web-dev-qa-db-fra.com

Implémentation de Gradient Descent en octave

Je lutte contre cela depuis 2 mois maintenant. Qu'est-ce qui les rend différents?

hypotheses= X * theta
temp=(hypotheses-y)'
temp=X(:,1) * temp
temp=temp * (1 / m)
temp=temp * alpha
theta(1)=theta(1)-temp

hypotheses= X * theta
temp=(hypotheses-y)'
temp=temp * (1 / m)
temp=temp * alpha
theta(2)=theta(2)-temp



theta(1) = theta(1) - alpha * (1/m) * ((X * theta) - y)' * X(:, 1);
theta(2) = theta(2) - alpha * (1/m) * ((X * theta) - y)' * X(:, 2);

Ce dernier fonctionne. Je ne sais pas pourquoi. J'ai du mal à comprendre le besoin de l'inverse de la matrice.

octave
36
narthur157

Ce que vous faites dans le premier exemple du deuxième bloc, vous avez manqué une étape, n'est-ce pas? Je suppose que vous avez concaténé X avec un vecteur de uns.

   temp=X(:,2) * temp

Le dernier exemple fonctionnera mais peut être vectorisé encore plus pour être plus simple et efficace.

Je suppose que vous n'avez qu'une seule fonctionnalité. cela fonctionnera de la même manière avec plusieurs fonctionnalités, car il ne vous reste qu'à ajouter une colonne supplémentaire à votre matrice X pour chaque fonctionnalité. Fondamentalement, vous ajoutez un vecteur de uns à x pour vectoriser l'interception.

Vous pouvez mettre à jour une matrice 2x1 de thetas dans une ligne de code. Avec x concaténer un vecteur de ceux qui en font une matrice nx2 alors vous pouvez calculer h(x) en multipliant par le vecteur thêta (2x1), ceci est (X * thêta) bit.

La deuxième partie de la vectorisation consiste à transposer (X * thêta) - y) qui vous donne une matrice 1 * n qui, multipliée par X (une matrice n * 2), agrégera essentiellement les deux (h (x) -y) x0 et (h (x) -y) x1. Par définition, les deux thetas se font en même temps. Il en résulte une matrice 1 * 2 de mes nouveaux thêtas que je viens de transposer à nouveau pour retourner autour du vecteur pour avoir les mêmes dimensions que le vecteur thêta. Je peux ensuite faire une simple multiplication scalaire par soustraction alpha et vectorielle avec thêta.

X = data(:, 1); y = data(:, 2);
m = length(y);
X = [ones(m, 1), data(:,1)]; 
theta = zeros(2, 1);        

iterations = 2000;
alpha = 0.001;

for iter = 1:iterations
     theta = theta -((1/m) * ((X * theta) - y)' * X)' * alpha;
end
65
Shaun Ryan

Dans le premier, si X était une matrice 3x2 et thêta était une matrice 2x1, alors les "hypothèses" seraient une matrice 3x1.

En supposant que y est une matrice 3x1, alors vous pouvez effectuer (hypothèses - y) et obtenir une matrice 3x1, puis la transposition de cette 3x1 est une matrice 1x3 affectée à temp.

Ensuite, la matrice 1x3 est définie sur thêta (2), mais cela ne doit pas être une matrice.

Les deux dernières lignes de votre code fonctionnent car, en utilisant mes exemples mxn ci-dessus,

(X * theta)

serait une matrice 3x1.

Ensuite, cette matrice 3x1 est soustraite de y (une matrice 3x1) et le résultat est une matrice 3x1.

(X * theta) - y

La transposition de la matrice 3x1 est donc une matrice 1x3.

((X * theta) - y)'

Enfin, une matrice 1x3 fois une matrice 3x1 équivaudra à une matrice scalaire ou 1x1, ce que vous recherchez. Je suis sûr que vous le saviez déjà, mais juste pour être complet, le X (:, 2) est la deuxième colonne de la matrice 3x2, ce qui en fait une matrice 3x1.

9
Justin Nafe

Lorsque vous mettez à jour, vous devez faire comme

Start Loop {

temp0 = theta0 - (equation_here);

temp1 = theta1 - (equation_here);


theta0 =  temp0;

theta1 =  temp1;

} End loop
4
hbr
function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)
% Performs gradient descent to learn theta. Updates theta by taking num_iters 
% gradient steps with learning rate alpha.

% Number of training examples
m = length(y); 
% Save the cost J in every iteration in order to plot J vs. num_iters and check for convergence 
J_history = zeros(num_iters, 1);

for iter = 1:num_iters
    h = X * theta;
    stderr = h - y;
    theta = theta - (alpha/m) * (stderr' * X)';
    J_history(iter) = computeCost(X, y, theta);
end

end
4
skeller88

Cela peut être vectorisé plus simplement avec

h = X * theta   % m-dimensional matrix (prediction our hypothesis gives per training example)
std_err = h - y  % an m-dimensional matrix of errors (one per training example)
theta = theta - (alpha/m) * X' * std_err

Rappelez-vous que X, est la matrice de conception, et en tant que telle, chaque ligne de X représente un exemple d'apprentissage et chaque colonne de X représente un composant donné (disons le zéro ou les premiers composants ) dans tous les exemples de formation. Chaque colonne de X est donc exactement ce que nous voulons multiplier élément par élément avec le std_err avant de sommer pour obtenir la composante correspondante du vecteur thêta.

2
fpghost