# Masked language modeling

[[open-in-colab]]

Masked language modeling predicts a masked token in a sequence, and the model can attend to tokens bidirectionally. This

means the model has full access to the tokens on the left and right. Masked language modeling is great for tasks that

require a good contextual understanding of an entire sequence. BERT is an example of a masked language model.

This guide will show you how to:

1. Finetune [DistilRoBERTa](https://huggingface.co/distilroberta-base) on the [r/askscience](https://www.reddit.com/r/askscience/) subset of the [ELI5](https://huggingface.co/datasets/eli5) dataset.

2. Use your finetuned model for inference.

You can finetune other architectures for masked language modeling following the same steps in this guide.

Choose one of the following architectures:

[ALBERT](../model_doc/albert), [BART](../model_doc/bart), [BERT](../model_doc/bert), [BigBird](../model_doc/big_bird), [CamemBERT](../model_doc/camembert), [ConvBERT](../model_doc/convbert), [Data2VecText](../model_doc/data2vec-text), [DeBERTa](../model_doc/deberta), [DeBERTa-v2](../model_doc/deberta-v2), [DistilBERT](../model_doc/distilbert), [ELECTRA](../model_doc/electra), [ERNIE](../model_doc/ernie), [ESM](../model_doc/esm), [FlauBERT](../model_doc/flaubert), [FNet](../model_doc/fnet), [Funnel Transformer](../model_doc/funnel), [I-BERT](../model_doc/ibert), [LayoutLM](../model_doc/layoutlm), [Longformer](../model_doc/longformer), [LUKE](../model_doc/luke), [mBART](../model_doc/mbart), [MEGA](../model_doc/mega), [Megatron-BERT](../model_doc/megatron-bert), [MobileBERT](../model_doc/mobilebert), [MPNet](../model_doc/mpnet), [MRA](../model_doc/mra), [MVP](../model_doc/mvp), [Nezha](../model_doc/nezha), [Nyströmformer](../model_doc/nystromformer), [Perceiver](../model_doc/perceiver), [QDQBert](../model_doc/qdqbert), [Reformer](../model_doc/reformer), [RemBERT](../model_doc/rembert), [RoBERTa](../model_doc/roberta), [RoBERTa-PreLayerNorm](../model_doc/roberta-prelayernorm), [RoCBert](../model_doc/roc_bert), [RoFormer](../model_doc/roformer), [SqueezeBERT](../model_doc/squeezebert), [TAPAS](../model_doc/tapas), [Wav2Vec2](../model_doc/wav2vec2), [XLM](../model_doc/xlm), [XLM-RoBERTa](../model_doc/xlm-roberta), [XLM-RoBERTa-XL](../model_doc/xlm-roberta-xl), [X-MOD](../model_doc/xmod), [YOSO](../model_doc/yoso)

Before you begin, make sure you have all the necessary libraries installed:

```bash

pip install transformers datasets evaluate

We encourage you to log in to your Hugging Face account so you can upload and share your model with the community. When prompted, enter your token to log in:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

## Load ELI5 dataset

Start by loading a smaller subset of the r/askscience subset of the ELI5 dataset from the 🤗 Datasets library. This'll

give you a chance to experiment and make sure everything works before spending more time training on the full dataset.

>>> from datasets import load_dataset

>>> eli5 = load_dataset("eli5", split="train_asks[:5000]")

Split the dataset's `train_asks` split into a train and test set with the [`~datasets.Dataset.train_test_split`] method:

>>> eli5 = eli5.train_test_split(test_size=0.2)

Then take a look at an example:

>>> eli5["train"][0]

{'answers': {'a_id': ['c3d1aib', 'c3d4lya'],

  'score': [6, 3],

  'text': ["The velocity needed to remain in orbit is equal to the square root of Newton's constant times the mass of earth divided by the distance from the center of the earth. I don't know the altitude of that specific mission, but they're usually around 300 km. That means he's going 7-8 km/s.\n\nIn space there are no other forces acting on either the shuttle or the guy, so they stay in the same position relative to each other. If he were to become unable to return to the ship, he would presumably run out of oxygen, or slowly fall into the atmosphere and burn up.",

   "Hope you don't mind me asking another question, but why aren't there any stars visible in this photo?"]},

 'answers_urls': {'url': []},

 'document': '',

 'q_id': 'nyxfp',

 'selftext': '_URL_0_\n\nThis was on the front page earlier and I have a few questions about it. Is it possible to calculate how fast the astronaut would be orbiting the earth? Also how does he stay close to the shuttle so that he can return safely, i.e is he orbiting at the same speed and can therefore stay next to it? And finally if his propulsion system failed, would he eventually re-enter the atmosphere and presumably die?',

 'selftext_urls': {'url': ['http://apod.nasa.gov/apod/image/1201/freeflyer_nasa_3000.jpg']},

 'subreddit': 'askscience',

 'title': 'Few questions about this space walk photograph.',

 'title_urls': {'url': []}}

While this may look like a lot, you're only really interested in the `text` field. What's cool about language modeling tasks is you don't need labels (also known as an unsupervised task) because the next word *is* the label.

## Preprocess

For masked language modeling, the next step is to load a DistilRoBERTa tokenizer to process the `text` subfield:

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("distilroberta-base")

You'll notice from the example above, the `text` field is actually nested inside `answers`. This means you'll need to e

xtract the `text` subfield from its nested structure with the [`flatten`](https://huggingface.co/docs/datasets/process#flatten) method:

>>> eli5 = eli5.flatten()

>>> eli5["train"][0]

{'answers.a_id': ['c3d1aib', 'c3d4lya'],

 'answers.score': [6, 3],

 'answers.text': ["The velocity needed to remain in orbit is equal to the square root of Newton's constant times the mass of earth divided by the distance from the center of the earth. I don't know the altitude of that specific mission, but they're usually around 300 km. That means he's going 7-8 km/s.\n\nIn space there are no other forces acting on either the shuttle or the guy, so they stay in the same position relative to each other. If he were to become unable to return to the ship, he would presumably run out of oxygen, or slowly fall into the atmosphere and burn up.",

  "Hope you don't mind me asking another question, but why aren't there any stars visible in this photo?"],

 'answers_urls.url': [],

 'document': '',

 'q_id': 'nyxfp',

 'selftext': '_URL_0_\n\nThis was on the front page earlier and I have a few questions about it. Is it possible to calculate how fast the astronaut would be orbiting the earth? Also how does he stay close to the shuttle so that he can return safely, i.e is he orbiting at the same speed and can therefore stay next to it? And finally if his propulsion system failed, would he eventually re-enter the atmosphere and presumably die?',

 'selftext_urls.url': ['http://apod.nasa.gov/apod/image/1201/freeflyer_nasa_3000.jpg'],

 'subreddit': 'askscience',

 'title': 'Few questions about this space walk photograph.',

 'title_urls.url': []}

Each subfield is now a separate column as indicated by the `answers` prefix, and the `text` field is a list now. Instead

of tokenizing each sentence separately, convert the list to a string so you can jointly tokenize them.

Here is a first preprocessing function to join the list of strings for each example and tokenize the result:

>>> def preprocess_function(examples):

     return tokenizer([" ".join(x) for x in examples["answers.text"]])

To apply this preprocessing function over the entire dataset, use the 🤗 Datasets [`~datasets.Dataset.map`] method. You can speed up the `map` function by setting `batched=True` to process multiple elements of the dataset at once, and increasing the number of processes with `num_proc`. Remove any columns you don't need:

>>> tokenized_eli5 = eli5.map(

     preprocess_function,

     batched=True,

     num_proc=4,

     remove_columns=eli5["train"].column_names,

 )

This dataset contains the token sequences, but some of these are longer than the maximum input length for the model.

You can now use a second preprocessing function to

- concatenate all the sequences

- split the concatenated sequences into shorter chunks defined by `block_size`, which should be both shorter than the maximum input length and short enough for your GPU RAM. 

>>> block_size = 128

>>> def group_texts(examples):

     # Concatenate all texts.

     concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}

     total_length = len(concatenated_examples[list(examples.keys())[0]])

     # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can

     # customize this part to your needs.

     if total_length >= block_size:

         total_length = (total_length // block_size) * block_size

     # Split by chunks of block_size.

     result = {

         k: [t[i : i + block_size] for i in range(0, total_length, block_size)]

         for k, t in concatenated_examples.items()

     }

     return result

Apply the `group_texts` function over the entire dataset:

>>> lm_dataset = tokenized_eli5.map(group_texts, batched=True, num_proc=4)

Now create a batch of examples using [`DataCollatorForLanguageModeling`]. It's more efficient to *dynamically pad* the sentences to the longest length in a batch during collation, instead of padding the whole dataset to the maximum length.

Use the end-of-sequence token as the padding token and specify `mlm_probability` to randomly mask tokens each time you iterate over the data:

>>> from transformers import DataCollatorForLanguageModeling

>>> tokenizer.pad_token = tokenizer.eos_token

>>> data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm_probability=0.15)

Use the end-of-sequence token as the padding token and specify `mlm_probability` to randomly mask tokens each time you iterate over the data:

>>> from transformers import DataCollatorForLanguageModeling

>>> data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm_probability=0.15, return_tensors="tf")

## Train

If you aren't familiar with finetuning a model with the [`Trainer`], take a look at the basic tutorial [here](../training#train-with-pytorch-trainer)!

You're ready to start training your model now! Load DistilRoBERTa with [`AutoModelForMaskedLM`]:

>>> from transformers import AutoModelForMaskedLM

>>> model = AutoModelForMaskedLM.from_pretrained("distilroberta-base")

At this point, only three steps remain:

1. Define your training hyperparameters in [`TrainingArguments`]. The only required parameter is `output_dir` which specifies where to save your model. You'll push this model to the Hub by setting `push_to_hub=True` (you need to be signed in to Hugging Face to upload your model).

2. Pass the training arguments to [`Trainer`] along with the model, datasets, and data collator.

3. Call [`~Trainer.train`] to finetune your model.

>>> training_args = TrainingArguments(

     output_dir="my_awesome_eli5_mlm_model",

     evaluation_strategy="epoch",

     learning_rate=2e-5,

     num_train_epochs=3,

     weight_decay=0.01,

     push_to_hub=True,

 )

>>> trainer = Trainer(

     model=model,

     args=training_args,

     train_dataset=lm_dataset["train"],

     eval_dataset=lm_dataset["test"],

     data_collator=data_collator,

 )

>>> trainer.train()

Once training is completed, use the [`~transformers.Trainer.evaluate`] method to evaluate your model and get its perplexity:

>>> import math

>>> eval_results = trainer.evaluate()

>>> print(f"Perplexity: {math.exp(eval_results['eval_loss']):.2f}")

Perplexity: 8.76

Then share your model to the Hub with the [`~transformers.Trainer.push_to_hub`] method so everyone can use your model:

>>> trainer.push_to_hub()

If you aren't familiar with finetuning a model with Keras, take a look at the basic tutorial [here](../training#train-a-tensorflow-model-with-keras)!

To finetune a model in TensorFlow, start by setting up an optimizer function, learning rate schedule, and some training hyperparameters:

>>> from transformers import create_optimizer, AdamWeightDecay

>>> optimizer = AdamWeightDecay(learning_rate=2e-5, weight_decay_rate=0.01)

Then you can load DistilRoBERTa with [`TFAutoModelForMaskedLM`]:

>>> from transformers import TFAutoModelForMaskedLM

>>> model = TFAutoModelForMaskedLM.from_pretrained("distilroberta-base")

Convert your datasets to the `tf.data.Dataset` format with [`~transformers.TFPreTrainedModel.prepare_tf_dataset`]:

>>> tf_train_set = model.prepare_tf_dataset(

     lm_dataset["train"],

     shuffle=True,

     batch_size=16,

     collate_fn=data_collator,

 )

>>> tf_test_set = model.prepare_tf_dataset(

     lm_dataset["test"],

     shuffle=False,

     batch_size=16,

     collate_fn=data_collator,

 )

Configure the model for training with [`compile`](https://keras.io/api/models/model_training_apis/#compile-method). Note that Transformers models all have a default task-relevant loss function, so you don't need to specify one unless you want to:

>>> import tensorflow as tf

>>> model.compile(optimizer=optimizer)  # No loss argument!

This can be done by specifying where to push your model and tokenizer in the [`~transformers.PushToHubCallback`]:

>>> from transformers.keras_callbacks import PushToHubCallback

>>> callback = PushToHubCallback(

     output_dir="my_awesome_eli5_mlm_model",

     tokenizer=tokenizer,

 )

Finally, you're ready to start training your model! Call [`fit`](https://keras.io/api/models/model_training_apis/#fit-method) with your training and validation datasets, the number of epochs, and your callback to finetune the model:

>>> model.fit(x=tf_train_set, validation_data=tf_test_set, epochs=3, callbacks=[callback])

Once training is completed, your model is automatically uploaded to the Hub so everyone can use it!

For a more in-depth example of how to finetune a model for masked language modeling, take a look at the corresponding

[PyTorch notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb)

or [TensorFlow notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb).

## Inference

Great, now that you've finetuned a model, you can use it for inference!

Come up with some text you'd like the model to fill in the blank with, and use the special `` token to indicate the blank:

>>> text = "The Milky Way is a  galaxy."

The simplest way to try out your finetuned model for inference is to use it in a [`pipeline`]. Instantiate a `pipeline` for fill-mask with your model, and pass your text to it. If you like, you can use the `top_k` parameter to specify how many predictions to return:

>>> from transformers import pipeline

>>> mask_filler = pipeline("fill-mask", "stevhliu/my_awesome_eli5_mlm_model")

>>> mask_filler(text, top_k=3)

[{'score': 0.5150994658470154,

  'token': 21300,

  'token_str': ' spiral',

  'sequence': 'The Milky Way is a spiral galaxy.'},

 {'score': 0.07087188959121704,

  'token': 2232,

  'token_str': ' massive',

  'sequence': 'The Milky Way is a massive galaxy.'},

 {'score': 0.06434620916843414,

  'token': 650,

  'token_str': ' small',

  'sequence': 'The Milky Way is a small galaxy.'}]

Tokenize the text and return the `input_ids` as PyTorch tensors. You'll also need to specify the position of the `` token:

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_eli5_mlm_model")

>>> inputs = tokenizer(text, return_tensors="pt")

>>> mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]

Pass your inputs to the model and return the `logits` of the masked token:

>>> from transformers import AutoModelForMaskedLM

>>> model = AutoModelForMaskedLM.from_pretrained("stevhliu/my_awesome_eli5_mlm_model")

>>> logits = model(**inputs).logits

>>> mask_token_logits = logits[0, mask_token_index, :]

Then return the three masked tokens with the highest probability and print them out:

>>> top_3_tokens = torch.topk(mask_token_logits, 3, dim=1).indices[0].tolist()

>>> for token in top_3_tokens:

     print(text.replace(tokenizer.mask_token, tokenizer.decode([token])))

The Milky Way is a spiral galaxy.

The Milky Way is a massive galaxy.

The Milky Way is a small galaxy.

Tokenize the text and return the `input_ids` as TensorFlow tensors. You'll also need to specify the position of the `` token:

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_eli5_mlm_model")

>>> inputs = tokenizer(text, return_tensors="tf")

>>> mask_token_index = tf.where(inputs["input_ids"] == tokenizer.mask_token_id)[0, 1]

Pass your inputs to the model and return the `logits` of the masked token:

>>> from transformers import TFAutoModelForMaskedLM

>>> model = TFAutoModelForMaskedLM.from_pretrained("stevhliu/my_awesome_eli5_mlm_model")

>>> logits = model(**inputs).logits

>>> mask_token_logits = logits[0, mask_token_index, :]

Then return the three masked tokens with the highest probability and print them out:

>>> top_3_tokens = tf.math.top_k(mask_token_logits, 3).indices.numpy()

>>> for token in top_3_tokens:

     print(text.replace(tokenizer.mask_token, tokenizer.decode([token])))

The Milky Way is a spiral galaxy.

The Milky Way is a massive galaxy.

The Milky Way is a small galaxy.