✋🏿 🐷 ⭐️ आदिमों की सादगी और जटिलता या तंत्रिका नेटवर्क के लिए अनावश्यक प्रीप्रोसेसिंग का निर्धारण कैसे करें ✊🏽 🔨 🌩️

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

आइए तुलना करने की कोशिश करें, और तुलना के लिए हमारे पास एक महान विचार है, जो छात्रों की पीढ़ियों द्वारा परीक्षण किया गया है, यह विचार - धोखा शीट जितना छोटा होगा, परीक्षा उतनी ही आसान होगी।

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

तो, आइए यह पता लगाने की कोशिश करें कि विभाजन के लिए कौन सा ज्यामितीय आंकड़ा अधिक जटिल या सरल है, एआई के लिए व्याख्यान का कौन सा पाठ्यक्रम अधिक समझ में आता है और बेहतर अवशोषित होता है।

कई अलग-अलग ज्यामितीय आकृतियाँ हैं, लेकिन हम केवल त्रिकोण, चतुष्कोण और पाँच-नुकीले तारों की तुलना करेंगे। हम ट्रेन अनुक्रम के निर्माण के लिए एक सरल विधि का उपयोग करेंगे - हम 128x128 मोनोक्रोम छवियों को चार भागों में विभाजित करेंगे और बेतरतीब ढंग से एक दीर्घवृत्त डालेंगे और, उदाहरण के लिए, इन तिमाहियों में एक त्रिकोण। हम दीर्घवृत्त के समान रंग के एक त्रिकोण का पता लगाएंगे। यानी कार्य नेटवर्क को भेद करने के लिए प्रशिक्षित करना है, उदाहरण के लिए, एक ही रंग में चित्रित दीर्घवृत्त से एक चतुष्कोणीय बहुभुज। यहाँ चित्रों के उदाहरण हैं जिनका हम अध्ययन करेंगे

हम एक चित्र में एक त्रिभुज और एक चतुर्भुज का पता नहीं लगाएंगे, हम उन्हें अलग-अलग गाड़ियों में, दीर्घवृत्त के रूप में हस्तक्षेप की पृष्ठभूमि के खिलाफ अलग-अलग पता लगाएंगे।

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

तो, दिया गया:

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

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

निर्धारित करें कि प्रशिक्षण के कौन से क्रम सीखने के लिए "कठिन" हैं;
कुछ प्रीप्रोसेसिंग तकनीक सीखने को कैसे प्रभावित करती हैं

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

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

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 })

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

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

