टेक्स्ट की कैटगरी तय करने के लिए, Fluter ऐप्लिकेशन बनाएं

1. शुरू करने से पहले

इस कोडलैब में, आप REST और gRPC की मदद से TensorFlow सर्विंग के साथ Fluter ऐप्लिकेशन से टेक्स्ट क्लासिफ़िकेशन का अनुमान चलाने का तरीका जानेंगे.

ज़रूरी बातें

• डार्ट के साथ फ़्लटर डेवलपमेंट की बुनियादी जानकारी
• TensorFlow का इस्तेमाल करके, मशीन लर्निंग की बुनियादी जानकारी. जैसे, ट्रेनिंग और डिप्लॉयमेंट
• टर्मिनल और डॉकर की बुनियादी जानकारी
• TenorFlow Lite मॉडल मेकर कोडलैब की मदद से, स्पैम टिप्पणी की पहचान करने वाले मॉडल को ट्रेनिंग देना

आप इन चीज़ों के बारे में जानेंगे

• आसान फ़्लूटर ऐप्लिकेशन कैसे बनाएं और TensorFlow सर्विंग (REST और gRPC) की मदद से टेक्स्ट की कैटगरी तय करें.
• यूज़र इंटरफ़ेस (यूआई) में नतीजे दिखाने का तरीका.

आपको इनकी ज़रूरत होगी

• बहुत ज़रूरी SDK टूल
• Fluter के लिए Android या iOS सेटअप
• फ़्लटर और डार्ट के लिए विज़ुअल स्टूडियो कोड (वीएस कोड)
• डॉकर
• बैश
• प्रोटोकॉल कंपाइलर के लिए प्रोटोकॉल बफ़र कंपाइलर और gRPC डार्ट प्लग इन (सिर्फ़ तब ज़रूरी है, जब आप खुद gRPC स्टब को फिर से जनरेट करना चाहते हों)

2. अपने पत्तों के विकास का माहौल सेट अप करें

फ़्लूटर डेवलपमेंट के लिए, आपको इस लैब को पूरा करने के लिए सॉफ़्टवेयर के दो हिस्सों की ज़रूरत होगी—Fltur SDK टूल और एक एडिटर.

आप इनमें से किसी भी डिवाइस का इस्तेमाल करके कोडलैब (कोड बनाना सीखना) चला सकते हैं:

• iOS सिम्युलेटर (इसके लिए Xcode टूल इंस्टॉल करना ज़रूरी है).
• Android एम्युलेटर (Android Studio में सेट अप करना ज़रूरी है).
• ब्राउज़र (Chrome पर डीबग करना ज़रूरी है).
• Windows, Linux या macOS डेस्कटॉप ऐप्लिकेशन के रूप में. आपको उस प्लैटफ़ॉर्म पर काम करना होगा जहां आप डिप्लॉय करना चाहते हैं. इसलिए, अगर आपको Windows डेस्कटॉप ऐप्लिकेशन डेवलप करना है, तो आपको सही बिल्ड चेन ऐक्सेस करने के लिए Windows पर डेवलप करना होगा. ऑपरेटिंग सिस्टम के लिए, कुछ खास ज़रूरी शर्तें पूरी की गई हैं. इन शर्तों के बारे में docs.fltur.dev/desktop पर जानकारी दी गई है.

3. सेट अप करें

इस कोडलैब के लिए कोड डाउनलोड करने के लिए:

1. इस कोडलैब के लिए, GitHub की रिपॉज़िटरी पर जाएं.
2. इस कोडलैब के सभी कोड डाउनलोड करने के लिए, कोड > ज़िप डाउनलोड करें पर क्लिक करें.

3. codelabs-main रूट फ़ोल्डर को अनपैक करने के लिए डाउनलोड किए गए ZIP फ़ाइल को खोलें. इसमें आपको सभी ज़रूरी संसाधन मिलेंगे.

इस कोडलैब के लिए, आपको रिपॉज़िटरी में सिर्फ़ tfserving-flutter/codelab2 सबडायरेक्ट्री की फ़ाइलों की ज़रूरत होती है, जिसमें दो फ़ोल्डर होते हैं:

• starter फ़ोल्डर में वह स्टार्टर कोड शामिल है जिसे आपने इस कोडलैब के लिए बनाया है.
• finished फ़ोल्डर में, तैयार हो चुके सैंपल ऐप्लिकेशन का पूरा कोड है.

4. प्रोजेक्ट के लिए डिपेंडेंसी डाउनलोड करना

1. वीएस कोड में, फ़ाइल > फ़ोल्डर खोलें पर क्लिक करें. इसके बाद, पहले डाउनलोड किए गए सोर्स कोड से starter फ़ोल्डर चुनें.
2. अगर आपको एक डायलॉग दिखता है, जिसमें आपको स्टार्टर ऐप्लिकेशन के लिए ज़रूरी पैकेज डाउनलोड करने के लिए कहा जाता है, तो पैकेज पाएं पर क्लिक करें.
3. अगर आपको यह डायलॉग नहीं दिखता, तो अपना टर्मिनल खोलें और starter फ़ोल्डर में flutter pub get निर्देश चलाएं.

5. स्टार्टर ऐप्लिकेशन चलाएं

1. वीएस कोड में यह पक्का करें कि Android Emulator या iOS सिम्युलेटर ठीक से सेट अप किया गया हो और स्टेटस बार में दिखता हो.

उदाहरण के लिए, Android Emulator के साथ Pixel 5 का इस्तेमाल करने पर, आपको यह जानकारी दिखती है:

जब आप iOS सिम्युलेटर के साथ iPhone 13 का इस्तेमाल करते हैं, तो आपको ये चीज़ें दिखाई देती हैं:

2. डीबग करना शुरू करें पर क्लिक करें.

ध्यान दें: यह कोडलैब यह मानता है कि आप Android एम्युलेटर या iOS सिम्युलेटर का इस्तेमाल करते हैं. अगर आप किसी फ़िज़िकल फ़ोन का उपयोग करते हैं, तो कोड में मौजूद अपने 10.0.2.2 या localhost आईपी पते को अपने सर्वर के पते में बदलें, जो TensorFlow सर्विंग की सुविधा देता है.

ऐप्लिकेशन चलाएं और उसके बारे में ज़्यादा जानें

ऐप्लिकेशन को आपके Android Emulator या iOS सिम्युलेटर पर लॉन्च होना चाहिए. यूज़र इंटरफ़ेस (यूआई) बहुत आसान है. एक टेक्स्ट फ़ील्ड है, जिसकी मदद से उपयोगकर्ता टेक्स्ट टाइप कर सकता है. उपयोगकर्ता यह चुन सकता है कि डेटा को बैकएंड में REST या gRPC के साथ भेजना है या नहीं. पहले से प्रोसेस किए गए इनपुट पर, टेक्स्ट की कैटगरी तय करने के लिए बैकएंड, TensorFlow मॉडल का इस्तेमाल करता है. साथ ही, यह क्लाइंट ऐप्लिकेशन को क्लासिफ़िकेशन नतीजे दिखाता है, जिससे यूज़र इंटरफ़ेस (यूआई) अपडेट हो जाता है.

श्रेणी तय करें पर क्लिक करने से कुछ नहीं होता, क्योंकि यह अभी बैकएंड के साथ बातचीत नहीं कर सकता.

6. TensorFlow सर्विंग के साथ टेक्स्ट क्लासिफ़िकेशन मॉडल को डिप्लॉय करना

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

टेक्स्ट की कैटगरी तय करना एक सामान्य मशीन लर्निंग टास्क है. यह टेक्स्ट को पहले से तय कैटगरी में बांटता है. इस कोडलैब में, आप TensorFlow Lite मॉडल के साथ, टिप्पणी की स्पैम का पता लगाने वाले मॉडल को ट्रेनिंग देते हैं. इसके लिए, TensorFlow सर्विंग के लिए फ़्रेमवर्क का इस्तेमाल किया जाता है. साथ ही, इनपुट टेक्स्ट को स्पैम या स्पैम की कैटगरी में रखने के लिए, अपने फ़्लटर फ़्रंटएंड से बैकएंड को कॉल करें.

ध्यान दें: शब्दावली और लेबल फ़ाइलों के साथ, सेव किया गया एक अनुमानित मॉडल tfserving-flutter/codelab1/mm_spam_savedmodel फ़ोल्डर में दिया जाता है.

TensorFlow सर्विंग शुरू करें

