डिबग ऑटोएन्कोडर के उदाहरण पर गहरी सीखने की मूल बातें, भाग संख्या 1

यदि आप keras.io वेबसाइट पर ऑटो-एनकोडर पर प्रशिक्षण पढ़ते हैं, तो पहले संदेशों में से एक ऐसा कुछ है: व्यवहार में, ऑटो-एनकोडर लगभग कभी भी उपयोग नहीं किए जाते हैं, लेकिन वे अक्सर प्रशिक्षण के बारे में बात करते हैं और लोग आसपास आते हैं, इसलिए हमने उनके बारे में अपना ट्यूटोरियल लिखने का फैसला किया:

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

फिर भी, उन व्यावहारिक कार्यों में से एक जिनके लिए उन्हें लागू किया जा सकता है विसंगतियों की खोज है, और मुझे व्यक्तिगत रूप से शाम की परियोजना के ढांचे में इसकी आवश्यकता थी।

इंटरनेट पर, ऑटो-एनकोडर पर बहुत सारे ट्यूटोरियल हैं, एक और लिखने के लिए क्या है? खैर, ईमानदार होने के लिए, इसके कई कारण थे:

• एक भावना थी कि वास्तव में ट्यूटोरियल लगभग 3 या 4 थे, बाकी सभी को अपने शब्दों में फिर से लिखा गया था;
• लगभग सब कुछ - चित्रों के साथ लंबे समय से पीड़ित MNIST'e पर 28x28;
• मेरी विनम्र राय में - वे एक अंतर्ज्ञान विकसित नहीं करते हैं कि यह सब कैसे काम करना चाहिए, लेकिन बस दोहराने की पेशकश करें;
• और सबसे महत्वपूर्ण कारक - व्यक्तिगत रूप से, जब मैंने अपने स्वयं के डाटासेट के साथ MNIST को बदल दिया - तो यह सब बेवकूफी से काम करना बंद कर दिया ।

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

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

चलिए शुरू करते हैं। मेरे पास 4000 काले और सफेद चित्रों की 64x64 पिक्सेल है, यह कुछ इस तरह दिखता है:

काली पृष्ठभूमि पर बस कुछ पंक्तियाँ, और 64x64 चित्र में लगभग 2% अंक भरे गए हैं। यदि आप बहुत सारे चित्रों को देखते हैं, तो, ज़ाहिर है, यह पता चला है कि अधिकांश लाइनें बहुत समान हैं।

मैं इस बात के विवरण में नहीं जाऊंगा कि डेटासेट कैसे लोड किया गया, संसाधित किया गया, क्योंकि लेख का उद्देश्य, फिर से, यह नहीं है। बस एक डरावना कोड कोड दिखाएं।

# only for google colab %tensorflow_version 2.x import tensorflow as tf import numpy as np import matplotlib.pyplot as plt import os import zipfile import datetime import tensorflow_addons as tfa BATCH_SIZE = 128 AUTOTUNE=tf.data.experimental.AUTOTUNE def load_image(fpath): img_raw = tf.io.read_file(fpath) img = tf.io.decode_png(img_raw, channels=1, dtype=tf.uint8) return tf.image.convert_image_dtype(img, dtype=tf.float32) ## for splitting test/train def is_test(x, y): return x % 4 == 0 def is_train(x, y): return not is_test(x,y) ## for image augmentation def random_flip_flop(img): return tf.image.random_flip_left_right(img) def transform_aug(shift_val): def random_transform(img): return tfa.image.translate(img,tf.random.uniform([2], -1*shift_val, shift_val)) return random_transform def prepare_for_training(ds, cache=True, shuffle_buffer_size=1000, transform=0, flip=False): if cache: if isinstance(cache, str): ds = ds.cache(cache) else: ds = ds.cache() ds = ds.shuffle(buffer_size=shuffle_buffer_size) if transform != 0: ds = ds.map(transform_aug(transform)) if flip: ds = ds.map(random_flip_flop) ds = ds.repeat() ds = ds.batch(BATCH_SIZE) ds = ds.prefetch(buffer_size=AUTOTUNE) return ds def prepare_input_output(x): return (x, x) list_ds = tf.data.Dataset.list_files("/content/planes64/*") imgs_df = list_ds.map(load_image) train = imgs_df.enumerate().filter(is_train).map(lambda x,y: y) train_ds = prepare_for_training(train, transform=10, flip=True) train_ds = train_ds.map(prepare_input_output) val = imgs_df.enumerate().filter(is_test).map(lambda x, y: y) val_ds = val.map(prepare_input_output).batch(BATCH_SIZE, drop_remainder=True) 

