Grazie per esserti sintonizzato su Google I/O. Visualizza tutte le sessioni su richiesta Guarda su richiesta

Integra il classificatore del linguaggio naturale

L'API NLClassifier della Libreria attività 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.

Caratteristiche principali dell'API NLClassifier

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

  • Tokenizzazione Regex opzionale disponibile per il testo di input.

  • Configurabile per adattare diversi modelli di classificazione.

Modelli NLClassifier supportati

I seguenti modelli sono garantiti per essere compatibili con l'API NLClassifier .

Esegui l'inferenza in Java

Vedere 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 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 Vision Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.3.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

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.2.0'
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)

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

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.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 spreco 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 tuoi dati di prova.

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 . Vedere esempi di creazione di metadati per classificatori in linguaggio naturale utilizzando l' API di scrittura di metadati TensorFlow Lite .

I modelli compatibili devono soddisfare i seguenti requisiti:

  • Tensore di ingresso: (kTfLiteString/kTfLiteInt32)

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

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

    • Tensore di uscita 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 normale con un'etichetta per riga e il numero di etichette deve corrispondere al numero di categorie come output del modello. Vedere il file di etichetta di esempio .

  • Tensore etichetta di uscita: (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.