Lưu ngày! Google I / O hoạt động trở lại từ ngày 18 đến 20 tháng 5 Đăng ký ngay
Trang này được dịch bởi Cloud Translation API.
Switch to English

Giải quyết các tác vụ GLUE bằng cách sử dụng BERT trên TPU

Xem trên TensorFlow.org Chạy trong Google Colab Xem trên GitHub Tải xuống sổ ghi chép Xem mô hình TF Hub

BERT có thể được sử dụng để giải quyết nhiều vấn đề trong xử lý ngôn ngữ tự nhiên. Bạn sẽ học cách tinh chỉnh BERT cho nhiều tác vụ từ tiêu chuẩn GLUE :

  1. CoLA (Corpus of Linguistic Acceptability): Câu có đúng ngữ pháp không?

  2. SST-2 (Stanford Sentiment Treebank): Nhiệm vụ là dự đoán cảm xúc của một câu nhất định.

  3. MRPC (Microsoft Research Paraphrase Corpus): Xác định xem một cặp câu có tương đương về mặt ngữ nghĩa hay không.

  4. QQP (Quora Question Pairs2): Xác định xem một cặp câu hỏi có tương đương về mặt ngữ nghĩa hay không.

  5. MNLI (Suy luận ngôn ngữ tự nhiên đa thể loại): Đưa ra một câu tiền đề và một câu giả thuyết, nhiệm vụ là dự đoán xem tiền đề đó có chứa giả thuyết (kéo theo), mâu thuẫn với giả thuyết (mâu thuẫn) hay không (trung lập).

  6. QNLI (Suy luận Ngôn ngữ Tự nhiên Câu hỏi-Trả lời): Nhiệm vụ là xác định xem câu ngữ cảnh có chứa câu trả lời cho câu hỏi hay không.

  7. RTE (Ghi nhận phần nhập văn bản): Xác định xem một câu có chứa một giả thuyết đã cho hay không.

  8. WNLI (Winograd Natural Language Inference): Nhiệm vụ là dự đoán xem câu có đại từ thay thế có bị câu gốc kéo theo hay không.

Hướng dẫn này chứa mã end-to-end hoàn chỉnh để đào tạo các mô hình này trên TPU. Bạn cũng có thể chạy máy tính xách tay này trên GPU, bằng cách thay đổi một dòng (mô tả bên dưới).

Trong sổ tay này, bạn sẽ:

  • Tải mô hình BERT từ TensorFlow Hub
  • Chọn một trong các tác vụ GLUE và tải xuống tập dữ liệu
  • Xử lý trước văn bản
  • Tinh chỉnh BERT (ví dụ được đưa ra cho tập dữ liệu một câu và nhiều câu)
  • Lưu mô hình được đào tạo và sử dụng nó

Thiết lập

Bạn sẽ sử dụng một mô hình riêng biệt để xử lý trước văn bản trước khi sử dụng nó để tinh chỉnh BERT. Mô hình này phụ thuộc vào tensorflow / text , mà bạn sẽ cài đặt bên dưới.

pip install -q -U tensorflow-text

Bạn sẽ sử dụng trình tối ưu hóa AdamW từ tensorflow / models để tinh chỉnh BERT, mà bạn cũng sẽ cài đặt.

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

Tiếp theo, định cấu hình TFHub để đọc các điểm kiểm tra trực tiếp từ các nhóm Lưu trữ đám mây của TFHub. Điều này chỉ được khuyến nghị khi chạy các mô hình TFHub trên TPU.

Nếu không có cài đặt này, TFHub sẽ tải xuống tệp nén và giải nén trạm kiểm soát cục bộ. Cố gắng tải từ các tệp cục bộ này sẽ không thành công với lỗi sau:

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

Điều này là do TPU chỉ có thể đọc trực tiếp từ nhóm Bộ nhớ đám mây .

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

Kết nối với nhân viên TPU

Đoạn mã sau kết nối với TPU worker và thay đổi thiết bị mặc định của TensorFlow thành thiết bị CPU trên TPU worker. Nó cũng xác định chiến lược phân phối TPU mà bạn sẽ sử dụng để phân phối đào tạo mô hình lên 8 lõi TPU riêng biệt có sẵn trên một nhân viên TPU này. Xem hướng dẫn TPU của TensorFlow để biết thêm thông tin.

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

Đang tải mô hình từ TensorFlow Hub