• अपने टर्मिनल में, TensorFlow सेवा को डॉक करने वाले टूल से शुरू करें. हालांकि, अपने कंप्यूटर पर PATH/TO/SAVEDMODEL प्लेसहोल्डर की जगह mm_spam_savedmodel फ़ोल्डर का इस्तेमाल करें.

docker pull tensorflow/serving

docker run -it --rm -p 8500:8500 -p 8501:8501 -v "PATH/TO/SAVEDMODEL:/models/spam-detection" -e MODEL_NAME=spam-detection tensorflow/serving

डॉकर सबसे पहले TensorFlow सर्विंग इमेज को अपने-आप डाउनलोड कर लेता है. इसमें एक मिनट लगता है. इसके बाद, TensorFlow सर्विंग शुरू हो जानी चाहिए. लॉग इस कोड स्निपेट जैसा दिखना चाहिए:

2022-02-25 06:01:12.513231: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-02-25 06:01:12.585012: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 3000000000 Hz
2022-02-25 06:01:13.395083: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/ssd_mobilenet_v2_2/123
2022-02-25 06:01:13.837562: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 1928700 microseconds.
2022-02-25 06:01:13.877848: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/ssd_mobilenet_v2_2/123/assets.extra/tf_serving_warmup_requests
2022-02-25 06:01:13.929844: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: spam-detection version: 123}
2022-02-25 06:01:13.985848: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-02-25 06:01:13.985987: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-02-25 06:01:13.988994: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-02-25 06:01:14.033872: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

ध्यान दें: TensorFlow दिखाने वाले डॉकर इमेज को शुरू करने के बाद, इनपुट और आउटपुट टेंसर की जानकारी देखने के लिए, http://localhost:8501/v1/models/<MODEL_NAME>/metadata पर जाएं. इस कोडलैब में, <MODEL_NAME> को spam-detection से बदलें.

7. इनपुट वाक्य को टोकनाइज़ करें

अब आपका बैकएंड तैयार है, इसलिए आप ##39; TensorFlow सर्विंग के लिए क्लाइंट अनुरोध भेजने के लिए करीब-करीब तैयार हैं, लेकिन पहले आपको इनपुट वाक्य के टोकन को टोकन के तौर पर भेजना होगा. अगर आप मॉडल के इनपुट टेंसर की जांच करते हैं, तो आप देख सकते हैं कि उसमें रॉ स्ट्रिंग के बजाय 20 इंटिजर संख्याएं हैं. टोकनाइज़ेशन तब होता है, जब आप ऐप्लिकेशन में टाइप किए गए अलग-अलग शब्दों को किसी शब्दावली शब्दकोश के आधार पर पूर्णांकों की सूची में मैप करते हैं. इसके बाद, आप उन्हें कैटगरी तय करने के लिए बैकएंड में भेजते हैं. उदाहरण के लिए, अगर आप buy book online to learn more टाइप करते हैं, तो टोकन बनाने की प्रोसेस उसे [32, 79, 183, 10, 224, 631, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] के साथ मैप कर देती है. शब्दकोश के शब्द के हिसाब से खास संख्याएं अलग-अलग हो सकती हैं.

1. lib/main.dart शब्दावली में, _vocabMap शब्दावली का डिक्शनरी बनाने के लिए, इस कोड को predict() में जोड़ें.

// Build _vocabMap if empty.
if (_vocabMap.isEmpty) {
  final vocabFileString = await rootBundle.loadString(vocabFile);
  final lines = vocabFileString.split('\n');
  for (final l in lines) {
    if (l != "") {
      var wordAndIndex = l.split(' ');
      (_vocabMap)[wordAndIndex[0]] = int.parse(wordAndIndex[1]);
    }
  }
} 

2. पिछले कोड स्निपेट के तुरंत बाद, टोकन लागू करने के लिए इस कोड को जोड़ें:

// Tokenize the input sentence.
final inputWords = _inputSentenceController.text
    .toLowerCase()
    .replaceAll(RegExp('[^a-z ]'), '')
    .split(' ');
// Initialize with padding token.
_tokenIndices = List.filled(maxSentenceLength, 0);
var i = 0;
for (final w in inputWords) {
  if ((_vocabMap).containsKey(w)) {
    _tokenIndices[i] = (_vocabMap)[w]!;
    i++;
  }

  // Truncate the string if longer than maxSentenceLength.
  if (i >= maxSentenceLength - 1) {
    break;
  }
}

