एक तंत्रिका नेटवर्क बनाना: मस्तिष्क को कैसे तोड़ना है

नमस्कार, हेब्र!

इस छोटे से लेख में मैं आपको उन दो नुकसानों के बारे में बताऊंगा जिनके साथ टकराना आसान है और जिनके बारे में तोड़ना आसान है।

यह केरस पर एक तुच्छ तंत्रिका नेटवर्क बनाने के बारे में होगा, जिसके साथ हम दो संख्याओं के अंकगणितीय माध्य की भविष्यवाणी करेंगे।

ऐसा लगता है कि यह आसान हो सकता है। और वास्तव में, कुछ भी जटिल नहीं है, लेकिन बारीकियां हैं।

जिनके लिए विषय दिलचस्प है, कट के तहत स्वागत है, लंबे समय तक उबाऊ वर्णन नहीं होगा, बस एक छोटा कोड और उस पर टिप्पणी।

समाधान कुछ इस तरह दिखता है:

import numpy as np from keras.layers import Input, Dense, Lambda from keras.models import Model import keras.backend as K #   def train_iterator(batch_size=64): x = np.zeros((batch_size, 2)) while True: for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean = (x[::,0] + x[::,1]) / 2 x_mean_ex = np.expand_dims(x_mean, -1) yield [x], [x_mean_ex] #  def create_model(): x = Input(name = 'x', shape=(2,)) x_mean = Dense(1)(x) model = Model(inputs=x, outputs=x_mean) return model #    model = create_model() model.compile(loss=['mse'], optimizer = 'rmsprop') model.fit_generator(train_iterator(), steps_per_epoch = 1000, epochs = 100, verbose = 1) #  x, x_mean = next(train_iterator(1)) print(x, x_mean, model.predict(x)) 

सीखने की कोशिश कर रहा है ... लेकिन कुछ भी नहीं आता है। और यहां इस जगह में आप एक नखरे के साथ नृत्य की व्यवस्था कर सकते हैं और बहुत समय खो सकते हैं।

 Epoch 1/100 1000/1000 [==============================] - 2s 2ms/step - loss: 1044.0806 Epoch 2/100 1000/1000 [==============================] - 2s 2ms/step - loss: 713.5198 Epoch 3/100 1000/1000 [==============================] - 3s 3ms/step - loss: 708.1110 ... Epoch 98/100 1000/1000 [==============================] - 2s 2ms/step - loss: 415.0479 Epoch 99/100 1000/1000 [==============================] - 2s 2ms/step - loss: 416.6932 Epoch 100/100 1000/1000 [==============================] - 2s 2ms/step - loss: 417.2400 [array([[73., 57.]])] [array([[65.]])] [[49.650894]] 

49 की भविष्यवाणी की गई थी, जो 65 से दूर है।

लेकिन जैसे ही हम जनरेटर को थोड़ा कम करते हैं, सब कुछ तुरंत काम करना शुरू कर देता है।

 def train_iterator_1(batch_size=64): x = np.zeros((batch_size, 2)) x_mean = np.zeros((batch_size,)) while True: for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean[::] = (x[::,0] + x[::,1]) / 2 x_mean_ex = np.expand_dims(x_mean, -1) yield [x], [x_mean_ex] 

और यह स्पष्ट है कि पहले से ही सचमुच तीसरे युग में नेटवर्क परिवर्तित हो रहा है।

 Epoch 1/5 1000/1000 [==============================] - 2s 2ms/step - loss: 648.9184 Epoch 2/5 1000/1000 [==============================] - 2s 2ms/step - loss: 0.0177 Epoch 3/5 1000/1000 [==============================] - 2s 2ms/step - loss: 0.0030 

मुख्य अंतर यह है कि पहले मामले में, x_mean ऑब्जेक्ट को हर बार मेमोरी में बनाया जाता है, और दूसरे मामले में, यह तब दिखाई देता है जब जनरेटर बनाया जाता है और फिर इसे केवल पुन: उपयोग किया जाता है।

हम आगे समझते हैं कि क्या इस जनरेटर में सब कुछ सही है। यह पता चला है कि वास्तव में नहीं।
निम्नलिखित उदाहरण से पता चलता है कि कुछ गलत हो रहा है।

 def train_iterator(batch_size=1): x = np.zeros((batch_size, 2)) while True: for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean = (x[::,0] + x[::,1]) / 2 yield x, x_mean it = train_iterator() print(next(it), next(it)) 

(array([[44., 2.]]), array([10.])) (array([[44., 2.]]), array([23.]))

