#!/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

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 = 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

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')
        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'):
        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([vecDifference, vecLayeroutHidden,
                       scalarLogdiffsum, scalarMSE],
                      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[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(target_scaler.inverse_transform([result[3]]))