Ich habe ein neuronales Netzwerk und möchte das trainierte neuronale Netzwerk verwenden, um nach einer Reihe von Testdaten zu suchen. Ich habe Schwierigkeiten damit, die Formel für die verborgene Schicht und für die Ausgabeschicht zu schreiben. Ich möchte eine vektorisierte Formel haben, aber ich werde auch gerne eine Schleifenvariation implementieren.

Jetzt glaube ich, dass ich die richtige Formel für die verborgene Ebene habe und nur eine für die Ausgabeebene benötige, würde es aber begrüßen, wenn jemand bestätigt, dass es sich um die vektorisierte Formel handelt.

% Variables
% Xtest test training data
% thetah - trained weights for inputs to hidden layer
% thetao - trained weights for hidden layer to outputs
% ytest - output

htest =   (1 ./ (1 +  exp(-(thetah * Xtest'))))' ; % FORMULA FOR HIDDEN LAYER
ytest = ones(mtest, num_outputs) ; % FORMULA FOR OUTPUT LAYER
0
Jean de Toit 27 Dez. 2015 im 07:55

2 Antworten

Beste Antwort

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
2
Anton 30 Dez. 2015 im 00:29

Angenommen, Ihr Xtest hat die Dimensionen N by M, wobei N die Anzahl der Beispiele und M die Anzahl der Merkmale ist, ist thetah eine M by H1 Matrix, wobei H1 die Anzahl der ausgeblendeten ist Ebenen in der ersten Ebene und thetao ist eine H1 by O Matrix, wobei O die Anzahl der Ausgabeklassen ist, die Sie wie folgt ausführen:

a1 = Xtest * thetah; 
z1 = 1 / (1 + exp(-a1)); %Assuming you are using sigmoid units

a2 = z1 * thetao;
z2 = softmax(a2);

Lesen Sie hier mehr über softmax .

0
Amir 2 Jän. 2016 im 04:43