🚵🏿 🚔 👨🏽‍🔧 कृत्रिम बुद्धि के लिए चीट शीट - अतिरिक्त फेंक दें, मुख्य बात सिखाएं। प्रशिक्षण अनुक्रम प्रसंस्करण तकनीक 🏾 💖 🔻

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

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

कागल समुद्री खोज प्रतियोगिता हाल ही में समाप्त हुई है। एयरबस ने जहाजों के साथ और बिना समुद्र के उपग्रह चित्रों का विश्लेषण करने का प्रस्ताव दिया। कुल 192555 चित्र 768x768x3 - 340 720 680 960 बाइट्स हैं यदि uint8 और यह एक बड़ी मात्रा में जानकारी है और एक अस्पष्ट संदेह था कि नेटवर्क के प्रशिक्षण के लिए सभी चित्रों की आवश्यकता नहीं है और इस जानकारी में पुनरावृत्ति और अतिरेक स्पष्ट हैं। एक नेटवर्क को प्रशिक्षित करते समय, यह कुछ डेटा को अलग करने और प्रशिक्षण में इसका उपयोग नहीं करने के लिए प्रथागत है, लेकिन इसका उपयोग प्रशिक्षण की गुणवत्ता को सत्यापित करने के लिए करें। और अगर समुद्र का एक और एक ही खंड दो अलग-अलग छवियों में गिर गया और एक ही समय में एक छवि प्रशिक्षण अनुक्रम में और दूसरी सत्यापन क्रम में गिर गई, तो सत्यापन अपना अर्थ खो देगा और नेटवर्क पीछे हट जाएगा, हम जानकारी को सामान्य करने के लिए नेटवर्क की क्षमता की जांच नहीं करेंगे, क्योंकि डेटा समान है। इस घटना के खिलाफ लड़ाई में प्रतिभागियों के GPU का बहुत समय और प्रयास लगा। हमेशा की तरह, विजेताओं और पुरस्कार विजेताओं को अपने प्रशंसकों को महारत के रहस्यों को दिखाने और कोड को बाहर करने की कोई जल्दी नहीं है, और इसका अध्ययन करने और इसे सीखने का कोई तरीका नहीं है, इसलिए हम सिद्धांत का पालन करेंगे।

एक साधारण दृश्य जांच से पता चला कि वास्तव में बहुत अधिक डेटा है, समुद्र का एक ही खिंचाव विभिन्न चित्रों में गिर गया, उदाहरण देखें

यह इस कारण से है कि हम वास्तविक डेटा में रुचि नहीं रखते हैं, बहुत अधिक निर्भरताएं हैं, हमारे लिए अनावश्यक कनेक्शन, खराब मार्कअप और अन्य कमियां हैं।

पहले लेख में, हमने दीर्घवृत्त और शोर के साथ चित्रों को देखा, और हम उनका अध्ययन करना जारी रखेंगे। इस दृष्टिकोण का लाभ यह है कि यदि आपको चित्रों के एक मनमाने सेट पर प्रशिक्षित नेटवर्क का कोई आकर्षक फीचर मिलता है, तो यह स्पष्ट नहीं है कि यह नेटवर्क संपत्ति है या प्रशिक्षण सेट की संपत्ति है। वास्तविक दुनिया से लिए गए दृश्यों के सांख्यिकीय पैरामीटर अज्ञात हैं। हाल ही में, ग्रैंडमास्टर प्लास्कोव पावले पस्के ने इस बारे में बात की थी कि कभी-कभी तस्वीरों का विभाजन / वर्गीकरण वर्गीकरण जीतना कितना आसान होता है यदि यह स्वयं डेटा में तल्लीनता के लिए अच्छा है, उदाहरण के लिए, फोटो मेटाडेटा देखें। और इस बात की कोई गारंटी नहीं है कि वास्तविक आंकड़ों में ऐसी कोई निर्भरता नहीं है, अनैच्छिक रूप से छोड़ दिया गया है। इसलिए, नेटवर्क के गुणों का अध्ययन करने के लिए, हम दीर्घवृत्त और आयतों के साथ चित्र लेते हैं, और एक कंप्यूटर के यादृच्छिक संख्या जनरेटर (जिसमें छद्म यादृच्छिक जनरेटर होता है, जो अन्य गैर-डिजिटल एल्गोरिदम और पदार्थ के भौतिक गुणों के आधार पर जनरेटर का उपयोग करके जगह और रंग और अन्य मापदंडों का निर्धारण करते हैं) लेकिन हम इस लेख में इस पर चर्चा नहीं करेंगे)।

तो, समुद्री np.random.sample () * 0.75 को लें , हमें लहरों, हवा, तटों और अन्य छिपे हुए पैटर्न और चेहरे की आवश्यकता नहीं है। जहाजों / एलिप्स को भी एक ही रंग में चित्रित किया जाएगा, और समुद्र को नाव और हस्तक्षेप से अलग करने के लिए, 0.25 को समुद्र या नाव / जैमर में जोड़ा जाएगा, और वे सभी एक ही आकार के होंगे - विभिन्न आकारों और झुकावों के दीर्घवृत्त। हस्तक्षेप भी केवल उसी रंग का आयताकार होगा जैसा कि दीर्घवृत्त - यह महत्वपूर्ण है, जानकारी और शोर की पृष्ठभूमि के खिलाफ एक ही रंग का हस्तक्षेप। हम केवल रंग में एक छोटा सा बदलाव करेंगे और हम प्रत्येक चित्र के लिए और प्रत्येक दीर्घवृत्त / आयत के लिए np.random.sample () चलाएंगे , अर्थात। न तो पृष्ठभूमि और न ही दीर्घवृत्त / आयत का रंग दोहराया जाता है। पाठ में आगे चित्र / मुखौटे बनाने के लिए कार्यक्रम का एक कोड है और दस बेतरतीब ढंग से चयनित जोड़े का एक उदाहरण है।

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

तो, दिया गया:

चित्र / मुखौटा जोड़े का सीखने का क्रम। हम चित्रों / मास्क की किसी भी संख्या को उत्पन्न कर सकते हैं। मैं तुरंत इस प्रश्न का उत्तर दूंगा - रंग और पृष्ठभूमि यादृच्छिक क्यों है? मैं बस, संक्षेप में, स्पष्ट रूप से और व्यापक रूप से जवाब दूंगा कि मुझे यह बहुत पसंद है, सीमा के रूप में एक अतिरिक्त इकाई की आवश्यकता नहीं है;
नेटवर्क साधारण, साधारण U- नेट, थोड़ा संशोधित और व्यापक रूप से विभाजन के लिए उपयोग किया जाता है।

परीक्षण करने का विचार:

निर्मित अनुक्रम में, वास्तविक कार्यों में, डेटा के गीगाबाइट का उपयोग किया जाता है। लेखक का मानना है कि प्रशिक्षण अनुक्रम का आकार इतना महत्वपूर्ण नहीं है और इसमें बहुत अधिक डेटा नहीं होना चाहिए, लेकिन उनमें "बहुत कुछ" जानकारी होनी चाहिए। ऐसी राशि, दस हजार जोड़े चित्र / मुखौटे आवश्यक नहीं हैं, और नेटवर्क बहुत कम मात्रा में डेटा से सीखेंगे।

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

अब आप अपने अंतर्ज्ञान की जांच कर सकते हैं और मान सकते हैं कि 10,000 में से कितने जोड़े दूसरे को प्रशिक्षित करने और भविष्यवाणी करने के लिए पर्याप्त हैं, लेकिन 0.98 से अधिक की सटीकता के साथ 10,000 जोड़े का अनुक्रम भी बनाया है। तुलना के बाद, कागज के एक टुकड़े पर लिखें।

व्यावहारिक उपयोग के लिए, कृपया ध्यान रखें कि हस्तक्षेप के साथ समुद्र और जहाजों दोनों को कृत्रिम रूप से चुना गया है, यह np.random.sample () है ।

हम पुस्तकालयों को लोड करते हैं, हम चित्रों की एक सरणी का आकार निर्धारित करते हैं

import numpy as np import matplotlib.pyplot as plt %matplotlib inline import math from tqdm import tqdm from skimage.draw import ellipse, polygon from keras import Model from keras.optimizers import Adam from keras.layers import Input,Conv2D,Conv2DTranspose,MaxPooling2D,concatenate from keras.layers import BatchNormalization,Activation,Add,Dropout from keras.losses import binary_crossentropy from keras import backend as K import tensorflow as tf import keras as keras w_size = 128 train_num = 10000 radius_min = 10 radius_max = 20

