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 essa API é especialmente adaptada para modelos relacionados ao Bert que exigem tokenizações Wordpiece e Sentencepiece fora do modelo TFLite.

Principais recursos da API BertNLClassifier

  • Recebe uma única string como entrada, executa a classificação com a string e as saídas pares como resultados de classificação.

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

Modelos BertNLClassifier compatíveis

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

Executar inferência em Java

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

Copie o arquivo de modelo .tflite para o diretório assets 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.3.0'
}

Etapa 2: execute a 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);

Consulte o código-fonte para obter mais detalhes.

Executar inferência no Swift

Etapa 1: importar CocoaPods

Adicionar o pod TensorFlowLiteTaskText no Podfile

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

Etapa 2: execute a inferência usando a API

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

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

Consulte o código-fonte para obter mais detalhes.

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

Consulte o código-fonte para obter mais detalhes.

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 viagem 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 do 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 Wordpiece/Sentencepiece Tokenizer

  • 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 opcionalmente anexado. Se um arquivo de etiqueta estiver anexado, o arquivo deve ser um arquivo de texto simples com uma etiqueta por linha e o número de etiquetas deve corresponder ao número de categorias conforme as saídas do modelo.