इस लेख का उद्देश्य न्यूरल नेटवर्क को जीवन के खेल को बिना सिखाए उसे खेल के नियम सिखाना है।

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

यदि आप जीवन नामक खेल से परिचित नहीं हैं ( यह 1970 में अंग्रेजी गणितज्ञ जॉन कॉनवे द्वारा आविष्कार किया गया एक कोशिकीय ऑटोमोबेटन है ), नियम इस प्रकार हैं।

खेल ब्रह्मांड एक अनंत, दो आयामी ग्रिड वर्ग कोशिकाओं का है, जिनमें से प्रत्येक दो संभावित राज्यों में से एक है: जीवित या मृत (या क्रमशः बसे हुए और निर्जन,)। प्रत्येक कोशिका अपने आठ पड़ोसियों के साथ क्षैतिज, लंबवत या तिरछे तरीके से बातचीत करती है। प्रत्येक समय कदम पर, निम्नलिखित संक्रमण होते हैं:

• दो जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका मर जाती है।
• दो या तीन जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका अगली पीढ़ी तक जीवित रहती है।
• तीन से अधिक जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका मर जाती है।
• ठीक तीन जीवित पड़ोसियों के साथ कोई भी मृत कोशिका एक जीवित कोशिका बन जाती है।

प्रारंभिक पीढ़ी में प्रत्येक कोशिका में एक साथ उपरोक्त नियमों को लागू करने से पहली पीढ़ी का निर्माण होता है, जन्म और मृत्यु एक साथ समय पर असतत बिंदुओं पर होते हैं। प्रत्येक पीढ़ी पिछले का एक शुद्ध कार्य है। नई पीढ़ी को अगली पीढ़ी बनाने के लिए नियम लागू होते रहते हैं।

विवरण के लिए विकिपीडिया देखें।

ऐसा क्यों? मुख्य रूप से मनोरंजन के लिए, और दृढ़ तंत्रिका नेटवर्क के बारे में थोड़ा जानने के लिए।

इसलिए ...

खेल तर्क

पहली बात यह है कि एक फ़ंक्शन को परिभाषित करना है जो खेल के मैदान को इनपुट के रूप में लेता है और अगले राज्य को वापस करता है।

सौभाग्य से, इंटरनेट पर कई कार्यान्वयन उपलब्ध हैं, जैसे: https://jakevdp.imtqy.com/blog/2013/08/07/conways-game-of-life/ ।

वास्तव में, यह खेल के मैदान के मैट्रिक्स को इनपुट के रूप में लेता है, जहां 0 एक मृत सेल का प्रतिनिधित्व करता है, और 1 एक जीवित सेल का प्रतिनिधित्व करता है और उसी आकार के मैट्रिक्स को लौटाता है, लेकिन गेम के अगले पुनरावृत्ति पर प्रत्येक सेल की स्थिति को समाहित करता है।

import numpy as np def life_step(X): live_neighbors = sum(np.roll(np.roll(X, i, 0), j, 1) for i in (-1, 0, 1) for j in (-1, 0, 1) if (i != 0 or j != 0)) return (live_neighbors == 3) | (X & (live_neighbors == 2)).astype(int) 

खेल क्षेत्र पीढ़ी

खेल तर्क के बाद, हमें गेम फ़ील्ड को बेतरतीब ढंग से उत्पन्न करने और उन्हें कल्पना करने का एक तरीका चाहिए।

num_frames फ़ंक्शन एक निश्चित आकार और एक पूर्वनिर्धारित संभावना के साथ यादृच्छिक गेम फ़ील्ड्स के num_frames बनाता है जो प्रत्येक सेल "लाइव" होगा, और render_frames दो गेम फ़ील्ड्स की छवियों का प्रतिनिधित्व तुलना के लिए साइड से करते हैं (जीवित कोशिकाएं सफेद और मृत कोशिकाएं काली होती हैं):

 import matplotlib.pyplot as plt def generate_frames(num_frames, board_shape=(100,100), prob_alive=0.15): return np.array([ np.random.choice([False, True], size=board_shape, p=[1-prob_alive, prob_alive]) for _ in range(num_frames) ]).astype(int) def render_frames(frame1, frame2): plt.subplot(1, 2, 1) plt.imshow(frame1.flatten().reshape(board_shape), cmap='gray') plt.subplot(1, 2, 2) plt.imshow(frame2.flatten().reshape(board_shape), cmap='gray') 

आइए देखें कि ये क्षेत्र क्या दिखते हैं:

 board_shape = (20, 20) board_size = board_shape[0] * board_shape[1] probability_alive = 0.15 frames = generate_frames(10, board_shape=board_shape, prob_alive=probability_alive) print(frames.shape) # (num_frames, board_w, board_h) 

 (10, 20, 20) 

 print(frames[0]) 

 [[0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0], [0, 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, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1], [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0]]) 

इसके बाद, खेल क्षेत्र का पूर्णांक प्रतिनिधित्व एक छवि के रूप में लिया और प्रदर्शित किया जाता है।
खेल के मैदान की निम्न स्थिति को भी life_step फ़ंक्शन का उपयोग करके दाईं ओर दिखाया गया है:

 ender_frames(frames[1], life_step(frames[1])) 

भवन प्रशिक्षण और परीक्षण सेट

अब हम प्रशिक्षण, सत्यापन और परीक्षण के लिए डेटा उत्पन्न कर सकते हैं।

y_train / y_val / y_test में प्रत्येक तत्व y_train / y_val / y_test फ़ील्ड के प्रत्येक फ्रेम के लिए अगले गेम फ़ील्ड का प्रतिनिधित्व करेगा।

 def reshape_input(X): return X.reshape(X.shape[0], X.shape[1], X.shape[2], 1) def generate_dataset(num_frames, board_shape, prob_alive): X = generate_frames(num_frames, board_shape=board_shape, prob_alive=prob_alive) X = reshape_input(X) y = np.array([ life_step(frame) for frame in X ]) return X, y train_size = 70000 val_size = 10000 test_size = 20000 

 print("Training Set:") X_train, y_train = generate_dataset(train_size, board_shape, probability_alive) print(X_train.shape) print(y_train.shape) 

 Training Set: (70000, 20, 20, 1) (70000, 20, 20, 1) 

 print("Validation Set:") X_val, y_val = generate_dataset(val_size, board_shape, probability_alive) print(X_val.shape) print(y_val.shape) 

 Validation Set: (10000, 20, 20, 1) (10000, 20, 20, 1) 

 print("Test Set:") X_test, y_test = generate_dataset(test_size, board_shape, probability_alive) print(X_test.shape) print(y_test.shape) 

 Test Set: (20000, 20, 20, 1) (20000, 20, 20, 1) 

संवेदी तंत्रिका नेटवर्क निर्माण

अब हम केरस का उपयोग करके एक दृढ़ तंत्रिका नेटवर्क बनाने की दिशा में पहला कदम उठा सकते हैं। यहाँ मुख्य बिंदु कर्नेल आकार (3, 3) और चरण 1 है। वे CNN को वर्तमान सेल सहित उस क्षेत्र में प्रत्येक सेल के लिए आसपास की कोशिकाओं के 3x3 मैट्रिक्स का उपयोग करने के लिए कहते हैं।

उदाहरण के लिए, यदि निम्नलिखित एक गेम फ़ील्ड था, और हम मध्य सेल x में थे, तो वह विस्मयादिबोधक चिह्न के साथ चिह्नित सभी कोशिकाओं को देखेगा ! और सेल । फिर नेटवर्क सेल के साथ दाईं ओर जाता है और वही काम करता है, जब तक कि यह पूरे सेल और उसके पड़ोसियों को पूरे क्षेत्र में संसाधित न कर दे।

 0 0 0 0 0 0! ! ! 0 0! x ! 0 0! ! ! 0 0 0 0 0 0 