नुकसान और सटीकता कार्यों का निर्धारण करें

 def dice_coef(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred = K.cast(y_pred, 'float32') y_pred_f = K.cast(K.greater(K.flatten(y_pred), 0.5), 'float32') intersection = y_true_f * y_pred_f score = 2. * K.sum(intersection) / (K.sum(y_true_f) + K.sum(y_pred_f)) return score def dice_loss(y_true, y_pred): smooth = 1. y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) intersection = y_true_f * y_pred_f score = (2. * K.sum(intersection) + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) return 1. - score def bce_dice_loss(y_true, y_pred): return binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred) def get_iou_vector(A, B): # Numpy version batch_size = A.shape[0] metric = 0.0 for batch in range(batch_size): t, p = A[batch], B[batch] true = np.sum(t) pred = np.sum(p) # deal with empty mask first if true == 0: metric += (pred == 0) continue # non empty mask case. Union is never empty # hence it is safe to divide by its number of pixels intersection = np.sum(t * p) union = true + pred - intersection iou = intersection / union # iou metrric is a stepwise approximation of the real iou over 0.5 iou = np.floor(max(0, (iou - 0.45)*20)) / 10 metric += iou # teake the average over all images in batch metric /= batch_size return metric def my_iou_metric(label, pred): # Tensorflow version return tf.py_func(get_iou_vector, [label, pred > 0.5], tf.float64) from keras.utils.generic_utils import get_custom_objects get_custom_objects().update({'bce_dice_loss': bce_dice_loss }) get_custom_objects().update({'dice_loss': dice_loss }) get_custom_objects().update({'dice_coef': dice_coef }) get_custom_objects().update({'my_iou_metric': my_iou_metric })

हम पहले लेख से मीट्रिक का उपयोग करेंगे। मुझे पाठकों को याद दिलाना है कि हम पिक्सेल के मुखौटे की भविष्यवाणी करेंगे - यह "समुद्र" या "जहाज" है और भविष्यवाणी की सच्चाई या झूठ का मूल्यांकन करता है। यानी निम्नलिखित चार विकल्प संभव हैं - हमने सही ढंग से भविष्यवाणी की कि एक पिक्सेल "समुद्र" है, सही ढंग से भविष्यवाणी की है कि एक पिक्सेल "जहाज" है या "समुद्र" या "जहाज" की भविष्यवाणी करने में गलती की है। और इसलिए, सभी चित्रों और सभी पिक्सेल के लिए, हम सभी चार विकल्पों की संख्या का अनुमान लगाते हैं और परिणाम की गणना करते हैं - यह नेटवर्क का परिणाम होगा। और कम त्रुटिपूर्ण भविष्यवाणियां और अधिक सत्य, परिणाम जितना सटीक और बेहतर नेटवर्क।

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

हम नेटवर्क को "ब्लैक बॉक्स" के रूप में जांचते हैं, हम यह नहीं देखेंगे कि अंदर नेटवर्क के साथ क्या हो रहा है, कैसे वज़न बदलता है और कैसे ग्रेडिएंट चुना जाता है - यह एक अन्य अध्ययन का विषय है।