इस कोड में, वाक्य की स्ट्रिंग को अंग्रेज़ी के छोटे अक्षरों में बदला जाता है. साथ ही, इसमें ऐसे वर्ण हटा दिए जाते हैं जो अक्षर नहीं हैं. साथ ही, यह शब्दावली टेबल के हिसाब से शब्दों को 20 अंकों के इंडेक्स में मैप करता है.

8. Flurt ऐप्लिकेशन को REST के ज़रिए TensorFlow सर्विंग से कनेक्ट करें

TensorFlow सर्विंग को दो तरीकों से अनुरोध भेजे जा सकते हैं:

• आरएसटी
• gRPC

REST के ज़रिए अनुरोध भेजना और जवाब पाना

REST के ज़रिए अनुरोध भेजने और जवाब पाने के तीन आसान चरण हैं:

1. REST अनुरोध बनाएं.
2. TensorFlow सर्विंग को REST का अनुरोध भेजें.
3. REST के जवाब से अनुमानित नतीजे निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.

आप main.dart फ़ाइल में, इन चरणों को पूरा करते हैं.

TensorFlow सर्विंग के लिए REST अनुरोध बनाएं और भेजें

1. फ़िलहाल, predict() फ़ंक्शन'TenorFlow से सर्व करने के लिए REST अनुरोध नहीं भेजता. REST अनुरोध बनाने के लिए आपको REST ब्रांच को लागू करना होगा:

if (_connectionMode == ConnectionModeType.rest) {
  // TODO: Create and send the REST request.

}

2. इस कोड को REST शाखा में जोड़ें:

//Create the REST request.
final response = await http.post(
  Uri.parse('http://' +
      _server +
      ':' +
      restPort.toString() +
      '/v1/models/' +
      modelName +
      ':predict'),
  body: jsonEncode(<String, List<List<int>>>{
    'instances': [_tokenIndices],
  }),
);

TensorFlow सर्विंग से मिलने वाले REST के जवाब को प्रोसेस करें

• REST के जवाब को हैंडल करने के लिए, पिछले कोड स्निपेट के ठीक बाद इस कोड को जोड़ें:

// Process the REST response.
if (response.statusCode == 200) {
  Map<String, dynamic> result = jsonDecode(response.body);
  if (result['predictions']![0][1] >= classificationThreshold) {
    return 'This sentence is spam. Spam score is ' +
        result['predictions']![0][1].toString();
  }
  return 'This sentence is not spam. Spam score is ' +
      result['predictions']![0][1].toString();
} else {
  throw Exception('Error response');
}

पोस्टप्रोसेसिंग कोड इस बात की संभावना निकालता है कि इनपुट वाक्य, जवाब से मिला एक स्पैम मैसेज है और यह यूज़र इंटरफ़ेस (यूआई) में क्लासिफ़िकेशन नतीजे दिखाता है.

इसे चलाएं

1. डीबग करना शुरू करें पर क्लिक करें और फिर ऐप्लिकेशन के लोड होने का इंतज़ार करें.
2. कुछ टेक्स्ट डालें, फिर REST > क्लासिफ़िकेशन चुनें.

9. Fluter ऐप्लिकेशन को gRPC की मदद से TensorFlow सर्विंग से कनेक्ट करें

REST के अलावा, TensorFlow सर्व करने की सुविधा gRPC पर भी काम करती है.

gRPC एक आधुनिक, ओपन सोर्स, हाई-परफ़ॉर्मेंस रिमोट प्रोसेस कॉल (आरपीसी) फ़्रेमवर्क है, जो किसी भी एनवायरमेंट में चल सकता है. यह डेटा केंद्रों में, लोड बैलेंसिंग, ट्रेसिंग, स्वास्थ्य जांच, और पुष्टि करने की सुविधा के साथ बेहतर तरीके से सेवाओं को कनेक्ट कर सकती है. यह देखा गया है कि REST की तुलना में gRPC, बेहतर परफ़ॉर्म करता है.

gRPC से अनुरोध भेजें और जवाब पाएं

