সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

TPU- এ BERT ব্যবহার করে আঠালো কার্যগুলি সমাধান করুন

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub এ দেখুন নোটবুক ডাউনলোড করুন TF হাব মডেল দেখুন

প্রাকৃতিক ভাষা প্রক্রিয়াকরণের অনেক সমস্যা সমাধানের জন্য BERT ব্যবহার করা যেতে পারে। কীভাবে থেকে অনেক কাজের জন্য নিখুঁত টিউন বার্ট করা শিখতে হবে আঠালো বেঞ্চমার্ক :

  1. কোলা (ভাষাগত গ্রহণযোগ্যতার করপাস): বাক্য ব্যাকরণগতভাবে সঠিক?

  2. প্রথম পাতা-2 (স্ট্যানফোর্ড ভাবপ্রবণতা Treebank): কাজের একটি প্রদত্ত বাক্যের অনুভূতি ভবিষ্যদ্বাণী করা হয়।

  3. MRPC (মাইক্রোসফট গবেষণা ভাষান্তর করপাস): নির্ধারণ বাক্য একজোড়া শব্দার্থগতভাবে হয় সমতুল্য কিনা।

  4. QQP (কুয়োরা প্রশ্ন Pairs2): নির্ধারণ প্রশ্ন একজোড়া শব্দার্থগতভাবে হয় সমতুল্য কিনা।

  5. MNLI (মাল্টি-ঘরানার প্রাকৃতিক ভাষা ইনফিরেনস): প্রদত্ত প্রতিজ্ঞা বাক্য এবং একটি হাইপোথিসিস বাক্য, টাস্ক, প্রতিজ্ঞা entails কিনা হাইপোথিসিস (entailment) ভবিষ্যদ্বাণী করা হয় হাইপোথিসিস (অসঙ্গতি) contradicts বা হবেও (নিরপেক্ষ)।

  6. QNLI (প্রশ্নোত্তর উত্তর প্রাকৃতিক ভাষা ইনফিরেনস): কাজের কিনা তা নির্ধারণ করতে প্রেক্ষাপটে বাক্য প্রশ্নের উত্তর থাকে।

  7. আরটিই (স্বীকৃতিপ্রদান বিষয়বস্তুর Entailment): নির্ধারণ একটি বাক্য একটি প্রদত্ত হাইপোথিসিস entails বা না পারেন।

  8. WNLI (Winograd প্রাকৃতিক ভাষা ইনফিরেনস): কাজের যদি সর্বনাম প্রতিস্থাপিত সঙ্গে বাক্য মূল বাক্য দ্বারা entailed হয় ভবিষ্যদ্বাণী করা হয়।

এই টিউটোরিয়ালে এই মডেলগুলিকে একটি TPU-তে প্রশিক্ষণ দেওয়ার জন্য সম্পূর্ণ এন্ড-টু-এন্ড কোড রয়েছে। আপনি একটি GPU তে এই নোটবুকটি চালাতে পারেন, একটি লাইন পরিবর্তন করে (নীচে বর্ণিত)।

এই নোটবুকে, আপনি করবেন:

  • TensorFlow Hub থেকে একটি BERT মডেল লোড করুন
  • GLUE টাস্কগুলির মধ্যে একটি বেছে নিন এবং ডেটাসেট ডাউনলোড করুন
  • টেক্সট প্রিপ্রসেস করুন
  • ফাইন-টিউন BERT (একক-বাক্য এবং বহু-বাক্য ডেটাসেটের জন্য উদাহরণ দেওয়া হয়েছে)
  • প্রশিক্ষিত মডেল সংরক্ষণ করুন এবং এটি ব্যবহার করুন

সেটআপ

BERT ফাইন-টিউন করার জন্য টেক্সট ব্যবহার করার আগে প্রিপ্রসেস করার জন্য আপনি একটি আলাদা মডেল ব্যবহার করবেন। এই মডেল উপর নির্ভর করে tensorflow / পাঠ্য , আপনি নীচের ইনস্টল করবে পারে।

pip install -q -U tensorflow-text

আপনি এর থেকে AdamW অপটিমাইজার ব্যবহার করবে tensorflow / মডেল নিখুঁত টিউন বার্ট, যা আপনি পাশাপাশি ইনস্টল হবে।

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')
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/requests/__init__.py:104: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (2.3.0)/charset_normalizer (2.0.7) doesn't match a supported version!
  RequestsDependencyWarning)

এরপর, TFHub-এর ক্লাউড স্টোরেজ বালতি থেকে সরাসরি চেকপয়েন্ট পড়ার জন্য TFHub কনফিগার করুন। TPU-তে TFHub মডেল চালানোর সময় এটি শুধুমাত্র সুপারিশ করা হয়।

