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

introduction

Environnement de vérification

Item Version
OS Ubuntu 18.04
OpenSSH 7.6p1

Demander un serveur GPU (via Tellus)

Tellus

À propos du serveur GPU

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

  1. Après vous être enregistré en tant que membre de Tellus (gratuit), postulez pour un environnement de développement.
  1. La période peut être choisie entre 1 mois, 3 mois ou plus (consultation requise)
  1. Après un certain temps après l'application, l'opération vous contactera avec votre identifiant de connexion.

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

tellus_dashboard.png

Connecter au serveur

~/.ssh/config


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

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

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

/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

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

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

nvidia-smi.png

Construction d'environnement (Python)

Anaconda

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

.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

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

MLFlow

conda install -c conda-forge mlflow

~/.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

conda install -c conda-forge qgis=3.10.8

Contrôle de fonctionnement

Apprentissage GPU

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 cpu_batch_1024.png cpu_batch_1024_smi.png

Résultat GPU gpu_batch_1024.png gpu_batch_1024_smi.png

MLFlow

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 mlflow_localforward.png mlflow_test.png mlflow_sinwave.png

QGIS

ssh -X tellus
qgis

Utilisation du code VS

conda install -c conda-forge ipykernel

en conclusion

Page de référence

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

Recommended Posts

Création d'un environnement d'apprentissage automatique avec le serveur Tellus GPU (Sakura High-Power Computing)
Construire un environnement Python sur le serveur Sakura VPS
Créer un environnement d'apprentissage automatique Python avec des conteneurs
Créer un environnement de développement d'applications d'apprentissage automatique avec Python
Mémo de construction d'environnement d'apprentissage automatique par Python
Créez un environnement d'apprentissage automatique à partir de zéro avec Winsows 10
(Maintenant) Construisez un environnement GPU Deep Learning avec GeForce GTX 960
Créer un environnement Kubernetes avec Ansible 2
Que diriez-vous d'Anaconda pour créer un environnement d'apprentissage automatique avec Python?
Une histoire sur l'apprentissage automatique avec Kyasuket
Création d'un environnement Python 3.6 avec Windows + PowerShell
Créer un environnement de développement pour l'apprentissage automatique
Construction d'environnement AI / Machine Learning avec Python
Construire un environnement python avec virtualenv et direnv
Comment préparer l'environnement pour Google Colab avec le cours avancé d'apprentissage automatique de Coursera
Comment créer rapidement un environnement d'apprentissage automatique à l'aide de Jupyter Notebook avec UbuntuServer 16.04 LTS
Jusqu'à ce que vous créiez un environnement d'apprentissage automatique avec Python sur Windows 7 et que vous l'exécutiez
Recommandation de construction d'un environnement Python portable avec conda
Exécutez un pipeline de machine learning avec Cloud Dataflow (Python)
Créer un environnement Python d'apprentissage automatique sur Mac OS
Création d'un environnement TensorFlow qui utilise des GPU sous Windows 10
Remarque conda: Création d'un environnement Python avec Spacon ITO
Windows10 (x64) Créer nativement un environnement d'apprentissage automatique
Comment créer rapidement un environnement d'apprentissage automatique à l'aide de Jupyter Notebook avec UbuntuServer 16.04 LTS avec Anaconda
Reconstruction de l'environnement pour l'apprentissage automatique avec Miniconda (version Windows)
Créer un environnement d'étude d'apprentissage automatique Python avec macOS Sierra
Créer un environnement d'apprentissage automatique sur Mac (pyenv, deeplearning, opencv)
Créez une application d'apprentissage automatique avec ABEJA Platform + LINE Bot
Résumé de la construction de Python 3.4. * De la source à la création d'un environnement informatique scientifique
Lancement d'un environnement d'apprentissage automatique à l'aide de Google Compute Engine (GCE)
Paramètres d'environnement d'apprentissage automatique basés sur Python3 sur Mac (coexistence avec Python2)
Créer un environnement PyData pour une session d'étude sur l'apprentissage automatique (janvier 2017)
Créer un environnement d'auto-apprentissage qui semi-automatise l'apprentissage automatique (Mac et Docker)
Étapes rapides pour créer un environnement d'apprentissage automatique à l'aide de Jupyter Notebook sur macOS Sierra avec anaconda
L'apprentissage automatique appris avec Pokemon
Apprentissage automatique avec Python! Préparation
Construire un environnement virtuel Python
Démineur d'apprentissage automatique avec PyTorch
Essayez le machine learning à la légère avec Kaggle
Une histoire coincée avec l'installation de la bibliothèque de machine learning JAX
Création d'un environnement de développement avec Maven sur Google App Engine [Java]
Créez un environnement d'apprentissage automatique arbitraire avec GCP + Docker + Jupyter Lab
Création d'un environnement pour exécuter ChainerMN sur une instance de GPU AWS
Comment créer une API de machine learning sans serveur avec AWS Lambda