This page was translated by the Cloud Translation API.
Switch to English

নিখুঁত টিউন একটি বার্ট মডেল

TensorFlow.org দেখুন গুগল Colab চালনা করুন GitHub থেকে উৎস দেখুন ডাউনলোড নোটবুক

এই উদাহরণে, আমরা tensorflow-মডেল PIP এর প্যাকেজ ব্যবহার ফাইন টিউনিং মাধ্যমে কাজ করবে একটি বার্ট মডেল।

Pretrained বার্ট মডেল এই টিউটোরিয়াল উপর ভিত্তি করে তৈরি এছাড়াও উপলব্ধ TensorFlow হাব কিভাবে এটি পড়ুন ব্যবহার করতে দেখতে হাব পরিশিষ্ট

সেটআপ

TensorFlow মডেল গার্ডেন পিপ প্যাকেজ ইনস্টল করুন

  • tf-models-nightly দৈনন্দিন স্বয়ংক্রিয়ভাবে তৈরি রাত্রিকালীন মডেল গার্ডেন প্যাকেজ।
  • পিপ সব মডেল এবং নির্ভরতা স্বয়ংক্রিয়ভাবে ইনস্টল হবে।
pip install -q tf-nightly
pip install -q tf-models-nightly

আমদানি

 import os

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf

import tensorflow_hub as hub
import tensorflow_datasets as tfds
tfds.disable_progress_bar()

from official.modeling import tf_utils
from official import nlp
from official.nlp import bert

# Load the required submodules
import official.nlp.optimization
import official.nlp.bert.bert_models
import official.nlp.bert.configs
import official.nlp.bert.run_classifier
import official.nlp.bert.tokenization
import official.nlp.data.classifier_data_lib
import official.nlp.modeling.losses
import official.nlp.modeling.models
import official.nlp.modeling.networks
 
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_addons/utils/ensure_tf_install.py:44: UserWarning: You are currently using a nightly version of TensorFlow (2.3.0-dev20200623). 
TensorFlow Addons offers no support for the nightly versions of TensorFlow. Some things might work, some other might not. 
If you encounter a bug, do not file an issue on GitHub.
  UserWarning,

সম্পদ

এই ডিরেক্টরিটি কনফিগারেশন, শব্দভাণ্ডার এবং একটি প্রাক প্রশিক্ষিত এই টিউটোরিয়ালটিতে ব্যবহৃত চেকপয়েন্ট রয়েছে:

 gs_folder_bert = "gs://cloud-tpu-checkpoints/bert/keras_bert/uncased_L-12_H-768_A-12"
tf.io.gfile.listdir(gs_folder_bert)
 
['bert_config.json',
 'bert_model.ckpt.data-00000-of-00001',
 'bert_model.ckpt.index',
 'vocab.txt']

আপনি এখানে TensorFlow হাব থেকে একটি প্রাক প্রশিক্ষিত বার্ট এনকোডার পেতে পারেন:

 hub_url_bert = "https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/2"
 

তথ্যটি

এই উদাহরণস্বরূপ আমরা ব্যবহৃত TFDS থেকে আঠালো MRPC ডেটা সেটটি

এই সেটটি তাই সেট আপ করা হয়নি এটি সরাসরি বার্ট মডেল মধ্যে প্রতিপালিত করা যাবে, সুতরাং এই বিভাগে প্রয়োজনীয় প্রাক-প্রক্রিয়াকরণ পরিচালনা করে।

TensorFlow ডেটাসেটস থেকে ডেটা সেটটি পান

মাইক্রোসফট রিসার্চ ভাষান্তর করপাস (দোলন ও Brockett, 2005) বাক্য জোড়া একটি কর্পাস অনলাইনে স্বয়ংক্রিয়ভাবে সংবাদ উত্স থেকে নিষ্কাশিত জন্য কিনা জোড়ায় বাক্য শব্দার্থগতভাবে হয় সমতুল্য মানুষের টীকা সাথে।

  • লেবেল সংখ্যা: 2।
  • প্রশিক্ষণ ডেটাসেটের আকার: 3668।
  • মূল্যায়ন ডেটাসেটের আকার: 408।
  • প্রশিক্ষণ ও মূল্যায়ন ডেটাসেটের সর্বোচ্চ ক্রম দৈর্ঘ্য: 128।
 glue, info = tfds.load('glue/mrpc', with_info=True,
                       # It's small, load the whole dataset
                       batch_size=-1)
 
