O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Resolva tarefas de GLUE usando BERT em TPU

Ver no TensorFlow.org Executar no Google Colab Ver no GitHub Baixar caderno Veja o modelo TF Hub

O BERT pode ser usado para resolver muitos problemas no processamento de linguagem natural. Você vai aprender a BERT afinar para muitas tarefas da referência COLA :

  1. Cola (Corpus de linguística aceitabilidade): É a frase gramaticalmente correta?

  2. SST-2 (Stanford Sentiment Treebank): A tarefa é prever o sentimento de uma determinada frase.

  3. MRPC (Microsoft Research Paraphrase Corpus): Determinar se um par de frases são semanticamente equivalentes.

  4. QQP (Quora Pergunta Pairs2): Determinar se um par de perguntas são semanticamente equivalentes.

  5. MnlI (Multi-Gênero Natural Inference Language): Dada uma frase premissa e uma sentença hipótese, a tarefa é de prever se a premissa implica a hipótese (vinculação), contradiz a hipótese (contradição), ou nenhum (neutro).

  6. QNLI (Pergunta-respondendo Natural Inference Language): A tarefa é determinar se a sentença de contexto contém a resposta para a pergunta.

  7. RTE (Reconhecendo Prova Entailment): Determine se uma sentença implica uma dada hipótese ou não.

  8. WNLI (Winograd Natural Inference Language): A tarefa é prever se a frase com o pronome substituído é imposta pela sentença original.

Este tutorial contém código completo de ponta a ponta para treinar esses modelos em uma TPU. Você também pode executar este notebook em uma GPU, alterando uma linha (descrito abaixo).

Neste bloco de notas, você irá:

  • Carregue um modelo BERT do TensorFlow Hub
  • Escolha uma das tarefas do GLUE e baixe o conjunto de dados
  • Pré-processar o texto
  • BERT de ajuste fino (exemplos são dados para conjuntos de dados de uma ou várias frases)
  • Salve o modelo treinado e use-o

Configurar

Você usará um modelo separado para pré-processar o texto antes de usá-lo para ajustar o BERT. Este modelo depende tensorflow / texto , que você vai instalar abaixo.

pip install -q -U tensorflow-text

Você vai usar o otimizador AdamW de tensorflow / modelos para BERT ajuste fino, que você vai instalar também.

pip install -q -U tf-models-official
pip install -U tfds-nightly
import os
import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_datasets as tfds
import tensorflow_text as text  # A dependency of the preprocessing model
import tensorflow_addons as tfa
from official.nlp import optimization
import numpy as np

tf.get_logger().setLevel('ERROR')
/home/kbuilder/.local/lib/python3.6/site-packages/requests/__init__.py:104: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (2.3.0)/charset_normalizer (2.0.7) doesn't match a supported version!
  RequestsDependencyWarning)

Em seguida, configure o TFHub para ler os pontos de verificação diretamente dos intervalos do Cloud Storage do TFHub. Isso só é recomendado ao executar modelos TFHub na TPU.

Sem essa configuração, o TFHub baixaria o arquivo compactado e extrairia o ponto de verificação localmente. A tentativa de carregar a partir desses arquivos locais falhará com o seguinte erro:

InvalidArgumentError: Unimplemented: File system scheme '[local]' not implemented

Isso ocorre porque o TPU só pode ler diretamente de baldes Cloud Storage .

os.environ["TFHUB_MODEL_LOAD_FORMAT"]="UNCOMPRESSED"

Conecte-se ao trabalhador TPU

O código a seguir se conecta ao trabalhador da TPU e altera o dispositivo padrão do TensorFlow para o dispositivo da CPU no trabalhador da TPU. Ele também define uma estratégia de distribuição de TPU que você usará para distribuir o treinamento do modelo para os 8 núcleos de TPU separados disponíveis neste trabalhador de TPU. Veja de TensorFlow guia de TPU para mais informações.

import os

if os.environ['COLAB_TPU_ADDR']:
  cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
  tf.config.experimental_connect_to_cluster(cluster_resolver)
  tf.tpu.experimental.initialize_tpu_system(cluster_resolver)
  strategy = tf.distribute.TPUStrategy(cluster_resolver)
  print('Using TPU')
