<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <h2>Arbeiten mit Tensorflow - Beispiel Umrechnung Celsius in Fahrenheit</h2>
In diesem Jupyter Notebook werden Sie ein weiteres Machine Learning model auf Basis von Tensorflow trainieren!
Es werden nochmals grundlegende Konzepte vorgestellt. Weitere Notebooks werden vertiefend in die Probleme einsteigen.
Das Problem das wir lösen wollen ist die Umrechnung von Celsius Werten in Fahrenheit Werte. Die Formel hierfür lautet
Step1:  Es ist also sehr einfach in Python diese Funktion zu programmieren.Das hat aber nichts mit Machine Learning zu tun, sondern das ist das klassische Programmier Paradigma
Step2:  <h2> Aufsetzen des Neuronalen Netzes als nn</h2>
Step3:  <h2>Vorhersage von Werten</h2>
Step4:  <h3 style="color
Step5:  In diesem Single Layer Neuronalen Netz lässt sich die Formel<br>
für die Umrechnung also exakt nachbilden und die Parameter werden gelernt.<br>
<br>
Wie sieht das aber aus, wenn wir eine andere Struktur des Neuronalen Netzes wählen ?<br>
<h2>Erweiterung des Neuronalen Netzes nn2</h2>
Step6:  <h2> Vorhersage von Werten</h2>
Step7:  <h3 style="color
Step8:  Wie sehen aber die Parameter in den Layern aus ?
Step9:  Alle Parameter eines Layers können über Ihre Methoden<br>
get_weights()<br>
set_weights()<br>
angesprochen werden.
Für einen Dense Layer gehören dazu sowohl die <br>
Gewichte wie auch die Bias Werte.<br>
<br>
Wir lesen die Werte der Layer in die Variablen input1, input2 und input3<br>
aus. Die Layer haben dabei die Indizes 0-2.
Step10:  <h2>Auslesen der Werte für Layer b</h2>
Step11:  <h2>Auslesen der Werte für Layer c</h2>
Step12:  <h2>Aufsetzen eines Neuronalen Netzes nn3 und Überprüfen
    der Parameter vor und nach dem Training</h2>
Step13:  Warum stehen da Werte ? Warum sind die Bias Werte 0 ?
<ASSISTANT_TASK:>
Python Code:
# Definition der Funktion umrechnung
def umrechnung(C):
    F = #Ihr Code hier#
    return #Ihr Code hier#
