अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TPU पर BERT का उपयोग करके GLUE कार्यों को हल करें

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर देखें नोटबुक डाउनलोड करें TF हब मॉडल देखें

BERT का उपयोग प्राकृतिक भाषा प्रसंस्करण में कई समस्याओं को हल करने के लिए किया जा सकता है। आप सीखेंगे कि GLUE बेंचमार्क से कई कार्यों के लिए BERT को कैसे ठीक किया जाए:

  1. CoLA (Corpus of Linguistic Acceptability): क्या वाक्य व्याकरणिक रूप से सही है?

  2. SST-2 (स्टैनफोर्ड सेंटीमेंट ट्रीबैंक): कार्य किसी दिए गए वाक्य की भावना की भविष्यवाणी करना है।

  3. MRPC (Microsoft Research Paraphrase Corpus): निर्धारित करें कि वाक्यों की एक जोड़ी शब्दार्थ के समकक्ष है या नहीं।

  4. QQP (Quora Question Pairs2): यह निर्धारित करें कि प्रश्नों की एक जोड़ी शब्दार्थ के समकक्ष है या नहीं।

  5. MNLI (मल्टी-जेनर नेचुरल लैंग्वेज इनविज़न): एक आधार वाक्य और एक परिकल्पना वाक्य को देखते हुए, कार्य यह अनुमान लगाने के लिए है कि क्या आधार परिकल्पना (प्रवेश) को लागू करता है, परिकल्पना (विरोधाभास) का विरोध करता है, या न ही (तटस्थ)।

  6. QNLI (प्रश्न-उत्तर प्राकृतिक भाषा का आविष्कार ): कार्य यह निर्धारित करना है कि संदर्भ वाक्य में प्रश्न का उत्तर है या नहीं।

  7. RTE (मान्यता प्राप्त शाब्दिक प्रवेश): निर्धारित करें कि क्या एक वाक्य किसी दिए गए परिकल्पना को पूरा करता है या नहीं।

  8. WNLI (विनोग्राद नेचुरल लैंग्वेज इनविज़न): यह कार्य भविष्यवाणी करने के लिए है कि यदि सर्वनाम के साथ वाक्य को मूल वाक्य द्वारा प्रतिस्थापित किया गया है।

इस ट्यूटोरियल में TPU पर इन मॉडलों को प्रशिक्षित करने के लिए पूरा एंड-टू-एंड कोड है। आप एक पंक्ति (नीचे वर्णित) को बदलकर, इस नोटबुक को GPU पर भी चला सकते हैं।

इस नोटबुक में, आप करेंगे:

  • TensorFlow हब से एक BERT मॉडल लोड करें
  • GLUE कार्यों में से एक चुनें और डेटासेट डाउनलोड करें
  • पाठ को रोकें
  • फाइन-ट्यून BERT (उदाहरण एकल-वाक्य और बहु-वाक्य डेटासेट के लिए दिए गए हैं)
  • प्रशिक्षित मॉडल को सहेजें और इसका उपयोग करें

सेट अप

आप इसे ठीक करने के लिए BERT का उपयोग करने से पहले टेक्स्ट को प्रीप्रोसेस करने के लिए एक अलग मॉडल का उपयोग करेंगे। यह मॉडल टेनसफ़्लो / टेक्स्ट पर निर्भर करता है, जिसे आप नीचे स्थापित करेंगे।

pip install -q -U tensorflow-text

आप एडमवर्ट अनुकूलक का उपयोग टेंसोफ़्लो / मॉडल से ठीक- ठाक बीईआरटी में करेंगे, जिसे आप भी इंस्टॉल करेंगे।

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 को कॉन्फ़िगर करें। TPUub मॉडल को TPU पर चलाने पर यह केवल पुनःप्राप्त होता है।

इस सेटिंग के बिना TFHub संपीड़ित फ़ाइल डाउनलोड करेगा और स्थानीय रूप से चेकपॉइंट निकालेगा। इन स्थानीय फ़ाइलों से लोड करने का प्रयास त्रुटि के साथ विफल हो जाएगा:

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

