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
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
.
Bert Models 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
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 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 (NNAPI is included)
implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.4'
}
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.4.4'
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.
Executar 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 para configurar 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 viagem encantadora e muitas vezes comovente"
Resultado:
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.