054_DLbyABr_03a-BatchTensorFlowWithMatrices(Python)

# we know these params, but we're making TF learn them

REAL_SLOPE_X1 = 2 # slope along axis 1 (x-axis)

REAL_SLOPE_X2 = 3 # slope along axis 2 (y-axis)

REAL_INTERCEPT = 5 # intercept along axis 3 (z-axis), think of (x,y,z) axes in the usual way

import numpy as np

# GENERATE a batch of true data, with a little Gaussian noise added

def make_mini_batch(size=10):

  X = np.random.rand(size, 2) # 

  Y = np.matmul(X, [REAL_SLOPE_X1, REAL_SLOPE_X2]) + REAL_INTERCEPT + 0.2 * np.random.randn(size) 

  return X.reshape(size,2), Y.reshape(size,1)

 Xex = np.random.rand(10, 2) # Xex is simulating PRNGs from independent Uniform [0,1] RVs

 Xex # visualize these as 10 orddered pairs of points in the x-y plane that makes up our x-axis and y-axis (or x1 and x2 axes)

Yex = np.matmul(Xex, [REAL_SLOPE_X1, REAL_SLOPE_X2]) #+ REAL_INTERCEPT #+ 0.2 * np.random.randn(10) 

Yex

0.21757443*REAL_SLOPE_X1 +  0.01815727*REAL_SLOPE_X2 

Yex = np.matmul(Xex, [REAL_SLOPE_X1, REAL_SLOPE_X2]) + REAL_INTERCEPT # + 0.2 * np.random.randn(10) 

Yex

Yex = np.matmul(Xex, [REAL_SLOPE_X1, REAL_SLOPE_X2])  + REAL_INTERCEPT + 0.2 * np.random.randn(10) 

Yex # note how each entry in Yex is jiggled independently a bit by 0.2 * np.random.randn()

make_mini_batch() # our mini-batch of Xx and Ys

import tensorflow as tf

batch = 10 # size of batch

tf.reset_default_graph() # this is important to do before you do something new in TF

# we will work with single floating point precision and this is specified in the tf.float32 type argument to each tf object/method

x = tf.placeholder(tf.float32, shape=(batch, 2)) # placeholder node for the pairs of x variables (predictors) in batches of size batch

x_aug = tf.concat( (x, tf.ones((batch, 1))), 1 ) # x_aug is a concatenation of a vector of 1`s along the first dimension

y = tf.placeholder(tf.float32, shape=(batch, 1)) # placeholder node for the univariate response y with batch many rows and 1 column

model_params = tf.get_variable("model_params", [3,1]) # these are the x1 slope, x2 slope and the intercept (3 rows and 1 column)

y_model = tf.matmul(x_aug, model_params) # our two-factor regression model is defined by this matrix multiplication

# note that the noise is formally part of the model and what we are actually modeling is the mean response...

error = tf.reduce_sum(tf.square(y - y_model))/batch # this is mean square error where the sum is computed by a reduce call on addition

train_op = tf.train.GradientDescentOptimizer(0.02).minimize(error) # learning rate is set to 0.02

init = tf.global_variables_initializer() # our way into running the TF session

errors = [] # list to track errors over iterations

with tf.Session() as session:

    session.run(init)    

    for i in range(1000):

      x_data, y_data = make_mini_batch(batch) # simulate the mini-batch of data x1,x2 and response y with noise

      _, error_val = session.run([train_op, error], feed_dict={x: x_data, y: y_data})

      errors.append(error_val)

    out = session.run(model_params)

    print(out)

REAL_SLOPE_X1, REAL_SLOPE_X2, REAL_INTERCEPT # compare with rue parameter values - it's not too far from the estimates