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

17

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 .24

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.

Bildbeschreibung hier eingeben

Victor Yip
quelle

Antworten:

16

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=3A3OldZjNewZjNew=Σich=0ich=9WichjEINichÖld

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

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.

Neil Slater
quelle
Vielen Dank. Ich konnte diesem Teil nicht ganz folgen. Würde es Ihnen etwas ausmachen, weiter darauf einzugehen? - "Ich könnte Gewichte haben, die von der Aktivierung des alten Ausgangs i = 3, AOld3 bis zur Protokollierung der neuen Ausgänge ZNewj gehen, wobei ZNewj = Σi = 9i = 0Wij ∗ AOldi wie folgt ist: W3,0 = −10 W3,1 = −10 W3 , 2 = + 10 W3,3 = + 10 "
Victor Yip
EINich=f(Zich)f
@NeilSlater - funktionieren Ihre Beispielgewichtungen für die Ausgaben, die nicht 3 sind? Ich sehe nicht, dass sie es tun werden. Bitte erläutern Sie. Vielen Dank.
FullStack
A3old
1
@ Rrz0: Da ich bei der Ausgabe von einer Sigmoid-Schicht ausgehe, da es sich um eine binäre Klassifizierung handelt, ist das Bit entweder aktiviert oder deaktiviert. In deinem Beispiel erhältst du also einen Wert von sigmoid((0 * 10) * 1)0,5. Indem Sie entsprechend große Zahlen auswählen, stellen Sie entweder eine sehr hohe oder niedrige Ausgabe vor dem Sigmoid sicher, die dann sehr nahe an 0 oder 1 ausgegeben wird. Dies ist eine robustere IMO als die in FullStacks Antwort angenommene lineare Ausgabe, ignoriert dies jedoch im Wesentlichen unsere Zwei Antworten sind gleich.
Neil Slater
4

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)
Voller Stapel
quelle
Beachten Sie, dass dies eine Reihe von Gewichten für eine lineare Ausgabeebene implementiert. Im Gegensatz dazu geht meine Antwort von einer Sigma-Aktivierung in der Ausgabeebene aus. Ansonsten sind die beiden Antworten gleich.
Neil Slater
Was ist mit den Eingaben gemeint eye(10,10)?
Rrz0
ja, es funktioniert in der Tat wie ein Zauber, habe es gerade in Octave Online ausprobiert und bestätigt, danke !! ... PS: Eine kleine Erklärung wäre auch gut, sollte jemand stecken bleiben :)
Anaximandro Andrade
1
@ Rrz0 ist eine Matlab / Octave-Funktion zum Erstellen einer Identitätsmatrix (mit nur einer in der Hauptdiagonale)
Anaximandro Andrade
0

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
NpnSaddy
quelle
0

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