Integrar clasificador de lenguaje natural

La API NLClassifier de la biblioteca de tareas clasifica el texto de entrada en diferentes categorías y es una API versátil y configurable que puede manejar la mayoría de los modelos de clasificación de texto.

Características clave de la API NLClassifier

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

  • Tokenización Regex opcional disponible para entrada de texto.

  • Configurable para adaptar diferentes modelos de clasificación.

Modelos de NLClassifier compatibles

Se garantiza que los siguientes modelos serán compatibles con la API NLClassifier .

Ejecutar inferencia en Java

Consulte la aplicación de referencia de Clasificación de texto para ver un ejemplo de cómo usar NLClassifier en una aplicación de Android.

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 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'
}

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

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

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

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

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

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

Resultados de ejemplo

A continuación se muestra un ejemplo de los resultados de clasificación del modelo de reseña de películas .

Entrada: "Qué pérdida de tiempo".

Producción:

category[0]: 'Negative' : '0.81313'
category[1]: 'Positive' : '0.18687'

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

Requisitos de compatibilidad del modelo

Dependiendo del caso de uso, la API NLClassifier puede cargar un modelo TFLite con o sin metadatos del modelo TFLite . Vea ejemplos de creación de metadatos para clasificadores de lenguaje natural utilizando la API de escritura de metadatos de TensorFlow Lite .

Los modelos compatibles deben cumplir los siguientes requisitos:

  • Tensor de entrada: (kTfLiteString/kTfLiteInt32)

    • La entrada del modelo debe ser una cadena de entrada sin formato del tensor kTfLiteString o un tensor kTfLiteInt32 para índices tokenizados de expresiones regulares de una cadena de entrada sin formato.
    • Si el tipo de entrada es kTfLiteString, no se requieren metadatos para el modelo.
    • Si el tipo de entrada es kTfLiteInt32, se debe configurar un RegexTokenizer en los Metadata del tensor de entrada.
  • Tensor de puntuación de salida: (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

    • Tensor de salida obligatorio para la puntuación de cada categoría clasificada.

    • Si el tipo es uno de los tipos Int, descuantícelo para duplicarlo/flotarlo en las plataformas correspondientes.

    • Puede tener un archivo asociado opcional en los metadatos correspondientes del tensor de salida para las etiquetas de categorías, 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. Vea el archivo de etiqueta de ejemplo .

  • Tensor de etiqueta de salida: (kTfLiteString/kTfLiteInt32)

    • El tensor de salida opcional para la etiqueta de cada categoría debe tener la misma longitud que el tensor de puntuación de salida. Si este tensor no está presente, la API utiliza índices de puntuación como nombres de clase.

    • Se ignorará si el archivo de etiqueta asociado está presente en los metadatos del tensor de puntuación de salida.