📥 ❔ 🔷 TensorFlow के लिए केर की समीक्षा 💞 👩🏻‍🔧 🖋️

Tensorflow.org से अवलोकन गाइड का अनुवाद। यह मार्गदर्शिका आपको केरस से आरंभ करने के लिए मूल बातें देगी। पढ़ने में 10 मिनट लगते हैं।

आयात tf.keras

tf.keras Keras API विनिर्देशन का कार्यान्वयन है। यह निर्माण और प्रशिक्षण मॉडल के लिए एक उच्च-स्तरीय एपीआई है जिसमें टेन्सरफ्लो-विशिष्ट कार्यक्षमता जैसे कि उत्सुक निष्पादन , tf.data पाइपलाइन और एस्टीमेटर के लिए प्रथम श्रेणी का समर्थन शामिल है। tf.keras लचीलापन और प्रदर्शन का त्याग किए बिना TensorFlow का उपयोग करना आसान बनाता है।

आरंभ करने के लिए, अपने TensorFlow सेटअप के भाग के रूप में tf.keras आयात करें:

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

tf.keras किसी भी tf.keras संगत कोड को निष्पादित कर सकता है, लेकिन ध्यान रखें:

नवीनतम TensorFlow रिलीज़ में tf.keras का संस्करण keras में keras के नवीनतम संस्करण से भिन्न हो सकता है। tf.keras.__version__ देखें।
जब आप मॉडल वज़न tf.keras , तो tf.keras चेकपॉइंट प्रारूप में डिफ़ॉल्ट रूप से ऐसा करता है। save_format='h5' का उपयोग करने के लिए save_format='h5' पैरामीटर पास करें (या फ़ाइल .h5 में .h5 एक्सटेंशन जोड़ें)।

एक साधारण मॉडल बनाएँ

अनुक्रमिक मॉडल

केरस में, आप मॉडल बनाने के लिए परतें जमा करते हैं । एक मॉडल एक (आमतौर पर) परत ग्राफ है। मॉडल का सबसे आम प्रकार परत ढेर है: tf.keras.Sequential मॉडल।

हम एक पूरी तरह से जुड़े नेटवर्क का निर्माण करते हैं (यानी, एक बहुपरत अवधारणात्मक):

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

परतों को अनुकूलित करें

tf.keras.layers परतों की कई किस्में tf.keras.layers । उनमें से ज्यादातर एक सामान्य तर्क निर्माता का उपयोग करते हैं:

activation : परत के लिए सक्रियण फ़ंक्शन सेट करता है। यह पैरामीटर अंतर्निहित फ़ंक्शन या तथाकथित ऑब्जेक्ट का नाम निर्दिष्ट करता है। पैरामीटर का कोई डिफ़ॉल्ट मान नहीं है।
kernel_initializer और bias_initializer : आरंभिक योजनाएँ जो लेयर वेट (कोर और शिफ्ट) बनाती हैं। यह पैरामीटर नाम या तथाकथित ऑब्जेक्ट हो सकता है। डिफ़ॉल्ट इनिशियलाइज़र "Glorot uniform" ।
kernel_regularizer और bias_regularizer : bias_regularizer योजनाओं को परत भार (कोर और शिफ्ट) में जोड़ा जाता है, जैसे कि एल 1 या एल 2 नियमितीकरण। डिफ़ॉल्ट रूप से, नियमितीकरण सेट नहीं है।

'Tf.keras.layers.Dense' परतों के उदाहरणों के निम्न उदाहरण कंस्ट्रक्टर के तर्क का उपयोग करते हैं:

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

प्रशिक्षण और मूल्यांकन

प्रशिक्षण सेटअप

मॉडल के निर्माण के बाद, compile प्रक्रिया को कॉल करके सीखने की प्रक्रिया को कॉन्फ़िगर करें:

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

tf.keras.Model.compile तीन महत्वपूर्ण तर्क स्वीकार करता है:

optimizer : यह ऑब्जेक्ट प्रशिक्षण प्रक्रिया को परिभाषित करता है। tf.keras.optimizers मॉड्यूल से ऑप्टिमाइज़र इंस्टेंसेस पास करें, जैसे कि tf.keras.optimizers.Adam या tf.keras.optimizers.SGD । यदि आप केवल डिफ़ॉल्ट विकल्पों का उपयोग करना चाहते हैं, तो आप 'adam' या 'sgd' जैसे कीवर्ड के साथ ऑप्टिमाइज़र भी निर्दिष्ट कर सकते हैं।
loss : यह एक ऐसा कार्य है जिसे सीखने की प्रक्रिया में न्यूनतम किया जाता है। सामान्य भिन्नताओं में मानक त्रुटि ( mse ), binary_crossentropy , binary_crossentropy । हानि कार्यों को नाम या निर्दिष्ट ऑब्जेक्ट tf.keras.losses मॉड्यूल से पास करके निर्दिष्ट किया जाता है।
metrics : प्रशिक्षण की निगरानी के लिए उपयोग किया जाता है। ये स्ट्रिंग नाम हैं या जिन्हें tf.keras.metrics मॉड्यूल से ऑब्जेक्ट कहा जाता है।
इसके अलावा, यह सुनिश्चित करने के लिए कि मॉडल को प्रशिक्षित किया गया है और उत्सुकता से मूल्यांकन किया गया है, जांचें कि आप पैरामीटर run_eagerly=True कंपाइलर पर run_eagerly=True

अगला, हम प्रशिक्षण के लिए मॉडल विन्यास के कुछ उदाहरण देखेंगे:

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

NumPy Data से सीखना

छोटे डेटासेट के लिए, मॉडल को प्रशिक्षित करने और मूल्यांकन करने के लिए NumPy की मेमोरी सरणियों का उपयोग करें। मॉडल `फिट` विधि का उपयोग कर प्रशिक्षण डेटा पर" प्रशिक्षित "है:

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit में तीन महत्वपूर्ण तर्क दिए गए हैं:

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

यहाँ validation_data का उपयोग करके एक उदाहरण दिया गया है:

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))

Tf.data डेटासेट का उपयोग करके प्रशिक्षण

बड़े डेटाबेस या कई उपकरणों के प्रशिक्षण के लिए डेटासेट एपीआई का उपयोग करें। fit विधि के लिए 'tf.data.Dataset' का उदाहरण दें:

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

चूंकि Dataset बैचों में डेटा प्रदान करता है, कोड के इस टुकड़े को batch_size तर्क की आवश्यकता नहीं होती है।

डेटासेट को मान्य करने के लिए भी उपयोग किया जा सकता है:

 dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)

आकलन और भविष्यवाणी

tf.keras.Model.evaluate और tf.keras.Model.predict NumPy और tf.data.Dataset उपयोग कर सकती हैं।

यह है कि आप प्रदान किए गए डेटा के लिए आउटपुट मोड और मीट्रिक में नुकसान का अनुमान लगा सकते हैं:

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

और यहां बताया गया है कि न्यूमपी सरणी के रूप में प्रदान किए गए डेटा के लिए आउटपुट मोड में अंतिम स्तर के आउटपुट की भविष्यवाणी कैसे करें:

जटिल मॉडल का निर्माण

कार्यात्मक एपीआई

tf.keras.Sequential मॉडल एक साधारण परत स्टैक है जिसके साथ आप एक मनमाने मॉडल की कल्पना नहीं कर सकते हैं। जटिल मॉडल टोपोलॉजी बनाने के लिए केरस कार्यात्मक एपीआई का उपयोग करें, जैसे:

एकाधिक इनपुट मॉडल
कई आउटपुट वाले मॉडल,
सामान्य परतों वाले मॉडल (एक ही परत को कई बार कहा जाता है),
असंगत डेटा धाराओं वाले मॉडल (उदा। अवशिष्ट संबंध)।

एक कार्यात्मक एपीआई के साथ एक मॉडल का निर्माण निम्नानुसार काम करता है:

परत का उदाहरण कॉल करने योग्य है और एक टेंसर को लौटाता है।
इनपुट और आउटपुट tf.keras.Model का उपयोग tf.keras.Model के उदाहरण को निर्धारित करने के लिए किया जाता है
यह मॉडल `अनुक्रमिक` मॉडल की तरह ही प्रशिक्षित है।

