While working with multivariate regression there are certain essential principles that must be applied to ensure the correctness of the solution while being able to pick the most optimum solution. This is all the more important when the problem has a large number of features. In this post I apply these important principles to a regression data set which I was able to pull of the internet. This data set was taken from the UCI Machine Learning repository and deals with Boston housing data. The housing data provides the cost of house in Boston suburbs given the number of rooms, the connectivity to main highways, and crime rate in the area and several other data. There are a total of 506 data points in this data set with a total of 13 features.
This seemed a reasonable dataset to start to try out the principles of Machine Learning I had picked up from Coursera’s ML course.
Out of a total of 13 features 2 features ’ZN’ and ‘CHAS’ proximity to Charles river were dropped as the values were mostly zero in these columns . The remaining 11 features were used to map to the output variable of the price.
The following key rules have been applied on the
- The dataset was divided into training samples (60%), cross-validation set (20%) and test set (20%) using a random index
- Try out different polynomial functions while performing gradient descent to determine the theta values
- Different combinations of ‘alpha’ learning rate and ‘lambda’ the regularization parameter were tried while performing gradient descent
- The error rate is then calculated on the cross-validation and test set
- The theta values that were obtained for the lowest cost for a polynomial was used to compute and plot the learning curve for the different polynomials against increasing number of training and cross-validation test samples to check for bias and variance.
- The plot of the cost versus the polynomial degree was plotted to obtain the best fit polynomial for the data set.
A multivariate regression hypothesis can be represented as
hθ(x) = θ0 + θ1x1 + θ2x2 + θ3x3 + θ4x4 + …
And the cost can is determined as
J(θ0, θ1, θ2, θ3..) = 1/2m ∑ (hΘ (xi) -yi)2
The implementation was done using Octave. As in my previous posts some functions have not been include to comply with Coursera’s Honor Code. The code can be cloned from GitHub at machine-learning-principles
a) housing compute.m. In this module I perform gradient descent for different polynomial degrees and check the error that is obtained when using the computed theta on the cross validation and test set
max_degrees =4;
J_history = zeros(max_degrees, 1);
Jcv_history = zeros(max_degrees, 1);
for degree = 1:max_degrees;
[J Jcv alpha lambda] = train_samples(randidx, training,cross_validation,test_data,degree);
end;
b) train_samples.m – This module uses gradient descent to check the best fit for a given polynomial degree for different combinations of alpha (learning rate) and lambda( regularization).
for i = 1:length(alpha_arr),
for j = 1:length(lambda_arr)
alpha = alpha_arr{i};
lambda= lambda_arr{j};
% Perform Gradient descent
% Compute error for training sample for computed theta values
% Compute the error rate for the cross validation samples
% Compute the error rate against the test set
end;
end;
c) cross_validation.m – This module uses the theta values to compute cost for the cross validation set
d) test-samples.m – This modules computes the error when using the trained theta on the test set
e) poly.m – This module constructs polynomial vectors based on the degree as follows
function [x] = poly(xinput, n)
x = [];
for i= 1:n
xtemp = xinput .^i;
x = [x xtemp];
end;
e) learning_curve.m – The learning curve module plots the error rate for increasing number of training and cross validation samples. This is done as follows. For the theta with the lowest cost as determined by gradient descent
for i from 1 to 100
- Compute the error for ‘i’ training samples
- Compute the error for ‘i’ cross-validation
- Plot the learning curve to determine the bias and variance of the polynomial fit
This is included below
for i = 1: 100
xsample = xtrain(1:i,:);
ysample = ytrain(1:i,:);
size(xsample);
size(ysample);
[xsample] = poly(xsample,degree);
xsample= [ones(i, 1) xsample];
[c d] = size(xsample);
theta = zeros(d, 1);
% Minimize using fmincg
J = computeCost(xsample, ysample, theta);
Jtrain(i) = J;
xsample_cv = xcv(1:i,:);
ysample_cv = ycv(1:i,:);
[xsample_cv] = poly(xsample_cv,degree);
xsample_cv= [ones(i, 1) xsample_cv];
J_cv = computeCost(xsample_cv, ysample_cv,theta)
Jcv(i) = J_cv;
end;
Finally a plot is done been different lambda and the cost.
The results are included below
A) Polynomial degree 1
Convergence graph
Learning curve
The above figure does show a stronger bias. Note: the learning curve was done with around 100 samples
B) Polynomial degree 2
Convergence graph
Learning curve
The learning curve for degree 2 shows a stronger variance.
C) Polynomial degree 3
Convergence graph
Learning curve
D) Polynomial degree 4
Convergence graph
E) Learning curve
This plot is useful to determine which polynomial degree will give the best fit for the dataset and the lowest cost
Clearly from the above it can be seen that degree 2 will give a good fit for the data set.
F) Lambda vs Cost function
The above code demonstrates some key principles while performing multivariate regression
The code can be cloned from GitHub at machine-learning-principles
Giga thoughts ... 
2 thoughts on “Applying the principles of Machine Learning”