לשמור את התאריך! קלט / פלט של Google חוזר 18-20 במאי הירשם עכשיו
דף זה תורגם על ידי Cloud Translation API.
Switch to English

פתר משימות GLUE באמצעות BERT ב- TPU

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה ב- GitHub הורד מחברת ראה מודל TF Hub

בעזרת BERT ניתן לפתור בעיות רבות בעיבוד שפות טבעיות. תלמד כיצד לכוונן את BERT למשימות רבות מתוך מדד ה- GLUE :

  1. CoLA (קורפוס של קבילות לשונית): האם המשפט נכון מבחינה דקדוקית?

  2. SST-2 (סטנפורד סנטימנט טריבנק): המשימה היא לחזות את הרגש של משפט נתון.

  3. MRPC (Microsoft Research Paraphrase Corpus): קבע אם זוג משפטים שווים מבחינה סמנטית.

  4. QQP (Quora Question Pairs2): קבע אם זוג שאלות שוות ערך סמנטית.

  5. MNLI (Multi-Genre Natural Language Inference): בהינתן משפט הנחת יסוד ומשפט השערה, המשימה היא לחזות האם הנחת היסוד כוללת את ההשערה (entailment), סותרת את ההשערה (סתירה) או אף אחת מהן (ניטרלית).

  6. QNLI (מענה לשאלה הטבעית): המשימה היא לקבוע אם משפט ההקשר מכיל את התשובה לשאלה.

  7. RTE (זיהוי השתתפות טקסטואלית): קבע אם משפט טומן בחובו השערה נתונה או לא.

  8. WNLI (Winograd Natural Language Inference): המשימה היא לחזות אם המשפט עם הכינוי שהוחלף נובע מהמשפט המקורי.

הדרכה זו מכילה קוד מקצה לקצה מלא להכשרת דגמים אלה ב- TPU. אתה יכול גם להריץ מחשב נייד זה על גבי GPU, על ידי שינוי שורה אחת (שתואר להלן).

במחברת זו תוכלו:

  • טען מודל BERT מ- TensorFlow Hub
  • בחר אחת ממשימות ה- GLUE והורד את מערך הנתונים
  • עיבד מראש את הטקסט
  • כוונן את BERT (דוגמאות ניתנות למערכי נתונים של משפט אחד ורב משפטים)
  • שמור את המודל המאומן והשתמש בו

להכין

תשתמש במודל נפרד כדי לעבד מראש טקסט לפני שתשתמש בו בכדי לכוונן את BERT. מודל זה תלוי בזרימת טנסור / טקסט , אותו תתקין למטה.

pip install -q -U tensorflow-text

תשתמש בכלי האופטימיזציה של AdamW מ- tensorflow / דגמים בכדי לכוונן את BERT, אותו תתקין גם כן.

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

בשלב הבא, הגדר את תצורת TFHub כך שתקרא נקודות מחסום ישירות מדלי אחסון הענן של TFHub. זה מומלץ רק כאשר מריצים דגמי TFHub ב- TPU.

ללא הגדרה זו TFHub היה מוריד את הקובץ הדחוס ומחלץ את נקודת הביקורת באופן מקומי. ניסיון לטעון מקבצים מקומיים אלה ייכשל עם השגיאה הבאה:

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

הסיבה לכך היא ש- TPU יכול לקרוא רק ישירות מדלי אחסון בענן .

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

התחבר לעובד TPU

הקוד הבא מתחבר לעובד TPU ומשנה את מכשיר ברירת המחדל של TensorFlow למכשיר המעבד שעובד TPU. זה גם מגדיר אסטרטגיית הפצה של TPU בה תשתמש כדי להפיץ אימון מודלים על 8 ליבות ה- TPU הנפרדות הזמינות לעובד TPU אחד זה. עיין במדריך TPU של TensorFlow למידע נוסף.

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

כאן תוכל לבחור איזה דגם BERT תטען מ- TensorFlow Hub וכוונון עדין. ישנם מספר דגמי BERT זמינים לבחירה.

  • בסיס BERT , לא ממוסגר ושבעה דגמים נוספים עם משקולות מאומנות ששוחררו על ידי מחברי ה- BERT המקוריים.
  • ל- BERTs קטנים אותה ארכיטקטורה כללית אך פחות ו / או חסימות שנאי קטנות יותר, המאפשרת לחקור פשרות בין מהירות, גודל ואיכות.
  • ALBERT : ארבעה גדלים שונים של "A Lite BERT" המפחית את גודל הדגם (אך לא את זמן החישוב) על ידי שיתוף פרמטרים בין שכבות.
  • מומחי BERT : שמונה דגמים שכולם בעלי ארכיטקטורת בסיס ה- BERT אך מציעים בחירה בין תחומים שונים לפני הכשרה, כדי להתאים יותר מקרוב למשימת היעד.
  • לאלקטרה ארכיטקטורה זהה לזו של BERT (בשלושה גדלים שונים), אך עוברת הכשרה מוקדמת כמפלה במערך הדומה לרשת גנטית-אדברסרית (GAN).
  • ל- BERT עם קשב מדבר-ראשים ו- GELU מגודרת [ בסיס , גדול ] שני שיפורים בליבת ארכיטקטורת הרובוטריקים.

