Régularisation de régression logistique code en matlab

Je tente ma main à régulariser LR, simple avec cette formules dans matlab:

La fonction de coût:

J(theta) = 1/m*sum((-y_i)*log(h(x_i)-(1-y_i)*log(1-h(x_i))))+(lambda/2*m)*sum(theta_j)

Le gradient:

∂J(theta)/∂theta_0 = [(1/m)*(sum((h(x_i)-y_i)*x_j)] if j=0

∂j(theta)/∂theta_n = [(1/m)*(sum((h(x_i)-y_i)*x_j)]+(lambda/m)*(theta_j) if j>1

Ce n'est pas le code matlab est juste la formule.

Jusqu'à présent, j'ai fait ceci:

function [J, grad] = costFunctionReg(theta, X, y, lambda)
J = 0;
grad = zeros(size(theta));
temp_theta = [];
%cost function
%get the regularization term
for jj = 2:length(theta)
temp_theta(jj) = theta(jj)^2;
end
theta_reg = lambda/(2*m)*sum(temp_theta);
temp_sum =[];
%for the sum in the cost function
for ii =1:m
temp_sum(ii) = -y(ii)*log(sigmoid(theta'*X(ii,:)'))-(1-y(ii))*log(1-sigmoid(theta'*X(ii,:)'));
end
tempo = sum(temp_sum);
J = (1/m)*tempo+theta_reg;
%regulatization
%theta 0
reg_theta0 = 0;
for jj=1:m
reg_theta0(jj) = (sigmoid(theta'*X(m,:)') -y(jj))*X(jj,1)
end    
reg_theta0 = (1/m)*sum(reg_theta0)
grad_temp(1) = reg_theta0
%for the rest of thetas
reg_theta  = [];
thetas_sum = 0;
for ii=2:size(theta)
for kk =1:m
reg_theta(kk) = (sigmoid(theta'*X(m,:)') - y(kk))*X(kk,ii)
end
thetas_sum(ii) = (1/m)*sum(reg_theta)+(lambda/m)*theta(ii)
reg_theta = []
end
for i=1:size(theta)
if i == 1
grad(i) = grad_temp(i)
else
grad(i) = thetas_sum(i)
end
end
end

Et de la fonction de coût est de donner des résultats corrects, mais je n'ai aucune idée pourquoi le gradient (une seule étape) n'est pas, le coût donne J = 0.6931 qui est correct et que le gradient grad = 0.3603 -0.1476 0.0320, ce qui ne l'est pas, le coût commence à partir de 2 parce que le paramètre thêta(1) n'ont pas à être régularisés, toute aide? Je pense qu'il y a quelque chose de mal avec le code, mais au bout de 4 jours je ne peux pas le voir.Grâce

OriginalL'auteur Pedro.Alonso | 2013-11-06

38

Vectorisé:
```
function [J, grad] = costFunctionReg(theta, X, y, lambda)
hx = sigmoid(X * theta);
m = length(X);
J = (sum(-y' * log(hx) - (1 - y')*log(1 - hx)) / m) + lambda * sum(theta(2:end).^2) / (2*m);
grad =((hx - y)' * X / m)' + lambda .* theta .* [0; ones(length(theta)-1, 1)] ./ m ;
end
```
pouvez-vous svp m'expliquer quel est l'importance de l'ajout du terme de régularisation +lambda * sum(theta(2:end).^2) / (2*m) dans J que nous sommes en train de initial_theta = zeros(size(X, 2), 1); le terme lorsqu'il est multiplié donne de la valeur à 0 Donc, quel est le point parce que la Fonction de coût doit rester la même...
sont 0 la première fois que vous appelez costFunctionReg, mais après la première itération, ils sont va être changé.
juste pour souligner que J = (sum(... ici en premier sum est inutile parce que son argument a déjà dimension {1x1}, qui est juste un nombre.
Cela fonctionne! Merci.
suis-je en droit de penser que dans [ ((hx - y)' * X / m)' + lambda .* theta .* [0; ones(length(theta)-1, 1)] ./ m ] l'opérateur .* n'est nécessaire entre thêta et [0, (... )] sinon, simple * est-ce assez?

OriginalL'auteur Franck Dernoncourt

J'ai utilisé plus de variables, de sorte que vous pourriez voir clairement ce qui vient de la formule standard, et ce qui vient de "la régularisation de la situation des coûts ajoutée". En outre, Il est une bonne pratique d'utiliser "vectorisation" au lieu de boucles dans Matlab/Octave. En faisant cela, vous garantie une plus solution optimisée.

 function [J, grad] = costFunctionReg(theta, X, y, lambda)
%Hypotheses
hx = sigmoid(X * theta);
%%The cost without regularization
J_partial = (-y' * log(hx) - (1 - y)' * log(1 - hx)) ./ m;
%%Regularization Cost Added
J_regularization = (lambda/(2*m)) * sum(theta(2:end).^2);
%%Cost when we add regularization
J = J_partial + J_regularization;
%Grad without regularization
grad_partial = (1/m) * (X' * (hx -y));
%%Grad Cost Added
grad_regularization = (lambda/m) .* theta(2:end);
grad_regularization = [0; grad_regularization];
grad = grad_partial + grad_regularization;

bien,belle réponse qu'il doit être regularization, 🙂
Merci! J'ai oublié de le modifier avant 😉

OriginalL'auteur Fernando Cardenas

Finalement obtenu, après avoir à le réécrire encore une fois comme pour la 4ème fois, c'est le bon code:

function [J, grad] = costFunctionReg(theta, X, y, lambda)
J = 0;
grad = zeros(size(theta));
temp_theta = [];
for jj = 2:length(theta)
temp_theta(jj) = theta(jj)^2;
end
theta_reg = lambda/(2*m)*sum(temp_theta);
temp_sum =[];
for ii =1:m
temp_sum(ii) = -y(ii)*log(sigmoid(theta'*X(ii,:)'))-(1-y(ii))*log(1-sigmoid(theta'*X(ii,:)'));
end
tempo = sum(temp_sum);
J = (1/m)*tempo+theta_reg;
%regulatization
%theta 0
reg_theta0 = 0;
for i=1:m
reg_theta0(i) = ((sigmoid(theta'*X(i,:)'))-y(i))*X(i,1)
end
theta_temp(1) = (1/m)*sum(reg_theta0)
grad(1) = theta_temp
sum_thetas = []
thetas_sum = []
for j = 2:size(theta)
for i = 1:m
sum_thetas(i) = ((sigmoid(theta'*X(i,:)'))-y(i))*X(i,j)
end
thetas_sum(j) = (1/m)*sum(sum_thetas)+((lambda/m)*theta(j))
sum_thetas = []
end
for z=2:size(theta)
grad(z) = thetas_sum(z)
end
% =============================================================
end

Si son aide à quelqu'un, ou quelqu'un a des commentaires sur la façon dont je peux faire mieux. 🙂

Merci, pourriez-vous exlpain? 1. Pourquoi nous sommes skiping theta(1) ici, pour un coût J? 2. Pourquoi nous sommes ignorant lambda/m*theta pour grad(1)?
Si je me souviens correctement en regardant le code theta(1) n'est pas ignorée, est calculée de la seule, je l'ai vu comme plus facile. Et la deuxième question, je ne suis pas sûr de ce que je tente d'accomplir.
Je crois que grad(1) est ignorée de régularisation, car il correspond au poids de la colonne de 1s que vous êtes en train d'ajouter aux données

OriginalL'auteur Pedro.Alonso

Ici est une réponse qui élimine les boucles

m = length(y); % number of training examples
predictions = sigmoid(X*theta);
reg_term = (lambda/(2*m)) * sum(theta(2:end).^2);
calcErrors = -y.*log(predictions) - (1 -y).*log(1-predictions);
J = (1/m)*sum(calcErrors)+reg_term;
% prepend a 0 column to our reg_term matrix so we can use simple matrix addition
reg_term = [0 (lambda*theta(2:end)/m)'];
grad = sum(X.*(predictions - y)) / m + reg_term;

OriginalL'auteur Rick

Vous devez vous connecter pour publier un commentaire.