TensorFlow RNN को TensorFlow Lite में बदलना

खास जानकारी

TensorFlow Lite, TensorFlow RNN मॉडल को TensorFlow Lite के जुड़े LSTM ऑपरेशन में बदलने की सुविधा देता है. कई तरह की कार्रवाइयों का इस्तेमाल, उनके मूल kernel लागू करने की परफ़ॉर्मेंस को बेहतर बनाने के लिए किया जाता है. साथ ही, क्वांटिज़ाटाइज़ेशन जैसे जटिल ट्रांसफ़ॉर्मेशन को परिभाषित करने के लिए उच्च लेवल का इंटरफ़ेस उपलब्ध कराया जाता है.

TensorFlow में RNN एपीआई के कई वैरिएंट हैं. इसलिए, इसमें दो तरह से काम किया गया है:

1. Keras LSTM जैसे स्टैंडर्ड TensorFlow RNN एपीआई के लिए स्थानीय सहायता दें. यह विकल्प सुझाया गया है.
2. उपयोगकर्ता के तय किए गए RNN फ़ंक्शन के लिए, कन्वर्ज़न इन्फ़्रास्ट्रक्चर में इंटरफ़ेस दें, ताकि प्लग इन किया जा सके और TensorFlow Lite में बदला जा सके. हम ऐसे कन्वर्ज़न के कुछ बेहतरीन उदाहरण देते हैं. इसके लिए, lingvo के LSTMCellSimple और LayerNormalizedLSTMCellSimple RNN इंटरफ़ेस का इस्तेमाल करते हैं.

कन्वर्टर एपीआई

यह सुविधा, TensorFlow 2.3 रिलीज़ का हिस्सा है. यह tf-nightly पीआईपी या हेड से भी उपलब्ध है.

सेव किए गए मॉडल या सीधे Keras मॉडल से, TensorFlow Lite में बदलने पर, कन्वर्ज़न की यह सुविधा उपलब्ध होती है. इस्तेमाल के उदाहरण देखें.

सेव किए गए मॉडल से

# build a saved model. Here concrete_function is the exported function
# corresponding to the TensorFlow model containing one or more
# Keras LSTM layers.
saved_model, saved_model_dir = build_saved_model_lstm(...)
saved_model.save(saved_model_dir, save_format="tf", signatures=concrete_func)

# Convert the model.
converter = TFLiteConverter.from_saved_model(saved_model_dir)
tflite_model = converter.convert()

Keras मॉडल से

# build a Keras model
keras_model = build_keras_lstm(...)

# Convert the model.
converter = TFLiteConverter.from_keras_model(keras_model)
tflite_model = converter.convert()

उदाहरण

Keras LSTM और TensorFlow Lite Colab में, TensorFlow Lite अनुवादक की मदद से, इस्तेमाल को खत्म करने की जानकारी दिखाई गई है.

TensorFlow RNNs एपीआई काम करता है

Keras LSTM कन्वर्ज़न (सुझाया गया)

हम Keras LSTM को TensorFlow Lite में बदलने की सुविधा देते हैं. इसके काम करने का तरीका जानने के लिए, कृपया Keras LSTM इंटरफ़ेस और कन्वर्ज़न लॉजिक यहां देखें.

यह भी ज़रूरी है कि TensorFlow Lite के एलएसटीएम कॉन्ट्रैक्ट को, Keras ऑपरेशन की परिभाषा के हिसाब से हाइलाइट किया जाए:

1. इनपुट टेंसर का डाइमेंशन 0, बैच साइज़ होता है.
2. recurrent_weight टेंसर का डाइमेंशन 0, आउटपुट की संख्या है.
3. वज़न और recurrent_kernel टेंसर को ट्रांसपोज़ किया जाता है.
4. ट्रांसपोज़ किया गया वज़न, ट्रांसपोज़ किया गया बार-बार होने वाला कर्नेल और बायस टेंसर, डाइमेंशन 0 पर चार बराबर साइज़ के टेंसर में बंट जाता है. ये इनपुट गेट, फ़ाॅरगेट गेट, सेल, और आउटपुट गेट से संबंधित हैं.

Keras LSTM वैरिएंट

टाइम मेजर