निम्न उदाहरण एक सरल, पूरी तरह से जुड़े नेटवर्क के निर्माण के लिए कार्यात्मक एपीआई का उपयोग करता है:

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

इन इनपुट और आउटपुट के साथ मॉडल का एक उदाहरण बनाएं।

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

उपवर्ग मॉडल

tf.keras.Model का उपयोग करके एक पूरी तरह से अनुकूलन योग्य मॉडल बनाएं और अपने स्वयं के सीधे वितरण को परिभाषित करें। __init__ विधि में परतें बनाएं और उन्हें वर्ग उदाहरण की विशेषताओं के रूप में सेट करें। call विधि में प्रत्यक्ष प्रसार को परिभाषित call ।

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

नोट: यदि आप चाहते हैं कि आपका मॉडल हमेशा अनिवार्य रूप से निष्पादित हो, तो आप super कंस्ट्रक्टर को कॉल करते समय dynamic=True सेट कर सकते हैं।

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

निम्न उदाहरण एक उपवर्गित tf.keras.Model मॉडल दिखाता है जो कस्टम प्रत्यक्ष वितरण का उपयोग करता है, जो अपूर्ण होने की आवश्यकता नहीं है:

 class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

नए मॉडल वर्ग का एक उदाहरण बनाएं:

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

कस्टम परतें

tf.keras.layers.Layer एक कस्टम लेयर बनाएं। निम्नलिखित तरीकों को लागू करें और लागू करें:

__init__ : वैकल्पिक रूप से इस परत में उपयोग किए जाने वाले सबलेयर निर्दिष्ट करें।
* build : परत वजन बनाएँ। add_weight विधि का उपयोग करके वेट जोड़ें
call : प्रत्यक्ष वितरण को परिभाषित करें।
वैकल्पिक रूप से, get_config विधि और from_config वर्ग from_config को लागू करके परत को क्रमबद्ध किया जा सकता है।

नीचे एक उपयोगकर्ता परत का एक उदाहरण है जो कर्नेल मैट्रिक्स के साथ इनपुट को matmul गए मैट्रिक्स ( matmul ) को गुणा करता है:

 class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): #       . self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)

अपने कस्टम लेयर का उपयोग करके एक मॉडल बनाएँ:

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

कॉलबैक

कोल्बक एक ऐसी वस्तु है जो प्रशिक्षण के दौरान अपने व्यवहार को अनुकूलित और विस्तारित करने के लिए मॉडल में स्थानांतरित की जाती है। आप अपना स्वयं का कस्टम कॉलबैक लिख सकते हैं या अंतर्निहित tf.keras.callbacks उपयोग कर tf.keras.callbacks जिसमें शामिल हैं:

tf.keras.callbacks.ModelCheckpoint : नियमित अंतराल पर मॉडल ब्रेकप्वाइंट सहेजना।
tf.keras.callbacks.LearningRateScheduler : डायनामिक रूप से शिक्षण चरण बदलें।
tf.keras.callbacks.EarlyStopping : सत्यापन के परिणाम में सुधार होने पर प्रशिक्षण रोक देना।
tf.keras.callbacks.TensorBoard: मॉनिटर मॉडल व्यवहार का उपयोग करना
TensorBoard

tf.keras.callbacks.Callback उपयोग करने के लिए, इसे fit मॉडल विधि में पास करें:

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))

सहेजना और पुनर्स्थापित करना

केवल वजन मूल्यों की बचत

tf.keras.Model.save_weights का उपयोग करके मॉडल भार को सहेजें और लोड करें:

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy'])

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

डिफ़ॉल्ट रूप से, मॉडल वेट TensorFlow चेकपॉइंट प्रारूप में सहेजे जाते हैं। वजन को केरस एचडीएफ 5 प्रारूप (केरस सार्वभौमिक कार्यान्वयन के लिए डिफ़ॉल्ट मूल्य) में भी बचाया जा सकता है:

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

