Integra il classificatore del linguaggio naturale

L'API NLClassifier della Task Library classifica il testo di input in diverse categorie ed è un'API versatile e configurabile in grado di gestire la maggior parte dei modelli di classificazione del testo.

Funzionalità principali dell'API NLClassifier

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

  • Tokenizzazione Regex opzionale disponibile per il testo di input.

  • Configurabile per adattare diversi modelli di classificazione.

Modelli NLClassifier supportati

È garantita la compatibilità dei seguenti modelli con l'API NLClassifier .

Esegui l'inferenza in Java

Consulta l' app di riferimento per la classificazione del testo per un esempio di come utilizzare NLClassifier in un'app Android.

Passaggio 1: importa la dipendenza Gradle e altre impostazioni

Copia il file del modello .tflite nella directory asset del modulo Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso e aggiungi 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 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'
}

Passaggio 2: esegui l'inferenza utilizzando l'API

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

Vedere il codice sorgente per ulteriori opzioni per configurare NLClassifier .

Esegui l'inferenza in Swift

Passaggio 1: importa CocoaPods

Aggiungi il pod TensorFlowLiteTaskText in Podfile

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

Passaggio 2: esegui l'inferenza utilizzando l'API

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

Vedi il codice sorgente per maggiori dettagli.

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

Vedi 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.NLClassifier.create_from_file(model_path)

# Run inference
text_classification_result = classifier.classify(text)

Vedere il codice sorgente per ulteriori opzioni per configurare NLClassifier .

Risultati di esempio

Ecco un esempio dei risultati della classificazione del modello di recensione del film .

Input: "Che perdita di tempo."

Produzione:

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

Prova il semplice strumento demo CLI per NLClassifier con il tuo modello e i dati di test.

Requisiti di compatibilità del modello

A seconda del caso d'uso, l'API NLClassifier può caricare un modello TFLite con o senza metadati del modello TFLite . Guarda gli esempi di creazione di metadati per i classificatori del linguaggio naturale utilizzando l' API TensorFlow Lite Metadata Writer .

I modelli compatibili dovrebbero soddisfare i seguenti requisiti:

  • Tensore di input: (kTfLiteString/kTfLiteInt32)

    • L'input del modello deve essere una stringa di input non elaborata del tensore kTfLiteString o un tensore kTfLiteInt32 per gli indici tokenizzati regex della stringa di input non elaborata.
    • Se il tipo di input è kTfLiteString, per il modello non sono richiesti metadati .
    • Se il tipo di input è kTfLiteInt32, è necessario impostare un RegexTokenizer nel Metadata del tensore di input.

  • Tensore del punteggio di output: (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

    • Tensore di output obbligatorio per il punteggio di ciascuna categoria classificata.

    • Se type è uno dei tipi Int, dequantizzalo per raddoppiarlo/fluttuare sulle piattaforme corrispondenti

    • Può avere un file associato facoltativo nei metadati corrispondenti del tensore di output per le etichette di categoria, il file deve essere un file di testo semplice con un'etichetta per riga e il numero di etichette deve corrispondere al numero di categorie come output del modello. Vedi il file di etichetta di esempio .

  • Tensore etichetta di output: (kTfLiteString/kTfLiteInt32)

    • Il tensore di output opzionale per l'etichetta per ciascuna categoria deve avere la stessa lunghezza del tensore del punteggio di output. Se questo tensore non è presente, l'API utilizza gli indici di punteggio come nomi di classe.

    • Verrà ignorato se il file di etichetta associato è presente nei metadati del tensore del punteggio di output.