प्राकृतिक भाषा वर्गीकरण को एकीकृत करें

टास्क लाइब्रेरी का NLClassifier एपीआई इनपुट टेक्स्ट को विभिन्न श्रेणियों में वर्गीकृत करता है, और एक बहुमुखी और कॉन्फ़िगर करने योग्य एपीआई है जो अधिकांश टेक्स्ट वर्गीकरण मॉडल को संभाल सकता है।

एनएलक्लासिफ़ायर एपीआई की मुख्य विशेषताएं

• इनपुट के रूप में एक स्ट्रिंग लेता है, स्ट्रिंग और आउटपुट के साथ वर्गीकरण करता है वर्गीकरण परिणाम के रूप में जोड़े।

• इनपुट टेक्स्ट के लिए वैकल्पिक रेगेक्स टोकनाइजेशन उपलब्ध है।

• विभिन्न वर्गीकरण मॉडलों को अनुकूलित करने के लिए कॉन्फ़िगर करने योग्य।

समर्थित एनएलक्लासिफ़ायर मॉडल

निम्नलिखित मॉडलों को NLClassifier API के साथ संगत होने की गारंटी दी गई है।

• फ़िल्म समीक्षा भावना वर्गीकरण मॉडल।

• टेक्स्ट वर्गीकरण के लिए TensorFlow Lite मॉडल निर्माता द्वारा बनाए गए average_word_vec विनिर्देश वाले मॉडल।

• कस्टम मॉडल जो मॉडल संगतता आवश्यकताओं को पूरा करते हैं।

जावा में अनुमान चलाएँ

एंड्रॉइड ऐप में NLClassifier का उपयोग कैसे करें के उदाहरण के लिए टेक्स्ट क्लासिफिकेशन संदर्भ ऐप देखें।

चरण 1: ग्रैडल निर्भरता और अन्य सेटिंग्स आयात करें

.tflite मॉडल फ़ाइल को एंड्रॉइड मॉड्यूल की संपत्ति निर्देशिका में कॉपी करें जहां मॉडल चलाया जाएगा। निर्दिष्ट करें कि फ़ाइल को संपीड़ित नहीं किया जाना चाहिए, और मॉड्यूल की 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 (NNAPI is included)
    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'
}

नोट: एंड्रॉइड ग्रैडल प्लगइन के संस्करण 4.1 से शुरू होकर, .tflite को डिफ़ॉल्ट रूप से noCompress सूची में जोड़ा जाएगा और उपरोक्त aaptOptions की अब आवश्यकता नहीं है।

चरण 2: एपीआई का उपयोग करके अनुमान चलाएँ

// 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 कॉन्फ़िगर करने के लिए अधिक विकल्पों के लिए स्रोत कोड देखें।

स्विफ्ट में अनुमान चलाएँ

चरण 1: कोकोपोड्स आयात करें

पॉडफाइल में TensorFlowLiteTaskText पॉड जोड़ें

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

चरण 2: एपीआई का उपयोग करके अनुमान चलाएँ

// 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);

अधिक विवरण के लिए स्रोत कोड देखें।

पायथन में अनुमान चलाएँ

चरण 1: पिप पैकेज स्थापित करें

pip install tflite-support

चरण 2: मॉडल का उपयोग करना

# 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 API TFLite मॉडल मेटाडेटा के साथ या उसके बिना TFLite मॉडल लोड कर सकता है। TensorFlow Lite मेटाडेटा राइटर API का उपयोग करके प्राकृतिक भाषा क्लासिफायर के लिए मेटाडेटा बनाने के उदाहरण देखें।

संगत मॉडल को निम्नलिखित आवश्यकताओं को पूरा करना चाहिए:

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

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

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

  • वर्गीकृत प्रत्येक श्रेणी के स्कोर के लिए अनिवार्य आउटपुट टेंसर।

  • यदि प्रकार Int प्रकारों में से एक है, तो इसे संबंधित प्लेटफ़ॉर्म पर दोगुना/फ्लोट करने के लिए डिक्वांटाइज़ करें

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

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

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

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