boston code cleaning

1 files changed, 31 insertions, 16 deletions

diff --git a/boston.py b/boston.py
index 3ae8785..e8ff793 100644
--- a/boston.py
+++ b/boston.py
@@ -6,39 +6,47 @@ import tensorflow as tf
 import numpy.random
 import numpy as np
 
-# TODO: vorzeigbar machen, aufräumen
-
+# Siehe Kommentar in dem Programm der linearen Regression
 SEED = 42
 numpy.random.seed(SEED)
 tf.set_random_seed(SEED)
 
+# Datenreihe laden
 dataset = datasets.load_boston()
 data, target = dataset.data, dataset.target
 
+# Datenwerte für ein effektiveres Lernen zwischen 0 und 1 skalieren
 data_scaler = preprocessing.MinMaxScaler()
 data = data_scaler.fit_transform(data)
 target_scaler = preprocessing.MinMaxScaler()
 target = target_scaler.fit_transform(target)
 
-# use sklearn to fit the data values between 0 and 1
+# Datenwerte in Trainings- und Testreihe aufteilen
 x_train, x_test, y_train, y_test = train_test_split(
     data, target, train_size=0.85
 )
 
+# Die Netzkonfiguration
 BATCH = 50
-STEPS = 300  # epochs
-HIDDEN = 11  # hidden nodes in 1 layer
-IN = 13  # input nodes
-OUT = 1  # output node(s)
+STEPS = 300
+HIDDEN = 11
+IN = 13
+OUT = 1
 LEARNINGRATE = 0.01
 DECAYRATE = 0.96
 DECAYSTEPS = 50
 
+# Der Lernverlauf wird in einem individuellem Dateinamen gespeichert,
+# der je nach Konfiguration variiert.
 RUNNAME = 'B'+str(BATCH)+'S'+str(STEPS)+'H'+str(HIDDEN)+'LR'+str(LEARNINGRATE)\
         + 'DR'+str(DECAYRATE)+'DS'+str(DECAYSTEPS)+'SD'+str(SEED)
 
+# Es wird ausschließlich auf der CPU gerechnet,
+# da die GPU zu lange zum Initialisieren braucht und mehr RAM.
 with tf.device('/cpu:0'):
     sess = tf.InteractiveSession()
+    # Ausführliche Kommentare und ein vereinfachter Ablauf
+    # finden sich in Abschnitt 2.2.2 der Facharbeit.
 
     with tf.name_scope('input_layer'):
         matInput = tf.placeholder(tf.float32, [None, IN], name='input')
@@ -67,7 +75,7 @@ with tf.device('/cpu:0'):
         matLayerinHidden = tf.matmul(matLayerout, matWeightsHidden,
                                      name='hidden_input')
         matLayeroutHidden = tf.sigmoid(matLayerinHidden, name='hidden_output')
-        # only vec because OUT=1
+        # nur vec, wenn OUT=1
         vecLayeroutHidden = tf.reshape(matLayeroutHidden, [-1])
 
     with tf.name_scope('cost'):
@@ -77,7 +85,6 @@ with tf.device('/cpu:0'):
 
     with tf.name_scope('train'):
         global_step = tf.Variable(0, trainable=False)
-        # Facharbeit: LR decay bringt bombastisch bessere results
         learning_rate = tf.train.exponential_decay(LEARNINGRATE,
                                                    global_step, DECAYSTEPS,
                                                    DECAYRATE, staircase=True)
@@ -87,11 +94,12 @@ with tf.device('/cpu:0'):
     summaries = tf.merge_all_summaries()
     writer = tf.train.SummaryWriter("/tmp/boston_logs/%s" % RUNNAME,
                                     sess.graph_def)
-    # all variables have to be specified here
+    # Alle Tensorflow-Variablen müssen bis hier spezifiziert sein!
     sess.run(tf.initialize_all_variables())
 
+    # Training
     for count in range(0, int(len(x_train) / BATCH)):
-        print("step " + str(count))
+        print("batch " + str(count))
         for i in range(0, STEPS):
             result = sess.run([summaries, train_step],
                               feed_dict={
@@ -100,29 +108,36 @@ with tf.device('/cpu:0'):
                               })
             writer.add_summary(result[0], count * STEPS + i)
 
-    print("finished training")
+    print("Training beendet")
 
-    print("Test results, difference to real data:")
+    print("Testergebnisse - Differenz zu echten Daten:")
     result = sess.run([vecLayeroutHidden],
                       feed_dict={
                           matInput: x_test,
                           vecTarget: y_test
                       })
     print("================================")
-    print("expected")
+    print("erwartete Daten:")
     print("--------------------------------")
+    # Ausgabedaten sind skaliert, zurückskalieren
     print(target_scaler.inverse_transform(y_test))
     print("--------------------------------")
-    print("predicted")
+    print("vorhergesagte Daten:")
     print(target_scaler.inverse_transform(result[0]))
     print("--------------------------------")
     print("")
-    print("difference")
+    print("Differenz:")
     print("--------------------------------")
+    # MSE aus der Differenz unskalierter Daten berechnen,
+    # nicht MSE aus Differenz skalierter Daten unskalieren:
+    # !!! (a - b) * f + o != (a * f + o) - (b * f + o)
+    # <=> af - bf + o     != af - bf
     diff = target_scaler.inverse_transform(
             result[0]) - target_scaler.inverse_transform(y_test)
     print(diff)
     print("--------------------------------")
     print("")
     print("MSE")
+    # Entsprechend (af - bf + o)^2 != (af - bf)^2…
+    # Erkenntnis, hinter der 10h Arbeit, Frustration und Enttäuschung steht.
     print(np.mean(diff ** 2))