elif tf.config.list_physical_devices('GPU'):
  strategy = tf.distribute.MirroredStrategy()
  print('Using GPU')
else:
  raise ValueError('Running on CPU is not recommended.')
Using TPU

Carregando modelos do TensorFlow Hub

Aqui você pode escolher qual modelo BERT irá carregar do TensorFlow Hub e fazer o ajuste fino. Existem vários modelos BERT disponíveis para escolha.

  • Bert-base , uncased e mais sete modelos com pesos treinados liberados pelos autores BERT originais.
  • Pequenas BERTs ter a mesma arquitetura geral, mas em menor número e / ou blocos de transformadores menores, o que permite explorar melhor combinação entre velocidade, tamanho e qualidade.
  • ALBERT : quatro tamanhos diferentes de "A Lite BERT" que reduz o tamanho do modelo (mas não o tempo de computação) através da partilha de parâmetros entre as camadas.
  • BERT Especialistas : oito modelos que todos têm a arquitetura Bert-base, mas oferecem uma escolha entre domínios pré-formação diferentes, para alinhar mais estreitamente com a tarefa alvo.
  • Electra tem a mesma arquitetura como Bert (em três tamanhos diferentes), mas fica pré-treinado como um discriminador em um set-up que se assemelha a um Adversarial de rede Generative (GAN).
  • BERT com a falar-Cabeças atenção e fechado Gelu [ de base , grande ] tem duas melhorias para o núcleo da arquitetura Transformer.

Consulte a documentação do modelo no link acima para obter mais detalhes.

Neste tutorial, você começará com a base de BERT. Você pode usar modelos maiores e mais recentes para maior precisão ou modelos menores para tempos de treinamento mais rápidos. Para mudar o modelo, você só precisa mudar uma única linha de código (mostrado abaixo). Todas as diferenças estão encapsuladas no SavedModel, que você baixará do TensorFlow Hub.

Escolha um modelo de BERT para ajustar

BERT model selected           : https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3
Preprocessing model auto-selected: https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3

Pré-processar o texto

No texto Classifique com BERT CoLab o modelo de pré-processamento é usado diretamente incorporado com o codificador BERT.

Este tutorial demonstra como fazer o pré-processamento como parte do pipeline de entrada para treinamento, usando Dataset.map, e depois mesclá-lo no modelo que é exportado para inferência. Dessa forma, o treinamento e a inferência podem funcionar a partir de entradas de texto bruto, embora a própria TPU exija entradas numéricas.

Requisitos TPU lado, pode ajudar o desempenho tem pré-processamento feito de forma assíncrona em um gasoduto de entrada (você pode aprender mais na guia desempenho tf.data ).

Este tutorial também demonstra como construir modelos de múltiplas entradas e como ajustar o comprimento da sequência das entradas para BERT.

Vamos demonstrar o modelo de pré-processamento.

bert_preprocess = hub.load(tfhub_handle_preprocess)
tok = bert_preprocess.tokenize(tf.constant(['Hello TensorFlow!']))
print(tok)
<tf.RaggedTensor [[[7592], [23435, 12314], [999]]]>

Cada modelo de pré-processamento também fornece um método, .bert_pack_inputs(tensors, seq_length) , que recebe uma lista de símbolos (como tok acima) e um argumento comprimento de sequência. Isso empacota as entradas para criar um dicionário de tensores no formato esperado pelo modelo BERT.

text_preprocessed = bert_preprocess.bert_pack_inputs([tok, tok], tf.constant(20))

print('Shape Word Ids : ', text_preprocessed['input_word_ids'].shape)
print('Word Ids       : ', text_preprocessed['input_word_ids'][0, :16])
print('Shape Mask     : ', text_preprocessed['input_mask'].shape)
print('Input Mask     : ', text_preprocessed['input_mask'][0, :16])
print('Shape Type Ids : ', text_preprocessed['input_type_ids'].shape)
print('Type Ids       : ', text_preprocessed['input_type_ids'][0, :16])
Shape Word Ids :  (1, 20)
Word Ids       :  tf.Tensor(
[  101  7592 23435 12314   999   102  7592 23435 12314   999   102     0
     0     0     0     0], shape=(16,), dtype=int32)
