टेन्सरफ्लो में केरस फंक्शनल एपीआई

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

परिचय

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

यह इस तथ्य पर आधारित है कि गहन शिक्षण मॉडल आमतौर पर परतों का एक निर्देशित चक्रीय ग्राफ (डीएजी) है

कार्यात्मक एपीआई परतों की साजिश रचने के लिए उपकरणों का एक समूह है।

निम्नलिखित मॉडल पर विचार करें:

(इनपुट: 784-आयामी वेक्टर)
↧
[घनी परत (64 तत्व, रिले की सक्रियता)]
↧
[घनी परत (64 तत्व, रिले की सक्रियता)]
↧
[सघन परत (10 तत्व, सॉफ्टमैक्स की सक्रियता)]
↧
(आउटपुट: 10 से अधिक वर्गों में संभाव्यता वितरण)

यह 3 परतों का एक सरल ग्राफ है।

फंक्शनल एपीआई का उपयोग करके इस मॉडल को बनाने के लिए, आपको एक इनपुट नोड बनाकर शुरू करना होगा:

from tensorflow import keras inputs = keras.Input(shape=(784,)) 

यहां हम केवल अपने डेटा के आयाम को इंगित करते हैं: 784-आयामी वैक्टर। कृपया ध्यान दें कि डेटा की मात्रा हमेशा छोड़ी जाती है, हम केवल प्रत्येक तत्व के आयाम को इंगित करते हैं। छवियों के लिए इच्छित आकार दर्ज करने के लिए (32, 32, 3) `, हम उपयोग करेंगे:

 img_inputs = keras.Input(shape=(32, 32, 3)) 

inputs रिटर्न में आकार और डेटा के प्रकार के बारे में जानकारी होती है जिसे आप अपने मॉडल में स्थानांतरित करने की योजना बनाते हैं:

 inputs.shape 

 TensorShape([None, 784]) 

 inputs.dtype 

 tf.float32 

आप इस inputs ऑब्जेक्ट पर परत को कॉल करके परत ग्राफ में एक नया नोड बनाते हैं:

 from tensorflow.keras import layers dense = layers.Dense(64, activation='relu') x = dense(inputs) 

"एक परत को कॉल करना" हमारे द्वारा बनाई गई परत में "इनपुट" से एक तीर को खींचने के समान है। हम dense परत के इनपुट को "पास" करते हैं, और हमें x मिलता है।

आइए हमारी परत ग्राफ में कुछ और परतें जोड़ते हैं:

 x = layers.Dense(64, activation='relu')(x) outputs = layers.Dense(10, activation='softmax')(x) 

अब हम लेयर ग्राफ में इसके इनपुट और आउटपुट को निर्दिष्ट करके एक Model बना सकते हैं:

 model = keras.Model(inputs=inputs, outputs=outputs) 

आइए फिर से देखें पूरी मॉडल परिभाषा प्रक्रिया:

 inputs = keras.Input(shape=(784,), name='img') x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) outputs = layers.Dense(10, activation='softmax')(x) model = keras.Model(inputs=inputs, outputs=outputs, name='mnist_model') 

आइए देखें कि मॉडल सारांश कैसा दिखता है:

 model.summary() 

 Model: "mnist_model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= img (InputLayer) [(None, 784)] 0 _________________________________________________________________ dense_3 (Dense) (None, 64) 50240 _________________________________________________________________ dense_4 (Dense) (None, 64) 4160 _________________________________________________________________ dense_5 (Dense) (None, 10) 650 ================================================================= Total params: 55,050 Trainable params: 55,050 Non-trainable params: 0 _________________________________________________________________ 

हम मॉडल को एक ग्राफ के रूप में भी आकर्षित कर सकते हैं:

 keras.utils.plot_model(model, 'my_first_model.png') 

और वैकल्पिक रूप से निर्मित ग्राफ पर प्रत्येक परत के इनपुट और आउटपुट के आयामों को प्राप्त करें:

 keras.utils.plot_model(model, 'my_first_model_with_shape_info.png', show_shapes=True) 

यह छवि और हमारे द्वारा लिखा गया कोड समान है। कोड संस्करण में, बाइंडिंग एरो को केवल कॉल ऑपरेशंस द्वारा प्रतिस्थापित किया जाता है।

"लेयर ग्राफ" गहरी सीखने के मॉडल के लिए एक बहुत ही सहज मानसिक छवि है, और कार्यात्मक एपीआई मॉडल बनाने का एक तरीका है जो इस मानसिक छवि को बारीकी से दर्शाता है।

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

सेक्शनल मॉडल की तरह ही फंक्शनल एपीआई का उपयोग करके बनाए गए मॉडल के लिए सीखना, मूल्यांकन और व्युत्पन्न करना।

एक त्वरित डेमो पर विचार करें।

यहां हम MNIST छवि डेटासेट लोड करते हैं, इसे वैक्टर में परिवर्तित करते हैं, डेटा पर मॉडल को प्रशिक्षित करते हैं (परीक्षण नमूने पर काम की गुणवत्ता की निगरानी करते हुए), और अंत में हम परीक्षण मॉडल पर अपने मॉडल का मूल्यांकन करते हैं:

 (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() x_train = x_train.reshape(60000, 784).astype('float32') / 255 x_test = x_test.reshape(10000, 784).astype('float32') / 255 model.compile(loss='sparse_categorical_crossentropy', optimizer=keras.optimizers.RMSprop(), metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=64, epochs=5, validation_split=0.2) test_scores = model.evaluate(x_test, y_test, verbose=2) print('Test loss:', test_scores[0]) print('Test accuracy:', test_scores[1]) 

बचत और सीरियल करना

कार्यात्मक API का उपयोग करके बनाए गए मॉडल के लिए सहेजना और अनुक्रमित करना अनुक्रमिक मॉडल के समान ही काम करता है।

फ़ंक्शनल मॉडल को सहेजने का मानक तरीका model.save( ) को कॉल करना है, जो आपको पूरे मॉडल को एक फ़ाइल में सहेजने की अनुमति देता है।

आप बाद में इस फ़ाइल से उसी मॉडल को पुनर्स्थापित कर सकते हैं, भले ही आपके पास उस कोड तक पहुंच न हो जो मॉडल बनाया गया हो।

इस फ़ाइल में शामिल हैं:

• मॉडल वास्तुकला
• मॉडल वजन (जो प्रशिक्षण के दौरान प्राप्त किया गया था)
• मॉडल प्रशिक्षण विन्यास (आप compile में क्या पास किया है)
• आशावादी और इसकी स्थिति, अगर यह था (यह आपको प्रशिक्षण को फिर से शुरू करने की अनुमति देता है जहां से आपने छोड़ा था)

 model.save('path_to_my_model.h5') del model # Recreate the exact same model purely from the file: model = keras.models.load_model('path_to_my_model.h5') 

एक से अधिक मॉडलों को परिभाषित करने के लिए एक ही लेयर ग्राफ का उपयोग करना

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

नीचे दिए गए उदाहरण में, हम दो मॉडल बनाने के लिए समान परत का उपयोग करते हैं:
एक (encoder) मॉडल जो इनपुट छवियों को 16-आयामी वैक्टर में परिवर्तित करता है, और प्रशिक्षण के लिए एक एंड-टू-एंड (autoencoder) मॉडल है।

 encoder_input = keras.Input(shape=(28, 28, 1), name='img') x = layers.Conv2D(16, 3, activation='relu')(encoder_input) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.MaxPooling2D(3)(x) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.Conv2D(16, 3, activation='relu')(x) encoder_output = layers.GlobalMaxPooling2D()(x) encoder = keras.Model(encoder_input, encoder_output, name='encoder') encoder.summary() x = layers.Reshape((4, 4, 1))(encoder_output) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) x = layers.Conv2DTranspose(32, 3, activation='relu')(x) x = layers.UpSampling2D(3)(x) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) decoder_output = layers.Conv2DTranspose(1, 3, activation='relu')(x) autoencoder = keras.Model(encoder_input, decoder_output, name='autoencoder') autoencoder.summary() 

कृपया ध्यान दें कि हम डिकोडिंग आर्किटेक्चर को एन्कोडिंग आर्किटेक्चर के लिए सख्ती से सममित बनाते हैं, जिससे हमें आउटपुट डेटा का आयाम इनपुट डेटा (28, 28, 1) । Conv2D लेयर, Conv2D लेयर के Conv2D है, और MaxPooling2D लेयर वापस MaxPooling2D लेयर पर जाएगी।

मॉडल को परत के रूप में कहा जा सकता है

आप किसी भी मॉडल का उपयोग कर सकते हैं जैसे कि यह एक परत थी, इसे Input पर या किसी अन्य परत के आउटपुट पर कॉल करना।

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

 encoder_input = keras.Input(shape=(28, 28, 1), name='original_img') x = layers.Conv2D(16, 3, activation='relu')(encoder_input) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.MaxPooling2D(3)(x) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.Conv2D(16, 3, activation='relu')(x) encoder_output = layers.GlobalMaxPooling2D()(x) encoder = keras.Model(encoder_input, encoder_output, name='encoder') encoder.summary() decoder_input = keras.Input(shape=(16,), name='encoded_img') x = layers.Reshape((4, 4, 1))(decoder_input) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) x = layers.Conv2DTranspose(32, 3, activation='relu')(x) x = layers.UpSampling2D(3)(x) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) decoder_output = layers.Conv2DTranspose(1, 3, activation='relu')(x) decoder = keras.Model(decoder_input, decoder_output, name='decoder') decoder.summary() autoencoder_input = keras.Input(shape=(28, 28, 1), name='img') encoded_img = encoder(autoencoder_input) decoded_img = decoder(encoded_img) autoencoder = keras.Model(autoencoder_input, decoded_img, name='autoencoder') autoencoder.summary() 

जैसा कि आप देख सकते हैं, एक मॉडल नेस्टेड हो सकता है: एक मॉडल में एक सबमॉडल हो सकता है (चूंकि मॉडल को एक परत के रूप में माना जा सकता है)।

घोंसले के शिकार मॉडल के लिए एक सामान्य उपयोग का मामला है।

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

 def get_model(): inputs = keras.Input(shape=(128,)) outputs = layers.Dense(1, activation='sigmoid')(inputs) return keras.Model(inputs, outputs) model1 = get_model() model2 = get_model() model3 = get_model() inputs = keras.Input(shape=(128,)) y1 = model1(inputs) y2 = model2(inputs) y3 = model3(inputs) outputs = layers.average([y1, y2, y3]) ensemble_model = keras.Model(inputs=inputs, outputs=outputs) 

जटिल ग्राफ टोपोलॉजी में हेरफेर

कई इनपुट और आउटपुट के साथ मॉडल

कार्यात्मक एपीआई कई इनपुट और आउटपुट के हेरफेर को सरल बनाता है। यह अनुक्रमिक एपीआई के साथ नहीं किया जा सकता है।

यहाँ एक सरल उदाहरण है।

मान लीजिए आप प्राथमिकता के आधार पर ग्राहकों के आवेदनों को सूचीबद्ध करने और उन्हें सही विभाग को भेजने के लिए एक प्रणाली बना रहे हैं।

आपके मॉडल में 3 इनपुट होंगे:

• एप्लिकेशन हैडर (पाठ इनपुट)
• आवेदन की पाठ सामग्री (पाठ इनपुट)
• उपयोगकर्ता द्वारा जोड़ा गया कोई भी टैग (श्रेणीबद्ध इनपुट)

मॉडल में 2 आउटपुट होंगे:

• 0 और 1 (स्केलर सिग्मॉइड आउटपुट) के बीच प्राथमिकता स्कोर
• जिस विभाग को आवेदन की प्रक्रिया करनी चाहिए (कई विभागों से संबंधित सॉफ्टमैक्स आउटपुट)

चलो कार्यात्मक एपीआई का उपयोग करके कई लाइनों में एक मॉडल का निर्माण करते हैं।

 num_tags = 12 #     num_words = 10000 #         num_departments = 4 #     title_input = keras.Input(shape=(None,), name='title') #      body_input = keras.Input(shape=(None,), name='body') #      tags_input = keras.Input(shape=(num_tags,), name='tags') #    `num_tags` #      64-  title_features = layers.Embedding(num_words, 64)(title_input) #      64-  body_features = layers.Embedding(num_words, 64)(body_input) #        128-  title_features = layers.LSTM(128)(title_features) #        32-  body_features = layers.LSTM(32)(body_features) #          x = layers.concatenate([title_features, body_features, tags_input]) #         priority_pred = layers.Dense(1, activation='sigmoid', name='priority')(x) #       department_pred = layers.Dense(num_departments, activation='softmax', name='department')(x) #   ,     model = keras.Model(inputs=[title_input, body_input, tags_input], outputs=[priority_pred, department_pred]) 

आइए एक मॉडल ग्राफ बनाएं:

 keras.utils.plot_model(model, 'multi_input_and_output_model.png', show_shapes=True) 

इस मॉडल को संकलित करते समय, हम प्रत्येक आउटपुट को अलग-अलग हानि कार्य प्रदान कर सकते हैं।

आप प्रत्येक लर्निंग फंक्शन को अलग-अलग वज़न भी दे सकते हैं, ताकि समग्र शिक्षण हानि फ़ंक्शन में उनके योगदान को अलग-अलग किया जा सके।

 model.compile(optimizer=keras.optimizers.RMSprop(1e-3), loss=['binary_crossentropy', 'categorical_crossentropy'], loss_weights=[1., 0.2]) 

चूँकि हमने अपनी आउटपुट लेयर्स को नाम दिया था, हम नुकसान कार्यों को भी निर्दिष्ट कर सकते हैं:

 model.compile(optimizer=keras.optimizers.RMSprop(1e-3), loss={'priority': 'binary_crossentropy', 'department': 'categorical_crossentropy'}, loss_weights=[1., 0.2]) 

हम इनपुट डेटा और लेबल के Numpy सरणियों की सूची पास करके मॉडल को प्रशिक्षित कर सकते हैं:

 import numpy as np # Dummy input data title_data = np.random.randint(num_words, size=(1280, 10)) body_data = np.random.randint(num_words, size=(1280, 100)) tags_data = np.random.randint(2, size=(1280, num_tags)).astype('float32') # Dummy target data priority_targets = np.random.random(size=(1280, 1)) dept_targets = np.random.randint(2, size=(1280, num_departments)) model.fit({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets}, epochs=2, batch_size=32) 

([title_data, body_data, tags_data], [priority_targets, dept_targets]) ऑब्जेक्ट के साथ फिट होने पर, या तो सूचियों का एक टपल ([title_data, body_data, tags_data], [priority_targets, dept_targets]) जैसे कि ([title_data, body_data, tags_data], [priority_targets, dept_targets]) , या शब्दकोशों का एक टपल ({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets}) को लौटाया जाना चाहिए। ({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets}) ।

प्रशिक्षण रेज़नेट मॉडल

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

इसके लिए एक सामान्य उपयोग मामला अवशिष्ट कनेक्शन है।

आइए इसे प्रदर्शित करने के लिए CIFAR10 के लिए एक ResNet प्रशिक्षण मॉडल बनाएं।

 inputs = keras.Input(shape=(32, 32, 3), name='img') x = layers.Conv2D(32, 3, activation='relu')(inputs) x = layers.Conv2D(64, 3, activation='relu')(x) block_1_output = layers.MaxPooling2D(3)(x) x = layers.Conv2D(64, 3, activation='relu', padding='same')(block_1_output) x = layers.Conv2D(64, 3, activation='relu', padding='same')(x) block_2_output = layers.add([x, block_1_output]) x = layers.Conv2D(64, 3, activation='relu', padding='same')(block_2_output) x = layers.Conv2D(64, 3, activation='relu', padding='same')(x) block_3_output = layers.add([x, block_2_output]) x = layers.Conv2D(64, 3, activation='relu')(block_3_output) x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(256, activation='relu')(x) x = layers.Dropout(0.5)(x) outputs = layers.Dense(10, activation='softmax')(x) model = keras.Model(inputs, outputs, name='toy_resnet') model.summary() 

आइए एक मॉडल ग्राफ बनाएं:

 keras.utils.plot_model(model, 'mini_resnet.png', show_shapes=True) 

और उसे सिखाना:

 (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) model.compile(optimizer=keras.optimizers.RMSprop(1e-3), loss='categorical_crossentropy', metrics=['acc']) model.fit(x_train, y_train, batch_size=64, epochs=1, validation_split=0.2) 

परत बांटना

फ़ंक्शनल एपीआई का एक और अच्छा उपयोग ऐसे मॉडल हैं जो सामान्य परतों का उपयोग करते हैं। सामान्य परतें परतों के उदाहरण हैं जो एक ही मॉडल में पुन: उपयोग किए जाते हैं: वे उन विशेषताओं का अध्ययन करते हैं जो एक परत ग्राफ में कई पथों से संबंधित हैं।

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

फ़ंक्शनल एपीआई में एक परत साझा करने के लिए, बस परत के एक ही उदाहरण को कई बार कॉल करें। उदाहरण के लिए, यहां Embedding लेयर को दो टेक्स्ट इनपुट पर साझा किया गया है:

 #   1000    128-  shared_embedding = layers.Embedding(1000, 128) #     text_input_a = keras.Input(shape=(None,), dtype='int32') #     text_input_b = keras.Input(shape=(None,), dtype='int32') #           encoded_input_a = shared_embedding(text_input_a) encoded_input_b = shared_embedding(text_input_b) 

एक परत ग्राफ में नोड्स को पुनः प्राप्त करना और पुन: उपयोग करना

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

इसका मतलब यह भी है कि हम मध्यवर्ती परतों ("ग्राफ में" नोड्स) की सक्रियता तक पहुंच सकते हैं और अन्य स्थानों पर उनका उपयोग कर सकते हैं। उदाहरण के लिए लक्षण निकालने के लिए यह अत्यंत उपयोगी है!

एक उदाहरण देखते हैं। यह एक वीजीजी 19 मॉडल है, जो इमेजनेट पर पूर्व-प्रशिक्षित है:

 from tensorflow.keras.applications import VGG19 vgg19 = VGG19() 

और ये ग्राफ डेटा संरचना की क्वेरी द्वारा प्राप्त मध्यवर्ती मॉडल सक्रियण हैं:

 features_list = [layer.output for layer in vgg19.layers] 

हम एक नई सुविधा निष्कर्षण मॉडल बनाने के लिए इन सुविधाओं का उपयोग कर सकते हैं जो मध्यवर्ती स्तर के सक्रियण मान लौटाता है - और हम इसे 3 पंक्तियों में कर सकते हैं

 feat_extraction_model = keras.Model(inputs=vgg19.input, outputs=features_list) img = np.random.random((1, 224, 224, 3)).astype('float32') extracted_features = feat_extraction_model(img) 

अन्य मामलों की तरह, तंत्रिका शैली हस्तांतरण को लागू करते समय यह सुविधाजनक है।

कस्टम परतों को लिखकर एपीआई का विस्तार करना

tf.keras में अंतर्निहित परतों की एक विस्तृत श्रृंखला है। यहाँ कुछ उदाहरण हैं:

Conv1D परतें: Conv1D , Conv2D , Conv3D , Conv2DTranspose , आदि।
MaxPooling1D परतें: MaxPooling1D , MaxPooling2D 2 MaxPooling1D , MaxPooling2D MaxPooling3D , AveragePooling1D , आदि।
RNN परतें: GRU , LSTM , ConvLSTM2D , आदि।
BatchNormalization , Dropout , BatchNormalization , आदि।

यदि आपको वह नहीं मिला है जिसकी आपको आवश्यकता है, तो अपनी खुद की परत बनाकर एपीआई का विस्तार करना आसान है।

सभी Layer वर्ग को उपवर्गित करती हैं और कार्यान्वित करती हैं:

call विधि जो परत द्वारा की गई गणना को परिभाषित करती है।
लेयर वेट build वाली build विधि (ध्यान दें कि यह सिर्फ एक स्टाइल कन्वेंशन है; आप __init__ में वेट भी बना सकते हैं)।

यहाँ Dense परत का एक सरल कार्यान्वयन है:

 class CustomDense(layers.Layer): def __init__(self, units=32): super(CustomDense, self).__init__() self.units = units def build(self, input_shape): self.w = self.add_weight(shape=(input_shape[-1], self.units), initializer='random_normal', trainable=True) self.b = self.add_weight(shape=(self.units,), initializer='random_normal', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.w) + self.b inputs = keras.Input((4,)) outputs = CustomDense(10)(inputs) model = keras.Model(inputs, outputs) 

यदि आप अपनी कस्टम लेयर को क्रमांकन का समर्थन करना चाहते हैं, तो आपको get_config विधि को भी परिभाषित करना होगा जो लेयर इंस्टेंस के कंस्ट्रक्टर तर्कों को लौटाता है:

 class CustomDense(layers.Layer): def __init__(self, units=32): super(CustomDense, self).__init__() self.units = units def build(self, input_shape): self.w = self.add_weight(shape=(input_shape[-1], self.units), initializer='random_normal', trainable=True) self.b = self.add_weight(shape=(self.units,), initializer='random_normal', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.w) + self.b def get_config(self): return {'units': self.units} inputs = keras.Input((4,)) outputs = CustomDense(10)(inputs) model = keras.Model(inputs, outputs) config = model.get_config() new_model = keras.Model.from_config( config, custom_objects={'CustomDense': CustomDense}) 

वैकल्पिक रूप से, आप from_config (cls, config) वर्ग विधि को भी लागू कर सकते हैं, जो कि इसके कॉन्फ़िगरेशन शब्दकोश को देखते हुए, लेयर इंस्टेंस को फिर से बनाने के लिए जिम्मेदार है। डिफ़ॉल्ट from_config इस तरह दिखता है:

 def from_config(cls, config): return cls(**config) 

फंक्शनल एपीआई का उपयोग कब करें

यह निर्धारित करने के लिए कि जब नए मॉडल बनाने के लिए कार्यात्मक एपीआई का उपयोग करना बेहतर होता है, या सीधे Model सीधे उपवर्ग का उपयोग करें?

सामान्य तौर पर, फंक्शनल एपीआई अधिक उच्च-स्तरीय और उपयोग में आसान होता है, इसमें कई फ़ंक्शन होते हैं जो उपवर्ग मॉडल द्वारा समर्थित नहीं होते हैं।

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

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

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

कार्यात्मक एपीआई छोटे कोड का उत्पादन करता है।

कोई super(MyClass, self).__init__(...) , नो def call(self, ...): आदि।

की तुलना करें:

 inputs = keras.Input(shape=(32,)) x = layers.Dense(64, activation='relu')(inputs) outputs = layers.Dense(10)(x) mlp = keras.Model(inputs, outputs) 

उपवर्गित संस्करण के साथ:

 class MLP(keras.Model): def __init__(self, **kwargs): super(MLP, self).__init__(**kwargs) self.dense_1 = layers.Dense(64, activation='relu') self.dense_2 = layers.Dense(10) def call(self, inputs): x = self.dense_1(inputs) return self.dense_2(x) #   . mlp = MLP() #    . #            . _ = mlp(tf.zeros((1, 32))) 

जैसा लिखा गया है वैसा ही आपका मॉडल मान्य है।

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

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

आपके कार्यात्मक मॉडल को ग्राफिक रूप से दर्शाया जा सकता है, और यह परीक्षण योग्य भी है।

आप एक ग्राफ के रूप में मॉडल को आकर्षित कर सकते हैं, और आप आसानी से ग्राफ के मध्यवर्ती नोड्स तक पहुंच सकते हैं, उदाहरण के लिए, मध्यवर्ती परतों के सक्रियण को निकालने और पुन: उपयोग करने के लिए, जैसा कि हमने पिछले उदाहरण में देखा था:

 features_list = [layer.output for layer in vgg19.layers] feat_extraction_model = keras.Model(inputs=vgg19.input, outputs=features_list) 

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

कार्यात्मक एपीआई कमजोरियों

यह गतिशील आर्किटेक्चर का समर्थन नहीं करता है।

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

कभी-कभी आपको केवल खरोंच से सब कुछ लिखने की आवश्यकता होती है।

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

विभिन्न एपीआई शैलियों का संयोजन और संयोजन

यह ध्यान रखना महत्वपूर्ण है कि कार्यात्मक एपीआई या मॉडल को उपवर्ग के बीच चुनना एक द्विआधारी समाधान नहीं है जो आपको मॉडल की एक श्रेणी तक सीमित करता है।Tf.keras API के सभी मॉडल एक-दूसरे के साथ बातचीत कर सकते हैं, यह अनुक्रमिक मॉडल, फ़ंक्शनल मॉडल या स्क्रैच से लिखे गए मॉडल / परतें हो सकते हैं।

आप हमेशा उपविभाजित मॉडल / परत के हिस्से के रूप में कार्यात्मक मॉडल या अनुक्रमिक मॉडल का उपयोग कर सकते हैं:

 units = 32 timesteps = 10 input_dim = 5 # Define a Functional model inputs = keras.Input((None, units)) x = layers.GlobalAveragePooling1D()(inputs) outputs = layers.Dense(1, activation='sigmoid')(x) model = keras.Model(inputs, outputs) class CustomRNN(layers.Layer): def __init__(self): super(CustomRNN, self).__init__() self.units = units self.projection_1 = layers.Dense(units=units, activation='tanh') self.projection_2 = layers.Dense(units=units, activation='tanh') # Our previously-defined Functional model self.classifier = model def call(self, inputs): outputs = [] state = tf.zeros(shape=(inputs.shape[0], self.units)) for t in range(inputs.shape[1]): x = inputs[:, t, :] h = self.projection_1(x) y = h + self.projection_2(state) state = y outputs.append(y) features = tf.stack(outputs, axis=1) print(features.shape) return self.classifier(features) rnn_model = CustomRNN() _ = rnn_model(tf.zeros((1, timesteps, input_dim))) 

इसके विपरीत, आप फंक्शनल एपीआई में किसी भी उपवर्गित परत या मॉडल का उपयोग कर सकते हैं यदि आप एक ऐसी विधि को लागू करते callहैं जो निम्नलिखित पैटर्न में से एक से मेल खाती है:

call(self, inputs, **kwargs)जहां inputsटेंसर या नेस्टेड टेंसर संरचना (जैसे टेंसरों की सूची) है, और जहां **kwargsगैर-टेनसर तर्क हैं (इनपुट नहीं) । बूलियन मान
call(self, inputs, training=None, **kwargs)कहाँ trainingइंगित करता है कि किस मोड में परत, सीखने या आउटपुट का व्यवहार करना चाहिए। बूलियन मास्क टेंसर (उदाहरण के लिए, RNN के लिए उपयोगी)
call(self, inputs, mask=None, **kwargs)कहाँ maskहै।
call(self, inputs, training=None, mask=None, **kwargs)- बेशक आपके पास एक ही समय में परत के व्यवहार को परिभाषित करने वाले दोनों पैरामीटर हो सकते हैं।

इसके अलावा, यदि आप अपने कस्टम लेयर या मॉडल पर `get_config` पद्धति को लागू करते हैं, तो आप इसके साथ जो कार्यात्मक मॉडल बनाते हैं, वह क्रमबद्ध और क्लोन किया जाएगा।

नीचे एक छोटा सा उदाहरण है जहां हम कस्टम आरएनएन का उपयोग करते हैं जो स्क्रैच कार्यात्मक मॉडल से लिखा गया है:

 units = 32 timesteps = 10 input_dim = 5 batch_size = 16 class CustomRNN(layers.Layer): def __init__(self): super(CustomRNN, self).__init__() self.units = units self.projection_1 = layers.Dense(units=units, activation='tanh') self.projection_2 = layers.Dense(units=units, activation='tanh') self.classifier = layers.Dense(1, activation='sigmoid') def call(self, inputs): outputs = [] state = tf.zeros(shape=(inputs.shape[0], self.units)) for t in range(inputs.shape[1]): x = inputs[:, t, :] h = self.projection_1(x) y = h + self.projection_2(state) state = y outputs.append(y) features = tf.stack(outputs, axis=1) return self.classifier(features) #           #  `batch_shape`,     `CustomRNN`  #    (     `state`). inputs = keras.Input(batch_shape=(batch_size, timesteps, input_dim)) x = layers.Conv1D(32, 3)(inputs) outputs = CustomRNN()(x) model = keras.Model(inputs, outputs) rnn_model = CustomRNN() _ = rnn_model(tf.zeros((1, 10, 5))) 

यह हमारी कार्यात्मक एपीआई गाइड का समापन करता है!

अब आपके पास गहन शिक्षण मॉडल बनाने के लिए उपकरणों का एक शक्तिशाली सेट है।

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