Lapisan output ekstra dalam jaringan saraf (Desimal ke biner)

Saya sedang mengerjakan pertanyaan dari buku online:

http://neuralnetworksanddeeplearning.com/chap1.html

Saya bisa mengerti bahwa jika lapisan output tambahan adalah 5 neuron output, saya mungkin bisa menetapkan bias pada 0,5 dan berat masing-masing 0,5 untuk lapisan sebelumnya. Tetapi pertanyaannya sekarang meminta lapisan baru dari empat neuron keluaran - yang lebih dari cukup untuk mewakili 10 kemungkinan keluaran pada .$2^{4}$

Dapatkah seseorang menuntun saya melalui langkah-langkah yang terlibat dalam memahami dan menyelesaikan masalah ini?

Pertanyaan latihan:

Ada cara untuk menentukan representasi bitwise digit dengan menambahkan lapisan tambahan ke jaringan tiga lapis di atas. Lapisan tambahan mengubah output dari lapisan sebelumnya menjadi representasi biner, seperti yang diilustrasikan dalam gambar di bawah ini. Temukan seperangkat bobot dan bias untuk lapisan keluaran baru. Asumsikan bahwa 3 lapisan neuron pertama adalah sedemikian sehingga output yang benar di lapisan ketiga (yaitu, lapisan output lama) memiliki aktivasi setidaknya 0,99, dan output yang salah memiliki aktivasi kurang dari 0,01.

Pertanyaannya adalah meminta Anda untuk membuat pemetaan berikut antara representasi lama dan representasi baru:

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

Karena lapisan keluaran yang lama memiliki bentuk yang sederhana, ini cukup mudah untuk dicapai. Setiap neuron keluaran harus memiliki bobot positif antara dirinya dan neuron keluaran yang harus dihidupkan untuk mewakilinya, dan bobot negatif antara neuron keluaran dan neuron keluaran yang harus dimatikan. Nilai harus digabungkan agar cukup besar untuk mengaktifkan atau menonaktifkan, jadi saya akan menggunakan bobot yang besar, seperti +10 dan -10.

Jika Anda memiliki aktivasi sigmoid di sini, biasnya tidak relevan. Anda hanya ingin menjenuhkan setiap neuron ke on atau off. Pertanyaannya telah memungkinkan Anda untuk mengasumsikan sinyal yang sangat jelas di lapisan keluaran yang lama.

Jadi, mengambil contoh mewakili 3 dan menggunakan pengindeksan nol untuk neuron dalam urutan yang saya tunjukkan (opsi ini tidak diatur dalam pertanyaan), saya mungkin memiliki bobot mulai dari aktivasi output lama , untuk keluar dari keluaran baru , di mana sebagai berikut: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 = +

Ini harus jelas menghasilkan dekat dengan 0 0 1 1output ketika hanya neuron lapisan keluaran lama yang mewakili "3" aktif. Dalam pertanyaan, Anda dapat mengasumsikan 0,99 aktivasi satu neuron dan <0,01 untuk yang bersaing di lapisan lama. Jadi, jika Anda menggunakan besarnya bobot yang sama di seluruh, maka nilai yang relatif kecil berasal dari + -0.1 (0,01 * 10) dari nilai aktivasi lapisan lama lainnya tidak akan secara serius mempengaruhi nilai + -9,9, dan output di lapisan baru akan jenuh pada sangat dekat dengan 0 atau 1.

Kode di bawah ini dari SaturnAPI menjawab pertanyaan ini. Lihat dan jalankan kode di 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)

Bukti Pythonic untuk latihan di atas:

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

Sedikit modifikasi pada jawaban FullStack mengenai komentar Neil Slater menggunakan 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')