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

একটি বিইআরটি মডেলকে ফাইন-টিউন করা

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন টিএফ হাব মডেল দেখুন

এই উদাহরণে, আমরা টেনসরফ্লো-মডেল পিআইপি প্যাকেজটি ব্যবহার করে একটি বিইআরটি মডেলকে সূক্ষ্ম-সুর করার মাধ্যমে কাজ করব।

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

সেটআপ

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

  • tf-models-official মডেলস tf-models-official হ'ল স্থিতিশীল মডেল গার্ডেন প্যাকেজ। মনে রাখবেন এটিতে tensorflow_models সর্বশেষ পরিবর্তনগুলি অন্তর্ভুক্ত নাও হতে পারে। সর্বশেষ পরিবর্তনগুলি অন্তর্ভুক্ত করার জন্য, আপনি tf-models-nightly ইনস্টল করতে পারেন যা নাইটলি মডেল গার্ডেন প্যাকেজ প্রতিদিন স্বয়ংক্রিয়ভাবে তৈরি হয়।
  • পিপ স্বয়ংক্রিয়ভাবে সমস্ত মডেল এবং নির্ভরতা ইনস্টল করবে।
pip install -q tf-models-official==2.3.0
WARNING: You are using pip version 20.2.3; however, version 20.2.4 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.

আমদানি

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

রিসোর্স

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

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

আপনি টেনসরফ্লো হাব থেকে একটি প্রাক-প্রশিক্ষিত বিআরটি এনকোডার পেতে পারেন:

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

তথ্যটি

এই উদাহরণের জন্য আমরা টিএফডিএস থেকে গ্লু এমআরপিসি ডেটাসেট ব্যবহার করেছি

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

টেনসরফ্লো ডেটাসেট থেকে ডেটাসেট পান

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

  • লেবেলের সংখ্যা: 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...
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incompleteKZIBN9/glue-train.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incompleteKZIBN9/glue-validation.tfrecord
Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incompleteKZIBN9/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 .'

বিইআরটি টোকেনাইজার

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

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

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

# 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

একটি বাক্য টোকেনাইজ করুন:

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

ডেটা অগ্রসর করুন

বিভাগটি ম্যানুয়ালি মডেল দ্বারা প্রত্যাশিত ফর্ম্যাটে ডেটাसेटকে প্রস্রোস করেছে।

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

বাক্যগুলি এনকোড করুন

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

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

একটি [SEP] টোকেন সংযুক্ত করার সময় সমস্ত বাক্য এনকোড করে শুরু করুন এবং সেগুলি রাগড-টেনেসারে প্যাক করুন:

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] টোকেন প্রস্তুত করুন, এবং প্রতিটি উদাহরণের জন্য একটি একক input_word_ids টেনসর গঠনের জন্য input_word_idsRaggedTensor.to_tensor() দীর্ঘতম ক্রমের শূন্য প্যাড 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())

পিএনজি

মুখোশ এবং ইনপুট প্রকার

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

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

মুখোশটি মডেলটিকে সামগ্রী এবং প্যাডিংয়ের মধ্যে পরিষ্কারভাবে পার্থক্য করতে দেয়। মাস্কটির input_word_ids সমান আকৃতি রয়েছে এবং input_word_ids প্যাডিং নয় এমন যে কোনও জায়গায় 1 রয়েছে।

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

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

পিএনজি

"ইনপুট টাইপ" তেও একই আকৃতি রয়েছে তবে নন-প্যাডযুক্ত অঞ্চলের ভিতরে 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 0x7fad143c1710>

পিএনজি

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

উপরের পাঠ্য পার্সিং কোডটি একটি ফাংশনে সংগ্রহ করুন এবং 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)

পিএনজি

প্রশিক্ষণের সেট থেকে 10 টি উদাহরণের টেস্ট ব্যাচে এটি চালান। আউটপুটটি দুটি শ্রেণীর লগইট:

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

