voll funktionsfähig \o/

1 files changed, 63 insertions, 31 deletions

diff --git a/boston.py b/boston.py
index 501ba78..d6cf0d9 100644
--- a/boston.py
+++ b/boston.py
@@ -3,12 +3,11 @@ from sklearn import datasets
 from sklearn import preprocessing
 from sklearn.cross_validation import train_test_split
 import tensorflow as tf
-import random
-import numpy.random  # TODO get rid of these
+import numpy.random
 
-SEED = 42
-random.seed(SEED)
+SEED = 1337
 numpy.random.seed(SEED)
+tf.set_random_seed(SEED)
 
 dataset = datasets.load_boston()
 data, target = dataset.data, dataset.target
@@ -20,19 +19,22 @@ target = target_scaler.fit_transform(target)
 
 # use sklearn to fit the data values between 0 and 1
 x_train, x_test, y_train, y_test = train_test_split(
-    data, target, train_size=0.9
+    data, target, train_size=0.85
 )
 
-# TODO weights typc
+BATCH = 50
+STEPS = 100  # epochs
+HIDDEN = 9  # hidden nodes in 1 layer
+IN = 13  # input nodes
+OUT = 1  # output node(s)
+LEARNINGRATE = 0.1
+DECAYRATE = 0.95
+DECAYSTEPS = 10
 
-BATCH = 10  # 10 data sets
-STEPS = 100  # 100 epochs
-HIDDEN = 9  # 9 hidden nodes in 1 layer
-IN = 13  # 13 input nodes
-OUT = 1  # 1 output node
+RUNNAME = 'B'+str(BATCH)+'S'+str(STEPS)+'H'+str(HIDDEN)+'LR'+str(LEARNINGRATE)\
+        + 'DR'+str(DECAYRATE)+'DS'+str(DECAYSTEPS)
 
 with tf.device('/cpu:0'):
-    tf.set_random_seed(SEED)
     sess = tf.InteractiveSession()
 
     with tf.name_scope('input_layer'):
@@ -48,40 +50,51 @@ with tf.device('/cpu:0'):
     with tf.name_scope('hidden_layer'):
         matWeights = tf.Variable(tf.random_uniform([IN, HIDDEN], -1.0, 1.0),
                                  name='weights')
-        summaryWeights = tf.histogram_summary('weigths', matWeights)
+        summaryWeights = tf.histogram_summary('weights', matWeights)
         matLayerin = tf.matmul(matBiasedInput, matWeights, name='layer_input')
         matLayerout = tf.sigmoid(matLayerin, name='layer_output')
 
     with tf.name_scope('output_layer'):
         vecTarget = vecTarget
-        matWeigthsHidden = tf.Variable(
+        matWeightsHidden = tf.Variable(
                 tf.random_uniform([HIDDEN, OUT], -1.0, 1.0),
-                name='hidden-weigths')
-        summaryWeightsHidden = tf.histogram_summary('hiddenweigths',
-                                                    matWeigthsHidden)
-        # only vec because OUT=1
-        vecLayerinHidden = tf.matmul(matLayerout, matWeigthsHidden,
+                name='hidden-weights')
+        summaryWeightsHidden = tf.histogram_summary('hiddenweights',
+                                                    matWeightsHidden)
+        matLayerinHidden = tf.matmul(matLayerout, matWeightsHidden,
                                      name='hidden_input')
-        vecLayeroutHidden = tf.sigmoid(vecLayerinHidden, name='hidden_output')
+        matLayeroutHidden = tf.sigmoid(matLayerinHidden, name='hidden_output')
         # TODO in Facharbeit Matrixprodukt erwähnen
+        # only vec because OUT=1
+        vecLayeroutHidden = tf.reshape(matLayeroutHidden, [-1])
 
-    with tf.name_scope('mse'):
+    with tf.name_scope('cost'):
         vecDifference = tf.sub(vecTarget, vecLayeroutHidden, name='diff')
-        vecMSE = tf.square(vecDifference, name='mse')
-        scalarMeanMSE = tf.reduce_mean(vecMSE, name='meanmse')
-        summaryMeanMSE = tf.scalar_summary('MSE', scalarMeanMSE)
+        vecLogdifference = tf.sub(tf.log(tf.add(vecTarget, 1)),
+                                  tf.log(tf.add(vecLayeroutHidden, 1)))
+        scalarLogdiffsum = tf.reduce_sum(tf.abs(vecLogdifference))
+        scalarDiffsum = tf.reduce_sum(tf.abs(vecDifference))
+        scalarMSE = tf.reduce_sum(tf.square(vecDifference))
+        scalarError = scalarDiffsum  # scalarLogdiffsum
+        summaryError = tf.scalar_summary('error', scalarError)
 
     with tf.name_scope('train'):
-        train_step = tf.train.GradientDescentOptimizer(0.1).minimize(
-                scalarMeanMSE)
+        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)
+        train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(
+                scalarError, global_step=global_step)
 
     summaries = tf.merge_all_summaries()
-    writer = tf.train.SummaryWriter("/tmp/boston_logs", sess.graph_def)
+    writer = tf.train.SummaryWriter("/tmp/boston_logs/%s" % RUNNAME,
+                                    sess.graph_def)
     # all variables have to be specified here
     sess.run(tf.initialize_all_variables())
 
     for count in range(0, int(len(x_train) / BATCH)):
-        print("count " + str(count))
+        print("step " + str(count))
         for i in range(0, STEPS):
             result = sess.run([summaries, train_step],
                               feed_dict={
@@ -92,10 +105,29 @@ with tf.device('/cpu:0'):
 
     print("finished training")
 
-    print("Test results:")
-    result = sess.run([vecDifference],
+    print("Test results, difference to real data:")
+    result = sess.run([vecDifference, vecLayeroutHidden,
+                       scalarLogdiffsum, scalarMSE],
                       feed_dict={
                           matInput: x_test,
                           vecTarget: y_test
                       })
-    print(result[0])
+    print("================================")
+    print("expected")
+    print("--------------------------------")
+    print(target_scaler.inverse_transform(y_test))
+    print("--------------------------------")
+    print("predicted")
+    print(target_scaler.inverse_transform(result[1]))
+    print("--------------------------------")
+    print("")
+    print("difference")
+    print("--------------------------------")
+    print(target_scaler.inverse_transform(result[0]))
+    print("--------------------------------")
+    print("")
+    print("total logarithmic difference")
+    print(str(result[2]) + " (" + str(
+        target_scaler.inverse_transform([result[2]])) + str(")"))
+    print("MSE")
+    print(result[3])