Integra il classificatore del linguaggio naturale BERT

L'API della libreria delle attività BertNLClassifier è molto simile a NLClassifier che classifica il testo di input in diverse categorie, tranne per il fatto che questa API è appositamente progettata per i modelli correlati a Bert che richiedono la tokenizzazione di Wordpiece e Sentencepiece al di fuori del modello TFLite.

Caratteristiche principali dell'API BertNLClassifier

• Prende una singola stringa come input, esegue la classificazione con la stringa e gli output coppie come risultati di classificazione.

• Esegue la tokenizzazione di Wordpiece o Sentencepiece fuori grafico sul testo di input.

Modelli BertNLClassifier supportati

I seguenti modelli sono compatibili con l'API BertNLClassifier .

• Modelli Bert creati da TensorFlow Lite Model Maker per la classificazione del testo .

• Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .

Esegui l'inferenza in Java

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo Android in cui verrà eseguito il modello. Specificare che il file non deve essere compresso e aggiungere la libreria TensorFlow Lite al file build.gradle del modulo:

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.3.0'
}

Passaggio 2: esegui l'inferenza utilizzando l'API

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

Vedere il codice sorgente per maggiori dettagli.

Esegui l'inferenza in Swift

Passaggio 1: importa CocoaPods

Aggiungi il pod TensorFlowLiteTaskText in Podfile

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

Passaggio 2: esegui l'inferenza utilizzando l'API

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

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

Vedere il codice sorgente per maggiori dettagli.

Esegui l'inferenza in 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);

Vedere il codice sorgente per maggiori dettagli.

Esegui l'inferenza in Python

Passaggio 1: installa il pacchetto pip

pip install tflite-support

Passaggio 2: utilizzo del modello

# Imports
from tflite_support.task import text

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

# Run inference
text_classification_result = classifier.classify(text)

Vedere il codice sorgente per ulteriori opzioni per configurare BertNLClassifier .

Risultati di esempio

Ecco un esempio dei risultati della classificazione delle recensioni di film utilizzando il modello MobileBert di Model Maker.

Input: "è un viaggio affascinante e spesso toccante"

Produzione:

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

Prova il semplice strumento demo CLI per BertNLClassifier con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API BetNLClassifier prevede un modello TFLite con metadati del modello TFLite obbligatori.

I metadati devono soddisfare i seguenti requisiti:

• input_process_units per il token di Wordpiece/Sentencepiece

• 3 tensori di input con nomi "ids", "mask" e "segment_ids" per l'output del tokenizer

• 1 tensore di uscita di tipo float32, con un file etichetta opzionale. Se è allegato un file di etichetta, il file deve essere un file di testo normale con un'etichetta per riga e il numero di etichette deve corrispondere al numero di categorie come output del modello.