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

खास जानकारी

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

TensorFlow में RNN एपीआई के कई वैरिएंट मौजूद हैं. इसलिए, हमारा तरीका दो फ़ोल्ड वाला:

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

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

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

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 एपीआई इस्तेमाल किए जा सकते हैं

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

हम Keras LSTM के आउट-ऑफ़-द-बॉक्स रूपांतरण को LiteRT में बदलने का समर्थन करते हैं. इसके लिए यह कैसे काम करता है, इसके बारे में जानने के लिए, कृपया Keras LSTM इंटरफ़ेस और कन्वर्ज़न लॉजिक यहां देखें.

इसके अलावा, LiteRT के एलएसटीएम समझौते को हाइलाइट करना भी ज़रूरी है Keras ऑपरेशन की परिभाषा में:

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

Keras LSTM के वैरिएंट

टाइम मेजर

उपयोगकर्ता यह चुन सकते हैं कि 'समय-मुख्य' या 'कोई समय-पूर्व नहीं' विकल्प चुना जा सकता है. Keras LSTM ने समय का एकदम सही पैमाना जोड़ा एट्रिब्यूट का इस्तेमाल करें. यूनिडायरेक्शनल सीक्वेंस एलएसटीएम के लिए, हम को आसानी से unidiecional_Sequence_lstm's पर मैप कर सकता है time मेजर एट्रिब्यूट के तौर पर इस्तेमाल करें.

द्विदिशात्मक एलएसटीएम

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

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

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

LiteRT पर “TensorFlow का आरएनएन बनाएं”

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

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

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

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

Lingvo में LSTMCellSample को परिभाषित किया गया है यहां पढ़ें. इस LSTM सेल की मदद से ट्रेन किए गए मॉडल को LiteRT में इस तरह बदला जा सकता है: अनुसरण करता है:

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

2. कस्टम कंपोज़िट सेशन में प्लग इन करने के लिए, रेडी-कंपोज़िट-फ़ंक्शन पास को बढ़ाना से लेकर, LiteRT फ़्यूज़्ड LSTM op कन्वर्ज़न में बदल गया. यहां जाएं: LSTMCellSimple कन्वर्ज़न कोड.

   कन्वर्ज़न का समझौता:

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

4. {input, recurrent} को {cell, Input gate, भिन्न गेट, आउटपुट गेट} को निकालने के लिए, ट्रांसपोज़ किए गए वेट टेंसर को स्लाइस करके निकाला जाता है.

5. {bias} से {bias} के बीच बायस टेंसर को स्लाइस करके निकाला गया.

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

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

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

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

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