Zusätzliche Ausgabeebene in einem neuronalen Netzwerk (Dezimal zu Binär)

Ich arbeite gerade an einer Frage aus dem Online-Buch:

http://neuralnetworksanddeeplearning.com/chap1.html

Ich kann verstehen, dass, wenn die zusätzliche Ausgangsschicht aus 5 Ausgangsneuronen besteht, ich wahrscheinlich eine Vorspannung von 0,5 und ein Gewicht von jeweils 0,5 für die vorherige Schicht festlegen könnte. Die Frage lautet nun aber: Eine neue Schicht von vier Ausgangsneuronen - das ist mehr als genug, um 10 mögliche Ausgänge bei darzustellen .$2^{4}$

Kann mich jemand durch die Schritte führen, die erforderlich sind, um dieses Problem zu verstehen und zu lösen?

Die Übungsfrage:

Es gibt eine Möglichkeit, die bitweise Darstellung einer Ziffer zu bestimmen, indem dem darüber liegenden dreischichtigen Netzwerk eine zusätzliche Schicht hinzugefügt wird. Die zusätzliche Ebene konvertiert die Ausgabe der vorherigen Ebene in eine binäre Darstellung, wie in der folgenden Abbildung dargestellt. Suchen Sie eine Reihe von Gewichten und Vorurteilen für die neue Ausgabeebene. Angenommen, die ersten drei Schichten von Neuronen sind so beschaffen, dass die Aktivierung der korrekten Ausgabe in der dritten Schicht (dh der alten Ausgabeschicht) mindestens 0,99 beträgt und die Aktivierung der falschen Ausgaben weniger als 0,01 beträgt.

Bei der Frage werden Sie aufgefordert, die folgende Zuordnung zwischen alter und neuer Darstellung vorzunehmen:

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

Da die alte Ausgabeebene eine einfache Form hat, ist dies recht einfach zu erreichen. Jedes Ausgangsneuron sollte ein positives Gewicht zwischen sich und den Ausgangsneuronen haben, die es darstellen sollen, und ein negatives Gewicht zwischen sich und den Ausgangsneuronen, die ausgeschaltet sein sollen. Die Werte sollten zusammen so groß sein, dass sie sauber ein- oder ausgeschaltet werden können. Daher würde ich große Gewichte wie +10 und -10 verwenden.

Wenn Sie hier Sigmoid-Aktivierungen haben, ist die Verzerrung nicht so relevant. Sie möchten einfach jedes Neuron ein- oder ausschalten. Die Frage hat es Ihnen ermöglicht, sehr klare Signale in der alten Ausgabeschicht anzunehmen.

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

Dies sollte eindeutig nahezu eine 0 0 1 1Ausgabe ergeben, wenn nur das Neuron der alten Ausgabeschicht, das eine "3" darstellt, aktiv ist. In der Frage können Sie 0,99 Aktivierung eines Neurons und <0,01 für konkurrierende in der alten Schicht annehmen. Wenn Sie also die gleiche Stärke der Gewichte verwenden, wirken sich relativ kleine Werte von + -0,1 (0,01 * 10) von den anderen Aktivierungswerten der alten Ebene nicht ernsthaft auf den Wert von + -9,9 und die Ausgaben in der neuen Ebene aus wird bei sehr nahe an 0 oder 1 gesättigt sein.

Der folgende Code von SaturnAPI beantwortet diese Frage. Den Code finden Sie unter 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)

Pythonischer Beweis für die obige Übung:

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

Eine kleine Änderung an der Antwort von FullStack bezüglich Neil Slaters Kommentaren mit 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')