এই সেটিং ছাড়া TFHub সংকুচিত ফাইল ডাউনলোড করবে এবং স্থানীয়ভাবে চেকপয়েন্টটি বের করবে। এই স্থানীয় ফাইলগুলি থেকে লোড করার প্রচেষ্টা নিম্নলিখিত ত্রুটির সাথে ব্যর্থ হবে:

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

এর কারণ নমনীয় শুধুমাত্র ক্লাউড স্টোরেজ বাকেট থেকে সরাসরি পড়তে পারেন

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

TPU কর্মীর সাথে সংযোগ করুন

নিম্নলিখিত কোডটি টিপিইউ ওয়ার্কারের সাথে সংযোগ করে এবং টেনসরফ্লো-এর ডিফল্ট ডিভাইসটিকে টিপিইউ ওয়ার্কারের সিপিইউ ডিভাইসে পরিবর্তন করে। এটি একটি TPU বিতরণ কৌশলও সংজ্ঞায়িত করে যা আপনি এই একজন TPU কর্মীতে উপলব্ধ 8টি পৃথক 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.config.list_physical_devices('GPU'):
  strategy = tf.distribute.MirroredStrategy()
  print('Using GPU')
else:
  raise ValueError('Running on CPU is not recommended.')
Using TPU

টেনসরফ্লো হাব থেকে মডেল লোড হচ্ছে

এখানে আপনি টেনসরফ্লো হাব এবং ফাইন-টিউন থেকে কোন BERT মডেলটি লোড করবেন তা বেছে নিতে পারেন। বেছে নেওয়ার জন্য একাধিক BERT মডেল উপলব্ধ।

  • বার্ট-বেজ , Uncased এবং আরও সাত মডেলের মূল বার্ট লেখক দ্বারা মুক্তি প্রশিক্ষিত ওজন সঙ্গে।
  • ছোট BERTs একই স্থাপত্য কিন্তু তার চেয়ে কম এবং / অথবা ছোট ট্রান্সফরমার ব্লক, আপনি গতি, আকার এবং মানের মধ্যে tradeoffs এক্সপ্লোর করতে দেয় যা আছে।
  • ALBERT : যে স্তর মধ্যে পরামিতি ভাগ করে মডেল আকার (কিন্তু গণনার সময়) হ্রাস করা "একজন লাইট বার্ট" এর চারটি ভিন্ন মাপ।
  • বার্ট বিশেষজ্ঞরা : আট মডেল যে সব বার্ট-মূল আর্কিটেকচার আছে কিন্তু বিভিন্ন প্রাক প্রশিক্ষণ ডোমেইনের মধ্যে একটা চয়েস প্রস্তাব, লক্ষ্য কাজে আরো ঘনিষ্ঠভাবে সারিবদ্ধ।
  • ইলেকট্রা বার্ট হিসাবে একই স্থাপত্য (তিন বিভিন্ন আকারের) আছে, কিন্তু একটি সেট-আপ একটি discriminator যেমন প্রাক প্রশিক্ষিত পরার যে বর্ণনার অনুরূপ একটি সৃজক adversarial নেটওয়ার্ক (GAN)।
  • টকিং-নেতৃবৃন্দ মনোযোগ এবং সুরক্ষতাপূর্ণ GELU [সঙ্গে বার্ট বেস , বড় ] ট্রান্সফরমার স্থাপত্যের কোর দুই উন্নতি হয়েছে।

আরো বিস্তারিত জানার জন্য উপরে লিঙ্ক মডেল ডকুমেন্টেশন দেখুন.

এই টিউটোরিয়ালে, আপনি BERT-base দিয়ে শুরু করবেন। আপনি উচ্চ নির্ভুলতার জন্য বড় এবং আরও সাম্প্রতিক মডেলগুলি, বা দ্রুত প্রশিক্ষণের সময়গুলির জন্য ছোট মডেলগুলি ব্যবহার করতে পারেন৷ মডেল পরিবর্তন করতে, আপনাকে শুধুমাত্র কোডের একটি লাইন পরিবর্তন করতে হবে (নীচে দেখানো হয়েছে)। আপনি টেনসরফ্লো হাব থেকে ডাউনলোড করবেন সেভডমডেলে সমস্ত পার্থক্য এনক্যাপসুলেট করা হয়েছে।

সূক্ষ্ম সুর করার জন্য একটি 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

টেক্সট প্রিপ্রসেস করুন

উপর বার্ট সঙ্গে শ্রেণীভুক্ত টেক্সট colab প্রাক-প্রক্রিয়াকরণ মডেল সরাসরি বার্ট এনকোডার সঙ্গে এমবেডেড ব্যবহার করা হয়।

