Commit ea126b36 authored by Nane Kratzke's avatar Nane Kratzke
Browse files

Typos

parent 62205313
%% Cell type:markdown id:d17c90fc-3a06-4914-af53-a229fb539ce3 tags:
# Ray Tutorial
Dieses Tutorial zeigt, wie die beabsichtigte Jupyter Hub Umgebung der THL genutzt werden kann, um Machine Learning Modelle nicht nur auf einer JupyterLab Instanz, sondern in einem für Machine Learning optimierten Ray-Cluster auszuführen.
%% Cell type:markdown id:f30664cd-7625-4971-b558-79018fa705cf tags:
## Training eines neuronalen Netzes auf einer Virtuellen Maschine
Die JupyterLab Instanzen sind bewusst knapp dimensioniert und haben keine GPU-Karten. Das Trainieren von Neuronalen Netzen direkt auf den JupyterLab Instanzen ist also recht ineffektiv, da dies auf einer All Purpose CPU erfolgt. Für kleinere Tests ist dies ausreichend, mit komplexeren Machine Learning Modellen stößt man damit aber schnell an Grenzen der Praktikabilität.
Das folgende Beispiel trainiert wieder den MNIST-Datensatz zur Erkennung von Kleidungsstücken, das Sie bereits aus dem Zalando-Tutorial kennen.
Diese Training erfolgt auf derselben Maschine, auf der auch diese Web-Oberfläche läuft und würde genauso auf ihrem Arbeitsplatz-PC oder Laptop funktionieren.
%% Cell type:code id:247b0023-9c47-46ec-ad01-e6c7d6d69f61 tags:
``` python
import time
print("Training eines Neuronalen Netzes ohne Cluster")
print("Dies kann einige Zeit in Anspruch nehmen.")
# Preliminary checks to import Tensorflow
import os, sys
if 'tensorflow' not in os.environ.get('JUPYTER_IMAGE').lower():
print("Error: You need a tensorflow image to run this notebook!", file=sys.stderr)
else:
# TensorFlow and tf.keras
import tensorflow as tf
# Helper libraries
import numpy as np
import matplotlib.pyplot as plt
print(f"Great, your Tensorflow Version is {tf.__version__}")
def train_local():
start = time.monotonic()
# Import the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# Preprocess the data
train_images = train_images / 255.0
test_images = test_images / 255.0
# Build the model
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10)
])
# Compile the model
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
# Train the model
model.fit(train_images, train_labels, epochs=10)
# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)
# Save the model
model.save('/tmp/zalando')
print('\nModel saved')
return time.monotonic() - start
local = train_local()
print(f"Berechnungsdauer ohne Ray Cluster: {local} sec")
```
%% Cell type:markdown id:8ab6fd7a-87bc-4f7d-8e41-0b357669bcd7 tags:
## Training in einem GPU-Cluster
Für die THL soll jedoch ein GPU-Cluster aufgebaut und Nutzergruppen für
- Lehre
- Forschung und
- Transfer
komfortabel zur Verfügung gestellt werden, um auch komplexere Fragenstellungen des Machine Learnings (z.B. das Trainieren neuronaler Netze) berechnen zu können. Dieses Beispiel hier zeigt das grundsätzliche Prinzip noch in Form eines noch CPU-basierten Demonstrators.
Perspektivisch sollen jedoch für Machine Learning optimierte GPU-Karten in einem Ray-Cluster zur Verfügung gestellt werden, die u.a. das Trainieren von Neuronalen Netzen erheblich beschleunigen und allen Nutzern als Shared Ressource zur Verfügung gestellt werden können. Der Ray-Cluster sorgt dafür, dass diese teuren GPU-Karten tatsächlich nur für die Trainingsdauer allokiert werden und direkt danach sofort wieder anderen Nutzern zur Verfügung gestellt werden.
Um das Training von Tensorflow oder PyTorch Modellen an diesen Cluster auszulagern, wird es nur erforderlich sein, das Training in einer Funktion zu kapseln und diese Funktion auf dem Cluster auszuführen. Dieses Tutorial zeigt am Beispiel des Zalando Tutorials wie dies grundsätzlich geht.
Auf diese Weise soll mit dem Ray Cluster das Training von Neuronalen Netzen substantiell für alle Nutzer beschleunigt werden (d.h. Trainingszeiten von Stunden oder Tagen auf Minuten oder Sekunden reduziert werden).
> __Hinweis:__
>
> Aktuell sind noch keine GPU-Karten im Ray Cluster hinterlegt.
> Diese werden aktuell durch die FB E+I und M+W beschafft.
> Ziel der beantragten Stelle ist es, solche Hochwert-Machine Learning Ressourcen
> allen Hochschulmitgliedern komfortabel zur Verfügung stellen zu können.
>
> __Die aktuelle Installation ist ein reiner Demonstrations-Prototyp.__
>
> Alle Warn-Meldungen der Tensorflow-Bibliothek sind aktuell noch auf das Fehlen
> von optimierten GPU-Karten zurückzuführen.
%% Cell type:code id:86c30926-02aa-4b84-a3a4-677341f112a6 tags:
``` python
print("Training eines Neuronalen Netzes im Ray Cluster mittels ray.remote() Annotation")
print("Auch dies wird noch eine ähnlich lange Zeit (aufgrund fehlender GPU-Ressourcen) in Anspruch nehmen.")
print("Die Stelle des wiss. MA soll u.a. die GPU-Ressourcen in diesen Cluster integrieren.")
# Import the necessary libraries
import ray, time
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
@ray.remote
def train_ray():
start = time.monotonic()
print(f"Hello from the Ray Cluster. The following training runs still on a CPU cluster.")
print(f"Providing GPU ressources would speedup training cycles by a factor of 1000 or even more.")
print(f"Hello from the Ray Cluster. The following training still runs on a CPU cluster.")
print(f"Providing GPU resources would speedup training cycles by a factor of 1000 or even more.")
# Import the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# Preprocess the data
train_images = train_images / 255.0
test_images = test_images / 255.0
# Build the model
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10)
])
# Compile the model
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
# Train the model
model.fit(train_images, train_labels, epochs=10)
# Evaluate
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('\nTest accuracy:', test_acc)
# Save the model
model.save('/tmp/zalando')
print('\nModel saved')
return time.monotonic() - start
ray.shutdown()
ray.client().connect()
print(f"Der Ray-Cluster stellt aktuell folgende Ressourcen bereit: { ray.available_resources() }")
refs = train_ray.remote()
cluster = ray.get(refs)
print(f"Berechnungsdauer im Ray Cluster: {cluster} sec")
ray.shutdown()
print(f"Obwohl es sich nur um einen CPU-Cluster zu Demonstrationszwecken handelt, konnte die Berechnungszeit immerhin auf {cluster / local * 100:.2f}% gesenkt werden.")
```
%% Cell type:code id:6755dcfb-d7b7-4b76-91bc-c7599919b0fe tags:
``` python
```
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment