Attend the Women in ML Symposium on December 7 Register now

Integrar clasificador de lenguaje natural

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 la clasificación.

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

  • Configurable para adaptar diferentes modelos de clasificación.

Modelos NLClassifier compatibles

Se garantiza que los siguientes modelos son 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. 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 Vision Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.3.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

Paso 2: Ejecute la 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.2.0'
end

Paso 2: Ejecute la 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)

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

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

Aquí hay un ejemplo de los resultados de clasificación del modelo de revisión 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 de modelos

Según el 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 mediante la API de escritor 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 procesar del tensor kTfLiteString o un tensor kTfLiteInt32 para índices tokenizados de expresiones regulares de la cadena de entrada sin procesar.
    • 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 metadatos 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/flotar a las plataformas correspondientes

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