# Water's Home

Just another Life Style

0%

## Basic Operations

If you want to build a large scale deployment of a learning algorithm, what people will often do is prototype and the language is Octave. Get your learning algorithms to work more quickly in Octave. Then overall you have a huge time savings by first developing the algorithms in Octave, and then implementing and maybe C++ or Java, only after we have the ideas working. Octave is nice because open sourced.* % : comment

• ~= : not equal
• ; : suppresses the print output
• DISP : For more complex printing

V=1：0.1：2 % it sets V to the bunch of elements that start from 1. And increments and steps of 0.1 until you get up to 2.

ones(2, 3) % generates a matrix that is a two by three matrix that is the matrix of all ones.

C = 2 * ones(2, 3) % that is all two’s.

w = zeros(1, 3) % that is all zero’s.

rand(3,3)

w = rand(1, 3) % normal random variable

hist % plot a histogram

help

## Moving Data Around

size(A) % the size of a matrix

size(A, 1) % the first dimension of A, size of the first dimension of A.

length(v) % the size of the longest dimension.

who % the variables that Octave has in memory currently

whos % the detailed view

clear featuresX

save hello.mat v % save the variable V into a file called hello.mat.

save hello.txt v -ascii % a human readable format

A(3,2)

A(2,:) % fetch everything in the second row.

A([1 3],:) % get all of the elements of A who’s first indexes one or three.

A = [A, [100, 101, 102]] % this will do is add another column vector to the right.

A(:) % put all elements with A into a single column vector

C = [A B] % taking these two matrices and just concatenating onto each other.

C = [A; B] % The semicolon notation means that I go put the next thing at the bottom.

There’s no point at all to try to memorize all these commands. It’s just, but what you should do is, hopefully from this video you have gotten a sense of the sorts of things you can do.

## Computing on Data

AxC % multiply 2 of matrices

A .* B % take each elements of A and multiply it by the corresponding elements of B.

A .^ 2 % the element wise squaring of A

1 ./ V % the element wise reciprocal of V

log(v) % an element wise logarithm of v

exp(v)

abs(V) % the element wise absolute value of V

-v % the same as -1 x V

v + ones(3,1) % this increments V by one.

v + 1 % another simpler way

A’ % the apostrophe symbol, a transpose of A

val=max(a) % set val equals max of A

[val, ind] = max(a) % val = the maximum value, ind = the index

a < 3 % a = [1 15 2 0.5], the result will be [1 0 1 1]

find(a < 3) % [1 3 4]

A = magic(3) % Returns this matrices called magic squares that all of their rows and columns and diagonals sum up to the same thing.

[r,c] = find( A>=7 ) % This finds all the elements of a that are greater than and equals to 7 and so, R C sense a row and column.

sum(a) % This adds up all the elements of A.

prod(a) % multiply them

floor(a) % Floor A rounds down

ceil(A) % rounded up

type(3) % sets a 3 by 3 matrix

max(A,[],1) % takes the column wise maximum

max(A,[],2) % takes the per row maximum

max(A) % it defaults to column

max(max(A)) % the maximum element in the entire matrix A

sum(A,1) % does a per column sum

sum(A,2) % do the row wise sum

eye(9) % nine identity matrix

sum(sum(A.*eye(9)) % the sum of these diagonal elements

flipup/flipud % Flip UD stands for flip up/down

pinv(A) % a pseudo inference

After running a learning algorithm, often one of the most useful things is to be able to look at your results, or to plot, or visualize your result.

## Plotting Data

Often, plots of the data or of all the learning algorithm outputs will also give you ideas for how to improve your learning algorithm.

t = [0:0.01:0.98]
y1 = sin(2 * pi * 4 * t)
plot(t, y1) % plot the sine function

y2 = cos(2 * pi * 4 * 4)
plot(t, y2)

hold on % figures on top of the old one

plot(t, y2, ‘r’) % different color

xlabel(‘time’) % label the X axis, or the horizontal axis
ylabel(‘value’)

legend(‘sin’, ‘cos’) % puts this legend up on the upper right showing what the 2 lines are

title(‘myplot’) % the title at the top of this figure

print -dpng ‘myplot.png’ % save figure

close % disappeared

figure(1); plot(t, y1); % Starts up first figure, and that plots t, y1.
figure(2); plot(t, y2);

subplot(1,2,1) % sub-divides the plot into a one-by-two grid with the first 2 parameters are
plot(t, y1) % fills up this first element
subplot(1,2,2)
plot(t, y2)

axis([0.5 1 -1 1]) % sets the x range and y range for the figure on the right

clf % clear

imagesc(A) % visualize the matrix and the different colors correspond to the different values in the A matrix.
colormap gray % color map gray

imagesc(magic(15))，colorbar，colormap gray % running three commands at a time

## Control Statements_ for, while, if statements

for i = 1 : 10,
v(i) = 2 ^ i;
end;

indices = 1 : 10;
for i = indices,
disp(i);
end;

i = 1;
while i <= 5,
v(i) = 100;
i = i + 1;
end;

i = 1;
while true,
v(i) = 999;
i = i + 1;
if i == 6,
break;
end;
end;

v(1) = 2;
if v(1) == 1,
disp(‘The value is one’);
elseif v(1) == 2,
disp(‘The value is two’);
else,
disp(‘The value is not one or two’);
end;

function name (arg-list)
body
endfunction

function wakeup (message)
printf (“\a%s\n”, message);
endfunction

wakeup (“Rise and shine!”);

function y = squareThisNumber(x)

[a, b] = SquareAndCubeThisNumber(5) % a = 25, b = 125

## Vectorization

#### Unvectorized implementation

$h_\theta (x) = \sum _{j=0}^{n} \theta _jx_j$

prediction = 0.0;
for j = 1 : n + 1,
prediction = prediction + theta(j) * x(j)
end;

#### Vectorized implementation

$h_\theta (x) = \theta ^Tx$

prediction = theta’ * x;

Using a vectorized implementation, you should be able to get a much more efficient implementation of linear regression.

## Working on and Submitting Programming Exercises

How to use the submission system which will let you verify right away that you got the right answer for your machine learning program exercise. If you are interested in details, you can visit coursera.org