बाकी नेटवर्क बहुत सरल है, इसलिए मैंने विवरण में नहीं जाना है। यदि आप किसी चीज में रुचि रखते हैं, तो मैं प्रलेखन पढ़ने की सलाह देता हूं।

 from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Conv2D, MaxPool2D # CNN Properties filters = 50 kernel_size = (3, 3) # look at all 8 neighboring cells, plus itself strides = 1 hidden_dims = 100 model = Sequential() model.add(Conv2D( filters, kernel_size, padding='same', activation='relu', strides=strides, input_shape=(board_shape[0], board_shape[1], 1) )) model.add(Dense(hidden_dims)) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

summary फ़ंक्शन के आउटपुट पर एक नज़र डालें:

 model.summary() 

 _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_9 (Conv2D) (None, 20, 20, 50) 500 _________________________________________________________________ dense_17 (Dense) (None, 20, 20, 100) 5100 _________________________________________________________________ dense_18 (Dense) (None, 20, 20, 1) 101 _________________________________________________________________ activation_9 (Activation) (None, 20, 20, 1) 0 ================================================================= Total params: 5,701 Trainable params: 5,701 Non-trainable params: 0 _________________________________________________________________ 

एक मॉडल का प्रशिक्षण और बचत

CNN का निर्माण करने के बाद, मॉडल को प्रशिक्षित करें और इसे डिस्क पर सहेजें:

 def train(model, X_train, y_train, X_val, y_val, batch_size=50, epochs=2, filename_suffix=''): model.fit( X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_val, y_val) ) with open('cgol_cnn{}.json'.format(filename_suffix), 'w') as file: file.write(model.to_json()) model.save_weights('cgol_cnn{}.h5'.format(filename_suffix)) train(model, X_train, y_train, X_val, y_val, filename_suffix='_basic') 

 Train on 70000 samples, validate on 10000 samples Epoch 1/2 70000/70000 [==============================] - 27s 388us/step - loss: 0.1324 - acc: 0.9651 - val_loss: 0.0833 - val_acc: 0.9815 Epoch 2/2 70000/70000 [==============================] - 27s 383us/step - loss: 0.0819 - acc: 0.9817 - val_loss: 0.0823 - val_acc: 0.9816 

यह मॉडल प्रशिक्षण और परीक्षण सेट दोनों के लिए सिर्फ 98% से अधिक की सटीकता प्रदान करता है, जो पहले पास के लिए बहुत अच्छा है। आइए यह पता लगाने की कोशिश करें कि हम कहां गलतियां करते हैं।

कोशिश

आइए एक यादृच्छिक खेल मैदान के लिए पूर्वानुमान देखें और यह कैसे काम करता है। सबसे पहले, एक खेल मैदान बनाएं और सही अगले फ्रेम को देखें:

 X, y = generate_dataset(1, board_shape=board_shape, prob_alive=probability_alive) render_frames(X[0].flatten().reshape(board_shape), y) 

अगला, चलो भविष्यवाणी करते हैं और देखते हैं कि कितनी कोशिकाओं को गलत भविष्यवाणी की गई थी:

 pred = model.predict_classes(X) print(np.count_nonzero(pred.flatten() - y.flatten()), "incorrect cells.") 

 4 incorrect cells. 

अगला, आइए भविष्यवाणी किए गए कदम के साथ सही अगले चरण की तुलना करें:

 render_frames(y, pred.flatten().reshape(board_shape)) 

यह डरावना नहीं है, लेकिन आप देखते हैं कि भविष्यवाणी कहाँ विफल रही? ऐसा लगता है कि नेटवर्क खेल के मैदान के किनारों पर कोशिकाओं की भविष्यवाणी नहीं कर सकता है। आइए देखें कि गैर-शून्य मान गलत भविष्यवाणियों को कहां दर्शाते हैं:

 print(pred.flatten().reshape(board_shape) - y.flatten().reshape(board_shape)) 

 [[ 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 -1 -1 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0]] 