Downloading and preparing dataset glue/mrpc/1.0.0 (download: 1.43 MiB, generated: Unknown size, total: 1.43 MiB) to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0...

/usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
  InsecureRequestWarning)
/usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
  InsecureRequestWarning)
/usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
  InsecureRequestWarning)

Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-train.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-validation.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-test.tfrecord
Dataset glue downloaded and prepared to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0. Subsequent calls will reuse this data.

 list(glue.keys())
 
['test', 'train', 'validation']

info বস্তুর ডেটা সেটটি বর্ণনা এবং এটি বৈশিষ্ট্য আছে:

 info.features
 
FeaturesDict({
    'idx': tf.int32,
    'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=2),
    'sentence1': Text(shape=(), dtype=tf.string),
    'sentence2': Text(shape=(), dtype=tf.string),
})

দুটি ক্লাস আছে:

 info.features['label'].names
 
['not_equivalent', 'equivalent']

এখানে প্রশিক্ষণ সেট থেকে একটি উদাহরণ হল:

 glue_train = glue['train']

for key, value in glue_train.items():
  print(f"{key:9s}: {value[0].numpy()}")
 
idx      : 1680
label    : 0
sentence1: b'The identical rovers will act as robotic geologists , searching for evidence of past water .'
sentence2: b'The rovers act as robotic geologists , moving on six wheels .'

বার্ট tokenizer

জরিমানা সুর একটি প্রাক প্রশিক্ষিত মডেল আপনি যে আপনার ঠিক একই tokenization, শব্দভাণ্ডার এবং সূচক ম্যাপিং হিসাবে আপনি প্রশিক্ষণ সময় ব্যবহৃত ব্যবহার করছেন নিশ্চিত হতে হবে।

বার্ট এই টিউটোরিয়ালটিতে ব্যবহৃত tokenizer (এটা TensorFlow অপস বাইরে নির্মিত না) বিশুদ্ধ পাইথন লেখা হয়। তাই আপনি শুধু এটা আপনার মডেল মধ্যে একটি হিসাবে চলা করতে পারবে না keras.layer মত আপনার সাথে করতে পারেন preprocessing.TextVectorization

নিম্নলিখিত কোড পুনঃনির্মাণ tokenizer যে বেস মডেল দ্বারা ব্যবহৃত হয়েছিল:

 # Set up tokenizer to generate Tensorflow dataset
tokenizer = bert.tokenization.FullTokenizer(
    vocab_file=os.path.join(gs_folder_bert, "vocab.txt"),
     do_lower_case=True)

print("Vocab size:", len(tokenizer.vocab))
 
Vocab size: 30522

একটি বাক্য Tokenize:

 tokens = tokenizer.tokenize("Hello TensorFlow!")
print(tokens)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
 
['hello', 'tensor', '##flow', '!']
[7592, 23435, 12314, 999]

Preprocess তথ্য

অধ্যায় নিজে বিন্যাস মডেল দ্বারা প্রত্যাশিত মধ্যে ডেটা সেটটি preprocessed।

তাই প্রাক-প্রক্রিয়াকরণ মেমরি দ্রুত এবং সহজে করা যেতে পারে এই সেটটি, ছোট। বৃহত্তর ডেটাসেট জন্য tf_models গ্রন্থাগার প্রাক-প্রক্রিয়াকরণ ও একটি ডেটাসেটের পুনরায় serializing জন্য কিছু টুলস অন্তর্ভুক্ত করা হয়েছে। দেখুন পরিশিষ্ট: একটি বৃহৎ ডেটাসেটের পুনরায় এনকোডিং বিস্তারিত জানার জন্য।

বাক্য এনকোড

মডেল আশা তার দুই ইনপুট বাক্য একসঙ্গে ঘনিভূত হবে। এই ইনপুট সঙ্গে একটি শুরু করার আশা করা হচ্ছে [CLS] টোকেন "এই একটি শ্রেণীবিভাগ সমস্যা", এবং প্রত্যেক বাক্যের একটি সঙ্গে শেষ হওয়া উচিত [SEP] "বিভাজক" টোকেন:

 tokenizer.convert_tokens_to_ids(['[CLS]', '[SEP]'])
 
[101, 102]

