NVIDIA जेटसन नैनो: टेस्ट और फर्स्ट इंप्रेशन - भाग 2, एआई टेस्ट

हाय, हैब्र।

पहले भाग में , NVIDIA जेटसन नैनो को माना गया था - रास्पबेरी पाई फॉर्म फैक्टर में एक बोर्ड, GPU का उपयोग करके प्रदर्शन कंप्यूटिंग पर केंद्रित था। यह बोर्ड का परीक्षण करने का समय है कि यह एआई-उन्मुख गणनाओं के लिए क्या बनाया गया था।



विचार करें कि बोर्ड पर विभिन्न कार्य कैसे चलते हैं, जैसे कि चित्रों को वर्गीकृत करना या पैदल चलने वालों या जवानों को पहचानना (जहां उनके बिना)। सभी परीक्षणों के लिए, डेस्कटॉप पर चलाए जा सकने वाले स्रोत कोड, जेटसन नैनो या रास्पबेरी पाई दिए गए हैं। जो दिलचस्पी रखते हैं, उनके लिए कटौती जारी है।

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

छवि वर्गीकरण

छवि पहचान की समस्या पर विचार करें। ऐसा करने के लिए, हम केरस के साथ आपूर्ति की गई ResNet50 मॉडल का उपयोग करेंगे (यह मॉडल 2015 में इमेजनेट चैलेंज का विजेता था)। इसका उपयोग करने के लिए, कोड की कुछ पंक्तियाँ पर्याप्त हैं।

import tensorflow as tf import numpy as np import time IMAGE_SIZE = 224 IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3) resnet = tf.keras.applications.ResNet50(input_shape=IMG_SHAPE) img = tf.contrib.keras.preprocessing.image.load_img('cat.png', target_size=(IMAGE_SIZE, IMAGE_SIZE)) t_start = time.time() img_data = tf.contrib.keras.preprocessing.image.img_to_array(img) x = tf.contrib.keras.applications.resnet50.preprocess_input(np.expand_dims(img_data, axis=0)) probabilities = resnet.predict(x) print(tf.contrib.keras.applications.resnet50.decode_predictions(probabilities, top=5)) print("dT", time.time() - t_start) 

मैंने स्पॉइलर के तहत कोड निकालना भी शुरू नहीं किया, क्योंकि वह बहुत छोटा है। जैसा कि आप देख सकते हैं, छवि को पहले 224x224 (यह इनपुट नेटवर्क प्रारूप है) में बदल दिया जाता है, अंत में, पूर्वानुमान कार्य सभी कार्य करता है।

हम बिल्ली की तस्वीर लेते हैं और कार्यक्रम चलाते हैं।



परिणाम:

 [[('n02123045', 'tabby', 0.765179), ('n02123159', 'tiger_cat', 0.19059166), ('n02124075', 'Egyptian_cat', 0.013605555), ('n04493381', 'tub', 0.0025916891), ('n04553703', 'washbasin', 0.0021566998)]] 

एक बार फिर अंग्रेजी के अपने ज्ञान से परेशान (मुझे आश्चर्य है कि कितने गैर-देशी लोग जानते हैं कि "टैबबी" क्या है?), मैंने शब्दकोश के साथ आउटपुट की जांच की, हां, सब कुछ काम करता है।

सीपीयू पर गणना के लिए पीसी कोड निष्पादन का समय 0.5 एस था और जीपीयू पर गणना के लिए 2 एस (!)। लॉग को देखते हुए, समस्या या तो मॉडल या टेन्सरफ़्लो में है, लेकिन जब यह शुरू होता है, तो कोड बहुत सी मेमोरी को आवंटित करने की कोशिश करता है, फॉर्म की कई चेतावनियां प्राप्त करते हुए "एलोकेटर (GPU_0_bfc) मेमोरी से बाहर भाग गया। 2.13GiB को freed_by_count = 0. के साथ आवंटित करने की कोशिश कर रहा है।" । यह एक चेतावनी है और एक त्रुटि नहीं है, कोड काम करता है, लेकिन इसके मुकाबले बहुत धीमा होना चाहिए।

जेटसन नैनो पर, यह अभी भी धीमा है: सीपीयू पर 2.8c और GPU पर 18.8c , जबकि आउटपुट इस तरह है:



सामान्य तौर पर, प्रति छवि 3s भी, यह वास्तविक समय नहीं है। स्टैक ओवरफ्लो पर अनुशंसित gpu_options.allow_growth विकल्प सेट करने से कोई मदद नहीं मिलती है, अगर किसी को कोई अन्य तरीका पता है, तो टिप्पणियों में लिखें।

संपादित करें : जैसा कि टिप्पणियों में कहा गया है, टेंसरफ़्लो की पहली शुरुआत हमेशा एक लंबा समय लेती है, और इसका उपयोग करके समय को मापना गलत है। वास्तव में, दूसरी और बाद की फ़ाइलों को संसाधित करते समय, परिणाम बहुत बेहतर होते हैं - एक GPU के बिना 0.6s और एक GPU के साथ 0.2s। डेस्कटॉप पर, गति, क्रमशः, 2.0s और 0.05s है।

ResNet50 की एक सुविधाजनक विशेषता यह है कि पहली शुरुआत में यह पूरे मॉडल को डिस्क (लगभग 100 एमबी) पर पंप करता है, फिर कोड पूरी तरह से स्वायत्तता से काम करता है, बिना पंजीकरण और एसएमएस के। जो विशेष रूप से अच्छा है, यह देखते हुए कि अधिकांश आधुनिक AI- सेवाएँ केवल सर्वर पर काम करती हैं, और इंटरनेट के बिना, डिवाइस एक "कद्दू" में बदल जाता है।

कुत्ते बनाम कुत्ते

निम्नलिखित समस्या पर विचार करें। Keras का उपयोग करके, हम एक तंत्रिका नेटवर्क बनाएंगे जो बिल्लियों और कुत्तों के बीच अंतर कर सकता है। यह एक कन्वेन्शनल न्यूरल नेटवर्क होगा (CNN - कन्वेंशनल न्यूरल नेटवर्क), हम इस प्रकाशन से नेटवर्क डिज़ाइन लेंगे। बिल्लियों और कुत्तों की छवियों का एक प्रशिक्षण सेट पहले से ही टेनसोरफ़्लो_डेटासेट पैकेज में शामिल है, इसलिए आपको उन्हें स्वयं फोटो नहीं देना होगा।

हम छवियों का एक सेट लोड करते हैं और इसे तीन ब्लॉकों में विभाजित करते हैं - प्रशिक्षण, सत्यापन और परीक्षण। हम प्रत्येक चित्र को "सामान्यीकृत" करते हैं, रंगों को 0..1 की सीमा में लाते हैं।

 import tensorflow as tf from tensorflow.keras import layers import tensorflow_datasets as tfds from keras.preprocessing import image import numpy as np import time IMAGE_SIZE = 64 IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3) splits = tfds.Split.TRAIN.subsplit(weighted=(80, 10, 10)) (cat_train, cat_valid, cat_test), info = tfds.load('cats_vs_dogs', split=list(splits), with_info=True, as_supervised=True) label_names = info.features['label'].int2str def pre_process_image(image, label): image = tf.cast(image, tf.float32) image = image / 255.0 # Normalize image: 0..255 -> 0..1 image = tf.image.resize(image, (IMAGE_SIZE, IMAGE_SIZE)) return image, label BATCH_SIZE = 32 SHUFFLE_BUFFER_SIZE = 1000 train_batch = cat_train.map(pre_process_image).shuffle(SHUFFLE_BUFFER_SIZE).repeat().batch(BATCH_SIZE) validation_batch = cat_valid.map(pre_process_image).repeat().batch(BATCH_SIZE) 

हम एक दृढ़ तंत्रिका नेटवर्क बनाने का कार्य लिखते हैं।

 def custom_model(): # Source: https://medium.com/@ferhat00/deep-learning-with-keras-classifying-cats-and-dogs-part-1-982067594856 classifier = tf.keras.Sequential() # Step 1 — Convolution classifier.add(layers.Conv2D(32, (3, 3), input_shape=IMG_SHAPE, activation='relu')) # Step 2 — Pooling classifier.add(layers.MaxPooling2D(pool_size=(2, 2))) # Adding a second convolutional layer classifier.add(layers.Conv2D(32, (3, 3), activation='relu')) classifier.add(layers.MaxPooling2D(pool_size=(2, 2))) # Step 3 — Flattening classifier.add(layers.Flatten()) # Step 4 — Full connection classifier.add(layers.Dense(units=128, activation='relu')) classifier.add(layers.Dense(units=1, activation='sigmoid')) # Compiling the CNN we shall use the Adam stochastic optimisation method, binary cross entropy loss function classifier.compile(optimizer=tf.keras.optimizers.Adam(), loss='binary_crossentropy', metrics=['accuracy']) return classifier 