यहाँ, उदाहरण के लिए, keras.io के साथ प्रस्तावित पहला मॉडल है, जिस पर उन्होंने काम किया और mnist पर प्रशिक्षित किया गया:

 # this is the size of our encoded representations encoding_dim = 32 # 32 floats -> compression of factor 24.5, assuming the input is 784 floats # this is our input placeholder input_img = Input(shape=(784,)) # "encoded" is the encoded representation of the input encoded = Dense(encoding_dim, activation='relu')(input_img) # "decoded" is the lossy reconstruction of the input decoded = Dense(784, activation='sigmoid')(encoded) 

मेरे मामले में, मॉडल इस तरह से परिभाषित किया गया है:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64/10, activation='relu')) model.add(tf.keras.layers.Dense(64*64, activation="sigmoid")) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

मामूली अंतर हैं जो मैं सीधे मॉडल में सपाट और पुनर्व्यवस्थित करता हूं, और यह कि मैं 25 बार "संपीड़ित" करता हूं, लेकिन केवल 10. यह कुछ भी प्रभावित नहीं करना चाहिए।

एक हानि-फ़ंक्शन के रूप में - मतलब चुकता त्रुटि, ऑप्टिमाइज़र मौलिक नहीं है, एडाम दें। इसके बाद, हम 20 युगों को प्रशिक्षित करते हैं, प्रति युग 100 कदम।

यदि आप मैट्रिक्स को देखते हैं - सब कुछ आग पर है। सटीकता == 0.993। यदि आप प्रशिक्षण कार्यक्रम को देखते हैं - सब कुछ थोड़ा दुखी है, तो हम तीसरे युग के क्षेत्र में एक पठार तक पहुंचते हैं।

ठीक है, यदि आप सीधे एनकोडर के परिणाम को देखते हैं, तो आपको आम तौर पर दुखद तस्वीर मिलती है (मूल शीर्ष पर है, और एन्कोडिंग-डिकोडिंग का परिणाम नीचे है):

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

ट्यूटोरियल के मूल में - फ्लैट डेटा को मॉडल इनपुट को आपूर्ति की जाती है और उन्हें आउटपुट पर लिया जाता है। क्यों नहीं समतल और पुनर्वसन पर मेरे कार्यों की जाँच करें। यहाँ इस तरह के एक सेशन मॉडल है:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

परिणाम:

यहां कुछ भी पढ़ाया नहीं जाता है। खैर, उसी समय, यह साबित हुआ कि मेरा विज़ुअलाइज़ेशन फ़ंक्शन भी काम करता है।

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

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation="sigmoid")) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

वह कुछ सीख रही है, सटीकता == 0.995 और फिर वह एक पठार में ठोकर खाती है।

लेकिन, सामान्य तौर पर, यह स्पष्ट है कि यह बहुत अच्छी तरह से काम नहीं करता है। वैसे भी - वहाँ क्या सीखना है, बाहर निकलने के लिए प्रवेश द्वार और वह है।

यदि आप घने परतों के बारे में केर प्रलेखन को पढ़ते हैं, तो यह बताता है कि वे क्या करते हैं: output = activation(dot(input, kernel) + bias)
इनपुट से मेल खाने के लिए आउटपुट के लिए, दो सरल चीजें पर्याप्त हैं - पूर्वाग्रह = 0 और कर्नेल - पहचान मैट्रिक्स (यहां इकाइयों से भरी मैट्रिक्स को छोड़ना महत्वपूर्ण नहीं है - ये बहुत अलग चीजें हैं)। सौभाग्य से, यह और यह एक ही Dense लिए प्रलेखन से काफी आसानी से किया जा सकता है।

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation = "sigmoid", use_bias=False, kernel_initializer = tf.keras.initializers.Identity())) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

क्योंकि हम तुरंत वजन निर्धारित करते हैं, तो आप कुछ भी नहीं सीख सकते हैं - अभी यह अच्छा है:

लेकिन अगर आप प्रशिक्षण शुरू करते हैं, तो यह पहली नज़र में, आश्चर्यजनक रूप से शुरू होता है - मॉडल सटीकता == 1.0 से शुरू होता है, लेकिन यह जल्दी से गिर जाता है।
प्रशिक्षण से पहले परिणाम का मूल्यांकन करें: 8/Unknown - 1s 140ms/step - loss: 0.2488 - accuracy: 1.0000[0.24875330179929733, 1.0] । शिक्षा:

 Epoch 1/20 100/100 [==============================] - 6s 56ms/step - loss: 0.1589 - accuracy: 0.9990 - val_loss: 0.0944 - val_accuracy: 0.9967 Epoch 2/20 100/100 [==============================] - 5s 51ms/step - loss: 0.0836 - accuracy: 0.9964 - val_loss: 0.0624 - val_accuracy: 0.9958 Epoch 3/20 100/100 [==============================] - 5s 50ms/step - loss: 0.0633 - accuracy: 0.9961 - val_loss: 0.0470 - val_accuracy: 0.9958 Epoch 4/20 100/100 [==============================] - 5s 48ms/step - loss: 0.0520 - accuracy: 0.9961 - val_loss: 0.0423 - val_accuracy: 0.9961 Epoch 5/20 100/100 [==============================] - 5s 48ms/step - loss: 0.0457 - accuracy: 0.9962 - val_loss: 0.0357 - val_accuracy: 0.9962 

हां, और यह बहुत स्पष्ट नहीं है, हमारे पास पहले से ही एक आदर्श मॉडल है - चित्र 1 में 1 से बाहर आता है, और नुकसान (मतलब चुकता त्रुटि) लगभग 0.25 दिखाता है।

यह, वैसे, मंचों पर एक लगातार सवाल है - नुकसान गिर रहा है, लेकिन सटीकता नहीं बढ़ रही है, यह कैसे हो सकता है?
यहां यह एक बार फिर से घने परत की परिभाषा को याद रखने योग्य है: output = activation(dot(input, kernel) + bias) और उसमें वर्णित शब्द सक्रियण, जिसे मैंने ऊपर सफलतापूर्वक अनदेखा किया था। पहचान मैट्रिक्स से भार के साथ और बिना पूर्वाग्रह के, हमें output = activation(input) ।

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

शुरुआत के लिए, आप प्रलेखन में पढ़ सकते हैं कि वे इसके बारे में क्या लिखते हैं: The sigmoid activation: (1.0 / (1.0 + exp(-x))) । यह व्यक्तिगत रूप से मुझे कुछ भी नहीं बताता, क्योंकि मैं अपने सिर में इस तरह के ग्राफ़ बनाने के लिए एक बार प्रेत नहीं हूँ।
लेकिन आप पेन से बना सकते हैं:

 import matplotlib.ticker as plticker range_tensor = tf.range(-4, 4, 0.01, dtype=tf.float32) fig, ax = plt.subplots(1,1) plt.plot(range_tensor.numpy(), tf.keras.activations.sigmoid(range_tensor).numpy()) ax.grid(which='major', linestyle='-', linewidth='0.5', color='red') ax.grid(which='minor', linestyle=':', linewidth='0.5', color='black') ax.yaxis.set_major_locator(plticker.MultipleLocator(base=0.5) ) plt.minorticks_on() 

और यहां यह स्पष्ट हो जाता है कि शून्य पर सिग्मॉइड 0.5 मान पर ले जाता है, और इकाई में - लगभग 0.73। और हमारे पास जो बिंदु हैं वे या तो काले हैं (0.0) या सफेद (1.0)। तो यह पता चला है कि पहचान फ़ंक्शन का चुकता त्रुटि गैर-शून्य रहता है।

आप पेन को भी देख सकते हैं, यहां परिणामस्वरूप छवि से एक पंक्ति है:

 array([0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.7310586, 0.7310586, 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 ], dtype=float32) 

और यह सब, वास्तव में, बहुत अच्छा है, क्योंकि कई प्रश्न एक साथ दिखाई देते हैं:

• यह ऊपर के दृश्य में क्यों नहीं दिखाई दे रहा था?
• फिर सटीकता == 1.0, क्योंकि मूल चित्र 0 और 1 हैं।

