Création d'un environnement d'apprentissage automatique avec le serveur Tellus GPU (Sakura High-Power Computing)

introduction

• Décrit la procédure de création d'un environnement d'apprentissage automatique sur le serveur Tellus GPU (calcul à haute température).
• Vérifiez les trois éléments suivants pour vérifier le fonctionnement
• Apprentissage GPU du modèle d'apprentissage en profondeur à l'aide de PyTorch
• Affichage des enregistrements d'expérience à l'aide de MLFlow
• Confirmation des données sur le serveur à l'aide de QGIS

Environnement de vérification

Demander un serveur GPU (via Tellus)

Tellus

• Tellus
• Première plateforme de données sanitaires du Japon
• En plus d'acquérir des données, nous proposons également un environnement de développement gratuit (JupyterLab ou serveur GPU).

À propos du serveur GPU

• Gamme de calcul à haute puissance thermique Sakura
• Environ 1 million de yens si vous essayez d'emprunter normalement
• Il y a une période de location, mais il n'y a pas de limite de temps d'utilisation dans la période
• Si vous n'y accédez pas pendant un mois à compter du dernier accès, celui-ci sera considéré comme fin de location
• La règle des 90 minutes / 12 heures existe pour google colaboratory

Flux d'application

1. Après vous être enregistré en tant que membre de Tellus (gratuit), postulez pour un environnement de développement.

• Gratuit

2. La période peut être choisie entre 1 mois, 3 mois ou plus (consultation requise)

• Peut être renouvelé après la fin de la période d'utilisation

3. Après un certain temps après l'application, l'opération vous contactera avec votre identifiant de connexion.

• Cela dépend de la disponibilité du serveur, mais cela prend environ 1 mois.

Construction de l'environnement (GPU)

En gros, suivez la procédure de Procédure d'installation du pilote de la carte CUDA Toolkit / GPU

Informations sur le serveur

Tableau de bord du compte Tellus → Voir l'environnement de développement

Connecter au serveur

• Décrivez les informations de connexion au serveur dans ~ / .ssh / config

~/.ssh/config

Host tellus
     HostName [Nom d'hôte / IP de l'environnement]
     User [Identifiant de connexion]
     IdentityFile ~/.ssh/id_rsa

• Entrez ssh tellus sur le terminal et il vous sera demandé le mot de passe.Entrez le mot de passe initial pour terminer la connexion.

Mise à jour et installation du package

Préparation avant d'installer le pilote GPU

sudo apt update
sudo apt upgrade
apt install build-essential
apt install dkms

CUDA Toolkit

• CUDA Toolkit Archive
• La dernière version de CUDA au 09/09/2020 est la 11.0
• PyTorch 1.6 (dernière version) prend en charge jusqu'à 10.2, donc une rétrogradation est requise
• Si vous utilisez autre chose que runfile, 11.0 est installé pour une raison quelconque même si vous spécifiez la version, alors assurez-vous d'utiliser runfile (local) **
• Si vous supprimez sudo lors de l'exécution de runfile, l'installation a échoué, alors ajoutez-le.

wget http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run
sudo sh cuda_10.2.89_440.33.01_linux.run
chmod +x cuda_10.2.89_440.33.01_linux.run
sudo ./cuda_10.2.89_440.33.01_linux.run --toolkit --samples --samplespath=/usr/local/cuda-samples --no-opengl-libs

• Après avoir créé le fichier de configuration des variables d'environnement, déconnectez-vous et reconnectez-vous

/etc/profile.d/cuda.sh

export CUDA_HOME="/usr/local/cuda" 
export PATH="$CUDA_HOME/bin:$PATH" 
export LD_LIBRARY_PATH="/usr/local/lib:$CUDA_HOME/lib64:$LD_LIBRARY_PATH" 
export CPATH="/usr/local/include:$CUDA_HOME/include:$CPATH" 
export INCLUDE_PATH="$CUDA_HOME/include" 

shell:/etc/profile.d/cuda.csh

export CUDA_HOME="/usr/local/cuda" 
export PATH="$CUDA_HOME/bin:$PATH" 
export LD_LIBRARY_PATH="/usr/local/lib:$CUDA_HOME/lib64:$LD_LIBRARY_PATH" 
export CPATH="/usr/local/include:$CUDA_HOME/include:$CPATH" 
export INCLUDE_PATH="$CUDA_HOME/include" 

CUDA Driver

• CUDA Driver Download
• Le pilote qui peut être installé avec la boîte à outils CUDA est ancien, donc installez-le séparément.
• Ajouter sudo à l'exécution comme Toolkit

wget https://us.download.nvidia.com/tesla/440.95.01/NVIDIA-Linux-x86_64-440.95.01.run
chmod +x NVIDIA-Linux-x86_64-440.95.01.run
sudo ./NVIDIA-Linux-x86_64-440.95.01.run --no-opengl-files --no-libglx-indirect --dkms

cuDNN

• NVIDIA cuDNN
• Inscription d'adhésion requise (gratuite)
• Téléchargement côté client et transfert vers le serveur avec scp
• Après le transfert, décompressez et déplacez le contenu dans le répertoire spécifié

client

scp -r cudnn-10.2-linux-x64-v8.0.3.33.tgz tellus:~/

server