जैसा कि आप देख सकते हैं, सभी गैर-शून्य मान खेल के मैदान के किनारों पर स्थित हैं। आइए पूर्ण परीक्षण सूट को देखें और पुष्टि करें कि यह अवलोकन सत्य है।

परीक्षण सूट का उपयोग करके बग देखें

हम एक फ़ंक्शन लिखेंगे जो एक हीटमैप दिखाता है जहां मॉडल गलतियाँ करता है, और पूरे टेस्ट सूट का उपयोग करके इसे कॉल करें:

 def view_prediction_errors(model, X, y): y_pred = model.predict_classes(X) sum_y_pred = np.sum(y_pred, axis=0).flatten().reshape(board_shape) sum_y = np.sum(y, axis=0).flatten().reshape(board_shape) plt.imshow(sum_y_pred - sum_y, cmap='hot', interpolation='nearest') plt.show() view_prediction_errors(model, X_test, y_test) 

किनारों और कोनों पर सभी त्रुटियां। जो तर्कसंगत है, क्योंकि सीएनएन चारों ओर नहीं देख सकता है, लेकिन life_step में खेल का तर्क life_step करता है। उदाहरण के लिए, निम्नलिखित पर विचार करें। नीचे किनारे सेल x देखते हुए, CNN केवल x और ! सेल:

 0 0 0 0 0 ! ! 0 0 0 x ! 0 0 0 ! ! 0 0 0 0 0 0 0 0 

लेकिन हम वास्तव में क्या चाहते हैं और जो life_step करता है वह विपरीत दिशा से कोशिकाओं को देखता है:

 0 0 0 0 0 ! ! 0 0 ! x ! 0 0 ! ! ! 0 0 ! 0 0 0 0 0 

कोनों में एक समान स्थिति:

 x ! 0 0 ! ! ! 0 0 ! 0 0 0 0 0 0 0 0 0 0 ! 0 0 0 ! 

इसे ठीक करने के लिए, Conv2D को किसी तरह खेल मैदान के विपरीत दिशा में देखना चाहिए। वैकल्पिक रूप से, प्रत्येक इनपुट क्षेत्र को विपरीत दिशा में किनारों को भरने के लिए प्रीप्रोसेस किया जा सकता है, और फिर Conv2D बस पहले या अंतिम कॉलम और पंक्ति को हटा सकता है। चूँकि हम करैस की दया पर हैं और यह जो कार्यशीलता प्रदान करता है, वह प्रदान करता है कि हम जो खोज रहे हैं उसका समर्थन नहीं करते हैं, हमें अपनी स्वयं की भरण राशि का सहारा लेना होगा।

भरने का उपयोग कर बढ़त दोषों का सुधार

हमें प्रत्येक खेल मैदान को एक विपरीत मान के साथ पूरक करने की आवश्यकता है जो कि life_step मूल्यों के लिए कैसे काम करता है। हम इसके लिए mode = 'wrap' साथ np.pad उपयोग कर सकते हैं। उदाहरण के लिए, नीचे दिए गए सरणी और संवर्धित आउटपुट पर विचार करें:

 x = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]) print(np.pad(x, (1, 1), mode='wrap')) 

 [[9, 7, 8, 9, 7], [3, 1, 2, 3, 1], [6, 4, 5, 6, 4], [9, 7, 8, 9, 7], [3, 1, 2, 3, 1]] 

ध्यान दें कि पहला स्तंभ / पंक्ति और अंतिम स्तंभ / पंक्ति मूल मैट्रिक्स के विपरीत तरफ दर्पण है, और मध्य 3x3 मैट्रिक्स मूल x मूल्य है। उदाहरण के लिए, सेल [1] [1] को सेल [४] [१] में विपरीत दिशा में कॉपी किया गया था, और इसी तरह [०] [१] इसमें [३] [१] सम्‍मिलित है। सभी दिशाओं में और यहां तक ​​कि कोनों में, सरणी को सही किया गया था ताकि इसमें विपरीत पक्ष शामिल हो। इससे सीएनएन पूरे खेल मैदान की समीक्षा करने और चरम मामलों को सही ढंग से संभालने की अनुमति देगा।

