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

टास्क लाइब्रेरी BertNLClassifier API, NLClassifier के समान है जो इनपुट टेक्स्ट को विभिन्न श्रेणियों में वर्गीकृत करता है, सिवाय इसके कि यह API विशेष रूप से Bert संबंधित मॉडलों के लिए तैयार किया गया है, जिन्हें TFLite मॉडल के बाहर वर्डपीस और सेंटेंसपीस टोकननाइजेशन की आवश्यकता होती है।

BertNLClassifier API की मुख्य विशेषताएं

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

  • इनपुट टेक्स्ट पर आउट-ऑफ-ग्राफ वर्डपीस या सेंटेंसपीस टोकननाइजेशन निष्पादित करता है।

समर्थित BertNLClassifier मॉडल

निम्नलिखित मॉडल BertNLClassifier API के साथ संगत हैं।

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

चरण 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 Text Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
}

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

// Initialization
BertNLClassifierOptions options =
    BertNLClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().setNumThreads(4).build())
        .build();
BertNLClassifier classifier =
    BertNLClassifier.createFromFileAndOptions(context, modelFile, options);

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

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

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

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

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

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

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

// Initialization
let bertNLClassifier = TFLBertNLClassifier.bertNLClassifier(
      modelPath: bertModelPath)

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

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

C++ में अनुमान चलाएँ

// Initialization
BertNLClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<BertNLClassifier> classifier = BertNLClassifier::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.BertNLClassifier.create_from_file(model_path)

# Run inference
text_classification_result = classifier.classify(text)

BertNLClassifier कॉन्फ़िगर करने के लिए अधिक विकल्पों के लिए स्रोत कोड देखें।

उदाहरण परिणाम

यहां मॉडल मेकर के मोबाइलबर्ट मॉडल का उपयोग करके फिल्म समीक्षाओं के वर्गीकरण परिणामों का एक उदाहरण दिया गया है।

इनपुट: "यह एक आकर्षक और अक्सर प्रभावित करने वाली यात्रा है"

आउटपुट:

category[0]: 'negative' : '0.00006'
category[1]: 'positive' : '0.99994'

अपने स्वयं के मॉडल और परीक्षण डेटा के साथ BertNLClassifier के लिए सरल सीएलआई डेमो टूल आज़माएं।

मॉडल अनुकूलता आवश्यकताएँ

BetNLClassifier API अनिवार्य TFLite मॉडल मेटाडेटा के साथ एक TFLite मॉडल की अपेक्षा करता है।

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

  • वर्डपीस/सेंटेंसपीस टोकनाइज़र के लिए इनपुट_प्रोसेस_यूनिट्स

  • टोकननाइज़र के आउटपुट के लिए "आईडी", "मास्क" और "सेगमेंट_आईडी" नाम वाले 3 इनपुट टेंसर

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