Tại đây, bạn có thể chọn mô hình BERT mà bạn sẽ tải từ TensorFlow Hub và tinh chỉnh. Có nhiều mô hình BERT có sẵn để lựa chọn.

  • BERT-Base , Uncasedbảy mô hình khác với trọng lượng được huấn luyện do các tác giả BERT ban đầu phát hành.
  • Các BERT nhỏ có cùng kiến ​​trúc chung nhưng ít hơn và / hoặc các khối Biến áp nhỏ hơn, cho phép bạn khám phá sự cân bằng giữa tốc độ, kích thước và chất lượng.
  • ALBERT : bốn kích thước khác nhau của "A Lite BERT" giúp giảm kích thước mô hình (nhưng không phải thời gian tính toán) bằng cách chia sẻ các tham số giữa các lớp.
  • Chuyên gia BERT : tám mô hình đều có kiến ​​trúc cơ sở BERT nhưng cung cấp sự lựa chọn giữa các miền đào tạo trước khác nhau, để điều chỉnh chặt chẽ hơn với nhiệm vụ mục tiêu.
  • Electra có kiến ​​trúc tương tự như BERT (ở ba kích thước khác nhau), nhưng được đào tạo trước như một người phân biệt trong một thiết lập giống như Mạng đối thủ chung (GAN).
  • BERT với Talking-Heads Attention và Gated GELU [ cơ bản , lớn ] có hai cải tiến đối với cốt lõi của kiến ​​trúc Transformer.

Xem tài liệu mô hình được liên kết ở trên để biết thêm chi tiết.

Trong hướng dẫn này, bạn sẽ bắt đầu với BERT-base. Bạn có thể sử dụng các mô hình lớn hơn và gần đây hơn để có độ chính xác cao hơn hoặc các mô hình nhỏ hơn để có thời gian đào tạo nhanh hơn. Để thay đổi mô hình, bạn chỉ cần chuyển một dòng mã duy nhất (hiển thị bên dưới). Tất cả sự khác biệt được gói gọn trong SavedModel mà bạn sẽ tải xuống từ TensorFlow Hub.

Chọn một mô hình BERT để tinh chỉnh

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

Xử lý trước văn bản

Trên cột Phân loại văn bản với BERT , mô hình tiền xử lý được sử dụng nhúng trực tiếp với bộ mã hóa BERT.

Hướng dẫn này trình bày cách thực hiện tiền xử lý như một phần của đường dẫn đầu vào để đào tạo, sử dụng Dataset.map, sau đó hợp nhất nó vào mô hình được xuất ra để suy luận. Bằng cách đó, cả đào tạo và suy luận đều có thể hoạt động từ đầu vào văn bản thô, mặc dù bản thân TPU yêu cầu đầu vào số.

Yêu cầu TPU sang một bên, nó có thể giúp hiệu suất có quá trình tiền xử lý được thực hiện không đồng bộ trong một đường dẫn đầu vào (bạn có thể tìm hiểu thêm trong hướng dẫn hiệu suất tf.data ).

Hướng dẫn này cũng trình bày cách xây dựng các mô hình đa đầu vào và cách điều chỉnh độ dài trình tự của các đầu vào thành BERT.

Hãy chứng minh mô hình tiền xử lý.

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

Mỗi mô hình tiền xử lý cũng cung cấp một phương thức, .bert_pack_inputs(tensors, seq_length) , lấy một danh sách các mã thông báo (như tok ở trên) và một đối số độ dài chuỗi. Điều này đóng gói các đầu vào để tạo ra một từ điển các tenxơ ở định dạng mà mô hình BERT mong đợi.

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)

Dưới đây là một số chi tiết cần chú ý:

  • input_mask Mặt nạ cho phép mô hình phân biệt rõ ràng giữa nội dung và phần đệm. Mặt nạ có cùng hình dạng với input_word_ids và chứa 1 ở bất kỳ vị trí nào mà input_word_ids không phải là padding.
  • input_type_ids có cùng hình dạng với input_mask , nhưng bên trong vùng không đệm, có chứa 0 hoặc 1 cho biết mã thông báo là một phần của câu nào.

Tiếp theo, bạn sẽ tạo một mô hình tiền xử lý đóng gói tất cả logic này. Mô hình của bạn sẽ lấy các chuỗi làm đầu vào và trả về các đối tượng được định dạng thích hợp có thể được chuyển tới BERT.

Mỗi mô hình BERT có một mô hình tiền xử lý cụ thể, hãy đảm bảo sử dụng mô hình thích hợp được mô tả trong tài liệu về mô hình của 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)

Hãy chứng minh mô hình tiền xử lý. Bạn sẽ tạo một bài kiểm tra với hai câu đầu vào (input1 và input2). Đầu ra là những gì một mô hình BERT mong đợi như đầu vào: input_word_ids , input_masksinput_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_mask', 'input_type_ids', '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)

