diff options
Diffstat (limited to 'neuralnet.py')
| -rw-r--r-- | neuralnet.py | 142 |
1 files changed, 142 insertions, 0 deletions
diff --git a/neuralnet.py b/neuralnet.py new file mode 100644 index 0000000..079e587 --- /dev/null +++ b/neuralnet.py @@ -0,0 +1,142 @@ +#!/usr/bin/python3 +from sklearn import datasets +from sklearn import preprocessing +from sklearn.cross_validation import train_test_split +import tensorflow as tf +import numpy.random +import numpy as np + +# 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) + +# 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 +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') + vecTarget = tf.placeholder(tf.float32, [None], name='target') + scalarNumelements = tf.shape(vecTarget, name='batch_length') + vecBias = tf.Variable(tf.random_uniform([IN], -1.0, 1.0), name='bias') + summaryBias = tf.histogram_summary("bias", vecBias) + vecsBias = tf.tile(vecBias, scalarNumelements) + vecsBias = tf.reshape(vecsBias, [-1, IN]) + matBiasedInput = tf.add(matInput, vecsBias, name='biased_input') + + with tf.name_scope('hidden_layer'): + matWeights = tf.Variable(tf.random_uniform([IN, HIDDEN], -1.0, 1.0), + name='weights') + 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 + matWeightsHidden = tf.Variable( + tf.random_uniform([HIDDEN, OUT], -1.0, 1.0), + name='hidden-weights') + summaryWeightsHidden = tf.histogram_summary('hiddenweights', + matWeightsHidden) + matLayerinHidden = tf.matmul(matLayerout, matWeightsHidden, + name='hidden_input') + matLayeroutHidden = tf.sigmoid(matLayerinHidden, name='hidden_output') + # nur vec, wenn OUT=1 + vecLayeroutHidden = tf.reshape(matLayeroutHidden, [-1]) + + with tf.name_scope('cost'): + vecDifference = tf.sub(vecTarget, vecLayeroutHidden, name='diff') + scalarError = tf.reduce_sum(tf.abs(vecDifference), name='error') + summaryError = tf.scalar_summary('error', scalarError) + + with tf.name_scope('train'): + global_step = tf.Variable(0, trainable=False) + 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/%s" % RUNNAME, + sess.graph_def) + # 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("batch " + str(count)) + for i in range(0, STEPS): + result = sess.run([summaries, train_step], + feed_dict={ + matInput: x_train[count*BATCH:(count+1)*BATCH], + vecTarget: y_train[count*BATCH:(count+1)*BATCH] + }) + writer.add_summary(result[0], count * STEPS + i) + + print("Training beendet") + + print("Testergebnisse - Differenz zu echten Daten:") + result = sess.run([vecLayeroutHidden], + feed_dict={ + matInput: x_test, + vecTarget: y_test + }) + print("================================") + print("erwartete Daten:") + print("--------------------------------") + # Ausgabedaten sind skaliert, zurückskalieren + print(target_scaler.inverse_transform(y_test)) + print("--------------------------------") + print("vorhergesagte Daten:") + print(target_scaler.inverse_transform(result[0])) + print("--------------------------------") + print("") + 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… + print(np.mean(diff ** 2)) |