Einführung

Beschrieben das Verfahren zum Erstellen einer maschinellen Lernumgebung mit Tellus GPU-Server (High-Heat-Computing).
Überprüfen Sie die folgenden drei Punkte, um den Vorgang zu überprüfen
GPU-Lernen des Deep-Learning-Modells mit PyTorch
Anzeigen von Versuchsaufzeichnungen mit MLFlow
Bestätigung der Daten auf dem Server mit QGIS

Überprüfungsumgebung

Item	Version
OS	Ubuntu 18.04
OpenSSH	7.6p1

GPU-Server beantragen (über Tellus)

Tellus

Tellus
Japans erste Plattform für Hygienedaten
Neben der Datenerfassung stellen wir auch eine kostenlose Entwicklungsumgebung zur Verfügung (JupyterLab oder GPU-Server).

Über den GPU-Server

Sakura High Thermal Power Computing Lineup
Ungefähr 1 Million Yen, wenn Sie versuchen, normal zu leihen
Es gibt eine Mietdauer, aber keine Nutzungsdauer innerhalb der Laufzeit
Wenn Sie ab dem letzten Zugriff einen Monat lang keinen Zugriff haben, gilt dies als Mietende
Für Google Colaboratory gilt eine 90-Minuten- / 12-Stunden-Regel

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

Anwendungsablauf

Beantragen Sie nach der Registrierung als Mitglied von Tellus (kostenlos) eine Entwicklungsumgebung.

Kostenlos

Der Zeitraum kann zwischen 1 Monat, 3 Monaten oder mehr gewählt werden (Beratung erforderlich)

Kann nach Ablauf der Nutzungsdauer erneuert werden

Nach einer Weile nach der Bewerbung werden Sie von der Operation mit Ihrer Login-ID kontaktiert.

Dies hängt von der Verfügbarkeit des Servers ab, dauert jedoch ca. 1 Monat.

Umgebungsbau (GPU)

Befolgen Sie grundsätzlich die Anweisungen unter Installationsverfahren für CUDA Toolkit / GPU-Kartentreiber.

Serverinformation

Tellus-Konto-Dashboard → Siehe Entwicklungsumgebung

Item	Entsprechender Artikel
Server IP	Umgebungshostname / IP
Anmelde-ID	Per E-Mail vom Management gesendet
Erstes Passwort	Token-Informationen / SSHPW-Informationen

Verbinden zum Server

Beschreiben Sie die Verbindungsinformationen zum Server in ~ / .ssh / config

`~/.ssh/config`


Host tellus
     HostName [Umgebungshostname / IP]
     User [Anmelde-ID]
     IdentityFile ~/.ssh/id_rsa

Geben Sie "ssh tellus" in das Terminal ein und Sie werden nach dem Passwort gefragt. Geben Sie das ursprüngliche Passwort ein, um die Verbindung herzustellen.

Paketaktualisierung und Installation

Vorbereitung vor der Installation des GPU-Treibers

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

CUDA Toolkit

CUDA Toolkit Archive
Die neueste Version von CUDA vom 09.09.2020 ist 11.0
PyTorch 1.6 (neueste Version) unterstützt bis zu 10.2, daher ist ein Downgrade erforderlich
Wenn Sie etwas anderes als runfile verwenden, wird 11.0 aus irgendeinem Grund installiert, auch wenn Sie die Version angeben. Verwenden Sie daher unbedingt runfile (lokal) **
Wenn Sie sudo entfernen, während Sie runfile ausführen, ist die Installation fehlgeschlagen. Fügen Sie es hinzu.

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

Melden Sie sich nach dem Erstellen der Einstellungsdatei für Umgebungsvariablen ab und wieder an

`/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
Der Treiber, der mit dem CUDA Toolkit installiert werden kann, ist alt. Installieren Sie ihn daher separat.
Fügen Sie zur Laufzeit sudo wie Toolkit hinzu

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
Registrierung der Mitgliedschaft erforderlich (kostenlos)
Auf der Clientseite herunterladen und mit scp auf den Server übertragen
Entpacken Sie den Inhalt nach der Übertragung und verschieben Sie ihn in das angegebene Verzeichnis

`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/

Installationsbestätigung

Überprüfen Sie mit nvidia-smi
Wenn die Installation erfolgreich war, sehen Sie die Anzeige wie im Bild unten.

Umgebungskonstruktion (Python)

Anaconda

Anaconda
Nach der Installation liegt es an Ihnen, eine Umgebung zu erstellen

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

Als ich die Umgebung erstellt habe, hat sie nicht so funktioniert, wie sie war. Deshalb habe ich .bashrc Folgendes hinzugefügt (py38 ist der Umgebungsname).

