तंत्रिका नेटवर्क में अतिरिक्त उत्पादन परत (बाइनरी के लिए दशमलव)

Question

मैं ऑनलाइन पुस्तक से एक प्रश्न के माध्यम से काम कर रहा हूँ:

http://neuralnetworksanddeeplearning.com/chap1.html

मैं समझ सकता हूं कि यदि अतिरिक्त आउटपुट परत 5 आउटपुट न्यूरॉन्स की है, तो मैं संभवतः 0.5 और पिछली परत के लिए 0.5 के वजन पर पूर्वाग्रह स्थापित कर सकता हूं। लेकिन सवाल अब चार आउटपुट न्यूरॉन्स की एक नई परत के लिए पूछता है - जो पर 10 संभावित आउटपुट का प्रतिनिधित्व करने के लिए पर्याप्त से अधिक है ।$2^{4}$

क्या कोई मुझे इस समस्या को समझने और हल करने में शामिल कदमों से चल सकता है?

व्यायाम सवाल:

ऊपर तीन-परत नेटवर्क में एक अतिरिक्त परत जोड़कर एक अंक के बिटवाइज़ प्रतिनिधित्व को निर्धारित करने का एक तरीका है। अतिरिक्त परत पिछली परत से आउटपुट को एक द्विआधारी प्रतिनिधित्व में परिवर्तित करती है, जैसा कि नीचे दिए गए आंकड़े में दिखाया गया है। नई आउटपुट परत के लिए वज़न और पूर्वाग्रहों का एक सेट खोजें। मान लें कि न्यूरॉन्स की पहली 3 परतें ऐसी हैं, जो तीसरी परत (यानी, पुरानी आउटपुट परत) में सही आउटपुट में कम से कम 0.99 है, और गलत आउटपुट में 0.01 से कम सक्रियण है।

Answer 1

प्रश्न आपको पुराने प्रतिनिधित्व और नए प्रतिनिधित्व के बीच निम्नलिखित मानचित्रण बनाने के लिए कह रहा है:

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

क्योंकि पुरानी आउटपुट परत का एक सरल रूप है, यह हासिल करना काफी आसान है। प्रत्येक आउटपुट न्यूरॉन में स्वयं और आउटपुट न्यूरॉन्स के बीच एक सकारात्मक वजन होना चाहिए जो इसे दर्शाने के लिए होना चाहिए, और स्वयं के बीच एक नकारात्मक वजन और आउटपुट न्यूरॉन्स जो बंद होना चाहिए। मानों को बड़े पैमाने पर सफाई से या बंद करने के लिए पर्याप्त रूप से संयोजित होना चाहिए, इसलिए मैं लार्जर वेट का उपयोग करूंगा, जैसे कि +10 और -10।

यदि आपके पास यहां सक्रिय गतिविधि है, तो पूर्वाग्रह उतना प्रासंगिक नहीं है। आप बस प्रत्येक न्यूरॉन को चालू या बंद करना चाहते हैं। प्रश्न ने आपको पुरानी आउटपुट परत में बहुत स्पष्ट संकेतों को ग्रहण करने की अनुमति दी है।

$i=3$$A_3^{Old}$$Z_j^{New}$$Z_j^{New} = \Sigma_{i=0}^{i=9} W_{ij} * A_i^{Old}$ के रूप में इस प्रकार है:

$$W_{3,0} = -10$$ $$W_{3,1} = -10$$ $$W_{3,2} = +10$$ $$W_{3,3} = +10$$

यह स्पष्ट रूप से 0 0 1 1आउटपुट के करीब होना चाहिए जब केवल "3" का प्रतिनिधित्व करने वाली पुरानी आउटपुट परत का न्यूरॉन सक्रिय हो। प्रश्न में, आप पुरानी परत में प्रतिस्पर्धा करने वालों के लिए एक न्यूरॉन के 0.99 सक्रियण और <0.01 मान सकते हैं। इसलिए, यदि आप पूरे वजन के समान परिमाण का उपयोग करते हैं, तो अन्य पुरानी परत सक्रियण मूल्यों से + -0.1 (0.01 * 10) से आने वाले अपेक्षाकृत छोटे मूल्य + -9.9 मूल्य और नई परत में आउटपुट को गंभीरता से प्रभावित नहीं करेंगे। 0 या 1 के बहुत करीब से संतृप्त किया जाएगा।

Comments

धन्यवाद। मैं इस भाग का काफी अनुसरण नहीं कर सका, क्या आप आगे कृपया विस्तार से बताएंगे? - "मेरे पास पुराने आउटपुट i = 3, AOld3 के सक्रियण से नए आउटपुट ZNewj के लॉग इन करने के लिए हो सकते हैं, जहाँ ZNewj = Σi = 9i = 0Wij O Aldldi इस प्रकार है: W3,0 = −10 W3,1 = −10 W3 , 2 = + 10 W3,3 = + 10 "

— विक्टर यिप

$A_i = f( Z_i )$$f$

@NeilSlater - क्या आपका उदाहरण 3 नहीं होने वाले आउटपुट के लिए वजन काम करेगा? मुझे नहीं लगता कि वे करेंगे। कृपया विस्तार से बताएं। धन्यवाद।

— फुलस्टैक

$A_3^{old}$

@ Rrz0: क्योंकि मैं आउटपुट पर एक सिग्मॉइड परत मान रहा हूं, क्योंकि यह एक द्विआधारी वर्गीकरण है - बिट या तो चालू या बंद है। तो आपके उदाहरण में आपको वह मिलता है sigmoid((0 * 10) * 1)जो 0.5 है। उपयुक्त रूप से बड़ी संख्या का चयन करके, आप सिग्मॉइड से पहले या तो बहुत अधिक या निम्न आउटपुट सुनिश्चित करते हैं, जो तब 0 या 1 के करीब आउटपुट होगा। यह फुलस्टैक के उत्तर में रेखीय आउटपुट की तुलना में अधिक मजबूत आईएमओ है, लेकिन इसे अनदेखा करना, अनिवार्य रूप से हमारे दो उत्तर समान हैं।

— नील स्लेटर

Answer 2

SaturnAPI से नीचे का कोड इस प्रश्न का उत्तर देता है। 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)

Comments

ध्यान दें कि यह रैखिक उत्पादन परत के लिए भार का एक सेट लागू करता है। इसके विपरीत, मेरा जवाब आउटपुट लेयर में सिग्मॉइड एक्टिवेशन को मानता है। अन्यथा दो उत्तर बराबर हैं।

— नील स्लेटर

इनपुट्स से क्या अभिप्राय है eye(10,10)?

— 15

हाँ, यह वास्तव में एक आकर्षण की तरह काम करता है, बस इसे ऑक्टेव ऑनलाइन में कोशिश की और पुष्टि की, धन्यवाद !! ... PS: थोड़ा सा ओ स्पष्टीकरण भी अच्छा होगा, किसी को अटक जाना चाहिए :)

— Anaximandro Andrade

@ Rrz0 यह पहचान मैट्रिक्स बनाने के लिए एक मैटलैब / ऑक्टेव फ़ंक्शन है (मुख्य विकर्ण में सिर्फ लोगों के साथ)

— Anaximandro Andrade

Answer 3

उपरोक्त अभ्यास के लिए पायथोनिक प्रमाण:

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

Answer 4

ऑक्टेव का उपयोग करके नील स्लेटर की टिप्पणियों के बारे में फुलस्टैक के उत्तर में थोड़ा संशोधन :

% 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')