दृश्य के साथ, सब कुछ आश्चर्यजनक रूप से सरल है। छवियों को प्रदर्शित करने के लिए, मैंने matplotlib: plt.imshow(res_imgs[i][:, :, 0]) । और, हमेशा की तरह, यदि आप प्रलेखन पर जाते हैं, तो वहां सब कुछ लिखा जाएगा: The Normalize instance used to scale scalar data to the [0, 1] range before mapping to colors using cmap. By default, a linear scaling mapping the lowest value to 0 and the highest to 1 is used. The Normalize instance used to scale scalar data to the [0, 1] range before mapping to colors using cmap. By default, a linear scaling mapping the lowest value to 0 and the highest to 1 is used. यानी लाइब्रेरी ने ध्यान से 0 से 1. रेंज में मेरे 0.5 और 0.73 को सामान्य किया। कोड बदलें:

 plt.imshow(res_imgs[i][:, :, 0], norm=matplotlib.colors.Normalize(0.0, 1.0)) 

और यहां सटीकता के साथ सवाल है। शुरू करने के लिए - आदत से बाहर, हम दस्तावेज़ीकरण पर जाते हैं, tf.keras.metrics.Accuracy लिए tf.keras.metrics.Accuracy और ऐसा लगता है कि वे समझने योग्य लिखते हैं:

 For example, if y_true is [1, 2, 3, 4] and y_pred is [0, 2, 3, 4] then the accuracy is 3/4 or .75. 

लेकिन इस मामले में, हमारी सटीकता 0. होनी चाहिए, परिणामस्वरूप, स्रोत में खुद को दफन कर दिया और यह खुद के लिए काफी स्पष्ट है:

  When you pass the strings 'accuracy' or 'acc', we convert this to one of `tf.keras.metrics.BinaryAccuracy`, `tf.keras.metrics.CategoricalAccuracy`, `tf.keras.metrics.SparseCategoricalAccuracy` based on the loss function used and the model output shape. We do a similar conversion for the strings 'crossentropy' and 'ce' as well. 

इसके अलावा, किसी कारण के लिए साइट पर प्रलेखन में यह अनुच्छेद .compile के विवरण में .compile ।

यहां https://github.com/tensorflow/tensorflow/blob/66c48046f169f3565d12e5fea263f6d731f9bfd2-tensorflow/py_n/engine/compile_utils.py से कोड का एक टुकड़ा है

 y_t_rank = len(y_t.shape.as_list()) y_p_rank = len(y_p.shape.as_list()) y_t_last_dim = y_t.shape.as_list()[-1] y_p_last_dim = y_p.shape.as_list()[-1] is_binary = y_p_last_dim == 1 is_sparse_categorical = ( y_t_rank < y_p_rank or y_t_last_dim == 1 and y_p_last_dim > 1) if metric in ['accuracy', 'acc']: if is_binary: metric_obj = metrics_mod.binary_accuracy elif is_sparse_categorical: metric_obj = metrics_mod.sparse_categorical_accuracy else: metric_obj = metrics_mod.categorical_accuracy 

y_t y_true, या अपेक्षित आउटपुट है, y_p y_predenced, या अनुमानित परिणाम है।
हमारे पास डेटा प्रारूप है: shape=(64,64,1) , इसलिए यह पता चलता है कि सटीकता को बाइनरी_सुरस के रूप में माना जाता है। यह कैसे माना जाता है, इसके लिए ब्याज:

 def binary_accuracy(y_true, y_pred, threshold=0.5): threshold = math_ops.cast(threshold, y_pred.dtype) y_pred = math_ops.cast(y_pred > threshold, y_pred.dtype) return K.mean(math_ops.equal(y_true, y_pred), axis=-1) 

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

 m = tf.keras.metrics.BinaryAccuracy() m.update_state(x_batch, res_imgs) print(m.result().numpy()) 

हमें 1.0 ।

और यहाँ

 m = tf.keras.metrics.Accuracy() m.update_state(x_batch, res_imgs) print(m.result().numpy()) 

हमें उसी डेटा पर 0.0 देगा।

वैसे, कोड के एक ही टुकड़े का उपयोग नुकसान-कार्यों के साथ खेलने और यह समझने के लिए किया जा सकता है कि वे कैसे काम करते हैं। यदि आप ऑटो-एनकोडर पर ट्यूटोरियल पढ़ते हैं, तो मूल रूप से वे दो हानि-कार्यों में से एक का उपयोग करने का सुझाव देते हैं: या तो चुकता त्रुटि या 'बाइनरी_क्रॉसेंट्रोपी'। आप उन्हें उसी समय भी देख सकते हैं।

