Unit-III

Advanced Machine Learning

 Machine learning algorithms are a subset of artificial intelligence (AI) that imitates the
human learning process.
 Machine learning algorithms develop multiple models (usually using multiple datasets) and
each model is analogous to an experience
 Machine learns with respect to a particular task T, performance metric P following experience
E, if the system reliably improves its performance P at task T following experience E.
 The major difference between statistical learning and machine learning is that statistical
learning depends heavily on validation of model assumptions and hypothesis testing, whereas
the objective of machine learning is to improve prediction accuracy
 Supervised Learning: In supervised learning, the datasets have the values of input variables
(feature values) and the corresponding outcome variable. The algorithms learn from the
training dataset and predict the outcome variable for a new record with values of input
variables.Ex:-Regression
 Unsupervised Learning: The datasets will have only input variable values, but not the output.
The algorithm learns the structure in the inputs. Ex:- Clustering
How Machines Learn?
In supervised learning, the algorithm learns using a function called loss function, cost function
or error function, which is a function of predicted output and the desired output. If h(Xi ) is the
predicted output and yi is the desired output, then the loss function is

where n is the total number of records for which the predictions are made. The function sum of
squared error (SSE) is the loss function for a regression model.
Machine learning uses optimization algorithms which can be used for minimizing the loss
function. Most widely used optimization technique is called the Gradient Descent.
GRADIENT DESCENT ALGORITHM
Gradient descent (GD) algorithm can be used for estimating the values of regression parameters,
given a dataset with inputs and outputs.
The functional form of a simple linear regression model is given by
The values of B0 and B1 at the minimum cost points are best estimates of the model parameters
Developing a Gradient Descent Algorithm for Linear Regression Model
To implement the GD algorithm using the dataset Advertising.csv
The dataset has the following elements:
1. TV – Spend on TV advertisements
2. Radio – Spend on radio advertisements
3. Newspaper – Spend on newspaper advertisements
4. Sales – Sales revenue generated
Loading the Dataset
Load the dataset using Pandas’ library.
import pandas as pd
import numpy as np
import warnings warnings.
filterwarnings(‘ignore’)
sales_df = pd.read_csv(‘Advertising.csv’)
# Printing first few records
sales_df.head()
Set X and Y Variables
X = sales_df[[‘TV’, ‘Radio’, ‘Newspaper’]]
Y = sales_df[‘Sales’]
Standardize X and Y
It is important to convert all variables into one scale.
Y = np.array( (Y - Y.mean() ) / Y.std() )
X = X.apply( lambda rec: ( rec - rec.mean() ) / rec.std(), axis = 0 )

Implementing the Gradient Descent Algorithm

A set of following utility methods need to be implemented:
1. Method 1: Method to randomly initialize the bias and weights.
2. Method 2: Method to calculate the predicted value of Y, that is, Y given the bias and weights.
3. Method 3: Method to calculate the cost function from predicted and actual values of Y.
4. Method 4: Method to calculate the gradients and adjust the bias and weights.
Method 1: Random Initialization of the Bias and Weights
The method randomly initializes the bias and weights. It takes the number of weights that need to be
initialized as a parameter.
import random
np.random.seed(seed=42)
random.seed(42)
#Initialize the bias.
b = random.random()
#Initialize the weights.
w = np.random.rand( dim )
Method 2: Predict Y Values from the Bias and Weights
# Inputs:
# b – bias, w – weights, X - the input matrix
def predict_Y( b, w, X ):
return b + np.matmul( X, w )
Now calculate the predicted values after initializing bias and weights.
b, w = initialize( 3 )
Y_hat = predict_Y( b, w, X)
Y_hat[0:10]
Method 3: Calculate the Cost Function — MSE
Compute mean squared error (MSE) by
1. Calculating differences between the estimated Ŷ and actual Y.
2. Calculating the square of the above residuals, and sum over all records.
3. Dividing it with the number of observations.
return np.sum( np.matmul( Y_resid.T, Y_resid ) ) / len( Y_resid )
Invoking get_cost() after initializing the bias and weights and calculating predicted values for outcome
variable.
b, w = initialize( 3 )
Y_hat = predict_Y( b, w, X)
get_cost( Y, Y_hat )
Method 4: Update the Bias and Weights
The bias and weights will be updated in a method update_beta() using the following gradients

where α is the learning parameter that decides the magnitude of the update to be done to the bias and
weights
Finding the Optimal Bias and Weights
The updates to the bias and weights need to be done iteratively, until the cost is minimum. It can take
several iterations and is time-consuming. There are two approaches to stop the iterations:
1. Run a fixed number of iterations and use the bias and weights as optimal values at the end these
iterations.
2. 2. Run iterations until the change in cost is small, that is, less than a predefined value (e.g., 0.001).

for each_iter in range(num_iterations):

Y_hat = predict_Y( b, w, X )
this_cost = get_cost( Y, Y_hat )
# Save the previous bias and weights
prev_b = b prev_w = w
b, w = update_beta( X, Y, Y_hat, prev_b, prev_w, alpha)
# For every 10 iterations, store the cost i.e. MSE
if( iter_num % 10 == 0 ):
gd_iterations_df.loc[result_idx] = [iter_num, this_cost]
result_idx = result_idx + 1
iter_num += 1 print( “Final estimate of b and w: ”, b, w )
Plotting the Cost Function against the Iterations
The value of the cost function at the end of each iteration can be visualized by plotting cost at every 10
iterations using the following commands:
import matplotlib.pyplot as plt
import seaborn as sn %matplotlib
inline plt.plot( gd_iterations_df[‘iteration’], gd_iterations_df[‘cost’] );
plt.xlabel(“Number of iterations”)
plt.xlabel(“Cost or MSE”)
print( “Final estimates of b and w: ”, b, w )