Hãy xem cấu trúc của mô hình, chú ý đến hai đầu vào mà bạn vừa xác định.

tf.keras.utils.plot_model(test_preprocess_model)
('Failed to import pydot. You must `pip install pydot` and install graphviz (https://graphviz.gitlab.io/download/), ', 'for `pydotprint` to work.')

Để áp dụng tiền xử lý trong tất cả các đầu vào từ tập dữ liệu, bạn sẽ sử dụng hàm map từ tập dữ liệu. Kết quả sau đó được lưu vào bộ nhớ cache để thực hiện .

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

Xác định mô hình của bạn

Giờ đây, bạn đã sẵn sàng xác định mô hình của mình để phân loại câu hoặc cặp câu bằng cách cung cấp các đầu vào được xử lý trước thông qua bộ mã hóa BERT và đặt một bộ phân loại tuyến tính lên trên (hoặc sắp xếp các lớp khác tùy thích) và sử dụng tính năng bỏ qua để chính quy hóa.

def build_classifier_model(num_classes):
  inputs = dict(
      input_word_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32),
      input_mask=tf.keras.layers.Input(shape=(None,), dtype=tf.int32),
      input_type_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32),
  )

  encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='encoder')
  net = encoder(inputs)['pooled_output']
  net = tf.keras.layers.Dropout(rate=0.1)(net)
  net = tf.keras.layers.Dense(num_classes, activation=None, name='classifier')(net)
  return tf.keras.Model(inputs, net, name='prediction')

Hãy thử chạy mô hình trên một số đầu vào được xử lý trước.

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

Chúng ta hãy nhìn vào cấu trúc của mô hình. Bạn có thể thấy ba đầu vào dự kiến ​​BERT.

tf.keras.utils.plot_model(test_classifier_model)
('Failed to import pydot. You must `pip install pydot` and install graphviz (https://graphviz.gitlab.io/download/), ', 'for `pydotprint` to work.')

Chọn một nhiệm vụ từ GLUE

Bạn sẽ sử dụng Tập dữ liệu TensorFlow từ bộ điểm chuẩn GLUE .

Colab cho phép bạn tải các tập dữ liệu nhỏ này xuống hệ thống tệp cục bộ và mã bên dưới đọc chúng hoàn toàn vào bộ nhớ, vì máy chủ lưu trữ công nhân TPU riêng biệt không thể truy cập hệ thống tệp cục bộ của thời gian chạy colab.

Đối với các tập dữ liệu lớn hơn, bạn sẽ cần tạo nhóm Google Cloud Storage của riêng mình và nhờ nhân viên TPU đọc dữ liệu từ đó. Bạn có thể tìm hiểu thêm trong hướng dẫn TPU .

Bạn nên bắt đầu với tập dữ liệu CoLa (cho câu đơn) hoặc MRPC (cho nhiều câu) vì chúng nhỏ và không mất nhiều thời gian để tinh chỉnh.

Using glue/cola from TFDS
This dataset has 10657 examples
Number of classes: 2
Features ['sentence']
Splits ['test', 'train', 'validation']
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)

Bộ dữ liệu cũng xác định loại vấn đề (phân loại hoặc hồi quy) và hàm tổn thất thích hợp cho việc huấn luyện.

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

Đào tạo mô hình của bạn

Cuối cùng, bạn có thể đào tạo mô hình từ đầu đến cuối trên tập dữ liệu bạn đã chọn.

Phân phối

Nhớ lại mã thiết lập ở trên cùng, mã này đã kết nối thời gian chạy colab với một công nhân TPU với nhiều thiết bị TPU. Để phân phối đào tạo cho họ, bạn sẽ tạo và biên dịch mô hình Keras chính của mình trong phạm vi của chiến lược phân phối TPU. (Để biết chi tiết, hãy xem Đào tạo phân tán với Keras .)

Mặt khác, tiền xử lý chạy trên CPU của máy chủ công nhân, không phải TPU, do đó, mô hình Keras cho tiền xử lý cũng như tập dữ liệu đào tạo và xác thực được ánh xạ với nó được xây dựng bên ngoài phạm vi chiến lược phân phối. Lệnh gọi đến Model.fit() sẽ đảm nhận việc phân phối tập dữ liệu được chuyển vào cho các bản sao mô hình.

Trình tối ưu hóa

