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

Item	Version
OS	Ubuntu 18.04
OpenSSH	7.6p1

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

Item	Spec
OS	Ubuntu 18.04(64bit)
GPU	NVIDIA Tesla V100 (32GB) ×1
CPU	Xeon 4Core 3.7GHz 1CPU
Disk	MLC SSD 480GB ×2
Memory	64GB

Flux d'application

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

Gratuit

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

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

Item	Article correspondant
IP du serveur	Nom d'hôte / IP de l'environnement
Identifiant de connexion	Envoyé par email de la direction
Mot de passe initial	Informations sur les jetons / informations SSHPW

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

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

introduction

Environnement de vérification

Demander un serveur GPU (via Tellus)

À propos du serveur GPU

Flux d'application

Construction de l'environnement (GPU)

Informations sur le serveur

Connecter au serveur

~/.ssh/config

Mise à jour et installation du package

/etc/profile.d/cuda.sh

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

client

server

Confirmation d'installation

Construction d'environnement (Python)

.bashrc

~/.ssh/config

Contrôle de fonctionnement

Apprentissage GPU

cifar10.py

record_sin.py

~/test_code/

Utilisation du code VS

en conclusion

Page de référence

`~/.ssh/config`

`/etc/profile.d/cuda.sh`

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

`client`

`server`

`.bashrc`

`~/.ssh/config`

`cifar10.py`

`record_sin.py`

`~/test_code/`