#!/usr/bin/python3
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

SEED = 42
random.seed(SEED)
numpy.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.9
)

# TODO weights typc

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

with tf.device('/cpu:0'):
    tf.set_random_seed(SEED)
    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('weigths', 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(
                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_input')
        vecLayeroutHidden = tf.sigmoid(vecLayerinHidden, name='hidden_output')
        # TODO in Facharbeit Matrixprodukt erwähnen

    with tf.name_scope('mse'):
        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)

    with tf.name_scope('train'):
        train_step = tf.train.GradientDescentOptimizer(0.1).minimize(
                scalarMeanMSE)

    summaries = tf.merge_all_summaries()
    writer = tf.train.SummaryWriter("/tmp/boston_logs", 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))
        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:")
    result = sess.run([vecDifference],
                      feed_dict={
                          matInput: x_test,
                          vecTarget: y_test
                      })
    print(result[0])