Une seule couche de réseau de neurones

Pour la mise en œuvre d'une seule couche de réseau de neurones, j'ai deux fichiers de données.

In:
    0.832 64.643
    0.818 78.843

Out:
    0 0 1
    0 0 1

Ci-dessus est le format de 2 fichiers de données.

La cible de sortie est à "1" pour une catégorie donnée d'entrée correspondantes appartient et "0" pour les 2 autres sorties.

Le problème est comme suit:

Votre seule couche de réseau de neurones va
trouver Un (3 par 2 de la matrice) et b (3 en 1
vector) de Y = A*X + b où Y est [C1,
C2, C3]' et X est [x1, x2]'.

Pour résoudre le problème ci-dessus avec un
réseau de neurones, on peut ré-écrire l'
l'équation comme suit: Y = A' * X' où
A' = [A b] (3 par 3 de la matrice) et X' est
[x1, x2, 1]'

Maintenant, vous pouvez utiliser un réseau de neurones avec
trois nœuds d'entrée (l'un de x1, x2 et
1 respectivement) et trois sorties (C1,
C2, C3).

L'résultant 9 (puisque nous avons 9
les connexions entre 3 entrées et 3
sorties) poids sera équivalent à
éléments d'Une " matrice.

Fondamentalement, je suis en train de faire quelque chose comme cela, mais ça ne fonctionne pas:

function neuralNetwork   
    load X_Q2.data
    load T_Q2.data
    x = X_Q2(:,1);
    y = X_Q2(:,2);

    learningrate = 0.2;
    max_iteration = 50;

    % initialize parameters
    count = length(x);
    weights = rand(1,3); % creates a 1-by-3 array with random weights
    globalerror = 0;
    iter = 0;
    while globalerror ~= 0 && iter <= max_iteration
        iter = iter + 1;
        globalerror = 0;
        for p = 1:count
            output = calculateOutput(weights,x(p),y(p));
            localerror = T_Q2(p) - output
            weights(1)= weights(1) + learningrate *localerror*x(p);
            weights(2)= weights(1) + learningrate *localerror*y(p);
            weights(3)= weights(1) + learningrate *localerror;
            globalerror = globalerror + (localerror*localerror);
        end 
    end

J'écris cette fonction dans un autre fichier et de l'appeler dans mon code précédent.

function result = calculateOutput (weights, x, y)
    s = x * weights(1) + y * weights(2) + weights(3);
    if s >= 0
        result = 1;
    else
        result = -1;
    end

InformationsquelleAutor user414981 | 2010-08-11

222

Je peux repérer quelques problèmes avec le code. Le principal problème est que la cible est multi-classe (pas binaire), de sorte que vous devez soit utiliser 3 nœuds de sortie un pour chaque classe (appelée 1-de-N de codage), ou utiliser un seul nœud de sortie avec un autre activation de la fonction (quelque chose capable de plus que juste sortie binaire -1/1 ou 0/1)

Dans la solution ci-dessous, la perceptron a la structure suivante:

Une seule couche de réseau de neurones

%# load your data
input = [
0.832 64.643
0.818 78.843
1.776 45.049
0.597 88.302
1.412 63.458
];
target = [
0 0 1
0 0 1
0 1 0
0 0 1
0 0 1
];
%# parameters of the learning algorithm
LEARNING_RATE = 0.1;
MAX_ITERATIONS = 100;
MIN_ERROR = 1e-4;
[numInst numDims] = size(input);
numClasses = size(target,2);
%# three output nodes connected to two-dimensional input nodes + biases
weights = randn(numClasses, numDims+1);
isDone = false;               %# termination flag
iter = 0;                     %# iterations counter
while ~isDone
iter = iter + 1;
%# for each instance
err = zeros(numInst,numClasses);
for i=1:numInst
%# compute output: Y = W*X + b, then apply threshold activation
output = ( weights * [input(i,:)';1] >= 0 );                       %#'
%# error: err = T - Y
err(i,:) = target(i,:)' - output;                                  %#'
%# update weights (delta rule): delta(W) = alpha*(T-Y)*X
weights = weights + LEARNING_RATE * err(i,:)' * [input(i,:) 1];    %#'
end
%# Root mean squared error
rmse = sqrt(sum(err.^2,1)/numInst);
fprintf(['Iteration %d: ' repmat('%f ',1,numClasses) '\n'], iter, rmse);
%# termination criteria
if ( iter >= MAX_ITERATIONS || all(rmse < MIN_ERROR) )
isDone = true;
end
end
%# plot points and one-against-all decision boundaries
[~,group] = max(target,[],2);                     %# actual class of instances
gscatter(input(:,1), input(:,2), group), hold on
xLimits = get(gca,'xlim'); yLimits = get(gca,'ylim');
for i=1:numClasses
ezplot(sprintf('%f*x + %f*y + %f', weights(i,:)), xLimits, yLimits)
end
title('Perceptron decision boundaries')
hold off

Les résultats de la formation sur les cinq exemples que vous avez fournies:

Iteration 1: 0.447214 0.632456 0.632456 
Iteration 2: 0.000000 0.447214 0.447214 
...
Iteration 49: 0.000000 0.447214 0.447214 
Iteration 50: 0.000000 0.632456 0.000000 
Iteration 51: 0.000000 0.447214 0.000000 
Iteration 52: 0.000000 0.000000 0.000000

Une seule couche de réseau de neurones

Noter que les données utilisées dans l'exemple ci-dessus ne contient que 5 échantillons. Vous obtiendrez des résultats plus significatifs si vous aviez plus de la formation des instances de chaque classe.

InformationsquelleAutor Amro

Vous devez vous connecter pour publier un commentaire.