ML (NN multi layers' backpropagation)

gistfile1.txt

import tensorflow as tf
import numpy as np
tf.set_random_seed(777)  # for reproducibility
learning_rate = 0.0001
xy = np.loadtxt('multiTimeline_bitcoin_2_normalized.csv', delimiter=',', dtype=np.float32)
X_data = xy[:, 0:-1]
def MinMaxScaler(x_data):
    numerator = x_data - np.min(x_data, 0)
    denominator = np.max(x_data, 0) - np.min(x_data, 0)
    return numerator / (denominator + 1e-10)
N = X_data.shape[0]
y_data = xy[:, [-1]]
x_data = np.array(X_data, dtype=np.float32)
y_data = np.array(y_data, dtype=np.float32)
print("Shape of X data:", x_data.shape)
print("Shape of y data: ", y_data.shape)
print('---------------')
X = tf.placeholder(tf.float32, [None, 52])
Y = tf.placeholder(tf.float32, [None, 1])
nb_classes = 4
print(X)
print(Y)
print('--------------------')
W1 = tf.Variable(tf.random_normal([52, nb_classes]), name='weight1')
b1 = tf.Variable(tf.random_normal([nb_classes]), name='bias1')
l1 = tf.sigmoid(tf.matmul(X, W1) + b1)
W2 = tf.Variable(tf.random_normal([4, 1]), name='weight2')
b2 = tf.Variable(tf.random_normal([1]), name='bias2')
Y_pred = tf.sigmoid(tf.matmul(l1, W2) + b2)
cost = -tf.reduce_mean(Y * tf.log(Y_pred) + (1 - Y) * tf.log(1 - Y_pred))
d_Y_pred = (Y_pred - Y) / (Y_pred * (1.0 - Y_pred) + 1e-7)
d_sigma2 = Y_pred * (1 - Y_pred)
d_a2 = d_Y_pred * d_sigma2
d_p2 = d_a2
d_b2 = d_a2
d_W2 = tf.matmul(tf.transpose(l1), d_p2)
d_b2_mean = tf.reduce_mean(d_b2, axis=[0])
d_W2_mean = d_W2 / tf.cast(tf.shape(l1)[0], dtype=tf.float32)
d_l1 = tf.matmul(d_p2, tf.transpose(W2))
d_sigma1 = l1 * (1 - l1)
d_a1 = d_l1 * d_sigma1
d_b1 = d_a1
d_p1 = d_a1
d_W1 = tf.matmul(tf.transpose(X), d_a1)
d_W1_mean = d_W1 / tf.cast(tf.shape(X)[0], dtype=tf.float32)
d_b1_mean = tf.reduce_mean(d_b1, axis=[0])
step = [
  tf.assign(W2, W2 - learning_rate * d_W2_mean),
  tf.assign(b2, b2 - learning_rate * d_b2_mean),
  tf.assign(W1, W1 - learning_rate * d_W1_mean),
  tf.assign(b1, b1 - learning_rate * d_b1_mean)
]
predicted = tf.cast(Y_pred > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print("shape", sess.run(tf.shape(X)[0], feed_dict={X: x_data}))

    for i in range(10001):
        sess.run([step, cost], feed_dict={X: x_data, Y: y_data})
        if i % 1000 == 0:
            print(i, sess.run([cost, d_W1], feed_dict={
                  X: x_data, Y: y_data}), sess.run([W1, W2]))

    h, c, a = sess.run([Y_pred, predicted, accuracy],
                       feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ", h, "\nCorrect: ", c, "\nAccuracy: ", a)