My presentation on Machine Learning using the popular TensorFlow library. I compare an implementation of linear regression without the library, and another implementation using the library.

1. Robert John
GDE (GCP, ML)
@robert_thas
TensorFlow
What is TensorFlow and why do we use it?

2. TensorFlow is a numerical
computation library. It lets us
perform mathematical and
statistical operations on our
data.

3. Example
Predict the selling price of a house given the number of rooms

7. ● Medv => y
● Rooms => x
● Constant => b
● Gradients => w
Formulate a Hypothesis
This hypothesis is called a model

8. Without TensorFlow

9. import pandas as pd
import numpy as np
train_df = pd.read_csv('/content/gdrive/My
Drive/boston/train.csv', index_col='ID')
train_df.head()

11. train_df[['rm', 'medv']].head()

12. y = train_df['medv'].values
train_df['constant'] = 1
columns = ['constant', 'rm']
x = train_df[columns].values
w = np.zeros((x.shape[1], 1))
y_pred = np.dot(x, w)

13. error = y - y_pred
print(error.shape)
squared_error = np.power(error, 2)
root_mean_squared_error = sqrt(squared_error.sum()) /
y_pred.shape[0]
print(root_mean_squared_error)

14. Training

15. costs = []
w_0_s = []
w_1_s = []
learning_rate = 1e-3
steps = 20

16. for a in range(steps):
w_0 = w[0][0]
w_1 = w[1][0]
# make prediction
y_pred = np.dot(x, w)
error = y - y_pred
error_squared = np.power(error, 2)

17. # cost function is Least Mean Squares
LMS = error_squared.sum() / (2 * y.shape[0])
costs.append(LMS)
w_0_s.append(w_0)
w_1_s.append(w_1)
# update
w_0 = w_0 + learning_rate/y.shape[0] * error.sum()
w_1 = w_1 + learning_rate/y.shape[0] * (error * x[1]).sum()
w[0][0] = w_0
w[1][0] = w_1

18. cost_df = pd.DataFrame({'cost': pd.Series(costs),
'w_0': pd.Series(w_0_s), 'w_1': pd.Series(w_1_s)})
cost_df['cost'].plot()

19. How good are the
predictions?

20. _w = [w_0, w_1]
_w = np.asarray(_w)
_x = train_df[['constant', 'rm']].values
y_pred = np.dot(_x, _w)
_p = pd.DataFrame(dict(actual=train_df['medv'].values,
predicted=y_pred.reshape(-1)))
_p.head()

22. How is TensorFlow different?

23. class Model(object):
def __init__(self):
self.W = None
self.b = None
def __call__(self, x):
if self.W == None:
self.W = tf.Variable(tf.random.normal(shape=(1, x.shape[1])))
if self.b == None:
self.b = tf.Variable(tf.random.normal(shape=(x.shape[0], 1)))
return tf.matmul(x, self.W, transpose_b=True) + self.b

24. model = Model()
output = model(tf.constant([3.0, 3.1, 1.9, 2.0, 2.5, 2.9],
shape=(3,2)))
print(output)

25. @tf.function
def loss(y_pred, y):
return tf.reduce_mean(tf.square(y-y_pred))

26. def train(model, x, y, alpha):
x = tf.convert_to_tensor(x, np.float32)
y = tf.convert_to_tensor(y, np.float32)
with tf.GradientTape() as t:
t.watch(x)
current_loss = loss(model(x), y)
#print(current_loss)
dW, db = t.gradient(current_loss, [model.W, model.b])
#print(dW, db)
model.W.assign_sub(alpha * dW)
model.b.assign_sub(alpha * db)

27. train_df = df.sample(frac=0.8,random_state=0)
test_df = df.drop(train_df.index)
columns = ['nox', 'rm', 'chas', 'dis', 'ptratio', 'lstat', 'rad']
X_train = train_df[columns].values
X_test = test_df[columns].values
y_train = train_df[['medv']].values
y_test = test_df[['medv']].values

28. epochs = 10
model = Model()
for i in range(epochs):
train(model, X_train, y_train, alpha=0.1)
print(model.W)

29. ● Vectors & Matrices
● Matrix Dot Products
● Differentiation
What was all that?
We got introduced to
● Learning Rates
● Gradient Descent
● Training Epochs

30. All of that was Linear Regression. How
about Neural Networks?

31. import tensorflow as tf
from tensorflow import keras
model = keras.Sequential([
keras.layers.Dense(50, input_shape=(7,), activation='relu'),
keras.layers.Dense(50, activation='relu'),
keras.layers.Dense(50, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(1)
])
print(model.summary())

33. adam = keras.optimizers.Adam(0.001)
model.compile(optimizer=adam, loss='mse')
model.fit(X_train, y_train, epochs=2000, validation_split=0.1)

34. ● Optimized operations
● Hardware acceleration
● Multiple languages/platforms
Benefits of using TensorFlow
● Layers
● Optimizers
● Loss Functions
● Feature Engineering
● Hyperparameter Tuning
● Model Optimization
● Transfer Learning

35. ● Keras Preprocessing Layers
● Recommendations
● New features in tf.data
● Experimental Numpy support
What’s New in TensorFlow

36. ● API Types (Keras, Estimators, etc)
● Originally graph-based vs. “pythonic”
Differences Between TensorFlow and Others

37. Learn More
Neural Networks and Deep Learning
http://neuralnetworksanddeeplearning.com/
Machine Learning Crash Course
https://developers.google.com/machine-learning/crash-course
TensorFlow
https://www.tensorflow.org/

38. Robert John
GDE (GCP, ML)
@robert_thas
Thank You!