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

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

NLClassifier एपीआई की मुख्य सुविधाएं

• इनपुट के रूप में एक स्ट्रिंग लेता है, स्ट्रिंग की मदद से क्लासिफ़िकेशन करता है और आउटपुट <label, Score=""> जोड़े हैं.</label,>

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

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

इस्तेमाल किए जा सकने वाले NLClassifier मॉडल

ये मॉडल, NLClassifier के साथ काम करते हैं एपीआई.

• फ़िल्म की समीक्षा से जुड़ी भावना कैटगरी तय करना मॉडल.

• TensorFlow Lite Model Maker के ज़रिए बनाए गए average_word_vec स्पेसिफ़िकेशन वाले मॉडल टेक्स्ट की कैटगरी तय करने के लिए.

• मॉडल के साथ काम करने वाले मॉडल की शर्तों को पूरा करने वाले कस्टम मॉडल ज़रूरी शर्तें.

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 को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

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

पहला चरण: 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 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 API, TFLite मॉडल को या TFLite मॉडल मेटाडेटा के बिना होना चाहिए. उदाहरण देखें हमने TensorFlow Lite की मदद से, नैचुरल लैंग्वेज क्लासिफ़ायर के लिए मेटाडेटा तैयार किया है मेटाडेटा लेखक एपीआई.

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

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

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

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

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

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

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

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

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

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