%% Machine Learning Online Class - Exercise : Linear Regression

%  Instructions

%  ------------

%

%  This file contains code that helps you get started on the

%  linear exercise. You will need to complete the following functions

%  in this exericse:

%

%     warmUpExercise.m

%     plotData.m

%     gradientDescent.m

%     computeCost.m

%     gradientDescentMulti.m

%     computeCostMulti.m

%     featureNormalize.m

%     normalEqn.m

%

%  For this exercise, you will not need to change any code in this file,

%  or any other files other than those mentioned above.

%

% x refers to the population size in ,000s

% y refers to the profit in $,000s

%

%% Initialization

clear ; close all; clc

%% ==================== Part : Basic Function ====================

% Complete warmUpExercise.m

fprintf('Running warmUpExercise ... \n');

fprintf('5x5 Identity Matrix: \n');

warmUpExercise()

fprintf('Program paused. Press enter to continue.\n');

pause;

%% ======================= Part : Plotting =======================

fprintf('Plotting Data ...\n')

data = load('ex1data1.txt');

X = data(:, ); y = data(:, );

m = length(y); % number of training examples

% Plot Data

% Note: You have to complete the code in plotData.m

plotData(X, y);

fprintf('Program paused. Press enter to continue.\n');

pause;

%% =================== Part : Cost and Gradient descent ===================

X = [ones(m, ), data(:,)]; % Add a column of ones to x

theta = zeros(, ); % initialize fitting parameters

% Some gradient descent settings

iterations = ;

alpha = 0.01;

fprintf('\nTesting the cost function ...\n')

% compute and display initial cost

J = computeCost(X, y, theta);

fprintf('With theta = [0 ; 0]\nCost computed = %f\n', J);

fprintf('Expected cost value (approx) 32.07\n');

% further testing of the cost function

J = computeCost(X, y, [- ; ]);

fprintf('\nWith theta = [-1 ; 2]\nCost computed = %f\n', J);

fprintf('Expected cost value (approx) 54.24\n');

fprintf('Program paused. Press enter to continue.\n');

pause;

fprintf('\nRunning Gradient Descent ...\n')

% run gradient descent

theta = gradientDescent(X, y, theta, alpha, iterations);

% print theta to screen

fprintf('Theta found by gradient descent:\n');

fprintf('%f\n', theta);

fprintf('Expected theta values (approx)\n');

fprintf(' -3.6303\n  1.1664\n\n');

% Plot the linear fit

hold on; % keep previous plot visible

plot(X(:,), X*theta, '-')

legend('Training data', 'Linear regression')

hold off % don't overlay any more plots on this figure

% Predict values for population sizes of , and ,

predict1 = [, 3.5] *theta;

fprintf('For population = 35,000, we predict a profit of %f\n',...

    predict1*);

predict2 = [, ] * theta;

fprintf('For population = 70,000, we predict a profit of %f\n',...

    predict2*);

fprintf('Program paused. Press enter to continue.\n');

pause;

%% ============= Part : Visualizing J(theta_0, theta_1) =============

fprintf('Visualizing J(theta_0, theta_1) ...\n')

% Grid over which we will calculate J

theta0_vals = linspace(-, , );

theta1_vals = linspace(-, , );

% initialize J_vals to a matrix of 's

J_vals = zeros(length(theta0_vals), length(theta1_vals));

% Fill out J_vals

for i = :length(theta0_vals)

    for j = :length(theta1_vals)

      t = [theta0_vals(i); theta1_vals(j)];

      J_vals(i,j) = computeCost(X, y, t);

    end

end

% Because of the way meshgrids work in the surf command, we need to

% transpose J_vals before calling surf, or else the axes will be flipped

J_vals = J_vals';

% Surface plot

figure;

surf(theta0_vals, theta1_vals, J_vals)

xlabel('\theta_0'); ylabel('\theta_1');

% Contour plot

figure;

% Plot J_vals as  contours spaced logarithmically between 0.01 and

contour(theta0_vals, theta1_vals, J_vals, logspace(-, , ))

xlabel('\theta_0'); ylabel('\theta_1');

hold on;

plot(theta(), theta(), 'rx', 'MarkerSize', , 'LineWidth', );

function J = computeCost(X, y, theta)

m = length(y); 

J = ;

  ans=X*theta; %X*theta计算hθ(x)

  ans=(ans-y).^; %计算平方差成本函数

  J=sum(ans)/(*m); %计算所有样本m的代价

end

function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)