tar xvzf cudnn-10.2-linux-x64-v8.0.3.33.tgz
sudo mv cuda/include/cudnn.h /usr/local/cuda/include/
sudo mv cuda/lib64/* /usr/local/cuda/lib64/

Confirmation d'installation

• Vérifiez avec nvidia-smi
• Si l'installation réussit, vous pouvez voir l'écran comme l'image ci-dessous.

Construction d'environnement (Python)

Anaconda

• Anaconda
• Après l'installation, c'est à vous de créer un environnement

wget https://repo.anaconda.com/archive/Anaconda3-2020.07-Linux-x86_64.sh
sudo bash Anaconda3-2020.07-Linux-x86_64.sh
conda update -n base conda

• Quand j'ai créé l'environnement, cela ne fonctionnait pas tel quel, j'ai donc ajouté ce qui suit à .bashrc (py38 est le nom de l'environnement)

.bashrc

export PYTHONPATH="/home/[Identifiant de connexion]/anaconda3/envs/py38/lib/python3.8:/home/[Identifiant de connexion]/anaconda3/envs/py38/lib/python3.8/site-packages:$PYTHONPATH"

PyTorch

• PyTorch get-started
• Lors de l'utilisation autre que conda, modifiez la partie Package et vérifiez la commande

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

MLFlow

• MLFlow
• Bibliothèque de gestion des expériences d'apprentissage automatique

conda install -c conda-forge mlflow

• Si vous entrez mlflow ui, l'interface utilisateur sera lancée à localhost: 5000, et vous pouvez vérifier les résultats expérimentaux avec le navigateur.

• Ajoutez le paramètre LocalForward à ~ / .ssh / config afin qu'il puisse être affiché sur le navigateur côté client lorsque l'interface utilisateur est lancée côté serveur.

~/.ssh/config

Host tellus
     HostName [Nom d'hôte / IP de l'environnement]
     User [Identifiant de connexion]
     IdentityFile ~/.ssh/id_rsa
     LocalForward [Numéro de port côté client] localhost:5000

QGIS

• QGIS
• Visionneuse pour les données avec des informations géographiques telles que GeoTiff et Shapefile
• Vous pouvez également parcourir des images ordinaires sans informations géographiques
• La dernière version (3.14.15) ne fonctionnait pas, j'ai donc utilisé la 3.10.8
• Erreur indiquant que libprotobuf-lite.so.23 est manquant

conda install -c conda-forge qgis=3.10.8

Contrôle de fonctionnement

Apprentissage GPU

• Exécutez en deux modes, CPU et GPU, et vérifiez s'il y a une différence dans le temps de traitement
• Vérifiez la mémoire GPU et volatile avec nvidia-smi lors de l'exécution du code
• Le code a changé la partie suivante faisant référence au Tutoriel CIFAR10 de PyTorch
• Le modèle est ResNet-18
• La taille du lot est de 1024, le nombre de nœuds de calcul est de 8 (= nombre de cœurs du serveur)
• L'exécution du processeur est exécutée en réécrivant dans device = torch.device (" cpu ")

cifar10.py

import os

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10
from tqdm import tqdm


batch = 1024
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


def dataloader(is_train: bool, transform: transforms.Compose) -> DataLoader:
    dataset = CIFAR10(root='./data', train=is_train, download=True, transform=transform)
    return DataLoader(dataset, batch_size=batch, shuffle=is_train, num_workers=os.cpu_count())


def model() -> nn.Module:
    model = models.resnet18(pretrained=True)
    model.fc = nn.Linear(512, 10)
    return model.to(device)


def training(net: nn.Module, trainloader: DataLoader, epochs: int) -> None:
    # loss function & optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

    for epoch in range(epochs):  # loop over the dataset multiple times
        running_loss = 0.0
        bar = tqdm(trainloader, desc="training model [epoch:{:02d}]".format(epoch), total=len(trainloader))
        for data in bar:
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data[0].to(device), data[1].to(device)

            # zero the parameter gradients
            optimizer.zero_grad()

            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            bar.set_postfix(device=device, batch=batch, loss=(running_loss / len(trainloader)))

    print('Finished Training')


transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainloader = dataloader(True, transform)
net = model()
training(net, trainloader, 3)

Résultat CPU

Résultat GPU

• Confirmé qu'il était environ 36 fois plus rapide en utilisant le GPU
• Confirmez que les valeurs de Mémoire et Volatile ont changé lors de l'utilisation du GPU

MLFlow

• Vérifiez si l'enregistrement de l'expérience sur le serveur peut être visualisé avec le navigateur côté client
• Le code expérimental enregistre le graphique de la forme d'onde Sin avec une amplitude doublée
• Vérifiez le numéro de port de transfert local au 23000

record_sin.py

from math import pi, sin

import mlflow

mlflow.set_experiment('test')
amplitude = 2.0

with mlflow.start_run() as _:
    mlflow.log_param('amplitude', amplitude)
    for i in range(360):
        sin_val = amplitude * sin(i * pi / 180.)
        mlflow.log_metric('sin wave', sin_val, step=i)

~/test_code/

python record_sin.py
mlflow ui

Image de résultat

QGIS

• Vérifiez si le code côté serveur (test_code) peut être visualisé avec Data Source Manager

ssh -X tellus
qgis

• Confirmez que vous avez cifar10.py et record_sin.py

Utilisation du code VS

• Comme ssh peut être utilisé, le [Développement à distance] de VS Code (https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack) peut également être utilisé.
• Si vous souhaitez créer un fichier notebook jupyter avec VS Code, vous devez installer ipykernel

conda install -c conda-forge ipykernel

en conclusion

• J'ai choisi le fichier deb dans l'installation de CUDA Toolkit et j'ai perdu du temps, j'ai donc résumé la procédure
• Si vous remplacez la partie QGIS par une autre visionneuse, vous devriez pouvoir suivre presque la même procédure.
• Je pense que c'est une procédure qui peut être utilisée dans une certaine mesure non seulement pour le calcul à haute température, mais aussi pour d'autres serveurs GPU.

Page de référence

Tellus FAQ Blog Takenoko - Création d'un environnement PyTorch à partir du serveur GPU de Tellus