उपयोगकर्ता टाइम-मेजर या कोई टाइम-मेजर नहीं चुन सकते हैं. Keras LSTM फ़ंक्शन def एट्रिब्यूट में टाइम-मेजर एट्रिब्यूट जोड़ता है. यूनिडायरेक्शनल सीक्वेंस एलएसटीएम के लिए, हम आसानी से uniderecional_second_lstm के टाइम मेजर एट्रिब्यूट को मैप कर सकते हैं.

दो-तरफ़ा एलएसटीएम

दो-तरफ़ा LSTM को दो Keras LSTM लेयर के साथ लागू किया जा सकता है, एक लेयर फ़ॉरवर्ड और बैकवर्ड के लिए. उदाहरण के लिए यहां देखें. जब हमें go_backward एट्रिब्यूट दिखता है, तो हम इसे बैकवर्ड एलएसटीएम (एलएसटीएम) के तौर पर पहचान लेते हैं. इसके बाद, हम फ़ॉरवर्ड और बैकवर्ड एलएसटीएम को एक साथ ग्रुप कर देते हैं. यह आने वाला काम है. फ़िलहाल, यह TensorFlow Lite मॉडल में दो UnidirectionalSequenceLSTM ऑपरेशन बनाता है.

उपयोगकर्ता के तय किए गए एलएसटीएम कन्वर्ज़न के उदाहरण

TensorFlow Lite, उपयोगकर्ता की ओर से तय किए गए एलएसटीएम लागू करने के तरीके को भी कन्वर्ट कर सकता है. यहां Lingvo के LSTM का इस्तेमाल करके बताया गया है कि इस सुविधा को कैसे लागू किया जा सकता है. ज़्यादा जानकारी के लिए, कृपया lingvo.LSTMCellSimple इंटरफ़ेस और कन्वर्ज़न लॉजिक यहां देखें. lingvo.layernormalizedLSTMCellSimple इंटरफ़ेस में, हमने Lingvo की एलएसटीएम डेफ़िनिशन का एक और उदाहरण भी दिया है और उसके कन्वर्ज़न लॉजिक का भी उदाहरण यहां दिया गया है.

TensorFlow Lite पर “अपना TensorFlow RNN” लाएं

अगर किसी उपयोगकर्ता का RNN इंटरफ़ेस, स्टैंडर्ड सपोर्टेड इंटरफ़ेस से अलग है, तो इसके लिए कुछ विकल्प मौजूद हैं:

पहला विकल्प: RNN इंटरफ़ेस को Keras RNN इंटरफ़ेस के मुताबिक बनाने के लिए, TensorFlow Python में अडैप्टर कोड लिखें. इसका मतलब है कि जनरेट किए गए आरएनएन इंटरफ़ेस के फ़ंक्शन पर tf_effectives एनोटेशन वाला tf.फ़ंक्शन, जो कि Keras LSTM लेयर से जनरेट किए गए फ़ंक्शन से मिलता-जुलता है. इसके बाद, Keras LSTM के लिए इस्तेमाल किया गया कन्वर्ज़न एपीआई काम करेगा.

दूसरा विकल्प: अगर ऊपर बताए गए तरीके से काम नहीं किया जा सकता (उदाहरण के लिए, Keras LSTM में कुछ फ़ंक्शन मौजूद नहीं हैं जो TensorFlow Lite के फ़्यूज़ किए गए LSTM ऑप की मदद से दिख रहे हैं, जैसे कि लेयर नॉर्मलाइज़ेशन), तो TensorFlow Lite कन्वर्टर को बढ़ाने के लिए कस्टम कन्वर्ज़न कोड लिखें और एमएलआईआर पास को प्लग-इन करने के लिए यहां क्लिक करें. फ़ंक्शन के इंटरफ़ेस को एपीआई कॉन्ट्रैक्ट की तरह माना जाना चाहिए. साथ ही, इसमें जोड़े गए TensorFlow Lite LSTM ऑपरेशन - इनपुट, बायस, वेट, प्रोजेक्शन, लेयर नॉर्मलाइज़ेशन वगैरह में बदलने के लिए ज़रूरी तर्क शामिल होने चाहिए. इस फ़ंक्शन में आर्ग्युमेंट के तौर पर पास किए गए टेंसर के लिए, इसे प्राथमिकता दी जानी चाहिए, ताकि रैंक (जैसे RankedTensorType) में हो. इससे कन्वर्ज़न कोड लिखना आसान हो जाता है, जो इन टेन्सर को RankedTensorType के रूप में मान सकता है और उन्हें जोड़े गए TensorFlow Lite ऑपरेटर के ऑपरेटर के अनुरूप रैंक किए गए टेन्सर में बदलने में मदद करता है.