সব বাক্য এনকোডিং সংযোজন যখন একটি করে শুরু [SEP] টোকেন এবং তাদের জীর্ণ-tensors মধ্যে বোঁচকা:

 def encode_sentence(s):
   tokens = list(tokenizer.tokenize(s.numpy()))
   tokens.append('[SEP]')
   return tokenizer.convert_tokens_to_ids(tokens)

sentence1 = tf.ragged.constant([
    encode_sentence(s) for s in glue_train["sentence1"]])
sentence2 = tf.ragged.constant([
    encode_sentence(s) for s in glue_train["sentence2"]])
 
 print("Sentence1 shape:", sentence1.shape.as_list())
print("Sentence2 shape:", sentence2.shape.as_list())
 
Sentence1 shape: [3668, None]
Sentence2 shape: [3668, None]

এখন পূর্বে লিখুন একটি [CLS] টোকেন, এবং জীর্ণ tensors কনক্যাটেনেট একটি একক গঠন input_word_ids প্রতিটি উদাহরণস্বরূপ টেন্সর। RaggedTensor.to_tensor() দীর্ঘতম ক্রম শূন্য প্যাড।

 cls = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*sentence1.shape[0]
input_word_ids = tf.concat([cls, sentence1, sentence2], axis=-1)
_ = plt.pcolormesh(input_word_ids.to_tensor())
 

PNG

মাস্ক এবং ইনপুট টাইপ

মডেল দুটি অতিরিক্ত ইনপুট প্রত্যাশা করে:

  • ইনপুট মাস্ক
  • ইনপুট টাইপ

মাস্ক বিষয়বস্তু এবং প্যাডিং মধ্যে পরিচ্ছন্নভাবে পার্থক্য মডেল পারেন। মাস্ক হিসাবে একই আকৃতি আছে input_word_ids , এবং একটি রয়েছে 1 যে কোন জায়গায় input_word_ids প্যাডিং প্রয়োগ করা হয় না।

 input_mask = tf.ones_like(input_word_ids).to_tensor()

plt.pcolormesh(input_mask)
 
<matplotlib.collections.QuadMesh at 0x7f82246c0cf8>

PNG

"ইনপুট প্রকার" একই আকৃতি আছে, কিন্তু অ প্যাডেড অঞ্চল ভিতরে রয়েছে একটি 0 বা 1 ইঙ্গিত কোন বাক্যটি টোকেন এর একটি অংশ।

 type_cls = tf.zeros_like(cls)
type_s1 = tf.zeros_like(sentence1)
type_s2 = tf.ones_like(sentence2)
input_type_ids = tf.concat([type_cls, type_s1, type_s2], axis=-1).to_tensor()

plt.pcolormesh(input_type_ids)
 
<matplotlib.collections.QuadMesh at 0x7f8224668438>

PNG

এটি সব একসাথে রাখুন

একটি একক ফাংশন মধ্যে উপরের পাঠ্য পার্সিং কোড সংগ্রহ করুন, এবং প্রতিটি বিভক্ত এটি প্রয়োগ glue/mrpc ডেটা সেটটি।

 def encode_sentence(s, tokenizer):
   tokens = list(tokenizer.tokenize(s))
   tokens.append('[SEP]')
   return tokenizer.convert_tokens_to_ids(tokens)

def bert_encode(glue_dict, tokenizer):
  num_examples = len(glue_dict["sentence1"])
  
  sentence1 = tf.ragged.constant([
      encode_sentence(s, tokenizer)
      for s in np.array(glue_dict["sentence1"])])
  sentence2 = tf.ragged.constant([
      encode_sentence(s, tokenizer)
       for s in np.array(glue_dict["sentence2"])])

  cls = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*sentence1.shape[0]
  input_word_ids = tf.concat([cls, sentence1, sentence2], axis=-1)

  input_mask = tf.ones_like(input_word_ids).to_tensor()

  type_cls = tf.zeros_like(cls)
  type_s1 = tf.zeros_like(sentence1)
  type_s2 = tf.ones_like(sentence2)
  input_type_ids = tf.concat(
      [type_cls, type_s1, type_s2], axis=-1).to_tensor()

  inputs = {
      'input_word_ids': input_word_ids.to_tensor(),
      'input_mask': input_mask,
      'input_type_ids': input_type_ids}

  return inputs
 
 glue_train = bert_encode(glue['train'], tokenizer)
glue_train_labels = glue['train']['label']

glue_validation = bert_encode(glue['validation'], tokenizer)
glue_validation_labels = glue['validation']['label']

