#
Causal language modeling

There are two types of language modeling, causal and masked. This guide illustrates causal language modeling. Causal language models are frequently used for text generation. You can use these models for creative applications like choosing your own text adventure or an intelligent coding assistant like Copilot or CodeParrot.

Causal language modeling predicts the next token in a sequence of tokens, and the model can only attend to tokens on the left. This means the model cannot see future tokens. GPT-2 is an example of a causal language model.

This guide will show you how to:

1. Finetune DistilGPT2 on the r/askscience subset of the ELI5 dataset.
2. Use your finetuned model for inference.

To see all architectures and checkpoints compatible with this task, we recommend checking the task-page

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

    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 the first 5000 examples from the ELI5-Category dataset with 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_category", split="train[:5000]")

Split the dataset’s `train` split into a train and test set with the train_test_split method:

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

Then take a look at an example:

    >>> eli5["train"][0]
    {'q_id': '7h191n',
     'title': 'What does the tax bill that was passed today mean? How will it affect Americans in each tax bracket?',
     'selftext': '',
     'category': 'Economics',
     'subreddit': 'explainlikeimfive',
     'answers': {'a_id': ['dqnds8l', 'dqnd1jl', 'dqng3i1', 'dqnku5x'],
      'text': ["The tax bill is 500 pages long and there were a lot of changes still going on right to the end. It's not just an adjustment to the income tax brackets, it's a whole bunch of changes. As such there is no good answer to your question. The big take aways are: - Big reduction in corporate income tax rate will make large companies very happy. - Pass through rate change will make certain styles of business (law firms, hedge funds) extremely happy - Income tax changes are moderate, and are set to expire (though it's the kind of thing that might just always get re-applied without being made permanent) - People in high tax states (California, New York) lose out, and many of them will end up with their taxes raised.",
       'None yet. It has to be reconciled with a vastly different house bill and then passed again.',
       'Also: does this apply to 2017 taxes? Or does it start with 2018 taxes?',
       'This article explains both the House and senate bills, including the proposed changes to your income taxes based on your income level. URL_0'],
      'score': [21, 19, 5, 3],
      'text_urls': [[],
       [],
       [],
       ['https://www.investopedia.com/news/trumps-tax-reform-what-can-be-done/']]},
     'title_urls': ['url'],
     'selftext_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

The next step is to load a DistilGPT2 tokenizer to process the `text` subfield:

    >>> from transformers import AutoTokenizer

    >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

You’ll notice from the example above, the `text` field is actually nested inside `answers`. This means you’ll need to extract the `text` subfield from its nested structure with the `flatten` method:

    >>> eli5 = eli5.flatten()
    >>> eli5["train"][0]
    {'q_id': '7h191n',
     'title': 'What does the tax bill that was passed today mean? How will it affect Americans in each tax bracket?',
     'selftext': '',
     'category': 'Economics',
     'subreddit': 'explainlikeimfive',
     'answers.a_id': ['dqnds8l', 'dqnd1jl', 'dqng3i1', 'dqnku5x'],
     'answers.text': ["The tax bill is 500 pages long and there were a lot of changes still going on right to the end. It's not just an adjustment to the income tax brackets, it's a whole bunch of changes. As such there is no good answer to your question. The big take aways are: - Big reduction in corporate income tax rate will make large companies very happy. - Pass through rate change will make certain styles of business (law firms, hedge funds) extremely happy - Income tax changes are moderate, and are set to expire (though it's the kind of thing that might just always get re-applied without being made permanent) - People in high tax states (California, New York) lose out, and many of them will end up with their taxes raised.",
      'None yet. It has to be reconciled with a vastly different house bill and then passed again.',
      'Also: does this apply to 2017 taxes? Or does it start with 2018 taxes?',
      'This article explains both the House and senate bills, including the proposed changes to your income taxes based on your income level. URL_0'],
     'answers.score': [21, 19, 5, 3],
     'answers.text_urls': [[],
      [],
      [],
      ['https://www.investopedia.com/news/trumps-tax-reform-what-can-be-done/']],
     'title_urls': ['url'],
     'selftext_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 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()
    ...     }
    ...     result["labels"] = result["input_ids"].copy()
    ...     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.

Pytorch
Hide Pytorch content

Use the end-of-sequence token as the padding token and set `mlm=False`. This will use the inputs as labels shifted to the right by one element:

    >>> from transformers import DataCollatorForLanguageModeling

    >>> tokenizer.pad_token = tokenizer.eos_token
    >>> data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

TensorFlow
Hide TensorFlow content

Use the end-of-sequence token as the padding token and set `mlm=False`. This will use the inputs as labels shifted to the right by one element:

    >>> from transformers import DataCollatorForLanguageModeling

    >>> data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False, return_tensors="tf")

##
Train