जीआरपीसी के साथ अनुरोध भेजने और जवाब पाने के चार आसान चरण हैं:

1. ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करें.
2. जीआरपीसी अनुरोध बनाएं.
3. TensorFlow सर्विंग के लिए जीआरपीसी अनुरोध भेजें.
4. gRPC रिस्पॉन्स से अनुमानित नतीजा निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.

आप main.dart फ़ाइल में, इन चरणों को पूरा करते हैं.

ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करें

ध्यान दें: यह चरण ज़रूरी नहीं है, क्योंकि स्टार्टर कोड में पहले से ही gRPC क्लाइंट स्टब कोड शामिल होता है. हालांकि, अगर आप क्लाइंट स्टब खुद जनरेट करना चाहते हैं, तो इसकी प्रोसेस को समझने के लिए इसे पढ़ने से फ़ायदा होगा. अगर आप इसे खुद आज़माते हैं, तो पक्का करें कि आपने प्रोटोकॉल बफ़र कंपाइलर और gRPC डार्ट कोड जनरेटर प्लग इन सही तरीके से सेट अप किया है.

TensorFlow सर्विंग के साथ जीआरपीसी का इस्तेमाल करने के लिए, आपको जीआरपीसी वर्कफ़्लो को फ़ॉलो करना होगा. ज़्यादा जानकारी के लिए, gRPC दस्तावेज़ देखें.

TensorFlow सर्विंग और TensorFlow आपके लिए .proto फ़ाइलें तय करते हैं. TensorFlow और TensorFlow 2.8 वर्शन के लिए, ये .proto फ़ाइलें ज़रूरी हैं:

tensorflow/core/example/example.proto
tensorflow/core/example/feature.proto
tensorflow/core/protobuf/struct.proto
tensorflow/core/protobuf/saved_object_graph.proto
tensorflow/core/protobuf/saver.proto
tensorflow/core/protobuf/trackable_object_graph.proto
tensorflow/core/protobuf/meta_graph.proto
tensorflow/core/framework/node_def.proto
tensorflow/core/framework/attr_value.proto
tensorflow/core/framework/function.proto
tensorflow/core/framework/types.proto
tensorflow/core/framework/tensor_shape.proto
tensorflow/core/framework/full_type.proto
tensorflow/core/framework/versions.proto
tensorflow/core/framework/op_def.proto
tensorflow/core/framework/graph.proto
tensorflow/core/framework/tensor.proto
tensorflow/core/framework/resource_handle.proto
tensorflow/core/framework/variable.proto

tensorflow_serving/apis/inference.proto
tensorflow_serving/apis/classification.proto
tensorflow_serving/apis/predict.proto
tensorflow_serving/apis/regression.proto
tensorflow_serving/apis/get_model_metadata.proto
tensorflow_serving/apis/input.proto
tensorflow_serving/apis/prediction_service.proto
tensorflow_serving/apis/model.proto

google/protobuf/any.proto
google/protobuf/wrappers.proto

ध्यान दें: any.proto और wrappers.proto फ़ाइलें, Google प्रोटोकॉल बफ़र डेटा स्टोर करने की जगह में दी गई हैं.

• अपने टर्मिनल में, starter/lib/proto/ फ़ोल्डर पर जाएं और स्टब जनरेट करें:

bash generate_grpc_stub_dart.sh

जीआरपीसी अनुरोध बनाएं

REST अनुरोध की तरह ही, gRPC ब्रांच में gRPC अनुरोध बनाया जाता है.

if (_connectionMode == ConnectionModeType.rest) {

} else {
  // TODO: Create and send the gRPC request.

}

• जीआरपीसी अनुरोध बनाने के लिए, यह कोड जोड़ें:

//Create the gRPC request.
final channel = ClientChannel(_server,
    port: grpcPort,
    options:
        const ChannelOptions(credentials: ChannelCredentials.insecure()));
_stub = PredictionServiceClient(channel,
    options: CallOptions(timeout: const Duration(seconds: 10)));

ModelSpec modelSpec = ModelSpec(
  name: 'spam-detection',
  signatureName: 'serving_default',
);

TensorShapeProto_Dim batchDim = TensorShapeProto_Dim(size: Int64(1));
TensorShapeProto_Dim inputDim =
    TensorShapeProto_Dim(size: Int64(maxSentenceLength));
