Résolvez les tâches GLUE à l'aide de BERT sur TPU

Voir sur TensorFlow.org Exécuter dans Google Colab Voir sur GitHub Télécharger le cahier Voir le modèle TF Hub

BERT peut être utilisé pour résoudre de nombreux problèmes de traitement du langage naturel. Vous apprendrez à BERT-tune bien pour de nombreuses tâches de l' indice de référence de COLLE :

  1. COLA (Corpus de Acceptabilité linguistique): La phrase grammaticalement correcte?

  2. SST-2 (Stanford Treebank Sentiment): La tâche est de prédire le sentiment d'une phrase donnée.

  3. MRPC (Microsoft Research paraphrase Corpus): Déterminer si une paire de phrases sont sémantiquement équivalentes.

  4. QQP (Quora Question Pairs2): Déterminer si une paire de questions sont sémantiquement équivalentes.

  5. Mnll (Multi-Genre Langue naturelle Inference): Étant donné une peine de principe et une phrase d'hypothèse, la tâche est de prédire si la prémisse implique l'hypothèse (entailment), contredit l'hypothèse (contradiction), ou ni (neutre).

  6. QNLI (question-réponse du langage naturel Inference): La tâche est de déterminer si la peine de contexte contient la réponse à la question.

  7. RTE (reconnaissance Implication textuels): Déterminer si une phrase implique une hypothèse donnée ou non.

  8. WNLI (Winograd Natural Language Inference): La tâche est de prédire si par la phrase d' origine est impliqué la phrase avec le pronom substitué.

Ce tutoriel contient un code complet de bout en bout pour entraîner ces modèles sur un TPU. Vous pouvez également exécuter ce notebook sur un GPU, en modifiant une ligne (décrit ci-dessous).

Dans ce cahier, vous allez :

  • Charger un modèle BERT à partir de TensorFlow Hub
  • Choisissez l'une des tâches GLUE et téléchargez l'ensemble de données
  • Prétraiter le texte
  • Ajustez le BERT (des exemples sont donnés pour des ensembles de données à une seule phrase et à plusieurs phrases)
  • Enregistrez le modèle entraîné et utilisez-le

Installer

Vous utiliserez un modèle distinct pour prétraiter le texte avant de l'utiliser pour affiner BERT. Ce modèle dépend de tensorflow / texte , que vous installerez ci - dessous.

pip install -q -U tensorflow-text

Vous utiliserez l'optimiseur de AdamW tensorflow / modèles à BERT-tune fine, que vous installerez ainsi.

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')

/tmpfs/src/tf_docs_env/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)

Ensuite, configurez TFHub pour lire les points de contrôle directement à partir des buckets Cloud Storage de TFHub. Ceci n'est recommandé que lors de l'exécution de modèles TFHub sur TPU.

Sans ce paramètre, TFHub téléchargerait le fichier compressé et extrairait le point de contrôle localement. La tentative de chargement à partir de ces fichiers locaux échouera avec l'erreur suivante :

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

En effet , le TPU ne peut lire directement des seaux Cloud Storage .

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

Se connecter au nœud de calcul TPU

Le code suivant se connecte au nœud de calcul TPU et remplace l'appareil par défaut de TensorFlow par le périphérique CPU sur le nœud de calcul TPU. Il définit également une stratégie de distribution TPU que vous utiliserez pour distribuer la formation de modèle sur les 8 cœurs TPU distincts disponibles sur ce seul travailleur TPU. Voir tensorflow de guide TPU pour plus d' informations.

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

Chargement de modèles depuis TensorFlow Hub

Ici, vous pouvez choisir le modèle BERT que vous allez charger à partir de TensorFlow Hub et le régler avec précision. Vous avez le choix entre plusieurs modèles BERT.

  • BERT-Base , non tubé et sept autres modèles avec des poids formés libérés par les auteurs de l' ORET d' origine.
  • Les petits BERT ont la même architecture générale mais moins et / ou petits blocs transformateurs, qui vous permet d' explorer des compromis entre la vitesse, la taille et la qualité.
  • ALBERT : quatre tailles différentes de « Un Lite BERT » qui réduit la taille du modèle (mais pas le temps de calcul) en partageant les paramètres entre les couches.
  • BERT experts : huit modèles qui ont tous l'architecture de base BERT , mais offrent un choix entre les différents domaines pré-formation, afin d' aligner plus étroitement avec la tâche cible.
  • Electra a la même architecture que BERT (en trois tailles différentes), mais obtient une pré-formation comme un discriminateur dans un set-up qui ressemble à un réseau générative accusatoire (de GAN).
  • BERT avec attention Talking Heads-et Gated GELU [ la base , grande ] a deux améliorations au cœur de l'architecture Transformer.

Voir la documentation du modèle liée ci-dessus pour plus de détails.

Dans ce tutoriel, vous commencerez avec BERT-base. Vous pouvez utiliser des modèles plus grands et plus récents pour une plus grande précision, ou des modèles plus petits pour des temps d'entraînement plus rapides. Pour changer de modèle, il vous suffit de changer une seule ligne de code (illustré ci-dessous). Toutes les différences sont encapsulées dans le SavedModel que vous téléchargerez à partir de TensorFlow Hub.

Choisissez un modèle BERT pour affiner

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étraiter le texte

Sur le texte Classifier avec BERT colab le modèle de pré - traitement est utilisé directement intégré avec l'encodeur BERT.

Ce didacticiel montre comment effectuer un prétraitement dans le cadre de votre pipeline d'entrée pour la formation, à l'aide de Dataset.map, puis le fusionner dans le modèle qui est exporté pour l'inférence. De cette façon, l'entraînement et l'inférence peuvent fonctionner à partir d'entrées de texte brut, bien que le TPU lui-même nécessite des entrées numériques.

Exigences TPU de côté, il peut améliorer les performances ont fait pré - traitement dans un pipeline de manière asynchrone d'entrée (vous pouvez en savoir plus dans le guide de performance tf.data ).

Ce didacticiel montre également comment créer des modèles à entrées multiples et comment ajuster la longueur de séquence des entrées vers BERT.

Démontrons le modèle de prétraitement.

bert_preprocess = hub.load(tfhub_handle_preprocess)
tok = bert_preprocess.tokenize(tf.constant(['Hello TensorFlow!']))
print(tok)

<tf.RaggedTensor [[[7592], [23435, 12314], [999]]]>

Chaque modèle de prétraitement fournit également un procédé, .bert_pack_inputs(tensors, seq_length) , qui prend une liste de jetons (comme tok ci - dessus) et un argument de longueur de séquence. Cela regroupe les entrées pour créer un dictionnaire de tenseurs au format attendu par le modèle 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)

Voici quelques détails auxquels faire attention :

  • input_mask Le masque permet au modèle de différencier nettement entre le contenu et le rembourrage. Le masque a la même forme que les input_word_ids , et contient un 1 où les input_word_ids ne sont pas rembourrage.
  • input_type_ids a la même forme que input_mask , mais à l' intérieur de la région non rembourré, contient un 0 ou un 1 indiquant quelle phrase le jeton est une partie de.

Ensuite, vous allez créer un modèle de prétraitement qui encapsule toute cette logique. Votre modèle prendra des chaînes en entrée et renverra des objets formatés de manière appropriée qui peuvent être transmis à BERT.

Chaque modèle BERT a un modèle de prétraitement spécifique, assurez-vous d'utiliser le modèle approprié décrit dans la documentation du modèle 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)

Démontrons le modèle de prétraitement. Vous allez créer un test avec deux phrases d'entrée (input1 et input2). La sortie est ce qu'un modèle de ORET attendre en entrée: input_word_ids , input_masks et 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_word_ids', 'input_mask', 'input_type_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)

Jetons un coup d'œil à la structure du modèle, en faisant attention aux deux entrées que vous venez de définir.

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.')

Pour appliquer le pré - traitement dans toutes les entrées de l'ensemble de données, vous utiliserez la map fonction de l'ensemble de données. Le résultat est ensuite mis en mémoire cache pour la performance .

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

Définir votre modèle

Vous êtes maintenant prêt à définir votre modèle de classification de phrases ou de paires de phrases en alimentant les entrées prétraitées via l'encodeur BERT et en plaçant un classificateur linéaire au-dessus (ou un autre arrangement de couches selon vos préférences) et en utilisant l'abandon pour la régularisation.

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

Essayons d'exécuter le modèle sur certaines entrées prétraitées.

test_classifier_model = build_classifier_model(2)
bert_raw_result = test_classifier_model(text_preprocessed)
print(tf.sigmoid(bert_raw_result))

tf.Tensor([[0.29329836 0.44367802]], shape=(1, 2), dtype=float32)

Choisissez une tâche dans GLUE

Vous allez utiliser un DataSet tensorflow de la COLLE suite de référence.

Colab vous permet de télécharger ces petits ensembles de données sur le système de fichiers local, et le code ci-dessous les lit entièrement en mémoire, car l'hôte de travail TPU distinct ne peut pas accéder au système de fichiers local de l'environnement d'exécution de colab.

Pour les plus grands ensembles de données, vous devrez créer votre propre Google Cloud Storage seau et avoir le travailleur TPU lire les données à partir de là. Vous pouvez en savoir plus dans le guide de TPU .

Il est recommandé de commencer avec l'ensemble de données CoLa (pour une seule phrase) ou MRPC (pour plusieurs phrases) car ils sont petits et ne prennent pas longtemps à affiner.

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)

L'ensemble de données détermine également le type de problème (classification ou régression) et la fonction de perte appropriée pour la formation.

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

Entraînez votre modèle

Enfin, vous pouvez entraîner le modèle de bout en bout sur l'ensemble de données que vous avez choisi.

Distribution

Rappelez-vous le code de configuration en haut, qui a connecté l'environnement d'exécution Colab à un nœud de calcul TPU avec plusieurs appareils TPU. Pour leur distribuer la formation, vous allez créer et compiler votre modèle Keras principal dans le cadre de la stratégie de distribution de TPU. (Pour plus de détails, voir la formation distribuée avec Keras .)

Le prétraitement, en revanche, s'exécute sur le processeur de l'hôte de travail, et non sur les TPU, de sorte que le modèle Keras pour le prétraitement ainsi que les ensembles de données d'entraînement et de validation mappés avec celui-ci sont construits en dehors de la portée de la stratégie de distribution. L'appel à Model.fit() se chargera de distribuer le passé en jeu de données aux répliques du modèle.

Optimiseur

Réglage fin suit la mise en place optimiseur de BERT pré-formation (comme dans le texte Classifier avec BERT ): Il utilise l'optimiseur AdamW avec une décroissance linéaire d'un taux d'apprentissage théorique initiale, préfixé avec une phase d' échauffement linéaire sur la première 10% des étapes de formation ( num_warmup_steps ). Conformément à l'article du BERT, le taux d'apprentissage initial est plus faible pour le réglage fin (le meilleur 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 [==============================] - 86s 81ms/step - loss: 0.6092 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.4846 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 2/3
267/267 [==============================] - 14s 53ms/step - loss: 0.3774 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.5322 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 3/3
267/267 [==============================] - 14s 53ms/step - loss: 0.2623 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.6469 - val_MatthewsCorrelationCoefficient: 0.0000e+00

Exporter pour inférence

Vous allez créer un modèle final contenant la partie de prétraitement et le BERT affiné que nous venons de créer.

Au moment de l'inférence, le prétraitement doit faire partie du modèle (car il n'y a plus de file d'attente d'entrée distincte comme pour les données d'apprentissage qui le fait). Le prétraitement n'est pas seulement du calcul ; il a ses propres ressources (la table de vocabulaire) qui doivent être attachées au modèle Keras qui est enregistré pour l'exportation. C'est cet assemblage final qui sera sauvé.

Vous allez enregistrer le modèle sur colab et plus tard , vous pouvez télécharger le garder pour l'avenir (Affichage -> Table des matières -> Fichiers).

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.

Tester le modèle

La dernière étape consiste à tester les résultats de votre modèle exporté.

Juste pour faire une comparaison, rechargeons le modèle et testons-le en utilisant quelques entrées du test fractionné de l'ensemble de données.

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

Méthodes utilitaires

Test

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'An old woman languished in the forest.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.7032353  3.3714833], shape=(2,), dtype=float32)

sentence: [b"I went to the movies and didn't pick up the shirts."]
This sentence is acceptable
BERT raw results: tf.Tensor([-0.73970896  1.0806316 ], shape=(2,), dtype=float32)

sentence: [b"Every essay that she's written and which I've read is on that pile."]
This sentence is acceptable
BERT raw results: tf.Tensor([-0.7034159  0.6236454], shape=(2,), dtype=float32)

sentence: [b'Either Bill ate the peaches, or Harry.']
This sentence is unacceptable
BERT raw results: tf.Tensor([ 0.05972151 -0.08620442], shape=(2,), dtype=float32)

sentence: [b'I ran into the baker from whom I bought these bagels.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6862067  3.285925 ], shape=(2,), dtype=float32)

Si vous souhaitez utiliser votre modèle sur Serving TF , rappelez - vous qu'il appellera votre SavedModel par l' une de ses signatures nommées. Notez qu'il y a quelques petites différences dans l'entrée. En Python, vous pouvez les tester comme suit :

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'Everyone attended more than two seminars.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.5594155  2.862155 ], shape=(2,), dtype=float32)

sentence: b'Most columnists claim that a senior White House official has been briefing them.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6298996  3.3155093], shape=(2,), dtype=float32)

sentence: b"That my father, he's lived here all his life is well known to those cops."
This sentence is acceptable
BERT raw results: tf.Tensor([-1.2048947  1.8589772], shape=(2,), dtype=float32)

sentence: b'Ourselves like us.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.2723312  2.0494034], shape=(2,), dtype=float32)

sentence: b'John is clever.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6516167  3.3147635], shape=(2,), dtype=float32)

Tu l'as fait! Votre modèle enregistré pourrait être utilisé pour la diffusion ou l'inférence simple dans un processus, avec une API plus simple avec moins de code et plus facile à maintenir.

Prochaines étapes

Maintenant que vous avez essayé l'un des modèles BERT de base, vous pouvez en essayer d'autres pour obtenir plus de précision ou peut-être avec des versions de modèle plus petites.

Vous pouvez également essayer dans d'autres ensembles de données.