Integrar o classificador de linguagem natural BERT

A API Task Library BertNLClassifier é muito semelhante à NLClassifier. que classifica o texto de entrada em diferentes categorias, com a diferença de que esta API especialmente sob medida para modelos relacionados ao Bert que exigem WordPeças e Tokenizações de frases-chave fora do modelo TFLite.

Principais recursos da API BertNLClassifier

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

• Executa o Wordnote fora do gráfico ou Frase de destaque tokenizações no texto de entrada.

Modelos BertNLClassifier com suporte

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

• Modelos Bert criados pelo TensorFlow Lite Model Maker para texto classificação.

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

Executar inferência em Java

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 Text Library dependency
    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);

Consulte a fonte código para mais detalhes.

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
let bertNLClassifier = TFLBertNLClassifier.bertNLClassifier(
      modelPath: bertModelPath)

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

Consulte a fonte código para 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 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.BertNLClassifier.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 BertNLClassifier.

Resultados de exemplo

Aqui está um exemplo dos resultados da classificação de críticas de filmes usando o MobileBert do Model Maker.

Entrada: "É uma jornada encantadora e que muitas vezes afeta"

Saída:

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

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

Requisitos de compatibilidade do modelo

A API BetNLClassifier espera um modelo TFLite com o modelo TFLite obrigatório Metadados.

Os metadados devem atender aos seguintes requisitos:

• input_process_units para o tokenizador do Wordnote/Sentencenote

• 3 tensores de entrada com os nomes "ids", "mask" e "segment_ids" para a saída de o tokenizador

• 1 tensor de saída do tipo float32, com um arquivo de rótulo opcionalmente anexado. Se um arquivo de rótulo estiver anexado, ele 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 das saídas do modelo.