ब्लॉक के साथ यू-नेट

 def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True): x = Conv2D(filters, size, strides=strides, padding=padding)(x) x = BatchNormalization()(x) if activation == True: x = Activation('relu')(x) return x def residual_block(blockInput, num_filters=16): x = Activation('relu')(blockInput) x = BatchNormalization()(x) x = convolution_block(x, num_filters, (3,3) ) x = convolution_block(x, num_filters, (3,3), activation=False) x = Add()([x, blockInput]) return x # Build model def build_model(input_layer, start_neurons, DropoutRatio = 0.5): conv1 = Conv2D(start_neurons * 1, (3, 3), activation=None, padding="same" )(input_layer) conv1 = residual_block(conv1,start_neurons * 1) conv1 = residual_block(conv1,start_neurons * 1) conv1 = Activation('relu')(conv1) pool1 = MaxPooling2D((2, 2))(conv1) pool1 = Dropout(DropoutRatio/2)(pool1) conv2 = Conv2D(start_neurons * 2, (3, 3), activation=None, padding="same" )(pool1) conv2 = residual_block(conv2,start_neurons * 2) conv2 = residual_block(conv2,start_neurons * 2) conv2 = Activation('relu')(conv2) pool2 = MaxPooling2D((2, 2))(conv2) pool2 = Dropout(DropoutRatio)(pool2) conv3 = Conv2D(start_neurons * 4, (3, 3), activation=None, padding="same")(pool2) conv3 = residual_block(conv3,start_neurons * 4) conv3 = residual_block(conv3,start_neurons * 4) conv3 = Activation('relu')(conv3) pool3 = MaxPooling2D((2, 2))(conv3) pool3 = Dropout(DropoutRatio)(pool3) conv4 = Conv2D(start_neurons * 8, (3, 3), activation=None, padding="same")(pool3) conv4 = residual_block(conv4,start_neurons * 8) conv4 = residual_block(conv4,start_neurons * 8) conv4 = Activation('relu')(conv4) pool4 = MaxPooling2D((2, 2))(conv4) pool4 = Dropout(DropoutRatio)(pool4) # Middle convm = Conv2D(start_neurons * 16, (3, 3), activation=None, padding="same")(pool4) convm = residual_block(convm,start_neurons * 16) convm = residual_block(convm,start_neurons * 16) convm = Activation('relu')(convm) deconv4 = Conv2DTranspose(start_neurons * 8, (3, 3), strides=(2, 2), padding="same")(convm) uconv4 = concatenate([deconv4, conv4]) uconv4 = Dropout(DropoutRatio)(uconv4) uconv4 = Conv2D(start_neurons * 8, (3, 3), activation=None, padding="same")(uconv4) uconv4 = residual_block(uconv4,start_neurons * 8) uconv4 = residual_block(uconv4,start_neurons * 8) uconv4 = Activation('relu')(uconv4) deconv3 = Conv2DTranspose(start_neurons * 4, (3, 3), strides=(2, 2), padding="same")(uconv4) uconv3 = concatenate([deconv3, conv3]) uconv3 = Dropout(DropoutRatio)(uconv3) uconv3 = Conv2D(start_neurons * 4, (3, 3), activation=None, padding="same")(uconv3) uconv3 = residual_block(uconv3,start_neurons * 4) uconv3 = residual_block(uconv3,start_neurons * 4) uconv3 = Activation('relu')(uconv3) deconv2 = Conv2DTranspose(start_neurons * 2, (3, 3), strides=(2, 2), padding="same")(uconv3) uconv2 = concatenate([deconv2, conv2]) uconv2 = Dropout(DropoutRatio)(uconv2) uconv2 = Conv2D(start_neurons * 2, (3, 3), activation=None, padding="same")(uconv2) uconv2 = residual_block(uconv2,start_neurons * 2) uconv2 = residual_block(uconv2,start_neurons * 2) uconv2 = Activation('relu')(uconv2) deconv1 = Conv2DTranspose(start_neurons * 1, (3, 3), strides=(2, 2), padding="same")(uconv2) uconv1 = concatenate([deconv1, conv1]) uconv1 = Dropout(DropoutRatio)(uconv1) uconv1 = Conv2D(start_neurons * 1, (3, 3), activation=None, padding="same")(uconv1) uconv1 = residual_block(uconv1,start_neurons * 1) uconv1 = residual_block(uconv1,start_neurons * 1) uconv1 = Activation('relu')(uconv1) uconv1 = Dropout(DropoutRatio/2)(uconv1) output_layer = Conv2D(1, (1,1), padding="same", activation="sigmoid")(uconv1) return output_layer # model input_layer = Input((w_size, w_size, 3)) output_layer = build_model(input_layer, 16) model = Model(input_layer, output_layer) model.compile(loss=bce_dice_loss, optimizer="adam", metrics=[my_iou_metric]) model.summary()

