La Descente de Gradient dans la mise en œuvre d'octave

En fait, j'ai lutté contre cette pour comme 2 mois maintenant. Qu'est-ce qui rend ces 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);

Les dernières œuvres. Je ne sais pas pourquoi..j'ai du mal à comprendre la nécessité de la matrice inverse .

Je ne pense pas que c'est une mise en œuvre correcte de descente de gradient. Vous devez mettre à jour. À la fois votre thetas dans le même temps, pour être précis. tmpTheta1= theta(1) - alpha * (1/m) * ((X * theta) - y)' * X(:, 1); tmpTheta2= theta(2) - alpha * (1/m) * ((X * theta) - y)' * X(:, 2); theta(1)=tmpTheta1; theta(2)=tmpTheta2;

InformationsquelleAutor narthur157 | 2012-05-14

octave

64

Ce que vous faites dans le premier exemple, dans le deuxième bloc, vous avez raté une étape, n'est-ce pas? Je suis en supposant que vous concaténées X par un vecteur de.
```
   temp=X(:,2) * temp
```
Le dernier exemple va fonctionner, mais peut être vectorisé encore plus pour être plus simple et efficace.

J'ai supposé vous avez seulement 1 fonctionnalité. il travaille de la même façon avec des fonctionnalités multiples, puisque tout ce qui arrive est que vous ajoutez une colonne supplémentaire pour votre X de la matrice de chacune des fonctions. Fondamentalement, vous ajoutez un vecteur de celles de x pour vectoriser l'ordonnée à l'origine.

Vous pouvez mettre à jour un 2x1 matrice de thetas en une seule ligne de code. Avec x concaténer un vecteur de ceux qui font un nx2 matrice ensuite, vous pouvez calculer h(x) en la multipliant par le theta vecteur (2x1), c'est (X * theta) bits.

La deuxième partie de la vectorisation consiste à transposer (X * theta) - y), ce qui vous donne un 1*n de la matrice qui, lorsqu'il est multiplié par X (n*2 de la matrice) sera essentiellement de regrouper à la fois (h(x)-y)x0 et h(x)-y)x1. Par définition, les deux thetas sont effectuées en même temps. Il en résulte une 1*2 de la matrice de mes nouvelles de theta, dont je viens de transposer de nouveau pour retourner vers le vecteur d'être les mêmes dimensions que le thêta vecteur. Je peux alors faire une simple multiplication scalaire par alpha et vecteur de la soustraction 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
```
- pourquoi avez-vous besoin de transposer (1/m) * ((X * theta) - y)' * X dans votre boucle for ?
- Même question que Grahm, pourquoi est-ce que l'ensemble de la sous-expression tranposed ?
- Le résultat de ((1/m) * ((X * theta) - y)' * X) est 1x2. theta est 2x1. Donc le bit entre crochets doit être transposée à avoir les mêmes dimensions et de la soustraire theta.
- Même question que ci-dessus. Il devrait être theta = theta (alpha/m) * X * (X * theta - y)
- Je pense que c'est en relation avec les règles pour le calcul de la matrice... A*B = produit de lignes par lignes B... je veux dire, sur le plan conceptuel, de son droit d'utiliser les formules générales pour gradient descendant, mais ensuite, quand vous jouez dans la matrice de champs, vous devez vous adapter à leurs propres règles (multiplication de lignes en lignes, commutative restrictions, etc.)... C'est juste mon avis, peut-être que je me trompe...
InformationsquelleAutor Shaun Ryan
8

Dans la première, si X une matrice 3x2 et thêta ont été un 2x1 la matrice, puis "hypothèses" serait un 3x1 de la matrice.

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

Puis le 1x3 matrice est définie à theta(2), mais cela ne devrait pas être une matrice.

Les deux dernières lignes de ton code fonctionne parce que, à l'aide de mon mxn exemples ci-dessus,
```
(X * theta)
```
serait un 3x1 de la matrice.

Alors que 3x1 matrice est soustrait par y (un 3x1 de la matrice), et le résultat est un 3x1 de la matrice.
```
(X * theta) - y
```
De sorte que la transposition de la 3x1 matrice est un 1x3 matrice.
```
((X * theta) - y)'
```
Enfin, un 1x3 matrice fois un 3x1 de la matrice sera égal à un scalaire ou 1x1 de la matrice, qui est ce que vous cherchez. Je suis sûr que tu le savais déjà, mais juste pour être complet, le X(:,2) est la deuxième colonne de la matrice 3x2, faisant d'elle une 3x1 de la matrice.

InformationsquelleAutor 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

InformationsquelleAutor 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

InformationsquelleAutor skeller88

2

Cela peut être vectorisé plus simplement avec des
```
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 X, est la matrice de conception, et en tant que tel, 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 la première composants) dans l'ensemble des exemples d'apprentissage. Chaque colonne de X est donc exactement la chose que nous voulons multiplier élément-sage avec le std_err en attendant d'obtenir la composante correspondante de la theta vecteur.

InformationsquelleAutor fpghost

-1

function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)
m = length(y); % number of training examples
J_history = zeros(num_iters, 1);
for iter = 1 : num_iters
    hypothesis = X * theta;
    Error = (hypothesis - y);
    temp = theta - ((alpha / m) * (Error' * X)');
    theta = temp;
    J_history(iter) = computeCost(X, y, theta);
end
end

veuillez expliquer comment cela répondre à la question

InformationsquelleAutor Pritha Majumder

-7

.
.
.
.
.
.
.
.
.
Spoiler alert












m = length(y); % number of training examples
J_history = zeros(num_iters, 1);

for iter = 1: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.
% ========================== BEGIN ===========================


t = zeros(2,1);
J = computeCost(X, y, theta);
t = theta - ((alpha*((theta'*X') - y'))*X/m)';
theta = t;
J1 = computeCost(X, y, theta);

if(J1>J),
    break,fprintf('Wrong alpha');
else if(J1==J)
    break;
end;


% ========================== END ==============================

% Save the cost J in every iteration    
J_history(iter) = sum(computeCost(X, y, theta));
end
end

l'idée est d'aider les utilisateurs à obtenir de l'avant, pas de post plein d'exemples réels exercices à la maison

InformationsquelleAutor user2696258

Vous devez vous connecter pour publier un commentaire.