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. Il s'agit d'une API polyvalente et configurable qui peut gérer la plupart des modèles de classification de texte.

Fonctionnalités clés de l'API NLClassifier

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

  • Tokenisation Regex facultative disponible pour le texte d'entrée.

  • 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

Voir l' application de référence Text Classification pour un exemple d'utilisation de 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 assets 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.3.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

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

Voir 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.2.0'
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_file);
std::unique_ptr<NLClassifier> classifier = NLClassifier::CreateFromOptions(options).value();

// Run inference
std::vector<core::Category> categories = classifier->Classify(kInput);

Voir le code source pour plus de détails.

Exemples de résultats

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

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 Metadata du tenseur d'entrée.
  • Tenseur de 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 vers 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'étiquette .

  • 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.