TensorShapeProto inputTensorShape =
    TensorShapeProto(dim: [batchDim, inputDim]);
TensorProto inputTensor = TensorProto(
    dtype: DataType.DT_INT32,
    tensorShape: inputTensorShape,
    intVal: _tokenIndices);

// If you train your own model, update the input and output tensor names.
const inputTensorName = 'input_3';
const outputTensorName = 'dense_5';
PredictRequest request = PredictRequest(
    modelSpec: modelSpec, inputs: {inputTensorName: inputTensor});

ध्यान दें: इनपुट और आउटपुट टेंसर के नाम, मॉडल के आधार पर अलग-अलग हो सकते हैं, भले ही मॉडल आर्किटेक्चर एक जैसे हों. अगर आप अपने मॉडल को ट्रेनिंग देते हैं, तो इन्हें अपडेट करना न भूलें.

TensorFlow सर्व करने के लिए, जीआरपीसी का अनुरोध भेजें

• पिछले कोड स्निपेट के बाद, इस कोड को जोड़ें. इससे, TensorFlow सर्विंग को जीआरपीसी अनुरोध भेजा जाएगा:

// Send the gRPC request.
PredictResponse response = await _stub.predict(request);

TensorFlow सर्विंग से जीआरपीसी जवाब को प्रोसेस करें

• रिस्पॉन्स को मैनेज करने के लिए, कॉलबैक फ़ंक्शन लागू करने के लिए पिछले कोड स्निपेट के बाद यह कोड जोड़ें:

// Process the response.
if (response.outputs.containsKey(outputTensorName)) {
  if (response.outputs[outputTensorName]!.floatVal[1] >
      classificationThreshold) {
    return 'This sentence is spam. Spam score is ' +
        response.outputs[outputTensorName]!.floatVal[1].toString();
  } else {
    return 'This sentence is not spam. Spam score is ' +
        response.outputs[outputTensorName]!.floatVal[1].toString();
  }
} else {
  throw Exception('Error response');
}

अब पोस्टप्रोसेसिंग कोड, रिस्पॉन्स से क्लासिफ़िकेशन नतीजे को निकालता है और उसे यूज़र इंटरफ़ेस (यूआई) में दिखाता है.

इसे चलाएं

1. डीबग करना शुरू करें पर क्लिक करें और फिर ऐप्लिकेशन के लोड होने का इंतज़ार करें.
2. कुछ टेक्स्ट डालें और फिर gRPC > क्लासिफ़िकेशन चुनें.

ध्यान दें: इस कोडलैब में, आप सिर्फ़ Android या iOS प्लैटफ़ॉर्म पर ऐप्लिकेशन को चलाते हैं. हालांकि, Flutter, कई प्लैटफ़ॉर्म का फ़्रंटएंड फ़्रेमवर्क है, इसलिए आप डेस्कटॉप प्लैटफ़ॉर्म पर भी ऐप्लिकेशन चला सकते हैं. ज़्यादा जानकारी के लिए, फ़्लटर के लिए डेस्कटॉप सहायता और फ़्लटर डेस्कटॉप ऐप्लिकेशन कोडलैब (कोड बनाना सीखना) देखें.

वेब प्लैटफ़ॉर्म के लिए, अनुरोध को TensorFlow सर्विंग के लिए रूट करने के लिए, आपको Envoy या NGINX जैसे प्रॉक्सी को सेट अप करना होगा, क्योंकि TensorFlow सर्विंग Access-Control-Allow-Origin# हेडर को सेट नहीं करती है. ज़्यादा जानकारी के लिए, Evoy प्रॉक्सी सेट अप करें देखें.

10. बधाई हो

आपने अपने ऐप्लिकेशन में टेक्स्ट की कैटगरी तय करने की क्षमताएं जोड़ने के लिए, TensorFlow सर्विंग का इस्तेमाल किया!

अगले कोडलैब में, मॉडल को बेहतर बनाया जाएगा, ताकि आप ऐसे खास स्पैम मैसेज का पता लगा सकें जिनका पता मौजूदा ऐप्लिकेशन नहीं लगा सकता.

ज़्यादा जानें

• TensorFlow सर्विंग का होम पेज
• gRPC का होम पेज
• काट-छांट वाला होम पेज