Question

我前几天问了一个问题，但我觉得这有点太复杂了，我不希望得到任何答案。

我的问题是我需要使用ANN进行分类。我已经读过更好的成本函数（或某些书中指定的损失函数）是交叉熵，即J(w) = -1/m * sum_i( yi*ln(hw(xi)) + (1-yi)*ln(1 - hw(xi)) ); i表示否。来自训练矩阵X的数据。我试着在MATLAB中应用它，但我发现它真的很难。有几件我不知道的事情：

我应该在给定所有训练数据的情况下对每个输出求和（i = 1，... N，其中N是训练输入的数量）
是正确计算的渐变
是正确计算的数值梯度（gradAapprox）。

我有以下MATLAB代码。我意识到我可能要求琐碎的事情，但无论如何我希望有人可以给我一些线索如何找到问题。我怀疑问题是计算渐变。

非常感谢。

主要剧本：

close all
clear all

L = @(x) (1 + exp(-x)).^(-1);
NN = @(x,theta) theta{2}*[ones(1,size(x,1));L(theta{1}*[ones(size(x,1),1) x]')];

% theta = [10 -30 -30];
x = [0 0; 0 1; 1 0; 1 1];
y = [0.9 0.1 0.1 0.1]';

theta0 = 2*rand(9,1)-1;
options = optimset('gradObj','on','Display','iter');
thetaVec = fminunc(@costFunction,theta0,options,x,y);
theta = cell(2,1);
theta{1} = reshape(thetaVec(1:6),[2 3]);
theta{2} = reshape(thetaVec(7:9),[1 3]);

NN(x,theta)'

成本函数：

function [jVal,gradVal,gradApprox] = costFunction(thetaVec,x,y)
persistent index;

%     1 x x
%     1 x x
%     1 x x
% x = 1 x x
%     1 x x
%     1 x x
%     1 x x

m = size(x,1);

if isempty(index) || index > size(x,1)
    index = 1;
end

L = @(x) (1 + exp(-x)).^(-1);
NN = @(x,theta) theta{2}*[ones(1,size(x,1));L(theta{1}*[ones(size(x,1),1) x]')];

theta = cell(2,1);
theta{1} = reshape(thetaVec(1:6),[2 3]);
theta{2} = reshape(thetaVec(7:9),[1 3]);
Dew = cell(2,1);
DewApprox = cell(2,1);

% Forward propagation
a0 = x(index,:)';
z1 = theta{1}*[1;a0];
a1 = L(z1);
z2 = theta{2}*[1;a1];
a2 = L(z2);

% Back propagation
d2 = 1/m*(a2 - y(index))*L(z2)*(1-L(z2));
Dew{2} = [1;a1]*d2;
d1 = [1;a1].*(1 - [1;a1]).*theta{2}'*d2;
Dew{1} = [1;a0]*d1(2:end)';

% NNRes = NN(x,theta)';
% jVal = -1/m*sum(NNRes-y)*NNRes*(1-NNRes);
jVal = -1/m*(a2 - y(index))*a2*(1-a2);
gradVal = [Dew{1}(:);Dew{2}(:)];

gradApprox = CalcGradApprox(0.0001);

index = index + 1;

function output = CalcGradApprox(epsilon)
    output = zeros(size(gradVal));
    for n=1:length(thetaVec)
        thetaVecMin = thetaVec;
        thetaVecMax = thetaVec;
        thetaVecMin(n) = thetaVec(n) - epsilon;
        thetaVecMax(n) = thetaVec(n) + epsilon;

        thetaMin = cell(2,1);
        thetaMax = cell(2,1);
        thetaMin{1} = reshape(thetaVecMin(1:6),[2 3]);
        thetaMin{2} = reshape(thetaVecMin(7:9),[1 3]);
        thetaMax{1} = reshape(thetaVecMax(1:6),[2 3]);
        thetaMax{2} = reshape(thetaVecMax(7:9),[1 3]);

        a2min = NN(x(index,:),thetaMin)';
        a2max = NN(x(index,:),thetaMax)';
        jValMin = -1/m*(a2min-y(index))*a2min*(1-a2min);
        jValMax = -1/m*(a2max-y(index))*a2max*(1-a2max);
        output(n) = (jValMax - jValMin)/2/epsilon;
    end
end
end

编辑：下面我为那些可能感兴趣的人提供我的costFunction的正确版本。

function [jVal,gradVal,gradApprox] = costFunction(thetaVec,x,y)
    m = size(x,1);

    L = @(x) (1 + exp(-x)).^(-1);
    NN = @(x,theta) L(theta{2}*[ones(1,size(x,1));L(theta{1}*[ones(size(x,1),1) x]')]);

    theta = cell(2,1);
    theta{1} = reshape(thetaVec(1:6),[2 3]);
    theta{2} = reshape(thetaVec(7:9),[1 3]);
    Delta = cell(2,1);
    Delta{1} = zeros(size(theta{1}));
    Delta{2} = zeros(size(theta{2}));
    D = cell(2,1);
    D{1} = zeros(size(theta{1}));
    D{2} = zeros(size(theta{2}));
    jVal = 0;

    for in = 1:size(x,1)
        % Forward propagation
        a1 = [1;x(in,:)']; % added bias to a0
        z2 = theta{1}*a1;
        a2 = [1;L(z2)]; % added bias to a1
        z3 = theta{2}*a2;
        a3 = L(z3);
        % Back propagation
        d3 = a3 - y(in);
        d2 = theta{2}'*d3.*a2.*(1 - a2);
        Delta{2} = Delta{2} + d3*a2';
        Delta{1} = Delta{1} + d2(2:end)*a1';
        jVal = jVal + sum(  y(in)*log(a3) + (1-y(in))*log(1-a3)  );
    end
    D{1} = 1/m*Delta{1};
    D{2} = 1/m*Delta{2};

    jVal = -1/m*jVal;
    gradVal = [D{1}(:);D{2}(:)];
    gradApprox = CalcGradApprox(x(in,:),0.0001);



    % Nested function to calculate gradApprox
    function output = CalcGradApprox(x,epsilon)
        output = zeros(size(thetaVec));
        for n=1:length(thetaVec)
            thetaVecMin = thetaVec;
            thetaVecMax = thetaVec;
            thetaVecMin(n) = thetaVec(n) - epsilon;
            thetaVecMax(n) = thetaVec(n) + epsilon;

            thetaMin = cell(2,1);
            thetaMax = cell(2,1);
            thetaMin{1} = reshape(thetaVecMin(1:6),[2 3]);
            thetaMin{2} = reshape(thetaVecMin(7:9),[1 3]);
            thetaMax{1} = reshape(thetaVecMax(1:6),[2 3]);
            thetaMax{2} = reshape(thetaVecMax(7:9),[1 3]);

            a3min = NN(x,thetaMin)';
            a3max = NN(x,thetaMax)';
            jValMin = 0;
            jValMax = 0;
            for inn=1:size(x,1)
                jValMin = jValMin + sum(  y(inn)*log(a3min) + (1-y(inn))*log(1-a3min)  );
                jValMax = jValMax + sum(  y(inn)*log(a3max) + (1-y(inn))*log(1-a3max)  );
            end
            jValMin = 1/m*jValMin;
            jValMax = 1/m*jValMax;
            output(n) = (jValMax - jValMin)/2/epsilon;
        end
    end
end

Answer 1

我对你的代码只有一个快速的眼球。这里有一些指示。

<强> Q1

我应该给出所有训练数据的每个输出（i = 1，... N，其中 N是培训的输入数量）

如果您正在谈论成本函数，那么通过训练样本的数量求和并标准化是正常的，以便进行比较。

我无法从代码中看出你是否有一个可以改变答案的矢量化实现。请注意，sum函数一次只能汇总一个维度 - 这意味着如果你有一个（M乘N）数组，sum将产生一个1乘N的数组。

成本函数应具有标量输出。

<强> Q2

是正确计算的渐变

梯度计算不正确 - 特别是增量看起来不对。试试Andrew Ng's notes [PDF]，他们非常好。

<强> Q3

是正确计算的数值梯度（gradAapprox）。

这条线看起来有点怀疑。这更有意义吗？

output(n) = (jValMax - jValMin)/(2*epsilon);

编辑：我实际上无法做出渐变近似的正面或反面。您应该只在参数中使用向前传播和小调整来计算渐变。祝你好运！

神经网络在MATLAB中的应用

1 个答案: