Integrar classificador de linguagem natural BERT

A API BertNLClassifier da Biblioteca de Tarefas é muito semelhante ao NLClassifier que classifica o texto de entrada em diferentes categorias, exceto que esta API é especialmente adaptada para modelos relacionados ao Bert que requerem tokenizações Wordpiece e Sentencepiece fora do modelo TFLite.

Principais recursos da API BertNLClassifier

  • Pega uma única string como entrada, realiza a classificação com a string e gera pares como resultados de classificação.

  • Executa tokenizações de Wordpiece ou Sentencepiece fora do gráfico no texto de entrada.

Modelos BertNLClassifier suportados

Os modelos a seguir são compatíveis com a API BertNLClassifier .

Execute inferência em Java

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

Copie o arquivo do modelo .tflite para o diretório de ativos do módulo Android onde o modelo será executado. Especifique que o arquivo não deve ser compactado e adicione a biblioteca 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 Text Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
}

Etapa 2: executar inferência usando a 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);

Veja o código fonte para mais detalhes.

Execute inferência em Swift

Etapa 1: importar CocoaPods

Adicione o pod TensorFlowLiteTaskText no Podfile

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

Etapa 2: executar inferência usando a API

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

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

Veja o código fonte para mais detalhes.

Execute inferência em 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);

Veja o código fonte para mais detalhes.

Execute inferência em Python

Etapa 1: instale o pacote pip

pip install tflite-support

Etapa 2: usando o 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 o código-fonte para obter mais opções de configuração BertNLClassifier .

Resultados de exemplo

Aqui está um exemplo dos resultados de classificação de resenhas de filmes usando o modelo MobileBert do Model Maker.

Entrada: "é uma jornada encantadora e muitas vezes comovente"

Saída:

category[0]: 'negative' : '0.00006'
category[1]: 'positive' : '0.99994'

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

Requisitos de compatibilidade de modelo

A API BetNLClassifier espera um modelo TFLite com metadados de modelo TFLite obrigatórios.

Os metadados devem atender aos seguintes requisitos:

  • input_process_units para tokenizador de peça de palavra/frase

  • 3 tensores de entrada com nomes "ids", "mask" e "segment_ids" para a saída do tokenizer

  • 1 tensor de saída do tipo float32, com um arquivo de rótulo anexado opcionalmente. Se um arquivo de rótulo for anexado, o arquivo deverá ser um arquivo de texto simples com um rótulo por linha e o número de rótulos deverá corresponder ao número de categorias conforme o modelo produz.