Integrar o classificador de linguagem natural

A API NLClassifier da Biblioteca de tarefas classifica o texto de entrada em diferentes e é uma API versátil e configurável que pode lidar com a maioria dos modelos de classificação.

Principais recursos da API NLClassifier

• Utiliza uma única string como entrada, realiza a classificação com a string e gera <label, score=""> pares como resultados da classificação.</label,>

• Tokenização de regex opcional disponível para texto de entrada.

• Configurável para adaptar diferentes modelos de classificação.

Modelos NLClassifier com suporte

Os modelos a seguir têm a garantia de compatibilidade com o NLClassifier API.

• O sentimento da resenha de filme classificação um modelo de machine learning.

• Modelos com a especificação average_word_vec criados pelo TensorFlow Lite Model Maker para classificação de texto.

• Modelos personalizados que atendem aos requisitos de compatibilidade do modelo .

Executar inferência em Java

Consulte a referência de classificação de texto App para conferir um exemplo de como usar NLClassifier em um app Android.

Etapa 1: importar a dependência do Gradle e outras configurações

Copie o arquivo modelo .tflite para o diretório de assets do módulo Android. em que o modelo será executado. Especifique que o arquivo não deve ser compactado. Adicione a biblioteca do TensorFlow Lite ao arquivo build.gradle do 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
    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'
}

Etapa 2: executar inferência usando a 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 a fonte código para mais opções de configuração do NLClassifier.

Executar inferência no Swift

Etapa 1: importar o CocoaPods

Adicionar o pod do TensorFlowLiteTaskText ao Podfile

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

Etapa 2: executar inferência usando a 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 a fonte código para mais detalhes.

Executar inferência em 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 a fonte código para mais detalhes.

Executar inferência em Python

Etapa 1: instalar o pacote pip

pip install tflite-support

Etapa 2: uso do 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 a fonte código para mais opções de configuração do NLClassifier.

Resultados de exemplo

Aqui está um exemplo dos resultados da classificação da crítica de filme modelo.

Entrada: "Que perda de tempo".

Saída:

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

Teste a ferramenta de demonstração simples da CLI para NLClassifier com seu próprio modelo e dados de teste.

Requisitos de compatibilidade do modelo

Dependendo do caso de uso, a API NLClassifier pode carregar um modelo TFLite com ou sem TFLite Model Metadata. Confira exemplos da criação de metadados para classificadores de linguagem natural usando o TensorFlow Lite Gravador de metadados API.

Os modelos compatíveis devem atender aos seguintes requisitos:

• Tensor de entrada: (kTfLiteString/kTfLiteInt32)

  • A entrada do modelo deve ser uma entrada bruta do tensor kTfLiteString string ou um tensor kTfLiteInt32 para índices tokenizados de regex de entrada bruta fio.
  • Se o tipo de entrada for kTfLiteString, não Os metadados são obrigatórios para o modelo.
  • Se o tipo de entrada for kTfLiteInt32, será necessário configurar um RegexTokenizer no o valor do tensor de entrada Metadados.

• Tensor de pontuação de saída: (kTfLiteUInt8/kTfLiteInt8/kTfLiteInt16/kTfLiteFloat32/kTfLiteFloat64)

  • Tensor de saída obrigatório para a pontuação de cada categoria classificada.

  • Se o tipo for um dos tipos Int, dequantize-o para duplo/flutuar para plataformas correspondentes

  • Pode ter um arquivo associado opcional no valor do tensor de saída Metadados correspondentes à categoria rótulos, o arquivo deve ser um arquivo de texto simples com um rótulo por linha, e o número de rótulos deve corresponder ao número de categorias as saídas do modelo. Veja o exemplo de rótulo arquivo.

• Tensor do rótulo de saída: (kTfLiteString/kTfLiteInt32)

  • O tensor de saída opcional para o rótulo de cada categoria deve ser do tipo que tem o mesmo comprimento do tensor de pontuação de saída. Se esse tensor não estiver presente, o A API usa índices de pontuação como nomes de classe.

  • Será ignorado se o arquivo de rótulo associado estiver presente na pontuação de saída dos metadados do tensor.