मैं आपको याद दिलाता हूं कि mse मैंने पहले से ही evaluate मॉडल दिए थे:

 8/Unknown - 2s 221ms/step - loss: 0.2488 - accuracy: 1.0000[0.24876083992421627, 1.0] 

यानी loss == 0.2488 आइए देखें कि यह क्यों है। यह मुझे व्यक्तिगत रूप से लगता है कि यह सबसे सरल और सबसे समझ में आता है: y_true और y_predict के बीच अंतर पिक्सेल द्वारा पिक्सेल को घटाया जाता है, प्रत्येक परिणाम को चुकता किया जाता है, और फिर औसत खोजा जाता है।

 tf.keras.backend.mean(tf.math.squared_difference(x_batch[0], res_imgs[0])) 

और उत्पादन में:

 <tf.Tensor: shape=(), dtype=float32, numpy=0.24826494> 

यहां अंतर्ज्ञान बहुत सरल है - अधिकांश खाली पिक्सेल हैं, मॉडल 0.5 का उत्पादन करता है, उनके लिए 0.25 - चुकता अंतर मिलता है।

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

  if from_logits: return nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output) if not isinstance(output, (ops.EagerTensor, variables_module.Variable)): output = _backtrack_identity(output) if output.op.type == 'Sigmoid': # When sigmoid activation function is used for output operation, we # use logits from the sigmoid function directly to compute loss in order # to prevent collapsing zero when training. assert len(output.op.inputs) == 1 output = output.op.inputs[0] return nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output) # Compute cross entropy from probabilities. bce = target * math_ops.log(output + epsilon()) bce += (1 - target) * math_ops.log(1 - output + epsilon()) return -bce 

सच कहूं, तो मैंने बहुत लंबे समय के लिए कोड की इन कुछ पंक्तियों पर अपने दिमाग को लुटा दिया। सबसे पहले, यह तुरंत स्पष्ट है कि दो कार्यान्वयन काम कर सकते हैं: या तो sigmoid_cross_entropy_with_logits को बुलाया जाएगा, या लाइनों की अंतिम जोड़ी काम करेगी। अंतर यह है कि sigmoid_cross_entropy_with_logits logits (जैसा कि नाम का अर्थ है, doh) के साथ काम करता है, और मुख्य कोड प्रायिकता के साथ काम करता है।

कौन लोग हैं? यदि आप विषय पर एक लाख अलग-अलग लेख पढ़ते हैं, तो वे गणितीय परिभाषाओं, सूत्रों, कुछ और का उल्लेख करेंगे। व्यवहार में, सब कुछ आश्चर्यजनक रूप से सरल लगता है (मुझे गलत होने पर सही करें)। भविष्यवाणी का कच्चा आउटपुट लॉगिट्स है। खैर, या लॉग-ऑड्स, लॉगरिदमिक ऑड्स जो लॉग इस् टिक में मापा जाता है, उसके लॉजिस्टिक तोते।

 ln(1/2) == -0.69 ln(2/1) == 0.69 ln(1/100) == -4.6 ln(100/1) == 4.6 

टेंसोफ़्लो के मामले में, यह बल्कि मनमाना है, क्योंकि, कड़ाई से बोलने पर, परत का उत्पादन गणितीय रूप से लॉग-ऑड नहीं है, लेकिन यह पहले से ही स्वीकार किया जाता है। यदि कच्चा मान -∞ से + raw तक है - तो लॉगिन करता है। फिर उन्हें संभावनाओं में परिवर्तित किया जा सकता है। इसके लिए दो विकल्प हैं: सॉफ्टमैक्स और उसका विशेष मामला, सिग्मॉइड। सॉफ्टमैक्स - लॉग का एक वेक्टर लें, और उन्हें संभावनाओं के वेक्टर में परिवर्तित करें, और यहां तक ​​कि इसमें सभी घटनाओं की संभावना का योग 1 निकलता है। सिग्मॉइड (tf के मामले में) लॉग का वेक्टर भी लेता है, लेकिन उनमें से प्रत्येक को अलग-अलग, स्वतंत्र रूप से संभावनाओं में परिवर्तित करता है। बाकी से।

 # 1+ln(0.5) == 0.30685281944 tf.math.softmax(tf.constant([0.30685281944, 1.0, 0.30685281944])) ## <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0.25, 0.5 , 0.25], dtype=float32)> tf.math.sigmoid(tf.constant([0.30685281944, 1.0, 0.30685281944])) ## <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0.57611686, 0.7310586 , 0.57611686], dtype=float32)> 

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

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

