La Fonction de coût, de Régression Linéaire, en essayant d'éviter le codage en dur des thêta. Octave.

Je suis dans la deuxième semaine de Professeur Andrew Ng lavable en cours d'Apprentissage par le biais de Coursera. Nous travaillons sur la régression linéaire et maintenant je m'occupe du codage de la fonction de coût.

Le code que j'ai écrit résout le problème correctement, mais ne passe pas le processus de soumission et d'échec de l'unité de test parce que j'ai codé en dur les valeurs de theta et ne permet pas, pour plus de deux valeurs de thêta.

Voici le code que j'ai obtenu jusqu'à présent

function J = computeCost(X, y, theta)

m = length(y);
J = 0;

for i = 1:m,
    h = theta(1) + theta(2) * X(i)
    a = h - y(i);
    b = a^2;
    J = J + b;
    end;
J = J * (1 / (2 * m));

end

l'unité de test est

computeCost( [1 2 3; 1 3 4; 1 4 5; 1 5 6], [7;6;5;4], [0.1;0.2;0.3])

et devrait produire des ans = 7.0175

J'ai donc besoin d'ajouter une autre boucle for pour parcourir thêta, ce qui permet donc à n'importe quel nombre de valeurs de thêta, mais que je sois damné si je peux envelopper ma tête autour de comment/où.

Quelqu'un peut-il suggérer une façon de me permettre pour n'importe quel nombre de valeurs de thêta au sein de cette fonction?

Si vous avez besoin de plus d'informations pour comprendre ce que j'essaie de poser la question, je vais essayer de mon mieux pour fournir.

InformationsquelleAutor Faulty | 2014-03-25

69

Vous pouvez utiliser vectoriser des opérations dans l'Octave/Matlab.
Itérer sur l'ensemble de vecteur - il est vraiment une mauvaise idée, si votre programme de langue laissez-vous vectoriser des opérations.
R, Octave, Matlab, Python (numpy) autoriser cette opération.
Par exemple, vous pouvez obtenir scalaire de production, si theta = (t0, t1, t2, t3) et X = (x0, x1, x2, x3) de la façon suivante:
theta * X' = (t0, t1, t2, t3) * (x0, x1, x2, x3)' = t0*x0 + t1*x1 + t2 x2 + t3*x3
Le résultat sera scalaire.

