Integra classificatore di linguaggio naturale

L'API NLClassifier della libreria attività classifica il testo di input in ed è un'API versatile e configurabile in grado di gestire la maggior parte dei di classificazione.

Funzionalità chiave dell'API NLClassifier

  • Prende una singola stringa come input, esegue la classificazione con la stringa e restituisce <label, score=""> coppie come risultati di classificazione.</label,>

  • Tokenizzazione regex facoltativa disponibile per il testo di input.

  • Configurabile per adattare modelli di classificazione diversi.

Modelli NLClassifier supportati

La compatibilità dei seguenti modelli è garantita con NLClassifier tramite Google Cloud CLI o tramite l'API Compute Engine.

Esegui l'inferenza in Java

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

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo per Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso. 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
    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);

Consulta la fonte codice per altre opzioni di configurazione di 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)

Consulta la fonte codice per ulteriori informazioni.

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

Consulta la fonte codice per ulteriori informazioni.

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)

Consulta la fonte codice per altre opzioni di configurazione di NLClassifier.

Risultati di esempio

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

Input: "Che perdita di tempo".

Output:

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

Prova il semplice strumento dimostrativo dell'interfaccia a riga di comando per NLClassifier con il tuo modello e 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 TFLite Model Metadata. Visualizza esempi di creazione di metadati per i classificatori del linguaggio naturale utilizzando TensorFlow Lite Writer metadati tramite Google Cloud.

I modelli compatibili devono soddisfare i seguenti requisiti:

  • Tensore di input: (kTfLiteString/kTfLiteInt32)

    • L'input del modello deve essere un input non elaborato di un tensore kTfLiteString o un tensore kTfLiteInt32 per gli indici tokenizzati regex di input non elaborati stringa.
    • Se il tipo di input è kTfLiteString, non viene I metadati sono obbligatori per il modello.
    • Se il tipo di input è kTfLiteInt32, è necessario configurare un RegexTokenizer in il tensore di input Metadati.

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

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

    • Se il tipo è uno dei tipi Int, dequantizzalo in modo che sia doppio o fluttuante in piattaforme corrispondenti

    • Può avere un file associato facoltativo nel tensore di output Metadati corrispondenti per la categoria etichette, 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 del modello. Consulta l'etichetta di esempio .

  • Tensore etichetta di output: (kTfLiteString/kTfLiteInt32)

    • Il tensore di output facoltativo per l'etichetta di ogni categoria deve essere del della stessa lunghezza del tensore del punteggio di output. Se questo tensore non è presente, L'API utilizza indici di punteggio come nomi delle classi.

    • Verrà ignorato se il file delle etichette associato è presente nel punteggio di output i metadati del tensore.