 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub এ দেখুন |  নোটবুক ডাউনলোড করুন |
ওভারভিউ
টেক্সট প্রিপ্রসেসিং হল একটি মডেলের পূর্ণসংখ্যা ইনপুটগুলিতে কাঁচা পাঠের শেষ থেকে শেষ রূপান্তর। NLP মডেলগুলি প্রায়শই পাঠ্য প্রিপ্রসেস করার জন্য পাইথন কোডের কয়েকশো (যদি হাজার হাজার না) লাইনের সাথে থাকে। পাঠ্য প্রিপ্রসেসিং প্রায়শই মডেলগুলির জন্য একটি চ্যালেঞ্জ কারণ:
প্রশিক্ষণ-পরিষেবা তির্যক. মডেলের ইনপুটগুলির প্রি-প্রসেসিং লজিক মডেল ডেভেলপমেন্টের সমস্ত পর্যায়ে সামঞ্জস্যপূর্ণ কিনা তা নিশ্চিত করা ক্রমবর্ধমান কঠিন হয়ে ওঠে (যেমন প্রি-ট্রেনিং, ফাইন-টিউনিং, মূল্যায়ন, অনুমান)। বিভিন্ন হাইপারপ্যারামিটার, টোকেনাইজেশন, স্ট্রিং প্রি-প্রসেসিং অ্যালগরিদম ব্যবহার করা বা বিভিন্ন পর্যায়ে অসঙ্গতিপূর্ণভাবে মডেল ইনপুট প্যাকেজ করা মডেলটিতে কঠিন-ডিবাগ এবং বিপর্যয়কর প্রভাব ফেলতে পারে।
দক্ষতা এবং নমনীয়তা। যদিও প্রি-প্রসেসিং অফলাইনে করা যেতে পারে (যেমন ডিস্কের ফাইলগুলিতে প্রক্রিয়াকৃত আউটপুট লিখে এবং তারপর ইনপুট পাইপলাইনে বলা প্রি-প্রসেসড ডেটা পুনরায় ব্যবহার করে), এই পদ্ধতিতে একটি অতিরিক্ত ফাইল পড়ার এবং লেখার খরচ বহন করে। প্রি-প্রসেসিং অফলাইনেও অসুবিধাজনক যদি প্রি-প্রসেসিং সিদ্ধান্তগুলি গতিশীলভাবে ঘটতে হবে। একটি ভিন্ন বিকল্পের সাথে পরীক্ষা করার জন্য আবার ডেটাসেট পুনরায় তৈরি করা প্রয়োজন।
জটিল মডেল ইন্টারফেস। পাঠ্য মডেলগুলি অনেক বেশি বোধগম্য হয় যখন তাদের ইনপুটগুলি বিশুদ্ধ পাঠ্য হয়। একটি মডেল বোঝা কঠিন যখন এর ইনপুটগুলির জন্য একটি অতিরিক্ত, পরোক্ষ এনকোডিং পদক্ষেপের প্রয়োজন হয়৷ প্রিপ্রসেসিং জটিলতা হ্রাস করা বিশেষভাবে মডেল ডিবাগিং, পরিবেশন এবং মূল্যায়নের জন্য প্রশংসা করা হয়।
উপরন্তু, সহজ মডেল ইন্টারফেসগুলি বিভিন্ন, অনাবিষ্কৃত ডেটাসেটে মডেল (যেমন অনুমান বা প্রশিক্ষণ) চেষ্টা করা আরও সুবিধাজনক করে তোলে।
TF.Text সহ পাঠ্য প্রিপ্রসেসিং
TF.Text এর টেক্সট প্রিপ্রসেসিং API ব্যবহার করে, আমরা একটি প্রিপ্রসেসিং ফাংশন তৈরি করতে পারি যা ব্যবহারকারীর টেক্সট ডেটাসেটকে মডেলের পূর্ণসংখ্যা ইনপুটে রূপান্তর করতে পারে। ব্যবহারকারীরা উপরে উল্লিখিত সমস্যাগুলি দূর করতে তাদের মডেলের অংশ হিসাবে সরাসরি প্রিপ্রসেসিং প্যাকেজ করতে পারেন।
এই টিউটোরিয়ালটি কিভাবে TF.Text preprocessing অপস ব্যবহার করতে বার্ট মডেল এবং কার্য pretraining মাস্কিং ভাষার জন্য ইনপুট "মাস্ক LM ও কাচ পদ্ধতি" এর বর্ণিত ইনপুট মধ্যে টেক্সট ডাটা রুপান্তর দেখাবে ভাষার ডীপ দ্বিমুখী ট্রান্সফরমার প্রাক প্রশিক্ষণ: বার্ট বুঝতে পারা । প্রক্রিয়াটির মধ্যে পাঠ্যকে সাবওয়ার্ড ইউনিটে টোকেনাইজ করা, বাক্যগুলিকে একত্রিত করা, বিষয়বস্তুকে একটি নির্দিষ্ট আকারে ছাঁটাই করা এবং মুখোশযুক্ত ভাষা মডেলিং কাজের জন্য লেবেল বের করা জড়িত।
সেটআপ
আসুন প্রথমে আমাদের প্রয়োজনীয় প্যাকেজ এবং লাইব্রেরিগুলি আমদানি করি।
pip install -q -U tensorflow-text
import tensorflow as tf
import tensorflow_text as text
import functools
আমাদের তথ্য দুটি টেক্সট বৈশিষ্ট্য রয়েছে এবং আমরা একটি উদাহরণ তৈরি করতে পারেন tf.data.Dataset । আমাদের লক্ষ্য একটি ফাংশন যে আমরা সরবরাহ করতে পারে তৈরি করা Dataset.map() প্রশিক্ষণ ব্যবহৃত হবে না।
examples = {
"text_a": [
b"Sponge bob Squarepants is an Avenger",
b"Marvel Avengers"
],
"text_b": [
b"Barack Obama is the President.",
b"President is the highest office"
],
}
dataset = tf.data.Dataset.from_tensor_slices(examples)
next(iter(dataset))
{'text_a': <tf.Tensor: shape=(), dtype=string, numpy=b'Sponge bob Squarepants is an Avenger'>,
'text_b': <tf.Tensor: shape=(), dtype=string, numpy=b'Barack Obama is the President.'>}
টোকেনাইজিং
আমাদের প্রথম ধাপ হল যেকোনো স্ট্রিং প্রিপ্রসেসিং চালানো এবং আমাদের ডেটাসেটকে টোকেনাইজ করা। এই ব্যবহার করা যেতে পারে text.BertTokenizer , যা একটি হল text.Splitter যে জন্য subwords বা wordpieces বাক্যটিকে tokenize করতে বার্ট মডেল একটি শব্দভান্ডার থেকে উত্পন্ন দেওয়া Wordpiece অ্যালগরিদম । আপনি এর থেকে TF.Text পাওয়া অন্যান্য subword tokenizers সম্পর্কে আরও জানতে পারেন এখানে ।
শব্দভান্ডারটি পূর্বে তৈরি করা BERT চেকপয়েন্ট থেকে হতে পারে, অথবা আপনি নিজের ডেটাতে নিজেই একটি তৈরি করতে পারেন। এই উদাহরণের উদ্দেশ্যে, আসুন একটি খেলনা শব্দভাণ্ডার তৈরি করি:
_VOCAB = [
# Special tokens
b"[UNK]", b"[MASK]", b"[RANDOM]", b"[CLS]", b"[SEP]",
# Suffixes
b"##ack", b"##ama", b"##ger", b"##gers", b"##onge", b"##pants", b"##uare",
b"##vel", b"##ven", b"an", b"A", b"Bar", b"Hates", b"Mar", b"Ob",
b"Patrick", b"President", b"Sp", b"Sq", b"bob", b"box", b"has", b"highest",
b"is", b"office", b"the",
]
_START_TOKEN = _VOCAB.index(b"[CLS]")
_END_TOKEN = _VOCAB.index(b"[SEP]")
_MASK_TOKEN = _VOCAB.index(b"[MASK]")
_RANDOM_TOKEN = _VOCAB.index(b"[RANDOM]")
_UNK_TOKEN = _VOCAB.index(b"[UNK]")
_MAX_SEQ_LEN = 8
_MAX_PREDICTIONS_PER_BATCH = 5
_VOCAB_SIZE = len(_VOCAB)
lookup_table = tf.lookup.StaticVocabularyTable(
tf.lookup.KeyValueTensorInitializer(
keys=_VOCAB,
key_dtype=tf.string,
values=tf.range(
tf.size(_VOCAB, out_type=tf.int64), dtype=tf.int64),
value_dtype=tf.int64),
num_oov_buckets=1
)
আসুন কনস্ট্রাক্ট একটি text.BertTokenizer উপরে শব্দমালা ব্যবহার করে এবং একটি টেক্সট ইনপুট tokenize RaggedTensor .`।
bert_tokenizer = text.BertTokenizer(lookup_table, token_out_type=tf.string)
bert_tokenizer.tokenize(examples["text_a"])
<tf.RaggedTensor [[[b'Sp', b'##onge'], [b'bob'], [b'Sq', b'##uare', b'##pants'], [b'is'], [b'an'], [b'A', b'##ven', b'##ger']], [[b'Mar', b'##vel'], [b'A', b'##ven', b'##gers']]]>
bert_tokenizer.tokenize(examples["text_b"])
<tf.RaggedTensor [[[b'Bar', b'##ack'], [b'Ob', b'##ama'], [b'is'], [b'the'], [b'President'], [b'[UNK]']], [[b'President'], [b'is'], [b'the'], [b'highest'], [b'office']]]>
থেকে টেক্সট আউটপুট text.BertTokenizer দেখা যাক কিভাবে টেক্সট tokenized হচ্ছে পারবেন, কিন্তু মডেল পূর্ণসংখ্যা ID- র প্রয়োজন। আমরা সেট করতে পারেন token_out_type করার PARAM tf.int64 ID- র (যা শব্দভান্ডার মধ্যে সূচকের হয়) পূর্ণসংখ্যা প্রাপ্ত।
bert_tokenizer = text.BertTokenizer(lookup_table, token_out_type=tf.int64)
segment_a = bert_tokenizer.tokenize(examples["text_a"])
segment_a
<tf.RaggedTensor [[[22, 9], [24], [23, 11, 10], [28], [14], [15, 13, 7]], [[18, 12], [15, 13, 8]]]>
segment_b = bert_tokenizer.tokenize(examples["text_b"])
segment_b
<tf.RaggedTensor [[[16, 5], [19, 6], [28], [30], [21], [0]], [[21], [28], [30], [27], [29]]]>
text.BertTokenizer একটি ফেরৎ RaggedTensor আকৃতি সঙ্গে [batch, num_tokens, num_wordpieces] । যেহেতু আমরা অতিরিক্ত প্রয়োজন হবে না num_tokens আমাদের বর্তমান ব্যবহার ক্ষেত্রে জন্য মাত্রা, আমরা একটি প্রাপ্ত গত দুই মাত্রা মার্জ করতে পারবেন RaggedTensor আকৃতি সঙ্গে [batch, num_wordpieces] :
segment_a = segment_a.merge_dims(-2, -1)
segment_a
<tf.RaggedTensor [[22, 9, 24, 23, 11, 10, 28, 14, 15, 13, 7], [18, 12, 15, 13, 8]]>
segment_b = segment_b.merge_dims(-2, -1)
segment_b
<tf.RaggedTensor [[16, 5, 19, 6, 28, 30, 21, 0], [21, 28, 30, 27, 29]]>
বিষয়বস্তু ছাঁটাই
BERT-এর প্রধান ইনপুট হল দুটি বাক্যের সমন্বয়। যাইহোক, BERT-এর ইনপুটগুলি একটি নির্দিষ্ট-আকার এবং আকারে হওয়া প্রয়োজন এবং আমাদের কাছে এমন সামগ্রী থাকতে পারে যা আমাদের বাজেটের চেয়ে বেশি।
আমরা একটি ব্যবহার করে এই সাজসরঁজাম করতে text.Trimmer (একবার গত অক্ষ বরাবর ঘনিভূত) একটি পূর্ব নির্ধারিত মাপ আমাদের সামগ্রী নিচে ছাঁটা হয়। তারা আলাদা text.Trimmer ধরনের যা বিভিন্ন আলগোরিদিম ব্যবহার সংরক্ষণে বিষয়বস্তু নির্বাচন করুন। text.RoundRobinTrimmer উদাহরণস্বরূপ প্রত্যেক সেগমেন্ট জন্য সমানভাবে কোটা বরাদ্দ হবে কিন্তু বাক্য প্রান্ত ছাঁটা পারে। text.WaterfallTrimmer শেষ বাক্য শেষে থেকে শুরু ছাঁটা হবে।
আমাদের উদাহরণস্বরূপ, আমরা ব্যবহার করবে RoundRobinTrimmer একটি বাম-থেকে-ডান পদ্ধতিতে প্রত্যেক সেগমেন্ট থেকে যা নির্বাচন আইটেম।
trimmer = text.RoundRobinTrimmer(max_seq_length=[_MAX_SEQ_LEN])
trimmed = trimmer.trim([segment_a, segment_b])
trimmed
[<tf.RaggedTensor [[22, 9, 24, 23], [18, 12, 15, 13]]>, <tf.RaggedTensor [[16, 5, 19, 6], [21, 28, 30, 27]]>]
trimmed যেখানে একটি ব্যাচ জুড়ে উপাদানের সংখ্যা 8 উপাদান (যখন বরাবর অক্ষ = -1 ঘনিভূত) এখন অংশ রয়েছে।
সেগমেন্টের সমন্বয়
এখন যে আমরা অংশ ছাঁটা, আমরা তাদের একসঙ্গে একটি একক পেতে একত্রিত করতে পারেন RaggedTensor । বার্ট শুরুতে (ইঙ্গিত বিশেষ টোকেন ব্যবহার [CLS] ) এবং একটি সেগমেন্ট (শেষে [SEP] )। এছাড়াও আমরা একটি প্রয়োজন RaggedTensor যা মিলিত আইটেম ইঙ্গিত Tensor যা সেগমেন্ট অন্তর্গত। আমরা ব্যবহার করতে পারি text.combine_segments() এই দুটি পেতে Tensor সন্নিবেশিত বিশেষ টোকেন সঙ্গে।
segments_combined, segments_ids = text.combine_segments(
[segment_a, segment_b],
start_of_sequence_id=_START_TOKEN, end_of_segment_id=_END_TOKEN)
segments_combined, segments_ids
(<tf.RaggedTensor [[3, 22, 9, 24, 23, 11, 10, 28, 14, 15, 13, 7, 4, 16, 5, 19, 6, 28, 30, 21, 0, 4], [3, 18, 12, 15, 13, 8, 4, 21, 28, 30, 27, 29, 4]]>, <tf.RaggedTensor [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]]>)
মাস্কড ল্যাঙ্গুয়েজ মডেল টাস্ক
এখন যে আমরা আমাদের মৌলিক ইনপুট আছে, আমরা ইনপুট "মাস্ক LM ও কাচ পদ্ধতি" জন্য প্রয়োজন বের করে আনতে শুরু করতে পারবেন কাজের বর্ণিত বার্ট: ভাষা বোঝার জন্য ডীপ দ্বিমুখী ট্রান্সফরমার প্রাক প্রশিক্ষণ
মাস্কড ল্যাঙ্গুয়েজ মডেল টাস্কে আমাদের চিন্তা করার জন্য দুটি উপ-সমস্যা রয়েছে: (1) মাস্কিংয়ের জন্য কোন আইটেমগুলি নির্বাচন করতে হবে এবং (2) সেগুলি কী মান নির্ধারণ করা হয়েছে?
আইটেম নির্বাচন
যেহেতু আমরা এলোমেলোভাবে মাস্কিং জন্য আইটেম নির্বাচন করতে বেছে নেবেন, আমরা একটি ব্যবহার করা হবে text.RandomItemSelector । RandomItemSelector এলোমেলোভাবে দেওয়া সীমাবদ্ধতা (জন্য একটি ব্যাচ বিষয় আইটেম নির্বাচন max_selections_per_batch , selection_rate এবং unselectable_ids এবং) আয় একটি বুলিয়ান মাস্ক ইঙ্গিত যা আইটেম নির্বাচিত করা হয়েছে।
random_selector = text.RandomItemSelector(
max_selections_per_batch=_MAX_PREDICTIONS_PER_BATCH,
selection_rate=0.2,
unselectable_ids=[_START_TOKEN, _END_TOKEN, _UNK_TOKEN]
)
selected = random_selector.get_selection_mask(
segments_combined, axis=1)
selected
<tf.RaggedTensor [[False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, True, True, True, False, False], [False, False, False, False, False, True, False, False, False, False, False, True, False]]>
মুখোশযুক্ত মান নির্বাচন করা হচ্ছে
মুখোশের জন্য মান নির্বাচন করার জন্য মূল BERT কাগজের বর্ণনা করা পদ্ধতিটি নিম্নরূপ:
জন্য mask_token_rate সময় সঙ্গে আইটেমটি প্রতিস্থাপন [MASK] টোকেন:
"my dog is hairy" -> "my dog is [MASK]"
জন্য random_token_rate সময়, একটি র্যান্ডম শব্দ দিয়ে আইটেমটি প্রতিস্থাপন করুন:
"my dog is hairy" -> "my dog is apple"
জন্য 1 - mask_token_rate - random_token_rate সময়, আইটেম অপরিবর্তিত রাখবেন:
"my dog is hairy" -> "my dog is hairy."
text.MaskedValuesChooser এই যুক্তি encapsulates এবং আমাদের প্রাক-প্রক্রিয়াকরণ ফাংশন জন্য ব্যবহার করা যাবে। এখানে কি একটি উদাহরণ MaskValuesChooser আয় একটি প্রদত্ত mask_token_rate 80% এবং ডিফল্ট random_token_rate :
input_ids = tf.ragged.constant([[19, 7, 21, 20, 9, 8], [13, 4, 16, 5], [15, 10, 12, 11, 6]])
mask_values_chooser = text.MaskValuesChooser(_VOCAB_SIZE, _MASK_TOKEN, 0.8)
mask_values_chooser.get_mask_values(input_ids)
<tf.RaggedTensor [[1, 1, 1, 1, 1, 1], [1, 1, 1, 1], [1, 10, 1, 1, 6]]>
যখন একটি সঙ্গে সরবরাহকৃত RaggedTensor ইনপুট, text.MaskValuesChooser একটি ফেরৎ RaggedTensor পারেন সঙ্গে একই আকৃতি _MASK_VALUE (0), একটি র্যান্ডম আইডি, অথবা একই অপরিবর্তিত আইডি।
মাস্কড ল্যাঙ্গুয়েজ মডেল টাস্কের জন্য ইনপুট তৈরি করা হচ্ছে
এখন যে আমরা একটি আছে RandomItemSelector সাহায্য করতে আমাদের মাস্কিং এবং জন্য আইটেম নির্বাচন text.MaskValuesChooser মান দায়িত্ব অর্পণ করা, আমরা ব্যবহার করতে পারেন text.mask_language_model() আমাদের বার্ট মডেল জন্য এই কাজের সব ইনপুট জড় করা।
masked_token_ids, masked_pos, masked_lm_ids = text.mask_language_model(
segments_combined,
item_selector=random_selector, mask_values_chooser=mask_values_chooser)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/util/dispatch.py:206: batch_gather (from tensorflow.python.ops.array_ops) is deprecated and will be removed after 2017-10-25. Instructions for updating: `tf.batch_gather` is deprecated, please use `tf.gather` with `batch_dims=-1` instead.
আসুন ডুব গভীর এবং আউটপুটের পরীক্ষা mask_language_model() আউটপুট masked_token_ids হল:
masked_token_ids
<tf.RaggedTensor [[3, 22, 1, 24, 23, 1, 10, 28, 1, 15, 1, 7, 4, 16, 5, 19, 6, 28, 30, 21, 0, 4], [3, 18, 12, 15, 13, 1, 4, 21, 28, 30, 27, 1, 4]]>
মনে রাখবেন যে আমাদের ইনপুট একটি শব্দভান্ডার ব্যবহার করে এনকোড করা হয়েছে। আমরা যদি ডিকোড masked_token_ids আমাদের শব্দমালা ব্যবহার করে আমরা পাই:
tf.gather(_VOCAB, masked_token_ids)
<tf.RaggedTensor [[b'[CLS]', b'Sp', b'[MASK]', b'bob', b'Sq', b'[MASK]', b'##pants', b'is', b'[MASK]', b'A', b'[MASK]', b'##ger', b'[SEP]', b'Bar', b'##ack', b'Ob', b'##ama', b'is', b'the', b'President', b'[UNK]', b'[SEP]'], [b'[CLS]', b'Mar', b'##vel', b'A', b'##ven', b'[MASK]', b'[SEP]', b'President', b'is', b'the', b'highest', b'[MASK]', b'[SEP]']]>
লক্ষ্য করুন যে কিছু wordpiece টোকেন সঙ্গে পারেন প্রতিস্থাপিত করা হয়েছে [MASK] , [RANDOM] অথবা একটি ভিন্ন আইডি মান। masked_pos আউটপুট আমাদের টোকেন যে প্রতিস্থাপিত করা হয়েছে সূচকের (নিজ নিজ ব্যাচের মধ্যে) দেয়।
masked_pos
<tf.RaggedTensor [[2, 5, 8, 10], [5, 11]]>
masked_lm_ids আমাদের টোকেন মূল মান দেয়।
masked_lm_ids
<tf.RaggedTensor [[9, 11, 14, 13], [8, 29]]>
মানুষের পঠনযোগ্য মান পেতে আমরা আবার এখানে আইডি ডিকোড করতে পারি।
tf.gather(_VOCAB, masked_lm_ids)
<tf.RaggedTensor [[b'##onge', b'##uare', b'an', b'##ven'], [b'##gers', b'office']]>
প্যাডিং মডেল ইনপুট
এখন যে আমরা আমাদের মডেল জন্য সমস্ত ইনপুট আছে, আমাদের প্রাক-প্রক্রিয়াকরণ করার শেষ পদক্ষেপ তাদের 2-মাত্রিক সংশোধন মধ্যে প্যাকেজ হয় Tensor গুলি প্যাডিং সহ এবং একটি মাস্ক উৎপন্ন Tensor মান যা প্যাড মান নির্দেশ করে। আমরা ব্যবহার করতে পারি text.pad_model_inputs() এই কাজের সঙ্গে আমাদের সাহায্য করার জন্য।
# Prepare and pad combined segment inputs
input_word_ids, input_mask = text.pad_model_inputs(
masked_token_ids, max_seq_length=_MAX_SEQ_LEN)
input_type_ids, _ = text.pad_model_inputs(
masked_token_ids, max_seq_length=_MAX_SEQ_LEN)
# Prepare and pad masking task inputs
masked_lm_positions, masked_lm_weights = text.pad_model_inputs(
masked_token_ids, max_seq_length=_MAX_PREDICTIONS_PER_BATCH)
masked_lm_ids, _ = text.pad_model_inputs(
masked_lm_ids, max_seq_length=_MAX_PREDICTIONS_PER_BATCH)
model_inputs = {
"input_word_ids": input_word_ids,
"input_mask": input_mask,
"input_type_ids": input_type_ids,
"masked_lm_ids": masked_lm_ids,
"masked_lm_positions": masked_lm_positions,
"masked_lm_weights": masked_lm_weights,
}
model_inputs
{'input_word_ids': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[ 3, 22, 1, 24, 23, 1, 10, 28],
[ 3, 18, 12, 15, 13, 1, 4, 21]])>,
'input_mask': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])>,
'input_type_ids': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[ 3, 22, 1, 24, 23, 1, 10, 28],
[ 3, 18, 12, 15, 13, 1, 4, 21]])>,
'masked_lm_ids': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[ 9, 11, 14, 13, 0],
[ 8, 29, 0, 0, 0]])>,
'masked_lm_positions': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[ 3, 22, 1, 24, 23],
[ 3, 18, 12, 15, 13]])>,
'masked_lm_weights': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]])>}
পুনঃমূল্যায়ন
এখন পর্যন্ত আমরা যা পেয়েছি তা পর্যালোচনা করি এবং আমাদের প্রিপ্রসেসিং ফাংশনকে একত্রিত করি। আমাদের যা আছে তা এখানে:
def bert_pretrain_preprocess(vocab_table, features):
# Input is a string Tensor of documents, shape [batch, 1].
text_a = features["text_a"]
text_b = features["text_b"]
# Tokenize segments to shape [num_sentences, (num_words)] each.
tokenizer = text.BertTokenizer(
vocab_table,
token_out_type=tf.int64)
segments = [tokenizer.tokenize(text).merge_dims(
1, -1) for text in (text_a, text_b)]
# Truncate inputs to a maximum length.
trimmer = text.RoundRobinTrimmer(max_seq_length=6)
trimmed_segments = trimmer.trim(segments)
# Combine segments, get segment ids and add special tokens.
segments_combined, segment_ids = text.combine_segments(
trimmed_segments,
start_of_sequence_id=_START_TOKEN,
end_of_segment_id=_END_TOKEN)
# Apply dynamic masking task.
masked_input_ids, masked_lm_positions, masked_lm_ids = (
text.mask_language_model(
segments_combined,
random_selector,
mask_values_chooser,
)
)
# Prepare and pad combined segment inputs
input_word_ids, input_mask = text.pad_model_inputs(
masked_input_ids, max_seq_length=_MAX_SEQ_LEN)
input_type_ids, _ = text.pad_model_inputs(
masked_input_ids, max_seq_length=_MAX_SEQ_LEN)
# Prepare and pad masking task inputs
masked_lm_positions, masked_lm_weights = text.pad_model_inputs(
masked_input_ids, max_seq_length=_MAX_PREDICTIONS_PER_BATCH)
masked_lm_ids, _ = text.pad_model_inputs(
masked_lm_ids, max_seq_length=_MAX_PREDICTIONS_PER_BATCH)
model_inputs = {
"input_word_ids": input_word_ids,
"input_mask": input_mask,
"input_type_ids": input_type_ids,
"masked_lm_ids": masked_lm_ids,
"masked_lm_positions": masked_lm_positions,
"masked_lm_weights": masked_lm_weights,
}
return model_inputs
আমরা পূর্বে একটি নির্মাণ tf.data.Dataset এবং এখন আমরা আমাদের একত্র প্রাক-প্রক্রিয়াকরণ ফাংশন ব্যবহার করতে পারেন bert_pretrain_preprocess() মধ্যে Dataset.map() । এটি আমাদের কাঁচা স্ট্রিং ডেটাকে পূর্ণসংখ্যা ইনপুটে রূপান্তর করার জন্য একটি ইনপুট পাইপলাইন তৈরি করতে এবং সরাসরি আমাদের মডেলে ফিড করতে দেয়।
dataset = tf.data.Dataset.from_tensors(examples)
dataset = dataset.map(functools.partial(
bert_pretrain_preprocess, lookup_table))
next(iter(dataset))
{'input_word_ids': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[ 3, 22, 9, 1, 4, 16, 5, 19],
[ 3, 18, 1, 15, 4, 1, 28, 30]])>,
'input_mask': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])>,
'input_type_ids': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
array([[ 3, 22, 9, 1, 4, 16, 5, 19],
[ 3, 18, 1, 15, 4, 1, 28, 30]])>,
'masked_lm_ids': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[24, 19, 0, 0, 0],
[12, 21, 0, 0, 0]])>,
'masked_lm_positions': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[ 3, 22, 9, 1, 4],
[ 3, 18, 1, 15, 4]])>,
'masked_lm_weights': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]])>}
সম্পর্কিত টিউটোরিয়াল
বার্ট সঙ্গে শ্রেণীভুক্ত টেক্সট - কিভাবে শ্রেণীভুক্ত টেক্সট একটি pretrained বার্ট মডেল ব্যবহার করতে উপর একটি টিউটোরিয়াল। এটি এখন একটি চমৎকার ফলো আপ কারণ আপনি BERT মডেলের দ্বারা ব্যবহৃত ইনপুটগুলিকে কীভাবে প্রিপ্রসেস করতে হয় তার সাথে পরিচিত।
মেমরি পাঠ্য এই দিয়ে Tokenizing - টিউটোরিয়াল tokenizers বিভিন্ন ধরনের যে TF.Text মধ্যে উপস্থিত বিশদ।
সঙ্গে লেখা পরিচালনা
RaggedTensor- কিভাবে ব্যবহার তৈরি, এবং নিপূণভাবে উপর বিশদ নির্দেশিকাRaggedTensorগুলি।