TPU'da BERT kullanarak TUTKAL görevlerini çözün

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın GitHub'da görüntüle Not defterini indir TF Hub modeline bakın

BERT, doğal dil işlemedeki birçok sorunu çözmek için kullanılabilir. Sen nasıl birçok görevler için ince ayar bert öğrenecektir YAPIŞTIRICI kriter :

  1. Cola (Dil Kabul Edilebilirlik Corpus): cümle dilbilgisi açısından doğru mu?

  2. SST-2 (Stanford Duygu Treebank): Görev verilen bir cümlenin duyguları tahmin etmektir.

  3. MRPC (Microsoft Research açımlanması Corpus): cümlelerin bir çift anlama sahip olmadığını belirleyin.

  4. QQP (Quora Soru Pairs2): sorular bir çift anlama sahip olmadığını belirleyin.

  5. MNLI (Çok Tür Doğal Dil Çıkarım): Bir öncül tümce ve hipotez cümle dikkate alındığında, görev, öncül hipotezi (Vasiyetiniz) yapılıp yapılmayacağı tahmin etmektir hipotezi (çelişki) çelişmektedir veya hiçbiri (nötr).

  6. QNLI (Doğal Dil Çıkarım, soru-cevap): Görev bağlam cümle sorunun cevabını içerip içermediğini belirlemek etmektir.

  7. RTE (Metin Vasiyetiniz tanınması): Bir cümle belli bir hipotezi gerektirir olmadığını belirler.

  8. WNLI (Winograd Doğal Dil Çıkarım): Görev ikame zamiri cümle orijinal cümle gerektirdiği takdirde tahmin etmektir.

Bu öğretici, bu modelleri bir TPU üzerinde eğitmek için eksiksiz bir uçtan uca kod içerir. Bu not defterini bir satırı değiştirerek (aşağıda açıklanmıştır) bir GPU üzerinde de çalıştırabilirsiniz.

Bu defterde şunları yapacaksınız:

  • TensorFlow Hub'dan bir BERT modeli yükleyin
  • GLUE görevlerinden birini seçin ve veri kümesini indirin
  • Metni ön işleme
  • İnce ayar BERT (tek cümle ve çok cümle veri kümeleri için örnekler verilmiştir)
  • Eğitilmiş modeli kaydedin ve kullanın

Kurmak

BERT'de ince ayar yapmak için kullanmadan önce metni önceden işlemek için ayrı bir model kullanacaksınız. Bu model bağlıdır tensorflow / metin aşağıda kuracaktır.

pip install -q -U tensorflow-text

Sen den AdamW optimize edici kullanacak tensorflow / modeller size sıra kuracaktır ince ayar Bert için.

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.6) or chardet (2.3.0)/charset_normalizer (2.0.4) doesn't match a supported version!
  RequestsDependencyWarning)

Ardından, kontrol noktalarını doğrudan TFHub'ın Bulut Depolama paketlerinden okumak için TFHub'ı yapılandırın. Bu, yalnızca TPU'da TFHub modellerini çalıştırırken önerilir.

Bu ayar olmadan TFHub, sıkıştırılmış dosyayı indirir ve kontrol noktasını yerel olarak çıkarır. Bu yerel dosyalardan yüklemeye çalışmak aşağıdaki hatayla başarısız olur:

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

Bunun nedeni TPU yalnızca Bulut Depolama kovalar doğrudan okuyabilir .

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

TPU çalışanına bağlanın

Aşağıdaki kod TPU çalışanına bağlanır ve TensorFlow'un varsayılan aygıtını TPU çalışanı üzerindeki CPU aygıtına değiştirir. Ayrıca, model eğitimini bu TPU çalışanında bulunan 8 ayrı TPU çekirdeğine dağıtmak için kullanacağınız bir TPU dağıtım stratejisini tanımlar. TensorFlow en Bkz TPU kılavuzu Daha fazla bilgi için.

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.test.is_gpu_available():
  strategy = tf.distribute.MirroredStrategy()
  print('Using GPU')