चित्र / मुखौटा जोड़े उत्पन्न करने का कार्य। 128x128 रंग की तस्वीर पर दो शोरों से यादृच्छिक रूप से चयनित यादृच्छिक शोर से भरी हुई है, या तो 0.0 ... 0.75 या 0.25..1.0। बेतरतीब ढंग से उन्मुख दीर्घवृत्त को चित्र में रखें और उसी स्थान पर एक आयत रखें। हम जांचते हैं कि वे प्रतिच्छेद नहीं करते हैं और यदि आवश्यक हो, तो आयत को किनारे पर स्थानांतरित करें। हर बार हम समुद्र / नाव के रंग के मूल्यों की फिर से गणना करते हैं। सादगी के लिए, हम चित्र को एक सरणी में, चौथे रंग के रूप में, अर्थात् डाल देंगे। Red.Green.Blue.Mask, यह आसान है।

 def next_pair(): img_l = (np.random.sample((w_size, w_size, 3))* 0.75).astype('float32') img_h = (np.random.sample((w_size, w_size, 3))* 0.75 + 0.25).astype('float32') img = np.zeros((w_size, w_size, 4), dtype='float') p = np.random.sample() - 0.5 r = np.random.sample()*(w_size-2*radius_max) + radius_max c = np.random.sample()*(w_size-2*radius_max) + radius_max r_radius = np.random.sample()*(radius_max-radius_min) + radius_min c_radius = np.random.sample()*(radius_max-radius_min) + radius_min rot = np.random.sample()*360 rr, cc = ellipse( r, c, r_radius, c_radius, rotation=np.deg2rad(rot), shape=img_l.shape ) p1 = np.rint(np.random.sample()* (w_size-2*radius_max) + radius_max) p2 = np.rint(np.random.sample()* (w_size-2*radius_max) + radius_max) p3 = np.rint(np.random.sample()* (2*radius_max - radius_min) + radius_min) p4 = np.rint(np.random.sample()* (2*radius_max - radius_min) + radius_min) poly = np.array(( (p1, p2), (p1, p2+p4), (p1+p3, p2+p4), (p1+p3, p2), (p1, p2), )) rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) in_sc_rr = list(set(rr) & set(rr_p)) in_sc_cc = list(set(cc) & set(cc_p)) if len(in_sc_rr) > 0 and len(in_sc_cc) > 0: if len(in_sc_rr) > 0: _delta_rr = np.max(in_sc_rr) - np.min(in_sc_rr) + 1 if np.mean(rr_p) > np.mean(in_sc_rr): poly[:,0] += _delta_rr else: poly[:,0] -= _delta_rr if len(in_sc_cc) > 0: _delta_cc = np.max(in_sc_cc) - np.min(in_sc_cc) + 1 if np.mean(cc_p) > np.mean(in_sc_cc): poly[:,1] += _delta_cc else: poly[:,1] -= _delta_cc rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) if p > 0: img[:,:,:3] = img_l.copy() img[rr, cc,:3] = img_h[rr, cc] img[rr_p, cc_p,:3] = img_h[rr_p, cc_p] else: img[:,:,:3] = img_h.copy() img[rr, cc,:3] = img_l[rr, cc] img[rr_p, cc_p,:3] = img_l[rr_p, cc_p] img[:,:,3] = 0. img[rr, cc,3] = 1. return img

चलो जोड़े का एक प्रशिक्षण अनुक्रम बनाते हैं, यादृच्छिक 10 देखें

 _txy = [next_pair() for idx in range(train_num)] f_imgs = np.array(_txy)[:,:,:,:3].reshape(-1,w_size ,w_size ,3) f_msks = np.array(_txy)[:,:,:,3:].reshape(-1,w_size ,w_size ,1) del(_txy) #    10   fig, axes = plt.subplots(2, 10, figsize=(20, 5)) for k in range(10): kk = np.random.randint(train_num) axes[0,k].set_axis_off() axes[0,k].imshow(f_imgs[kk]) axes[1,k].set_axis_off() axes[1,k].imshow(f_msks[kk].squeeze())

पहला कदम। आइए न्यूनतम सेट पर प्रशिक्षित करने का प्रयास करें

हमारे प्रयोग का पहला चरण सरल है, हम केवल 11 पहले चित्रों की भविष्यवाणी करने के लिए नेटवर्क को प्रशिक्षित करने की कोशिश कर रहे हैं।

 batch_size = 10 val_len = 11 precision = 0.85 m0_select = np.zeros((f_imgs.shape[0]), dtype='int') for k in range(val_len): m0_select[k] = 1 t = tqdm() while True: fit = model.fit(f_imgs[m0_select>0], f_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] t.set_description("accuracy {0:6.4f} loss {1:6.4f} ".\ format(current_accu, current_loss)) t.update(1) if current_accu > precision: break t.close()

accuracy 0.8636 loss 0.0666 : : 47it [00:29, 5.82it/s]

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