केवल मॉडल कॉन्फ़िगरेशन सहेजना

मॉडल के विन्यास को बचाया जा सकता है - यह बिना किसी वजन के मॉडल की वास्तुकला को क्रमबद्ध करता है। एक सहेजा गया कॉन्फ़िगरेशन मूल मॉडल को परिभाषित किए बिना, समान मॉडल को पुनर्स्थापित और प्रारंभ कर सकता है। केरसन JSON और YAML क्रमांकन स्वरूपों का समर्थन करता है:

 #     JSON json_string = model.to_json() json_string

 import json import pprint pprint.pprint(json.loads(json_string))

JSON से एक मॉडल (पुनर्निवेशित) को पुनर्स्थापित करना:

 fresh_model = tf.keras.models.model_from_json(json_string)

मॉडल को यरमल के साथ सीरियल करने के लिए TensorFlow आयात करने से पहले `pyyaml` की स्थापना की आवश्यकता होती है:

 yaml_string = model.to_yaml() print(yaml_string)

YAML से एक मॉडल को पुनर्स्थापित करना:

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

नोट: उपवर्गित मॉडल क्रमिक नहीं हैं, क्योंकि उनकी वास्तुकला को `कॉल` पद्धति के शरीर में पायथन कोड द्वारा परिभाषित किया गया है।

पूरे मॉडल को एक फ़ाइल में सहेजना

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

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

उत्सुक निष्पादन

एगर निष्पादन एक अनिवार्य प्रोग्रामिंग वातावरण है जो तुरंत संचालन करता है। यह tf.keras लिए आवश्यक नहीं है, लेकिन tf.keras द्वारा समर्थित है और आपके प्रोग्राम और डिबगिंग की जाँच के लिए उपयोगी है।

`Tf.keras` एपीआई के सभी इमारत मॉडल उत्सुक निष्पादन के साथ संगत हैं। यद्यपि `अनुक्रमिक` और कार्यात्मक एपीआई का उपयोग किया जा सकता है, एक मॉडल को बनाने और कस्टम परतों के निर्माण के दौरान उत्सुक निष्पादन विशेष रूप से उपयोगी होता है - इन एपीआई को आपको कोड के रूप में प्रत्यक्ष वितरण लिखने की आवश्यकता होती है (एपीआई के बजाय जो मौजूदा परतों को इकट्ठा करके मॉडल बनाते हैं)।

वितरण

मल्टीपल जीपीयू

tf.keras मॉडल को कई GPU पर tf.distribute.Strategy का उपयोग करके चलाया जा सकता है। यह एपीआई मौजूदा कोड में बहुत कम या कोई बदलाव नहीं के साथ कई GPU में वितरित सीखने प्रदान करता है।

वर्तमान में, tf.distribute.MirroredStrategy एकमात्र समर्थित वितरण रणनीति है। MirroredStrategy रेखांकन के साथ रेखांकन करता है
एक मशीन पर सभी को कम करने का उपयोग कर तुल्यकालिक सीखने। ` .scope() उपयोग करने के लिए,` Strategy `` .scope() `में मॉडल के अनुकूलक अधिष्ठापन, डिज़ाइन और संकलन को घोंसले में .scope() , फिर मॉडल को प्रशिक्षित करें।

निम्न उदाहरण एक ही मशीन पर कई GPU के बीच tf.keras.Model वितरित tf.keras.Model ।

सबसे पहले, हम एक वितरित रणनीति के क्षेत्र के भीतर एक मॉडल को परिभाषित करते हैं:

 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()

फिर हम हमेशा की तरह डेटा पर मॉडल को प्रशिक्षित करते हैं:

 x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)

सत्यापन के बाद, अनुवाद Tensorflow.org पर भी दिखाई देगा। यदि आप रूसी में Tensorflow.org वेबसाइट के प्रलेखन के अनुवाद में भाग लेना चाहते हैं, तो कृपया एक व्यक्तिगत या टिप्पणी में संपर्क करें। किसी भी सुधार या टिप्पणी की सराहना की जाती है।

TensorFlow के लिए केर की समीक्षा