Understanding Gradient Descent Algorithm with Python Code

Gradient Descent (GD) is the basic optimization algorithm for machine learning or deep learning. This post explains the basic concept of gradient descent with python code.

Parameter Learning

Data is the outcome of action or activity.

y, x

Our focus is to predict the outcome of next action from data. For this end, we should develop a model to describe data properly and do forecasting

Model is a function of data and parameters (θ= (w,b)′). We estimate parameters which fit data well.

Loss is a distance function between data and model like MSE(Mean Squared Error).

Since data is fixed and given, the learning is the parameter update.

Here γ is the learning rate or step size and

is the gradient. The gradient is the partial derivatives of J with respect to θ as follows.

Illustration for Gradient Descent

Purpose of learning is to minimize a loss or cost function J with respect to parameters. This is done by finding gradient. But the gradient always points in the direction of steepest increase in the loss function as can be seen in the following figure.

Therefore the gradient descent which aims to find target parameters(b∗) takes a step in the direction of the negative gradient in order to reduce loss. For candidate parameters to move in the direction of reducing loss, new parameters are updated by negative gradient with learning rate or step size. In other words, parameters are determined by the gradient descent method automatically but learning rate is set by hand, which is a hyperparameter.

Python Code

The following python code implements the above explanation about gradient descent algorithm. Due to its structured simplicity, it is straightforward to understand relevant aspect of the gradient descent.

#=========================================================================#
# Financial Econometrics & Derivatives, ML/DL using R, Python, Tensorflow 
# by Sang-Heon Lee
#
# https://shleeai.blogspot.com
#-------------------------------------------------------------------------#
# Gradient Descent example
#=========================================================================#
 
# -*- coding: utf-8 -*-
import numpy as np
 
#-------------------------------------------------------------------------#
# Declaration of functions
#-------------------------------------------------------------------------#
# Model
def Model(x, w, b):
    y_hat = w*x + b
    return y_hat
 
# Gradient
def Gradient(y,x,w,b):
    y_hat = Model(x, w, b)
    djdw = 2*np.mean((y-y_hat)*(-x))
    djdb = 2*np.mean((y-y_hat)*(-1))
    return djdw, djdb
 
# Learning : step = step size or learning rate
def Learning(y,x,w,b,lr):
    djdw, djdb = Gradient(y, x, w, b)
    w_update = w - step*djdw
    b_update = b - step*djdb
    return w_update, b_update
 
#-------------------------------------------------------------------------#
# use real data
#-------------------------------------------------------------------------#
import pandas as pd
import matplotlib.pyplot as plt
 
url = 'https://raw.githubusercontent.com/bammuger/blog/main/sample_data.csv'
data = pd.read_csv(url)
data.head()
 
plt.scatter(data.inputs, data.outputs, s = 0.5)
plt.show()

1) Sufficient Iteration

#-------------------------------------------------------------------------#
# Learning - sufficient iteration
#-------------------------------------------------------------------------#
# initial guess
w = 2; b = 3; step = 0.05
 
# Iternated learning process by parameter update using gradient descent
for i in range(0,5000):
    y = data.outputs
    x = data.inputs
    w, b  = Learning(y, x, w, b, step)
 
print("Learned_w: {}, Learned_b: {}".format(w, b))
  
X = np.linspace(0, 1, 100)
Y = w * X + b
 
plt.scatter(data.inputs, data.outputs, s = 0.3)
plt.plot(X, Y, '-r', linewidth = 1.5)
plt.show()

2) Insufficient Iteration

#-------------------------------------------------------------------------#
# Learning - insufficient iteration
#-------------------------------------------------------------------------#
# initial guess
w = 2; b = 3; step = 0.05
 
# Iternated learning process by parameter update using gradient descent
for i in range(0,10):
    y = data.outputs
    x = data.inputs
    w, b  = Learning(y, x, w, b, step)
    
print("Learned_w: {}, Learned_b: {}".format(w, b))
  
X = np.linspace(0, 1, 100)
Y = (w * X) + b
 
plt.scatter(data.inputs, data.outputs, s = 0.3)
plt.plot(X, Y, '-r', linewidth = 1.5)
plt.show()

Next post, we will cover stochastic gradient descent, mini-batch gradient descent algorithm which are variants of GD.

Originally posted on SHLee AI Financial Model blog.

Go Source