NNCostFunction.m

function [J grad] = NNCostFunction(nn_params, ...
                                   input_layer_size, ...
                                   hidden_layer_size, ...
                                   num_labels, ...
                                   X, Y, lambda)

%   NNCOSTFUNCTON computes the cost and gradient of the neural network. The
%   parameters for the neural network are "unrolled" into the vector
%   nn_params and need to be converted back into the weight matrices. 
% 
%   The returned parameter grad should be a "unrolled" vector of the
%   partial derivatives of the neural network.
%

% Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices
% for our 2 layer neural network


Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
                 hidden_layer_size, (input_layer_size + 1));

Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
                 num_labels, (hidden_layer_size + 1));

% size of number of samples
m = size(X, 1);


% initialisation---- 
J = 0;
Theta1_grad = zeros(size(Theta1));
Theta2_grad = zeros(size(Theta2));


% forward propagation-----
a1 = [ones(m,1) X];
z2 = a1 * Theta1';
a2 = [ones(m,1) sigmoid(z2)];
z3 = a2*Theta2';
hx = sigmoid(z3);

% cost calculator
J = (1/m)*sum(sum((-Y).*log(hx) - (1-Y).*log(1-hx),2));

% adding the regularisation term-------
reg = (lambda/(2*m))*(sum(sum(Theta1(:,2:end).^2,2)) + sum(sum(Theta2(:,2:end).^2,2)));

J = J + reg;

% backward propagation to calculate delta 
d3 = hx - Y;
d2 = (d3*Theta2.*sigmoidGradient([ones(size(z2,1),1) z2]))(:,2:end);

% gradient calculate using the delta and node values
del1 = d2'*a1;
del2 = d3'*a2;

% addition of the regularisation term;
Theta1_grad = del1./m + (lambda/m)*[zeros(size(Theta1,1),1) Theta1(:,2:end)];
Theta2_grad = del2./m + (lambda/m)*[zeros(size(Theta2,1),1) Theta2(:,2:end)];





% Unroll gradients
grad = [Theta1_grad(:) ; Theta2_grad(:)];


end