'नैचुरल लैंग्वेज क्लासिफ़ायर' का इस्तेमाल करें

टास्क लाइब्रेरी का NLClassifier एपीआई, इनपुट टेक्स्ट को अलग-अलग कैटगरी में बाँटता है. यह एक वर्सटाइल और कॉन्फ़िगर किया जा सकने वाला एपीआई है, जो टेक्स्ट क्लासिफ़िकेशन के ज़्यादातर मॉडल को हैंडल कर सकता है.

NLClassifier API की मुख्य सुविधाएं

  • यह फ़ंक्शन, इनपुट के तौर पर एक स्ट्रिंग लेता है. इसके बाद, स्ट्रिंग के आधार पर कैटगरी तय करता है. साथ ही, कैटगरी तय करने के नतीजों के तौर पर <label, score=""> जोड़े दिखाता है.</label,>

  • इनपुट टेक्स्ट के लिए, रेगुलर एक्सप्रेशन के आधार पर टोकन बनाने की सुविधा उपलब्ध है. हालांकि, इसका इस्तेमाल करना ज़रूरी नहीं है.

  • अलग-अलग क्लासिफ़िकेशन मॉडल के हिसाब से कॉन्फ़िगर किया जा सकता है.

NLClassifier के साथ काम करने वाले मॉडल

इन मॉडल में NLClassifier API का इस्तेमाल किया जा सकता है.

Java में अनुमान लगाने की सुविधा इस्तेमाल करना

Android ऐप्लिकेशन में NLClassifier का इस्तेमाल करने का तरीका जानने के लिए, टेक्स्ट क्लासिफ़िकेशन का रेफ़रंस ऐप्लिकेशन देखें.

पहला चरण: Gradle डिपेंडेंसी और अन्य सेटिंग इंपोर्ट करना

.tflite मॉडल फ़ाइल को Android मॉड्यूल की ऐसेट डायरेक्ट्री में कॉपी करें. मॉडल को इसी डायरेक्ट्री में चलाया जाएगा. यह तय करें कि फ़ाइल को कंप्रेस नहीं किया जाना चाहिए. साथ ही, मॉड्यूल की build.gradle फ़ाइल में TensorFlow Lite लाइब्रेरी जोड़ें:

android {
    // Other settings

    // Specify tflite file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }

}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.4'
}

दूसरा चरण: एपीआई का इस्तेमाल करके अनुमान लगाना

// Initialization, use NLClassifierOptions to configure input and output tensors
NLClassifierOptions options =
    NLClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setInputTensorName(INPUT_TENSOR_NAME)
        .setOutputScoreTensorName(OUTPUT_SCORE_TENSOR_NAME)
        .build();
NLClassifier classifier =
    NLClassifier.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Category> results = classifier.classify(input);

NLClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के लिए, सोर्स कोड देखें.

Swift में अनुमान लगाने की सुविधा इस्तेमाल करना

पहला चरण: CocoaPods इंपोर्ट करना

Podfile में TensorFlowLiteTaskText पॉड जोड़ें

target 'MySwiftAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskText', '~> 0.4.4'
end

दूसरा चरण: एपीआई का इस्तेमाल करके अनुमान लगाना

// Initialization
var modelOptions:TFLNLClassifierOptions = TFLNLClassifierOptions()
modelOptions.inputTensorName = inputTensorName
modelOptions.outputScoreTensorName = outputScoreTensorName
let nlClassifier = TFLNLClassifier.nlClassifier(
      modelPath: modelPath,
      options: modelOptions)

// Run inference
let categories = nlClassifier.classify(text: input)

ज़्यादा जानकारी के लिए, सोर्स कोड देखें.

C++ में अनुमान चलाने की सुविधा

// Initialization
NLClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<NLClassifier> classifier = NLClassifier::CreateFromOptions(options).value();

// Run inference with your input, `input_text`.
std::vector<core::Category> categories = classifier->Classify(input_text);

ज़्यादा जानकारी के लिए, सोर्स कोड देखें.

Python में अनुमान लगाने की सुविधा का इस्तेमाल करना

पहला चरण: pip पैकेज इंस्टॉल करना

pip install tflite-support

दूसरा चरण: मॉडल का इस्तेमाल करना

# Imports
from tflite_support.task import text

# Initialization
classifier = text.NLClassifier.create_from_file(model_path)

# Run inference
text_classification_result = classifier.classify(text)

NLClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के लिए, सोर्स कोड देखें.

परिणामों के उदाहरण

यहाँ फ़िल्म की समीक्षा करने वाले मॉडल के क्लासिफ़िकेशन के नतीजों का एक उदाहरण दिया गया है.

इनपुट: "मेरा समय बर्बाद हो गया."

आउटपुट:

category[0]: 'Negative' : '0.81313'
category[1]: 'Positive' : '0.18687'

अपने मॉडल और टेस्ट डेटा के साथ, NLClassifier के लिए सीएलआई डेमो टूल आज़माएं.

मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तें

इस्तेमाल के उदाहरण के आधार पर, NLClassifier एपीआई, TFLite मॉडल मेटाडेटा के साथ या उसके बिना TFLite मॉडल लोड कर सकता है. TensorFlow Lite Metadata Writer API का इस्तेमाल करके, नैचुरल लैंग्वेज क्लासिफ़ायर के लिए मेटाडेटा बनाने के उदाहरण देखें.

साथ काम करने वाले मॉडल को ये ज़रूरी शर्तें पूरी करनी होंगी:

  • इनपुट टेंसर: (kTfLiteString/kTfLiteInt32)

    • मॉडल का इनपुट, kTfLiteString टेंसर रॉ इनपुट स्ट्रिंग या kTfLiteInt32 टेंसर होना चाहिए. यह रॉ इनपुट स्ट्रिंग के रेगुलर एक्सप्रेशन वाले टोकनाइज़ किए गए इंडेक्स के लिए होता है.
    • अगर इनपुट टाइप kTfLiteString है, तो मॉडल के लिए किसी मेटाडेटा की ज़रूरत नहीं होती.
    • अगर इनपुट टाइप kTfLiteInt32 है, तो इनपुट टेंसर के मेटाडेटा में RegexTokenizer को सेट अप करना होगा.

  • आउटपुट स्कोर टेंसर: (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

    • यह हर कैटगरी के स्कोर के लिए ज़रूरी आउटपुट टेंसर है.

    • अगर टाइप, इंट टाइप में से कोई एक है, तो उसे डबल/फ़्लोट में बदलकर, उससे जुड़े प्लैटफ़ॉर्म पर भेजें

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

  • आउटपुट लेबल टेंसर: (kTfLiteString/kTfLiteInt32)

    • हर कैटगरी के लेबल के लिए, यह एक वैकल्पिक आउटपुट टेंसर है. इसकी लंबाई, आउटपुट स्कोर टेंसर के बराबर होनी चाहिए. अगर यह टेंसर मौजूद नहीं है, तो एपीआई, स्कोर इंडेक्स को क्लासनेम के तौर पर इस्तेमाल करता है.

    • अगर इससे जुड़ी लेबल फ़ाइल, आउटपुट स्कोर टेंसर के मेटाडेटा में मौजूद है, तो इसे अनदेखा कर दिया जाएगा.