अब हम अपने "कैट-डॉग" किट पर नेटवर्क प्रशिक्षण चला सकते हैं। प्रशिक्षण में एक लंबा समय लगता है (GPU पर 20 मिनट और CPU पर 1-2 घंटे), इसलिए अंत में हम मॉडल को एक फ़ाइल में सहेजते हैं।

 tl_model = custom_model() t_start = time.time() tl_model.fit(train_batch, steps_per_epoch=8000, epochs=2, validation_data=validation_batch, validation_steps=10, callbacks=None) print("Training done, dT:", time.time() - t_start) print(tl_model.summary()) validation_steps = 20 loss0, accuracy0 = tl_model.evaluate(validation_batch, steps=validation_steps) print("Loss: {:.2f}".format(loss0)) print("Accuracy: {:.2f}".format(accuracy0)) tl_model.save("dog_cat_model.h5") 

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

फिर एक और नुकसान सामने आया - पीसी पर टेंसोफ्लो संस्करण 14 लाइब्रेरी स्थापित की गई, और जेटसन नैनो के लिए अब तक का नवीनतम संस्करण 13. है और 14 वें संस्करण में सहेजे गए मॉडल को 13 वें में नहीं पढ़ा गया था, मुझे पाइप का उपयोग करके समान संस्करण स्थापित करना था।

अंत में, हम मॉडल को एक फ़ाइल से लोड कर सकते हैं और छवियों को पहचानने के लिए इसका उपयोग कर सकते हैं।

 def predict_model(model, image_file): img = image.load_img(image_file, target_size=(IMAGE_SIZE, IMAGE_SIZE)) t_start = time.time() img_arr = np.expand_dims(img, axis=0) result = model.predict_classes(img_arr) print("Result: {}, dT: {}".format(label_names(result[0][0]), time.time() - t_start)) model = tf.keras.models.load_model('dog_cat_model.h5') predict_model(model, "cat.png") predict_model(model, "dog1.png") predict_model(model, "dog2.png") 

बिल्ली की तस्वीर का उपयोग किया गया था, लेकिन "कुत्ते" परीक्षण के लिए 2 चित्रों का उपयोग किया गया था:



पहले ने सही अनुमान लगाया, और दूसरे में पहली बार त्रुटियां थीं और तंत्रिका नेटवर्क ने सोचा कि यह एक बिल्ली है, मुझे प्रशिक्षण की पुनरावृत्तियों की संख्या में वृद्धि करनी थी। हालाँकि, मैंने शायद पहली बार गलती की होगी;)

जेटसन नैनो पर निष्पादन का समय काफी छोटा हो गया था - बहुत पहले फोटो 0.3 में संसाधित किया गया था, लेकिन बाद के सभी बहुत तेज थे, जाहिर है डेटा स्मृति में कैश्ड है।



सामान्य तौर पर, हम यह मान सकते हैं कि ऐसे सरल तंत्रिका नेटवर्क पर, बोर्ड की गति बिना किसी अनुकूलन के भी काफी पर्याप्त है, 100fps वास्तविक समय में वीडियो के लिए भी पर्याप्त मूल्य है।

निष्कर्ष

जैसा कि आप देख सकते हैं, यहां तक ​​कि केरस और टेन्सरफ्लो के मानक मॉडल का उपयोग नैनो पर किया जा सकता है, भले ही अलग-अलग सफलता के साथ - कुछ काम करता है, कुछ नहीं करता है। हालांकि, परिणामों में सुधार किया जा सकता है, मॉडल को अनुकूलित करने और स्मृति आकार को कम करने के निर्देश यहां पढ़े जा सकते हैं ।

लेकिन सौभाग्य से हमारे लिए, निर्माताओं ने हमारे लिए यह किया है। यदि पाठकों में अभी भी रुचि है, तो अंतिम भाग जेट्सन नैनो के साथ काम करने के लिए अनुकूलित पुस्तकालयों के लिए समर्पित होगा।