अब हम अपने सभी इनपुट मैट्रिसेस को पॉप्युलेट करने के लिए एक फंक्शन लिख सकते हैं:

 def pad_input(X): return reshape_input(np.array([ np.pad(x.reshape(board_shape), (1,1), mode='wrap') for x in X ])) X_train_padded = pad_input(X_train) X_val_padded = pad_input(X_val) X_test_padded = pad_input(X_test) print(X_train_padded.shape) print(X_val_padded.shape) print(X_test_padded.shape) 

 (70000, 22, 22, 1) (10000, 22, 22, 1) (20000, 22, 22, 1) 

सभी डेटासेट अब लिपटे हुए स्तंभों / पंक्तियों के साथ पूरक हैं, जो CNN को खेल के मैदान के विपरीत पक्ष को देखने की अनुमति देता है, जैसा कि life_step करता है। इस वजह से, प्रत्येक खेल मैदान का मूल 20x20 के बजाय अब 22x22 का आकार है।

फिर, CNN को padding = 'valid' का उपयोग कर padding = 'valid' को त्यागने के लिए फिर से बनाया जाना चाहिए (जो कि कन्वर्ज़न को किनारों को त्यागने के लिए कहता है, हालाँकि यह तुरंत स्पष्ट नहीं है), और नए input_shape हैंडल करें। इस प्रकार, जब हम 22x22 के आकार के साथ खेल मैदान छोड़ते हैं, तब भी हमें आउटपुट के रूप में 20x20 का आकार मिलता है, क्योंकि हम पहले और आखिरी कॉलम / पंक्ति को छोड़ देते हैं। बाकी समान है:

 model_padded = Sequential() model_padded.add(Conv2D( filters, kernel_size, padding='valid', activation='relu', strides=strides, input_shape=(board_shape[0] + 2, board_shape[1] + 2, 1) )) model_padded.add(Dense(hidden_dims)) model_padded.add(Dense(1)) model_padded.add(Activation('sigmoid')) model_padded.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model_padded.summary() 

 _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_10 (Conv2D) (None, 20, 20, 50) 500 _________________________________________________________________ dense_19 (Dense) (None, 20, 20, 100) 5100 _________________________________________________________________ dense_20 (Dense) (None, 20, 20, 1) 101 _________________________________________________________________ activation_10 (Activation) (None, 20, 20, 1) 0 ================================================================= Total params: 5,701 Trainable params: 5,701 Non-trainable params: 0 _________________________________________________________________ 

अब हम संरेखित फ़ील्ड का उपयोग करके सीख सकते हैं:

 train( model_padded, X_train_padded, y_train, X_val_padded, y_val, filename_suffix='_padded' ) 

 Train on 70000 samples, validate on 10000 samples Epoch 1/2 70000/70000 [==============================] - 27s 389us/step - loss: 0.0604 - acc: 0.9807 - val_loss: 4.5475e-04 - val_acc: 1.0000 Epoch 2/2 70000/70000 [==============================] - 27s 382us/step - loss: 1.7058e-04 - acc: 1.0000 - val_loss: 5.9932e-05 - val_acc: 1.0000 

भविष्यवाणी की सटीकता 98% से 100% है, जो हमें इंडेंटेशन को जोड़ने से पहले मिली थी। आइए परीक्षण के मामले में त्रुटि को देखें:

 view_prediction_errors(model_padded, X_test_padded, y_test) 

बहुत बढ़िया! ब्लैक हीट मैप बताता है कि मूल्यों में कोई अंतर नहीं है, और इसका मतलब है कि हमने प्रत्येक खेल के लिए प्रत्येक सेल की सफलतापूर्वक भविष्यवाणी की है।

यह एक बड़ा डेटासेट का उपयोग किए बिना जटिल तंत्रिका नेटवर्क के साथ खेलने के लिए एक छोटा सा व्यायाम था। GitHub पर देखने के लिए स्वतंत्र महसूस करें ।