Shape Mask     :  (1, 20)
Input Mask     :  tf.Tensor([1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0], shape=(16,), dtype=int32)
Shape Type Ids :  (1, 20)
Type Ids       :  tf.Tensor([0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0], shape=(16,), dtype=int32)

Aqui estão alguns detalhes para prestar atenção:

  • input_mask A máscara permite que o modelo para diferenciar corretamente entre o conteúdo eo preenchimento. A máscara tem a mesma forma que os input_word_ids , e contém um 1 em qualquer lugar as input_word_ids não é acolchoar.
  • input_type_ids tem a mesma forma que input_mask , mas dentro da região não acolchoada, contém um 0 ou um 1, indicando que a frase token é uma parte de.

A seguir, você criará um modelo de pré-processamento que encapsula toda essa lógica. Seu modelo receberá strings como entrada e retornará objetos formatados apropriadamente que podem ser passados ​​para o BERT.

Cada modelo de BERT possui um modelo de pré-processamento específico, certifique-se de utilizar o adequado descrito na documentação do modelo de BERT.

def make_bert_preprocess_model(sentence_features, seq_length=128):
  """Returns Model mapping string features to BERT inputs.

  Args:
    sentence_features: a list with the names of string-valued features.
    seq_length: an integer that defines the sequence length of BERT inputs.

  Returns:
    A Keras Model that can be called on a list or dict of string Tensors
    (with the order or names, resp., given by sentence_features) and
    returns a dict of tensors for input to BERT.
  """

  input_segments = [
      tf.keras.layers.Input(shape=(), dtype=tf.string, name=ft)
      for ft in sentence_features]

  # Tokenize the text to word pieces.
  bert_preprocess = hub.load(tfhub_handle_preprocess)
  tokenizer = hub.KerasLayer(bert_preprocess.tokenize, name='tokenizer')
  segments = [tokenizer(s) for s in input_segments]

  # Optional: Trim segments in a smart way to fit seq_length.
  # Simple cases (like this example) can skip this step and let
  # the next step apply a default truncation to approximately equal lengths.
  truncated_segments = segments

  # Pack inputs. The details (start/end token ids, dict of output tensors)
  # are model-dependent, so this gets loaded from the SavedModel.
  packer = hub.KerasLayer(bert_preprocess.bert_pack_inputs,
                          arguments=dict(seq_length=seq_length),
                          name='packer')
  model_inputs = packer(truncated_segments)
  return tf.keras.Model(input_segments, model_inputs)

Vamos demonstrar o modelo de pré-processamento. Você criará um teste com entrada de duas sentenças (entrada1 e entrada2). A saída é o que um modelo BERT seria de esperar como entrada: input_word_ids , input_masks e input_type_ids .

test_preprocess_model = make_bert_preprocess_model(['my_input1', 'my_input2'])
test_text = [np.array(['some random test sentence']),
             np.array(['another sentence'])]
text_preprocessed = test_preprocess_model(test_text)

print('Keys           : ', list(text_preprocessed.keys()))
print('Shape Word Ids : ', text_preprocessed['input_word_ids'].shape)
print('Word Ids       : ', text_preprocessed['input_word_ids'][0, :16])
print('Shape Mask     : ', text_preprocessed['input_mask'].shape)
print('Input Mask     : ', text_preprocessed['input_mask'][0, :16])
print('Shape Type Ids : ', text_preprocessed['input_type_ids'].shape)
print('Type Ids       : ', text_preprocessed['input_type_ids'][0, :16])
Keys           :  ['input_type_ids', 'input_mask', 'input_word_ids']
Shape Word Ids :  (1, 128)
Word Ids       :  tf.Tensor(
[ 101 2070 6721 3231 6251  102 2178 6251  102    0    0    0    0    0
    0    0], shape=(16,), dtype=int32)
Shape Mask     :  (1, 128)
Input Mask     :  tf.Tensor([1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0], shape=(16,), dtype=int32)
Shape Type Ids :  (1, 128)
Type Ids       :  tf.Tensor([0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0], shape=(16,), dtype=int32)

Vamos dar uma olhada na estrutura do modelo, prestando atenção nas duas entradas que você acabou de definir.

tf.keras.utils.plot_model(test_preprocess_model, show_shapes=True, show_dtype=True)
('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.')

