import pandas as pd
import numpy as np
import tensorflow as tf

# Step 1 - Load our data
dataframe = pd.read_csv('data.csv') # dataframe object

# Remove features we don't care about
dataframe = dataframe.drop(['index', 'price', 'sq_price'], axis=1)

# We only use the first 10 rows
# We're using area and bathrooms for our features, you can use others, we'll be using these
dataframe = dataframe[0:10]
dataframe

# Step 2 - Add labels
# 1 = Good buy
# 0 = Bad buy
dataframe.loc[:, ('y1')] = [1,1,1,0,0,1,0,1,1,1]

# y2 is a negation of y1 - we don't like a house
dataframe.loc[:, ('y2')] = dataframe['y1'] == 0

# turn TRUE/FALSE values into 1s and 0s
dataframe.loc[:, ('y2')] = dataframe['y2'].astype(int)

# Print our dataframe
dataframe

# Step 3 - Prepare data for tensorflow

# convert features to input tensor
inputX = dataframe.loc[:, ['area', 'bathrooms']].as_matrix()

# convert labels to input tensors
inputY = dataframe.loc[:, ['y1', 'y2']].as_matrix()

inputX

inputY

# Step 4 - Set our hyperparameters
learning_rate = 0.000001
training_epochs = 2000
display_step = 250
n_samples = inputY.size

# Step 5 - Create our computation graph/neural network
# for our feature input tensor, none means any numbers of examples
# placeholders are gateways for data into our computation graph
x = tf.placeholder(tf.float32, [None, 2]) # 2 because we have 2 features (a 2d matrix)

# create weights
# 2x2 float matrix that we update through the training process
# variables in tf hold and update parameters, e.g: weights (they are in memory buffers containing tensors)
W = tf.Variable(tf.zeros([2,2]))

# add biases - biases help our model fit better
# b in the y = mx + b
# The bias shifts the line to best fit our data
b = tf.Variable(tf.zeros([2]))

# Multiply our weights by our inputs, first calculation
# weights are how we govern how data flows in out computation graph
# multiply input by weights and add biases
y_values = tf.add(tf.matmul(x, W), b)

# apply softmax (our "activation function") to value we just created - softmax normalizes our value
# it takes our value and converts it to a probability that we can then feed to our output
y = tf.nn.softmax(y_values)

# feed in a matrix of labels
# We have 'x' already which are our features, these are our y labels
y_ = tf.placeholder(tf.float32, [None, 2])

# Step 6 - Perform training
# Create our cost function, mean squared error
# Calculate the error between our 2 'y' values
# Take the average of the difference in values (our error) - the squared difference
# reduce sum computes the sum of elements across dimensions of a tensor
cost = tf.reduce_sum(tf.pow(y_ - y, 2))/(2*n_samples)

# Gradient descent (computing the partial derivative with respect to our input variables - in our case a set of weights and biases)
# We have this `cost` function, we want to _minimize_ that cost using `GradientDescent` with this `learning_rate` to define how fast we want to do that
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# Initialize our variables and tensorflow session

# Initializes all the variables and placeholder objects
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

# Training loop
for i in range(training_epochs):
    # Run our session given our optimizer
    sess.run(optimizer, feed_dict={x: inputX, y_: inputY})
    
    # Write our debugging logs
    if (i % display_step == 0):
        cc = sess.run(cost, feed_dict={x: inputX, y_: inputY})
        print('Training step:', '%04d' % (i), "cost=", "{:.9f}".format(cc))
        
print("Optimization Finished!")
training_cost = sess.run(cost, feed_dict={x: inputX, y_: inputY})
print("Training cost=", training_cost, "W=", sess.run(W), "b=", sess.run(b))

# Test our output
# We feed in our inputX and the y1 and y2 values are predicted below.
sess.run(y, feed_dict={x: inputX})