else:
  raise ValueError('Running on CPU is not recommended.')
Using TPU

TensorFlow Hub'dan model yükleme

Burada TensorFlow Hub'dan hangi BERT modelini yükleyeceğinizi seçebilir ve ince ayar yapabilirsiniz. Aralarından seçim yapabileceğiniz birden fazla BERT modeli vardır.

  • Bert-Baz , kılıfsız ve yedi fazla model orijinal Bert yazarlar tarafından yayımlanan eğitilmiş ağırlıklarla.
  • Küçük Yolcu Yatak hız, boyut ve kalite arasında seçim yapmak keşfetmenize olanak tanır aynı genel mimarisini ancak daha az ve / veya daha küçük Trafo blokları var.
  • ALBERT : katmanları arasında parametreleri paylaşarak modeli boyutunu (ancak hesaplama süresi) azaltır "Bir Lite bert" dört farklı boyutları.
  • Bert Uzmanlar : sekiz modeller tüm bu Bert-baz mimariye sahip ancak hedef görev ile daha yakından uyum sağlamak, farklı antrenman öncesi etki alanı arasında bir seçenek sunuyoruz.
  • Electra (üç farklı boyutta) bert ile aynı mimariye sahiptir, ancak bir dizi çekim bir ayırım düzeni olarak önceden eğitilmiş olur andıran bir Üretken olarak rakip Ağı (GAN).
  • Konuşan-Başlıkları Dikkat ve geçitli gelu [ile Bert tabanı , geniş ] Transformatör mimarisinin çekirdek iki iyileştirmeler bulunur.

Daha fazla ayrıntı için yukarıda bağlantılı model belgelerine bakın.

Bu eğitimde, BERT-base ile başlayacaksınız. Daha yüksek doğruluk için daha büyük ve daha yeni modelleri veya daha hızlı eğitim süreleri için daha küçük modelleri kullanabilirsiniz. Modeli değiştirmek için tek bir kod satırını değiştirmeniz yeterlidir (aşağıda gösterilmiştir). Tüm farklılıklar, TensorFlow Hub'dan indireceğiniz SavedModel'de özetlenmiştir.

İnce ayar yapmak için bir BERT modeli seçin

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

Metni ön işleme

On bert ile sınıflandırır metin CoLab ön işleme modeli doğrudan Bert kodlayıcı ile gömülü işlemi için kullanılır.

Bu öğretici, Dataset.map kullanarak eğitim için giriş işlem hattınızın bir parçası olarak ön işlemenin nasıl yapılacağını ve ardından çıkarım için dışa aktarılan modelle nasıl birleştirileceğini gösterir. Bu şekilde, TPU'nun kendisi sayısal girişler gerektirse de, hem eğitim hem de çıkarım ham metin girişlerinden çalışabilir.

TPU gereksinimleri yana, performans (daha öğrenebileceğiniz bir giriş boru hattı uyumsuz yapılan ön işleme sahip olmanızı sağlayabilir tf.data performans rehberi ).

Bu öğretici ayrıca çok girişli modellerin nasıl oluşturulacağını ve girişlerin sıra uzunluğunun BERT'ye nasıl ayarlanacağını gösterir.

Önişleme modelini gösterelim.

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

Her bir ön işlemesi modeli aynı zamanda bir yöntem sunmaktadır .bert_pack_inputs(tensors, seq_length) , (gibi jeton bir listesini alır tok edilmiş) ve bir dizi uzunluğu değişken. Bu, BERT modeli tarafından beklenen biçimde bir tensör sözlüğü oluşturmak için girdileri paketler.

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)