Para aplicar o pré-processamento em todas as entradas do conjunto de dados, você vai usar o map função do conjunto de dados. O resultado é então armazenado em cache para o desempenho .

AUTOTUNE = tf.data.AUTOTUNE


def load_dataset_from_tfds(in_memory_ds, info, split, batch_size,
                           bert_preprocess_model):
  is_training = split.startswith('train')
  dataset = tf.data.Dataset.from_tensor_slices(in_memory_ds[split])
  num_examples = info.splits[split].num_examples

  if is_training:
    dataset = dataset.shuffle(num_examples)
    dataset = dataset.repeat()
  dataset = dataset.batch(batch_size)
  dataset = dataset.map(lambda ex: (bert_preprocess_model(ex), ex['label']))
  dataset = dataset.cache().prefetch(buffer_size=AUTOTUNE)
  return dataset, num_examples

Defina o seu modelo

Agora você está pronto para definir seu modelo de frase ou classificação de par de frases alimentando as entradas pré-processadas por meio do codificador BERT e colocando um classificador linear no topo (ou outro arranjo de camadas de sua preferência) e usando dropout para regularização.

def build_classifier_model(num_classes):

  class Classifier(tf.keras.Model):
    def __init__(self, num_classes):
      super(Classifier, self).__init__(name="prediction")
      self.encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True)
      self.dropout = tf.keras.layers.Dropout(0.1)
      self.dense = tf.keras.layers.Dense(num_classes)

    def call(self, preprocessed_text):
      encoder_outputs = self.encoder(preprocessed_text)
      pooled_output = encoder_outputs["pooled_output"]
      x = self.dropout(pooled_output)
      x = self.dense(x)
      return x

  model = Classifier(num_classes)
  return model

Vamos tentar executar o modelo em algumas entradas pré-processadas.

test_classifier_model = build_classifier_model(2)
bert_raw_result = test_classifier_model(text_preprocessed)
print(tf.sigmoid(bert_raw_result))
tf.Tensor([[0.30604815 0.75996256]], shape=(1, 2), dtype=float32)

Escolha uma tarefa da GLUE

Você está indo para usar um TensorFlow DataSet do COLA suíte benchmark.

O Colab permite que você baixe esses pequenos conjuntos de dados para o sistema de arquivos local, e o código a seguir lê-os inteiramente na memória, porque o host do trabalhador TPU separado não pode acessar o sistema de arquivos local do tempo de execução do colab.

Para conjuntos de dados maiores, você vai precisar para criar o seu próprio Google Cloud Storage balde e tem o trabalhador TPU ler os dados de lá. Você pode aprender mais no guia de TPU .

Recomenda-se começar com o conjunto de dados CoLa (para uma frase) ou MRPC (para várias frases), pois são pequenos e não demoram muito para serem ajustados.

Using glue/cola from TFDS
This dataset has 10657 examples
Number of classes: 2
Features ['sentence']
Splits ['train', 'validation', 'test']
Here are some sample rows from glue/cola dataset
['unacceptable', 'acceptable']

sample row 1
b'It is this hat that it is certain that he was wearing.'
label: 1 (acceptable)

sample row 2
b'Her efficient looking up of the answer pleased the boss.'
label: 1 (acceptable)

sample row 3
b'Both the workers will wear carnations.'
label: 1 (acceptable)

sample row 4
b'John enjoyed drawing trees for his syntax homework.'
label: 1 (acceptable)

sample row 5
b'We consider Leslie rather foolish, and Lou a complete idiot.'
label: 1 (acceptable)

O conjunto de dados também determina o tipo de problema (classificação ou regressão) e a função de perda apropriada para o treinamento.

def get_configuration(glue_task):

  loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  if glue_task == 'glue/cola':
    metrics = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=2)
  else:
    metrics = tf.keras.metrics.SparseCategoricalAccuracy(
        'accuracy', dtype=tf.float32)

  return metrics, loss

Treine seu modelo

Por fim, você pode treinar o modelo de ponta a ponta no conjunto de dados escolhido.

Distribuição