अब मुख्य प्रयोग शुरू करें

हम निर्मित अनुक्रम से नई तस्वीर / मुखौटा जोड़े लेंगे और पहले से ही चयनित अनुक्रम पर प्रशिक्षित नेटवर्क द्वारा उनकी भविष्यवाणी करने की कोशिश करेंगे। शुरुआत में, यह केवल 11 जोड़े चित्र / मुखौटा है और नेटवर्क प्रशिक्षित है, शायद बहुत सही ढंग से नहीं। यदि किसी नए जोड़े में चित्र से मुखौटा को स्वीकार्य सटीकता के साथ भविष्यवाणी की जाती है, तो हम इस जोड़ी को त्याग देते हैं, इसके पास नेटवर्क के लिए नई जानकारी नहीं है, यह पहले से ही जानता है और इस तस्वीर से मुखौटा की गणना कर सकता है। यदि भविष्यवाणी की सटीकता अपर्याप्त है, तो हम इस तस्वीर को अपने अनुक्रम में मास्क के साथ जोड़ते हैं और नेटवर्क को प्रशिक्षित करना शुरू करते हैं जब तक कि चयनित अनुक्रम पर स्वीकार्य सटीकता परिणाम प्राप्त नहीं होता है। यानी इस चित्र में नई जानकारी है और हम इसे अपने प्रशिक्षण अनुक्रम में जोड़ते हैं और प्रशिक्षण द्वारा इसमें निहित जानकारी निकालते हैं।

 batch_size = 50 t_batch_size = 1024 raw_len = val_len t = tqdm(-1) id_train = 0 #id_select = 1 while True: t.set_description("Accuracy {0:6.4f} loss {1:6.4f}\ selected img {2:5d} tested img {3:5d} ". format(current_accu, current_loss, val_len, raw_len)) t.update(1) if id_train == 1: fit = model.fit(f_imgs[m0_select>0], f_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] if current_accu > precision: id_train = 0 else: t_pred = model.predict( f_imgs[raw_len: min(raw_len+t_batch_size,f_imgs.shape[0])], batch_size=batch_size ) for kk in range(t_pred.shape[0]): val_iou = get_iou_vector( f_msks[raw_len+kk].reshape(1,w_size,w_size,1), t_pred[kk].reshape(1,w_size,w_size,1) > 0.5) if val_iou < precision*0.95: new_img_test = 1 m0_select[raw_len+kk] = 1 val_len += 1 break raw_len += (kk+1) id_train = 1 if raw_len >= train_num: break t.close()

 Accuracy 0.9830 loss 0.0287 selected img 271 tested img 9949 : : 1563it [14:16, 1.01it/s]

यहां सटीकता का उपयोग "सटीकता" के अर्थ में किया जाता है, न कि मानक केरस मीट्रिक के रूप में, और सटीकता की गणना करने के लिए सबरूटीन "my_iou_metric" का उपयोग किया जाता है। जांच और जोड़े गए चित्रों की सटीकता और संख्या का निरीक्षण करना बहुत दिलचस्प है। शुरुआत में, लगभग सभी चित्र / मुखौटा जोड़े नेटवर्क द्वारा जोड़े जाते हैं, और कहीं 70 के आसपास इसे दूर फेंकना शुरू होता है। 8000 से लगभग सभी जोड़े के करीब।

नेटवर्क द्वारा चयनित दृष्टिहीन जोड़े की जाँच करें:

 fig, axes = plt.subplots(2, 10, figsize=(20, 5)) t_imgs = f_imgs[m0_select>0] t_msks = f_msks[m0_select>0] for k in range(10): kk = np.random.randint(t_msks.shape[0]) axes[0,k].set_axis_off() axes[0,k].imshow(t_imgs[kk]) axes[1,k].set_axis_off() axes[1,k].imshow(t_msks[kk].squeeze())

कुछ भी विशेष या अलौकिक नहीं:

ये प्रशिक्षण के विभिन्न चरणों में नेटवर्क द्वारा चयनित जोड़े हैं। जब नेटवर्क को इस अनुक्रम से एक इनपुट जोड़ी मिली, तो यह निर्दिष्ट सटीकता के साथ मुखौटा की गणना नहीं कर सका और इस जोड़ी को प्रशिक्षण अनुक्रम में शामिल किया गया। लेकिन कुछ खास नहीं, साधारण तस्वीरें।