İşte dikkat etmeniz gereken bazı detaylar:

  • input_mask maske içeriği ve dolgu arasına temiz farklılıklarını göz modeli sağlar. Maske ile aynı şekle sahip input_word_ids ve 1 hiçbir yerinde içeriyor input_word_ids doldurma değil.
  • input_type_ids aynı şekle sahiptir input_mask ama dolu olmayan bölge içinde, bir 0 ya da 1 belirteci bir parçası olan cümle gösteren içerir.

Ardından, tüm bu mantığı kapsayan bir ön işleme modeli oluşturacaksınız. Modeliniz girdi olarak dizeleri alacak ve BERT'e iletilebilecek uygun şekilde biçimlendirilmiş nesneler döndürecektir.

Her BERT modelinin belirli bir ön işleme modeli vardır, BERT'nin model belgelerinde açıklanan uygun olanı kullandığınızdan emin olun.

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)

Önişleme modelini gösterelim. İki cümle girişi (input1 ve input2) ile bir test oluşturacaksınız. : Çıkışı Bert model girdi olarak ne beklenir input_word_ids , input_masks ve 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)

Az önce tanımladığınız iki girdiye dikkat ederek modelin yapısına bir göz atalım.

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

Veri kümesi tüm girdilerin içinde önişlemeyi uygulamak için kullanacağı map veri setinden işlevini. Sonuç daha sonra için önbelleğe performans .

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

Modelinizi tanımlayın

Artık, önceden işlenmiş girdileri BERT kodlayıcı aracılığıyla besleyerek ve üstüne doğrusal bir sınıflandırıcı koyarak (veya tercih ettiğiniz başka bir katman düzenlemesi) ve düzenlileştirme için bırakma özelliğini kullanarak, cümle veya cümle çifti sınıflandırması için modelinizi tanımlamaya hazırsınız.

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

Modeli önceden işlenmiş bazı girdilerde çalıştırmayı deneyelim.

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

GLUE'dan bir görev seçin

Sen bir TensorFlow DataSet kullanacağız YAPIŞTIRICI kriter paketi.

Colab, bu küçük veri kümelerini yerel dosya sistemine indirmenize izin verir ve ayrı TPU çalışan ana bilgisayarı, colab çalışma zamanının yerel dosya sistemine erişemediğinden, aşağıdaki kod bunları tamamen belleğe okur.

Daha büyük veri setleri için, kendi oluşturmanız gerekir Google Bulut Depolama kova ve TPU işçisi orada veri okumak var. Sen daha fazla bilgi edinebilirsiniz TPU rehberi .

CoLa veri seti (tek cümle için) veya MRPC (çok cümle için) ile başlamanız önerilir, çünkü bunlar küçüktür ve ince ayar yapılması uzun sürmez.

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)

Veri seti ayrıca problem tipini (sınıflandırma veya regresyon) ve eğitim için uygun kayıp fonksiyonunu belirler.

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

Modelinizi eğitin

Son olarak, modeli seçtiğiniz veri kümesi üzerinde uçtan uca eğitebilirsiniz.

Dağıtım

Kolab çalışma zamanını birden çok TPU cihazına sahip bir TPU çalışanına bağlayan en üstteki kurulum kodunu hatırlayın. Onlara eğitim dağıtmak için, TPU dağıtım stratejisi kapsamında ana Keras modelinizi oluşturacak ve derleyeceksiniz. (Ayrıntılar için bkz keras ile eğitim Distributed .)

Öte yandan ön işleme, TPU'larda değil, çalışan ana bilgisayarın CPU'sunda çalışır, bu nedenle ön işleme için Keras modelinin yanı sıra onunla eşlenen eğitim ve doğrulama veri kümeleri, dağıtım stratejisi kapsamının dışında oluşturulur. Çağrısı Model.fit() dağıtılması ilgilenir geçti-model kopyaları için veri kümesi.

Optimize Edici

