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

खास जानकारी

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

TensorFlow में RNN एपीआई के कई वैरिएंट उपलब्ध हैं. इसलिए, हमने दो तरीके अपनाए हैं:

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

Converter API

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

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

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

# 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 से LiteRT Colab में, LiteRT इंटरप्रेटर का इस्तेमाल करने का पूरा तरीका बताया गया है.

TensorFlow RNNs API के साथ काम करता है

Keras LSTM मॉडल को बदलना (सुझाया गया)

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

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

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

Keras LSTM के वैरिएंट

टाइम मेजर

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

BiDirectional LSTM

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

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

LiteRT, उपयोगकर्ता के तय किए गए एलएसटीएम को लागू करने के तरीके को बदलने का विकल्प भी देता है. यहां हम Lingvo के एलएसटीएम का इस्तेमाल करके, यह उदाहरण देते हैं कि इसे कैसे लागू किया जा सकता है. ज़्यादा जानकारी के लिए, कृपया lingvo.LSTMCellSimple इंटरफ़ेस और कन्वर्ज़न लॉजिक यहां देखें. हमने lingvo.LayerNormalizedLSTMCellSimple इंटरफ़ेस में, Lingvo की एक और एलएसटीएम परिभाषा का उदाहरण भी दिया है. साथ ही, इसके कन्वर्ज़न लॉजिक का उदाहरण यहां दिया गया है.

LiteRT में “Bring your own TensorFlow RNN” सुविधा

अगर किसी उपयोगकर्ता का आरएनएन इंटरफ़ेस, स्टैंडर्ड तौर पर काम करने वाले इंटरफ़ेस से अलग है, तो उसके पास ये विकल्प हैं:

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

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

इस तरह के कन्वर्ज़न फ़्लो का एक पूरा उदाहरण, Lingvo के LSTMCellSimple से LiteRT में कन्वर्ज़न है.

Lingvo में LSTMCellSimple को यहां तय किया गया है. इस एलएसटीएम सेल से ट्रेन किए गए मॉडल को LiteRT में इस तरह बदला जा सकता है:

1. LSTMCellSimple के सभी इस्तेमाल को tf.function में रैप करें.साथ ही, tf_implements एनोटेशन का इस्तेमाल करें. इसे इस तरह लेबल किया गया है (उदाहरण के लिए, lingvo.LSTMCellSimple यहां एनोटेशन का अच्छा नाम होगा). पक्का करें कि जनरेट किया गया tf.function, कन्वर्ज़न कोड में इस्तेमाल किए जाने वाले फ़ंक्शन के इंटरफ़ेस से मेल खाता हो. यह एनोटेशन जोड़ने वाले मॉडल के लेखक और कन्वर्ज़न कोड के बीच का कानूनी समझौता है.

2. कस्टम कंपोज़िट ऑप को LiteRT फ़्यूज़्ड एलएसटीएम ऑप में बदलने के लिए, prepare-composite-functions पास को बढ़ाएं. LSTMCellSimple का कन्वर्ज़न कोड देखें.

   कन्वर्ज़न अनुबंध:

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

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

5. {bias} तक के {bias} को, बायस टेंसर को स्लाइस करके निकाला जाता है.

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

7. इसी तरह का कन्वर्ज़न, LayerNormalizedLSTMCellSimple के लिए लिखा गया है.

8. लाइटआरटी कन्वर्ज़न इन्फ़्रास्ट्रक्चर के बाकी हिस्सों का फिर से इस्तेमाल किया जा सकता है. इनमें तय किए गए सभी MLIR पास और LiteRT फ़्लैटबफ़र में फ़ाइनल एक्सपोर्ट शामिल हैं.

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

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