Integre el clasificador de lenguaje natural BERT

La API BertNLClassifier de la biblioteca de tareas es muy similar al NLClassifier que clasifica el texto de entrada en diferentes categorías, excepto que esta API está especialmente diseñada para los 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 la 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 la 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. Especifica que el archivo no debe comprimirse y agrega 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: Ejecute la 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);

Ver el código fuente para 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: Ejecute la inferencia usando la API

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

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

Ver el código fuente para 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);

Ver el código fuente para más detalles.

Ejecutar inferencia en Python

Paso 1: Instale el paquete pip

pip install tflite-support

Paso 2: Usando 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

Este es 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 de modelos

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

Los Metadatos deben cumplir con los siguientes requisitos:

• input_process_units para Wordpiece/Sentencepiece Tokenizer

• 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 etiquetas adjunto opcionalmente. Si se adjunta un archivo de etiqueta, el archivo debe ser un archivo de texto sin formato con una etiqueta por línea y la cantidad de etiquetas debe coincidir con la cantidad de categorías que genera el modelo.