לפרטים נוספים, עיין בתיעוד המודל המקושר למעלה.

במדריך זה תתחיל עם בסיס BERT. אתה יכול להשתמש בדגמים גדולים ואחרונים לדיוק גבוה יותר, או בדגמים קטנים יותר לזמני אימון מהירים יותר. כדי לשנות את הדגם, עליך להחליף רק שורה אחת של קוד (מוצג להלן). כל ההבדלים נעטפים ב- SavedModel שתורידו מ- TensorFlow Hub.

בחר דגם BERT לכוונון עדין

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

עיבד מראש את הטקסט

בטקסט Classify עם BERT colab נעשה שימוש במודל העיבוד המוקדם המוטבע ישירות עם מקודד ה- BERT.

הדרכה זו מדגימה כיצד לבצע עיבוד מקדים כחלק מצינור הקלט שלך לאימון, באמצעות Dataset.map, ואז למזג אותו למודל שיוצא לשם היסק. בדרך זו, הן אימונים והן היסק יכולים לעבוד מכניסות טקסט גולמיות, אם כי ה- TPU עצמו דורש קלט מספרי.

מלבד דרישות TPU, זה יכול לעזור לביצועים שעיבוד מקדים נעשה בצורה אסינכרונית בצינור קלט (תוכלו ללמוד עוד במדריך הביצועים tf.data ).

מדריך זה מדגים גם כיצד לבנות מודלים מרובי קלט, וכיצד להתאים את אורך הרצף של הקלטים ל- BERT.

בואו נדגים את מודל העיבוד המקדים.

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

כל מודל עיבוד מקדים מספק גם שיטה, .bert_pack_inputs(tensors, seq_length) , שלוקחת רשימה של אסימונים (כמו tok לעיל) וטיעון אורך רצף. זה מארז את התשומות ליצירת מילון טנזורים בפורמט המצופה על ידי מודל 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)

להלן מספר פרטים שיש לשים לב אליהם:

  • input_mask המסכה מאפשרת למודל להבדיל בצורה נקייה בין התוכן לריפוד. המסכה יש את אותה צורה כמו input_word_ids , והיא מכילה 1 בכל מקום בו input_word_ids אינו מרופד.
  • input_type_ids יש את אותה צורה כמו input_mask , אך בתוך האזור שאינו מרופד, מכיל 0 או 1 המציין מאיזה משפט האסימון הוא חלק.

לאחר מכן, תיצור מודל עיבוד מקדים המכיל את כל ההיגיון הזה. המודל שלך יקבל מחרוזות כקלט, ויחזיר אובייקטים מעוצבים כראוי שניתן להעביר ל- BERT.

לכל דגם BERT יש דגם עיבוד מקדים ספציפי, הקפידו להשתמש במודל המתאים המתואר בתיעוד המודל של ה- 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)

בואו נדגים את מודל העיבוד המקדים. תיצור מבחן עם שני משפטים קלט (קלט 1 וקלט 2). הפלט הוא מה שמודל BERT היה מצפה כקלט: input_word_ids , input_masks ו- 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_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)

בואו נסתכל על מבנה המודל ונשים לב לשני התשומות שהגדרת זה עתה.

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

כדי להחיל את העיבוד המקדים בכל הקלטים ממערך הנתונים, תשתמש בפונקציית map ממערך הנתונים. התוצאה נשמרת לצורך ביצוע .

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

הגדירו את המודל שלכם

כעת אתה מוכן להגדיר את המודל שלך לסיווג זוג משפטים או משפטים על ידי הזנת הקלטים שעובדו מראש דרך מקודד ה- BERT והנחת מסווג ליניארי מעל (או סידור אחר של שכבות לפי העדפתך) ושימוש בנשירה לצורך הסדרה.

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

בואו ננסה להריץ את המודל בכמה תשומות מעובדות מראש.

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)