पहली पुनरावृत्ति कॉल में औसत मूल्य उस संख्या के आधार पर मेल नहीं खाता है जिसके आधार पर इसकी गणना की जाती है। वास्तव में, औसत मूल्य की सही गणना की गई थी, लेकिन क्योंकि सरणी को संदर्भ द्वारा पारित किया गया था, दूसरी बार जब इसे पुनरावृत्त कहा जाता था, तो सरणी में मानों को ओवरराइट कर दिया गया था, और प्रिंट () फ़ंक्शन सरणी में क्या था, लौटा दिया गया था, और जो हमें उम्मीद नहीं थी।

इसे ठीक करने के दो तरीके हैं। दोनों महंगे हैं लेकिन सही हैं।
1. चर लूप के अंदर चर x के निर्माण को स्थानांतरित करें ताकि प्रत्येक उपज पर एक सरणी बनाई जाए।

 def train_iterator_1(batch_size=1): while True: x = np.zeros((batch_size, 2)) for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean = (x[::,0] + x[::,1]) / 2 yield x, x_mean it_1 = train_iterator_1() print(next(it_1), next(it_1)) 

(array([[82., 4.]]), array([43.])) (array([[77., 34.]]), array([55.5]))


2. सरणी की एक प्रति लौटाएं।

 def train_iterator_2(batch_size=1): x = np.zeros((batch_size, 2)) while True: x = np.zeros((batch_size, 2)) for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean = (x[::,0] + x[::,1]) / 2 yield np.copy(x), x_mean it_2 = train_iterator_2() print(next(it_2), next(it_2)) 

(array([[63., 31.]]), array([47.])) (array([[94., 25.]]), array([59.5]))


अब सब ठीक है। आगे बढ़ो।

क्या Expand_dims किए जाने की आवश्यकता है? आइए इस लाइन को हटाने की कोशिश करें और नया कोड इस तरह होगा:

 def train_iterator(batch_size=64): while True: x = np.zeros((batch_size, 2)) for i in range(batch_size): x[i][0] = np.random.randint(0, 100) x[i][1] = np.random.randint(0, 100) x_mean = (x[::,0] + x[::,1]) / 2 yield [x], [x_mean] 

सब कुछ ठीक सीखता है, हालांकि लौटाए गए डेटा का एक अलग आकार है।

उदाहरण के लिए, [[४ ९।]] था, और यह [४ ९।] बन गया, लेकिन केरस के अंदर, यह, जाहिरा तौर पर, वांछित आयाम तक सही ढंग से घटा है।

तो, हम जानते हैं कि सही डेटा जनरेटर को किस तरह दिखना चाहिए, अब लैम्बडा फ़ंक्शन के साथ खेलते हैं, और वहां विस्तारा_डिम्स व्यवहार को देखें।

हम किसी भी चीज की भविष्यवाणी नहीं करेंगे, हम सिर्फ लैम्ब्डा के अंदर सही मूल्य पर विचार करते हैं।

कोड निम्नानुसार है:

 def calc_mean(x): res = (x[::,0] + x[::,1]) / 2 res = K.expand_dims(res, -1) return res def create_model(): x = Input(name = 'x', shape=(2,)) x_mean = Lambda(lambda x: calc_mean(x), output_shape=(1,))(x) model = Model(inputs=x, outputs=x_mean) return model 

हम शुरू करते हैं और देखते हैं कि सब कुछ ठीक है:

 Epoch 1/5 100/100 [==============================] - 0s 3ms/step - loss: 0.0000e+00 Epoch 2/5 100/100 [==============================] - 0s 2ms/step - loss: 0.0000e+00 Epoch 3/5 100/100 [==============================] - 0s 3ms/step - loss: 0.0000e+00 

अब अपने लैम्ब्डा फ़ंक्शन को थोड़ा संशोधित करने और एक्सपेंशन_डिम्स हटाने की कोशिश करते हैं।

 def calc_mean(x): res = (x[::,0] + x[::,1]) / 2 return res 

मॉडल को संकलित करते समय, आयाम पर कोई त्रुटि नहीं दिखाई दी, लेकिन परिणाम पहले से ही अलग है, नुकसान को समझ से बाहर माना जाता है कि कैसे। तो यहाँ का विस्तार_ करने की आवश्यकता है, कुछ भी अपने आप नहीं होगा।

 Epoch 1/5 100/100 [==============================] - 0s 3ms/step - loss: 871.6299 Epoch 2/5 100/100 [==============================] - 0s 3ms/step - loss: 830.2568 Epoch 3/5 100/100 [==============================] - 0s 2ms/step - loss: 830.8041 

और यदि आप भविष्यवाणी () लौटाए गए परिणाम को देखते हैं, तो आप देख सकते हैं कि आयाम गलत है, आउटपुट [46.] है, और अपेक्षित [[46.]] है।

कुछ इस तरह। इसे पढ़ने वाले सभी को धन्यवाद। और विवरण में सावधान रहें, उनमें से प्रभाव महत्वपूर्ण हो सकता है।