Capa de salida adicional en una red neuronal (decimal a binario)

Estoy trabajando en una pregunta del libro en línea:

http://neuralnetworksanddeeplearning.com/chap1.html

Puedo entender que si la capa de salida adicional es de 5 neuronas de salida, probablemente podría establecer un sesgo de 0.5 y un peso de 0.5 cada una para la capa anterior. Pero la pregunta ahora pide una nueva capa de cuatro neuronas de salida, que es más que suficiente para representar 10 salidas posibles en .$2^{4}$

¿Puede alguien guiarme por los pasos necesarios para comprender y resolver este problema?

La pregunta del ejercicio:

Hay una manera de determinar la representación en bits de un dígito agregando una capa adicional a la red de tres capas anterior. La capa adicional convierte la salida de la capa anterior en una representación binaria, como se ilustra en la figura a continuación. Encuentre un conjunto de pesos y sesgos para la nueva capa de salida. Suponga que las primeras 3 capas de neuronas son tales que la salida correcta en la tercera capa (es decir, la capa de salida anterior) tiene una activación de al menos 0.99, y las salidas incorrectas tienen una activación menor de 0.01.

La pregunta es pedirle que haga la siguiente asignación entre la representación antigua y la nueva representación:

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

Debido a que la capa de salida anterior tiene una forma simple, esto es bastante fácil de lograr. Cada neurona de salida debería tener un peso positivo entre sí y las neuronas de salida que deberían estar activadas para representarla, y un peso negativo entre sí y las neuronas de salida que deberían estar apagadas. Los valores deben combinarse para ser lo suficientemente grandes como para encender o apagar limpiamente, por lo que usaría pesos más grandes, como +10 y -10.

Si tiene activaciones sigmoideas aquí, el sesgo no es tan relevante. Simplemente desea saturar cada neurona hacia encendido o apagado. La pregunta le ha permitido asumir señales muy claras en la capa de salida anterior.

Entonces, tomando el ejemplo de representar un 3 y usar el índice cero para las neuronas en el orden en que las estoy mostrando (estas opciones no están establecidas en la pregunta), podría tener pesos que van desde la activación de la salida anterior , para nuevas salidas , donde siguiente manera:A O l d 3 Z N e w j Z N e w j = Σ i = 9 i = 0 W i j ∗ A O l d$i=3$$A_3^{Old}$$Z_j^{New}$$Z_j^{New} = \Sigma_{i=0}^{i=9} W_{ij} * A_i^{Old}$

W 3 , 1 = - 10 W 3 , 2 = + 10 W 3 , 3 = +

Esto debería producir claramente cerca de la 0 0 1 1salida cuando solo la neurona de la capa de salida anterior que representa un "3" está activa. En la pregunta, puede suponer la activación 0.99 de una neurona y <0.01 para las competidoras en la capa anterior. Entonces, si usa la misma magnitud de pesos en todo momento, los valores relativamente pequeños que provienen de + -0.1 (0.01 * 10) de los otros valores de activación de la capa anterior no afectarán seriamente el valor de + -9.9, y las salidas en la nueva capa estará saturado muy cerca de 0 o 1.

El siguiente código de SaturnAPI responde a esta pregunta. Vea y ejecute el código en 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)

Prueba pitónica para el ejercicio anterior:

"""
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 pequeña modificación a la respuesta de FullStack con respecto a los comentarios de 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')