Typos

zalando-tutorial-on-ray.ipynb

@@ -146,8 +146,8 @@
     "def train_ray():\n",
     "    start = time.monotonic()\n",
     "\n",
-    "    print(f\"Hello from the Ray Cluster. The following training runs still on a CPU cluster.\")\n",
-    "    print(f\"Providing GPU ressources would speedup training cycles by a factor of 1000 or even more.\")\n",
+    "    print(f\"Hello from the Ray Cluster. The following training still runs on a CPU cluster.\")\n",
+    "    print(f\"Providing GPU resources would speedup training cycles by a factor of 1000 or even more.\")\n",
     "    \n",
     "    \n",
     "    # Import the Fashion MNIST dataset\n",
 %% 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
 ```