Couche de sortie supplémentaire dans un réseau neuronal (décimal à binaire)


17

Je travaille sur une question du livre en ligne:

http://neuralnetworksanddeeplearning.com/chap1.html

Je peux comprendre que si la couche de sortie supplémentaire est composée de 5 neurones de sortie, je pourrais probablement définir un biais à 0,5 et un poids de 0,5 pour la couche précédente. Mais la question demande maintenant une nouvelle couche de quatre neurones de sortie - ce qui est plus que suffisant pour représenter 10 sorties possibles à .24

Quelqu'un peut-il me guider à travers les étapes de la compréhension et de la résolution de ce problème?

La question de l'exercice:

Il existe un moyen de déterminer la représentation au niveau du bit d'un chiffre en ajoutant une couche supplémentaire au réseau à trois couches ci-dessus. La couche supplémentaire convertit la sortie de la couche précédente en une représentation binaire, comme illustré dans la figure ci-dessous. Trouvez un ensemble de pondérations et de biais pour la nouvelle couche de sortie. Supposons que les 3 premières couches de neurones sont telles que la sortie correcte dans la troisième couche (c'est-à-dire l'ancienne couche de sortie) a une activation d'au moins 0,99 et que les sorties incorrectes ont une activation inférieure à 0,01.

entrez la description de l'image ici

Réponses:


16

La question vous demande de faire le mappage suivant entre ancienne représentation et nouvelle représentation:

Represent    Old                     New
0            1 0 0 0 0 0 0 0 0 0     0 0 0 0 
1            0 1 0 0 0 0 0 0 0 0     0 0 0 1 
2            0 0 1 0 0 0 0 0 0 0     0 0 1 0 

3            0 0 0 1 0 0 0 0 0 0     0 0 1 1 
4            0 0 0 0 1 0 0 0 0 0     0 1 0 0 
5            0 0 0 0 0 1 0 0 0 0     0 1 0 1 

6            0 0 0 0 0 0 1 0 0 0     0 1 1 0 
7            0 0 0 0 0 0 0 1 0 0     0 1 1 1 
8            0 0 0 0 0 0 0 0 1 0     1 0 0 0 

9            0 0 0 0 0 0 0 0 0 1     1 0 0 1

Étant donné que l'ancienne couche de sortie a une forme simple, cela est assez facile à réaliser. Chaque neurone de sortie devrait avoir un poids positif entre lui-même et les neurones de sortie qui devraient être allumés pour le représenter, et un poids négatif entre lui-même et les neurones de sortie qui devraient être éteints. Les valeurs doivent se combiner pour être suffisamment grandes pour s'allumer ou s'éteindre proprement, donc j'utiliserais des poids plus importants, tels que +10 et -10.

Si vous avez des activations sigmoïdes ici, le biais n'est pas si pertinent. Vous voulez simplement saturer chaque neurone en marche ou en arrêt. La question vous a permis de supposer des signaux très clairs dans l'ancienne couche de sortie.

je=3UNE3OlZjNewZjNew=Σje=0je=9WjejUNEjeOl

W3,0=-dix
W3,1=-dix
W3,2=+dix
W3,3=+dix

Cela devrait clairement produire près de la 0 0 1 1sortie lorsque seul le neurone de l'ancienne couche de sortie représentant un "3" est actif. Dans la question, vous pouvez supposer une activation de 0,99 d'un neurone et <0,01 pour les neurones concurrents de l'ancienne couche. Donc, si vous utilisez la même amplitude de poids tout au long, des valeurs relativement petites provenant de + -0,1 (0,01 * 10) des autres anciennes valeurs d'activation de couche n'affecteront pas sérieusement la valeur + -9,9, et les sorties dans la nouvelle couche sera saturé à très proche de 0 ou 1.


Je vous remercie. Je ne pourrais pas tout à fait suivre cette partie. - "Je pourrais avoir des poids allant de l'activation de l'ancienne sortie i = 3, AOld3 au logit des nouvelles sorties ZNewj, où ZNewj = Σi = 9i = 0Wij ∗ AOldi comme suit: W3,0 = −10 W3,1 = −10 W3 , 2 = + 10 W3,3 = + 10 "
Victor Yip

UNEje=F(Zje)F

@NeilSlater - vos poids d'exemple fonctionneront-ils pour les sorties qui ne sont pas 3? Je ne vois pas qu'ils le feront. Veuillez développer. Merci.
FullStack

UNE3ol

1
@ Rrz0: Parce que je suppose une couche sigmoïde en sortie, car c'est une classification binaire - le bit est activé ou désactivé. Donc, dans votre exemple, vous obtenez sigmoid((0 * 10) * 1)0,5. En choisissant des nombres convenablement grands, vous garantissez une sortie très élevée ou faible avant le sigmoïde, qui sortira alors très près de 0 ou 1. Ceci est plus robuste IMO que la sortie linéaire supposée dans la réponse de FullStack, mais en ignorant cela, essentiellement notre deux réponses sont les mêmes.
Neil Slater