এই টিউটোরিয়ালটি প্রদর্শন করে যে কিভাবে প্রশিক্ষণের জন্য আপনার ইনপুট পাইপলাইনের অংশ হিসাবে প্রিপ্রসেসিং করতে হয়, Dataset.map ব্যবহার করে, এবং তারপরে অনুমানের জন্য রপ্তানি করা হয় এমন মডেলে এটি মার্জ করা যায়। এইভাবে, প্রশিক্ষণ এবং অনুমান উভয়ই কাঁচা টেক্সট ইনপুট থেকে কাজ করতে পারে, যদিও 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]]]>

প্রতিটি 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 , এবং একটি 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)

প্রিপ্রসেসিং মডেল দেখাই। আপনি দুটি বাক্য ইনপুট (input1 এবং input2) দিয়ে একটি পরীক্ষা তৈরি করবেন। : আউটপুট কি একটি বার্ট মডেল ইনপুট হিসাবে আশা নেই 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_word_ids', 'input_mask', 'input_type_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, show_shapes=True, show_dtype=True)
('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot 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):

  class Classifier(tf.keras.Model):
    def __init__(self, num_classes):
      super(Classifier, self).__init__(name="prediction")
      self.encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True)
      self.dropout = tf.keras.layers.Dropout(0.1)
      self.dense = tf.keras.layers.Dense(num_classes)

    def call(self, preprocessed_text):
      encoder_outputs = self.encoder(preprocessed_text)
      pooled_output = encoder_outputs["pooled_output"]
      x = self.dropout(pooled_output)
      x = self.dense(x)
      return x

  model = Classifier(num_classes)
  return model

আসুন কিছু প্রিপ্রসেসড ইনপুটগুলিতে মডেলটি চালানোর চেষ্টা করি।

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

GLUE থেকে একটি টাস্ক বেছে নিন

আপনার পক্ষ থেকে একটি TensorFlow ডেটা সেটটি ব্যবহার করতে যাচ্ছি আঠালো বেঞ্চমার্ক সুইট।

Colab আপনাকে স্থানীয় ফাইল সিস্টেমে এই ছোট ডেটাসেটগুলি ডাউনলোড করতে দেয় এবং নীচের কোডটি সেগুলি সম্পূর্ণরূপে মেমরিতে পড়ে, কারণ পৃথক TPU কর্মী হোস্ট কোল্যাব রানটাইমের স্থানীয় ফাইল সিস্টেম অ্যাক্সেস করতে পারে না।

বড় ডেটাসেট, আপনি আপনার নিজের তৈরি করতে হবে Google মেঘ সংগ্রহস্থল বালতি এবং নমনীয় কর্মী সেখান থেকে ডেটা পড়তে আছে। আপনি আরও জানতে পারেন নমনীয় নির্দেশিকা

CoLa ডেটাসেট (একক বাক্যের জন্য) বা MRPC (মাল্টি বাক্যের জন্য) দিয়ে শুরু করার পরামর্শ দেওয়া হচ্ছে কারণ এগুলো ছোট এবং সূক্ষ্ম সুর হতে বেশি সময় নেয় না।

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

আপনার মডেল প্রশিক্ষণ

অবশেষে, আপনি আপনার বেছে নেওয়া ডেটাসেটে মডেলটিকে এন্ড-টু-এন্ড প্রশিক্ষণ দিতে পারেন।

বিতরণ

উপরের সেট-আপ কোডটি স্মরণ করুন, যেটি একাধিক TPU ডিভাইসের সাথে একটি TPU কর্মীর সাথে কোলাব রানটাইমকে সংযুক্ত করেছে। তাদের উপর প্রশিক্ষণ বিতরণ করতে, আপনি TPU বিতরণ কৌশলের সুযোগের মধ্যে আপনার প্রধান কেরাস মডেল তৈরি এবং সংকলন করবেন। (বিস্তারিত জানার জন্য দেখুন, Keras সঙ্গে প্রশিক্ষণ বন্টিত ।)

অন্যদিকে, প্রিপ্রসেসিং, টিপিইউ নয়, কর্মী হোস্টের সিপিইউতে চলে, তাই প্রিপ্রসেসিংয়ের জন্য কেরাস মডেলের পাশাপাশি এটির সাথে ম্যাপ করা প্রশিক্ষণ এবং বৈধতা ডেটাসেটগুলি বিতরণ কৌশলের সুযোগের বাইরে তৈরি করা হয়েছে। কলে Model.fit() বিতরণ যত্ন নিতে হবে পাস-ইন মডেল প্রতিলিপি করতে ডেটা সেটটি।

