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
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.