4

Le code ci-dessous de SaturnAPI répond à cette question. Voir et exécuter le code sur https://saturnapi.com/artitw/neural-network-decimal-digits-to-binary-bitwise-conversion

% Welcome to Saturn's MATLAB-Octave API.
% Delete the sample code below these comments and write your own!

% Exercise from http://neuralnetworksanddeeplearning.com/chap1.html
% There is a way of determining the bitwise representation of a digit by adding an extra layer to the three-layer network above. The extra layer converts the output from the previous layer into a binary representation, as illustrated in the figure below. Find a set of weights and biases for the new output layer. Assume that the first 3 layers of neurons are such that the correct output in the third layer (i.e., the old output layer) has activation at least 0.99, and incorrect outputs have activation less than 0.01.

% Inputs from 3rd layer
xj = eye(10,10)

% Weights matrix
wj = [0 0 0 0 0 0 0 0 1 1 ;
      0 0 0 0 1 1 1 1 0 0 ;
      0 0 1 1 0 0 1 1 0 0 ;
      0 1 0 1 0 1 0 1 0 1 ]';

% Results
wj*xj


% Confirm results
integers = 0:9;
dec2bin(integers)

Notez que cela implémente un ensemble de pondérations pour une couche de sortie linéaire. En revanche, ma réponse suppose une activation sigmoïde dans la couche de sortie. Sinon, les deux réponses sont équivalentes.
Neil Slater

Qu'entend-on par entrées eye(10,10)?
Rrz0

oui, cela fonctionne en effet comme un charme, venez de l'essayer dans Octave Online et confirmé, merci !! ... PS: Une petite explication serait également bonne, si quelqu'un était coincé :)
Anaximandro Andrade

1
@ Rrz0 c'est une fonction Matlab / Octave pour créer une matrice d'identité (avec seulement celles dans la diagonale principale)
Anaximandro Andrade

0

Preuve pythonique pour l'exercice ci-dessus:

"""
NEURAL NETWORKS AND DEEP LEARNING by Michael Nielsen

Chapter 1

http://neuralnetworksanddeeplearning.com/chap1.html#exercise_513527

Exercise:

There is a way of determining the bitwise representation of a digit by adding an extra layer to the three-layer network above. The extra layer converts the output from the previous layer into a binary representation, as illustrated in the figure below. Find a set of weights and biases for the new output layer. Assume that the first 3 layers of neurons are such that the correct output in the third layer (i.e., the old output layer) has activation at least 0.99, and incorrect outputs have activation less than 0.01.

"""
import numpy as np


def sigmoid(x):
    return(1/(1+np.exp(-x)))


def new_representation(activation_vector):
    a_0 = np.sum(w_0 * activation_vector)
    a_1 = np.sum(w_1 * activation_vector)
    a_2 = np.sum(w_2 * activation_vector)
    a_3 = np.sum(w_3 * activation_vector)

    return a_3, a_2, a_1, a_0


def new_repr_binary_vec(new_representation_vec):
    sigmoid_op = np.apply_along_axis(sigmoid, 0, new_representation_vec)
    return (sigmoid_op > 0.5).astype(int)


w_0 = np.full(10, -1, dtype=np.int8)
w_0[[1, 3, 5, 7, 9]] = 1
w_1 = np.full(10, -1, dtype=np.int8)
w_1[[2, 3, 6, 7]] = 1
w_2 = np.full(10, -1, dtype=np.int8)
w_2[[4, 5, 6, 7]] = 1
w_3 = np.full(10, -1, dtype=np.int8)
w_3[[8, 9]] = 1

activation_vec = np.full(10, 0.01, dtype=np.float)
# correct number is 5
activation_vec[3] = 0.99

new_representation_vec = new_representation(activation_vec)
print(new_representation_vec)
# (-1.04, 0.96, -1.0, 0.98)
print(new_repr_binary_vec(new_representation_vec))
# [0 1 0 1]

# if you wish to convert binary vector to int
b = new_repr_binary_vec(new_representation_vec)
print(b.dot(2**np.arange(b.size)[::-1]))
# 5

0

Une petite modification à la réponse de FullStack concernant les commentaires de Neil Slater en utilisant Octave:

% gzanellato
% Octave

% 3rd layer:
A = eye(10,10);

% Weights matrix:

fprintf('\nSet of weights:\n\n')

wij = [-10 -10 -10 -10 -10 -10 -10 -10 10 10;
       -10 -10 -10 -10 10 10 10 10 -10 -10;
       -10 -10 10 10 -10 -10 10 10 -10 -10;
       -10 10 -10 10 -10 10 -10 10 -10 10]

% Any bias between -9.999.. and +9.999.. runs ok

bias=5

Z=wij*A+bias;

% Sigmoid function:

for j=1:10;
  for i=1:4;
    Sigma(i,j)=int32(1/(1+exp(-Z(i,j))));
  end
end

fprintf('\nBitwise representation of digits:\n\n')

disp(Sigma')
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.