ऐसा इसलिए है क्योंकि TPU केवल क्लाउड स्टोरेज बकेट से सीधे पढ़ा जा सकता है

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

TPU कार्यकर्ता से कनेक्ट करें

निम्न कोड TPU कार्यकर्ता से कनेक्ट होता है और TPU कार्यकर्ता पर CPU डिवाइस में TensorFlow के डिफ़ॉल्ट डिवाइस को बदलता है। यह एक TPU वितरण रणनीति को परिभाषित करता है जिसका उपयोग आप इस एक TPU कार्यकर्ता पर उपलब्ध 8 अलग TPU कोर पर मॉडल प्रशिक्षण वितरित करने के लिए करेंगे। अधिक जानकारी के लिए TensorFlow का TPU गाइड देखें।

import os

if os.environ['COLAB_TPU_ADDR']:
  cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='grpc://' + os.environ['COLAB_TPU_ADDR'])
  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 recomended.')
Using TPU

TensorFlow हब से लोड हो रहे मॉडल

यहां आप चुन सकते हैं कि कौन सा BERT मॉडल आप TensorFlow Hub और फाइन-ट्यून से लोड करेंगे। चुनने के लिए कई BERT मॉडल उपलब्ध हैं।

  • BERT-Base , बिना लाइसेंस वाले और मूल BERT लेखकों द्वारा जारी प्रशिक्षण भार के साथ सात और मॉडल
  • छोटे BERTs में समान सामान्य वास्तुकला लेकिन कम और / या छोटे ट्रांसफार्मर ब्लॉक होते हैं, जो आपको गति, आकार और गुणवत्ता के बीच ट्रेडऑफ़ का पता लगाने देता है।
  • ALBERT : "A Lite BERT" के चार अलग-अलग आकार जो परतों के बीच मापदंडों को साझा करके मॉडल आकार (लेकिन गणना समय नहीं) को कम करते हैं।
  • बीईआरटी विशेषज्ञ : आठ मॉडल जो सभी में बीईआरटी-बेस वास्तुकला है, लेकिन विभिन्न पूर्व-प्रशिक्षण डोमेन के बीच एक विकल्प प्रदान करते हैं, लक्ष्य कार्य के साथ अधिक निकटता संरेखित करने के लिए।
  • इलेक्ट्रा में BERT (तीन अलग-अलग आकारों में) के समान वास्तुकला है, लेकिन एक सेट-अप में एक भेदभावपूर्ण के रूप में पूर्व-प्रशिक्षित हो जाता है जो एक जनरेटिव एडवरसरी नेटवर्क (GAN) जैसा दिखता है।
  • टॉकिंग-हेड्स अटेंशन और गेटेड GELU [ बेस , बड़े ] के साथ BERT में ट्रांसफॉर्मर आर्किटेक्चर के मूल में दो सुधार हैं।

अधिक विवरण के लिए ऊपर दिए गए मॉडल प्रलेखन देखें।

इस ट्यूटोरियल में, आप BERT-base से शुरू करेंगे। आप उच्च सटीकता के लिए बड़े और अधिक हाल के मॉडल का उपयोग कर सकते हैं, या तेज प्रशिक्षण समय के लिए छोटे मॉडल। मॉडल को बदलने के लिए, आपको केवल कोड की एक पंक्ति (नीचे दिखाया गया है) स्विच करने की आवश्यकता है। सावेदमोडेल में सभी अंतर अलग-अलग हैं जिन्हें आप 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

पाठ को रोकें

BERT कोलब के साथ वर्गीकृत पाठ पर प्रीप्रोसेसिंग मॉडल का उपयोग सीधे BERT एनकोडर के साथ किया जाता है।

यह ट्यूटोरियल दर्शाता है कि Dataset.map का उपयोग करके प्रशिक्षण के लिए अपने इनपुट पाइपलाइन के हिस्से के रूप में प्रीप्रोसेसिंग कैसे करें, और फिर इसे उस मॉडल में मर्ज करें जो कि अनुमान के लिए निर्यात किया जाता है। इस तरह, प्रशिक्षण और निष्कर्ष दोनों कच्चे पाठ इनपुट से काम कर सकते हैं, हालांकि टीपीयू को स्वयं संख्यात्मक इनपुट की आवश्यकता होती है।