bert_classifier(
    glue_batch, training=True
).numpy()
array([[ 0.08382261,  0.34465584],
       [ 0.02057236,  0.24053624],
       [ 0.04930754,  0.1117427 ],
       [ 0.17041089,  0.20810834],
       [ 0.21667874,  0.2840511 ],
       [ 0.02325345,  0.33799925],
       [-0.06198866,  0.13532838],
       [ 0.084592  ,  0.20711854],
       [-0.04323687,  0.17096342],
       [ 0.23759182,  0.16801538]], dtype=float32)

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

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

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

পিএনজি

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

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

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 0x7fad4580ffd0>

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

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

# 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 [==============================] - 26s 222ms/step - loss: 0.6151 - accuracy: 0.6611 - val_loss: 0.5462 - val_accuracy: 0.7451
Epoch 2/3
115/115 [==============================] - 24s 212ms/step - loss: 0.4447 - accuracy: 0.8010 - val_loss: 0.4150 - val_accuracy: 0.8309
Epoch 3/3
115/115 [==============================] - 24s 213ms/step - loss: 0.2830 - accuracy: 0.8964 - val_loss: 0.3697 - val_accuracy: 0.8480

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

এখন এটি কার্যকর হয় তা দেখার জন্য একটি কাস্টম উদাহরণে সূক্ষ্ম সুরযুক্ত মডেলটি চালান।

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

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())
[[-0.95450354  1.1227685 ]
 [ 0.40344787 -0.58954155]]

[[-0.95450354  1.1227684 ]
 [ 0.4034478  -0.5895414 ]]

পরিশিষ্ট

একটি বড় ডেটাसेट পুনরায় এনকোডিং

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

এটি কেবলমাত্র সম্ভব ছিল কারণ 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)

তারপরে নতুন টিএফআরকর্ড ফাইল তৈরি করতে রূপান্তরটি প্রয়োগ করুন।

# 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 ইনপুট পাইপলাইনগুলি তৈরি করুন:

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) জোড়া ফিরে আসে (features, labels) keras.Model.fit দ্বারা প্রত্যাশিত 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 BERT

আপনি টিএফএইচবি থেকে শেল্ফের বাইরে বিআরটি মডেলটি পেতে পারেন। এই hub.KerasLayer উপরে একটি শ্রেণিবিন্যাসের মাথা যুক্ত করা কঠিন হবে না hub.KerasLayer

# Note: 350MB download.
import tensorflow_hub as hub
hub_model_name = "bert_en_uncased_L-12_H-768_A-12" 
hub_encoder = hub.KerasLayer(f"https://tfhub.dev/tensorflow/{hub_model_name}/2",
                             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 ফাংশন bert_models.classifier_model হাব থেকে এনকোডারটিতে একটি শ্রেণিবদ্ধও তৈরি করতে পারে:

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)

টিএফএইচবি থেকে এই মডেলটি লোড করার একটি খারাপ দিক হ'ল অভ্যন্তরীণ কেরাস স্তরগুলির কাঠামো পুনরুদ্ধার করা হয়নি। সুতরাং মডেলটি পরীক্ষা করা বা সংশোধন করা আরও কঠিন TransformerEncoder মডেল এখন একক স্তর:

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

পিএনজি

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 0x7fac08046e10>,
 '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 0x7fabefa596d8>

এটি পরীক্ষা করুন:

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.07863025, -0.02940944],
       [ 0.30274656,  0.27299827]], dtype=float32)

অপ্টিমাইজার এবং সময়সূচী

মডেলটিকে প্রশিক্ষণ দেওয়ার জন্য ব্যবহৃত অপটিমাইজারটি 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 0x7fabef5e69e8>]

পিএনজি

এগুলি পরিবর্তে একটি WarmUp শিডিয়ুলের সাথে আবৃত হয় যা প্রশিক্ষণের প্রথম 10% এর তুলনায় WarmUp শিক্ষার হারকে লক্ষ্য মানকে বাড়িয়ে WarmUp :

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 0x7fabef559630>]

পিএনজি

তারপরে nlp.optimization.AdamWeightDecay মডেলের জন্য কনফিগার করা সেই সময়সূচীটি ব্যবহার করে 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'])