Lembre-se do código de configuração na parte superior, que conectou o tempo de execução do colab a um trabalhador de TPU com vários dispositivos de TPU. Para distribuir o treinamento para eles, você criará e compilará seu modelo Keras principal dentro do escopo da estratégia de distribuição de TPU. (Para mais detalhes, consulte Distributed formação com Keras .)

O pré-processamento, por outro lado, é executado na CPU do host worker, não nas TPUs, portanto, o modelo Keras para pré-processamento, bem como os conjuntos de dados de treinamento e validação mapeados com ele, são criados fora do escopo da estratégia de distribuição. A chamada para Model.fit() vai cuidar de distribuir o passado-no conjunto de dados para o modelo de réplicas.

Otimizador

Ajuste fino segue o set-up otimizador de BERT pré-formação (como no texto Classifique com BERT ): Ele usa o otimizador AdamW com um decaimento linear de uma taxa inicial de aprendizado teórico, prefixado com uma fase de aquecimento linear em relação ao primeiro 10% das etapas de formação ( num_warmup_steps ). De acordo com o artigo de BERT, a taxa de aprendizado inicial é menor para o ajuste fino (melhor de 5e-5, 3e-5, 2e-5).

epochs = 3
batch_size = 32
init_lr = 2e-5

print(f'Fine tuning {tfhub_handle_encoder} model')
bert_preprocess_model = make_bert_preprocess_model(sentence_features)

with strategy.scope():

  # metric have to be created inside the strategy scope
  metrics, loss = get_configuration(tfds_name)

  train_dataset, train_data_size = load_dataset_from_tfds(
      in_memory_ds, tfds_info, train_split, batch_size, bert_preprocess_model)
  steps_per_epoch = train_data_size // batch_size
  num_train_steps = steps_per_epoch * epochs
  num_warmup_steps = num_train_steps // 10

  validation_dataset, validation_data_size = load_dataset_from_tfds(
      in_memory_ds, tfds_info, validation_split, batch_size,
      bert_preprocess_model)
  validation_steps = validation_data_size // batch_size

  classifier_model = build_classifier_model(num_classes)

  optimizer = optimization.create_optimizer(
      init_lr=init_lr,
      num_train_steps=num_train_steps,
      num_warmup_steps=num_warmup_steps,
      optimizer_type='adamw')

  classifier_model.compile(optimizer=optimizer, loss=loss, metrics=[metrics])

  classifier_model.fit(
      x=train_dataset,
      validation_data=validation_dataset,
      steps_per_epoch=steps_per_epoch,
      epochs=epochs,
      validation_steps=validation_steps)
Fine tuning https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3 model
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/keras/engine/functional.py:585: UserWarning: Input dict contained keys ['idx', 'label'] which did not match any model input. They will be ignored by the model.
  [n for n in tensors.keys() if n not in ref_input_names])
Epoch 1/3
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/framework/indexed_slices.py:449: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor("AdamWeightDecay/gradients/StatefulPartitionedCall:1", shape=(None,), dtype=int32), values=Tensor("clip_by_global_norm/clip_by_global_norm/_0:0", dtype=float32), dense_shape=Tensor("AdamWeightDecay/gradients/StatefulPartitionedCall:2", shape=(None,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.
  "shape. This may consume a large amount of memory." % value)
267/267 [==============================] - 88s 80ms/step - loss: 0.6160 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.4583 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 2/3
267/267 [==============================] - 14s 53ms/step - loss: 0.3523 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.4945 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 3/3
267/267 [==============================] - 14s 53ms/step - loss: 0.2440 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.6435 - val_MatthewsCorrelationCoefficient: 0.0000e+00

Exportar para inferência

Você criará um modelo final que possui a parte de pré-processamento e o BERT ajustado que acabamos de criar.

No momento da inferência, o pré-processamento precisa fazer parte do modelo (porque não há mais uma fila de entrada separada para os dados de treinamento que o fazem). O pré-processamento não é apenas computação; ele tem seus próprios recursos (a tabela de vocabulário) que devem ser anexados ao modelo Keras que é salvo para exportação. Essa montagem final é o que será salvo.

Você está indo para salvar o modelo em colab e mais tarde você pode baixar para mantê-lo para o futuro (Visão -> Índice -> Files).

main_save_path = './my_models'
bert_type = tfhub_handle_encoder.split('/')[-2]
saved_model_name = f'{tfds_name.replace("/", "_")}_{bert_type}'

saved_model_path = os.path.join(main_save_path, saved_model_name)

preprocess_inputs = bert_preprocess_model.inputs
bert_encoder_inputs = bert_preprocess_model(preprocess_inputs)
bert_outputs = classifier_model(bert_encoder_inputs)
model_for_export = tf.keras.Model(preprocess_inputs, bert_outputs)

print('Saving', saved_model_path)

# Save everything on the Colab host (even the variables from TPU memory)
save_options = tf.saved_model.SaveOptions(experimental_io_device='/job:localhost')
model_for_export.save(saved_model_path, include_optimizer=False,
                      options=save_options)
Saving ./my_models/glue_cola_bert_en_uncased_L-12_H-768_A-12
WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 910). These functions will not be directly callable after loading.

