TensorFlow در 14 مه به Google I/O بازگشته است! همین الان ثبت نام کنید

این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

پیش پردازش BERT با TF Text

مشاهده در TensorFlow.org

در Google Colab اجرا شود

در GitHub مشاهده کنید

دانلود دفترچه یادداشت

بررسی اجمالی

پیش پردازش متن، تبدیل سرتاسر متن خام به ورودی های عدد صحیح مدل است. مدل‌های NLP اغلب با صدها (اگر نه هزاران) خط کد پایتون برای پیش‌پردازش متن همراه هستند. پیش پردازش متن اغلب برای مدل ها یک چالش است زیرا:

چوله آموزشی-سرویس. اطمینان از سازگاری منطق پیش پردازش ورودی های مدل در تمام مراحل توسعه مدل (مثلاً پیش آموزش، تنظیم دقیق، ارزیابی، استنتاج) به طور فزاینده ای دشوار می شود. استفاده از هایپرپارامترهای مختلف، نشانه گذاری، الگوریتم های پیش پردازش رشته یا صرفاً بسته بندی ورودی های مدل به طور متناقض در مراحل مختلف می تواند اشکال زدایی سخت و اثرات مخربی را برای مدل به همراه داشته باشد.
کارایی و انعطاف پذیری. در حالی که پیش پردازش را می توان به صورت آفلاین انجام داد (مثلاً با نوشتن خروجی های پردازش شده روی فایل های روی دیسک و سپس مصرف مجدد داده های پیش پردازش شده در خط لوله ورودی)، این روش هزینه خواندن و نوشتن فایل اضافی را به همراه دارد. اگر تصمیمات پیش پردازشی وجود داشته باشد که باید به صورت پویا اتفاق بیفتد، پیش پردازش آفلاین نیز ناخوشایند است. آزمایش با یک گزینه دیگر نیاز به تولید مجدد مجموعه داده دارد.
رابط مدل پیچیده مدل‌های متنی زمانی که ورودی‌های آن‌ها متن خالص باشد، بسیار قابل درک‌تر هستند. درک یک مدل زمانی که ورودی های آن نیاز به یک مرحله کدگذاری غیرمستقیم اضافی دارند، دشوار است. کاهش پیچیدگی پیش پردازش به ویژه برای اشکال زدایی مدل، سرویس دهی و ارزیابی مورد استقبال قرار می گیرد.

علاوه بر این، رابط‌های مدل ساده‌تر، آزمایش مدل (مثلاً استنتاج یا آموزش) را بر روی مجموعه داده‌های مختلف و ناشناخته راحت‌تر می‌کند.

پیش پردازش متن با TF.Text

با استفاده از APIهای پیش پردازش متن TF.Text، می توانیم یک تابع پیش پردازش بسازیم که می تواند مجموعه داده متنی کاربر را به ورودی های عدد صحیح مدل تبدیل کند. کاربران می توانند پیش پردازش را مستقیماً به عنوان بخشی از مدل خود بسته بندی کنند تا مشکلات ذکر شده در بالا را کاهش دهند.

این آموزش نشان می دهد که چگونه به استفاده TF.Text عملیات پیش پردازش برای تبدیل داده های متن را به ورودی برای مدل برت و ورودی برای زبان پوشش 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 . شما می توانید اطلاعات بیشتر در مورد سایر 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 ها، اما مدل نیاز به شناسه عدد صحیح است. ما می توانیم مجموعه ای 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)، یک ID به صورت تصادفی، و یا همان شناسه بدون تغییر.

ایجاد ورودی برای کار مدل زبان ماسک شده

حالا که ما یک 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]])>}

آموزش های مرتبط

متن طبقه بندی با برت - آموزش A در چگونه به استفاده از یک مدل برت pretrained به متن طبقه بندی. اکنون که با نحوه پیش پردازش ورودی های استفاده شده توسط مدل BERT آشنا شده اید، این یک پیگیری خوب است.
Tokenizing با TF متن - آموزش جزئیات انواع مختلف tokenizers که در TF.Text وجود داشته باشد.
سیستم های انتقال مواد متن با RaggedTensor - راهنمای مفصل در مورد چگونگی ایجاد، استفاده و دستکاری RaggedTensor است.