Livello di output aggiuntivo in una rete neurale (da decimale a binario)

Sto lavorando a una domanda dal libro online:

http://neuralnetworksanddeeplearning.com/chap1.html

Posso capire che se lo strato di output aggiuntivo è composto da 5 neuroni di output, probabilmente potrei impostare un bias a 0,5 e un peso di 0,5 ciascuno per lo strato precedente. Ma la domanda ora richiede un nuovo livello di quattro neuroni di output, che è più che sufficiente per rappresentare 10 possibili output a .$2^{4}$

Qualcuno può guidarmi attraverso i passaggi necessari per comprendere e risolvere questo problema?

La domanda dell'esercizio:

Esiste un modo per determinare la rappresentazione bit a bit di una cifra aggiungendo un livello aggiuntivo alla rete a tre livelli sopra. Il livello aggiuntivo converte l'output del livello precedente in una rappresentazione binaria, come illustrato nella figura seguente. Trova una serie di pesi e distorsioni per il nuovo livello di output. Supponiamo che i primi 3 livelli di neuroni siano tali che l'output corretto nel terzo layer (ovvero il vecchio layer di output) abbia un'attivazione di almeno 0,99 e che output errati abbiano un'attivazione inferiore a 0,01.

La domanda ti chiede di creare la seguente mappatura tra la vecchia rappresentazione e la nuova rappresentazione:

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

Poiché il vecchio livello di output ha una forma semplice, questo è abbastanza facile da ottenere. Ogni neurone in uscita dovrebbe avere un peso positivo tra se stesso e i neuroni in uscita che dovrebbero essere attivi per rappresentarlo, e un peso negativo tra se stesso e i neuroni in uscita che dovrebbe essere spento. I valori dovrebbero combinarsi per essere sufficientemente grandi da poter essere accesi o spenti in modo pulito, quindi utilizzerei pesi di grandi dimensioni, come +10 e -10.

Se hai attivazioni sigmoidi qui, il bias non è così rilevante. Volete semplicemente saturare ogni neurone verso l'accensione o lo spegnimento. La domanda ti ha permesso di assumere segnali molto chiari nel vecchio livello di output.

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

Ciò dovrebbe produrre chiaramente vicino 0 0 1 1all'output quando è attivo solo il neurone del vecchio strato di output che rappresenta un "3". Nella domanda, puoi assumere 0,99 di attivazione di un neurone e <0,01 per quelli concorrenti nel vecchio livello. Pertanto, se si utilizza la stessa ampiezza di pesi in tutto, i valori relativamente piccoli provenienti da + -0,1 (0,01 * 10) dagli altri valori di attivazione del vecchio livello non influiranno seriamente sul valore + -9,9 e gli output nel nuovo livello sarà saturato molto vicino a 0 o 1.

Il codice seguente di SaturnAPI risponde a questa domanda. Vedi ed esegui il codice su 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)

Prova pitonica per l'esercizio sopra:

"""
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

Una piccola modifica alla risposta di FullStack riguardo ai commenti di Neil Slater usando 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')