Comparaison de la fonction fminunc avec la méthode BFGS pour la régression logistique

Question

Je construis un algorithme qui utilise la méthode BFGS pour trouver les paramètres dans une régression logistique pour un ensemble de données binaires dans Octave. Maintenant, je suis aux prises avec quelque chose que je crois être un problème de sur-apprentissage. Je lance l'algorithme pour plusieurs jeux de données et converge vers les mêmes résultats que la fonction fminunc d'Octave. Cependant, pour un "type de jeu de données" particulier, l'algorithme converge vers des valeurs très élevées des paramètres, contrairement à la fminunc qui donne des valeurs razonnables de ces paramètres. J'ai ajouté un terme de régularisation et j'ai effectivement atteint mon algorithme pour converger vers les mêmes valeurs de fminunc.

Ce type de jeu de données a des données qui peuvent être complètement séparées par une ligne droite. Ma question est: pourquoi est-ce un problème pour la méthode BFGS mais ce n'est pas un problème pour fminunc? Comment cette fonction évite-t-elle ce problème sans régularisation? Puis-je implémenter ceci dans mon algorithme?

Le code de mon algorithme est le suivant:

function [beta] = Log_BFGS(data, L_0) 
clc 
close 
%************************************************************************ 
%************************************************************************ 
%Loading the data: 
[n, e] = size(data); 
d = e - 1; 
n; %Number of observations. 
d; %Number of features. 
Y = data(:, e); %Labels´ values 
X_o = data(:, 1:d); 
X = [ones(n, 1) X_o]; %Features values    

%Initials conditions: 
beta_0 = zeros(e, 1); 

beta = []; 
beta(:, 1) = beta_0; 
N = 600; %Max iterations 
Tol = 1e-10; %Tolerance 
error = .1; 
L = L_0; %Regularization parameter 
B = eye(e); 

options = optimset('GradObj', 'on', 'MaxIter', 600); 
[beta_s] = fminunc(@(t)(costFunction(t, X, Y, L)), beta_0, options); 
disp('Beta obtained with the fminunc function'); 
disp("--------------"); 
disp(beta_s) 

k = 1; 
a_0 = 1; 
% Define the sigmoid function 
h = inline('1.0 ./ (1.0 + exp(-z))'); 

while (error > Tol && k < N) 
    beta_k = beta(:, k); 
    x_0 = X*beta_k; 
    h_0 = h(x_0); 
    beta_r = [0 ; beta(:, k)(2:e, :)]; 
    g_k = ((X)'*(h_0 - Y) + L*beta_r)/n; 
    d_k = -pinv(B)*g_k; 
    a = 0.1; %I´ll implement an Armijo line search here (soon) 
    beta(:, k+1) = beta(:, k) + a*d_k; 
    beta_k_1 = beta(:, k+1); 
    x_1 = X*beta_k_1; 
    h_1 = h(x_1); 
    beta_s = [0 ; beta(:, k+1)(2:e, :)]; 
    g_k_1 = (transpose(X)*(h_1 - Y) + L*beta_s)/n; 
    s_k = beta(:, k+1) - beta(:, k); 
    y_k = g_k_1 - g_k; 
    B = B - B*s_k*s_k'*B/(s_k'*B*s_k) + y_k*y_k'/(s_k'*y_k); 
    k = k + 1; 
    error = norm(d_k); 
endwhile 

%Accuracy of the logistic model: 

p = zeros(n, 1); 
for j = 1:n 
    if (1./(1. + exp(-1.*(X(j, :)*beta(:, k)))) >= 0.5) 
    p(j) = 1; 
    else 
    p(j) = 0; 
    endif 
endfor 
R = mean(double(p == Y)); 
beta = beta(:, k); 

%Showing the results: 

disp("Estimation of logistic regression model Y = 1/(1 + e^(beta*X)),") 
disp("using the algorithm BFGS =") 
disp("--------------") 
disp(beta) 
disp("--------------") 
disp("with a convergence error in the last iteration of:") 
disp(error) 
disp("--------------") 
disp("and a total number of") 
disp(k-1) 
disp("iterations") 
disp("--------------") 
if k == N 
    disp("The maximum number of iterations was reached before obtaining the desired error") 
else 
    disp("The desired error was reached before reaching the maximum of iterations") 
endif 
disp("--------------") 
disp("The precision of the logistic regression model is given by (max 1.0):") 
disp("--------------") 
disp(R) 
disp("--------------") 

endfunction 

Les résultats que j'ai obtenu pour l'ensemble de données sont montrées dans l'image ci-dessous. Si vous avez besoin des données utilisées dans cette situation, s'il vous plaît faites le moi savoir.

Results of the algorithm

Answer 1

Vérifiez les objectifs!

Les valeurs du vecteur-solution sont sympa, mais l'optimisation complète est guidée par l'objectif. Vous dites fminunc which gives reasonable values of these parameters, mais raisonnable n'est pas défini dans ce modèle. Il ne serait pas impossible que votre solution de faible valeur et votre solution de haute valeur permettent à peu près le même objectif. Et c'est ce que ces solveurs se soucient uniquement (en n'utilisant aucun terme de régulation). La question importante est donc la suivante: y a-t-il une solution unique (qui devrait interdire ces résultats)? Seulement quand votre ensemble de données a le rang complet! Alors peut-être que vos données sont insuffisantes et que vous obtenez deux solutions tout aussi bonnes. Bien sûr, il peut y avoir de légères différences dues aux problèmes numériques, qui sont toujours source d'erreurs, en particulier dans les algorithmes d'optimisation plus complexes.