#
# Rufen Sie die definierte Funktion mit unterschiedlichen Werten (8,12.5,23,44.6)
# einmal auf. Sie sollten die Ergebnisse (46.4, 54.5, 73.4, 112.28) erhalten.
# Aufruf - Ersetzen Sie #Wert# durch Ihre Zahl - Berechnen Sie die Zelle
#
umrechnung(#Wert#)
Explanation: <h2>Arbeiten mit Tensorflow - Beispiel Umrechnung Celsius in Fahrenheit</h2>
In diesem Jupyter Notebook werden Sie ein weiteres Machine Learning model auf Basis von Tensorflow trainieren!
Es werden nochmals grundlegende Konzepte vorgestellt. Weitere Notebooks werden vertiefend in die Probleme einsteigen.
Das Problem das wir lösen wollen ist die Umrechnung von Celsius Werten in Fahrenheit Werte. Die Formel hierfür lautet:
$$ f = c \times 1.8 + 32 $$
Der formale Zusammenhang ist also bekannt und es ist deshalb einfach in irgendeiner Programmiersprache diesen Algorithmus zur Umrechnung zu programmieren.
Wir werden dies in einem ersten Schritt einmal versuchen!
Definieren Sie hierzu eine Funktion in Python, die uns diese Umrechnung erledigt !
Geben Sie hierzu in eine Zelle folgenden Code ein:<br>
def umrechnung(C):<br>
    F = 1.8*C+32<br>
    return F<br>
Achtung: Beachten Sie, dass bei der Definition einer Funktion nach dem :
die Teile der Funktion eine Einrückung haben müssen.
End of explanation
# Importieren Sie numpy as np
import numpy as np
# Importieren Sie tensorflow as tf
# Import des Modells Sequential
# from keras.models import Sequential
# Import des Dense Layers
# from keras.layers import Dense
# importieren Sie matplotlib.pyplot as plt
# Setzen Sie den magic Befehl: %matplotlib inline
# Übergabe der zu lernenden Werte und deren Umrechnungsergebnisse an numpy arrays
celsius_i    = np.array([-40, -10,  0,  8, 12.5, 15, 22,  38, 49.5],  dtype=float)
fahrenheit_o = np.array([-40,  14, 32, 46.4, 54.5, 59, 71.6, 100.4, 121.1],  dtype=float)
# Ausgabe der zu lernenden Werte
print("Die zu lernenden Werte sind:")
for i,c in enumerate(celsius_i):
  print("{} Grad Celsius = {} Grad Fahrenheit".format(c, fahrenheit_o[i]))
Explanation: Es ist also sehr einfach in Python diese Funktion zu programmieren.Das hat aber nichts mit Machine Learning zu tun, sondern das ist das klassische Programmier Paradigma:<br>
- es gibt eine Regel
- es gibt einen Input
- der Algorithmus erzeugt einen Output<br>
Dieses Prinzip wird häufig auch EVA genannt - Eingabe/Verarbeitung/Ausgabe<br>
Im Machine Learning ist die zugrundeliegende Regel nicht bekannt.
Wir kennen nur den Input und den Output und der ML Algorithmus soll die zugrundeliegenden Parameter lernen.<br>
Das heisst in diesem Problem sind die Parameter 1.8 und 32 erst einmal zu lernen.<br>
Wir wollen also ein ML Modell auf Basis von Tensorflow und Keras trainieren, diese Parameter zu lernen.<br>
<h2>Importieren der notwendigen Bibliotheken</h2>
End of explanation
# Initialisieren Sie ein Neuronales Netz nn mit Sequential()
# nn = Sequential()
# Fügen Sie einen Dense Layer mit einem Neuron hinzu, (units=1,input_dim=1)
#
# Wieviel Parameter hat dieser Layer ?
#
# nn.add(Dense(units=1, input_dim=1))
# Wir wollen den adam optimizer mit einer bestimmten Lernrate einsetzen
# mit der Angabe optimizer='adam' würden nur die default Werte genommen werden.
# Definition des optimzers mit Übergabe einer Lernrate 0.1
optimizer_adam=tf.keras.optimizers.Adam(0.1)
# Kompilieren Sie das Modell
nn.compile(optimizer=optimizer_adam, loss='mean_squared_error')
# Überprüfen der Konfiguration
# nn.summary()
# Wieviel Parameter sind trainierbar ?
# Trainieren Sie das Modell mit 1000 epochs
epoch_num = #Wert#
history = nn.fit(celsius_i,fahrenheit_o,epochs=epoch_num, verbose=1 )
print("Das Training ist beendet")
# Graphische Darstellung der Ergebnisentwicklung
plt.xlabel('Epoch Number')
plt.ylabel("Loss Magnitude")
plt.plot(history.history['loss'])
Explanation: <h2> Aufsetzen des Neuronalen Netzes als nn</h2>
End of explanation
# Vorhersage für den Wert 100.0
ergebnis = nn.predict([#Wert#])
print(ergebnis)
# Vorhersage für den Wert 85.5
ergebnis = nn.predict([#Wert#])
print(ergebnis)
Explanation: <h2>Vorhersage von Werten</h2>
End of explanation
# Ausgabe der Layer Parameter die gelernt wurden
print("Dies sind die Layer Variablen: {}".format(nn.get_weights()))
# erwartetes Ergebnis [1.8, 32]
Explanation: <h3 style="color:orange; font-weight:bold;">Dies ist doch ein erstaunliches Ergebnis, oder ?</h3>
Wir wollen deshalb einmal überprüfen welche Werte in diesem einen<br>
Layer gelernt wurden.
<h2>Auslesen der gelernten Parameter</h2>
End of explanation
# Initialisieren des Neuronalen Netzes nn2
# nn2=Sequential()
#
# Hinufügen der Layer (Vergabe von Namen)
#
# nn2.add(Dense(units=4, input_dim=1, name='a'))
# nn2.add(Dense(units=4, name='b'))
# nn2.add(Dense(units=1, name='c'))
# Überlegung:
# Wieviel Parameter hat Layer a ?
# Wieviel Parameter hat Layer b ?
# Wieviel Parameter hat Layer c ?
# Wieviel Parameter hat das Modell insgesamt ?
#
# Definieren des optimizers mit einer Lernrate 0.1
optimizer_a=tf.keras.optimizers.Adam(0.1)
# Kompilieren Sie das Modell
nn2.compile(optimizer=optimizer_a, loss='mean_squared_error')
#
# Überprüfen der Konfiguration
# Wieviel Parameter hat Layer a ?
# Wieviel Parameter hat Layer b ?
# Wieviel Parameter hat Layer c ?
#
# nn2.summary()
# Trainieren Sie das Modell nn2 mit 1000 epochs
epoch_num = #Wert#
history = nn2.fit(celsius_i,fahrenheit_o,epochs=epoch_num, verbose=1 )
print("Das Training ist beendet")
Explanation: In diesem Single Layer Neuronalen Netz lässt sich die Formel<br>
für die Umrechnung also exakt nachbilden und die Parameter werden gelernt.<br>
<br>
Wie sieht das aber aus, wenn wir eine andere Struktur des Neuronalen Netzes wählen ?<br>
<h2>Erweiterung des Neuronalen Netzes nn2</h2>
End of explanation
# Vorhersage für den Wert 100.0
ergebnis = nn2.predict([#Wert#])
print(ergebnis)
# Vorhersage für den Wert 85.5
ergebnis = nn2.predict([#Wert#])
print(ergebnis)
Explanation: <h2> Vorhersage von Werten</h2>
End of explanation
print("Model nn2 ermittelt, dass 100 Grad Celsius: {} Grad Fahrenheit sind.".format(nn2.predict([100.0])))
Explanation: <h3 style="color:orange;">Dieses Modell liefert also nahezu identische Vorhersagewerte</h3>
End of explanation
# Ausgabe der Layer
# nn2.layers
nn2.layers
Explanation: Wie sehen aber die Parameter in den Layern aus ?
End of explanation
# Auslesen der Layer 1-3 in Variablen - Index 0-2
input1 = nn2.layers[0]
input2 = nn2.layers[1]
input3 = nn2.layers[2]
# Einlesen der Gewichte und Bias Werte aus Layer a h hat den Index 0
weights, biases = input1.get_weights()
# Ausgabe der Gewichte in Layer a
weights
# Aus gabe der Bias Werte in Layer a
biases
Explanation: Alle Parameter eines Layers können über Ihre Methoden<br>
get_weights()<br>
set_weights()<br>
angesprochen werden.
Für einen Dense Layer gehören dazu sowohl die <br>
Gewichte wie auch die Bias Werte.<br>
<br>
Wir lesen die Werte der Layer in die Variablen input1, input2 und input3<br>
aus. Die Layer haben dabei die Indizes 0-2.
End of explanation
# Einlesen der Gewichte und Bias Werte aus Layer b - hat den Index 1 
# und wurde in die Variable input2 ausgelesen
weights1, biases1 = input2.get_weights()
# Ausgabe der Gewichte in Layer b
weights1
# Aus gabe der Bias Werte in Layer b
biases1
Explanation: <h2>Auslesen der Werte für Layer b</h2>
End of explanation
# Einlesen der Gewichte und Bias Werte aus Layer c - hat den Index 2 und
# wurde in die Variable input3 ausgelesen
weights2, biases2 = input3.get_weights()
# Ausgabe der Gewichte in Layer c
weights2
# Aus gabe der Bias Werte in Layer b
biases2
print("Das sind die Parameter in Layer a: {}".format(input1.get_weights()))
print("Das sind die Parameter in Layer b: {}".format(input2.get_weights()))
print("Das sind die Parameter in Layer c: {}".format(input3.get_weights()))
#
# Versuchen Sie einmal in unserer Aufgabe 10 die
# Werte des Layers im Modell nn zu ermitteln !
#
Explanation: <h2>Auslesen der Werte für Layer c</h2>
End of explanation
# Initialisierung des Modells nn3 als Sequential
# nn3 = Sequential()
# Hinzufügen der Layer
#nn3.add(Dense(units=16, input_dim=1))
#nn3.add(Dense(units=8))
#nn3.add(Dense(units=1))
#
# Überprüfen Sie gedanklich einmal die Parameter
#
# Überprüfen der Konfiguration
# nn3.summary()
# Definieren des optimizers mit einer Lernrate 0.1
optimizer_a=tf.keras.optimizers.Adam(0.1)
# Kompilieren Sie das Modell
nn3.compile(optimizer=optimizer_a, loss='mean_squared_error')
# Auslesen der Layer
nn3.layers
# Auslesen der Layer 1-3 in Variablen - Index 0-2
inp1 = nn3.layers[0]
inp2 = nn3.layers[1]
inp3 = nn3.layers[2]
print("Das sind die Parameter in Layer 0: {}".format(inp1.get_weights()))
Explanation: <h2>Aufsetzen eines Neuronalen Netzes nn3 und Überprüfen
    der Parameter vor und nach dem Training</h2>
End of explanation
print("Das sind die Parameter in Layer 1: {}".format(inp2.get_weights()))
print("Das sind die Parameter in Layer 2: {}".format(inp3.get_weights()))
# Trainieren Sie das Modell nn2 mit 800 epochs
epoch_num = #Wert#
history = nn3.fit(celsius_i,fahrenheit_o,epochs=epoch_num, verbose=1 )
print("Das Training ist beendet")
# Graphische Darstellung der Ergebnisentwicklung
plt.xlabel('Epoch Number')
plt.ylabel("Loss Magnitude")
plt.plot(history.history['loss'])
# Vorhersage für den Wert 100.0
ergebnis = nn3.predict([#Wert#])
print(ergebnis)
#
# Versuchen Sie einmal die Parameter der Layer des Modells nn3 jetzt nach dem Training
# auszugeben !
#
i1 = nn3.layers[0]
i2 = nn3.layers[1]
i3 = nn3.layers[2]
print("Das sind die Parameter in Layer 2 nach dem Training: {}".format(i3.get_weights()))
#
# Wie hat sich der Bias Wert nach dem Training verändert ?
#
Explanation: Warum stehen da Werte ? Warum sind die Bias Werte 0 ?
End of explanation
<END_TASK>