plot the cost aer every iteration for dierent learning rate parameters (alpha values).
plt.plot( alpha_df_1[‘iteration’], alpha_df_1[‘cost’], label = “alpha = 0.01” );
plt.plot( alpha_df_2[‘iteration’], alpha_df_2[‘cost’], label = “alpha = 0.001”);

The plot in Figure shows that the learning is faster for alpha value 0.01 compared to 0.001. For smaller
values, the learning could be slower whereas higher learning rate could lead to skipping the minima of
cost function. It is imperative to search for the optimal learning parameter.

SCIKIT-LEARN LIBRARY FOR MACHINE LEARNING

The scikit-learn library in Python, which is primarily an open-source Python library for building machine
learning models. scikit-learn provides a comprehensive set of algorithms for the following kind of
problems:
1. Regression
2. Classification
3. Clustering
scikit-learn also provides an extensive set of methods for data pre-processing and feature selection

Steps for Building Machine Learning Models

The steps to be followed for building, validating a machine learning model and measuring its accuracy
are as follows:
1. Identify the features and outcome variable in the dataset.
2. Split the dataset into training and test sets.
3. Build the model using training set.
4. Predict outcome variable using a test set.
5. Compare the predicted and actual values of the outcome variable in the test set and measure
accuracy using measures such as mean absolute percentage error (MAPE) or root mean square error
(RMSE).
Splitting Dataset into Train and Test Datasets
The following commands can be used for splitting the dataset using 70:30 ratio. That is, 70% for
training and 30% for the test set. Usually, data scientists use a range of 60% to 80% for training and the
rest for testing the model.
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test =
train_test_split( sales_df[[“TV”, “Radio”, “Newspaper”]], sales_df.Sales, test_size=0.3, random_state =
42)
The following commands can be used for finding the number of records sampled into training and test
sets.
len( X_train )
140
len( X_test )
60
Building Linear Regression Model with Train Dataset
from sklearn.linear_model import LinearRegression
Steps for building a model in sklearn are
1. Initialize the model.
2. Invoke fit() method on the model and pass the input (X) and output(Y) values.
3. fit() will run the algorithm and return the final estimated model parameters.
linreg = LinearRegression()
linreg.fit( X_train, y_train )
 To associate the coefficient values with the variable names, we can use zip() in Python.
 zip() returns a dictionary with variable names mapped to coefficient values.
list( zip( [“TV”, “Radio”, “Newspaper”], list( linreg.coef) ) )
[(‘TV’, 0.04405928), (‘Radio’, 0.1992874968989395), (‘Newspaper’, 0.0068824522222754)]
Making Prediction on Test Set
sklearn provides predict() method for all ML models, which takes the X values and predicts the
outcome variable Y as shown in the following code:
y_pred = linreg.predict( X_test )
The residual here refers to the difference between the actual and the predicted values
test_pred_df = pd.DataFrame( { ‘actual’: y_test, ‘predicted’: np.round( y_pred, 2 ), ‘residuals’: y_test -
y_pred } )
Measuring Accuracy
sklearn.metrics package provides methods to measure various metrics. For regression models,
mean_squared_error and r2_score can be used to calculate MSE and R-squared values, respectively.
R-Squared Value
The R-squared value is calculated on the training data, which is the amount of variance in Y that can be
explained by the model. metrics.r2_score() takes the actual and the predicted values of Y to compute
R-squared value.
r2 = metrics.r2_score( y_train, linreg.predict(X_train) )
print(“R Squared: ”, r2)
R Squared: 0.9055159502227753
RMSE Calculation
metrics.mean_squared_error() takes actual and predicted values and returns MSE.
mse = metrics.mean_squared_error( y_test, y_pred )
rmse = round( np.sqrt(mse), 2 )
print(“RMSE: ”, rmse)
RMSE: 1.95
The RMSE value indicates the model prediction has a standard deviation of 1.95.
Bias-Variance Trade-off
Model errors can be decomposed into two components: bias and variance.
High bias can lead to building underfitting model, whereas high variance can lead to overfitting models.
The following code to build models with degrees ranging from 1 to 15 and storing the degree and error
details in different columns of a DataFrame named rmse_df.
1. degree: Degree of the model (number of polynomial terms).
2. rmse_train: RMSE error on train set.
3. rmse_test: RMSE error on test set.
rmse_df = pd.DataFrame( columns = [“degree”, “rmse_train”, “rmse_test”] )
plt.plot( rmse_df.degree, rmse_df.rmse_train, label=‘RMSE on Training Set’, color = ‘r’ )
plt.plot( rmse_df.degree, rmse_df.rmse_test, label=‘RMSE on Test Set’, color = ‘g’ )
Three key observations from Figure are as follows:
1. Error on the test set are high for the model with complexity of degree 1 and degree 15.
2. Error on the test set reduces initially, however increases after a specific level of complexity.
3. Error on the training set decreases continuously
K-Fold Cross-Validation
K-fold cross-validation is a robust validation approach that can be adopted to verify if the model is
overfitting.

Figure depicts the process of K-fold cross-validation with 5 folds