Pytorch
Hide Pytorch content

If you aren’t familiar with finetuning a model with the Trainer, take a look at the basic tutorial!

You’re ready to start training your model now! Load DistilGPT2 with AutoModelForCausalLM:

    >>> from transformers import AutoModelForCausalLM, TrainingArguments, Trainer

    >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")

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 train() to finetune your model.

    >>> training_args = TrainingArguments(
    ...     output_dir="my_awesome_eli5_clm-model",
    ...     eval_strategy="epoch",
    ...     learning_rate=2e-5,
    ...     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,
    ...     tokenizer=tokenizer,
    ... )

    >>> trainer.train()

Once training is completed, use the 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: 49.61

Then share your model to the Hub with the push_to_hub() method so everyone can use your model:

    >>> trainer.push_to_hub()

TensorFlow
Hide TensorFlow content

If you aren’t familiar with finetuning a model with Keras, take a look at the basic tutorial!

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 DistilGPT2 with TFAutoModelForCausalLM:

    >>> from transformers import TFAutoModelForCausalLM

    >>> model = TFAutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")

Convert your datasets to the `tf.data.Dataset` format with 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`. 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 PushToHubCallback:

    >>> from transformers.keras_callbacks import PushToHubCallback

    >>> callback = PushToHubCallback(
    ...     output_dir="my_awesome_eli5_clm-model",
    ...     tokenizer=tokenizer,
    ... )

Finally, you’re ready to start training your model! Call `fit` 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 causal language modeling, take a look at the corresponding PyTorch notebook or TensorFlow notebook.

##
Inference

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

Come up with a prompt you’d like to generate text from:

    >>> prompt = "Somatic hypermutation allows the immune system to"

The simplest way to try out your finetuned model for inference is to use it in a pipeline(). Instantiate a `pipeline` for text generation with your model, and pass your text to it:

    >>> from transformers import pipeline

    >>> generator = pipeline("text-generation", model="username/my_awesome_eli5_clm-model")
    >>> generator(prompt)
    [{'generated_text': "Somatic hypermutation allows the immune system to be able to effectively reverse the damage caused by an infection.\n\n\nThe damage caused by an infection is caused by the immune system's ability to perform its own self-correcting tasks."}]

Pytorch
Hide Pytorch content

Tokenize the text and return the `input_ids` as PyTorch tensors:

    >>> from transformers import AutoTokenizer

    >>> tokenizer = AutoTokenizer.from_pretrained("username/my_awesome_eli5_clm-model")
    >>> inputs = tokenizer(prompt, return_tensors="pt").input_ids

Use the generate() method to generate text. For more details about the different text generation strategies and parameters for controlling generation, check out the Text generation strategies page.

    >>> from transformers import AutoModelForCausalLM

    >>> model = AutoModelForCausalLM.from_pretrained("username/my_awesome_eli5_clm-model")
    >>> outputs = model.generate(inputs, max_new_tokens=100, do_sample=True, top_k=50, top_p=0.95)

Decode the generated token ids back into text:

    >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
    ["Somatic hypermutation allows the immune system to react to drugs with the ability to adapt to a different environmental situation. In other words, a system of 'hypermutation' can help the immune system to adapt to a different environmental situation or in some cases even a single life. In contrast, researchers at the University of Massachusetts-Boston have found that 'hypermutation' is much stronger in mice than in humans but can be found in humans, and that it's not completely unknown to the immune system. A study on how the immune system"]

TensorFlow
Hide TensorFlow content

Tokenize the text and return the `input_ids` as TensorFlow tensors:

    >>> from transformers import AutoTokenizer

    >>> tokenizer = AutoTokenizer.from_pretrained("username/my_awesome_eli5_clm-model")
    >>> inputs = tokenizer(prompt, return_tensors="tf").input_ids

Use the `~transformers.generation_tf_utils.TFGenerationMixin.generate` method to create the summarization. For more details about the different text generation strategies and parameters for controlling generation, check out the Text generation strategies page.

    >>> from transformers import TFAutoModelForCausalLM

    >>> model = TFAutoModelForCausalLM.from_pretrained("username/my_awesome_eli5_clm-model")
    >>> outputs = model.generate(input_ids=inputs, max_new_tokens=100, do_sample=True, top_k=50, top_p=0.95)

Decode the generated token ids back into text:

    >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
    ['Somatic hypermutation allows the immune system to detect the presence of other viruses as they become more prevalent. Therefore, researchers have identified a high proportion of human viruses. The proportion of virus-associated viruses in our study increases with age. Therefore, we propose a simple algorithm to detect the presence of these new viruses in our samples as a sign of improved immunity. A first study based on this algorithm, which will be published in Science on Friday, aims to show that this finding could translate into the development of a better vaccine that is more effective for']

< > Update on GitHub