परिणाम और सटीकता का सत्यापन

चलो नेटवर्क प्रशिक्षण कार्यक्रम की गुणवत्ता की जांच करें, सुनिश्चित करें कि गुणवत्ता प्रारंभिक अनुक्रम के आदेश पर निर्भर नहीं करती है, जिसके लिए हम चित्र / मुखौटा जोड़े के प्रारंभिक अनुक्रम को मिलाते हैं, अन्य 11 को पहले और उसी तरह लेते हैं, नेटवर्क को प्रशिक्षित करते हैं और अतिरिक्त काट देते हैं।

 sh = np.arange(train_num) np.random.shuffle(sh) f0_imgs = f_imgs[sh] f0_msks = f_msks[sh] model.compile(loss=bce_dice_loss, optimizer="adam", metrics=[my_iou_metric]) model.summary()

वर्कआउट कोड

 batch_size = 10 val_len = 11 precision = 0.85 m0_select = np.zeros((f_imgs.shape[0]), dtype='int') for k in range(val_len): m0_select[k] = 1 t = tqdm() while True: fit = model.fit(f0_imgs[m0_select>0], f0_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] t.set_description("accuracy {0:6.4f} loss {1:6.4f} ".\ format(current_accu, current_loss)) t.update(1) if current_accu > precision: break t.close()

 accuracy 0.8636 loss 0.0710 : : 249it [01:03, 5.90it/s]

 batch_size = 50 t_batch_size = 1024 raw_len = val_len t = tqdm(-1) id_train = 0 #id_select = 1 while True: t.set_description("Accuracy {0:6.4f} loss {1:6.4f}\ selected img {2:5d} tested img {3:5d} ". format(current_accu, current_loss, val_len, raw_len)) t.update(1) if id_train == 1: fit = model.fit(f0_imgs[m0_select>0], f0_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] if current_accu > precision: id_train = 0 else: t_pred = model.predict( f_imgs[raw_len: min(raw_len+t_batch_size,f_imgs.shape[0])], batch_size=batch_size ) for kk in range(t_pred.shape[0]): val_iou = get_iou_vector( f_msks[raw_len+kk].reshape(1,w_size,w_size,1), t_pred[kk].reshape(1,w_size,w_size,1) > 0.5) if val_iou < precision*0.95: new_img_test = 1 m0_select[raw_len+kk] = 1 val_len += 1 break raw_len += (kk+1) id_train = 1 if raw_len >= train_num: break t.close()

 Accuracy 0.9890 loss 0.0224 selected img 408 tested img 9456 : : 1061it [21:13, 2.16s/it]

परिणाम मूल अनुक्रम के जोड़े के क्रम पर काफी निर्भर नहीं करता है। पिछले मामले में, नेटवर्क ने 271, अब 408 को चुना, यदि आप इसे मिलाते हैं, तो नेटवर्क एक अलग राशि चुन सकता है। हम जांच नहीं करेंगे, लेखक का मानना है कि हमेशा 10,000 से काफी कम होगा।

एक नए स्वतंत्र अनुक्रम पर नेटवर्क भविष्यवाणी की सटीकता की जांच करें

 _txy = [next_pair() for idx in range(train_num)] test_imgs = np.array(_txy)[:,:,:,:3].reshape(-1,w_size ,w_size ,3) test_msks = np.array(_txy)[:,:,:,3:].reshape(-1,w_size ,w_size ,1) del(_txy) test_pred_0 = model.predict(test_imgs) t_val_0 = get_iou_vector(test_msks,test_pred_0) t_val_0

 0.9927799999999938

सारांश और निष्कर्ष

इसलिए, हम 10,000 जोड़े में से चयनित तीन या चार सौ से कम को निचोड़ने में सक्षम थे, भविष्यवाणी की सटीकता 0.99278 है, हमने उन सभी जोड़ों को लिया जिनमें कम से कम कुछ उपयोगी जानकारी शामिल है और बाकी को बाहर फेंक दिया। हमने प्रशिक्षण अनुक्रम के सांख्यिकीय मापदंडों को संरेखित नहीं किया, जानकारी की पुनरावृत्ति को जोड़ते हैं, आदि। और सांख्यिकीय विधियों का उपयोग नहीं किया। हम एक तस्वीर लेते हैं जिसमें नेटवर्क के लिए अभी भी अज्ञात जानकारी होती है और इसके बारे में सब कुछ नेटवर्क के वजन में निचोड़ देता है। यदि नेटवर्क कम से कम एक "रहस्यमय" चित्र से मिलता है, तो यह व्यवसाय में इसका उपयोग करेगा।