ऐसे कन्वर्ज़न फ़्लो का एक अच्छा उदाहरण Lingvo का LSTMCellSimple से TensorFlow Lite कन्वर्ज़न, है.

Lingvo में LSTMCellSimple के बारे में यहां बताया गया है. इस LSTM सेल से ट्रेनिंग वाले मॉडल को TensorFlow Lite में बदला जा सकता है. ऐसा करने के लिए यह तरीका अपनाएं:

1. LSTMCellSimple के सभी इस्तेमाल को tf.Function में रैप करें.इसके लिए, tf_ Implements ऐनोटेशन का इस्तेमाल करें, जिसे इस तरह लेबल किया गया हो. जैसे, यहां lingvo.LSTMCellSimple के तौर पर एक अच्छा एनोटेशन नाम दिया जा सकता है. पक्का करें कि जनरेट किया गया tf.फ़ंक्शन, कन्वर्ज़न कोड में मौजूद फ़ंक्शन के इंटरफ़ेस से मेल खाता हो. यह एनोटेशन और कन्वर्ज़न कोड जोड़ने वाले मॉडल लेखक के बीच का कॉन्ट्रैक्ट है.

2. TensorFlow Lite के फ़्यूज़ किए गए LSTM ऑप कन्वर्ज़न में, कस्टम कंपोज़िट विकल्प को कनेक्ट करने के लिए, तैयार-कंपोज़िट-फ़ंक्शन पास को बढ़ाएं. LSTMCellSimple कन्वर्ज़न कोड देखें.

   कन्वर्ज़न कॉन्ट्रैक्ट:

3. वज़न और प्रक्षेपण तनों को ट्रांसपोज़ किया गया है.

4. ट्रांसपोज़ किए गए वेट टेंसर को काटने से, {input,recurrent} से {cell,input gate, remove gate, display gate} निकाले जाते हैं.

5. बायस टेंसर को काटने से, {bis} से {cell,input gate, remove gate, out gate} हटाए जाते हैं.

6. ट्रांसपोज़ किए गए प्रोजेक्शन टेंसर को काटकर, प्रोजेक्शन निकाला जाता है.

7. इसी तरह का बदलाव LayerNormalizedLSTMCellSimple के लिए लिखा गया है.

8. TensorFlow Lite के फ़्लैटबफ़र में एक्सपोर्ट किए गए बाकी इंफ़्रास्ट्रक्चर MLIR पास और TensorFlow Lite फ़्लैटबफ़र में एक्सपोर्ट के साथ-साथ फिर से इस्तेमाल किए जा सकते हैं.

पहले से मालूम समस्याएं/सीमाएं

1. फ़िलहाल, सिर्फ़ बिना स्टेटस वाले Keras LSTM (Keras में डिफ़ॉल्ट तरीका) को बदलने की सुविधा उपलब्ध है. स्टेटफ़ुल Keras LSTM कन्वर्ज़न, आने वाले समय में किया जाने वाला काम है.
2. अब भी, स्टेटलेस Keras LSTM लेयर का मॉडल बनाया जा सकता है. ऐसा करने के लिए, इसमें मौजूद स्टेटलेस Keras LSTM लेयर का इस्तेमाल किया जा सकता है. साथ ही, उपयोगकर्ता प्रोग्राम में, स्टेटस को साफ़ तौर पर मैनेज किया जा सकता है. ऐसे TensorFlow प्रोग्राम को अब भी यहां बताई गई सुविधा का इस्तेमाल करके TensorFlow Lite में बदला जा सकता है.
3. फ़िलहाल, TensorFlow Lite में दो UnidirectionalSequenceLSTM ऑपरेशन के तौर पर दो-तरफ़ा LSTM को मॉडल किया गया है. इसे एक BidirectionalSequenceLSTM ऑप से बदल दिया जाएगा.