glue_test = bert_encode(glue['test'], tokenizer)
glue_test_labels  = glue['test']['label']
 

তথ্য প্রত্যেকটি উপসেট বৈশিষ্ট্য অভিধান এবং লেবেলগুলির একটি সেট রুপান্তরিত হয়েছে। ইনপুট অভিধান প্রতিটি বৈশিষ্ট্য একই আকৃতি আছে, এবং লেবেলের সংখ্যা মেলে উচিত:

 for key, value in glue_train.items():
  print(f'{key:15s} shape: {value.shape}')

print(f'glue_train_labels shape: {glue_train_labels.shape}')
 
input_word_ids  shape: (3668, 103)
input_mask      shape: (3668, 103)
input_type_ids  shape: (3668, 103)
glue_train_labels shape: (3668,)

মডেলটি

মডেল নির্মান

প্রথম পদক্ষেপ প্রাক প্রশিক্ষণ মডেল জন্য কনফিগারেশন ডাউনলোড করা।

 import json

bert_config_file = os.path.join(gs_folder_bert, "bert_config.json")
config_dict = json.loads(tf.io.gfile.GFile(bert_config_file).read())

bert_config = bert.configs.BertConfig.from_dict(config_dict)

config_dict
 
{'attention_probs_dropout_prob': 0.1,
 'hidden_act': 'gelu',
 'hidden_dropout_prob': 0.1,
 'hidden_size': 768,
 'initializer_range': 0.02,
 'intermediate_size': 3072,
 'max_position_embeddings': 512,
 'num_attention_heads': 12,
 'num_hidden_layers': 12,
 'type_vocab_size': 2,
 'vocab_size': 30522}

config কোর বার্ট মডেল, যার আউটপুট ভবিষ্যদ্বাণী করা একটি Keras মডেল সংজ্ঞায়িত num_classes সর্বাধিক ক্রম দৈর্ঘ্য সঙ্গে ইনপুট থেকে max_seq_length

এই ফাংশনটি উভয় এনকোডার এবং ক্লাসিফায়ার ফেরৎ।

 bert_classifier, bert_encoder = bert.bert_models.classifier_model(
    bert_config, num_labels=2)
 

ক্লাসিফায়ার তিন ইনপুট এবং এক আউটপুট আছে:

 tf.keras.utils.plot_model(bert_classifier, show_shapes=True, dpi=48)
 

PNG

তথ্য ট্রেনিং সেট থেকে 10 উদাহরণ একটি পরীক্ষা ব্যাচ তে এটি চালান। আউটপুট দুটি ক্লাস জন্য logits হল:

 glue_batch = {key: val[:10] for key, val in glue_train.items()}

bert_classifier(
    glue_batch, training=True
).numpy()
 
array([[ 0.05488977, -0.26042116],
       [ 0.11358108, -0.09727937],
       [ 0.14350253, -0.2465629 ],
       [ 0.2775127 , -0.09028438],
       [ 0.3606584 , -0.17138724],
       [ 0.3287397 , -0.14672714],
       [ 0.18621178, -0.13080403],
       [ 0.21898738,  0.10716071],
       [ 0.18413854, -0.13491377],
       [ 0.20307963, -0.05396855]], dtype=float32)

TransformerEncoder ক্লাসিফায়ার কেন্দ্রে উপরে bert_encoder

এনকোডার পরিদর্শন, আমরা দেখতে তার স্ট্যাক Transformer স্তর ঐ একই তিন ইনপুট সংযুক্ত:

 tf.keras.utils.plot_model(bert_encoder, show_shapes=True, dpi=48)
 

PNG

এনকোডার ওজন পুনরুদ্ধার করুন

বিল্ট এনকোডার এলোমেলোভাবে সক্রিয়া করা হয়। চেকপয়েন্ট থেকে এনকোডারের ওজন পুনঃস্থাপিত করো:

 checkpoint = tf.train.Checkpoint(model=bert_encoder)
checkpoint.restore(
    os.path.join(gs_folder_bert, 'bert_model.ckpt')).assert_consumed()
 
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f8242dadc88>

অপটিমাইজার সেট আপ করুন

বার্ট ওজন ক্ষয় (ওরফে "সঙ্গে আদম অপটিমাইজার গ্রহণ AdamW ")। এছাড়া একটি শেখার হার সময়তালিকা যে 0 থেকে প্রথমত উষ্ণ আপ এবং তারপর 0 decays নিয়োগ।

 # Set up epochs and steps
