Vektorisierte Formel für die Ausgabeschicht in einem neuronalen Netzwerk

Unten finden Sie sowohl vektorisierte als auch Schleifenimplementierungen der Vorwärtsausbreitung. Es ist möglich, dass Ihre Eingabedaten aufgrund unterschiedlicher Notationen und der Art und Weise, wie Sie Daten in Ihren Matrizen speichern, an den folgenden Code angepasst werden müssen.

Sie müssen sowohl der Eingabe- als auch der ausgeblendeten Ebene eine Bias-Einheit hinzufügen.

Um die Arbeit an der Implementierung und dem Debuggen zu vereinfachen, habe ich einige Daten aus dem Open Source Repository für maschinelles Lernen und schulte das Netzwerk für die Weinklassifizierungsaufgabe.

• Xtest - Eingabedaten [178x13]
• y - Ausgabeklasse [178x1]
• thetah - Parameter der verborgenen Ebene [15x14]
• Thetao - Parameter der Ausgabeschicht [3x16]

Das Netzwerk trennt die Eingabedaten mit einer Rate von 97,7%

Hier ist der Code:

function [] = nn_fp()

    load('Xtest.mat'); %input data 178x13
    load('y.mat'); %output data 178x1
    load('thetah.mat'); %Parameters of the hidden layer 15x14
    load('thetao.mat'); %Parameters of the output layer 3x16

    predict_simple(Xtest, y, thetah, thetao); 

    predict_vectorized(Xtest, y, thetah, thetao); 
end

function predict_simple(Xtest, y, thetah, thetao)

    mtest = size(Xtest, 1); %number of input examples
    n = size(Xtest, 2); %number of features
    hl_size = size(thetah, 1); %size of the hidden layer (without the bias unit)
    num_outputs = size(thetao, 1); %size of the output layer

    %add a bias unit to the input layer
    a1 = [ones(mtest, 1) Xtest]; %[mtest x (n+1)]

    %compute activations of the hidden layer
    z2 = zeros(mtest, hl_size); %[mtest x hl_size] 
    a2 = zeros(mtest, hl_size); %[mtest x hl_size]

    for i=1:mtest
        for j=1:hl_size
            for k=1:n+1
                z2(i, j) = z2(i, j) + a1(i, k)*thetah(j, k);
            end

            a2(i, j) = sigmoid_simple(z2(i, j));
        end
    end

    %add a bias unit to the hidden layer
    a2 = [ones(mtest, 1) a2]; %[mtest x (hl_size+1)]

    %compute activations of the output layer
    z3 = zeros(mtest, num_outputs); %[mtest x num_outputs]
    h = zeros(mtest, num_outputs); %[mtest x num_outputs]

    for i=1:mtest
        for j=1:num_outputs
            for k=1:hl_size+1
                z3(i, j) = z3(i, j) + a2(i, k)*thetao(j, k);
            end

            h(i, j) = sigmoid_simple(z3(i, j)); %the hypothesis
        end
    end

    %calculate predictions for each input example based on the maximum term
    %of the hypothesis h
    p = zeros(size(y));

    for i=1:mtest
        max_ind = 1;
        max_value = h(i, 1);
        for j=2:num_outputs
            if (h(i, j) > max_value)
                max_ind = j;
                max_value = h(i, j);
            end
        end

        p(i) = max_ind;
    end

    %calculate the success rate of the prediction
    correct_count = 0;
    for i=1:mtest
        if (p(i) == y(i))
            correct_count = correct_count + 1;
        end
    end

    rate = correct_count/mtest*100;

    display(['simple version rate:', num2str(rate)]);
end

function predict_vectorized(Xtest, y, thetah, thetao)

    mtest = size(Xtest, 1); %number of input examples

    %add a bias unit to the input layer
    a1 = [ones(mtest, 1) Xtest];

    %compute activations of the hidden layer
    z2 = a1*thetah';
    a2 = sigmoid_universal(z2);

    %add a bias unit to the hidden layer
    a2 = [ones(mtest, 1) a2];

    %compute activations of the output layer
    z3 = a2*thetao';
    h = sigmoid_universal(z3); %the hypothesis

    %calculate predictions for each input example based on the maximum term
    %of the hypothesis h
    [~,p] = max(h, [], 2);
    %calculate the success rate of the prediction
    rate = mean(double((p == y))) * 100;
    display(['vectorized version rate:', num2str(rate)]);
end

function [ s ] = sigmoid_simple( z )
    s = 1/(1+exp(-z));
end

function [ s ] = sigmoid_universal( z )
    s = 1./(1+exp(-z));
end