בואו נסתכל על מבנה המודל. אתה יכול לראות את שלוש התשומות הצפויות של 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.')

בחר משימה מתוך דבק

אתה הולך להשתמש במערך TensorFlow מן דבק חבילת ביצועים.

Colab מאפשר לך להוריד מערכי נתונים קטנים אלה למערכת הקבצים המקומית, והקוד שלמטה קורא אותם לחלוטין בזיכרון, מכיוון שמארח העובדים הנפרד של TPU אינו יכול לגשת למערכת הקבצים המקומית של זמן הריצה של colab.

עבור מערכי נתונים גדולים יותר, יהיה עליך ליצור דלי אחסון בענן שלך ב- Google ולבקש שעובד TPU יקרא את הנתונים משם. תוכל ללמוד עוד במדריך TPU .

מומלץ להתחיל במערך הנתונים של CoLa (למשפט בודד) או MRPC (למשפט רב-משפט) מכיוון שאלו קטנים ולא לוקח זמן רב לכוונן.

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)

מערך הנתונים קובע גם את סוג הבעיה (סיווג או רגרסיה) ואת פונקציית האובדן המתאימה לאימונים.

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

תאמן את המודל שלך

לבסוף, תוכלו לאמן את המודל מקצה לקצה במערך הנתונים שבחרתם.

הפצה

זוכר את קוד ההגדרה בחלק העליון, שחיבר את זמן הריצה של colab לעובד TPU עם מספר התקני TPU. כדי להפיץ אימונים עליהם, תיצור ותרכיב את מודל Keras הראשי שלך במסגרת אסטרטגיית ההפצה של TPU. (לפרטים, ראה אימונים מבוזרים עם Keras .)

לעומת זאת, עיבוד מקדים פועל על המעבד של מארח העובדים, ולא על ה- TPU, כך שמודל Keras לעיבוד מקדים כמו גם מערכי הנתונים של אימונים ואימות הממופים איתו בנויים מחוץ לתחום אסטרטגיית ההפצה. הקריאה ל- Model.fit() תדאג להפצת מערך הנתונים שהועבר Model.fit() העתק של המודל.

מיטוב

כוונון עדין עוקב אחר הגדרת האופטימיזציה מההכשרה המקדימה של BERT (כמו בטקסט מסווג עם BERT ): היא משתמשת בכלי האופטימיזציה של AdamW עם ריקבון ליניארי של קצב למידה ראשוני רעיוני, עם קידומת שלב חימום ליניארי במהלך הראשון 10% num_warmup_steps האימון ( num_warmup_steps ). בהתאם לנייר BERT, קצב הלמידה הראשוני קטן יותר לכוונון עדין (הטוב ביותר מ- 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

ייצא למסקנה

תיצור מודל סופי המכיל את החלק העיבוד המוקדם ואת ה- BERT המכוונן שיצרנו זה עתה.

בזמן ההסקה, עיבוד מקדים צריך להיות חלק מהמודל (מכיוון שכבר אין תור קלט נפרד לגבי נתוני אימון שעושים זאת). עיבוד מקדים אינו רק חישוב; יש לו משאבים משלו (טבלת אוצר המילים) שיש לצרף למודל Keras שנשמר לייצוא. האסיפה הסופית הזו היא מה שיישמר.

אתה הולך לשמור את הדגם ב- colab ובהמשך תוכל להוריד כדי לשמור אותו לעתיד ( תצוגה -> תוכן עניינים -> קבצים ).

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.

בדוק את המודל

השלב האחרון הוא בדיקת תוצאות המודל המיוצא שלך.

רק כדי לבצע השוואה מסוימת, בואו טען מחדש את המודל ונבדוק אותו באמצעות כמה תשומות מפיצול הבדיקה ממערך הנתונים.

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

שיטות שירות

מִבְחָן

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)

אם אתה רוצה להשתמש במודל שלך ב- TF Serving , זכור שהוא יתקשר ל- SavedModel שלך באמצעות אחת החתימות שלו. שימו לב שיש כמה הבדלים קטנים בקלט. בפייתון תוכלו לבדוק אותם באופן הבא:

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)

עשית את זה! המודל השמור שלך יכול לשמש להגשה או להסקה פשוטה בתהליך, עם ממשק API פשוט יותר עם פחות קוד וקל יותר לתחזוקה.

הצעדים הבאים

כעת, לאחר שניסיתם את אחד מדגמי ה- BERT הבסיסיים, תוכלו לנסות אחרים כדי להשיג דיוק רב יותר או אולי עם גרסאות דגם קטנות יותר.

אתה יכול לנסות גם בערכות נתונים אחרות.