epochs = 3
batch_size = 32
eval_batch_size = 32

train_data_size = len(glue_train_labels)
steps_per_epoch = int(train_data_size / batch_size)
num_train_steps = steps_per_epoch * epochs
warmup_steps = int(epochs * train_data_size * 0.1 / batch_size)

# creates an optimizer with learning rate schedule
optimizer = nlp.optimization.create_optimizer(
    2e-5, num_train_steps=num_train_steps, num_warmup_steps=warmup_steps)
 

এই আয় একটি AdamWeightDecay শেখার হার সময়তালিকা সেট দিয়ে অপটিমাইজার:

 type(optimizer)
 
official.nlp.optimization.AdamWeightDecay

কিভাবে অপটিমাইজার এবং এটি সময়সূচী কাস্টমাইজ করতে একটি উদাহরণ দেখার জন্য, দেখুন অপ্টিমাইজার সময়তালিকা পরিশিষ্ট

মডেল ট্রেন

মেট্রিক সঠিকতা এবং আমরা ক্ষয় যেমন বিক্ষিপ্ত শ্রেণীগত ক্রস এনট্রপি ব্যবহার করুন।

 metrics = [tf.keras.metrics.SparseCategoricalAccuracy('accuracy', dtype=tf.float32)]
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

bert_classifier.compile(
    optimizer=optimizer,
    loss=loss,
    metrics=metrics)

bert_classifier.fit(
      glue_train, glue_train_labels,
      validation_data=(glue_validation, glue_validation_labels),
      batch_size=32,
      epochs=epochs)
 
Epoch 1/3
115/115 [==============================] - 25s 218ms/step - loss: 0.7047 - accuracy: 0.6101 - val_loss: 0.5219 - val_accuracy: 0.7181
Epoch 2/3
115/115 [==============================] - 24s 210ms/step - loss: 0.5068 - accuracy: 0.7560 - val_loss: 0.5047 - val_accuracy: 0.7794
Epoch 3/3
115/115 [==============================] - 24s 209ms/step - loss: 0.3812 - accuracy: 0.8332 - val_loss: 0.4839 - val_accuracy: 0.8137

<tensorflow.python.keras.callbacks.History at 0x7f82107c8cf8>

এখন দেখতে এটি কাজ করে একটি কাস্টম উদাহরণ ফাইন টিউন মডেল চালানো।

কিছু বাক্য জোড়া এনকোডিং দ্বারা শুরু করুন:

 my_examples = bert_encode(
    glue_dict = {
        'sentence1':[
            'The rain in Spain falls mainly on the plain.',
            'Look I fine tuned BERT.'],
        'sentence2':[
            'It mostly rains on the flat lands of Spain.',
            'Is it working? This does not match.']
    },
    tokenizer=tokenizer)
 

মডেল বর্গ জানানো উচিত 1 প্রথম উদাহরণ এবং ক্লাস-এর জন্য "ম্যাচ" 0 সেকেন্ডের জন্য "কোন ম্যাচ":

 result = bert_classifier(my_examples, training=False)

result = tf.argmax(result).numpy()
result
 
array([1, 0])
 np.array(info.features['label'].names)[result]
 
array(['equivalent', 'not_equivalent'], dtype='<U14')

মডেল সংরক্ষণ

প্রায়শই একটি মডেল প্রশিক্ষণ লক্ষ্য কিছুর জন্য এটি ব্যবহার করতে, তাই মডেল রপ্তানি এবং তারপর এটিকে পুনরুদ্ধার নিশ্চিত করুন যে এটি কাজ করে হতে হয়।

 export_dir='./saved_model'
tf.saved_model.save(bert_classifier, export_dir=export_dir)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

INFO:tensorflow:Assets written to: ./saved_model/assets

INFO:tensorflow:Assets written to: ./saved_model/assets

 reloaded = tf.saved_model.load(export_dir)
reloaded_result = reloaded([my_examples['input_word_ids'],
                            my_examples['input_mask'],
                            my_examples['input_type_ids']], training=False)

original_result = bert_classifier(my_examples, training=False)

# The results are (nearly) identical:
print(original_result.numpy())
print()
print(reloaded_result.numpy())
 
[[-1.1238481   0.92107666]
 [ 0.35722053 -0.4061358 ]]