Par exemple, vous pouvez vectoriser h dans le code de la manière suivante:
```
H = (theta'*X')';
S = sum((H - y) .^ 2);
J = S / (2*m);
```
- Avez-vous pu le faire avec la boucle de là? Et si j'ai bien lu ce que vous avez écrit (theta transposer * X transposer)transposer.
- Oui, ces trois lignes de code, remplacer la totalité de la boucle! Et donc, il transpose (j'utilise Octave de la syntaxe)
- Je pense que vous avez utilisé des majuscules pour les variables ici comme une question de convention de nommage de la matrice des variables, donc merci de me le rappeler à ce sujet. Ce que je ne comprends pas, c'est dans la ligne "S = sum((H - y).^2);" ce qui est le "."? Je sais que je l'ai vu avant mais je ne me souviens pas de son but.
- le point dans la matrice ariphmetic utiliser pour l'élément par élément des opérations. Par exemple: A = [ 1 2 ; 3 4 ] B = [ 3 4 ; 1 2 ] Ainsi, A*B = [ 5 8 ; 13 20 ] (c'est à dire généralement la multiplication de matrice) A.*B = [ 3 8 ; 3 8 ] (c'est à dire l'élément par élément de multiplication - [ 1*3 2*4 ; 3*1 4*2] de la Même façon: A.^2 = [1^2 2^2 ; 3^2 4^2 ] = [1 4 ; 9 16 ]
- OK, il m'a fallu un moment pour comprendre pourquoi ce code fonctionne, mais il n'. Merci.
- Pourquoi n'utilisez-vous pas "ceux(1,97)' * ((X*theta)-y).^2"?
- la façon dont vous avez créé H est un chef-d'œuvre absolument
InformationsquelleAutor Simplex
26

La réponse ci-dessus est parfait, mais vous pouvez aussi le faire
```
H = (X*theta);
S = sum((H - y) .^ 2);
J = S / (2*m);
```
Plutôt que de l'informatique
```
(theta' * X')'
```
et puis en prenant la transposer, vous pouvez calculer directement
```
(X * theta)
```
Il fonctionne parfaitement.
- Merci pour vos commentaires.
- Pourquoi avez-vous besoin des parenthèses autour de X*theta?
- Vous n'avez pas besoin. J'ai cette habitude de mettre des parenthèse juste pour éviter toute confusion en cas de grandes expressions.
- Juste pour être clair, l'égalité X*theta = (theta'*X')' détient, car les deux identités : (A')' = A et A' * B' = (BA)'. Si juste de le prendre (theta' * X') = (X * theta) " ce, transposée, donne ((X * theta)')' qui est égale à X * theta.
- Ce que je suis confus, c'est que dans l'équation H(x), on a que H(x) = theta' * X, mais il me semble que nous avons à prendre la transposition de que lors de la mise en œuvre dans le code, mais pourquoi
- Je suis aussi très curieux de connaître la réponse à rasen58 de la question, même si il a été demandé il y a longtemps.
- Si encore quelqu'un se soucie de cela, j'ai eu le même problème lorsque j'essaie de mettre en œuvre cette.. en gros ce que j'ai découvert, est dans la fonction de coût de l'équation, nous avons theta' * x. Lorsque nous mettons en œuvre la fonction, nous n'avons pas de x, nous avons la fonction de la matrice X. x est un vecteur, X est une matrice dont chaque ligne est un vecteur x transposée. Donc, c'est là que le supplément de transposer les opérations de viennent de.
- Merci pour la clarification. ( J'ai atteint cette page, après googler "thêta transposer x") 🙂
InformationsquelleAutor caped114
9

La ligne ci-dessous retourne pas le 32.07 valeur de coût, tandis que nous courons computeCost fois à l'aide de θ initialisé à zéros:
```
J = (1/(2*m)) * (sum(((X * theta) - y).^2));
```
et est semblable à l'original des formules qui leur est donnée ci-dessous.

InformationsquelleAutor user3352632
2

Il peut également se faire en ligne
m- # formation ensembles
```
J=(1/(2*m)) * ((((X * theta) - y).^2)'* ones(m,1));
```
- est-il nécessaire de multiplier avec(m,1) ?
InformationsquelleAutor prajnan2k
0
```
J = sum(((X*theta)-y).^2)/(2*m);
ans =  32.073
```
La réponse ci-dessus est parfait,je pensais que le problème profondément pour une journée et encore peu familiers avec l'Octave,donc,il suffit d'étudier ensemble!
- Bien sûr,avec plaisir.Il est basé sur la fonction de coût et utilise la multiplication de matrice,plutôt qu'explicite sommation ou en boucle.
- Je ne sais pas qui vous a donné "-" mais c'est aussi une solution, je suis venu avec. C'est plus propre, je crois plus efficace. obtenu 100%.
InformationsquelleAutor Jessica
0

Si vous souhaitez utiliser uniquement de la matrice, de sorte que:
```
temp = (X * theta - y);        % h(x) - y
J = ((temp')*temp)/(2 * m);
clear temp;
```
InformationsquelleAutor Konstantin Zyryanov
0
```
function J = computeCost(X, y, theta)

m = length(y);

J = 0;

% Hypothesis h(x)
h = X * theta;

% Error function (h(x) - y) ^ 2
squaredError = (h-y).^2;

% Cost function
J = sum(squaredError)/(2*m);

end
```
- Merci de ne pas poster de code seulement comme une réponse. Ce n'est pas utile. Veuillez prendre le temps de fournir de haute qualité des réponses. Note: "Cette réponse a été signalée comme étant de faible qualité en raison de sa longueur et son contenu.". Si vous n'avez pas d'améliorer la qualité de votre réponse, ce post peut être supprimé.
- href="https://meta.stackoverflow.com/q/256359/6296561">faux.
- Quel est le problème? J'ai juste informé l'auteur que son poste a été signalée comme étant de faible qualité et probablement sera supprimé. Poster du code, sans aucune explication n'est pas une bonne réponse. Je n'ai pas de drapeau bien. C'était juste censé être un bon conseil.
InformationsquelleAutor Shakir
-3

Je pense que nous avions besoin d'utiliser d'itération pour beaucoup de solution générale pour le coût de plutôt une itération, aussi le résultat s'affiche dans le fichier PDF 32.07 peut-être pas réponse correcte que le correcteur est à la recherche de la raison d'être de son un cas de beaucoup de données d'entraînement.

Je pense qu'il devrait en boucle comme ceci
```
  for i in 1:iteration
  theta = theta - alpha*(1/m)(theta'*x-y)*x

  j = (1/(2*m))(theta'*x-y)^2
```
- La vectorisation de votre code est la meilleure façon de résoudre les opérations matricielles de l'itération de la matrice au cours d'une boucle for.
InformationsquelleAutor Gautam Karmakar

Vous devez vous connecter pour publier un commentaire.