TensorFlow sẽ trở lại tại Google I/O vào ngày 14 tháng 5! Đăng ký ngay bây giờ

Trang này được dịch bởi Cloud Translation API.

BERT Tiền xử lý với Văn bản TF

Xem trên TensorFlow.org

Chạy trong Google Colab

Xem trên GitHub

Tải xuống sổ ghi chép

Tổng quat

Tiền xử lý văn bản là sự chuyển đổi từ đầu đến cuối của văn bản thô thành đầu vào số nguyên của mô hình. Các mô hình NLP thường đi kèm với hàng trăm (nếu không phải hàng nghìn) dòng mã Python để xử lý trước văn bản. Xử lý trước văn bản thường là một thách thức đối với các mô hình vì:

Đào tạo-phục vụ xiên. Ngày càng khó đảm bảo rằng logic tiền xử lý của các đầu vào của mô hình là nhất quán ở tất cả các giai đoạn phát triển mô hình (ví dụ: đào tạo trước, tinh chỉnh, đánh giá, suy luận). Sử dụng các siêu tham số khác nhau, mã hóa, thuật toán tiền xử lý chuỗi hoặc chỉ đơn giản là đóng gói đầu vào mô hình không nhất quán ở các giai đoạn khác nhau có thể mang lại những tác động khó gỡ lỗi và tai hại cho mô hình.
Hiệu quả và tính linh hoạt. Trong khi tiền xử lý có thể được thực hiện ngoại tuyến (ví dụ: bằng cách ghi đầu ra đã xử lý ra tệp trên đĩa và sau đó khôi phục lại dữ liệu đã xử lý trước đó trong đường dẫn đầu vào), phương pháp này phát sinh thêm chi phí đọc và ghi tệp. Tiền xử lý ngoại tuyến cũng không thuận tiện nếu có các quyết định tiền xử lý cần phải xảy ra động. Thử nghiệm với một tùy chọn khác sẽ yêu cầu tạo lại tập dữ liệu.
Giao diện mô hình phức tạp. Các mô hình văn bản dễ hiểu hơn nhiều khi đầu vào của chúng là văn bản thuần túy. Thật khó để hiểu một mô hình khi đầu vào của nó yêu cầu thêm một bước mã hóa gián tiếp. Giảm độ phức tạp tiền xử lý đặc biệt được đánh giá cao đối với việc gỡ lỗi, phân phát và đánh giá mô hình.

Ngoài ra, các giao diện mô hình đơn giản hơn cũng giúp thuận tiện hơn khi thử mô hình (ví dụ: suy luận hoặc đào tạo) trên các tập dữ liệu khác nhau, chưa được khám phá.

Xử lý trước văn bản với TF.Text

Sử dụng các API tiền xử lý văn bản của TF.Text, chúng tôi có thể xây dựng một hàm tiền xử lý có thể chuyển đổi tập dữ liệu văn bản của người dùng thành các đầu vào số nguyên của mô hình. Người dùng có thể đóng gói tiền xử lý trực tiếp như một phần của mô hình của họ để giảm bớt các vấn đề đã đề cập ở trên.

Hướng dẫn này sẽ hiển thị cách sử dụng TF.Text ops tiền xử lý để chuyển đổi dữ liệu văn bản vào đầu vào cho các mô hình Bert và đầu vào cho ngôn ngữ che pretraining nhiệm vụ được mô tả trong "Masked LM và Masking Thủ tục" của Bert: Pre-đào tạo sâu hai chiều Transformers cho ngôn ngữ hiểu biết . Quá trình này bao gồm việc mã hóa văn bản thành các đơn vị từ khóa con, kết hợp các câu, cắt nội dung theo một kích thước cố định và trích xuất các nhãn cho tác vụ mô hình hóa ngôn ngữ được che giấu.

Thành lập

Trước tiên, hãy nhập các gói và thư viện mà chúng ta cần.

pip install -q -U tensorflow-text

import tensorflow as tf
import tensorflow_text as text
import functools

Dữ liệu của chúng tôi bao gồm hai tính năng văn bản và chúng ta có thể tạo ra một ví dụ tf.data.Dataset . Mục tiêu của chúng tôi là tạo ra một chức năng mà chúng ta có thể cung cấp Dataset.map() với được sử dụng trong đào tạo.

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.'>}

Mã hóa

