web-dev-qa-db-ja.com

オクターブ：ロジスティック回帰：fmincgとfminuncの違い

ロジスティック回帰の問題にはfminuncをよく使用します。 Andrew Ng は同じ引数でfmincgの代わりにfminuncを使用することをWebで読みました。結果は異なり、多くの場合、fmincgはより正確ですが、あまり多くありません。 （fmincg関数fminuncの結果を同じデータと比較しています）

だから、私の質問は次のとおりです。これら2つの機能の違いは何ですか？各機能はどのアルゴリズムを実装していますか？ （現在、これらの関数を使用する方法を正確に知らずにこれらの関数を使用しています）。

ありがとう：）

algorithmmachine-learningneural-networkoctave
41
hqt

Octaveの一部ではないため、fmincgのコード内を調べる必要があります。いくつかの検索の後、宿題の一部としてCourseraのMachine Learningクラスによって提供される関数ファイルであることがわかりました。アルゴリズムに関する議論については、 この質問 のコメントと回答を読んでください。

41
carandraug

ここでの他の回答とは対照的に、fmincgとfminuncの主な違いは精度または速度であると示唆していますが、一部のアプリケーションで最も重要な違いはおそらくメモリ効率です。 CourseraのAndrew Ngの機械学習クラスのプログラミング演習4（ニューラルネットワークトレーニング）で、fmincgに関するex4.mのコメントは

%% ===================パート8：NNのトレーニング===================
％これで、ニューラルのトレーニングに必要なすべてのコードを実装しました。
％ 通信網。ニューラルネットワークをトレーニングするために、「fmincg」を使用します。
％は、「fminunc」と同様に機能する関数です。これらを思い出してください
％の高度なオプティマイザーは、コスト関数を次のように効率的にトレーニングできます。
％勾配計算を提供する限り。

元のポスターのように、fmincgの代わりにfminuncを使用してex4.mの結果がどのように異なるかについても興味がありました。だから私はfmincg呼び出しを置き換えようとしました

options = optimset('MaxIter', 50);
[nn_params, cost] = fmincg(costFunction, initial_nn_params, options);

次のfminuncの呼び出し

options = optimset('GradObj', 'on', 'MaxIter', 50);
[nn_params, cost, exit_flag] = fminunc(costFunction, initial_nn_params, options);

しかし、Windowsで実行されているOctaveの32ビットビルドから次のエラーメッセージが表示されました。

エラー：メモリが使い果たされるか、Octaveのインデックスタイプの範囲に対して要求されたサイズが大きすぎる-プロンプトに戻ろう

Windows上で実行されるMATLABの32ビットビルドは、より詳細なエラーメッセージを提供します。

検索の使用エラー
メモリ不足です。オプションにHELP MEMORYと入力します。
sponesのエラー（14行目）
[i、j] = find（S）;
色のエラー（26行目）
J = spones（J）;
sfminbxのエラー（行155）
group = color（Hstr、p）;
fminuncのエラー（行408）
[x、FVAL、〜、EXITFLAG、OUTPUT、GRAD、HESSIAN] = sfminbx（funfcn、x、l、u、...
ex4のエラー（205行目）
[nn_params、cost、exit_flag] = fminunc（costFunction、initial_nn_params、options）;

私のラップトップコンピューターのMATLABメモリコマンドは次を報告します。

可能な最大配列：2046 MB（2.146e + 09バイト）*
すべてのアレイで使用可能なメモリ：3402 MB（3.568e + 09バイト）**
MATLABが使用するメモリ：373 MB（3.910e + 08バイト）
物理メモリ（RAM）：3561 MB（3.734e + 09バイト）
*利用可能な連続した仮想アドレス空間によって制限されます。
**利用可能な仮想アドレス空間によって制限されます。

Ng教授はfmincgを使用してex4.mニューラルネットワーク（バイアス入力を含む401の入力機能を持つ400）をトレーニングして、トレーニング速度を上げることを選択したと以前考えていました。ただし、fmincgを使用する彼の理由は、32ビットビルドのOctave/MATLABでトレーニングを実行できるようにメモリの効率を十分に高めることであると考えています。 Windows OS上で実行されるOctaveの64ビットビルドを取得するために必要な作業についての簡単な説明は here。 です。

23
gregS

Andrew Ng自身によると、fmincgはより正確な結果を得るために使用されません（どちらの場合でもコスト関数は同じであり、仮説はより単純でも複雑でもないことを思い出してください）特に複雑な仮説のために勾配降下を行う。彼自身は、仮説に特徴がほとんどないfminuncを使用しているようですが、数百個あるfmincgを使用しているようです。

12
Edward Dixon

Fmincgが機能する理由

以下に、使用されているさまざまなアルゴリズムを説明するコメント付きのソースコードのコピーを示します。犬と椅子を区別することを学ぶときに子供の脳が行うのと同じことを行うので、それはすごいです。

これは、fmincg.mのオクターブソースです。

function [X, fX, i] = fmincg(f, X, options, P1, P2, P3, P4, P5)
% Minimize a continuous differentialble multivariate function. Starting point
% is given by "X" (D by 1), and the function named in the string "f", must
% return a function value and a vector of partial derivatives. The Polack-
% Ribiere flavour of conjugate gradients is used to compute search directions,
% and a line search using quadratic and cubic polynomial approximations and the
% Wolfe-Powell stopping criteria is used together with the slope ratio method
% for guessing initial step sizes. Additionally a bunch of checks are made to
% make sure that exploration is taking place and that extrapolation will not
% be unboundedly large. The "length" gives the length of the run: if it is
% positive, it gives the maximum number of line searches, if negative its
% absolute gives the maximum allowed number of function evaluations. You can
% (optionally) give "length" a second component, which will indicate the
% reduction in function value to be expected in the first line-search (defaults
% to 1.0). The function returns when either its length is up, or if no further
% progress can be made (ie, we are at a minimum, or so close that due to
% numerical problems, we cannot get any closer). If the function terminates
% within a few iterations, it could be an indication that the function value
% and derivatives are not consistent (ie, there may be a bug in the
% implementation of your "f" function). The function returns the found
% solution "X", a vector of function values "fX" indicating the progress made
% and "i" the number of iterations (line searches or function evaluations,
% depending on the sign of "length") used.
%
% Usage: [X, fX, i] = fmincg(f, X, options, P1, P2, P3, P4, P5)
%
% See also: checkgrad
%
% Copyright (C) 2001 and 2002 by Carl Edward Rasmussen. Date 2002-02-13
%
%
% (C) Copyright 1999, 2000 & 2001, Carl Edward Rasmussen
%
% Permission is granted for anyone to copy, use, or modify these
% programs and accompanying documents for purposes of research or
% education, provided this copyright notice is retained, and note is
% made of any changes that have been made.
%
% These programs and documents are distributed without any warranty,
% express or implied.  As the programs were written for research
% purposes only, they have not been tested to the degree that would be
% advisable in any important application.  All use of these programs is
% entirely at the user's own risk.
%
% [ml-class] Changes Made:
% 1) Function name and argument specifications
% 2) Output display
%

% Read options
if exist('options', 'var') && ~isempty(options) && isfield(options, 'MaxIter')
    length = options.MaxIter;
else
    length = 100;
end

RHO = 0.01;                            % a bunch of constants for line searches
SIG = 0.5;       % RHO and SIG are the constants in the Wolfe-Powell conditions
INT = 0.1;    % don't reevaluate within 0.1 of the limit of the current bracket
EXT = 3.0;                    % extrapolate maximum 3 times the current bracket
MAX = 20;                         % max 20 function evaluations per line search
RATIO = 100;                                      % maximum allowed slope ratio

argstr = ['feval(f, X'];                      % compose string used to call function
for i = 1:(nargin - 3)
  argstr = [argstr, ',P', int2str(i)];
end
argstr = [argstr, ')'];

if max(size(length)) == 2, red=length(2); length=length(1); else red=1; end
S=['Iteration '];