ठीक है, इसे सुलझा लिया, अब बाइनरी_क्रोसेंट्रॉपी। दो लोकप्रिय "सहज" स्पष्टीकरण हैं जो क्रॉस-एंट्रोपी को मापते हैं।

अधिक औपचारिक: कल्पना करें कि एक निश्चित मॉडल है जो n वर्गों के लिए उनकी घटना की संभावना जानता है (y ₀ , y ₁ , ..., y _n )। और अब जीवन में, इन वर्गों में से प्रत्येक ने k _n बार (k ₁ , k ₁ , ..., k _n ) उत्पन्न किया है। इस तरह की घटना की संभावना प्रत्येक व्यक्ति वर्ग के लिए संभाव्यता का उत्पाद है - (y ₁ ^ k ₁ ) (y ₂ ^ k ₂ ) ... (y _n ^ k _n )। सिद्धांत रूप में - यह पहले से ही क्रॉस-एन्ट्रॉपी की एक सामान्य परिभाषा है - एक डेटासेट की संभावना दूसरे डेटासेट की संभावना के संदर्भ में व्यक्त की जाती है। इस परिभाषा के साथ समस्या यह है कि यह 0 से 1 तक हो जाएगा और अक्सर बहुत छोटा होगा; ऐसे मूल्यों की तुलना करना सुविधाजनक नहीं है।
यदि हम इससे लघुगणक लेते हैं, तो k ₁ log (y ₁ ) + k ₂ log (y ₂ ) बाहर आएगा और इसी तरह। मानों की सीमा ∞ से 0. तक हो जाती है - इन सभी को -1 / n से गुणा करें - और 0 से + more तक की सीमा, इसके अलावा, क्योंकि इसे प्रत्येक वर्ग के लिए मानों के योग के रूप में व्यक्त किया जाता है, प्रत्येक कक्षा में परिवर्तन समग्र रूप से बहुत ही अनुमानित तरीके से परिलक्षित होता है।

अधिक सरल: क्रॉस-एन्ट्रापी दिखाता है कि मूल मॉडल के संदर्भ में नमूना को व्यक्त करने के लिए कितने अतिरिक्त बिट्स की आवश्यकता है। यदि हम बेस 2 के साथ एक लघुगणक बनाने के लिए वहां थे, तो हम सीधे बिट्स जाएंगे। हम हर जगह प्राकृतिक लघुगणक का उपयोग करते हैं, इसलिए वे नट की संख्या दिखाते हैं ( https://en.wikipedia.org/wiki/Nat_(unit )), बिट्स नहीं।

बाइनरी क्रॉस-एंट्रोपी, बदले में, साधारण क्रॉस-एन्ट्रॉपी का एक विशेष मामला है, जब कक्षाओं की संख्या दो होती है। तब हमारे पास एक वर्ग - y ₁ के होने की संभावना का पर्याप्त ज्ञान है, और दूसरे की संभावना (1-y ₁ ) होगी।

लेकिन, यह मुझे लगता है, मुझे थोड़ा उलझन में है। मुझे याद दिलाएं, पिछली बार जब हमने एक पहचान ऑटो-एनकोडर बनाने की कोशिश की थी, तो उसने हमें एक सुंदर तस्वीर दिखाई, और 1.0 की सटीकता भी दिखाई, लेकिन वास्तव में संख्या भयानक निकली। प्रयोग के लिए, आप कुछ और परीक्षण कर सकते हैं:
1) सक्रियता को पूरी तरह से हटाया जा सकता है, एक साफ पहचान होगी
2) आप अन्य सक्रियण कार्यों की कोशिश कर सकते हैं, उदाहरण के लिए उसी रिले

सक्रियण के बिना:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, use_bias=False, kernel_initializer=tf.keras.initializers.Identity())) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

हमें पूर्ण पहचान मॉडल मिलता है:

 model.evaluate(x=val.map(lambda x: (x,x)).batch(BATCH_SIZE, drop_remainder=True)) # 8/Unknown - 1s 173ms/step - loss: 0.0000e+00 - accuracy: 1.0000[0.0, 1.0] 

प्रशिक्षण, वैसे, कुछ भी नहीं होगा, क्योंकि हानि == 0.0।

