Intégrer un classificateur en langage naturel BERT

L'API BertNLClassifier de la bibliothèque de tâches est très semblable à NLClassifier. qui classe le texte d'entrée en différentes catégories, à la différence près que cette API est spécialement conçu pour les modèles BERT nécessitant Tokenisation d'extraits de phrases en dehors du modèle TFLite.

Principales fonctionnalités de l'API BertNLClassifier

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

• Effectue des recherches dans un fichier WordPoint hors graphique. ou Extrait de phrase et tokenisations sur le texte d'entrée.

Modèles BertNLClassifier compatibles

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

• Modèles BERT créés par TensorFlow Lite Model Maker pour le texte Classification :

• Des modèles personnalisés qui répondent aux critères de compatibilité exigences.

Exécuter une inférence en Java

É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 Text Library dependency
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
}

Étape 2: Exécutez l'inférence à l'aide de l'API

// Initialization
BertNLClassifierOptions options =
    BertNLClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().setNumThreads(4).build())
        .build();
BertNLClassifier classifier =
    BertNLClassifier.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Category> results = classifier.classify(input);

Consultez la source du code pour en savoir plus.

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
let bertNLClassifier = TFLBertNLClassifier.bertNLClassifier(
      modelPath: bertModelPath)

// Run inference
let categories = bertNLClassifier.classify(text: input)

Consultez la source du code pour en savoir plus.

Exécuter une inférence en C++

// Initialization
BertNLClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<BertNLClassifier> classifier = BertNLClassifier::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.BertNLClassifier.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 BertNLClassifier.

Exemples de résultats

Voici un exemple de classement de critiques de films utilisant la méthode MobileBert de Model Maker.

Entrée : "C'est un voyage charmant et souvent bouleversant"

Sortie :

category[0]: 'negative' : '0.00006'
category[1]: 'positive' : '0.99994'

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

Exigences de compatibilité des modèles

L'API BetNLClassifier attend un modèle TFLite avec un modèle TFLite obligatoire Métadonnées.

Les métadonnées doivent répondre aux exigences suivantes:

• input_process_units pour l'outil de tokenisation WordFragment/Sentenceroom

• 3 Tensors d'entrée nommés "ids", "mask" et "segment_ids" pour la sortie de la fonction de tokenisation

• Un Tensor de sortie de type float32, avec un fichier d'étiquettes éventuellement associé Si un fichier d'étiquettes est joint, le fichier doit être au format texte brut avec une par ligne et le nombre d'étiquettes doit correspondre au nombre de catégories indiqué les sorties du modèle.