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
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
.
Le modèle de classification des sentiments des critiques de films .
Modèles avec la spécification
average_word_vec
créés par TensorFlow Lite Model Maker pour la classification de texte .Modèles personnalisés qui répondent aux exigences de compatibilité des modèles .
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.