Intégrer un classificateur Natural Language

L'API NLClassifier de la bibliothèque de tâches classe le texte d'entrée dans différentes Il s'agit d'une API polyvalente et configurable capable de gérer la plupart des types de texte modèles de classification.

Principales fonctionnalités de l'API NLClassifier

  • Prend une seule chaîne en entrée, effectue une classification avec la chaîne et renvoie <label, score="">. paires comme résultats de classification.</label,>

  • Tokenisation d'expressions régulières facultative disponible pour le texte d'entrée.

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

Modèles NLClassifier compatibles

La compatibilité des modèles suivants avec NLClassifier est garantie. API.

Exécuter une inférence en Java

Consultez la documentation de référence sur la classification de texte l'appli pour obtenir un exemple d'utilisation de NLClassifier dans une application Android.

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

Copiez le fichier de modèle .tflite dans le répertoire d'éléments du module Android. où le modèle sera exécuté. Spécifier que le fichier ne doit pas être compressé 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);

Consultez la source du code pour afficher d'autres options de configuration de NLClassifier.

Exécuter une inférence en Swift

Étape 1: Importez des 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)

Consultez la source du code pour en savoir plus.

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

Consultez la source du code pour en savoir plus.

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

Consultez la source du code pour afficher d'autres options de configuration de NLClassifier.

Exemples de résultats

Voici un exemple des résultats de classification d'une critique de film modèle.

Entrée : "Quelle perte de temps."

Sortie :

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. Voir des exemples de création de métadonnées pour les classificateurs en langage naturel à l'aide de la bibliothèque TensorFlow Lite Rédacteur de métadonnées API.

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

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

    • L'entrée du modèle doit être une entrée brute de Tensor kTfLiteString chaîne ou un Tensor kTfLiteInt32 pour les index tokenisés sous forme d'expression régulière de l'entrée brute .
    • Si le type d'entrée est kTfLiteString, aucune Des métadonnées sont requises pour le modèle.
    • Si le type d'entrée est kTfLiteInt32, un RegexTokenizer doit être configuré dans du Tensor d'entrée Métadonnées :

  • Tensor 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 pour doubler/float pour plates-formes correspondantes

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

  • Tensor de l'étiquette de sortie: (kTfLiteString/kTfLiteInt32)

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

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