Teste o modelo

A etapa final é testar os resultados do modelo exportado.

Apenas para fazer uma comparação, vamos recarregar o modelo e testá-lo usando algumas entradas da divisão de teste do conjunto de dados.

with tf.device('/job:localhost'):
  reloaded_model = tf.saved_model.load(saved_model_path)

Métodos utilitários

Teste

with tf.device('/job:localhost'):
  test_dataset = tf.data.Dataset.from_tensor_slices(in_memory_ds[test_split])
  for test_row in test_dataset.shuffle(1000).map(prepare).take(5):
    if len(sentence_features) == 1:
      result = reloaded_model(test_row[0])
    else:
      result = reloaded_model(list(test_row))

    print_bert_results(test_row, result, tfds_name)
sentence: [b'That the Giants lost the series sucks.']
This sentence is acceptable
BERT raw results: tf.Tensor([-3.119716   1.8645784], shape=(2,), dtype=float32)

sentence: [b'The chair abuts the wall.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.361659  2.4861  ], shape=(2,), dtype=float32)

sentence: [b'Mary runs not the marathon.']
This sentence is unacceptable
BERT raw results: tf.Tensor([ 2.5620868 -1.5487652], shape=(2,), dtype=float32)

sentence: [b'John made Bill be mad at himself.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.3180927  1.946092 ], shape=(2,), dtype=float32)

sentence: [b'The car honked its way down the road.']
This sentence is acceptable
BERT raw results: tf.Tensor([-3.1917076  1.9977642], shape=(2,), dtype=float32)

Se você quiser usar o seu modelo na TF Dose , lembre-se que ele irá chamar o seu SavedModel através de uma das suas assinaturas nomeados. Observe que há algumas pequenas diferenças na entrada. Em Python, você pode testá-los da seguinte maneira:

with tf.device('/job:localhost'):
  serving_model = reloaded_model.signatures['serving_default']
  for test_row in test_dataset.shuffle(1000).map(prepare_serving).take(5):
    result = serving_model(**test_row)
    # The 'prediction' key is the classifier's defined model name.
    print_bert_results(list(test_row.values()), result['prediction'], tfds_name)
sentence: b'Alison poked at the cloth.'
This sentence is acceptable
BERT raw results: tf.Tensor([-3.528609   1.5976582], shape=(2,), dtype=float32)

sentence: b"Jenny hasn't eaten all her Clinique make-up again, has she?"
This sentence is acceptable
BERT raw results: tf.Tensor([-2.7757154  1.8673844], shape=(2,), dtype=float32)

sentence: b'I am anxious you to study English grammar hard.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 2.1782281 -1.4177405], shape=(2,), dtype=float32)

sentence: b'the putter of books on the table left.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 1.1711266 -1.1128566], shape=(2,), dtype=float32)

sentence: b'John said that Heidi was obsessed with broccoli.'
This sentence is acceptable
BERT raw results: tf.Tensor([-2.2336094  2.6760008], shape=(2,), dtype=float32)

Você fez isso! Seu modelo salvo pode ser usado para servir ou inferência simples em um processo, com uma API mais simples com menos código e mais fácil de manter.

Próximos passos

Agora que você experimentou um dos modelos básicos de BERT, pode experimentar outros para obter mais precisão ou talvez com versões de modelo menores.

Você também pode tentar em outros conjuntos de dados.