import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

with open(r"C:\pypro\brcatest_go.csv", 'r') as f:

    data = pd.read_csv(f)

print(data.shape)

tcga_input=np.transpose(data)

print(tcga_input.shape)

learning_rate = 0.01

training_epochs = 10

batch_size = 50

display_step = 1

examples_to_show = 10

dropout=0.1

n_input = 60779

scale = 0.0001

# tf Graph input (only pictures)

X = tf.placeholder("float", [None, n_input])

n_hidden_1 = 500 # 

n_hidden_2 = 200 # 

weights = {

    'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),

    'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),

    'decoder_h1': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),

    'decoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_input])),

}

biases = {

    'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),

    'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),

    'decoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),

    'decoder_b2': tf.Variable(tf.random_normal([n_input])),

}

def encoder(x):

    layer_1 = tf.nn.tanh(tf.add(tf.matmul(x, weights['encoder_h1']),

                                   biases['encoder_b1']))

    layer_2 = tf.nn.tanh(tf.add(tf.matmul(layer_1, weights['encoder_h2']),

                                   biases['encoder_b2']))

    return layer_2

def decoder(x):

    layer_1 = tf.nn.tanh(tf.add(tf.matmul(x, weights['decoder_h1']),

                                   biases['decoder_b1']))

    layer_2 = tf.nn.tanh(tf.add(tf.matmul(layer_1, weights['decoder_h2']),

                                   biases['decoder_b2']))

    return layer_2

##################################################################

fc_1 = tf.layers.dense(inputs=X, units=n_hidden_1,

                       kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=scale))

fc_1_out = tf.nn.tanh(fc_1)

fc_1_dropout = tf.layers.dropout(inputs=fc_1_out, rate=dropout)

fc_2 = tf.layers.dense(inputs = fc_1_dropout, units = n_hidden_2, kernel_regularizer= tf.contrib.layers.l2_regularizer(scale=scale))

fc_2_out = tf.nn.tanh(fc_2)

encoder_op = tf.layers.dropout(inputs=fc_2_out, rate=dropout)

fc_3 = tf.layers.dense(inputs = encoder_op, units = n_hidden_1, kernel_regularizer= tf.contrib.layers.l2_regularizer(scale=scale))

fc_3_out = tf.nn.tanh(fc_3)

fc_3_dropout = tf.layers.dropout(inputs=fc_3_out, rate=dropout)

decoder_op = tf.layers.dense(inputs=fc_3_dropout, units=n_input)

##################################################################

y_pred = decoder_op

y_true = X

cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))#+lossL 

l2_loss = tf.losses.get_regularization_loss()

optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost+l2_loss)

with tf.Session() as sess:

    # tf.initialize_all_variables() no long valid from

    # 2017-03-02 if using tensorflow >= 0.12

    if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:

        init = tf.initialize_all_variables()

    else:

        init = tf.global_variables_initializer()

    sess.run(init)

    total_batch = int(len(tcga_input)/batch_size) 

    for epoch in range(training_epochs):

        for i in range(total_batch):

            # tch_xs, batch_ys = mnist.train.next_batch(batch_size)  # max(x) = 1, min(x) = 0

            batch_xs = tcga_input[((i)*batch_size):((i+1)*batch_size)]

            # Run optimization op (backprop) and cost op (to get loss value)

            _, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})

        if epoch % display_step == 0:

            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))

        if epoch == training_epochs - 1:

                fea_output = sess.run([encoder_op], feed_dict={X: tcga_input})

                # print(fea_output)

                print(np.array(fea_output).shape)

                np.savetxt(r'C:\pypro\fea.csv', np.array(fea_output[0]), delimiter=',')

    print("Optimization Finished!")