[[-1.1238478   0.9210764 ]
 [ 0.35722044 -0.40613574]]

উপাঙ্গ

বৃহৎ ডেটাসেটের পুনরায় এনকোডিং

এই টিউটোরিয়ালটি আপনাকে মেমরি ডেটা সেটটি পুনরায় এনকোড, স্বচ্ছতার জন্য।

এটি কেবলমাত্র সম্ভব ছিল কারণ glue/mrpc একটি খুব ছোট ডেটা সেটটি নেই। বৃহত্তর ডেটাসেট মোকাবেলা করার জন্য tf_models গ্রন্থাগার প্রক্রিয়াকরণের ও দক্ষ প্রশিক্ষণের জন্য একটি ডেটাসেটের পুনরায় এনকোডিং জন্য কিছু টুলস অন্তর্ভুক্ত করা হয়েছে।

প্রথম পদক্ষেপ বর্ণনা করতে যা ডেটাসেটের বৈশিষ্ট্য রুপান্তরিত করা উচিত হল:

 processor = nlp.data.classifier_data_lib.TfdsProcessor(
    tfds_params="dataset=glue/mrpc,text_key=sentence1,text_b_key=sentence2",
    process_text_fn=bert.tokenization.convert_to_unicode)
 

তারপর নতুন TFRecord ফাইল জেনারেট করতে রূপান্তর প্রযোজ্য।

 # Set up output of training and evaluation Tensorflow dataset
train_data_output_path="./mrpc_train.tf_record"
eval_data_output_path="./mrpc_eval.tf_record"

max_seq_length = 128
batch_size = 32
eval_batch_size = 32

# Generate and save training data into a tf record file
input_meta_data = (
    nlp.data.classifier_data_lib.generate_tf_record_from_data_file(
      processor=processor,
      data_dir=None,  # It is `None` because data is from tfds, not local dir.
      tokenizer=tokenizer,
      train_data_output_path=train_data_output_path,
      eval_data_output_path=eval_data_output_path,
      max_seq_length=max_seq_length))
 

অবশেষে তৈরি tf.data ঐ TFRecord ফাইল থেকে ইনপুট পাইপলাইনগুলি:

 training_dataset = bert.run_classifier.get_dataset_fn(
    train_data_output_path,
    max_seq_length,
    batch_size,
    is_training=True)()

evaluation_dataset = bert.run_classifier.get_dataset_fn(
    eval_data_output_path,
    max_seq_length,
    eval_batch_size,
    is_training=False)()

 

ফলে tf.data.Datasets আগমন (features, labels) জোড়া দ্বারা আশানুরূপ keras.Model.fit :

 training_dataset.element_spec
 
({'input_word_ids': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None),
  'input_mask': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None),
  'input_type_ids': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None)},
 TensorSpec(shape=(32,), dtype=tf.int32, name=None))

প্রশিক্ষণ ও পরীক্ষা নিরীক্ষার জন্য tf.data.Dataset তৈরি করুন

আপনি এখানে ডাটা লোড পরিবর্তন করার প্রয়োজন হলে আপনি শুরু করতে কিছু কোড হল:

 def create_classifier_dataset(file_path, seq_length, batch_size, is_training):
  """Creates input dataset from (tf)records files for train/eval."""
  dataset = tf.data.TFRecordDataset(file_path)
  if is_training:
    dataset = dataset.shuffle(100)
    dataset = dataset.repeat()

  def decode_record(record):
    name_to_features = {
      'input_ids': tf.io.FixedLenFeature([seq_length], tf.int64),
      'input_mask': tf.io.FixedLenFeature([seq_length], tf.int64),
      'segment_ids': tf.io.FixedLenFeature([seq_length], tf.int64),
      'label_ids': tf.io.FixedLenFeature([], tf.int64),
    }
    return tf.io.parse_single_example(record, name_to_features)

  def _select_data_from_record(record):
    x = {
        'input_word_ids': record['input_ids'],
        'input_mask': record['input_mask'],
        'input_type_ids': record['segment_ids']
    }
    y = record['label_ids']
    return (x, y)

  dataset = dataset.map(decode_record,
                        num_parallel_calls=tf.data.experimental.AUTOTUNE)
  dataset = dataset.map(
      _select_data_from_record,
      num_parallel_calls=tf.data.experimental.AUTOTUNE)
  dataset = dataset.batch(batch_size, drop_remainder=is_training)
  dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
  return dataset
 
 # Set up batch sizes
batch_size = 32
eval_batch_size = 32

# Return Tensorflow dataset
training_dataset = create_classifier_dataset(
    train_data_output_path,
    input_meta_data['max_seq_length'],
    batch_size,
    is_training=True)

evaluation_dataset = create_classifier_dataset(
    eval_data_output_path,
    input_meta_data['max_seq_length'],
    eval_batch_size,
    is_training=False)
 
 training_dataset.element_spec
 
({'input_word_ids': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None),
  'input_mask': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None),
  'input_type_ids': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None)},
 TensorSpec(shape=(32,), dtype=tf.int64, name=None))

TFHub উপর TFModels বার্ট

আপনি পেতে পারেন বার্ট মডেল থেকে বালুচর বন্ধ TFHub । এটা এই উপরে একটি শ্রেণীবিভাগ মাথা যোগ করার জন্য হার্ড হবে না hub.KerasLayer

 # Note: 350MB download.
import tensorflow_hub as hub
hub_encoder = hub.KerasLayer(hub_url_bert, trainable=True)

print(f"The Hub encoder has {len(hub_encoder.trainable_variables)} trainable variables")
 
The Hub encoder has 199 trainable variables

টেস্ট ডেটার একটি ব্যাচ তে এটি চালানোর:

 result = hub_encoder(
    inputs=[glue_train['input_word_ids'][:10],
            glue_train['input_mask'][:10],
            glue_train['input_type_ids'][:10],],
    training=False,
)

print("Pooled output shape:", result[0].shape)
print("Sequence output shape:", result[1].shape)
 
Pooled output shape: (10, 768)
Sequence output shape: (10, 103, 768)

এই মুহুর্তে এটি একটি শ্রেণীবিন্যাস মাথা নিজেকে যোগ করার জন্য সহজ হবে।

bert_models.classifier_model ফাংশন এছাড়াও TensorFlow হাব থেকে এনকোডার সম্মুখের দিকে একটি ক্লাসিফায়ার নির্মাণ করতে পারেন:

 hub_classifier, hub_encoder = bert.bert_models.classifier_model(
    # Caution: Most of `bert_config` is ignored if you pass a hub url.
    bert_config=bert_config, hub_module_url=hub_url_bert, num_labels=2)
 

TFHub থেকে এই মডেল লোড করার জন্য এক downside হয় যে অভ্যন্তরীণ keras স্তর গঠন পুনঃস্থাপিত করা হয়। পরিদর্শন বা মডেল পরিবর্তন করতে সুতরাং এটি আরো কঠিন হবে। TransformerEncoder মডেলটি এখন একটি একক স্তরে হল:

 tf.keras.utils.plot_model(hub_classifier, show_shapes=True, dpi=64)
 

PNG

 try:
  tf.keras.utils.plot_model(hub_encoder, show_shapes=True, dpi=64)
  assert False
except Exception as e:
  print(f"{type(e).__name__}: {e}")
 
AttributeError: 'KerasLayer' object has no attribute 'layers'

নিম্ন স্তর মডেল ভবন

আপনার মডেলকে নির্মাণের উপর একটি আরো নিয়ন্ত্রণ প্রয়োজন এটা যে মূল্য classifier_model ফাংশন আগের ব্যবহৃত সত্যিই ওভার মাত্র একটি পাতলা মোড়কের হয় nlp.modeling.networks.TransformerEncoder এবং nlp.modeling.models.BertClassifier ক্লাস। শুধু মনে রাখবেন যে আপনি যদি স্থাপত্য পরিবর্তন শুরু এটা যাতে আপনি স্ক্র্যাচ থেকে আবার শেখতে করব সঠিক বা সম্ভব প্রাক প্রশিক্ষিত চেকপয়েন্ট পুনরায় লোড করার নাও হতে পারে।

এনকোডার তৈরি করুন:

 transformer_config = config_dict.copy()

# You need to rename a few fields to make this work:
transformer_config['attention_dropout_rate'] = transformer_config.pop('attention_probs_dropout_prob')
transformer_config['activation'] = tf_utils.get_activation(transformer_config.pop('hidden_act'))
transformer_config['dropout_rate'] = transformer_config.pop('hidden_dropout_prob')
transformer_config['initializer'] = tf.keras.initializers.TruncatedNormal(
          stddev=transformer_config.pop('initializer_range'))