%GRADIENTDESCENT Performs gradient descent to learn theta

%   theta = GRADIENTDESCENT(X, y, theta, alpha, num_iters) updates theta by

%   taking num_iters gradient steps with learning rate alpha

% Initialize some useful values

m = length(y); % number of training examples

J_history = zeros(num_iters, );

for iter = :num_iters

    % ====================== YOUR CODE HERE ======================

    % Instructions: Perform a single gradient step on the parameter vector

    %               theta.

    %

    % Hint: While debugging, it can be useful to print out the values

    %       of the cost function (computeCost) and gradient here.

    %

     % ans1=theta()-sum((sum(X*theta,)-y).*X(:,))*alpha/m;

     % ans2=theta()-sum((sum(X*theta,)-y).*X(:,))*alpha/m;

     %  theta()=ans1;

     %  theta()=ans2;

      %梯度下降，X为(m,)，hθ(x)-y为(m,)，先将X转置

      theta=theta-((X')*(X*theta-y)).*(alpha/m); 

    % ============================================================

    % Save the cost J in every iteration

    J_history(iter) = computeCost(X, y, theta);

end

end

%% Machine Learning Online Class

%  Exercise : Linear regression with multiple variables

%

%  Instructions

%  ------------

%

%  This file contains code that helps you get started on the

%  linear regression exercise.

%

%  You will need to complete the following functions in this

%  exericse:

%

%     warmUpExercise.m

%     plotData.m

%     gradientDescent.m

%     computeCost.m

%     gradientDescentMulti.m

%     computeCostMulti.m

%     featureNormalize.m

%     normalEqn.m

%

%  For this part of the exercise, you will need to change some

%  parts of the code below for various experiments (e.g., changing

%  learning rates).

%

%% Initialization

%% ================ Part : Feature Normalization ================

%% Clear and Close Figures

clear ; close all; clc

fprintf('Loading data ...\n');

%% Load Data

data = load('ex1data2.txt');

X = data(:, :);

y = data(:, );

m = length(y);

% Print out some data points

fprintf('First 10 examples from the dataset: \n');

fprintf(' x = [%.0f %.0f], y = %.0f \n', [X(:,:) y(:,:)]');

fprintf('Program paused. Press enter to continue.\n');

pause;

% Scale features and set them to zero mean

fprintf('Normalizing Features ...\n');

[X mu sigma] = featureNormalize(X);

% Add intercept term to X

X = [ones(m, ) X]; %而外增加一列截距项为1的数据列

%% ================ Part : Gradient Descent ================

% ====================== YOUR CODE HERE ======================

% Instructions: We have provided you with the following starter

%               code that runs gradient descent with a particular

%               learning rate (alpha).

%

%               Your task is to first make sure that your functions -

%               computeCost and gradientDescent already work with

%               this starter code and support multiple variables.

%

%               After that, try running gradient descent with

%               different values of alpha and see which one gives

%               you the best result.

%

%               Finally, you should complete the code at the end

%               to predict the price of a  sq-ft,  br house.

%

% Hint: By using the 'hold on' command, you can plot multiple

%       graphs on the same figure.

%

% Hint: At prediction, make sure you do the same feature normalization.

%

fprintf('Running gradient descent ...\n');

% Choose some alpha value

alpha = 0.01;

num_iters = ;

% Init Theta and Run Gradient Descent

theta = zeros(, );

[theta, J_history] = gradientDescentMulti(X, y, theta, alpha, num_iters);

##alpha2 = 0.1;

##theta2 = zeros(, );

##[theta2, J2] = gradientDescentMulti(X, y, theta2, alpha2, num_iters);

##alpha3 = 0.9;

##theta3 = zeros(, );

##[theta3, J3] = gradientDescentMulti(X, y, theta3, alpha3, num_iters);

% Plot the convergence graph

figure;

plot(:numel(J_history), J_history, '-b', 'LineWidth', );

##plot(:, J_history(:), '-b', 'LineWidth', );

xlabel('Number of iterations');

ylabel('Cost J');

##hold on;

##plot(:,J2(:),'r');

##

##hold on;

##plot(:,J3(:),'k');

% Display gradient descent's result

fprintf('Theta computed from gradient descent: \n');

fprintf(' %f \n', theta);

fprintf('\n');

% Estimate the price of a  sq-ft,  br house

% ====================== YOUR CODE HERE ======================

% Recall that the first column of X is all-ones. Thus, it does

% not need to be normalized.

%预测房子1650平方，3个房间的价格

predict1=[ ];

predict1=(predict1.-mu)./sigma; %用测试数据的特征缩放的平均值与标准差的值

predict1=[ones(,) predict1];

fprintf(' %f \n', predict1);

price = predict1 *theta; % 预测价格

% ============================================================

fprintf(['Predicted price of a 1650 sq-ft, 3 br house ' ...

         '(using gradient descent):\n $%f\n'], price);

fprintf('Program paused. Press enter to continue.\n');

pause;

%% ================ Part : Normal Equations ================

fprintf('Solving with normal equations...\n');

% ====================== YOUR CODE HERE ======================

% Instructions: The following code computes the closed form

%               solution for linear regression using the normal

%               equations. You should complete the code in

%               normalEqn.m

%

%               After doing so, you should complete this code

%               to predict the price of a  sq-ft,  br house.

%

%% Load Data

data = csvread('ex1data2.txt');

X = data(:, :);

y = data(:, );

m = length(y);

% Add intercept term to X

X = [ones(m, ) X];

% Calculate the parameters from the normal equation

theta = normalEqn(X, y);

% Display normal equation's result

fprintf('Theta computed from the normal equations: \n');

fprintf(' %f \n', theta);

fprintf('\n');

% Estimate the price of a  sq-ft,  br house

% ====================== YOUR CODE HERE ======================

predict1=[  ];

price = predict1*theta; % 预测价格

% ============================================================

fprintf(['Predicted price of a 1650 sq-ft, 3 br house ' ...

         '(using normal equations):\n $%f\n'], price);

function [X_norm, mu, sigma] = featureNormalize(X)

%FEATURENORMALIZE Normalizes the features in X

%   FEATURENORMALIZE(X) returns a normalized version of X where

%   the mean value of each feature is  and the standard deviation

%   is . This is often a good preprocessing step to do when

%   working with learning algorithms.

% You need to set these values correctly

X_norm = X;

mu = zeros(, size(X, ));

sigma = zeros(, size(X, ));

% ====================== YOUR CODE HERE ======================

% Instructions: First, for each feature dimension, compute the mean

%               of the feature and subtract it from the dataset,

%               storing the mean value in mu. Next, compute the

%               standard deviation of each feature and divide

%               each feature by it's standard deviation, storing

%               the standard deviation in sigma.

%

%               Note that X is a matrix where each column is a

%               feature and each row is an example. You need

%               to perform the normalization separately for

%               each feature.

%

% Hint: You might find the 'mean' and 'std' functions useful.

%       

  mu=mean(X); %计算X每列的平均值

  sigma=std(X); %计算X每列的标准差

  X_norm=(X.-mu)./sigma; %特征缩放

% ============================================================

end

function J = computeCostMulti(X, y, theta)

%COMPUTECOSTMULTI Compute cost for linear regression with multiple variables

%   J = COMPUTECOSTMULTI(X, y, theta) computes the cost of using theta as the

%   parameter for linear regression to fit the data points in X and y

% Initialize some useful values

m = length(y); % number of training examples

% You need to return the following variables correctly

J = ;

% ====================== YOUR CODE HERE ======================

% Instructions: Compute the cost of a particular choice of theta

%               You should set J to the cost.

   ans=X*theta-y; %计算hθ(x)-y

   ans=(ans')*ans;  %计算(hθ(x)-y)^2

   % ans=ans.^; %或者是这样计算

   J=sum(ans)./(*m); %计算代价函数

% =========================================================================

end

function [theta, J_history] = gradientDescentMulti(X, y, theta, alpha, num_iters)

%GRADIENTDESCENTMULTI Performs gradient descent to learn theta

%   theta = GRADIENTDESCENTMULTI(x, y, theta, alpha, num_iters) updates theta by

%   taking num_iters gradient steps with learning rate alpha

% Initialize some useful values

m = length(y); % number of training examples

J_history = zeros(num_iters, );

for iter = :num_iters

    % ====================== YOUR CODE HERE ======================

    % Instructions: Perform a single gradient step on the parameter vector

    %               theta.

    %

    % Hint: While debugging, it can be useful to print out the values

    %       of the cost function (computeCostMulti) and gradient here.

    %

    theta=theta-((X')*(X*theta-y)).*(alpha/m);

    % ============================================================

    % Save the cost J in every iteration

    %每一次迭代计算代价函数保存，以后可作为可视化图

    J_history(iter) = computeCostMulti(X, y, theta);

end

end