Intégrer un classificateur Natural Language

L'API NLClassifier de la bibliothèque de tâches classe le texte saisi dans différentes catégories. Il s'agit d'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 la classification avec la chaîne et génère des paires <label, score=""> comme résultats de classification.</label,>

  • La tokenisation Regex facultative est disponible pour le texte saisi.

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

Modèles NLClassifier compatibles

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

Exécuter une inférence en Java

Pour découvrir un exemple d'utilisation de NLClassifier dans une application Android, consultez l'application de référence sur la classification de texte.

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

Copiez le fichier de modèle .tflite dans le répertoire des éléments du module Android dans lequel 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
    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écutez 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);

Pour découvrir d'autres options de configuration de NLClassifier, consultez le code source.

Exécuter l'inférence en Swift

Étape 1 : Importer CocoaPods

Ajouter le pod TensorFlowLiteTaskText dans le fichier Podfile

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

Étape 2 : Exécutez 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)

Pour en savoir plus, consultez le code source.

Exécuter une 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);

Pour en savoir plus, consultez le code source.

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support

Étape 2 : Utiliser le 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)

Pour découvrir d'autres options de configuration de NLClassifier, consultez le code source.

Exemples de résultats

Voici un exemple des résultats de classification du modèle d'analyse des sentiments pour les avis sur les films.

Entrée : "Quelle perte de temps !"

Résultat :

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

Essayez l'outil de démonstration simple de l'interface de ligne de commande 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 un Tensor kTfLiteString (chaîne d'entrée brute) ou un Tensor kTfLiteInt32 (indices de la chaîne d'entrée brute tokenisée par expression régulière).
    • 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 métadonnées du Tensor d'entrée.

  • Tenseur de score de sortie : (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

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

    • Si le type est l'un des types Int, déquantifiez-le en double/float pour les plates-formes correspondantes.

    • Peut avoir un fichier associé facultatif dans les métadonnées correspondantes du Tensor de sortie. Pour les libellés de catégorie, le fichier doit être un fichier en texte brut avec un libellé par ligne, et le nombre de libellés doit correspondre au nombre de catégories générées par le modèle. Consultez l'exemple de fichier de libellés.

  • Tensor de libellé de sortie : (kTfLiteString/kTfLiteInt32)

    • Tensor de sortie facultatif pour le libellé de chaque catégorie. Il doit avoir la même longueur que le Tensor de score de sortie. Si ce Tensor n'est pas présent, l'API utilise les index de score comme noms de classe.

    • Sera ignoré si le fichier de libellé associé est présent dans les métadonnées du Tensor de score de sortie.