transformer_config['max_sequence_length'] = transformer_config.pop('max_position_embeddings')
transformer_config['num_layers'] = transformer_config.pop('num_hidden_layers')

transformer_config
 
{'hidden_size': 768,
 'intermediate_size': 3072,
 'num_attention_heads': 12,
 'type_vocab_size': 2,
 'vocab_size': 30522,
 'attention_dropout_rate': 0.1,
 'activation': <function official.modeling.activations.gelu.gelu(x)>,
 'dropout_rate': 0.1,
 'initializer': <tensorflow.python.keras.initializers.initializers_v2.TruncatedNormal at 0x7f81145cb3c8>,
 'max_sequence_length': 512,
 'num_layers': 12}
 manual_encoder = nlp.modeling.networks.TransformerEncoder(**transformer_config)
 

ওজন পুনঃস্থাপিত করো:

 checkpoint = tf.train.Checkpoint(model=manual_encoder)
checkpoint.restore(
    os.path.join(gs_folder_bert, 'bert_model.ckpt')).assert_consumed()
 
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f813c336fd0>

টেস্ট এটি চালানোর:

 result = manual_encoder(my_examples, training=True)

print("Sequence output shape:", result[0].shape)
print("Pooled output shape:", result[1].shape)
 
Sequence output shape: (2, 23, 768)
Pooled output shape: (2, 768)

একটি ক্লাসিফায়ার এটা মোড়ানো:

 manual_classifier = nlp.modeling.models.BertClassifier(
        bert_encoder,
        num_classes=2,
        dropout_rate=transformer_config['dropout_rate'],
        initializer=tf.keras.initializers.TruncatedNormal(
          stddev=bert_config.initializer_range))
 
 manual_classifier(my_examples, training=True).numpy()
 
array([[-0.22512403,  0.07213479],
       [-0.21233292,  0.1311737 ]], dtype=float32)

Optimizers এবং সময়সূচীর

মডেল প্রশিক্ষণের ব্যবহৃত অপ্টিমাইজার ব্যবহার করে তৈরি করা হয়েছে nlp.optimization.create_optimizer ফাংশন:

 optimizer = nlp.optimization.create_optimizer(
    2e-5, num_train_steps=num_train_steps, num_warmup_steps=warmup_steps)
 

আপ শেখার হার সময়সূচী এবং অপটিমাইজার সেট মোড়কের যে উচ্চ স্তর।

বেস শেখার হার এখানে ব্যবহার সময়তালিকা প্রশিক্ষণ রান ওভার শুন্যতে একটি রৈখিক ক্ষয় হল:

 epochs = 3
batch_size = 32
eval_batch_size = 32

train_data_size = len(glue_train_labels)
steps_per_epoch = int(train_data_size / batch_size)
num_train_steps = steps_per_epoch * epochs
 
 decay_schedule = tf.keras.optimizers.schedules.PolynomialDecay(
      initial_learning_rate=2e-5,
      decay_steps=num_train_steps,
      end_learning_rate=0)

plt.plot([decay_schedule(n) for n in range(num_train_steps)])
 
[<matplotlib.lines.Line2D at 0x7f8115ab5320>]

PNG

এই ঘুরে একটি জড়িয়ে রাখা হয়েছে WarmUp সময়তালিকা সুসংগত উপর প্রশিক্ষণ প্রথম 10% লক্ষ্য মান শেখার হার বৃদ্ধি যে:

 warmup_steps = num_train_steps * 0.1

warmup_schedule = nlp.optimization.WarmUp(
        initial_learning_rate=2e-5,
        decay_schedule_fn=decay_schedule,
        warmup_steps=warmup_steps)

# The warmup overshoots, because it warms up to the `initial_learning_rate`
# following the original implementation. You can set
# `initial_learning_rate=decay_schedule(warmup_steps)` if you don't like the
# overshoot.
plt.plot([warmup_schedule(n) for n in range(num_train_steps)])
 
[<matplotlib.lines.Line2D at 0x7f81150c27f0>]

PNG

তারপর তৈরি nlp.optimization.AdamWeightDecay সময়সূচীর, বার্ট মডেল জন্য কনফিগার ব্যবহার করছে:

 optimizer = nlp.optimization.AdamWeightDecay(
        learning_rate=warmup_schedule,
        weight_decay_rate=0.01,
        epsilon=1e-6,
        exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias'])