Tinh chỉnh tuân theo trình tối ưu hóa được thiết lập từ đào tạo trước BERT (như trong Phân loại văn bản với BERT ): Nó sử dụng trình tối ưu hóa AdamW với phân rã tuyến tính của tốc độ học ban đầu theo danh nghĩa, được bắt đầu bằng giai đoạn khởi động tuyến tính so với giai đoạn đầu 10% số bước đào tạo ( num_warmup_steps ). Phù hợp với bài báo BERT, tốc độ học ban đầu nhỏ hơn để tinh chỉnh (tốt nhất là 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/tensorflow/python/keras/engine/functional.py:595: 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:437: 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 [==============================] - 79s 77ms/step - loss: 0.5812 - MatthewsCorrelationCoefficient: 0.5968 - val_loss: 0.4688 - val_MatthewsCorrelationCoefficient: 0.5871
Epoch 2/3
267/267 [==============================] - 15s 58ms/step - loss: 0.3561 - MatthewsCorrelationCoefficient: 0.5906 - val_loss: 0.5723 - val_MatthewsCorrelationCoefficient: 0.5871
Epoch 3/3
267/267 [==============================] - 15s 58ms/step - loss: 0.2352 - MatthewsCorrelationCoefficient: 0.5909 - val_loss: 0.6748 - val_MatthewsCorrelationCoefficient: 0.5871

Xuất để suy luận

Bạn sẽ tạo một mô hình cuối cùng có phần tiền xử lý và BERT tinh chỉnh mà chúng tôi vừa tạo.

Tại thời điểm suy luận, tiền xử lý cần phải là một phần của mô hình (vì không còn một hàng đợi đầu vào riêng biệt như đối với dữ liệu huấn luyện thực hiện nó). Tiền xử lý không chỉ là tính toán; nó có các tài nguyên riêng (bảng vocab) phải được gắn vào Mô hình Keras được lưu để xuất. Lắp ráp cuối cùng này là những gì sẽ được lưu.

Bạn sẽ lưu mô hình trên colab và sau này bạn có thể tải xuống để giữ nó cho tương lai ( Xem -> Mục lục -> Tệp ).

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

Kiểm tra mô hình

Bước cuối cùng là kiểm tra kết quả của mô hình đã xuất của bạn.

Chỉ để thực hiện một số so sánh, hãy tải lại mô hình và kiểm tra nó bằng cách sử dụng một số đầu vào từ phần tách thử nghiệm từ tập dữ liệu.

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

Các phương pháp tiện ích

Kiểm tra

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'Onto the table jumped a cat.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.5364362  3.0245366], shape=(2,), dtype=float32)

sentence: [b'it is important to John to leave.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.1081586  4.0080795], shape=(2,), dtype=float32)

sentence: [b'Gina filled the pitcher with lemonade.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.5824902  3.740626 ], shape=(2,), dtype=float32)

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

sentence: [b'The student hated his morphology professor.']
This sentence is acceptable
BERT raw results: tf.Tensor([-2.4559186  3.5234451], shape=(2,), dtype=float32)

Nếu bạn muốn sử dụng mô hình của mình trên TF Serving , hãy nhớ rằng nó sẽ gọi SavedModel của bạn thông qua một trong các chữ ký được đặt tên của nó. Lưu ý rằng có một số khác biệt nhỏ trong đầu vào. Trong Python, bạn có thể kiểm tra chúng như sau:

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'His loves him'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 2.160802  -2.4170692], shape=(2,), dtype=float32)

sentence: b'John says Mary likes himself.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 1.759533  -2.0088294], shape=(2,), dtype=float32)

sentence: b'He treats John very under.'
This sentence is acceptable
BERT raw results: tf.Tensor([-0.19971004  1.1566539 ], shape=(2,), dtype=float32)

sentence: b'Karen asked where him to vote for.'
This sentence is unacceptable
BERT raw results: tf.Tensor([ 2.1606677 -2.1753395], shape=(2,), dtype=float32)

sentence: b"I didn't give Jack Ed's picture of anybody."
This sentence is unacceptable
BERT raw results: tf.Tensor([ 1.755337 -1.904901], shape=(2,), dtype=float32)

Bạn làm được rồi! Mô hình đã lưu của bạn có thể được sử dụng để phục vụ hoặc suy luận đơn giản trong một quy trình, với một api đơn giản hơn với ít mã hơn và dễ bảo trì hơn.

Bước tiếp theo

Bây giờ bạn đã thử một trong các mô hình BERT cơ sở, bạn có thể thử các mô hình khác để đạt được độ chính xác hơn hoặc có thể với các phiên bản mô hình nhỏ hơn.

Bạn cũng có thể thử trong các bộ dữ liệu khác.