Bước đầu tiên của chúng tôi là chạy bất kỳ quá trình tiền xử lý chuỗi nào và mã hóa tập dữ liệu của chúng tôi. Điều này có thể được thực hiện bằng cách sử dụng text.BertTokenizer , mà là một text.Splitter có thể tokenize câu vào subwords hoặc wordpieces cho mô hình Bert được một vốn từ vựng được tạo ra từ các thuật toán Wordpiece . Bạn có thể tìm hiểu thêm về tokenizers subword khác có sẵn trong TF.Text từ đây .

Từ vựng có thể là từ một điểm kiểm tra BERT đã tạo trước đó hoặc bạn có thể tự tạo một điểm kiểm tra trên dữ liệu của riêng mình. Với mục đích của ví dụ này, hãy tạo một từ vựng về đồ chơi:

_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
)

Hãy xây dựng một text.BertTokenizer bằng cách sử dụng từ vựng trên và tokenize đầu vào văn bản vào một 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']]]>

Văn bản đầu ra từ text.BertTokenizer cho phép chúng ta xem như thế nào các văn bản đã được tokenized, nhưng mô hình đòi hỏi ID số nguyên. Chúng ta có thể thiết lập các token_out_type param để tf.int64 để có được số nguyên ID (đó là những chỉ số vào từ vựng).

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 trả về một RaggedTensor với hình dạng [batch, num_tokens, num_wordpieces] . Bởi vì chúng ta không cần thêm num_tokens kích thước đối với trường hợp sử dụng hiện tại của chúng ta, chúng ta có thể hợp nhất hai kích thước cuối cùng để có được một RaggedTensor với hình dạng [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]]>

Cắt xén nội dung

Đầu vào chính cho BERT là sự ghép nối của hai câu. Tuy nhiên, BERT yêu cầu đầu vào phải có kích thước và hình dạng cố định và chúng tôi có thể có nội dung vượt quá ngân sách của chúng tôi.

Chúng ta có thể giải quyết vấn đề này bằng cách sử dụng một text.Trimmer để cắt giảm nội dung của chúng tôi đến một kích thước định trước (khi nối dọc theo trục cuối cùng). Có khác nhau text.Trimmer loại mà chọn nội dung để duy trì sử dụng các thuật toán khác nhau. text.RoundRobinTrimmer ví dụ sẽ phân bổ hạn ngạch như nhau cho từng phân khúc nhưng có thể cắt phần cuối của câu. text.WaterfallTrimmer sẽ cắt bắt đầu từ cuối của câu cuối cùng.

Ví dụ, chúng ta sẽ sử dụng RoundRobinTrimmer là chọn lựa các mặt hàng từ từng phân khúc một cách từ trái sang phải.

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 bây giờ chứa các phân đoạn mà số lượng các yếu tố trên một lô là 8 yếu tố (khi nối dọc theo trục = -1).

Kết hợp các phân đoạn

Bây giờ chúng ta đã phân đoạn cắt, chúng ta có thể kết hợp chúng lại với nhau để có được một đơn RaggedTensor . Bert sử dụng thẻ đặc biệt để chỉ ra sự khởi đầu ( [CLS] ) và kết thúc của một đoạn ( [SEP] ). Chúng ta cũng cần một RaggedTensor chỉ ra các mục trong kết hợp Tensor thuộc về phân khúc. Chúng ta có thể sử dụng text.combine_segments() để có được cả hai Tensor với thẻ đặc biệt chèn vào.

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

Nhiệm vụ mô hình ngôn ngữ có mặt nạ

Bây giờ chúng ta có đầu vào cơ bản của chúng tôi, chúng tôi có thể bắt đầu để trích xuất các đầu vào cần thiết cho "Masked LM và Masking Thủ tục" nhiệm vụ được mô tả trong Bert: Pre-đào tạo sâu hai chiều Transformers cho ngôn ngữ Hiểu

Nhiệm vụ mô hình ngôn ngữ mặt nạ có hai vấn đề phụ để chúng ta suy nghĩ: (1) những mục nào cần chọn để tạo mặt nạ và (2) chúng được gán những giá trị nào?

Lựa chọn mặt hàng

Bởi vì chúng ta sẽ chọn để chọn các mục ngẫu nhiên cho mặt nạ, chúng tôi sẽ sử dụng một text.RandomItemSelector . RandomItemSelector chọn ngẫu nhiên các mặt hàng trong một chủ đề hàng loạt những hạn chế nhất định ( max_selections_per_batch , selection_rate và unselectable_ids ) và trả về một mặt nạ boolean chỉ ra các mục đã được lựa chọn.

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

Chọn giá trị được che giấu

Phương pháp mô tả tài liệu BERT ban đầu để chọn giá trị cho việc tạo mặt nạ như sau:

Đối với mask_token_rate hết thời gian, thay thế các mục với [MASK] mã thông báo:

"my dog is hairy" -> "my dog is [MASK]"

Đối với random_token_rate hết thời gian, thay thế các mục với một từ ngẫu nhiên:

"my dog is hairy" -> "my dog is apple"

Đối với 1 - mask_token_rate - random_token_rate hết thời gian, giữ mục không thay đổi:

"my dog is hairy" -> "my dog is hairy."

text.MaskedValuesChooser đóng gói logic này và có thể được sử dụng cho các chức năng tiền xử lý của chúng tôi. Dưới đây là một ví dụ về những gì MaskValuesChooser lợi nhuận cho một mask_token_rate là 80% và mặc định 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]]>

Khi được cung cấp với một RaggedTensor đầu vào, text.MaskValuesChooser trả về một RaggedTensor của hình dạng giống với một trong hai _MASK_VALUE (0), một ID ngẫu nhiên, hoặc id không thay đổi tương tự.

Tạo đầu vào cho nhiệm vụ mô hình ngôn ngữ có mặt nạ

Bây giờ chúng ta có một RandomItemSelector để giúp chúng ta chọn các mục cho mặt nạ và text.MaskValuesChooser để gán các giá trị, chúng ta có thể sử dụng text.mask_language_model() để lắp ráp tất cả các đầu vào của nhiệm vụ này cho mô hình Bert của chúng tôi.

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.

Hãy lặn sâu hơn và kiểm tra kết quả đầu ra của mask_language_model() . Kết quả của masked_token_ids là:

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

Hãy nhớ rằng đầu vào của chúng tôi được mã hóa bằng từ vựng. Nếu chúng ta giải mã masked_token_ids sử dụng vốn từ vựng của chúng tôi, chúng tôi nhận được:

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

Chú ý rằng một số thẻ wordpiece đã được thay thế với một trong hai [MASK] , [RANDOM] hoặc một giá trị ID khác nhau. masked_pos đầu ra cho chúng ta các chỉ số (trong lô tương ứng) của các thẻ đó đã được thay thế.

masked_pos

<tf.RaggedTensor [[2, 5, 8, 10], [5, 11]]>

masked_lm_ids cho chúng ta giá trị ban đầu của thẻ.

masked_lm_ids

<tf.RaggedTensor [[9, 11, 14, 13], [8, 29]]>

Chúng tôi có thể giải mã lại các ID ở đây để nhận các giá trị mà con người có thể đọc được.

tf.gather(_VOCAB, masked_lm_ids)

<tf.RaggedTensor [[b'##onge', b'##uare', b'an', b'##ven'], [b'##gers', b'office']]>

Đầu vào mô hình đệm

Bây giờ chúng ta có tất cả các yếu tố đầu vào cho mô hình của chúng tôi, bước cuối cùng trong tiền xử lý của chúng tôi là để đóng gói chúng thành cố định 2 chiều Tensor s với đệm và cũng tạo ra một mặt nạ Tensor chỉ ra các giá trị đó là những giá trị pad. Chúng ta có thể sử dụng text.pad_model_inputs() để giúp chúng tôi với công việc này.

# 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]])>}

Kiểm tra lại

Hãy xem lại những gì chúng ta có cho đến nay và lắp ráp chức năng tiền xử lý của chúng ta. Đây là những gì chúng tôi có:

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

Trước đây chúng ta đã tạo tf.data.Dataset và bây giờ chúng ta có thể sử dụng lắp ráp tiền xử lý của chúng tôi hoạt bert_pretrain_preprocess() trong Dataset.map() . Điều này cho phép chúng tôi tạo một đường dẫn đầu vào để chuyển đổi dữ liệu chuỗi thô của chúng tôi thành các đầu vào số nguyên và cấp dữ liệu trực tiếp vào mô hình của chúng tôi.

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]])>}

Hướng dẫn liên quan

Phân loại văn bản với Bert - Một hướng dẫn về cách sử dụng một mô hình Bert pretrained văn bản phân loại. Đây là phần tiếp theo tuyệt vời khi bạn đã quen với cách xử lý trước các đầu vào được sử dụng bởi mô hình BERT.
Tokenizing với TF Tiêu đề - Hướng dẫn chi tiết các loại khác nhau của tokenizers mà tồn tại trong TF.Text.
Xử lý văn bản với RaggedTensor - hướng dẫn chi tiết về cách tạo, sử dụng và thao tác RaggedTensor s.