कुल 271 तस्वीर / मुखौटा जोड़े में 10,000 जोड़े की सटीकता के साथ प्रत्येक जोड़े पर कम से कम 0.8075 की भविष्यवाणी करने की जानकारी है, यानी, पूरे अनुक्रम पर कुल सटीकता अधिक है, लेकिन प्रत्येक तस्वीर में यह 0.8075 से कम नहीं है, हमारे पास ऐसी तस्वीरें नहीं हैं जिन्हें हम नहीं करते हैं हम भविष्यवाणी कर सकते हैं और हम इस भविष्यवाणी की निचली सीमा जानते हैं। (यहां, बेशक, लेखक ने दावा किया कि इसके बिना, लेख इस कथन को सत्यापित नहीं करता है, लगभग 0.8075, या सबूत, लेकिन सबसे अधिक संभावना यह सच है)

नेटवर्क को प्रशिक्षित करने के लिए, हाथ में आने वाली हर चीज के साथ GPU को लोड करने की आवश्यकता नहीं है, आप प्रशिक्षण की शुरुआत के रूप में ट्रेन के मूल को बाहर निकाल सकते हैं और उस पर नेटवर्क को प्रशिक्षित कर सकते हैं। जब आप नई तस्वीरें प्राप्त करते हैं, तो आप उन लोगों को मैन्युअल रूप से चिह्नित कर सकते हैं जो नेटवर्क भविष्यवाणी नहीं कर सकते थे और उन्हें ट्रेन के मूल में जोड़ सकते थे, नए चित्रों से सभी जानकारी को निचोड़ने के लिए फिर से नेटवर्क को पुनः प्राप्त कर सकते हैं। और सत्यापन क्रम को एकल करने के लिए आवश्यक नहीं है; हम यह मान सकते हैं कि चयनित एक को छोड़कर बाकी सब कुछ एक सत्यापन अनुक्रम है।

एक और गणितीय रूप से सख्त नहीं, लेकिन बहुत महत्वपूर्ण टिप्पणी। यह कहना सुरक्षित है कि प्रत्येक तस्वीर / मुखौटा जोड़ी में बहुत सारी जानकारी होती है। प्रत्येक जोड़ी में सूचना का "बहुत" होता है, हालांकि अधिकांश चित्र / मुखौटा जोड़े में जानकारी अंतर या दोहराता है। 271 चित्र / मुखौटा जोड़े में से प्रत्येक में ऐसी जानकारी होती है जो भविष्यवाणी के लिए आवश्यक होती है, और इस जोड़ी को बस फेंका नहीं जा सकता।

खैर, सिलवटों के बारे में एक छोटी सी टिप्पणी, कई विशेषज्ञ और कागलर्स प्रशिक्षण अनुक्रम को सिलवटों में विभाजित करते हैं और उन्हें अलग से प्रशिक्षित करते हैं, और आगे के ट्रिकी तरीकों से प्राप्त परिणामों को जोड़ते हैं। हमारे मामले में, आप इसे फोल्ड में भी विभाजित कर सकते हैं, यदि आप 10,000 से 271 जोड़े निकालते हैं, तो आप शेष लोगों में एक नया रूट अनुक्रम बना सकते हैं, जो स्पष्ट रूप से एक अलग लेकिन तुलनीय परिणाम प्रदान करेगा। जैसा कि ऊपर दिखाया गया है, आप बस अन्य प्रारंभिक 11 को मिला सकते हैं और ले सकते हैं।

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

कृत्रिम बुद्धि के लिए चीट शीट - अतिरिक्त फेंक दें, मुख्य बात सिखाएं। प्रशिक्षण अनुक्रम प्रसंस्करण तकनीक

पहला कदम। आइए न्यूनतम सेट पर प्रशिक्षित करने का प्रयास करें

अब मुख्य प्रयोग शुरू करें

परिणाम और सटीकता का सत्यापन

सारांश और निष्कर्ष

More articles: