Prétraitement BERT avec texte TF

Voir sur TensorFlow.org Exécuter dans Google Colab Voir sur GitHub Télécharger le cahier

Aperçu

Le prétraitement de texte est la transformation de bout en bout du texte brut en entrées entières d'un modèle. Les modèles NLP sont souvent accompagnés de plusieurs centaines (voire milliers) de lignes de code Python pour le prétraitement du texte. Le prétraitement du texte est souvent un défi pour les modèles car :

  • Asymétrie au service de la formation. Il devient de plus en plus difficile de s'assurer que la logique de prétraitement des entrées du modèle est cohérente à toutes les étapes du développement du modèle (par exemple, pré-apprentissage, réglage fin, évaluation, inférence). L'utilisation de différents hyperparamètres, la tokenisation, les algorithmes de prétraitement de chaînes ou simplement l'empaquetage des entrées du modèle de manière incohérente à différentes étapes pourraient entraîner des effets difficiles à déboguer et désastreux pour le modèle.

  • Efficacité et flexibilité. Alors que le prétraitement peut être effectué hors ligne (par exemple en écrivant les sorties traitées dans des fichiers sur disque, puis en réutilisant lesdites données prétraitées dans le pipeline d'entrée), cette méthode entraîne un coût supplémentaire de lecture et d'écriture de fichier. Le prétraitement hors ligne est également gênant si des décisions de prétraitement doivent être prises de manière dynamique. Expérimenter une autre option nécessiterait de régénérer à nouveau l'ensemble de données.

  • Interface de modèle complexe. Les modèles de texte sont beaucoup plus compréhensibles lorsque leurs entrées sont du texte pur. Il est difficile de comprendre un modèle lorsque ses entrées nécessitent une étape d'encodage indirecte supplémentaire. La réduction de la complexité du prétraitement est particulièrement appréciée pour le débogage, la diffusion et l'évaluation des modèles.

De plus, des interfaces de modèle plus simples facilitent également l'essai du modèle (par exemple, inférence ou formation) sur différents ensembles de données inexplorés.

Prétraitement de texte avec TF.Text

En utilisant les API de prétraitement de texte de TF.Text, nous pouvons construire une fonction de prétraitement qui peut transformer l'ensemble de données de texte d'un utilisateur en entrées entières du modèle. Les utilisateurs peuvent emballer le prétraitement directement dans le cadre de leur modèle pour atténuer les problèmes mentionnés ci-dessus.

Ce tutoriel va vous montrer comment utiliser TF.Text opérations de pré - traitement pour transformer les données de texte en entrées pour le modèle BERT et entrées pour tâche préformation de masquage langage décrit dans « Masked LM et Masking Procédure » de BERT: Pré-formation des transformateurs profonds Bidirectionnel pour la langue comprendre . Le processus implique la segmentation du texte en unités de sous-mots, la combinaison de phrases, le découpage du contenu à une taille fixe et l'extraction d'étiquettes pour la tâche de modélisation du langage masqué.

Installer

Importons d'abord les packages et les bibliothèques dont nous avons besoin.

pip install -q -U tensorflow-text
import tensorflow as tf
import tensorflow_text as text
import functools
2021-08-17 11:09:49.001212: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

Nos données contient deux éléments de texte et nous pouvons créer un exemple tf.data.Dataset . Notre objectif est de créer une fonction que nous pouvons fournir Dataset.map() avec à utiliser dans la formation.

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))
2021-08-17 11:09:50.986363: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-08-17 11:09:51.592118: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.593052: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-17 11:09:51.593089: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-17 11:09:51.596478: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-17 11:09:51.596574: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-08-17 11:09:51.597657: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-08-17 11:09:51.597974: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-08-17 11:09:51.598957: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-08-17 11:09:51.599848: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-08-17 11:09:51.600019: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-17 11:09:51.600118: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.601014: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.601942: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-17 11:09:51.602609: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-17 11:09:51.603201: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.604143: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-17 11:09:51.604221: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.605115: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:51.605907: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-17 11:09:51.605943: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-17 11:09:52.196319: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-17 11:09:52.196355: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-17 11:09:52.196362: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-17 11:09:52.196585: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:52.197468: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:52.198293: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-17 11:09:52.199096: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
{'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.'>}

Tokenisation

Notre première étape consiste à exécuter n'importe quel prétraitement de chaîne et à tokeniser notre ensemble de données. Cela peut être fait en utilisant la text.BertTokenizer , qui est un text.Splitter qui peut tokenizer phrases en sous - mots ou wordpieces pour le modèle BERT donné un vocabulaire généré par l' algorithme Wordpiece . Vous pouvez en savoir plus sur les autres tokenizers de sous - mots disponibles dans TF.Text d' ici .

Le vocabulaire peut provenir d'un point de contrôle BERT précédemment généré, ou vous pouvez en générer un vous-même sur vos propres données. Pour les besoins de cet exemple, créons un vocabulaire de jouets :

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

Regardons les choses en construire un text.BertTokenizer en utilisant le vocabulaire ci - dessus et tokenizer les entrées de texte dans un 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']]]>

Texte provenant text.BertTokenizer permet voir combien le texte est à jetons, mais le modèle requiert entiers ID. Nous pouvons définir le token_out_type param à tf.int64 obtenir entier ID (qui sont les indices dans le vocabulaire).

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 renvoie un RaggedTensor avec la forme [batch, num_tokens, num_wordpieces] . Parce que nous ne avons pas besoin les supplémentaires num_tokens dimensions pour notre cas en cours d'utilisation, nous pouvons fusionner les deux dernières dimensions pour obtenir un RaggedTensor avec la forme [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]]>

Découpage du contenu

L'entrée principale de BERT est une concaténation de deux phrases. Cependant, BERT exige que les intrants soient de taille et de forme fixes et nous pouvons avoir un contenu qui dépasse notre budget.

Nous pouvons aborder cela en utilisant un text.Trimmer pour couper notre contenu vers le bas à une taille prédéterminée (une fois concaténé le long du dernier axe). Il existe différents text.Trimmer types qui choisissent le contenu de préserver en utilisant des algorithmes différents. text.RoundRobinTrimmer par exemple allouera quota également pour chaque segment , mais peut couper les extrémités des phrases. text.WaterfallTrimmer taillera à partir de la fin de la dernière phrase.

Pour notre exemple, nous utiliserons RoundRobinTrimmer qui sélectionne les éléments de chaque segment d'une manière de gauche à droite.

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 contient maintenant les segments où le nombre d'éléments à travers un lot est de 8 éléments (lorsque concaténée le long de l' axe = -1).

Combiner des segments

Maintenant que nous avons des segments parés, nous pouvons les combiner ensemble pour obtenir un seul RaggedTensor . BERT utilise des jetons spéciaux pour indiquer le début ( [CLS] ) et à la fin d'un segment ( [SEP] ). Nous avons également besoin d' un RaggedTensor indiquant quels éléments de la combinaison Tensor appartiennent à quel segment. Nous pouvons utiliser text.combine_segments() pour obtenir ces deux Tensor avec des jetons spéciaux insérés.

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

Tâche de modèle de langage masqué

Maintenant que nous avons nos entrées de base, nous pouvons commencer à extraire les intrants nécessaires à la « Masked LM et Masking procédure » tâche décrite dans BERT: Pré-formation des transformateurs pour la compréhension profonde Bidirectionnel Langue

La tâche du modèle de langage masqué comporte deux sous-problèmes auxquels nous devons réfléchir : (1) quels éléments sélectionner pour le masquage et (2) quelles valeurs leur sont-elles attribuées ?

Sélection d'articles

Parce que nous allons choisir de sélectionner des éléments au hasard pour le masquage, nous utiliserons un text.RandomItemSelector . RandomItemSelector sélectionne de manière aléatoire des éléments dans un objet de traitement par lots à des restrictions données ( max_selections_per_batch , selection_rate et unselectable_ids ) et renvoie un masque booléenne indiquant quels éléments ont été sélectionnés.

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, True, False, True, True, False, False, False, False, False, True, False, False, False, False, False], [False, False, False, True, False, False, False, True, False, False, False, False, False]]>

Choix de la valeur masquée

La méthodologie décrite dans l'article original du BERT pour choisir la valeur de masquage est la suivante :

Pour mask_token_rate du temps, remplacer l'élément avec le [MASK] jeton:

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

Pour random_token_rate du temps, remplacer l'élément avec un mot au hasard:

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

Pour 1 - mask_token_rate - random_token_rate du temps, garder l'élément inchangé:

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

text.MaskedValuesChooser encapsule cette logique et peut être utilisé pour notre fonction de pré - traitement. Voici un exemple de ce que MaskValuesChooser rendement donné une mask_token_rate de 80% et par défaut 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], [16, 1, 12, 1, 1]]>

Lorsqu'il est fourni avec une RaggedTensor entrée, text.MaskValuesChooser renvoie un RaggedTensor de la même forme avec soit _MASK_VALUE (0), un identifiant aléatoire, ou le même identifiant inchangé.

Génération d'entrées pour la tâche de modèle de langage masqué

Maintenant que nous avons un RandomItemSelector pour nous aider à sélectionner des éléments pour masquer et text.MaskValuesChooser pour affecter les valeurs, nous pouvons utiliser text.mask_language_model() pour assembler toutes les entrées de cette tâche pour notre modèle BERT.

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.

