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

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 à .$2^{4}$

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.

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.

$i=3$$A_3^{Old}$$Z_j^{New}$$Z_j^{New} = \Sigma_{i=0}^{i=9} W_{ij} * A_i^{Old}$

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.

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)

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

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')