İnce ayar iyileştirici set-up bert arasında önceden eğitimi (olduğu gibi aşağıdaki bert ile sınıflandırır metnin bir kavramsal ilk öğrenme hızının doğrusal bir çürüme ile AdamW optimizer kullanır birinci üzerinde doğrusal ısınma safhası öneki:) eğitim adımlar (% 10 num_warmup_steps ). BERT belgesine uygun olarak, ilk öğrenme oranı ince ayar için daha küçüktür (5e-5, 3e-5, 2e-5'in en iyisi).

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.5384 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.5082 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 2/3
267/267 [==============================] - 14s 53ms/step - loss: 0.3510 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.4895 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 3/3
267/267 [==============================] - 14s 54ms/step - loss: 0.2331 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.6271 - val_MatthewsCorrelationCoefficient: 0.0000e+00

Çıkarım için dışa aktar

Ön işleme kısmına ve yeni oluşturduğumuz ince ayarlı BERT'ye sahip nihai bir model oluşturacaksınız.

Çıkarım zamanında, ön işlemenin modelin bir parçası olması gerekir (çünkü artık bunu yapan eğitim verileri için ayrı bir girdi kuyruğu yoktur). Ön işleme sadece hesaplama değildir; dışa aktarma için kaydedilen Keras Modeline eklenmesi gereken kendi kaynaklarına (kelime tablosu) sahiptir. Bu son montaj kurtarılacak olandır.

Sen CoLab üzerine modelini kurtarmak için gidiyoruz ve daha sonra gelecek için tutmaya indirebilirsiniz (Görünüm -> İçindekiler -> Dosyalar).

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.

Modeli test edin

Son adım, dışa aktarılan modelinizin sonuçlarını test etmektir.

Sadece biraz karşılaştırma yapmak için, modeli yeniden yükleyelim ve veri kümesindeki test bölümündeki bazı girdileri kullanarak test edelim.

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

Fayda yöntemleri

Ölçek

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'I will try to meet at 6.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.5220253  1.8490468], shape=(2,), dtype=float32)

sentence: [b'Cornelia lodged in the new boarding house.']
This sentence is acceptable
BERT raw results: tf.Tensor([-3.1192958  2.7799528], shape=(2,), dtype=float32)

sentence: [b'Both workers will wear carnations.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.237738   3.2021792], shape=(2,), dtype=float32)

sentence: [b'Medea murdered']
This sentence is unacceptable
BERT raw results: tf.Tensor([ 0.56222165 -2.260996  ], shape=(2,), dtype=float32)

sentence: [b'List all experts for the defendant who represented themselves.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.087904   1.6495142], shape=(2,), dtype=float32)

Eğer üzerinde modeli kullanmak istiyorsanız TF Sunum , onun adlandırılmış imzaların biri üzerinden SavedModel arayacak unutmayın. Girişte bazı küçük farklılıklar olduğuna dikkat edin. Python'da bunları aşağıdaki gibi test edebilirsiniz:

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"While Perry might switch the TV off, he won't on."
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6701834  0.8465962], shape=(2,), dtype=float32)

sentence: b'Pat took a seat available.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 1.3545492 -2.9612012], shape=(2,), dtype=float32)

sentence: b'That Pat is innocent proves.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 1.2258279 -2.2433956], shape=(2,), dtype=float32)

sentence: b'The jeweller printed the name.'
This sentence is acceptable
BERT raw results: tf.Tensor([-2.266377   1.8589431], shape=(2,), dtype=float32)

sentence: b'Paul breathed on Mary.'
This sentence is acceptable
BERT raw results: tf.Tensor([-2.676597   2.8310988], shape=(2,), dtype=float32)

Sen yaptın! Kaydedilen modeliniz, daha az kodlu ve bakımı daha kolay olan daha basit bir API ile bir süreçte hizmet veya basit çıkarım için kullanılabilir.

Sonraki adımlar

Artık temel BERT modellerinden birini denediğinize göre, daha fazla doğruluk elde etmek için diğerlerini veya belki daha küçük model sürümleriyle deneyebilirsiniz.

Diğer veri kümelerinde de deneyebilirsiniz.