Intégrer le classificateur de langage naturel

L'API NLClassifier de la bibliothèque de tâches classe le texte d'entrée dans différentes catégories et constitue une API polyvalente et configurable qui peut gérer la plupart des modèles de classification de texte.

Principales fonctionnalités de l'API NLClassifier

  • Prend une seule chaîne en entrée, effectue une classification avec la chaîne et les sorties paires comme résultats de classification.

  • Tokenisation Regex facultative disponible pour le texte de saisie.

  • Configurable pour adapter différents modèles de classification.

Modèles NLClassifier pris en charge

Les modèles suivants sont garantis compatibles avec l'API NLClassifier .

Exécuter l'inférence en Java

Consultez l’ application de référence Text Classification pour un exemple d’utilisation NLClassifier dans une application Android.

Étape 1 : Importer la dépendance Gradle et d'autres paramètres

Copiez le fichier de modèle .tflite dans le répertoire des actifs du module Android où le modèle sera exécuté. Spécifiez que le fichier ne doit pas être compressé et ajoutez la bibliothèque TensorFlow Lite au fichier build.gradle du module :

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

Étape 2 : Exécuter l'inférence à l'aide de 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);

Consultez le code source pour plus d'options pour configurer NLClassifier .

Exécuter l'inférence dans Swift

Étape 1 : Importer des CocoaPods

Ajouter le pod TensorFlowLiteTaskText dans Podfile

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

Étape 2 : Exécuter l'inférence à l'aide de 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)

Voir le code source pour plus de détails.

Exécuter l'inférence en 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);

Voir le code source pour plus de détails.

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support

Étape 2 : Utilisation du modèle

# Imports
from tflite_support.task import text

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

# Run inference
text_classification_result = classifier.classify(text)

Consultez le code source pour plus d'options pour configurer NLClassifier .

Exemples de résultats

Voici un exemple des résultats de classification du modèle de critique de films .

Entrée : "Quelle perte de temps."

Sortir:

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

Essayez l' outil de démonstration CLI simple pour NLClassifier avec votre propre modèle et vos données de test.

Exigences de compatibilité des modèles

Selon le cas d'utilisation, l'API NLClassifier peut charger un modèle TFLite avec ou sans métadonnées de modèle TFLite . Consultez des exemples de création de métadonnées pour les classificateurs de langage naturel à l'aide de l' API TensorFlow Lite Metadata Writer .

Les modèles compatibles doivent répondre aux exigences suivantes :

  • Tenseur d'entrée : (kTfLiteString/kTfLiteInt32)

    • L'entrée du modèle doit être soit une chaîne d'entrée brute de tenseur kTfLiteString, soit un tenseur kTfLiteInt32 pour les indices tokenisés regex de la chaîne d'entrée brute.
    • Si le type d'entrée est kTfLiteString, aucune métadonnée n'est requise pour le modèle.
    • Si le type d'entrée est kTfLiteInt32, un RegexTokenizer doit être configuré dans les Metadata du tenseur d'entrée.
  • Tenseur du score de sortie : (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

    • Tenseur de sortie obligatoire pour le score de chaque catégorie classée.

    • Si le type est l'un des types Int, déquantifiez-le pour doubler/flotter sur les plates-formes correspondantes

    • Peut avoir un fichier associé facultatif dans les métadonnées correspondantes du tenseur de sortie pour les étiquettes de catégorie, le fichier doit être un fichier texte brut avec une étiquette par ligne et le nombre d'étiquettes doit correspondre au nombre de catégories comme les sorties du modèle. Voir l' exemple de fichier d'étiquettes .

  • Tenseur d'étiquette de sortie : (kTfLiteString/kTfLiteInt32)

    • Le tenseur de sortie facultatif pour l'étiquette de chaque catégorie doit être de la même longueur que le tenseur de score de sortie. Si ce tenseur n'est pas présent, l'API utilise des indices de score comme noms de classe.

    • Sera ignoré si le fichier d'étiquette associé est présent dans les métadonnées du tenseur de score de sortie.