i = 0;                                            % zero the run length counter
ls_failed = 0;                             % no previous line search has failed
fX = [];
[f1 df1] = eval(argstr);                      % get function value and gradient
i = i + (length<0);                                            % count epochs?!
s = -df1;                                        % search direction is steepest
d1 = -s'*s;                                                 % this is the slope
z1 = red/(1-d1);                                  % initial step is red/(|s|+1)

while i < abs(length)                                      % while not finished
  i = i + (length>0);                                      % count iterations?!

  X0 = X; f0 = f1; df0 = df1;                   % make a copy of current values
  X = X + z1*s;                                             % begin line search
  [f2 df2] = eval(argstr);
  i = i + (length<0);                                          % count epochs?!
  d2 = df2'*s;
  f3 = f1; d3 = d1; z3 = -z1;             % initialize point 3 equal to point 1
  if length>0, M = MAX; else M = min(MAX, -length-i); end
  success = 0; limit = -1;                     % initialize quanteties
  while 1
    while ((f2 > f1+z1*RHO*d1) | (d2 > -SIG*d1)) & (M > 0)
      limit = z1;                                         % tighten the bracket
      if f2 > f1
        z2 = z3 - (0.5*d3*z3*z3)/(d3*z3+f2-f3);                 % quadratic fit
      else
        A = 6*(f2-f3)/z3+3*(d2+d3);                                 % cubic fit
        B = 3*(f3-f2)-z3*(d3+2*d2);
        z2 = (sqrt(B*B-A*d2*z3*z3)-B)/A;       % numerical error possible - ok!
      end
      if isnan(z2) | isinf(z2)
        z2 = z3/2;                  % if we had a numerical problem then bisect
      end
      z2 = max(min(z2, INT*z3),(1-INT)*z3);  % don't accept too close to limits
      z1 = z1 + z2;                                           % update the step
      X = X + z2*s;
      [f2 df2] = eval(argstr);
      M = M - 1; i = i + (length<0);                           % count epochs?!
      d2 = df2'*s;
      z3 = z3-z2;                    % z3 is now relative to the location of z2
    end
    if f2 > f1+z1*RHO*d1 | d2 > -SIG*d1
      break;                                                % this is a failure
    elseif d2 > SIG*d1
      success = 1; break;                                             % success
    elseif M == 0
      break;                                                          % failure
    end
    A = 6*(f2-f3)/z3+3*(d2+d3);                      % make cubic extrapolation
    B = 3*(f3-f2)-z3*(d3+2*d2);
    z2 = -d2*z3*z3/(B+sqrt(B*B-A*d2*z3*z3));        % num. error possible - ok!
    if ~isreal(z2) | isnan(z2) | isinf(z2) | z2 < 0   % num prob or wrong sign?
      if limit < -0.5                               % if we have no upper limit
        z2 = z1 * (EXT-1);                 % the extrapolate the maximum amount
      else
        z2 = (limit-z1)/2;                                   % otherwise bisect
      end
    elseif (limit > -0.5) & (z2+z1 > limit)          % extraplation beyond max?
      z2 = (limit-z1)/2;                                               % bisect
    elseif (limit < -0.5) & (z2+z1 > z1*EXT)       % extrapolation beyond limit
      z2 = z1*(EXT-1.0);                           % set to extrapolation limit
    elseif z2 < -z3*INT
      z2 = -z3*INT;
    elseif (limit > -0.5) & (z2 < (limit-z1)*(1.0-INT))   % too close to limit?
      z2 = (limit-z1)*(1.0-INT);
    end
    f3 = f2; d3 = d2; z3 = -z2;                  % set point 3 equal to point 2
    z1 = z1 + z2; X = X + z2*s;                      % update current estimates
    [f2 df2] = eval(argstr);
    M = M - 1; i = i + (length<0);                             % count epochs?!
    d2 = df2'*s;
  end                                                      % end of line search

  if success                                         % if line search succeeded
    f1 = f2; fX = [fX' f1]';
    fprintf('%s %4i | Cost: %4.6e\r', S, i, f1);
    s = (df2'*df2-df1'*df2)/(df1'*df1)*s - df2;      % Polack-Ribiere direction
    tmp = df1; df1 = df2; df2 = tmp;                         % swap derivatives
    d2 = df1'*s;
    if d2 > 0                                      % new slope must be negative
      s = -df1;                              % otherwise use steepest direction
      d2 = -s'*s;
    end
    z1 = z1 * min(RATIO, d1/(d2-realmin));          % slope ratio but max RATIO
    d1 = d2;
    ls_failed = 0;                              % this line search did not fail
  else
    X = X0; f1 = f0; df1 = df0;  % restore point from before failed line search
    if ls_failed | i > abs(length)          % line search failed twice in a row
      break;                             % or we ran out of time, so we give up
    end
    tmp = df1; df1 = df2; df2 = tmp;                         % swap derivatives
    s = -df1;                                                    % try steepest
    d1 = -s'*s;
    z1 = 1/(1-d1);
    ls_failed = 1;                                    % this line search failed
  end
  if exist('OCTAVE_VERSION')
    fflush(stdout);
  end
end
fprintf('\n');
8
Eric Leschinski

fmincgは 共役勾配法 を使用します

このリンクの写真を見ると、CG法はfminuncよりもはるかに速く収束することがわかりますが、fminunc法では必要ないと思われる多くの制約を想定しています（ [〜＃〜] bfgs [〜＃〜] ）（共役ベクトルと非共役ベクトル）。

つまり、fmincgメソッドは高速ですが、fminuncよりも粗いため、巨大な行列（数千のような多くの特徴）に対して、最大数百の特徴を持つ小さな行列に対してより効果的に機能します。お役に立てれば。

1
Sv Vr

fmincgはfminuncよりも正確です。両方でかかる時間はほぼ同じです。ニューラルネットワークまたは一般にfminuncがメモリ不足エラーを与える可能性のある重みがより多くないため、fmincgはメモリ効率が高くなります。 =

Fminuncを使用すると、精度は93.10で、所要時間は11.3794秒です。

Testing lrCostFunction() with regularization
Cost: 2.534819
Expected cost: 2.534819
Gradients:
 0.146561
 -0.548558
 0.724722
 1.398003
Expected gradients:
 0.146561
 -0.548558
 0.724722
 1.398003
Program paused. Press enter to continue.

Training One-vs-All Logistic Regression...
id = 1512324857357
Elapsed time is 11.3794 seconds.
Program paused. Press enter to continue.

Training Set Accuracy: 93.100000

Fmincgを使用すると、精度は95.12で、所要時間は11.7978秒です。

Testing lrCostFunction() with regularization
Cost: 2.534819
Expected cost: 2.534819
Gradients:
 0.146561
 -0.548558
 0.724722
 1.398003
Expected gradients:
 0.146561
 -0.548558
 0.724722
 1.398003
Program paused. Press enter to continue.

Training One-vs-All Logistic Regression...
id = 1512325280047
Elapsed time is 11.7978 seconds.

Training Set Accuracy: 95.120000
1
Goyal Vicky

Fmincgを使用してコスト関数を最適化する。fmincgはfminuncと同様に機能しますが、多数のパラメーターを扱う場合により効率的です。コスト関数はどちらの場合でも同じであり、仮説は単純でも複雑でもありません）が、特に複雑な仮説に対して勾配降下を行うのがより効率的であるためです。

効率的なメモリ使用に使用されました。

0
tonystark117

fmincgは、Octaveの組み込み関数であるfminuncとは異なり、Courseraのコースによって開発された内部関数です。両方ともロジスティック回帰に使用されるため、1つの側面のみが異なります。考慮されるパラメーターの数がかなり大きい場合（トレーニングセットのサイズと比較されるかどうか）、fmincgはfminuncよりも高速に動作し、より正確に処理されます。また、fminuncは、渡されるパラメーターに制限がない（制約されていない）場合に推奨されます。

0
a_ran