La plongée Let profonde et examiner les résultats de mask_language_model() . La sortie de masked_token_ids est:

masked_token_ids
<tf.RaggedTensor [[3, 22, 9, 25, 23, 1, 10, 28, 14, 1, 13, 7, 4, 16, 11, 19, 6, 28, 30, 21, 0, 4], [3, 18, 12, 15, 13, 8, 4, 21, 28, 1, 1, 29, 4]]>

N'oubliez pas que notre entrée est codée à l'aide d'un vocabulaire. Si on décode masked_token_ids en utilisant notre vocabulaire, nous obtenons:

tf.gather(_VOCAB, masked_token_ids)
<tf.RaggedTensor [[b'[CLS]', b'Sp', b'##onge', b'box', b'Sq', b'[MASK]', b'##pants', b'is', b'an', b'[MASK]', b'##ven', b'##ger', b'[SEP]', b'Bar', b'##uare', 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'##gers', b'[SEP]', b'President', b'is', b'[MASK]', b'[MASK]', b'office', b'[SEP]']]>

Notez que certains jetons de wordpiece ont été remplacés par deux [MASK] , [RANDOM] ou une valeur d'identité différente. masked_pos sortie nous donne les indices (dans le lot respectif) des jetons qui ont été remplacés.

masked_pos
<tf.RaggedTensor [[3, 5, 9, 14], [9, 10]]>

masked_lm_ids nous donne la valeur d' origine du jeton.

masked_lm_ids
<tf.RaggedTensor [[24, 11, 15, 5], [30, 27]]>

Nous pouvons à nouveau décoder les identifiants ici pour obtenir des valeurs lisibles par l'homme.

tf.gather(_VOCAB, masked_lm_ids)
<tf.RaggedTensor [[b'bob', b'##uare', b'A', b'##ack'], [b'the', b'highest']]>

Remplissage des entrées du modèle

Maintenant que nous avons toutes les entrées pour notre modèle, la dernière étape de notre pré - traitement est de les emballer dans deux dimensions fixe Tensor s avec rembourrage et générer également un masque Tensor indiquant les valeurs qui sont des valeurs de pad. Nous pouvons utiliser text.pad_model_inputs() pour nous aider dans cette tâche.

# 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,  9, 25, 23,  1, 10, 28],
        [ 3, 18, 12, 15, 13,  8,  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,  9, 25, 23,  1, 10, 28],
        [ 3, 18, 12, 15, 13,  8,  4, 21]])>,
 'masked_lm_ids': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
 array([[24, 11, 15,  5,  0],
        [30, 27,  0,  0,  0]])>,
 'masked_lm_positions': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
 array([[ 3, 22,  9, 25, 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]])>}

Revoir

Passons en revue ce que nous avons jusqu'à présent et assemblons notre fonction de prétraitement. Voici ce que nous avons :

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_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,
  }
  return model_inputs

Nous avons déjà construit un tf.data.Dataset et nous pouvons maintenant utiliser notre fonction pré - traitement assemblé bert_pretrain_preprocess() dans Dataset.map() . Cela nous permet de créer un pipeline d'entrée pour transformer nos données de chaîne brutes en entrées entières et alimenter directement notre modèle.

dataset = tf.data.Dataset.from_tensors(examples)
dataset = dataset.map(functools.partial(
    bert_pretrain_preprocess, lookup_table))

next(iter(dataset))
2021-08-17 11:09:58.366778: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-08-17 11:09:58.441242: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000165000 Hz
{'input_word_ids': <tf.Tensor: shape=(2, 8), dtype=int64, numpy=
 array([[ 3, 22,  9, 25, 23,  1, 10, 28],
        [ 3, 18, 12, 15, 13,  8,  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,  9, 25, 23,  1, 10, 28],
        [ 3, 18, 12, 15, 13,  8,  4, 21]])>,
 'masked_lm_ids': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
 array([[ 5, 19,  0,  0,  0],
        [12, 28,  0,  0,  0]])>,
 'masked_lm_positions': <tf.Tensor: shape=(2, 5), dtype=int64, numpy=
 array([[ 3, 22,  9, 25, 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]])>}
  • Classifier texte avec BERT - Un tutoriel sur la façon d'utiliser un modèle BERT au texte pré - entraîné Classifier. C'est un bon suivi maintenant que vous savez comment prétraiter les entrées utilisées par le modèle BERT.

  • Tokenizing avec TF Texte - Tutoriel détaillant les différents types de tokenizers qui existent dans TF.Text.

  • Manipulation Texte RaggedTensor - Guide détaillé sur la façon de créer, d' utiliser et de manipuler RaggedTensor s.