टीपीयू आवश्यकताओं को एक तरफ, यह एक इनपुट पाइपलाइन में अतुल्यकालिक रूप से किए गए प्रदर्शन को बेहतर बनाने में मदद कर सकता है (आप 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]]]>

प्रत्येक preprocessing मॉडल भी एक तरीका है, प्रदान करता है .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 के input_word_ids , और इसमें कहीं भी 1 है जिसमें input_word_ids नहीं है।
  • input_type_ids में input_type_ids का एक ही आकार input_mask , लेकिन गैर-गद्देदार क्षेत्र के अंदर, 0 या 1 होता है जो दर्शाता है कि टोकन किस वाक्य का एक हिस्सा है।

अगला, आप एक प्रीप्रोसेसिंग मॉडल बनाएंगे जो इस सारे तर्क को कूटबद्ध करता है। आपका मॉडल इनपुट के रूप में तार ले जाएगा, और उचित रूप से स्वरूपित वस्तुओं को वापस करेगा जो बीईआरटी को पारित किया जा सकता है।

प्रत्येक 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)

चलो प्रीप्रोसेसिंग मॉडल प्रदर्शित करते हैं। आप दो वाक्यों के इनपुट (input1 और input2) के साथ एक परीक्षण बनाएंगे। आउटपुट वह है जो एक 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_type_ids', 'input_word_ids', 'input_mask']
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.23200223 0.6682874 ]], 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.')

GLUE में से एक कार्य चुनें

आप GLUE बेंचमार्क सुइट से एक TensorFlow DataSet का उपयोग करने जा रहे हैं।

कोलाब आपको इन छोटे डेटासेट को स्थानीय फाइल सिस्टम में डाउनलोड करने देता है, और नीचे दिया गया कोड उन्हें पूरी तरह से मेमोरी में पढ़ता है, क्योंकि अलग TPU कार्यकर्ता होस्ट कोलाब रनटाइम के स्थानीय फाइल सिस्टम तक नहीं पहुंच सकता है।

बड़े डेटासेट के लिए, आपको अपना Google क्लाउड स्टोरेज बकेट बनाना होगा और टीपीयू कार्यकर्ता को वहां से डेटा पढ़ना होगा। आप टीपीयू गाइड में अधिक जान सकते हैं।

यह 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 is 'glue/cola':
    metrics = tfa.metrics.MatthewsCorrelationCoefficient()
  else:
    metrics = tf.keras.metrics.SparseCategoricalAccuracy(
        'accuracy', dtype=tf.float32)

  return metrics, loss

अपने मॉडल को प्रशिक्षित करें

अंत में, आप अपने द्वारा चुने गए डेटासेट पर मॉडल को एंड-टू-एंड प्रशिक्षित कर सकते हैं।

वितरण

शीर्ष पर सेट-अप कोड को याद करें, जिसने एक TPU कार्यकर्ता को कई TPU उपकरणों के साथ कोलाब रनटाइम से जोड़ा है। उन पर प्रशिक्षण वितरित करने के लिए, आप टीपीयू वितरण रणनीति के दायरे में अपने मुख्य केरस मॉडल का निर्माण और संकलन करेंगे। (विवरण के लिए, केरस के साथ वितरित प्रशिक्षण देखें।)

दूसरी ओर, प्रीप्रोसेसिंग, श्रमिक होस्ट के सीपीयू पर चलता है, टीपीयू नहीं, इसलिए प्रीप्रोसेसिंग के लिए केरस मॉडल और साथ ही इसके साथ मैप किए गए प्रशिक्षण और सत्यापन डेटासेट वितरण रणनीति के दायरे के बाहर बनाए गए हैं। Model.fit() को कॉल मॉडल प्रतिकृतियों में उत्तीर्ण डेटासेट को वितरित करने का ध्यान रखेगा।

ऑप्टिमाइज़र

ठीक-ट्यूनिंग बीईआरटी पूर्व-प्रशिक्षण से ऑप्टिमाइज़र सेट-अप का अनुसरण करता है (जैसे कि बीईआरटी के साथ वर्गीकृत पाठ में ): यह एक प्रारंभिक प्रारंभिक सीखने की दर के रैखिक क्षय के साथ एडम डब्ल्यू अनुकूलक का उपयोग करता है, जो पहले एक रैखिक वार्म अप चरण के साथ उपसर्ग करता है। 10% प्रशिक्षण चरण ( num_warmup_steps )। बीईआरटी पेपर के अनुरूप, प्रारंभिक शिक्षण दर फाइन-ट्यूनिंग के लिए छोटा है (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 76ms/step - loss: 0.6897 - accuracy: 0.6097 - val_loss: 0.4665 - val_accuracy: 0.8037
Epoch 2/3
267/267 [==============================] - 15s 58ms/step - loss: 0.3729 - accuracy: 0.8515 - val_loss: 0.5306 - val_accuracy: 0.8115
Epoch 3/3
267/267 [==============================] - 15s 57ms/step - loss: 0.2375 - accuracy: 0.9198 - val_loss: 0.6672 - val_accuracy: 0.8115

अनुमान के लिए निर्यात करें

आप एक अंतिम मॉडल बनाएंगे जिसमें प्रीप्रोसेसिंग हिस्सा है और ठीक ट्यून किए गए बीईआरटी जो हमने अभी बनाया है।

अनुमान के समय, प्रीप्रोसेसिंग को मॉडल का हिस्सा होना चाहिए (क्योंकि प्रशिक्षण डेटा के लिए एक अलग इनपुट कतार नहीं है जो इसे करता है)। प्रीप्रोसेसिंग केवल गणना नहीं है; इसके अपने संसाधन (वोकैब टेबल) हैं, जो निर्यात के लिए सहेजे गए केरस मॉडल से जुड़े होने चाहिए। यह अंतिम असेंबली है जो बचाई जाएगी।

आप कोलाब पर मॉडल को सहेजने जा रहे हैं और बाद में आप इसे भविष्य के लिए रखने के लिए डाउनलोड कर सकते हैं ( देखें -> सामग्री की तालिका -> फ़ाइलें )।

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(f'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'To her eldest son she left the Flemish tapestries.']
This sentence is acceptable
Bert raw results:[-1.9149436  3.0146608]

sentence: [b'Tabs were kept on no criminal by any agent.']
This sentence is acceptable
Bert raw results:[-1.6491104  2.2503743]

sentence: [b'I have eaten the muffin.']
This sentence is acceptable
Bert raw results:[-2.0706306  3.5650547]

sentence: [b'Sally wishes that everyone would praise her.']
This sentence is acceptable
Bert raw results:[-2.0767133  3.4313276]

sentence: [b'John strikes Bill as stupid.']
This sentence is acceptable
Bert raw results:[-1.6402274  3.326207 ]


यदि आप टीएफ सर्विंग पर अपने मॉडल का उपयोग करना चाहते हैं, तो याद रखें कि यह आपके 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'We voted for her.'
This sentence is acceptable
Bert raw results:[-1.8255943  3.3911474]

sentence: b'John is in the school.'
This sentence is acceptable
Bert raw results:[-1.7770475  3.5003886]

sentence: b'He walked right on the wall.'
This sentence is acceptable
Bert raw results:[-1.3748965  2.5856943]

sentence: b"With them on our team, we'll be sure to win."
This sentence is acceptable
Bert raw results:[-1.5921161  2.9578824]

sentence: b"The newspaper has reported that they are about to appoint someone, but I can't remember who."
This sentence is acceptable
Bert raw results:[-1.4567491  2.8264976]


तुमने यह किया! आपके सहेजे गए मॉडल का उपयोग एक प्रक्रिया में सेवा या सरल आक्षेप के लिए किया जा सकता है, कम कोड के साथ एक सरल एपीआई और बनाए रखने में आसान है।

अगला कदम

अब जब आपने आधार BERT मॉडल में से एक का प्रयास किया है, तो आप अन्य सटीकता या अधिक छोटे मॉडल संस्करणों के साथ प्राप्त करने की कोशिश कर सकते हैं।

आप अन्य डेटासेट में भी प्रयास कर सकते हैं।