Integre el clasificador de lenguaje natural BERT

La API BertNLClassifier de la biblioteca de tareas es muy similar a NLClassifier que clasifica el texto de entrada en diferentes categorías, excepto que esta API está especialmente diseñada para modelos relacionados con Bert que requieren tokenizaciones de Wordpiece y Sentencepiece fuera del modelo TFLite.

Características clave de la API BertNLClassifier

• Toma una sola cadena como entrada, realiza la clasificación con la cadena y genera pares como resultados de clasificación.

• Realiza tokenizaciones de Wordpiece o Sentencepiece fuera del gráfico en el texto de entrada.

Modelos BertNLClassifier compatibles

Los siguientes modelos son compatibles con la API BertNLClassifier .

• Modelos Bert creados por TensorFlow Lite Model Maker para clasificación de texto .

• Modelos personalizados que cumplen con los requisitos de compatibilidad de modelos .

Ejecutar inferencia en Java

Paso 1: importar la dependencia de Gradle y otras configuraciones

Copie el archivo del modelo .tflite en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifique que el archivo no debe comprimirse y agregue la biblioteca TensorFlow Lite al archivo build.gradle del módulo:

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 (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
}

Paso 2: Ejecutar inferencia usando la 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);

Consulte el código fuente para obtener más detalles.

Ejecutar inferencia en Swift

Paso 1: importar CocoaPods

Agregue el pod TensorFlowLiteTaskText en Podfile

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

Paso 2: Ejecutar inferencia usando la API

// Initialization
let bertNLClassifier = TFLBertNLClassifier.bertNLClassifier(
      modelPath: bertModelPath)

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

Consulte el código fuente para obtener más detalles.

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

Consulte el código fuente para obtener más detalles.

Ejecutar inferencia en Python

Paso 1: instale el paquete pip

pip install tflite-support

Paso 2: usar el modelo

# Imports
from tflite_support.task import text

# Initialization
classifier = text.BertNLClassifier.create_from_file(model_path)

# Run inference
text_classification_result = classifier.classify(text)

Consulte el código fuente para obtener más opciones para configurar BertNLClassifier .

Resultados de ejemplo

A continuación se muestra un ejemplo de los resultados de clasificación de reseñas de películas utilizando el modelo MobileBert de Model Maker.

Entrada: "es un viaje encantador y a menudo conmovedor"

Producción:

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

Pruebe la sencilla herramienta de demostración CLI para BertNLClassifier con su propio modelo y datos de prueba.

Requisitos de compatibilidad del modelo

La API BetNLClassifier espera un modelo TFLite con metadatos del modelo TFLite obligatorios.

Los Metadatos deben cumplir los siguientes requisitos:

• input_process_units para tokenizador de Wordpiece/Sentencepiece

• 3 tensores de entrada con nombres "ids", "mask" y "segment_ids" para la salida del tokenizador

• 1 tensor de salida de tipo float32, con un archivo de etiqueta adjunto opcional. Si se adjunta un archivo de etiquetas, el archivo debe ser un archivo de texto sin formato con una etiqueta por línea y el número de etiquetas debe coincidir con el número de categorías que genera el modelo.