1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
#!/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
# TODO: vorzeigbar machen, aufräumen
SEED = 42
numpy.random.seed(SEED)
tf.set_random_seed(SEED)
dataset = datasets.load_boston()
data, target = dataset.data, dataset.target
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
x_train, x_test, y_train, y_test = train_test_split(
data, target, train_size=0.85
)
BATCH = 50
STEPS = 300 # epochs
HIDDEN = 11 # hidden nodes in 1 layer
IN = 13 # input nodes
OUT = 1 # output node(s)
LEARNINGRATE = 0.01
DECAYRATE = 0.96
DECAYSTEPS = 50
RUNNAME = 'B'+str(BATCH)+'S'+str(STEPS)+'H'+str(HIDDEN)+'LR'+str(LEARNINGRATE)\
+ 'DR'+str(DECAYRATE)+'DS'+str(DECAYSTEPS)+'SD'+str(SEED)
with tf.device('/cpu:0'):
sess = tf.InteractiveSession()
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')
# only vec because 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)
# 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/%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("step " + 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("finished training")
print("Test results, difference to real data:")
result = sess.run([vecLayeroutHidden],
feed_dict={
matInput: x_test,
vecTarget: y_test
})
print("================================")
print("expected")
print("--------------------------------")
print(target_scaler.inverse_transform(y_test))
print("--------------------------------")
print("predicted")
print(target_scaler.inverse_transform(result[0]))
print("--------------------------------")
print("")
print("difference")
print("--------------------------------")
diff = target_scaler.inverse_transform(
result[0]) - target_scaler.inverse_transform(y_test)
print(diff)
print("--------------------------------")
print("")
print("MSE")
print(np.mean(diff ** 2))
|