`.bashrc`


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

PyTorch

PyTorch get-started
Wenn Sie eine andere als conda verwenden, ändern Sie den Paketteil und überprüfen Sie den Befehl

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

MLFlow

MLFlow
Bibliothek zur Verwaltung von Experimenten mit maschinellem Lernen

conda install -c conda-forge mlflow

Wenn Sie "mlflow ui" eingeben, wird die Benutzeroberfläche unter "localhost: 5000" gestartet und Sie können die experimentellen Ergebnisse mit dem Browser überprüfen.
Fügen Sie die Einstellung LocalForward zu ~ / .ssh / config hinzu, damit sie im clientseitigen Browser angezeigt werden kann, wenn die Benutzeroberfläche auf der Serverseite gestartet wird.

`~/.ssh/config`


Host tellus
     HostName [Umgebungshostname / IP]
     User [Anmelde-ID]
     IdentityFile ~/.ssh/id_rsa
     LocalForward [Clientseitige Portnummer] localhost:5000

QGIS

QGIS
Viewer für Daten mit geografischen Informationen wie GeoTiff und Shapefile
Sie können auch normale Bilder ohne geografische Informationen durchsuchen
Die neueste Version (3.14.15) hat nicht funktioniert, daher habe ich 3.10.8 verwendet
Fehler, dass libprotobuf-lite.so.23 fehlt

conda install -c conda-forge qgis=3.10.8

Funktionsprüfung

GPU lernen

Führen Sie zwei Modi aus, CPU und GPU, und prüfen Sie, ob sich die Verarbeitungszeit unterscheidet
Überprüfen Sie GPU Memory und Volatile mit nvidia-smi, wenn Sie Code ausführen
Der Code hat den folgenden Teil geändert, der sich auf [PyTorchs CIFAR10-Tutorial] bezieht (https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py).
Modell ist ResNet-18
Die Stapelgröße beträgt 1024, die Anzahl der Worker beträgt 8 (= Anzahl der Serverkerne)
Die CPU-Ausführung wird durch Umschreiben in "device = torch.device (" cpu ")" ausgeführt

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

CPU-Ergebnis

GPU-Ergebnis

Bestätigt, dass es mit GPU etwa 36-mal schneller war
Vergewissern Sie sich, dass sich die Werte für Speicher und flüchtig bei Verwendung der GPU geändert haben

MLFlow

Überprüfen Sie, ob der Versuchsdatensatz auf dem Server mit dem Browser auf der Clientseite angezeigt werden kann
Der experimentelle Code speichert ein Diagramm der Sin-Wellenform mit doppelter Amplitude
Überprüfen Sie die lokale Forward-Port-Nummer bei 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

Ergebnisbild

QGIS

Überprüfen Sie, ob der serverseitige Code (test_code) mit Data Source Manager angezeigt werden kann

ssh -X tellus
qgis

Bestätigen Sie, dass Sie cifar10.py und record_sin.py haben

VS-Code verwenden

Da ssh verwendet werden kann, kann auch das [Remote Development] von VS Code (https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack) verwendet werden.
Wenn Sie eine Jupyter-Notebook-Datei mit VS-Code erstellen möchten, müssen Sie ipykernel installieren

conda install -c conda-forge ipykernel

abschließend

Ich habe die Deb-Datei in der CUDA Toolkit-Installation ausgewählt und Zeit verschwendet, daher habe ich das Verfahren zusammengefasst
Wenn Sie den QGIS-Teil durch einen anderen Viewer ersetzen, sollten Sie fast das gleiche Verfahren anwenden können.
Ich denke, es ist ein Verfahren, das zum Teil nicht nur mit High-Heat-Computing, sondern auch mit anderen GPU-Servern verwendet werden kann.

Referenzseite

Tellus FAQ Takenoko Blog-Erstellen einer PyTorch-Umgebung vom GPU-Server von Tellus

[PYTHON] Aufbau einer maschinellen Lernumgebung mit Tellus GPU-Server (Sakura High-Heat-Computing)

Einführung

Überprüfungsumgebung

GPU-Server beantragen (über Tellus)

Über den GPU-Server

Anwendungsablauf

Umgebungsbau (GPU)

Serverinformation

Verbinden zum Server

~/.ssh/config

Paketaktualisierung und Installation

/etc/profile.d/cuda.sh

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

client

server

Installationsbestätigung

Umgebungskonstruktion (Python)

.bashrc

~/.ssh/config

Funktionsprüfung

GPU lernen

cifar10.py

record_sin.py

~/test_code/

VS-Code verwenden

abschließend

Referenzseite

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