अब रिले के साथ। उनका ग्राफ इस तरह दिखता है:

 import matplotlib.ticker as plticker range_tensor = tf.range(-4, 4, 0.01, dtype=tf.float32) fig, ax = plt.subplots(1,1) plt.plot(range_tensor.numpy(), tf.keras.activations.relu(range_tensor).numpy()) ax.grid(which='major', linestyle='-', linewidth='0.5', color='red') ax.grid(which='minor', linestyle=':', linewidth='0.5', color='black') ax.yaxis.set_major_locator(plticker.MultipleLocator(base=1) ) plt.minorticks_on() 

शून्य से नीचे - शून्य, ऊपर - y = x, अर्थात सिद्धांत रूप में, हमें सक्रियता की अनुपस्थिति में एक ही प्रभाव प्राप्त करना चाहिए - एक आदर्श मॉडल।

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation='relu', use_bias=False, kernel_initializer=tf.keras.initializers.Identity())) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"]) model.evaluate(x=val.map(lambda x: (x,x)).batch(BATCH_SIZE, drop_remainder=True)) # 8/Unknown - 1s 158ms/step - loss: 0.0000e+00 - accuracy: 1.0000[0.0, 1.0] 

ठीक है, हमने पहचान मॉडल का पता लगाया, यहां तक ​​कि सिद्धांत के कुछ हिस्से के साथ यह स्पष्ट हो गया। अब चलो उसी मॉडल को प्रशिक्षित करने का प्रयास करें ताकि यह पहचान बन जाए।

मज़े के लिए, मैं इस प्रयोग को तीन सक्रियण क्रियाओं पर करूँगा। के साथ शुरू करने के लिए - relu, क्योंकि यह खुद को पहले से ही अच्छी तरह से दिखाया गया था (सब कुछ पहले जैसा है, लेकिन kernel_initializer हटा दिया जाता है, इसलिए डिफ़ॉल्ट रूप से यह glorot_uniform होगा):

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation='relu', use_bias=False)) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

यह आश्चर्यजनक रूप से सीखता है:

परिणाम काफी अच्छा था, सटीकता: 0.9999, हानि (mse): 2e-04 20 युगों के बाद और आप आगे प्रशिक्षित कर सकते हैं।

अगला, सिग्मॉइड के साथ प्रयास करें:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation='sigmoid', use_bias=False)) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

मैंने पहले ही कुछ इसी तरह की शिक्षा दी थी, एकमात्र अंतर यह है कि पूर्वाग्रह यहाँ अक्षम है। वह मुझे अध्ययन करता है, 50 वें युग के क्षेत्र में एक पठार पर जाता है, सटीकता: 0.9970, हानि: 60 के दशक के बाद 0.01।

परिणाम फिर से प्रभावशाली नहीं है:

खैर, तन की भी जाँच करें:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation='tanh', use_bias=False)) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

परिणाम रिले के लिए तुलनीय है - सटीकता: 0.9999, नुकसान: 20 युगों के बाद 6e-04, और आप आगे प्रशिक्षित कर सकते हैं:

वास्तव में, मुझे इस सवाल से पीड़ा होती है कि क्या सिग्मॉइड को तुलनात्मक परिणाम दिखाने के लिए कुछ किया जा सकता है। विशेष रूप से खेल हित से बाहर।

उदाहरण के लिए, आप बैचननलाइज़ेशन जोड़ने का प्रयास कर सकते हैं:

 model = tf.keras.Sequential() model.add(tf.keras.Input(shape=(64,64,1))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(64*64, activation='sigmoid', use_bias=False)) model.add(tf.keras.layers.BatchNormalization()) model.add(tf.keras.layers.Reshape(target_shape=(64,64,1))) 

और फिर किसी तरह का जादू होता है। 13 वें युग में, सटीकता: 1.0। और उग्र परिणाम:

III ... इस चट्टान-पिछलग्गू पर मैं पहला भाग समाप्त कर दूंगा, क्योंकि पाठ बहुत अधिक नरम है, और यह स्पष्ट नहीं है कि किसी को इसकी आवश्यकता है या नहीं। दूसरे भाग में मैं समझूंगा कि जादू क्या हुआ, विभिन्न ऑप्टिमाइज़र के साथ प्रयोग करें, एक ईमानदार एनकोडर-डिकोडर बनाने की कोशिश करें, मेज पर मेरा सिर धमाका करें। मुझे आशा है कि कोई व्यक्ति दिलचस्पी और मददगार था।