অপ্টিমাইজার

ফাইন-টিউনিং অপটিমাইজার সেট-আপ বার্ট থেকে প্রাক প্রশিক্ষণ (হিসাবে অনুসরণ করে বার্ট সঙ্গে শ্রেণীভুক্ত টেক্সট এটি একটি ধারণাগত প্রাথমিক শিক্ষা হারের একটি রৈখিক ক্ষয় সঙ্গে AdamW অপটিমাইজার ব্যবহার করে, প্রথম ওভার একটি রৈখিক ওয়ার্ম আপ ফেজ প্রিফিক্স) প্রশিক্ষণ পদক্ষেপ (10% 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/keras/engine/functional.py:585: 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:449: 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 [==============================] - 86s 81ms/step - loss: 0.6092 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.4846 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 2/3
267/267 [==============================] - 14s 53ms/step - loss: 0.3774 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.5322 - val_MatthewsCorrelationCoefficient: 0.0000e+00
Epoch 3/3
267/267 [==============================] - 14s 53ms/step - loss: 0.2623 - MatthewsCorrelationCoefficient: 0.0000e+00 - val_loss: 0.6469 - val_MatthewsCorrelationCoefficient: 0.0000e+00

অনুমান জন্য রপ্তানি

আপনি একটি চূড়ান্ত মডেল তৈরি করবেন যাতে প্রিপ্রসেসিং অংশ এবং আমরা এইমাত্র তৈরি করেছি সূক্ষ্ম-টিউনড BERT।

অনুমানের সময়, প্রিপ্রসেসিংকে মডেলের অংশ হতে হবে (কারণ প্রশিক্ষণের ডেটার জন্য আলাদা ইনপুট সারি নেই যা এটি করে)। প্রিপ্রসেসিং শুধু গণনা নয়; এটির নিজস্ব সংস্থান রয়েছে (ভোকাব টেবিল) যা রপ্তানির জন্য সংরক্ষিত কেরাস মডেলের সাথে সংযুক্ত থাকতে হবে। এই চূড়ান্ত সমাবেশ কি সংরক্ষণ করা হবে.

আপনি 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.

মডেল পরীক্ষা করুন

চূড়ান্ত ধাপ হল আপনার এক্সপোর্ট করা মডেলের ফলাফল পরীক্ষা করা।

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

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'An old woman languished in the forest.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.7032353  3.3714833], shape=(2,), dtype=float32)

sentence: [b"I went to the movies and didn't pick up the shirts."]
This sentence is acceptable
BERT raw results: tf.Tensor([-0.73970896  1.0806316 ], shape=(2,), dtype=float32)

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

sentence: [b'Either Bill ate the peaches, or Harry.']
This sentence is unacceptable
BERT raw results: tf.Tensor([ 0.05972151 -0.08620442], shape=(2,), dtype=float32)

sentence: [b'I ran into the baker from whom I bought these bagels.']
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6862067  3.285925 ], shape=(2,), dtype=float32)

আপনি আপনার মডেল ব্যবহার করতে চান তাহলে মেমরি ভজনা , মনে রাখবেন যে এটা তার নামে স্বাক্ষর একজনের কাছ থেকে আপনার 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'Everyone attended more than two seminars.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.5594155  2.862155 ], shape=(2,), dtype=float32)

sentence: b'Most columnists claim that a senior White House official has been briefing them.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6298996  3.3155093], shape=(2,), dtype=float32)

sentence: b"That my father, he's lived here all his life is well known to those cops."
This sentence is acceptable
BERT raw results: tf.Tensor([-1.2048947  1.8589772], shape=(2,), dtype=float32)

sentence: b'Ourselves like us.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.2723312  2.0494034], shape=(2,), dtype=float32)

sentence: b'John is clever.'
This sentence is acceptable
BERT raw results: tf.Tensor([-1.6516167  3.3147635], shape=(2,), dtype=float32)

তুমি এটি করেছিলে! আপনার সংরক্ষিত মডেলটি কম কোড সহ একটি সহজ এপিআই সহ একটি প্রক্রিয়াতে পরিবেশন বা সাধারণ অনুমানের জন্য ব্যবহার করা যেতে পারে এবং বজায় রাখা সহজ।

পরবর্তী পদক্ষেপ

এখন যেহেতু আপনি বেস BERT মডেলগুলির মধ্যে একটি চেষ্টা করেছেন, আপনি আরও নির্ভুলতা অর্জনের জন্য অন্যগুলি চেষ্টা করতে পারেন বা সম্ভবত ছোট মডেল সংস্করণগুলির সাথে।

আপনি অন্যান্য ডেটাসেটেও চেষ্টা করতে পারেন।