सरल यू-नेट

 def build_model(input_layer, start_neurons): # 128 -> 64 conv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(input_layer) conv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(conv1) pool1 = MaxPooling2D((2, 2))(conv1) pool1 = Dropout(0.25)(pool1) # 64 -> 32 conv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(pool1) conv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(conv2) pool2 = MaxPooling2D((2, 2))(conv2) pool2 = Dropout(0.5)(pool2) # 32 -> 16 conv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(pool2) conv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(conv3) pool3 = MaxPooling2D((2, 2))(conv3) pool3 = Dropout(0.5)(pool3) # 16 -> 8 conv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(pool3) conv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(conv4) pool4 = MaxPooling2D((2, 2))(conv4) pool4 = Dropout(0.5)(pool4) # Middle convm = Conv2D(start_neurons * 16, (3, 3), activation="relu", padding="same")(pool4) convm = Conv2D(start_neurons * 16, (3, 3), activation="relu", padding="same")(convm) # 8 -> 16 deconv4 = Conv2DTranspose(start_neurons * 8, (3, 3), strides=(2, 2), padding="same")(convm) uconv4 = concatenate([deconv4, conv4]) uconv4 = Dropout(0.5)(uconv4) uconv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(uconv4) uconv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(uconv4) # 16 -> 32 deconv3 = Conv2DTranspose(start_neurons * 4, (3, 3), strides=(2, 2), padding="same")(uconv4) uconv3 = concatenate([deconv3, conv3]) uconv3 = Dropout(0.5)(uconv3) uconv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(uconv3) uconv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(uconv3) # 32 -> 64 deconv2 = Conv2DTranspose(start_neurons * 2, (3, 3), strides=(2, 2), padding="same")(uconv3) uconv2 = concatenate([deconv2, conv2]) uconv2 = Dropout(0.5)(uconv2) uconv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(uconv2) uconv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(uconv2) # 64 -> 128 deconv1 = Conv2DTranspose(start_neurons * 1, (3, 3), strides=(2, 2), padding="same")(uconv2) uconv1 = concatenate([deconv1, conv1]) uconv1 = Dropout(0.5)(uconv1) uconv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(uconv1) uconv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(uconv1) uncov1 = Dropout(0.5)(uconv1) output_layer = Conv2D(1, (1,1), padding="same", activation="sigmoid")(uconv1) return output_layer # model input_layer = Input((w_size, w_size, 1)) output_layer = build_model(input_layer, 26) model = Model(input_layer, output_layer) model.compile(loss=bce_dice_loss, optimizer=Adam(lr=1e-4), metrics=[my_iou_metric]) model.summary()

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

 def next_pair(): img_l = (np.random.sample((w_size, w_size, 1))* 0.75).astype('float32') img_h = (np.random.sample((w_size, w_size, 1))* 0.75 + 0.25).astype('float32') img = np.zeros((w_size, w_size, 2), dtype='float') i0_qua = math.trunc(np.random.sample()*4.) i1_qua = math.trunc(np.random.sample()*4.) while i0_qua == i1_qua: i1_qua = math.trunc(np.random.sample()*4.) _qua = np.int(w_size/4) qua = np.array([[_qua,_qua],[_qua,_qua*3],[_qua*3,_qua*3],[_qua*3,_qua]]) p = np.random.sample() - 0.5 r = qua[i0_qua,0] c = qua[i0_qua,1] 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 ) p0 = np.rint(np.random.sample()*(radius_max-radius_min) + radius_min) p1 = qua[i1_qua,0] - (radius_max-radius_min) p2 = qua[i1_qua,1] - (radius_max-radius_min) p3 = np.rint(np.random.sample()*radius_min) p4 = np.rint(np.random.sample()*radius_min) p5 = np.rint(np.random.sample()*radius_min) p6 = np.rint(np.random.sample()*radius_min) p7 = np.rint(np.random.sample()*radius_min) p8 = np.rint(np.random.sample()*radius_min) poly = np.array(( (p1, p2), (p1+p3, p2+p4+p0), (p1+p5+p0, p2+p6+p0), (p1+p7+p0, p2+p8), (p1, p2), )) rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) if p > 0: img[:,:,:1] = img_l.copy() img[rr, cc,:1] = img_h[rr, cc] img[rr_p, cc_p,:1] = img_h[rr_p, cc_p] else: img[:,:,:1] = img_h.copy() img[rr, cc,:1] = img_l[rr, cc] img[rr_p, cc_p,:1] = img_l[rr_p, cc_p] img[:,:,1] = 0. img[rr_p, cc_p,1] = 1. return img

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

 _txy = [next_pair() for idx in range(train_num)] f_imgs = np.array(_txy)[:,:,:,:1].reshape(-1,w_size ,w_size ,1) f_msks = np.array(_txy)[:,:,:,1:].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.8545 loss 0.0674 lenght 11 : : 793it [00:58, 14.79it/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.9338 loss 0.0266 selected img 1007 tested img 9985 : : 4291it [49:52, 1.73s/it]

यहां सटीकता का उपयोग "सटीकता" के अर्थ में किया जाता है, न कि मानक केरस मीट्रिक के रूप में, और सटीकता की गणना करने के लिए सबरूटीन "my_iou_metric" का उपयोग किया जाता है।

अब एक ही नेटवर्क के संचालन की तुलना एक ही अनुक्रम के साथ एक अलग अनुक्रम पर, त्रिकोणों पर करें

और हमें पूरी तरह से अलग परिणाम मिलता है

 Accuracy 0.9823 loss 0.0108 selected img 1913 tested img 9995 : : 6343it [2:11:36, 3.03s/it]

नेटवर्क ने "नई" जानकारी के साथ 1913 चित्रों का चयन किया, अर्थात्। त्रिकोण के साथ चित्रों की सामग्री चौगुनी के साथ आधी है!

चलो तारों पर एक ही चीज की जांच करें और तीसरे क्रम में नेटवर्क चलाएं

हमें मिलता है

 Accuracy 0.8985 loss 0.0478 selected img 476 tested img 9985 : : 2188it [16:13, 1.16it/s]

जैसा कि आप देख सकते हैं, सितारों ने सबसे अधिक जानकारीपूर्ण निकला, एक धोखा पत्र में केवल 476 चित्र।

हमारे पास उनके तंत्रिका नेटवर्क द्वारा धारणा के लिए ज्यामितीय आकृतियों की जटिलता का न्याय करने का कारण था। सबसे सरल स्टार है, चीट शीट में केवल 476 चित्र हैं, फिर उसके 1007 के साथ चतुर्भुज और सबसे जटिल एक त्रिकोण बन गया है - प्रशिक्षण के लिए आपको 1913 चित्रों की आवश्यकता है।

ध्यान रखें, यह हमारे लिए है, लोगों के लिए यह एक तस्वीर है, लेकिन नेटवर्क के लिए यह मान्यता पर एक व्याख्यान पाठ्यक्रम और त्रिकोण पर पाठ्यक्रम सबसे कठिन निकला।

अब गंभीर के बारे में

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

 from scipy.ndimage import gaussian_filter _tmp = [gaussian_filter(idx, sigma = 1) for idx in f_imgs] f1_imgs = np.array(_tmp)[:,:,:,:1].reshape(-1,w_size ,w_size ,1) del(_tmp) fig, axes = plt.subplots(2, 5, figsize=(20, 7)) for k in range(5): kk = np.random.randint(train_num) axes[0,k].set_axis_off() axes[0,k].imshow(f1_imgs[kk].squeeze(), cmap="gray") axes[1,k].set_axis_off() axes[1,k].imshow(f_msks[kk].squeeze(), cmap="gray")

पहली नज़र में, सब कुछ एक ही है, एक ही दीर्घवृत्त, एक ही बहुभुज, लेकिन नेटवर्क पूरी तरह से काम करना शुरू कर दिया है:

 Accuracy 1.0575 loss 0.0011 selected img 7963 tested img 9999 : : 17765it [29:02:00, 12.40s/it]

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

लेकिन, जैसा कि काम के परिणाम से देखा जा सकता है, एक सरल गॉसियन_फिल्टर ने नेटवर्क के लिए कई समस्याएं पैदा कीं, बहुत कुछ नया, और शायद अति-जानकारी, जानकारी उत्पन्न की।

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

परिणाम बताता है कि यादृच्छिक रंग बिल्कुल सरल जोड़ नहीं है।

 Accuracy 0.9004 loss 0.0315 selected img 251 tested img 9832 : : 1000it [06:46, 1.33it/s]

नेटवर्क पूरी तरह से 251 छवियों से निकाली गई जानकारी के लायक था, जो शोर से चित्रित कई चित्रों से लगभग चार गुना कम था।

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

इस लेगो उदाहरण को वास्तविक मामलों में लागू करने की संभावना स्पष्ट है, लेकिन वास्तविक प्रशिक्षुओं और पाठकों के नेटवर्क पाठकों पर निर्भर हैं।

आदिमों की सादगी और जटिलता या तंत्रिका नेटवर्क के लिए अनावश्यक प्रीप्रोसेसिंग का निर्धारण कैसे करें

पहला कदम। हम न्यूनतम शुरुआती सेट पर प्रशिक्षण देते हैं

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

अब गंभीर के बारे में

More articles: