Missing exercicises

ex8/checkCostFunction.m

@@ -0,0 +1,48 @@
+function checkCostFunction(lambda)
+%CHECKCOSTFUNCTION Creates a collaborative filering problem 
+%to check your cost function and gradients
+%   CHECKCOSTFUNCTION(lambda) Creates a collaborative filering problem 
+%   to check your cost function and gradients, it will output the 
+%   analytical gradients produced by your code and the numerical gradients 
+%   (computed using computeNumericalGradient). These two gradient 
+%   computations should result in very similar values.
+
+% Set lambda
+if ~exist('lambda', 'var') || isempty(lambda)
+    lambda = 0;
+end
+
+%% Create small problem
+X_t = rand(4, 3);
+Theta_t = rand(5, 3);
+
+% Zap out most entries
+Y = X_t * Theta_t';
+Y(rand(size(Y)) > 0.5) = 0;
+R = zeros(size(Y));
+R(Y ~= 0) = 1;
+
+%% Run Gradient Checking
+X = randn(size(X_t));
+Theta = randn(size(Theta_t));
+num_users = size(Y, 2);
+num_movies = size(Y, 1);
+num_features = size(Theta_t, 2);
+
+numgrad = computeNumericalGradient( ...
+                @(t) cofiCostFunc(t, Y, R, num_users, num_movies, ...
+                                num_features, lambda), [X(:); Theta(:)]);
+
+[cost, grad] = cofiCostFunc([X(:); Theta(:)],  Y, R, num_users, ...
+                          num_movies, num_features, lambda);
+
+disp([numgrad grad]);
+fprintf(['The above two columns you get should be very similar.\n' ...
+         '(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n']);
+
+diff = norm(numgrad-grad)/norm(numgrad+grad);
+fprintf(['If your cost function implementation is correct, then \n' ...
+         'the relative difference will be small (less than 1e-9). \n' ...
+         '\nRelative Difference: %g\n'], diff);
+
+end

ex8/cofiCostFunc.m

@@ -0,0 +1,53 @@
+function [J, grad] = cofiCostFunc(params, Y, R, num_users, num_movies, ...
+                                  num_features, lambda)
+%COFICOSTFUNC Collaborative filtering cost function
+%   [J, grad] = COFICOSTFUNC(params, Y, R, num_users, num_movies, ...
+%   num_features, lambda) returns the cost and gradient for the
+%   collaborative filtering problem.
+%
+
+% Unfold the U and W matrices from params
+X = reshape(params(1:num_movies*num_features), num_movies, num_features);
+Theta = reshape(params(num_movies*num_features+1:end), ...
+                num_users, num_features);
+
+
+% You need to return the following values correctly
+J = 0;
+X_grad = zeros(size(X));
+Theta_grad = zeros(size(Theta));
+
+% ====================== YOUR CODE HERE ======================
+% Instructions: Compute the cost function and gradient for collaborative
+%               filtering. Concretely, you should first implement the cost
+%               function (without regularization) and make sure it is
+%               matches our costs. After that, you should implement the 
+%               gradient and use the checkCostFunction routine to check
+%               that the gradient is correct. Finally, you should implement
+%               regularization.
+%
+% Notes: X - num_movies  x num_features matrix of movie features
+%        Theta - num_users  x num_features matrix of user features
+%        Y - num_movies x num_users matrix of user ratings of movies
+%        R - num_movies x num_users matrix, where R(i, j) = 1 if the 
+%            i-th movie was rated by the j-th user
+%
+% You should set the following variables correctly:
+%
+%        X_grad - num_movies x num_features matrix, containing the 
+%                 partial derivatives w.r.t. to each element of X
+%        Theta_grad - num_users x num_features matrix, containing the 
+%                     partial derivatives w.r.t. to each element of Theta
+%
+
+J = (sum(sum((((X * Theta') - Y) .^ 2) .* R)) / 2) + (sum(sum(Theta .^ 2)) * (lambda / 2)) + (sum(sum(X .^ 2)) * (lambda / 2));
+
+X_grad = ((((X * Theta') - Y) .* R) * Theta) + (lambda * X);
+
+Theta_grad = ((((X * Theta') - Y) .* R)' * X) + (lambda * Theta);
+
+% =============================================================
+
+grad = [X_grad(:); Theta_grad(:)];
+
+end

ex8/computeNumericalGradient.m

@@ -0,0 +1,29 @@
+function numgrad = computeNumericalGradient(J, theta)
+%COMPUTENUMERICALGRADIENT Computes the gradient using "finite differences"
+%and gives us a numerical estimate of the gradient.
+%   numgrad = COMPUTENUMERICALGRADIENT(J, theta) computes the numerical
+%   gradient of the function J around theta. Calling y = J(theta) should
+%   return the function value at theta.
+
+% Notes: The following code implements numerical gradient checking, and 
+%        returns the numerical gradient.It sets numgrad(i) to (a numerical 
+%        approximation of) the partial derivative of J with respect to the 
+%        i-th input argument, evaluated at theta. (i.e., numgrad(i) should 
+%        be the (approximately) the partial derivative of J with respect 
+%        to theta(i).)
+%                
+
+numgrad = zeros(size(theta));
+perturb = zeros(size(theta));
+e = 1e-4;
+for p = 1:numel(theta)
+    % Set perturbation vector
+    perturb(p) = e;
+    loss1 = J(theta - perturb);
+    loss2 = J(theta + perturb);
+    % Compute Numerical Gradient
+    numgrad(p) = (loss2 - loss1) / (2*e);
+    perturb(p) = 0;
+end
+
+end

ex8/estimateGaussian.m

@@ -0,0 +1,34 @@
+function [mu sigma2] = estimateGaussian(X)
+%ESTIMATEGAUSSIAN This function estimates the parameters of a 
+%Gaussian distribution using the data in X
+%   [mu sigma2] = estimateGaussian(X), 
+%   The input X is the dataset with each n-dimensional data point in one row
+%   The output is an n-dimensional vector mu, the mean of the data set
+%   and the variances sigma^2, an n x 1 vector
+% 
+
+% Useful variables
+[m, n] = size(X);
+
+% You should return these values correctly
+mu = zeros(n, 1);
+sigma2 = zeros(n, 1);
+
+% ====================== YOUR CODE HERE ======================
+% Instructions: Compute the mean of the data and the variances
+%               In particular, mu(i) should contain the mean of
+%               the data for the i-th feature and sigma2(i)
+%               should contain variance of the i-th feature.
+%
+
+mu = (sum(X', 2)) / m;
+
+for i=1:n
+	sigma2(i) = sum((X(:, i) - mu(i, :)) .^ 2) / m;
+end
+
+
+% =============================================================
+
+
+end

ex8/ex8.m

@@ -0,0 +1,121 @@
+%% Machine Learning Online Class
+%  Exercise 8 | Anomaly Detection and Collaborative Filtering
+%
+%  Instructions
+%  ------------
+%
+%  This file contains code that helps you get started on the
+%  exercise. You will need to complete the following functions:
+%
+%     estimateGaussian.m
+%     selectThreshold.m
+%     cofiCostFunc.m
+%
+%  For this exercise, you will not need to change any code in this file,
+%  or any other files other than those mentioned above.
+%
+
+%% Initialization
+clear ; close all; clc
+
+%% ================== Part 1: Load Example Dataset  ===================
+%  We start this exercise by using a small dataset that is easy to
+%  visualize.
+%
+%  Our example case consists of 2 network server statistics across
+%  several machines: the latency and throughput of each machine.
+%  This exercise will help us find possibly faulty (or very fast) machines.
+%
+
+fprintf('Visualizing example dataset for outlier detection.\n\n');
+
+%  The following command loads the dataset. You should now have the
+%  variables X, Xval, yval in your environment
+load('ex8data1.mat');
+
+%  Visualize the example dataset
+plot(X(:, 1), X(:, 2), 'bx');
+axis([0 30 0 30]);
+xlabel('Latency (ms)');
+ylabel('Throughput (mb/s)');
+
+fprintf('Program paused. Press enter to continue.\n');
+pause
+
+
+%% ================== Part 2: Estimate the dataset statistics ===================
+%  For this exercise, we assume a Gaussian distribution for the dataset.
+%
+%  We first estimate the parameters of our assumed Gaussian distribution, 
+%  then compute the probabilities for each of the points and then visualize 
+%  both the overall distribution and where each of the points falls in 
+%  terms of that distribution.
+%
+fprintf('Visualizing Gaussian fit.\n\n');
+
+%  Estimate my and sigma2
+[mu sigma2] = estimateGaussian(X);
+
+%  Returns the density of the multivariate normal at each data point (row) 
+%  of X
+p = multivariateGaussian(X, mu, sigma2);
+
+%  Visualize the fit
+visualizeFit(X,  mu, sigma2);
+xlabel('Latency (ms)');
+ylabel('Throughput (mb/s)');
+
+fprintf('Program paused. Press enter to continue.\n');
+pause;
+
+%% ================== Part 3: Find Outliers ===================
+%  Now you will find a good epsilon threshold using a cross-validation set
+%  probabilities given the estimated Gaussian distribution
+% 
+
+pval = multivariateGaussian(Xval, mu, sigma2);
+
+[epsilon F1] = selectThreshold(yval, pval);
+fprintf('Best epsilon found using cross-validation: %e\n', epsilon);
+fprintf('Best F1 on Cross Validation Set:  %f\n', F1);
+fprintf('   (you should see a value epsilon of about 8.99e-05)\n');
+fprintf('   (you should see a Best F1 value of  0.875000)\n\n');
+
+%  Find the outliers in the training set and plot the
+outliers = find(p < epsilon);
+
+%  Draw a red circle around those outliers
+hold on
+plot(X(outliers, 1), X(outliers, 2), 'ro', 'LineWidth', 2, 'MarkerSize', 10);
+hold off
+
+fprintf('Program paused. Press enter to continue.\n');
+pause;
+
+%% ================== Part 4: Multidimensional Outliers ===================
+%  We will now use the code from the previous part and apply it to a 
+%  harder problem in which more features describe each datapoint and only 
+%  some features indicate whether a point is an outlier.
+%
+
+%  Loads the second dataset. You should now have the
+%  variables X, Xval, yval in your environment
+load('ex8data2.mat');
+
+%  Apply the same steps to the larger dataset
+[mu sigma2] = estimateGaussian(X);
+
+%  Training set 
+p = multivariateGaussian(X, mu, sigma2);
+
+%  Cross-validation set
+pval = multivariateGaussian(Xval, mu, sigma2);
+
+%  Find the best threshold
+[epsilon F1] = selectThreshold(yval, pval);
+
+fprintf('Best epsilon found using cross-validation: %e\n', epsilon);
+fprintf('Best F1 on Cross Validation Set:  %f\n', F1);
+fprintf('   (you should see a value epsilon of about 1.38e-18)\n');
+fprintf('   (you should see a Best F1 value of 0.615385)\n');
+fprintf('# Outliers found: %d\n\n', sum(p < epsilon));