About IoT

Machine Learning

• Limitations of explicit programming

- Spam filter: many rules

- Automatic driving: too many rules

• Machine learning: "Field of study that gives

computers the ability to learn without being

explicitly programmed” Arthur Samuel (1959)

Supervised/Unsupervised learning

• Supervised learning:

- learning with labeled examples - training set

Supervised learning

An example training set for four visual categories.

Supervised/Unsupervised learning

• Supervised learning:

- learning with labeled examples

• Unsupervised learning: un-labeled data

- Google news grouping

- Word clustering

Supervised learning

• Most common problem type in ML

- Image labeling: learning from tagged images

- Email spam filter: learning from labeled (spam or ham) email

- Predicting exam score: learning from previous exam score and time spent

Types of supervised learning

• Predicting final exam score based on time spent

- regression

• Pass/non-pass based on time spent

- binary classification

• Letter grade (A, B, C, E and F) based on time spent

- multi-label classification

Predicting final exam score based on time spent

Pass/non-pass based on time spent

Letter grade (A, B, …) based on time spent

Linear regression?

Predicting exam score: regression

Regression (data)

Regression (presentation)

(Linear) Hypothesis

(Linear) Hypothesis

(Linear) Hypothesis

Which hypothesis is better?

Which hypothesis is better?

Cost function

• How fit the line to our (training) data

Cost function

• How fit the line to our (training) data

Cost function

Goal: Minimize cost

Simplified hypothesis

What cost(W) looks like?

What cost(W) looks like?

What cost(W) looks like?

What cost(W) looks like?

How to minimize it?

Gradient descent algorithm

• Minimize cost function

• Gradient descent is used many minimization problems

• For a given cost function, cost (W, b), it will find W, b to minimize cost

• It can be applied to more general function: cost (w1, w2, …)

How it works?

How would you find the lowest point?

How it works?

• Start with initial guesses

- Start at 0,0 (or any other value)

- Keeping changing W and b a little bit to try and reduce cost(W, b)

• Each time you change the parameters, you select the gradient which reduces

cost(W, b) the most possible

• Repeat

• Do so until you converge to a local minimum

• Has an interesting property

- Where you start can determine which minimum you end up

Formal definition

Formal definition

Formal definition

Gradient descent algorithm

Convex function

Convex function

with TensorFlow

import tensorflow as tf

import matplotlib.pyplot as plt

X = [1, 2, 3]

Y = [1, 2, 3]

W = tf.placeholder(tf.float32)

# Our hypothesis for linear model X * W

hypothesis = X * W

# cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())

# Variables for plotting cost function

W_val = []

cost_val = []

for i in range(-30, 50):

feed_W = i * 0.1

curr_cost, curr_W = sess.run([cost, W], feed_dict={W: feed_W})

W_val.append(curr_W)

cost_val.append(curr_cost)

# Show the cost function

plt.plot(W_val, cost_val)

plt.show()

with TensorFlow

One more?

import tensorflow as tf

x_data = [1, 2, 3]

y_data = [1, 2, 3]

W = tf.Variable(tf.random_normal([1]), name='weight')

X = tf.placeholder(tf.float32)

Y = tf.placeholder(tf.float32)

# Our hypothesis for linear model X * W

hypothesis = X * W

# cost/loss function

cost = tf.reduce_sum(tf.square(hypothesis - Y))

# Minimize: Gradient Descent using derivative: W -= learning_rate * derivative

learning_rate = 0.1

gradient = tf.reduce_mean((W * X - Y) * X)

descent = W - learning_rate * gradient

update = W.assign(descent)

# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())

for step in range(21):

sess.run(update, feed_dict={X: x_data, Y: y_data})

print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}), sess.run(W))

One more?

0 0.84999657 [0.7535978]

1 0.241777 [0.86858547]

2 0.068772085 [0.92991227]

3 0.019561779 [0.9626199]

4 0.0055642645 [0.9800639]

5 0.0015827268 [0.9893674]

6 0.0004501979 [0.9943293]

7 0.00012805895 [0.9969756]

8 3.6424557e-05 [0.998387]

9 1.0361303e-05 [0.9991397]

10 2.947762e-06 [0.99954116]

11 8.382236e-07 [0.9997553]

12 2.3837724e-07 [0.9998695]

13 6.771275e-08 [0.99993044]

14 1.921633e-08 [0.9999629]

15 5.4823204e-09 [0.9999802]

16 1.5620181e-09 [0.99998945]

17 4.3549164e-10 [0.9999944]

18 1.2649082e-10 [0.999997]

19 3.474554e-11 [0.99999845]

20 9.166001e-12 [0.99999917]

Another?

import tensorflow as tf

# tf Graph Input

X = [1, 2, 3]

Y = [1, 2, 3]

# Set wrong model weights

W = tf.Variable(5.0)

# Linear model

hypothesis = X * W

# cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize: Gradient Descent Magic

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)

train = optimizer.minimize(cost)

# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())

for step in range(100):

print(step, sess.run(W))

sess.run(train)

Another?