مساعدة في حماية الحاجز المرجاني العظيم مع TensorFlow على Kaggle تاريخ التحدي

معالجة BERT مع نص TF

عرض على TensorFlow.org تشغيل في Google Colab عرض على جيثب تحميل دفتر

ملخص

المعالجة المسبقة للنص هي التحويل من طرف إلى طرف للنص الخام إلى مدخلات عدد صحيح للنموذج. غالبًا ما تكون نماذج البرمجة اللغوية العصبية مصحوبة بمئات (إن لم يكن الآلاف) من سطور كود Python للمعالجة المسبقة للنص. غالبًا ما تمثل المعالجة المسبقة للنص تحديًا للنماذج للأسباب التالية:

  • انحراف خدمة التدريب. يصبح من الصعب بشكل متزايد التأكد من أن منطق المعالجة المسبقة لمدخلات النموذج متسق في جميع مراحل تطوير النموذج (مثل التدريب المسبق ، والضبط الدقيق ، والتقييم ، والاستدلال). يمكن أن يؤدي استخدام المعلمات الفائقة المختلفة ، أو الترميز ، أو خوارزميات المعالجة المسبقة للسلسلة أو مجرد تجميع مدخلات النموذج بشكل غير متسق في مراحل مختلفة ، إلى تأثيرات كارثية يصعب تصحيحها على النموذج.

  • الكفاءة والمرونة. بينما يمكن إجراء المعالجة المسبقة في وضع عدم الاتصال (على سبيل المثال عن طريق كتابة المخرجات المعالجة إلى الملفات الموجودة على القرص ثم إعادة استهلاك البيانات المذكورة مسبقًا في خط أنابيب الإدخال) ، فإن هذه الطريقة تتحمل تكلفة إضافية للقراءة والكتابة للملف. المعالجة المسبقة في وضع عدم الاتصال غير ملائمة أيضًا إذا كانت هناك قرارات معالجة مسبقة يجب أن تحدث ديناميكيًا. قد تتطلب تجربة خيار مختلف إعادة إنشاء مجموعة البيانات مرة أخرى.

  • واجهة نموذج معقدة. تكون النماذج النصية أكثر قابلية للفهم عندما تكون مدخلاتها نصًا خالصًا. من الصعب فهم النموذج عندما تتطلب مدخلاته خطوة ترميز إضافية غير مباشرة. يتم تقدير تقليل تعقيد المعالجة المسبقة بشكل خاص لتصحيح النموذج وتقديمه وتقييمه.

بالإضافة إلى ذلك ، تجعل واجهات النموذج الأبسط أيضًا تجربة النموذج أكثر ملاءمة (مثل الاستدلال أو التدريب) على مجموعات بيانات مختلفة غير مستكشفة.

معالجة النص مسبقًا باستخدام TF.Text

باستخدام واجهات برمجة تطبيقات المعالجة المسبقة للنص في TF.Text ، يمكننا إنشاء وظيفة معالجة مسبقة يمكنها تحويل مجموعة بيانات نص المستخدم إلى مدخلات عدد صحيح للنموذج. يمكن للمستخدمين حزم المعالجة المسبقة مباشرةً كجزء من نموذجهم للتخفيف من المشكلات المذكورة أعلاه.

هذا البرنامج التعليمي سوف تظهر كيفية استخدام TF.Text التقاط تجهيزها لتحويل البيانات النص إلى مدخلات لنموذج بيرت والمدخلات للغة اخفاء ما قبل التدرب مهمة وصفها في "ملثمون 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 التي يمكن tokenize الجمل في subwords أو wordpieces لل نموذج بيرت إعطاء المفردات المتولدة من خوارزمية Wordpiece . يمكنك معرفة المزيد عن tokenizers subword الأخرى المتاحة في TF.Text من هنا .

يمكن أن تكون المفردات من نقطة تفتيش 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 يسمح لنا نرى كيف يتم برموز والنص، ولكن هذا النموذج يتطلب معرفات عدد صحيح. فإننا يمكن أن يحدد token_out_type المعلمة إلى tf.int64 للحصول على عدد صحيح معرفات (التي هي مؤشرات إلى المفردات).

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 بتغليف هذا المنطق، ويمكن استخدامها من أجل وظيفة تجهيزها لدينا. وهنا مثال على ما 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] أو قيمة ID مختلفة. 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 مع TF نص - دروس بالتفصيل أنواع مختلفة من tokenizers الموجودة في TF.Text.

  • التعامل مع النص مع RaggedTensor - دليل مفصل حول كيفية إنشاء واستخدام والتلاعب RaggedTensor الصورة.