Datasets:

davidberenstein1957

/

hf-blogs-text-embeddings

like 0

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

5. Fine-tune your LM on a downstream task We now can fine-tune our new Esperanto language model on a downstream task of Part-of-speech tagging. As mentioned before, Esperanto is a highly regular language where word endings typically condition the grammatical part of speech. Using a dataset of annotated Esperanto POS tags formatted in the CoNLL-2003 format (see example below), we can use the run_ner.py script from transformers. > POS tagging is a token classification task just as NER so we can just use the exact same script. Again, here’s the hosted Tensorboard for this fine-tuning. We train for 3 epochs using a batch size of 64 per GPU. Training and eval losses converge to small residual values as the task is rather easy (the language is regular) – it’s still fun to be able to train it end-to-end 😃. This time, let’s use a TokenClassificationPipeline: python from transformers import TokenClassificationPipeline, pipeline MODEL_PATH = "./models/EsperBERTo-small-pos/" nlp = pipeline( "ner", model=MODEL_PATH, tokenizer=MODEL_PATH, ) # or instantiate a TokenClassificationPipeline directly. nlp("Mi estas viro kej estas tago varma.") # {'entity': 'PRON', 'score': 0.9979867339134216, 'word': ' Mi'} # {'entity': 'VERB', 'score': 0.9683094620704651, 'word': ' estas'} # {'entity': 'VERB', 'score': 0.9797462821006775, 'word': ' estas'} # {'entity': 'NOUN', 'score': 0.8509314060211182, 'word': ' tago'} # {'entity': 'ADJ', 'score': 0.9996201395988464, 'word': ' varma'} Looks like it worked! 🔥 For a more challenging dataset for NER, @stefan-it recommended that we could train on the silver standard dataset from WikiANN

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

# How to train a new language model from scratch using Transformers and Tokenizers Over the past few months, we made several improvements to our transformers and tokenizers libraries, with the goal of making it easier than ever to train a new language model from scratch. In this post we’ll demo how to train a “small” model (84 M parameters = 6 layers, 768 hidden size, 12 attention heads) – that’s the same number of layers & heads as DistilBERT – on Esperanto. We’ll then fine-tune the model on a downstream task of part-of-speech tagging. Esperanto is a constructed language with a goal of being easy to learn. We pick it for this demo for several reasons: - it is a relatively low-resource language (even though it’s spoken by ~2 million people) so this demo is less boring than training one more English model 😁 - its grammar is highly regular (e.g. all common nouns end in -o, all adjectives in -a) so we should get interesting linguistic results even on a small dataset. - finally, the overarching goal at the foundation of the language is to bring people closer (fostering world peace and international understanding) which one could argue is aligned with the goal of the NLP community 💚 > N.B. You won’t need to understand Esperanto to understand this post, but if you do want to learn it, Duolingo has a nice course with 280k active learners. Our model is going to be called… wait for it… EsperBERTo 😂

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

TADA! ➡️ Your model has a page on https://huggingface.co/models and everyone can load it using AutoModel.from_pretrained("username/model_name"). If you want to take a look at models in different languages, check https://huggingface.co/models

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

3. Train a language model from scratch Update: The associated Colab notebook uses our new Trainer directly, instead of through a script. Feel free to pick the approach you like best. We will now train our language model using the run_language_modeling.py script from transformers (newly renamed from run_lm_finetuning.py as it now supports training from scratch more seamlessly). Just remember to leave --model_name_or_path to None to train from scratch vs. from an existing model or checkpoint. > We’ll train a RoBERTa-like model, which is a BERT-like with a couple of changes (check the documentation for more details). As the model is BERT-like, we’ll train it on a task of Masked language modeling, i.e. the predict how to fill arbitrary tokens that we randomly mask in the dataset. This is taken care of by the example script. We just need to do two things: - implement a simple subclass of Dataset that loads data from our text files - Depending on your use case, you might not even need to write your own subclass of Dataset, if one of the provided examples (TextDataset and LineByLineTextDataset) works – but there are lots of custom tweaks that you might want to add based on what your corpus looks like. - Choose and experiment with different sets of hyperparameters. Here’s a simple version of our EsperantoDataset. python from torch.utils.data import Dataset class EsperantoDataset(Dataset): def __init__(self, evaluate: bool = False): tokenizer = ByteLevelBPETokenizer( "./models/EsperBERTo-small/vocab.json", "./models/EsperBERTo-small/merges.txt", ) tokenizer._tokenizer.post_processor = BertProcessing( ("</s>", tokenizer.token_to_id("</s>")), ("<s>", tokenizer.token_to_id("<s>")), ) tokenizer.enable_truncation(max_length=512) # or use the RobertaTokenizer from `transformers` directly. self.examples = [] src_files = Path("./data/").glob("*-eval.txt") if evaluate else Path("./data/").glob("*-train.txt") for src_file in src_files: print("🔥", src_file) lines = src_file.read_text(encoding="utf-8").splitlines() self.examples += [x.ids for x in tokenizer.encode_batch(lines)] def __len__(self): return len(self.examples) def __getitem__(self, i): # We’ll pad at the batch level. return torch.tensor(self.examples[i]) If your dataset is very large, you can opt to load and tokenize examples on the fly, rather than as a preprocessing step. Here is one specific set of hyper-parameters and arguments we pass to the script: --output_dir ./models/EsperBERTo-small-v1 --model_type roberta --mlm --config_name ./models/EsperBERTo-small --tokenizer_name ./models/EsperBERTo-small --do_train --do_eval --learning_rate 1e-4 --num_train_epochs 5 --save_total_limit 2 --save_steps 2000 --per_gpu_train_batch_size 16 --evaluate_during_training --seed 42 As usual, pick the largest batch size you can fit on your GPU(s). 🔥🔥🔥 Let’s start training!! 🔥🔥🔥 Here you can check our Tensorboard for one particular set of hyper-parameters: > Our example scripts log into the Tensorboard format by default, under runs/. Then to view your board just run tensorboard dev upload --logdir runs – this will set up tensorboard.dev, a Google-managed hosted version that lets you share your ML experiment with anyone.

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

Thank you!

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

6. Share your model 🎉 Finally, when you have a nice model, please think about sharing it with the community: - upload your model using the CLI: transformers-cli upload - write a README.md model card and add it to the repository under model_cards/. Your model card should ideally include: - a model description, - training params (dataset, preprocessing, hyperparameters), - evaluation results, - intended uses & limitations - whatever else is helpful! 🤓

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

2. Train a tokenizer We choose to train a byte-level Byte-pair encoding tokenizer (the same as GPT-2), with the same special tokens as RoBERTa. Let’s arbitrarily pick its size to be 52,000. We recommend training a byte-level BPE (rather than let’s say, a WordPiece tokenizer like BERT) because it will start building its vocabulary from an alphabet of single bytes, so all words will be decomposable into tokens (no more <unk> tokens!). python #! pip install tokenizers from pathlib import Path from tokenizers import ByteLevelBPETokenizer paths = [str(x) for x in Path("./eo_data/").glob("**/*.txt")] # Initialize a tokenizer tokenizer = ByteLevelBPETokenizer() # Customize training tokenizer.train(files=paths, vocab_size=52_000, min_frequency=2, special_tokens=[ "<s>", "<pad>", "</s>", "<unk>", "<mask>", ]) # Save files to disk tokenizer.save_model(".", "esperberto") And here’s a slightly accelerated capture of the output: On our dataset, training took about ~5 minutes. 🔥🔥 Wow, that was fast! ⚡️🔥 We now have both a vocab.json, which is a list of the most frequent tokens ranked by frequency, and a merges.txt list of merges. json { "<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3, "<mask>": 4, "!": 5, "\"": 6, "#": 7, "$": 8, "%": 9, "&": 10, "'": 11, "(": 12, ")": 13, # ... } # merges.txt l a Ġ k o n Ġ la t a Ġ e Ġ d Ġ p # ... What is great is that our tokenizer is optimized for Esperanto. Compared to a generic tokenizer trained for English, more native words are represented by a single, unsplit token. Diacritics, i.e. accented characters used in Esperanto – ĉ, ĝ, ĥ, ĵ, ŝ, and ŭ – are encoded natively. We also represent sequences in a more efficient manner. Here on this corpus, the average length of encoded sequences is ~30% smaller as when using the pretrained GPT-2 tokenizer. Here’s how you can use it in tokenizers, including handling the RoBERTa special tokens – of course, you’ll also be able to use it directly from transformers. python from tokenizers.implementations import ByteLevelBPETokenizer from tokenizers.processors import BertProcessing tokenizer = ByteLevelBPETokenizer( "./models/EsperBERTo-small/vocab.json", "./models/EsperBERTo-small/merges.txt", ) tokenizer._tokenizer.post_processor = BertProcessing( ("</s>", tokenizer.token_to_id("</s>")), ("<s>", tokenizer.token_to_id("<s>")), ) tokenizer.enable_truncation(max_length=512) print( tokenizer.encode("Mi estas Julien.") ) # Encoding(num_tokens=7, ...) # tokens: ['<s>', 'Mi', 'Ġestas', 'ĠJuli', 'en', '.', '</s>']

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

1. Find a dataset First, let us find a corpus of text in Esperanto. Here we’ll use the Esperanto portion of the OSCAR corpus from INRIA. OSCAR is a huge multilingual corpus obtained by language classification and filtering of Common Crawl dumps of the Web. The Esperanto portion of the dataset is only 299M, so we’ll concatenate with the Esperanto sub-corpus of the Leipzig Corpora Collection, which is comprised of text from diverse sources like news, literature, and wikipedia. The final training corpus has a size of 3 GB, which is still small – for your model, you will get better results the more data you can get to pretrain on.

How to train a new language model from scratch using Transformers and Tokenizers

julien-c

February 14, 2020

how-to-train

guide, nlp

https://huggingface.co/blog/how-to-train

4. Check that the LM actually trained Aside from looking at the training and eval losses going down, the easiest way to check whether our language model is learning anything interesting is via the FillMaskPipeline. Pipelines are simple wrappers around tokenizers and models, and the 'fill-mask' one will let you input a sequence containing a masked token (here, <mask>) and return a list of the most probable filled sequences, with their probabilities. python from transformers import pipeline fill_mask = pipeline( "fill-mask", model="./models/EsperBERTo-small", tokenizer="./models/EsperBERTo-small" ) # The sun <mask>. # => result = fill_mask("La suno <mask>.") # {'score': 0.2526160776615143, 'sequence': '<s> La suno brilis.</s>', 'token': 10820} # {'score': 0.0999930202960968, 'sequence': '<s> La suno lumis.</s>', 'token': 23833} # {'score': 0.04382849484682083, 'sequence': '<s> La suno brilas.</s>', 'token': 15006} # {'score': 0.026011141017079353, 'sequence': '<s> La suno falas.</s>', 'token': 7392} # {'score': 0.016859788447618484, 'sequence': '<s> La suno pasis.</s>', 'token': 4552} Ok, simple syntax/grammar works. Let’s try a slightly more interesting prompt: python fill_mask("Jen la komenco de bela <mask>.") # This is the beginning of a beautiful <mask>. # => # { # 'score':0.06502299010753632 # 'sequence':'<s> Jen la komenco de bela vivo.</s>' # 'token':1099 # } # { # 'score':0.0421181358397007 # 'sequence':'<s> Jen la komenco de bela vespero.</s>' # 'token':5100 # } # { # 'score':0.024884626269340515 # 'sequence':'<s> Jen la komenco de bela laboro.</s>' # 'token':1570 # } # { # 'score':0.02324388362467289 # 'sequence':'<s> Jen la komenco de bela tago.</s>' # 'token':1688 # } # { # 'score':0.020378097891807556 # 'sequence':'<s> Jen la komenco de bela festo.</s>' # 'token':4580 # } > “Jen la komenco de bela tago”, indeed! With more complex prompts, you can probe whether your language model captured more semantic knowledge or even some sort of (statistical) common sense reasoning.

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Greedy Search Greedy search is the simplest decoding method. It selects the word with the highest probability as its next word: \(w_t = argmax_{w}P(w | w_{1:t-1})\) at each timestep \(t\). The following sketch shows greedy search. Starting from the word \(\text{"The"},\) the algorithm greedily chooses the next word of highest probability \(\text{"nice"}\) and so on, so that the final generated word sequence is \((\text{"The"}, \text{"nice"}, \text{"woman"})\) having an overall probability of \(0.5 \times 0.4 = 0.2\) . In the following we will generate word sequences using GPT2 on the context \((\text{"I"}, \text{"enjoy"}, \text{"walking"}, \text{"with"}, \text{"my"}, \text{"cute"}, \text{"dog"})\). Let's see how greedy search can be used in transformers: python # encode context the generation is conditioned on model_inputs = tokenizer('I enjoy walking with my cute dog', return_tensors='pt').to(torch_device) # generate 40 new tokens greedy_output = model.generate(**model_inputs, max_new_tokens=40) print("Output:\n" + 100 * '-') print(tokenizer.decode(greedy_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with my dog. I'm not sure if I'll ever be able to walk with my dog. I'm not sure Alright! We have generated our first short text with GPT2 😊. The generated words following the context are reasonable, but the model quickly starts repeating itself! This is a very common problem in language generation in general and seems to be even more so in greedy and beam search - check out Vijayakumar et al., 2016 and Shao et al., 2017. The major drawback of greedy search though is that it misses high probability words hidden behind a low probability word as can be seen in our sketch above: The word \(\text{"has"}\) with its high conditional probability of \(0.9\) is hidden behind the word \(\text{"dog"}\), which has only the second-highest conditional probability, so that greedy search misses the word sequence \(\text{"The"}, \text{"dog"}, \text{"has"}\) . Thankfully, we have beam search to alleviate this problem!

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Beam search Beam search reduces the risk of missing hidden high probability word sequences by keeping the most likely num_beams of hypotheses at each time step and eventually choosing the hypothesis that has the overall highest probability. Let's illustrate with num_beams=2: At time step 1, besides the most likely hypothesis \((\text{"The"}, \text{"nice"})\), beam search also keeps track of the second most likely one \((\text{"The"}, \text{"dog"})\). At time step 2, beam search finds that the word sequence \((\text{"The"}, \text{"dog"}, \text{"has"})\), has with \(0.36\) a higher probability than \((\text{"The"}, \text{"nice"}, \text{"woman"})\), which has \(0.2\) . Great, it has found the most likely word sequence in our toy example! Beam search will always find an output sequence with higher probability than greedy search, but is not guaranteed to find the most likely output. Let's see how beam search can be used in transformers. We set num_beams > 1 and early_stopping=True so that generation is finished when all beam hypotheses reached the EOS token. python # activate beam search and early_stopping beam_output = model.generate( **model_inputs, max_new_tokens=40, num_beams=5, early_stopping=True ) print("Output:\n" + 100 * '-') print(tokenizer.decode(beam_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I'm not sure if I'll ever be able to walk with him again. I'm not sure While the result is arguably more fluent, the output still includes repetitions of the same word sequences. One of the available remedies is to introduce n-grams (a.k.a word sequences of n words) penalties as introduced by Paulus et al. (2017) and Klein et al. (2017). The most common n-grams penalty makes sure that no n-gram appears twice by manually setting the probability of next words that could create an already seen n-gram to 0. Let's try it out by setting no_repeat_ngram_size=2 so that no 2-gram appears twice: python # set no_repeat_ngram_size to 2 beam_output = model.generate( **model_inputs, max_new_tokens=40, num_beams=5, no_repeat_ngram_size=2, early_stopping=True ) print("Output:\n" + 100 * '-') print(tokenizer.decode(beam_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I've been thinking about this for a while now, and I think it's time for me to Nice, that looks much better! We can see that the repetition does not appear anymore. Nevertheless, n-gram penalties have to be used with care. An article generated about the city New York should not use a 2-gram penalty or otherwise, the name of the city would only appear once in the whole text! Another important feature about beam search is that we can compare the top beams after generation and choose the generated beam that fits our purpose best. In transformers, we simply set the parameter num_return_sequences to the number of highest scoring beams that should be returned. Make sure though that num_return_sequences <= num_beams! python # set return_num_sequences > 1 beam_outputs = model.generate( **model_inputs, max_new_tokens=40, num_beams=5, no_repeat_ngram_size=2, num_return_sequences=5, early_stopping=True ) # now we have 3 output sequences print("Output:\n" + 100 * '-') for i, beam_output in enumerate(beam_outputs): print("{}: {}".format(i, tokenizer.decode(beam_output, skip_special_tokens=True))) Output: ---------------------------------------------------------------------------------------------------- 0: I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I've been thinking about this for a while now, and I think it's time for me to 1: I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with her again. I've been thinking about this for a while now, and I think it's time for me to 2: I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I've been thinking about this for a while now, and I think it's a good idea to 3: I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I've been thinking about this for a while now, and I think it's time to take a 4: I enjoy walking with my cute dog, but I'm not sure if I'll ever be able to walk with him again. I've been thinking about this for a while now, and I think it's a good idea. As can be seen, the five beam hypotheses are only marginally different to each other - which should not be too surprising when using only 5 beams. In open-ended generation, a couple of reasons have been brought forward why beam search might not be the best possible option: - Beam search can work very well in tasks where the length of the desired generation is more or less predictable as in machine translation or summarization - see Murray et al. (2018) and Yang et al. (2018). But this is not the case for open-ended generation where the desired output length can vary greatly, e.g. dialog and story generation. - We have seen that beam search heavily suffers from repetitive generation. This is especially hard to control with n-gram- or other penalties in story generation since finding a good trade-off between inhibiting repetition and repeating cycles of identical n-grams requires a lot of finetuning. - As argued in Ari Holtzman et al. (2019), high quality human language does not follow a distribution of high probability next words. In other words, as humans, we want generated text to surprise us and not to be boring/predictable. The authors show this nicely by plotting the probability, a model would give to human text vs. what beam search does. So let's stop being boring and introduce some randomness 🤪.

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Conclusion As ad-hoc decoding methods, top-p and top-K sampling seem to produce more fluent text than traditional greedy - and beam search on open-ended language generation. There is evidence that the apparent flaws of greedy and beam search - mainly generating repetitive word sequences - are caused by the model (especially the way the model is trained), rather than the decoding method, cf. Welleck et al. (2019). Also, as demonstrated in Welleck et al. (2020), it looks as top-K and top-p sampling also suffer from generating repetitive word sequences. In Welleck et al. (2019), the authors show that according to human evaluations, beam search can generate more fluent text than Top-p sampling, when adapting the model's training objective. Open-ended language generation is a rapidly evolving field of research and as it is often the case there is no one-size-fits-all method here, so one has to see what works best in one's specific use case. Fortunately, you can try out all the different decoding methods in transfomers 🤗 -- you can have an overview of the available methods here. Thanks to everybody, who has contributed to the blog post: Alexander Rush, Julien Chaumand, Thomas Wolf, Victor Sanh, Sam Shleifer, Clément Delangue, Yacine Jernite, Oliver Åstrand and John de Wasseige.

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Appendix generate has evolved into a highly composable method, with flags to manipulate the resulting text in many directions that were not covered in this blog post. Here are a few helpful pages to guide you: - How to parameterize generate - How to stream the output - Full list of decoding options - generate API reference - LLM score leaderboard If you find that navigating our docs is challenging and you can't easily find what you're looking for, drop us a message in this GitHub issue. Your feedback is critical to set our future direction! 🤗

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Sampling In its most basic form, sampling means randomly picking the next word \(w_t\) according to its conditional probability distribution: $$ w_t \sim P(w|w_{1:t-1}) $$ Taking the example from above, the following graphic visualizes language generation when sampling. It becomes obvious that language generation using sampling is not deterministic anymore. The word \((\text{"car"})\) is sampled from the conditioned probability distribution \(P(w | \text{"The"})\), followed by sampling \((\text{"drives"})\) from \(P(w | \text{"The"}, \text{"car"})\) . In transformers, we set do_sample=True and deactivate Top-K sampling (more on this later) via top_k=0. In the following, we will fix the random seed for illustration purposes. Feel free to change the set_seed argument to obtain different results, or to remove it for non-determinism. python # set seed to reproduce results. Feel free to change the seed though to get different results from transformers import set_seed set_seed(42) # activate sampling and deactivate top_k by setting top_k sampling to 0 sample_output = model.generate( **model_inputs, max_new_tokens=40, do_sample=True, top_k=0 ) print("Output:\n" + 100 * '-') print(tokenizer.decode(sample_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog for the rest of the day, but this had me staying in an unusual room and not going on nights out with friends (which will always be wondered for a mere minute or so at this point). Interesting! The text seems alright - but when taking a closer look, it is not very coherent and doesn't sound like it was written by a human. That is the big problem when sampling word sequences: The models often generate incoherent gibberish, cf. Ari Holtzman et al. (2019). A trick is to make the distribution \(P(w|w_{1:t-1})\) sharper (increasing the likelihood of high probability words and decreasing the likelihood of low probability words) by lowering the so-called temperature of the softmax. An illustration of applying temperature to our example from above could look as follows. The conditional next word distribution of step \(t=1\) becomes much sharper leaving almost no chance for word \((\text{"car"})\) to be selected. Let's see how we can cool down the distribution in the library by setting temperature=0.6: python # set seed to reproduce results. Feel free to change the seed though to get different results set_seed(42) # use temperature to decrease the sensitivity to low probability candidates sample_output = model.generate( **model_inputs, max_new_tokens=40, do_sample=True, top_k=0, temperature=0.6, ) print("Output:\n" + 100 * '-') print(tokenizer.decode(sample_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog, but I don't like to chew on it. I like to eat it and not chew on it. I like to be able to walk with my dog." So how did you decide OK. There are less weird n-grams and the output is a bit more coherent now! While applying temperature can make a distribution less random, in its limit, when setting temperature \(\to 0\), temperature scaled sampling becomes equal to greedy decoding and will suffer from the same problems as before.

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

# How to generate text: using different decoding methods for language generation with Transformers Note: Edited on July 2023 with up-to-date references and examples.

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Top-p (nucleus) sampling Instead of sampling only from the most likely K words, in Top-p sampling chooses from the smallest possible set of words whose cumulative probability exceeds the probability p. The probability mass is then redistributed among this set of words. This way, the size of the set of words (a.k.a the number of words in the set) can dynamically increase and decrease according to the next word's probability distribution. Ok, that was very wordy, let's visualize. Having set \(p=0.92\), Top-p sampling picks the minimum number of words to exceed together \(p=92\%\) of the probability mass, defined as \(V_{\text{top-p}}\). In the first example, this included the 9 most likely words, whereas it only has to pick the top 3 words in the second example to exceed 92%. Quite simple actually! It can be seen that it keeps a wide range of words where the next word is arguably less predictable, e.g. \(P(w | \text{"The''})\), and only a few words when the next word seems more predictable, e.g. \(P(w | \text{"The"}, \text{"car"})\). Alright, time to check it out in transformers! We activate Top-p sampling by setting 0 < top_p < 1: python # set seed to reproduce results. Feel free to change the seed though to get different results set_seed(42) # set top_k to 50 sample_output = model.generate( **model_inputs, max_new_tokens=40, do_sample=True, top_p=0.92, top_k=0 ) print("Output:\n" + 100 * '-') print(tokenizer.decode(sample_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog for the rest of the day, but this had me staying in an unusual room and not going on nights out with friends (which will always be my yearning for such a spacious screen on my desk Great, that sounds like it could have been written by a human. Well, maybe not quite yet. While in theory, Top-p seems more elegant than Top-K, both methods work well in practice. Top-p can also be used in combination with Top-K, which can avoid very low ranked words while allowing for some dynamic selection. Finally, to get multiple independently sampled outputs, we can again set the parameter num_return_sequences > 1: python # set seed to reproduce results. Feel free to change the seed though to get different results set_seed(42) # set top_k = 50 and set top_p = 0.95 and num_return_sequences = 3 sample_outputs = model.generate( **model_inputs, max_new_tokens=40, do_sample=True, top_k=50, top_p=0.95, num_return_sequences=3, ) print("Output:\n" + 100 * '-') for i, sample_output in enumerate(sample_outputs): print("{}: {}".format(i, tokenizer.decode(sample_output, skip_special_tokens=True))) Output: ---------------------------------------------------------------------------------------------------- 0: I enjoy walking with my cute dog for the rest of the day, but this time it was hard for me to figure out what to do with it. When I finally looked at this for a few moments, I immediately thought, " 1: I enjoy walking with my cute dog. The only time I felt like walking was when I was working, so it was awesome for me. I didn't want to walk for days. I am really curious how she can walk with me 2: I enjoy walking with my cute dog (Chama-I-I-I-I-I), and I really enjoy running. I play in a little game I play with my brother in which I take pictures of our houses. Cool, now you should have all the tools to let your model write your stories with transformers!

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Introduction In recent years, there has been an increasing interest in open-ended language generation thanks to the rise of large transformer-based language models trained on millions of webpages, including OpenAI's ChatGPT and Meta's LLaMA. The results on conditioned open-ended language generation are impressive, having shown to generalize to new tasks, handle code, or take non-text data as input. Besides the improved transformer architecture and massive unsupervised training data, better decoding methods have also played an important role. This blog post gives a brief overview of different decoding strategies and more importantly shows how you can implement them with very little effort using the popular transformers library! All of the following functionalities can be used for auto-regressive language generation (here a refresher). In short, auto-regressive language generation is based on the assumption that the probability distribution of a word sequence can be decomposed into the product of conditional next word distributions: $$ P(w_{1:T} | W_0 ) = \prod_{t=1}^T P(w_{t} | w_{1: t-1}, W_0) \text{ ,with } w_{1: 0} = \emptyset, $$ and \(W_0\) being the initial context word sequence. The length \(T\) of the word sequence is usually determined on-the-fly and corresponds to the timestep \(t=T\) the EOS token is generated from \(P(w_{t} | w_{1: t-1}, W_{0})\). We will give a tour of the currently most prominent decoding methods, mainly Greedy search, Beam search, and Sampling. Let's quickly install transformers and load the model. We will use GPT2 in PyTorch for demonstration, but the API is 1-to-1 the same for TensorFlow and JAX. python !pip install -q transformers python from transformers import AutoModelForCausalLM, AutoTokenizer import torch torch_device = "cuda" if torch.cuda.is_available() else "cpu" tokenizer = AutoTokenizer.from_pretrained("gpt2") # add the EOS token as PAD token to avoid warnings model = AutoModelForCausalLM.from_pretrained("gpt2", pad_token_id=tokenizer.eos_token_id).to(torch_device)

How to generate text: using different decoding methods for language generation with Transformers

patrickvonplaten

March, 2020

how-to-generate

guide, nlp

https://huggingface.co/blog/how-to-generate

Top-K Sampling Fan et. al (2018) introduced a simple, but very powerful sampling scheme, called Top-K sampling. In Top-K sampling, the K most likely next words are filtered and the probability mass is redistributed among only those K next words. GPT2 adopted this sampling scheme, which was one of the reasons for its success in story generation. We extend the range of words used for both sampling steps in the example above from 3 words to 10 words to better illustrate Top-K sampling. Having set \(K = 6\), in both sampling steps we limit our sampling pool to 6 words. While the 6 most likely words, defined as \(V_{\text{top-K}}\) encompass only ca. two-thirds of the whole probability mass in the first step, it includes almost all of the probability mass in the second step. Nevertheless, we see that it successfully eliminates the rather weird candidates \((\text{not"}, \text{the"}, \text{small"}, \text{told"})\) in the second sampling step. Let's see how Top-K can be used in the library by setting top_k=50: python # set seed to reproduce results. Feel free to change the seed though to get different results set_seed(42) # set top_k to 50 sample_output = model.generate( **model_inputs, max_new_tokens=40, do_sample=True, top_k=50 ) print("Output:\n" + 100 * '-') print(tokenizer.decode(sample_output[0], skip_special_tokens=True)) Output: ---------------------------------------------------------------------------------------------------- I enjoy walking with my cute dog for the rest of the day, but this time it was hard for me to figure out what to do with it. (One reason I asked this for a few months back is that I had a Not bad at all! The text is arguably the most human-sounding text so far. One concern though with Top-K sampling is that it does not dynamically adapt the number of words that are filtered from the next word probability distribution \(P(w|w_{1:t-1})\). This can be problematic as some words might be sampled from a very sharp distribution (distribution on the right in the graph above), whereas others from a much more flat distribution (distribution on the left in the graph above). In step \(t=1\), Top-K eliminates the possibility to sample \((\text{"people"}, \text{"big"}, \text{"house"}, \text{"cat"})\), which seem like reasonable candidates. On the other hand, in step \(t=2\) the method includes the arguably ill-fitted words \((\text{"down"}, \text{"a"})\) in the sample pool of words. Thus, limiting the sample pool to a fixed size K could endanger the model to produce gibberish for sharp distributions and limit the model's creativity for flat distribution. This intuition led Ari Holtzman et al. (2019) to create Top-p- or nucleus-sampling.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

4. Axial Positional Encodings Reformer makes it possible to process huge input sequences. However, for such long input sequences standard positional encoding weight matrices alone would use more than 1GB to store its weights. To prevent such large positional encoding matrices, the official Reformer code introduced Axial Position Encodings. Important: Axial Position Encodings were not explained in the official paper, but can be well understood from looking into the code and talking to the authors

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Local Self-Attention Local self-attention is the obvious solution to reducing the \(\mathcal{O}(n^2)\) memory bottleneck, allowing us to model longer sequences with a reduced computational cost. In local self-attention the input \( \mathbf{X} = \mathbf{X}{1:n} = \mathbf{x}{1}, \ldots, \mathbf{x}{n} \) is cut into \(n_{c}\) chunks: \( \mathbf{X} = \left[\mathbf{X}{1:l{c}}, \ldots, \mathbf{X}{(n{c} - 1) * l_{c} : n_{c} * l_{c}}\right] \) each of length config.local_chunk_length, i.e. \(l_{c}\), and subsequently global self-attention is applied on each chunk separately. Let's take our input sequence for \(n=16, d_h=3\) again for visualization: Assuming \(l_{c} = 4, n_{c} = 4\), chunked attention can be illustrated as follows: As can be seen, the attention operation is applied for each chunk \(\mathbf{X}{1:4}, \mathbf{X}{5:8}, \mathbf{X}{9:12}, \mathbf{X}{13:16}\) individually. The first drawback of this architecture becomes obvious: Some input vectors have no access to their immediate context, e.g. \(\mathbf{x}9\) has no access to \(\mathbf{x}{8}\) and vice-versa in our example. This is problematic because these tokens are not able to learn word representations that take their immediate context into account. A simple remedy is to augment each chunk with config.local_num_chunks_before, i.e. \(n_{p}\), chunks and config.local_num_chunks_after, i.e. \(n_{a}\), so that every input vector has at least access to \(n_{p}\) previous input vectors and \(n_{a}\) following input vectors. This can also be understood as chunking with overlap whereas \(n_{p}\) and \(n_{a}\) define the amount of overlap each chunk has with all previous chunks and following chunks. We denote this extended local self-attention as follows: $$\mathbf{Z}^{\text{loc}} = \left[\mathbf{Z}{1:l{c}}^{\text{loc}}, \ldots, \mathbf{Z}{(n{c} - 1) * l_{c} : n_{c} * l_{c}}^{\text{loc}}\right], $$ with $$\mathbf{Z}{l{c} * (i - 1) + 1 : l_{c} * i}^{\text{loc}} = \text{SelfAttn}(\mathbf{X}{l{c} * (i - 1 - n_{p}) + 1: l_{c} * (i + n_{a})})\left[n_{p} * l_{c}: -n_{a} * l_{c}\right], \forall i \in {1, \ldots, n_{c} }$$ Okay, this formula looks quite complicated. Let's make it easier. In Reformer's self-attention layers \(n_{a}\) is usually set to 0 and \(n_{p}\) is set to 1, so let's write down the formula again for \(i = 1\): $$\mathbf{Z}{1:l{c}}^{\text{loc}} = \text{SelfAttn}(\mathbf{X}{-l{c} + 1: l_{c}})\left[l_{c}:\right]$$ We notice that we have a circular relationship so that the first segment can attend the last segment as well. Let's illustrate this slightly enhanced local attention again. First, we apply self-attention within each windowed segment and keep only the central output segment. Finally, the relevant output is concatenated to \(\mathbf{Z}^{\text{loc}}\) and looks as follows. Note that local self-attention is implemented efficiently way so that no output is computed and subsequently "thrown-out" as shown here for illustration purposes by the red cross. It's important to note here that extending the input vectors for each chunked self-attention function allows each single output vector \( \mathbf{z}{i} \) of this self-attention function to learn better vector representations. E.g. each of the output vectors \( \mathbf{z}{5}^{\text{loc}}, \mathbf{z}{6}^{\text{loc}}, \mathbf{z}{7}^{\text{loc}}, \mathbf{z}{8}^{\text{loc}} \) can take into account all of the input vectors \( \mathbf{X}{1:8} \) to learn better representations. The gain in memory consumption is quite obvious: The \( \mathcal{O}(n^2) \) memory complexity is broken down for each segment individually so that the total asymptotic memory consumption is reduced to \( \mathcal{O}(n_{c} * l_{c}^2) = \mathcal{O}(n * l_{c}) \). This enhanced local self-attention is better than the vanilla local self-attention architecture but still has a major drawback in that every input vector can only attend to a local context of predefined size. For NLP tasks that do not require the transformer model to learn long-range dependencies between the input vectors, which include arguably e.g. speech recognition, named entity recognition and causal language modeling of short sentences, this might not be a big issue. Many NLP tasks do require the model to learn long-range dependencies, so that local self-attention could lead to significant performance degradation, e.g. * Question-answering: the model has to learn the relationship between the question tokens and relevant answer tokens which will most likely not be in the same local range * Multiple-Choice: the model has to compare multiple answer token segments to each other which are usually separated by a significant length * Summarization: the model has to learn the relationship between a long sequence of context tokens and a shorter sequence of summary tokens, whereas the relevant relationships between context and summary can most likely not be captured by local self-attention * etc... Local self-attention on its own is most likely not sufficient for the transformer model to learn the relevant relationships of input vectors (tokens) to each other. Therefore, Reformer additionally employs an efficient self-attention layer that approximates global self-attention, called LSH self-attention.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Recap Global Self-Attention The core of every Transformer model is the self-attention layer. To recap the conventional self-attention layer, which we refer to here as the global self-attention layer, let us assume we apply a transformer layer on the embedding vector sequence \(\mathbf{X} = \mathbf{x}1, \ldots, \mathbf{x}_n\) where each vector \(\mathbf{x}{i}\) is of size config.hidden_size, i.e. \(d_h\). In short, a global self-attention layer projects \(\mathbf{X}\) to the query, key and value matrices \(\mathbf{Q}, \mathbf{K}, \mathbf{V}\) and computes the output \(\mathbf{Z}\) using the softmax operation as follows: \(\mathbf{Z} = \text{SelfAttn}(\mathbf{X}) = \text{softmax}(\mathbf{Q}\mathbf{K}^T) \mathbf{V}\) with \(\mathbf{Z}\) being of dimension \(d_h \times n\) (leaving out the key normalization factor and self-attention weights \(\mathbf{W}^{O}\) for simplicity). For more detail on the complete transformer operation, see the illustrated transformer. Visually, we can illustrate this operation as follows for \(n=16, d_h=3\): Note that for all visualizations batch_size and config.num_attention_heads is assumed to be 1. Some vectors, e.g. \(\mathbf{x_3}\) and its corresponding output vector \(\mathbf{z_3}\) are marked so that LSH self-attention can later be better explained. The presented logic can effortlessly be extended for multi-head self-attention (config.num_attention_{h}eads > 1). The reader is advised to read the illustrated transformer as a reference for multi-head self-attention. Important to remember is that for each output vector \(\mathbf{z}{i}\), the whole input sequence \(\mathbf{X}\) is processed. The tensor of the inner dot-product \(\mathbf{Q}\mathbf{K}^T\) has an asymptotic memory complexity of \(\mathcal{O}(n^2)\) which usually represents the memory bottleneck in a transformer model. This is also the reason why bert-base-cased has a config.max_position_embedding_size of only 512.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

LSH Self-Attention Alright, now that we have understood how local self-attention works, we can take a stab at the probably most innovative piece of Reformer: Locality sensitive hashing (LSH) Self-Attention. The premise of LSH self-attention is to be more or less as efficient as local self-attention while approximating global self-attention. LSH self-attention relies on the LSH algorithm as presented in Andoni et al (2015), hence its name. The idea behind LSH self-attention is based on the insight that if \(n\) is large, the softmax applied on the \(\mathbf{Q}\mathbf{K}^T\) attention dot-product weights only very few value vectors with values significantly larger than 0 for each query vector. Let's explain this in more detail. Let \(\mathbf{k}{i} \in \mathbf{K} = \left[\mathbf{k}_1, \ldots, \mathbf{k}_n \right]^T\) and \(\mathbf{q}{i} \in \mathbf{Q} = \left[\mathbf{q}1, \ldots, \mathbf{q}_n\right]^T\) be the key and query vectors. For each \(\mathbf{q}{i}\), the computation \(\text{softmax}(\mathbf{q}{i}^T \mathbf{K}^T)\) can be approximated by using only those key vectors of \(\mathbf{k}{j}\) that have a high cosine similarity with \(\mathbf{q}{i}\). This owes to the fact that the softmax function puts exponentially more weight on larger input values. So far so good, the next problem is to efficiently find the vectors that have a high cosine similarity with \(\mathbf{q}{i}\) for all \(i\). First, the authors of Reformer notice that sharing the query and key projections: \(\mathbf{Q} = \mathbf{K}\) does not impact the performance of a transformer model \({}^1\). Now, instead of having to find the key vectors of high cosine similarity for each query vector \(q_i\), only the cosine similarity of query vectors to each other has to be found. This is important because there is a transitive property to the query-query vector dot product approximation: If \(\mathbf{q}{i}\) has a high cosine similarity to the query vectors \(\mathbf{q}{j}\) and \(\mathbf{q}{k}\), then \(\mathbf{q}{j}\) also has a high cosine similarity to \(\mathbf{q}{k}\). Therefore, the query vectors can be clustered into buckets, such that all query vectors that belong to the same bucket have a high cosine similarity to each other. Let's define \(C{m}\) as the mth set of position indices, such that their corresponding query vectors are in the same bucket: \(C_{m} = { i | \text{ s.t. } \mathbf{q}{i} \in \text{mth cluster}}\) and config.num_buckets, i.e. \(n{b}\), as the number of buckets. For each set of indices \(C_{m}\), the softmax function on the corresponding bucket of query vectors \(\text{softmax}(\mathbf{Q}{i \in C{m}} \mathbf{Q}^T_{i \in C_{m}})\) approximates the softmax function of global self-attention with shared query and key projections \(\text{softmax}(\mathbf{q}{i}^T \mathbf{Q}^T)\) for all position indices \(i\) in \(C{m}\). Second, the authors make use of the LSH algorithm to cluster the query vectors into a predefined number of buckets \(n_{b}\). The LSH algorithm is an ideal choice here because it is very efficient and is an approximation of the nearest neighbor algorithm for cosine similarity. Explaining the LSH scheme is out-of-scope for this notebook, so let's just keep in mind that for each vector \(\mathbf{q}{i}\) the LSH algorithm attributes its position index \(i\) to one of \(n{b}\) predefined buckets, i.e. \(\text{LSH}(\mathbf{q}{i}) = m\) with \(i \in {1, \ldots, n}\) and \(m \in {1, \ldots, n{b}}\). Visually, we can illustrate this as follows for our original example: Third, it can be noted that having clustered all query vectors in \(n_{b}\) buckets, the corresponding set of indices \(C_{m}\) can be used to permute the input vectors \(\mathbf{x}1, \ldots, \mathbf{x}_n\) accordingly \({}^2\) so that shared query-key self-attention can be applied piecewise similar to local attention. Let's clarify with our example input vectors \(\mathbf{X} = \mathbf{x}_1, ..., \mathbf{x}{16}\) and assume config.num_buckets=4 and config.lsh_chunk_length = 4. Looking at the graphic above we can see that we have assigned each query vector \( \mathbf{q}1, \ldots, \mathbf{q}{16} \) to one of the clusters \( \mathcal{C}{1}, \mathcal{C}{2}, \mathcal{C}{3}, \mathcal{C}{4} \) . If we now sort the corresponding input vectors \( \mathbf{x}1, \ldots, \mathbf{x}{16} \) accordingly, we get the following permuted input \( \mathbf{X'} \): The self-attention mechanism should be applied for each cluster individually so that for each cluster \( \mathcal{C}m \) the corresponding output is calculated as follows: \( \mathbf{Z}^{\text{LSH}}{i \in \mathcal{C}m} = \text{SelfAttn}{\mathbf{Q}=\mathbf{K}}(\mathbf{X}{i \in \mathcal{C}_m}) \). Let's illustrate this again for our example. As can be seen, the self-attention function operates on different sizes of matrices, which is suboptimal for efficient batching in GPU and TPU. To overcome this problem, the permuted input can be chunked the same way it is done for local attention so that each chunk is of size config.lsh_chunk_length. By chunking the permuted input, a bucket might be split into two different chunks. To remedy this problem, in LSH self-attention each chunk attends to its previous chunk config.lsh_num_chunks_before=1 in addition to itself, the same way local self-attention does (config.lsh_num_chunks_after is usually set to 0). This way, we can be assured that all vectors in a bucket attend to each other with a high probability \({}^3\). All in all for all chunks \( k \in {1, \ldots, n{c}} \), LSH self-attention can be noted down as follows: $$ \mathbf{Z'}{l{c} * k + 1:l_{c} * (k + 1)}^{\text{LSH}} = \text{SelfAttn}{\mathbf{Q} = \mathbf{K}}(\mathbf{X'}{l_{c} * k + 1): l_{c} * (k + 1)})\left[l_{c}:\right] $$ with \(\mathbf{X'}\) and \( \mathbf{Z'} \) being the input and output vectors permuted according to the LSH algorithm. Enough complicated formulas, let's illustrate LSH self-attention. The permuted vectors \(\mathbf{X'}\) as shown above are chunked and shared query key self-attention is applied to each chunk. Finally, the output \(\mathbf{Z'}^{\text{LSH}}\) is reordered to its original permutation. One important feature to mention here as well is that the accuracy of LSH self-attention can be improved by running LSH self-attention config.num_hashes, e.g. \(n_{h} \) times in parallel, each with a different random LSH hash. By setting config.num_hashes > 1, for each output position \( i \), multiple output vectors \( \mathbf{z}^{\text{LSH}, 1}{i}, \ldots, \mathbf{z}^{\text{LSH}, n{h}}{i} \) are computed and subsequently merged: \( \mathbf{z}^{\text{LSH}}{i} = \sum_k^{n_{h}} \mathbf{Z}^{\text{LSH}, k}{i} * \text{weight}^k_i \). The \( \text{weight}^k_i \) represents the importance of the output vectors \( \mathbf{z}^{\text{LSH}, k}{i} \) of hashing round \( k \) in comparison to the other hashing rounds, and is exponentially proportional to the normalization term of their softmax computation. The intuition behind this is that if the corresponding query vector \( \mathbf{q}{i}^{k} \) have a high cosine similarity with all other query vectors in its respective chunk, then the softmax normalization term of this chunk tends to be high, so that the corresponding output vectors \( \mathbf{q}{i}^{k} \) should be a better approximation to global attention and thus receive more weight than output vectors of hashing rounds with a lower softmax normalization term. For more detail see Appendix A of the paper. For our example, multi-round LSH self-attention can be illustrated as follows. Great. That's it. Now we know how LSH self-attention works in Reformer. Regarding the memory complexity, we now have two terms that compete which each other to be the memory bottleneck: the dot-product: \( \mathcal{O}(n_{h} * n_{c} * l_{c}^2) = \mathcal{O}(n * n_{h} * l_{c}) \) and the required memory for LSH bucketing: \( \mathcal{O}(n * n_{h} * \frac{n_{b}}{2}) \) with \( l_{c} \) being the chunk length. Because for large \( n \), the number of buckets \( \frac{n_{b}}{2} \) grows much faster than the chunk length \( l_{c} \), the user can again factorize the number of buckets config.num_buckets as explained here. Let's recap quickly what we have gone through above: 1. We want to approximate global attention using the knowledge that the softmax operation only puts significant weights on very few key vectors. 2. If key vectors are equal to query vectors this means that for each query vector \( \mathbf{q}{i} \), the softmax only puts significant weight on other query vectors that are similar in terms of cosine similarity. 3. This relationship works in both ways, meaning if \( \mathbf{q}{j} \) is similar to \( \mathbf{q}{i} \) than \(\mathbf{q}{j} \) is also similar to \( \mathbf{q}{i} \), so that we can do a global clustering before applying self-attention on a permuted input. 4. We apply local self-attention on the permuted input and re-order the output to its original permutation. --- \( {}^{1} \) The authors run some preliminary experiments confirming that shared query key self-attention performs more or less as well as standard self-attention. \( {}^{2} \) To be more exact the query vectors within a bucket are sorted according to their original order. This means if, e.g. the vectors \( \mathbf{q}_1, \mathbf{q}_3, \mathbf{q}_7 \) are all hashed to bucket 2, the order of the vectors in bucket 2 would still be \( \mathbf{q}_1 \), followed by \( \mathbf{q}_3 \) and \( \mathbf{q}_7 \). \( {}^3 \) On a side note, it is to mention the authors put a mask on the query vector \( \mathbf{q}{i} \) to prevent the vector from attending to itself. Because the cosine similarity of a vector to itself will always be as high or higher than the cosine similarity to other vectors, the query vectors in shared query key self-attention are strongly discouraged to attend to themselves.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Benchmark Benchmark tools were recently added to Transformers - see here for a more detailed explanation. To show how much memory can be saved using "local" + "LSH" self-attention, the Reformer model google/reformer-enwik8 is benchmarked for different local_attn_chunk_length and lsh_attn_chunk_length. The default configuration and usage of the google/reformer-enwik8 model can be checked in more detail here. Let's first do some necessary imports and installs. #@title Installs and Imports # pip installs !pip -qq install git+https://github.com/huggingface/transformers.git !pip install -qq py3nvml from transformers import ReformerConfig, PyTorchBenchmark, PyTorchBenchmarkArguments First, let's benchmark the memory usage of the Reformer model using global self-attention. This can be achieved by setting lsh_attn_chunk_length = local_attn_chunk_length = 8192 so that for all input sequences smaller or equal to 8192, the model automatically switches to global self-attention. config = ReformerConfig.from_pretrained("google/reformer-enwik8", lsh_attn_chunk_length=16386, local_attn_chunk_length=16386, lsh_num_chunks_before=0, local_num_chunks_before=0) benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[2048, 4096, 8192, 16386], batch_sizes=[1], models=["Reformer"], no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config], args=benchmark_args) result = benchmark.run() HBox(children=(FloatProgress(value=0.0, description='Downloading', max=1279.0, style=ProgressStyle(description… 1 / 1 Doesn't fit on GPU. CUDA out of memory. Tried to allocate 2.00 GiB (GPU 0; 11.17 GiB total capacity; 8.87 GiB already allocated; 1.92 GiB free; 8.88 GiB reserved in total by PyTorch) ==================== INFERENCE - MEMORY - RESULT ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer 1 2048 1465 Reformer 1 4096 2757 Reformer 1 8192 7893 Reformer 1 16386 N/A -------------------------------------------------------------------------------- The longer the input sequence, the more visible is the quadratic relationship \( \mathcal{O}(n^2) \) between input sequence and peak memory usage. As can be seen, in practice it would require a much longer input sequence to clearly observe that doubling the input sequence quadruples the peak memory usage. For this a google/reformer-enwik8 model using global attention, a sequence length of over 16K results in a memory overflow. Now, let's activate local and LSH self-attention by using the model's default parameters. config = ReformerConfig.from_pretrained("google/reformer-enwik8") benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[2048, 4096, 8192, 16384, 32768, 65436], batch_sizes=[1], models=["Reformer"], no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config], args=benchmark_args) result = benchmark.run() 1 / 1 Doesn't fit on GPU. CUDA out of memory. Tried to allocate 2.00 GiB (GPU 0; 11.17 GiB total capacity; 7.85 GiB already allocated; 1.74 GiB free; 9.06 GiB reserved in total by PyTorch) Doesn't fit on GPU. CUDA out of memory. Tried to allocate 4.00 GiB (GPU 0; 11.17 GiB total capacity; 6.56 GiB already allocated; 3.99 GiB free; 6.81 GiB reserved in total by PyTorch) ==================== INFERENCE - MEMORY - RESULT ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer 1 2048 1785 Reformer 1 4096 2621 Reformer 1 8192 4281 Reformer 1 16384 7607 Reformer 1 32768 N/A Reformer 1 65436 N/A -------------------------------------------------------------------------------- As expected using local and LSH self-attention is much more memory efficient for longer input sequences, so that the model runs out of memory only at 16K tokens for a 11GB RAM GPU in this notebook.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

3. Reversible Residual Layers Reversible residual layers were first introduced in N. Gomez et al and used to reduce memory consumption when training the popular ResNet model. Mathematically, reversible residual layers are slightly different to "real" residual layers but do not require the activations to be saved during the forward pass, which can drastically reduce memory consumption for training.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Chunked Feed Forward Layer in Reformer In Reformer, the LSH- or local self-attention layer is usually followed by a residual connection, which then defines the first part in a transformer block. For more detail on this please refer to this blog. The output of the first part of the transformer block, called normed self-attention output can be written as \( \mathbf{\overline{Z}} = \mathbf{Z} + \mathbf{X} \), with \( \mathbf{Z} \) being either \( \mathbf{Z}^{\text{LSH}} \) or \( \mathbf{Z}^\text{loc} \) in Reformer. For our example input \( \mathbf{x}1, \ldots, \mathbf{x}{16} \), we illustrate the normed self-attention output as follows. Now, the second part of a transformer block usually consists of two feed forward layers \( ^{1} \), defined as \( \text{Linear}{\text{int}}(\ldots) \) that processes \( \mathbf{\overline{Z}} \), to an intermediate output \( \mathbf{Y}{\text{int}} \) and \( \text{Linear}{\text{out}}(\ldots) \) that processes the intermediate output to the output \( \mathbf{Y}{\text{out}} \). The two feed forward layers can be defined by $$\mathbf{Y}{\text{out}} = \text{Linear}{\text{out}}(\mathbf{Y}\text{int}) = \text{Linear}{\text{out}}(\text{Linear}{\text{int}}(\mathbf{\overline{Z}})).$$ It is important to remember at this point that mathematically the output of a feed forward layer at position \( \mathbf{y}{\text{out}, i} \) only depends on the input at this position \( \mathbf{\overline{y}}{i} \). In contrast to the self-attention layer, every output \( \mathbf{y}{\text{out}, i} \) is therefore completely independent of all inputs \( \mathbf{\overline{y}}{j \ne i} \) of different positions. Let's illustrate the feed forward layers for \( \mathbf{\overline{z}}_1, \ldots, \mathbf{\overline{z}}{16} \). As can be depicted from the illustration, all input vectors \( \mathbf{\overline{z}}{i} \) are processed by the same feed forward layer in parallel. It becomes interesting when one takes a look at the output dimensions of the feed forward layers. In Reformer, the output dimension of \( \text{Linear}{\text{int}} \) is defined as config.feed_forward_size, e.g. \( d_{f} \), and the output dimension of \( \text{Linear}{\text{out}} \) is defined as config.hidden_size, i.e. \( d{h} \). The Reformer authors observed that in a transformer model the intermediate dimension \( d_{f} \) usually tends to be much larger than the output dimension \(^{2}\) \( d_{h} \). This means that the tensor \( \mathbf{\mathbf{Y}}\text{int} \) of dimension \( d{f} \times n \) allocates a significant amount of the total memory and can even become the memory bottleneck. To get a better feeling for the differences in dimensions let's picture the matrices \( \mathbf{Y}\text{int} \) and \( \mathbf{Y}\text{out} \) for our example. It is becoming quite obvious that the tensor \( \mathbf{Y}\text{int} \) holds much more memory ( \( \frac{d{f}}{d_{h}} \times n \) as much to be exact) than \( \mathbf{Y}{\text{out}} \). But, is it even necessary to compute the full intermediate matrix \( \mathbf{Y}\text{int} \) ? Not really, because relevant is only the output matrix \( \mathbf{Y}\text{out} \). To trade memory for speed, one can thus chunk the linear layers computation to only process one chunk at the time. Defining config.chunk_size_feed_forward as \( c{f} \), chunked linear layers are defined as \( \mathbf{Y}{\text{out}} = \left[\mathbf{Y}{\text{out}, 1: c_{f}}, \ldots, \mathbf{Y}{\text{out}, (n - c{f}): n}\right] \) with \( \mathbf{Y}{\text{out}, (c{f} * i): (i * c_{f} + i)} = \text{Linear}{\text{out}}(\text{Linear}{\text{int}}(\mathbf{\overline{Z}}{(c{f} * i): (i * c_{f} + i)})) \). In practice, it just means that the output is incrementally computed and concatenated to avoid having to store the whole intermediate tensor \( \mathbf{Y}{\text{int}} \) in memory. Assuming \( c{f}=1 \) for our example we can illustrate the incremental computation of the output for position \( i=9 \) as follows. By processing the inputs in chunks of size 1, the only tensors that have to be stored in memory at the same time are \( \mathbf{Y}\text{out} \) of a maximum size of \( 16 \times d{h} \), \( \mathbf{y}{\text{int}, i} \) of size \( d{f} \) and the input \( \mathbf{\overline{Z}} \) of size \( 16 \times d_{h} \), with \( d_{h} \) being config.hidden_size \(^{3}\). Finally, it is important to remember that chunked linear layers yield a mathematically equivalent output to conventional linear layers and can therefore be applied to all transformer linear layers. Making use of config.chunk_size_feed_forward therefore allows a better trade-off between memory and speed in certain use cases. --- \( {}^1 \) For a simpler explanation, the layer norm layer which is normally applied to \( \mathbf{\overline{Z}} \) before being processed by the feed forward layers is omitted for now. \( {}^2 \) In bert-base-uncased, e.g. the intermediate dimension \( d_{f} \) is with 3072 four times larger than the output dimension \( d_{h} \). \( {}^3 \) As a reminder, the output config.num_attention_heads is assumed to be 1 for the sake of clarity and illustration in this notebook, so that the output of the self-attention layers can be assumed to be of size config.hidden_size. More information on chunked linear / feed forward layers can also be found here on the 🤗Transformers docs.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Benchmark Let's test how much memory can be saved by using chunked feed forward layers. #@title Installs and Imports # pip installs !pip -qq install git+https://github.com/huggingface/transformers.git !pip install -qq py3nvml from transformers import ReformerConfig, PyTorchBenchmark, PyTorchBenchmarkArguments Building wheel for transformers (setup.py) ... [?25l[?25hdone First, let's compare the default google/reformer-enwik8 model without chunked feed forward layers to the one with chunked feed forward layers. config_no_chunk = ReformerConfig.from_pretrained("google/reformer-enwik8") # no chunk config_chunk = ReformerConfig.from_pretrained("google/reformer-enwik8", chunk_size_feed_forward=1) # feed forward chunk benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[1024, 2048, 4096], batch_sizes=[8], models=["Reformer-No-Chunk", "Reformer-Chunk"], no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config_no_chunk, config_chunk], args=benchmark_args) result = benchmark.run() 1 / 2 Doesn't fit on GPU. CUDA out of memory. Tried to allocate 2.00 GiB (GPU 0; 11.17 GiB total capacity; 7.85 GiB already allocated; 1.74 GiB free; 9.06 GiB reserved in total by PyTorch) 2 / 2 Doesn't fit on GPU. CUDA out of memory. Tried to allocate 2.00 GiB (GPU 0; 11.17 GiB total capacity; 7.85 GiB already allocated; 1.24 GiB free; 9.56 GiB reserved in total by PyTorch) ==================== INFERENCE - MEMORY - RESULT ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer-No-Chunk 8 1024 4281 Reformer-No-Chunk 8 2048 7607 Reformer-No-Chunk 8 4096 N/A Reformer-Chunk 8 1024 4309 Reformer-Chunk 8 2048 7669 Reformer-Chunk 8 4096 N/A -------------------------------------------------------------------------------- Interesting, chunked feed forward layers do not seem to help here at all. The reason is that config.feed_forward_size is not sufficiently large to make a real difference. Only at longer sequence lengths of 4096, a slight decrease in memory usage can be seen. Let's see what happens to the memory peak usage if we increase the size of the feed forward layer by a factor of 4 and reduce the number of attention heads also by a factor of 4 so that the feed forward layer becomes the memory bottleneck. config_no_chunk = ReformerConfig.from_pretrained("google/reformer-enwik8", chunk_size_feed_forward=0, num_attention_{h}eads=2, feed_forward_size=16384) # no chuck config_chunk = ReformerConfig.from_pretrained("google/reformer-enwik8", chunk_size_feed_forward=1, num_attention_{h}eads=2, feed_forward_size=16384) # feed forward chunk benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[1024, 2048, 4096], batch_sizes=[8], models=["Reformer-No-Chunk", "Reformer-Chunk"], no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config_no_chunk, config_chunk], args=benchmark_args) result = benchmark.run() 1 / 2 2 / 2 ==================== INFERENCE - MEMORY - RESULT ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer-No-Chunk 8 1024 3743 Reformer-No-Chunk 8 2048 5539 Reformer-No-Chunk 8 4096 9087 Reformer-Chunk 8 1024 2973 Reformer-Chunk 8 2048 3999 Reformer-Chunk 8 4096 6011 -------------------------------------------------------------------------------- Now a clear decrease in peak memory usage can be seen for longer input sequences. As a conclusion, it should be noted chunked feed forward layers only makes sense for models having few attention heads and large feed forward layers.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

# The Reformer - Pushing the limits of language modeling

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Reversible Residual Layers in Reformer Let's start by investigating why training a model requires much more memory than the inference of the model. When running a model in inference, the required memory equals more or less the memory it takes to compute the single largest tensor in the model. On the other hand, when training a model, the required memory equals more or less the sum of all differentiable tensors. This is not surprising when considering how auto differentiation works in deep learning frameworks. These lecture slides by Roger Grosse of the University of Toronto are great to better understand auto differentiation. In a nutshell, in order to calculate the gradient of a differentiable function (e.g. a layer), auto differentiation requires the gradient of the function's output and the function's input and output tensor. While the gradients are dynamically computed and subsequently discarded, the input and output tensors (a.k.a activations) of a function are stored during the forward pass. Alright, let's apply this to a transformer model. A transformer model includes a stack of multiple so-called transformer layers. Each additional transformer layer forces the model to store more activations during the forward pass and thus increases the required memory for training. Let's take a more detailed look. A transformer layer essentially consists of two residual layers. The first residual layer represents the self-attention mechanism as explained in section 1) and the second residual layer represents the linear or feed-forward layers as explained in section 2). Using the same notation as before, the input of a transformer layer i.e. \( \mathbf{X} \) is first normalized \( ^{1} \) and subsequently processed by the self-attention layer to get the output \( \mathbf{Z} = \text{SelfAttn}(\text{LayerNorm}(\mathbf{X})) \). We will abbreviate these two layers with \( G \) so that \( \mathbf{Z} = G(\mathbf{X}) \). Next, the residual \( \mathbf{Z} \) is added to the input \( \mathbf{\overline{Z}} = \mathbf{Z} + \mathbf{X} \) and the sum is fed into the second residual layer - the two linear layers. \( \mathbf{\overline{Z}} \) is processed by a second normalization layer, followed by the two linear layers to get \( \mathbf{Y} = \text{Linear}(\text{LayerNorm}(\mathbf{Z} + \mathbf{X})) \). We will abbreviate the second normalization layer and the two linear layers with \( F \) yielding \( \mathbf{Y} = F(\mathbf{\overline{Z}}) \). Finally, the residual \( \mathbf{Y} \) is added to \( \mathbf{\overline{Z}} \) to give the output of the transformer layer \( \mathbf{\overline{Y}} = \mathbf{Y} + \mathbf{\overline{Z}} \). Let's illustrate a complete transformer layer using the example of \( \mathbf{x}1, \ldots, \mathbf{x}{16} \). To calculate the gradient of e.g. the self-attention block \( G \), three tensors have to be known beforehand: the gradient \( \partial \mathbf{Z} \), the output \( \mathbf{Z} \), and the input \( \mathbf{X} \). While \( \partial \mathbf{Z} \) can be calculated on-the-fly and discarded afterward, the values for \( \mathbf{Z} \) and \( \mathbf{X} \) have to be calculated and stored during the forward pass since it is not possible to recalculate them easily on-the-fly during backpropagation. Therefore, during the forward pass, large tensor outputs, such as the query-key dot product matrix \( \mathbf{Q}\mathbf{K}^T \) or the intermediate output of the linear layers \( \mathbf{Y}^{\text{int}} \), have to be stored in memory \( ^{2} \). Here, reversible residual layers come to our help. The idea is relatively straight-forward. The residual block is designed in a way so that instead of having to store the input and output tensor of a function, both can easily be recalculated during the backward pass so that no tensor has to be stored in memory during the forward pass. This is achieved by using two input streams \( \mathbf{X}^{(1)}, \mathbf{X}^{(2)} \), and two output streams \( \mathbf{\overline{Y}}^{(1)}, \mathbf{\overline{Y}}^{(2)} \). The first residual \( \mathbf{Z} \) is computed by the first output stream \( \mathbf{Z} = G(\mathbf{X}^{(1)}) \) and subsequently added to the input of the second input stream, so that \( \mathbf{\overline{Z}} = \mathbf{Z} + \mathbf{X}^{(2)} \). Similarly, the residual \( \mathbf{Y} = F(\mathbf{\overline{Z}}) \) is added to the first input stream again, so that the two output streams are defined by \( \mathbf{Y}^{(1)} = \mathbf{Y} + \mathbf{X}^{(1)} \) and \( \mathbf{Y}^{(2)} = \mathbf{X}^{(2)} + \mathbf{Z} = \mathbf{\overline{Z}} \). The reversible transformer layer can be visualized for \( \mathbf{x}1, \ldots, \mathbf{x}{16} \) as follows. As can be seen, the outputs \( \mathbf{\overline{Y}}^{(1)}, \mathbf{\overline{Y}}^{(2)} \) are calculated in a very similar way than \( \mathbf{\overline{Y}} \) of the non-reversible layer, but they are mathematically different. The authors of Reformer observe in some initial experiments that the performance of a reversible transformer model matches the performance of a standard transformer model. The first visible difference to the standard transformer layer is that there are two input streams and output streams \( ^{3} \), which at first slightly increases the required memory for both the forward pass. The two-stream architecture is crucial though for not having to save any activations during the forward pass. Let's explain. For backpropagation, the reversible transformer layer has to calculate the gradients \( \partial G \) and \( \partial F \). In addition to the gradients \( \partial \mathbf{Y} \) and \( \partial \mathbf{Z} \) which can be calculated on-the-fly, the tensor values \( \mathbf{Y} \), \( \mathbf{\overline{Z}} \) have to be known for \( \partial F \) and the tensor values \( \mathbf{Z} \) and \( \mathbf{X}^{(1)} \) for \( \partial G \) to make auto-differentiation work. If we assume to know \( \mathbf{\overline{Y}}^{(1)}, \mathbf{\overline{Y}}^{(2)} \), it can easily be depicted from the graph that one can calculate \( \mathbf{X}^{(1)}, \mathbf{X}^{(2)} \) as follows. \( \mathbf{X}^{(1)} = F(\mathbf{\overline{Y}}^{(1)}) - \mathbf{\overline{Y}}^{(1)} \). Great, now that \( \mathbf{X}^{(1)} \) is known, \( \mathbf{X}^{(2)} \) can be computed by \( \mathbf{X}^{(2)} = \mathbf{\overline{Y}}^{(1)} - G(\mathbf{X}^{(1)}) \). Alright now, \( \mathbf{Z} \) and \( \mathbf{Y} \) are trivial to compute via \( \mathbf{Y} = \mathbf{\overline{Y}}^{(1)} - \mathbf{X}^{(1)} \) and \( \mathbf{Z} = \mathbf{\overline{Y}}^{(2)} - \mathbf{X}^{(2)} \). So as a conclusion, if only the outputs \( \mathbf{\overline{Y}}^{(1)}, \mathbf{\overline{Y}}^{(2)} \) of the last reversible transformer layer are stored during the forward pass, all other relevant activations can be derived by making use of \( G \) and \( F \) during the backward pass and passing \( \mathbf{X}^{(1)} \) and \( \mathbf{X}^{(2)} \). The overhead of two forward passes of \( G \) and \( F \) per reversible transformer layer during the backpropagation is traded against not having to store any activations during the forward pass. Not a bad deal! Note: Since recently, major deep learning frameworks have released code that allows to store only certain activations and recompute larger ones during the backward propagation (Tensoflow here and PyTorch here). For standard reversible layers, this still means that at least one activation has to be stored for each transformer layer, but by defining which activations can dynamically be recomputed a lot of memory can be saved. --- \( ^{1} \) In the previous two sections, we have omitted the layer norm layers preceding both the self-attention layer and the linear layers. The reader should know that both \( \mathbf{X} \) and \( \mathbf{\overline{Z}} \) are both processed by layer normalization before being fed into self-attention and the linear layers respectively. \( ^{2} \) While in the design the dimension of \( \mathbf{Q}\mathbf{K} \) is written as \( n \times n \), in a LSH self-attention or local self-attention layer the dimension would only be \( n \times l_{c} \times n_{h} \) or \( n \times l_{c} \) respectively with \( l_{c} \) being the chunk length and \( n_{h} \) the number of hashes \( ^{3} \) In the first reversible transformer layer \( \mathbf{X}^{(2)} \) is set to be equal to \( \mathbf{X}^{(1)} \).

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Benchmark In order to measure the effect of reversible residual layers, we will compare the memory consumption of BERT with Reformer in training for an increasing number of layers. #@title Installs and Imports # pip installs !pip -qq install git+https://github.com/huggingface/transformers.git !pip install -qq py3nvml from transformers import ReformerConfig, BertConfig, PyTorchBenchmark, PyTorchBenchmarkArguments Let's measure the required memory for the standard bert-base-uncased BERT model by increasing the number of layers from 4 to 12. config_4_layers_bert = BertConfig.from_pretrained("bert-base-uncased", num_hidden_layers=4) config_8_layers_bert = BertConfig.from_pretrained("bert-base-uncased", num_hidden_layers=8) config_12_layers_bert = BertConfig.from_pretrained("bert-base-uncased", num_hidden_layers=12) benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[512], batch_sizes=[8], models=["Bert-4-Layers", "Bert-8-Layers", "Bert-12-Layers"], training=True, no_inference=True, no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config_4_layers_bert, config_8_layers_bert, config_12_layers_bert], args=benchmark_args) result = benchmark.run() HBox(children=(FloatProgress(value=0.0, description='Downloading', max=433.0, style=ProgressStyle(description_… 1 / 3 2 / 3 3 / 3 ==================== TRAIN - MEMORY - RESULTS ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Bert-4-Layers 8 512 4103 Bert-8-Layers 8 512 5759 Bert-12-Layers 8 512 7415 -------------------------------------------------------------------------------- It can be seen that adding a single layer of BERT linearly increases the required memory by more than 400MB. config_4_layers_reformer = ReformerConfig.from_pretrained("google/reformer-enwik8", num_hidden_layers=4, num_hashes=1) config_8_layers_reformer = ReformerConfig.from_pretrained("google/reformer-enwik8", num_hidden_layers=8, num_hashes=1) config_12_layers_reformer = ReformerConfig.from_pretrained("google/reformer-enwik8", num_hidden_layers=12, num_hashes=1) benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[512], batch_sizes=[8], models=["Reformer-4-Layers", "Reformer-8-Layers", "Reformer-12-Layers"], training=True, no_inference=True, no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config_4_layers_reformer, config_8_layers_reformer, config_12_layers_reformer], args=benchmark_args) result = benchmark.run() 1 / 3 2 / 3 3 / 3 ==================== TRAIN - MEMORY - RESULTS ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer-4-Layers 8 512 4607 Reformer-8-Layers 8 512 4987 Reformer-12-Layers 8 512 5367 -------------------------------------------------------------------------------- For Reformer, on the other hand, adding a layer adds significantly less memory in practice. Adding a single layer increases the required memory on average by less than 100MB so that a much larger 12-Layer reformer-enwik8 model requires less memory than a 12-Layer bert-base-uncased model.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

2. Chunked Feed Forward Layers Transformer-based models often employ very large feed forward layers after the self-attention layer in parallel. Thereby, this layer can take up a significant amount of the overall memory and sometimes even represent the memory bottleneck of a model. First introduced in the Reformer paper, feed forward chunking is a technique that allows to effectively trade better memory consumption for increased time consumption.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Benchmark Lastly, let's also compare the peak memory consumption of conventional positional embeddings to axial positional embeddings. #@title Installs and Imports # pip installs !pip -qq install git+https://github.com/huggingface/transformers.git !pip install -qq py3nvml from transformers import ReformerConfig, PyTorchBenchmark, PyTorchBenchmarkArguments, ReformerModel Positional embeddings depend only on two configuration parameters: The maximum allowed length of input sequences config.max_position_embeddings and config.hidden_size. Let's use a model that pushes the maximum allowed length of input sequences to half a million tokens, called google/reformer-crime-and-punishment, to see the effect of using axial positional embeddings. To begin with, we will compare the shape of axial position encodings with standard positional encodings and the number of parameters in the model. config_no_pos_axial_embeds = ReformerConfig.from_pretrained("google/reformer-crime-and-punishment", axial_pos_embds=False) # disable axial positional embeddings config_pos_axial_embeds = ReformerConfig.from_pretrained("google/reformer-crime-and-punishment", axial_pos_embds=True, axial_pos_embds_dim=(64, 192), axial_pos_shape=(512, 1024)) # enable axial positional embeddings print("Default Positional Encodings") print(20 * '-') model = ReformerModel(config_no_pos_axial_embeds) print(f"Positional embeddings shape: {model.embeddings.position_embeddings}") print(f"Num parameters of model: {model.num_parameters()}") print(20 * '-' + '\n\n') print("Axial Positional Encodings") print(20 * '-') model = ReformerModel(config_pos_axial_embeds) print(f"Positional embeddings shape: {model.embeddings.position_embeddings}") print(f"Num parameters of model: {model.num_parameters()}") print(20 * '-' + '\n\n') HBox(children=(FloatProgress(value=0.0, description='Downloading', max=1151.0, style=ProgressStyle(description… Default Positional Encodings -------------------- Positional embeddings shape: PositionEmbeddings( (embedding): Embedding(524288, 256) ) Num parameters of model: 136572416 -------------------- Axial Positional Encodings -------------------- Positional embeddings shape: AxialPositionEmbeddings( (weights): ParameterList( (0): Parameter containing: [torch.FloatTensor of size 512x1x64] (1): Parameter containing: [torch.FloatTensor of size 1x1024x192] ) ) Num parameters of model: 2584064 -------------------- Having read the theory, the shape of the axial positional encoding weights should not be a surprise to the reader. Regarding the results, it can be seen that for models being capable of processing such long input sequences, it is not practical to use default positional encodings. In the case of google/reformer-crime-and-punishment, standard positional encodings alone contain more than 100M parameters. Axial positional encodings reduce this number to just over 200K. Lastly, let's also compare the required memory at inference time. benchmark_args = PyTorchBenchmarkArguments(sequence_lengths=[512], batch_sizes=[8], models=["Reformer-No-Axial-Pos-Embeddings", "Reformer-Axial-Pos-Embeddings"], no_speed=True, no_env_print=True) benchmark = PyTorchBenchmark(configs=[config_no_pos_axial_embeds, config_pos_axial_embeds], args=benchmark_args) result = benchmark.run() 1 / 2 2 / 2 ==================== INFERENCE - MEMORY - RESULT ==================== -------------------------------------------------------------------------------- Model Name Batch Size Seq Length Memory in MB -------------------------------------------------------------------------------- Reformer-No-Axial-Pos-Embeddin 8 512 959 Reformer-Axial-Pos-Embeddings 8 512 447 -------------------------------------------------------------------------------- It can be seen that using axial positional embeddings reduces the memory requirement to approximately half in the case of google/reformer-crime-and-punishment.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

How the Reformer uses less than 8GB of RAM to train on sequences of half a million tokens The Reformer model as introduced by Kitaev, Kaiser et al. (2020) is one of the most memory-efficient transformer models for long sequence modeling as of today. Recently, long sequence modeling has experienced a surge of interest as can be seen by the many submissions from this year alone - Beltagy et al. (2020), Roy et al. (2020), Tay et al., Wang et al. to name a few. The motivation behind long sequence modeling is that many tasks in NLP, e.g. summarization, question answering, require the model to process longer input sequences than models, such as BERT, are able to handle. In tasks that require the model to process a large input sequence, long sequence models do not have to cut the input sequence to avoid memory overflow and thus have been shown to outperform standard "BERT"-like models cf. Beltagy et al. (2020). The Reformer pushes the limit of longe sequence modeling by its ability to process up to half a million tokens at once as shown in this demo. As a comparison, a conventional bert-base-uncased model limits the input length to only 512 tokens. In Reformer, each part of the standard transformer architecture is re-engineered to optimize for minimal memory requirement without a significant drop in performance. The memory improvements can be attributed to 4 features which the Reformer authors introduced to the transformer world: 1. Reformer Self-Attention Layer - How to efficiently implement self-attention without being restricted to a local context? 2. Chunked Feed Forward Layers - How to get a better time-memory trade-off for large feed forward layers? 3. Reversible Residual Layers - How to drastically reduce memory consumption in training by a smart residual architecture? 4. Axial Positional Encodings - How to make positional encodings usable for extremely large input sequences? The goal of this blog post is to give the reader an in-depth understanding of each of the four Reformer features mentioned above. While the explanations are focussed on the Reformer, the reader should get a better intuition under which circumstances each of the four features can be effective for other transformer models as well. The four sections are only loosely connected, so they can very well be read individually. Reformer is part of the 🤗Transformers library. For all users of the Reformer, it is advised to go through this very detailed blog post to better understand how the model works and how to correctly set its configuration. All equations are accompanied by their equivalent name for the Reformer config, e.g. config.<param_name>, so that the reader can quickly relate to the official docs and configuration file. Note: Axial Positional Encodings are not explained in the official Reformer paper, but are extensively used in the official codebase. This blog post gives the first in-depth explanation of Axial Positional Encodings.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

Axial Positional Encodings in Reformer Transformers need positional encodings to account for the order of words in the input because self-attention layers have no notion of order. Positional encodings are usually defined by a simple look-up matrix \( \mathbf{E} = \left[\mathbf{e}1, \ldots, \mathbf{e}{n_\text{max}}\right] \) The positional encoding vector \( \mathbf{e}{i} \) is then simply added to the ith input vector \( \mathbf{x}{i} + \mathbf{e}{i} \) so that the model can distinguish if an input vector (a.k.a token) is at position \( i \) or \( j \). For every input position, the model needs to be able to look up the corresponding positional encoding vector so that the dimension of \( \mathbf{E} \) is defined by the maximum length of input vectors the model can process config.max_position_embeddings, i.e. \( n\text{max} \), and the config.hidden_size, i.e. \( d_{h} \) of the input vectors. Assuming \( d_{h}=4 \) and \( n_\text{max}=49 \), such a positional encoding matrix can be visualized as follows: Here, we showcase only the positional encodings \( \mathbf{e}{1} \), \( \mathbf{e}{2} \), and \( \mathbf{e}{49} \) each of dimension, a.k.a height 4. Let's imagine, we want to train a Reformer model on sequences of a length of up to 0.5M tokens and an input vector config.hidden_size of 1024 (see notebook here). The corresponding positional embeddings have a size of \( 0.5M \times 1024 \sim 512M \) parameters, which corresponds to a size of 2GB. Such positional encodings would use an unnecessarily large amount of memory both when loading the model in memory and when saving the model on a hard drive. The Reformer authors managed to drastically shrink the positional encodings in size by cutting the config.hidden_size dimension in two and smartly factorizing the \( n\text{max} \) dimension. In Transformer, the user can decide into which shape \( n_\text{max} \) can be factorized into by setting config.axial_pos_shape to an appropriate list of two values \( n_\text{max}^1 \) and \( n_\text{max}^2 \) so that \( n_\text{max}^1 \times n_\text{max}^2 = n_\text{max} \). By setting config.axial_pos_embds_dim to an appropriate list of two values \( d_{h}^{1} \) and \( d_{h}^2 \) so that \( d_{h}^1 + d_{h}^2 = d_{h} \), the user can decide how the hidden size dimension should be cut. Now, let's visualize and explain more intuitively. One can think of factorizing \( n_{\text{max}} \) as folding the dimension into a third axis, which is shown in the following for the factorization config.axial_pos_shape = [7, 7]: Each of the three standing rectangular prisms corresponds to one of the encoding vectors \( \mathbf{e}{1}, \mathbf{e}{2}, \mathbf{e}{49} \), but we can see that the 49 encoding vectors are divided into 7 rows of 7 vectors each. Now the idea is to use only one row of 7 encoding vectors and expand those vectors to the other 6 rows, essentially reusing their values. Because it is discouraged to have the same values for different encoding vectors, each vector of dimension (a.k.a height) config.hidden_size=4 is cut into the lower encoding vector \( \mathbf{e}\text{down} \) of size \( 1 \) and \( \mathbf{e}\text{up} \) of size \( 3 \), so that the lower part can be expanded along the row dimension and the upper part can be expanded along the column dimension. Let's visualize for more clarity. We can see that we have cut the embedding vectors into \( \mathbf{e}\text{down} \) (in blue) and \( \mathbf{e}\text{up} \) (in yellow). Now for the "sub"-vectors \( \mathbf{E}\text{down} = \left[\mathbf{e}{\text{down},1}, \ldots, \mathbf{e}{\text{down},49}\right] \) only the first row, a.k.a. the width in the graphic, of \( 7 \) is kept and expanded along the column dimension, a.k.a. the depth of the graphic. Inversely, for the "sub"-vectors \( \mathbf{E}\text{up} = \left[\mathbf{e}{\text{up},1}, \ldots, \mathbf{e}{\text{up},49}\right] \) only the first column of \( 7 \) is kept and expanded along the row dimension. The resulting embedding vectors \( \mathbf{e'}{i} \) then correspond to $$\mathbf{e'}{i} = \left[ \left[\mathbf{e}{\text{down, } i \% n_\text{max}^1}\right]^T, \left[\mathbf{e}{\text{up, } \left \lfloor{\frac{i}{{n}^2{\text{max}}}}\right \rfloor} \right]^T \right]^T $$ whereas \( n_\text{max}^1 = 7 \) and \( n_\text{max}^2 = 7 \) in our example. These new encodings \( \mathbf{E'} = \left[\mathbf{e'}{1}, \ldots, \mathbf{e'}{n_\text{max}}\right] \) are called Axial Position Encodings. In the following, these axial position encodings are illustrated in more detail for our example. Now it should be more understandable how the final positional encoding vectors \( \mathbf{E'} \) are calculated only from \( \mathbf{E}{\text{down}} \) of dimension \( d{h}^1 \times n_{\text{max}^1} \) and \( \mathbf{E}{\text{up}} \) of dimension \( d{h}^2 \times n_{\text{max}}^2 \). The crucial aspect to see here is that Axial Positional Encodings make sure that none of the vectors \( \left[\mathbf{e'}1, \ldots, \mathbf{e'}{n_{\text{max}}}\right] \) are equal to each other by design and that the overall size of the encoding matrix is reduced from \( n_{\text{max}} \times d_{h} \) to \( n_{\text{max}}^1 \times d_{h}^1 + n_\text{max}^2 \times d_{h}^2 \). By allowing each axial positional encoding vector to be different by design the model is given much more flexibility to learn efficient positional representations if axial positional encodings are learned by the model. To demonstrate the drastic reduction in size, let's assume we would have set config.axial_pos_shape = [1024, 512] and config.axial_pos_embds_dim = [512, 512] for a Reformer model that can process inputs up to a length of 0.5M tokens. The resulting axial positional encoding matrix would have had a size of only \( 1024 \times 512 + 512 \times 512 \sim 800K \) parameters which corresponds to roughly 3MB. This is a drastic reduction from the 2GB a standard positional encoding matrix would require in this case. For a more condensed and math-heavy explanation please refer to the 🤗Transformers docs here.

The Reformer - Pushing the limits of language modeling

patrickvonplaten

July 3, 2020

reformer

research, nlp

https://huggingface.co/blog/reformer

1. Reformer Self-Attention Layer Reformer uses two kinds of special self-attention layers: local self-attention layers and Locality Sensitive Hashing (LSH) self-attention layers. To better introduce these new self-attention layers, we will briefly recap conventional self-attention as introduced in Vaswani et al. 2017. This blog post uses the same notation and coloring as the popular blog post The illustrated transformer, so the reader is strongly advised to read this blog first. Important: While Reformer was originally introduced for causal self-attention, it can very well be used for bi-directional self-attention as well. In this post, Reformer's self-attention is presented for bidirectional self-attention.

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

# Block Sparse Matrices for Smaller and Faster Language Models

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

Usage The provided BlockSparseLinear module is a drop in replacement for torch.nn.Linear, and it is trivial to use it in your models: python # from torch.nn import Linear from pytorch_block_sparse import BlockSparseLinear ... # self.fc = nn.Linear(1024, 256) self.fc = BlockSparseLinear(1024, 256, density=0.1) The extension also provides a BlockSparseModelPatcher that allows to modify an existing model "on the fly", which is shown in this example notebook. Such a model can then be trained as usual, without any change in your model source code.

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

NVIDIA CUTLASS This extension is based on the cutlass tilesparse proof of concept by Yulhwa Kim. It is using C++ CUDA templates for block-sparse matrix multiplication based on CUTLASS. CUTLASS is a collection of CUDA C++ templates for implementing high-performance CUDA kernels. With CUTLASS, approching cuBLAS performance on custom kernels is possible without resorting to assembly language code. The latest versions include all the Ampere Tensor Core primitives, providing x10 or more speedups with a limited loss of precision. Next versions of pytorch_block_sparse will make use of these primitives, as block sparsity is 100% compatible with Tensor Cores requirements.

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

Saving space and time, one zero at a time In previous blog posts we introduced sparse matrices and what they could do to improve neural networks. The basic assumption is that full dense layers are often overkill and can be pruned without a significant loss in precision. In some cases sparse linear layers can even improve precision or/and generalization. The main issue is that currently available code that supports sparse algebra computation is severely lacking efficiency. We are also still waiting for official PyTorch support. That's why we ran out of patience and took some time this summer to address this "lacuna". Today, we are excited to release the extension pytorch_block_sparse. By itself, or even better combined with other methods like distillation and quantization, this library enables networks which are both smaller and faster, something Hugging Face considers crucial to let anybody use neural networks in production at low cost, and to improve the experience for the end user.

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

Performance At the current stage of the library, the performances for sparse matrices are roughly two times slower than their cuBLAS optimized dense counterpart, and we are confident that we can improve this in the future. This is a huge improvement on PyTorch sparse matrices: their current implementation is an order of magnitude slower than the dense one. But the more important point is that the performance gain of using sparse matrices grows with the sparsity, so a 75% sparse matrix is roughly 2x faster than the dense equivalent. The memory savings are even more significant: for 75% sparsity, memory consumption is reduced by 4x as you would expect.

Block Sparse Matrices for Smaller and Faster Language Models

madlag

Sep 10, 2020

pytorch_block_sparse

research, nlp

https://huggingface.co/blog/pytorch_block_sparse

Future work Being able to efficiently train block-sparse linear layers was just the first step. The sparsity pattern is currenly fixed at initialization, and of course optimizing it during learning will yield large improvements. So in future versions, you can expect tools to measure the "usefulness" of parameters to be able to optimize the sparsity pattern. NVIDIA Ampere 50% sparse pattern within blocks will probably yield another significant performance gain, just as upgrading to more recent versions of CUTLASS does. So, stay tuned for more sparsity goodness in a near future!

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

Decoder As mentioned in the Encoder-Decoder section, the transformer-based decoder defines the conditional probability distribution of a target sequence given the contextualized encoding sequence: $$ p_{\theta_{dec}}(\mathbf{Y}{1: m} | \mathbf{\overline{X}}{1:n}), $$ which by Bayes\' rule can be decomposed into a product of conditional distributions of the next target vector given the contextualized encoding sequence and all previous target vectors: $$ p_{\theta_{dec}}(\mathbf{Y}{1:m} | \mathbf{\overline{X}}{1:n}) = \prod_{i=1}^{m} p_{\theta_{dec}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}_{1:n}). $$ Let\'s first understand how the transformer-based decoder defines a probability distribution. The transformer-based decoder is a stack of decoder blocks followed by a dense layer, the \"LM head\". The stack of decoder blocks maps the contextualized encoding sequence \(\mathbf{\overline{X}}_{1:n}\) and a target vector sequence prepended by the \(\text{BOS}\) vector and cut to the last target vector, i.e. \(\mathbf{Y}{0:i-1}\), to an encoded sequence of target vectors \(\mathbf{\overline{Y}}{0: i-1}\). Then, the \"LM head\" maps the encoded sequence of target vectors \(\mathbf{\overline{Y}}{0: i-1}\) to a sequence of logit vectors \(\mathbf{L}{1:n} = \mathbf{l}1, \ldots, \mathbf{l}_n\), whereas the dimensionality of each logit vector \(\mathbf{l}_i\) corresponds to the size of the vocabulary. This way, for each \(i \in {1, \ldots, n}\) a probability distribution over the whole vocabulary can be obtained by applying a softmax operation on \(\mathbf{l}_i\). These distributions define the conditional distribution: $$p{\theta_{dec}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}_{1:n}), \forall i \in {1, \ldots, n},$$ respectively. The \"LM head\" is often tied to the transpose of the word embedding matrix, i.e. \(\mathbf{W}{\text{emb}}^{\intercal} = \left[\mathbf{y}^1, \ldots, \mathbf{y}^{\text{vocab}}\right]^{\intercal}\) \({}^1\). Intuitively this means that for all \(i \in {0, \ldots, n - 1}\) the \"LM Head\" layer compares the encoded output vector \(\mathbf{\overline{y}}_i\) to all word embeddings in the vocabulary \(\mathbf{y}^1, \ldots, \mathbf{y}^{\text{vocab}}\) so that the logit vector \(\mathbf{l}{i+1}\) represents the similarity scores between the encoded output vector and each word embedding. The softmax operation simply transformers the similarity scores to a probability distribution. For each \(i \in {1, \ldots, n}\), the following equations hold: $$ p_{\theta_{dec}}(\mathbf{y} | \mathbf{\overline{X}}{1:n}, \mathbf{Y}{0:i-1})$$ $$ = \text{Softmax}(f_{\theta_{\text{dec}}}(\mathbf{\overline{X}}{1:n}, \mathbf{Y}{0:i-1}))$$ $$ = \text{Softmax}(\mathbf{W}{\text{emb}}^{\intercal} \mathbf{\overline{y}}{i-1})$$ $$ = \text{Softmax}(\mathbf{l}i). $$ Putting it all together, in order to model the conditional distribution of a target vector sequence \(\mathbf{Y}{1: m}\), the target vectors \(\mathbf{Y}_{1:m-1}\) prepended by the special \(\text{BOS}\) vector, i.e. \(\mathbf{y}0\), are first mapped together with the contextualized encoding sequence \(\mathbf{\overline{X}}{1:n}\) to the logit vector sequence \(\mathbf{L}{1:m}\). Consequently, each logit target vector \(\mathbf{l}_i\) is transformed into a conditional probability distribution of the target vector \(\mathbf{y}_i\) using the softmax operation. Finally, the conditional probabilities of all target vectors \(\mathbf{y}_1, \ldots, \mathbf{y}_m\) multiplied together to yield the conditional probability of the complete target vector sequence: $$ p{\theta_{dec}}(\mathbf{Y}{1:m} | \mathbf{\overline{X}}{1:n}) = \prod_{i=1}^{m} p_{\theta_{dec}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}_{1:n}).$$ In contrast to transformer-based encoders, in transformer-based decoders, the encoded output vector \(\mathbf{\overline{y}}_i\) should be a good representation of the next target vector \(\mathbf{y}{i+1}\) and not of the input vector itself. Additionally, the encoded output vector \(\mathbf{\overline{y}}_i\) should be conditioned on all contextualized encoding sequence \(\mathbf{\overline{X}}{1:n}\). To meet these requirements each decoder block consists of a uni-directional self-attention layer, followed by a cross-attention layer and two feed-forward layers \({}^2\). The uni-directional self-attention layer puts each of its input vectors \(\mathbf{y'}j\) only into relation with all previous input vectors \(\mathbf{y'}_i, \text{ with } i \le j\) for all \(j \in {1, \ldots, n}\) to model the probability distribution of the next target vectors. The cross-attention layer puts each of its input vectors \(\mathbf{y''}_j\) into relation with all contextualized encoding vectors \(\mathbf{\overline{X}}{1:n}\) to condition the probability distribution of the next target vectors on the input of the encoder as well. Alright, let\'s visualize the transformer-based decoder for our English to German translation example. We can see that the decoder maps the input \(\mathbf{Y}_{0:5}\) \"BOS\", \"Ich\", \"will\", \"ein\", \"Auto\", \"kaufen\" (shown in light red) together with the contextualized sequence of \"I\", \"want\", \"to\", \"buy\", \"a\", \"car\", \"EOS\", i.e. \(\mathbf{\overline{X}}{1:7}\) (shown in dark green) to the logit vectors \(\mathbf{L}{1:6}\) (shown in dark red). Applying a softmax operation on each \(\mathbf{l}1, \mathbf{l}_2, \ldots, \mathbf{l}_5\) can thus define the conditional probability distributions: $$ p{\theta_{dec}}(\mathbf{y} | \text{BOS}, \mathbf{\overline{X}}{1:7}), $$ $$ p{\theta_{dec}}(\mathbf{y} | \text{BOS Ich}, \mathbf{\overline{X}}{1:7}), $$ $$ \ldots, $$ $$ p{\theta_{dec}}(\mathbf{y} | \text{BOS Ich will ein Auto kaufen}, \mathbf{\overline{X}}{1:7}). $$ The overall conditional probability of: $$ p{\theta_{dec}}(\text{Ich will ein Auto kaufen EOS} | \mathbf{\overline{X}}{1:n})$$ can therefore be computed as the following product: $$ p{\theta_{dec}}(\text{Ich} | \text{BOS}, \mathbf{\overline{X}}{1:7}) \times \ldots \times p{\theta_{dec}}(\text{EOS} | \text{BOS Ich will ein Auto kaufen}, \mathbf{\overline{X}}{1:7}). $$ The red box on the right shows a decoder block for the first three target vectors \(\mathbf{y}_0, \mathbf{y}_1, \mathbf{y}_2\). In the lower part, the uni-directional self-attention mechanism is illustrated and in the middle, the cross-attention mechanism is illustrated. Let\'s first focus on uni-directional self-attention. As in bi-directional self-attention, in uni-directional self-attention, the query vectors \(\mathbf{q}_0, \ldots, \mathbf{q}{m-1}\) (shown in purple below), key vectors \(\mathbf{k}0, \ldots, \mathbf{k}{m-1}\) (shown in orange below), and value vectors \(\mathbf{v}0, \ldots, \mathbf{v}{m-1}\) (shown in blue below) are projected from their respective input vectors \(\mathbf{y'}0, \ldots, \mathbf{y'}{m-1}\) (shown in light red below). However, in uni-directional self-attention, each query vector \(\mathbf{q}_i\) is compared only to its respective key vector and all previous ones, namely \(\mathbf{k}_0, \ldots, \mathbf{k}_i\) to yield the respective attention weights. This prevents an output vector \(\mathbf{y''}j\) (shown in dark red below) to include any information about the following input vector \(\mathbf{y}_i, \text{ with } i > j\) for all \(j \in {0, \ldots, m - 1 }\). As is the case in bi-directional self-attention, the attention weights are then multiplied by their respective value vectors and summed together. We can summarize uni-directional self-attention as follows: $$\mathbf{y''}_i = \mathbf{V}{0: i} \textbf{Softmax}(\mathbf{K}_{0: i}^\intercal \mathbf{q}_i) + \mathbf{y'}_i. $$ Note that the index range of the key and value vectors is \(0:i\) instead of \(0: m-1\) which would be the range of the key vectors in bi-directional self-attention. Let\'s illustrate uni-directional self-attention for the input vector \(\mathbf{y'}_1\) for our example above. As can be seen \(\mathbf{y''}_1\) only depends on \(\mathbf{y'}_0\) and \(\mathbf{y'}_1\). Therefore, we put the vector representation of the word \"Ich\", i.e. \(\mathbf{y'}_1\) only into relation with itself and the \"BOS\" target vector, i.e. \(\mathbf{y'}_0\), but not with the vector representation of the word \"will\", i.e. \(\mathbf{y'}2\). So why is it important that we use uni-directional self-attention in the decoder instead of bi-directional self-attention? As stated above, a transformer-based decoder defines a mapping from a sequence of input vector \(\mathbf{Y}{0: m-1}\) to the logits corresponding to the next decoder input vectors, namely \(\mathbf{L}_{1:m}\). In our example, this means, e.g. that the input vector \(\mathbf{y}1\) = \"Ich\" is mapped to the logit vector \(\mathbf{l}_2\), which is then used to predict the input vector \(\mathbf{y}_2\). Thus, if \(\mathbf{y'}_1\) would have access to the following input vectors \(\mathbf{Y'}{2:5}\), the decoder would simply copy the vector representation of \"will\", i.e. \(\mathbf{y'}2\), to be its output \(\mathbf{y''}_1\). This would be forwarded to the last layer so that the encoded output vector \(\mathbf{\overline{y}}_1\) would essentially just correspond to the vector representation \(\mathbf{y}_2\). This is obviously disadvantageous as the transformer-based decoder would never learn to predict the next word given all previous words, but just copy the target vector \(\mathbf{y}_i\) through the network to \(\mathbf{\overline{y}}{i-1}\) for all \(i \in {1, \ldots, m }\). In order to define a conditional distribution of the next target vector, the distribution cannot be conditioned on the next target vector itself. It does not make much sense to predict \(\mathbf{y}i\) from \(p(\mathbf{y} | \mathbf{Y}{0:i}, \mathbf{\overline{X}})\) because the distribution is conditioned on the target vector it is supposed to model. The uni-directional self-attention architecture, therefore, allows us to define a causal probability distribution, which is necessary to effectively model a conditional distribution of the next target vector. Great! Now we can move to the layer that connects the encoder and decoder - the cross-attention mechanism! The cross-attention layer takes two vector sequences as inputs: the outputs of the uni-directional self-attention layer, i.e. \(\mathbf{Y''}{0: m-1}\) and the contextualized encoding vectors \(\mathbf{\overline{X}}{1:n}\). As in the self-attention layer, the query vectors \(\mathbf{q}0, \ldots, \mathbf{q}{m-1}\) are projections of the output vectors of the previous layer, i.e. \(\mathbf{Y''}{0: m-1}\). However, the key and value vectors \(\mathbf{k}_0, \ldots, \mathbf{k}{m-1}\) and \(\mathbf{v}0, \ldots, \mathbf{v}{m-1}\) are projections of the contextualized encoding vectors \(\mathbf{\overline{X}}_{1:n}\). Having defined key, value, and query vectors, a query vector \(\mathbf{q}_i\) is then compared to all key vectors and the corresponding score is used to weight the respective value vectors, just as is the case for bi-directional self-attention to give the output vector \(\mathbf{y'''}i\) for all \(i \in {0, \ldots, m-1}\). Cross-attention can be summarized as follows: $$ \mathbf{y'''}_i = \mathbf{V}{1:n} \textbf{Softmax}(\mathbf{K}{1: n}^\intercal \mathbf{q}_i) + \mathbf{y''}_i. $$ Note that the index range of the key and value vectors is \(1:n\) corresponding to the number of contextualized encoding vectors. Let\'s visualize the cross-attention mechanism for the input vector \(\mathbf{y''}_1\) for our example above. We can see that the query vector \(\mathbf{q}_1\) (shown in purple) is derived from \(\mathbf{y''}_1\)(shown in red) and therefore relies on a vector representation of the word \"Ich\". The query vector \(\mathbf{q}_1\) is then compared to the key vectors \(\mathbf{k}_1, \ldots, \mathbf{k}_7\) (shown in yellow) corresponding to the contextual encoding representation of all encoder input vectors \(\mathbf{X}{1:n}\) = \"I want to buy a car EOS\". This puts the vector representation of \"Ich\" into direct relation with all encoder input vectors. Finally, the attention weights are multiplied by the value vectors \(\mathbf{v}1, \ldots, \mathbf{v}_7\) (shown in turquoise) to yield in addition to the input vector \(\mathbf{y''}_1\) the output vector \(\mathbf{y'''}_1\) (shown in dark red). So intuitively, what happens here exactly? Each output vector \(\mathbf{y'''}_i\) is a weighted sum of all value projections of the encoder inputs \(\mathbf{v}{1}, \ldots, \mathbf{v}_7\) plus the input vector itself \(\mathbf{y''}_i\) (c.f. illustrated formula above). The key mechanism to understand is the following: Depending on how similar a query projection of the input decoder vector \(\mathbf{q}_i\) is to a key projection of the encoder input vector \(\mathbf{k}j\), the more important is the value projection of the encoder input vector \(\mathbf{v}_j\). In loose terms this means, the more \"related\" a decoder input representation is to an encoder input representation, the more does the input representation influence the decoder output representation. Cool! Now we can see how this architecture nicely conditions each output vector \(\mathbf{y'''}_i\) on the interaction between the encoder input vectors \(\mathbf{\overline{X}}{1:n}\) and the input vector \(\mathbf{y''}i\). Another important observation at this point is that the architecture is completely independent of the number \(n\) of contextualized encoding vectors \(\mathbf{\overline{X}}{1:n}\) on which the output vector \(\mathbf{y'''}i\) is conditioned on. All projection matrices \(\mathbf{W}^{\text{cross}}{k}\) and \(\mathbf{W}^{\text{cross}}_{v}\) to derive the key vectors \(\mathbf{k}_1, \ldots, \mathbf{k}_n\) and the value vectors \(\mathbf{v}_1, \ldots, \mathbf{v}_n\) respectively are shared across all positions \(1, \ldots, n\) and all value vectors \( \mathbf{v}_1, \ldots, \mathbf{v}_n \) are summed together to a single weighted averaged vector. Now it becomes obvious as well, why the transformer-based decoder does not suffer from the long-range dependency problem, the RNN-based decoder suffers from. Because each decoder logit vector is directly dependent on every single encoded output vector, the number of mathematical operations to compare the first encoded output vector and the last decoder logit vector amounts essentially to just one. To conclude, the uni-directional self-attention layer is responsible for conditioning each output vector on all previous decoder input vectors and the current input vector and the cross-attention layer is responsible to further condition each output vector on all encoded input vectors. To verify our theoretical understanding, let\'s continue our code example from the encoder section above. ------------------------------------------------------------------------ \({}^1\) The word embedding matrix \(\mathbf{W}_{\text{emb}}\) gives each input word a unique context-independent vector representation. This matrix is often fixed as the \"LM Head\" layer. However, the \"LM Head\" layer can very well consist of a completely independent \"encoded vector-to-logit\" weight mapping. \({}^2\) Again, an in-detail explanation of the role the feed-forward layers play in transformer-based models is out-of-scope for this notebook. It is argued in Yun et. al, (2017) that feed-forward layers are crucial to map each contextual vector \(\mathbf{x'}_i\) individually to the desired output space, which the self-attention layer does not manage to do on its own. It should be noted here, that each output token \(\mathbf{x'}\) is processed by the same feed-forward layer. For more detail, the reader is advised to read the paper. python from transformers import MarianMTModel, MarianTokenizer import torch tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de") model = MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de") embeddings = model.get_input_embeddings() # create token ids for encoder input input_ids = tokenizer("I want to buy a car", return_tensors="pt").input_ids # pass input token ids to encoder encoder_output_vectors = model.base_model.encoder(input_ids, return_dict=True).last_hidden_state # create token ids for decoder input decoder_input_ids = tokenizer("<pad> Ich will ein", return_tensors="pt", add_special_tokens=False).input_ids # pass decoder input ids and encoded input vectors to decoder decoder_output_vectors = model.base_model.decoder(decoder_input_ids, encoder_hidden_states=encoder_output_vectors).last_hidden_state # derive embeddings by multiplying decoder outputs with embedding weights lm_logits = torch.nn.functional.linear(decoder_output_vectors, embeddings.weight, bias=model.final_logits_bias) # change the decoder input slightly decoder_input_ids_perturbed = tokenizer("<pad> Ich will das", return_tensors="pt", add_special_tokens=False).input_ids decoder_output_vectors_perturbed = model.base_model.decoder(decoder_input_ids_perturbed, encoder_hidden_states=encoder_output_vectors).last_hidden_state lm_logits_perturbed = torch.nn.functional.linear(decoder_output_vectors_perturbed, embeddings.weight, bias=model.final_logits_bias) # compare shape and encoding of first vector print(f"Shape of decoder input vectors {embeddings(decoder_input_ids).shape}. Shape of decoder logits {lm_logits.shape}") # compare values of word embedding of "I" for input_ids and perturbed input_ids print("Is encoding for `Ich` equal to its perturbed version?: ", torch.allclose(lm_logits[0, 0], lm_logits_perturbed[0, 0], atol=1e-3)) Output: Shape of decoder input vectors torch.Size([1, 5, 512]). Shape of decoder logits torch.Size([1, 5, 58101]) Is encoding for `Ich` equal to its perturbed version?: True We compare the output shape of the decoder input word embeddings, i.e. embeddings(decoder_input_ids) (corresponds to \(\mathbf{Y}{0: 4}\), here <pad> corresponds to BOS and \"Ich will das\" is tokenized to 4 tokens) with the dimensionality of the lm_logits(corresponds to \(\mathbf{L}{1:5}\)). Also, we have passed the word sequence \"<pad> Ich will ein\" and a slightly perturbated version \"<pad> Ich will das\" together with the encoder_output_vectors through the decoder to check if the second lm_logit, corresponding to \"Ich\", differs when only the last word is changed in the input sequence (\"ein\" -> \"das\"). As expected the output shapes of the decoder input word embeddings and lm_logits, i.e. the dimensionality of \(\mathbf{Y}{0: 4}\) and \(\mathbf{L}{1:5}\) are different in the last dimension. While the sequence length is the same (=5), the dimensionality of a decoder input word embedding corresponds to model.config.hidden_size, whereas the dimensionality of a lm_logit corresponds to the vocabulary size model.config.vocab_size, as explained above. Second, it can be noted that the values of the encoded output vector of \(\mathbf{l}1 = \text{"Ich"}\) are the same when the last word is changed from \"ein\" to \"das\". This however should not come as a surprise if one has understood uni-directional self-attention. On a final side-note, _auto-regressive models, such as GPT2, have the same architecture as transformer-based decoder models if one removes the cross-attention layer because stand-alone auto-regressive models are not conditioned on any encoder outputs. So auto-regressive models are essentially the same as auto-encoding models but replace bi-directional attention with uni-directional attention. These models can also be pre-trained on massive open-domain text data to show impressive performances on natural language generation (NLG) tasks. In Radford et al. (2019), the authors show that a pre-trained GPT2 model can achieve SOTA or close to SOTA results on a variety of NLG tasks without much fine-tuning. All auto-regressive models of 🤗Transformers can be found here. Alright, that\'s it! Now, you should have gotten a good understanding of transformer-based encoder-decoder models and how to use them with the 🤗Transformers library. Thanks a lot to Victor Sanh, Sasha Rush, Sam Shleifer, Oliver Åstrand, ‪Ted Moskovitz and Kristian Kyvik for giving valuable feedback.

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

Encoder-Decoder In 2017, Vaswani et al. introduced the Transformer and thereby gave birth to transformer-based encoder-decoder models. Analogous to RNN-based encoder-decoder models, transformer-based encoder-decoder models consist of an encoder and a decoder which are both stacks of residual attention blocks. The key innovation of transformer-based encoder-decoder models is that such residual attention blocks can process an input sequence \(\mathbf{X}{1:n}\) of variable length \(n\) without exhibiting a recurrent structure. Not relying on a recurrent structure allows transformer-based encoder-decoders to be highly parallelizable, which makes the model orders of magnitude more computationally efficient than RNN-based encoder-decoder models on modern hardware. As a reminder, to solve a sequence-to-sequence problem, we need to find a mapping of an input sequence \(\mathbf{X}{1:n}\) to an output sequence \(\mathbf{Y}{1:m}\) of variable length \(m\). Let\'s see how transformer-based encoder-decoder models are used to find such a mapping. Similar to RNN-based encoder-decoder models, the transformer-based encoder-decoder models define a conditional distribution of target vectors \(\mathbf{Y}{1:n}\) given an input sequence \(\mathbf{X}{1:n}\): $$ p_{\theta_{\text{enc}}, \theta_{\text{dec}}}(\mathbf{Y}{1:m} | \mathbf{X}{1:n}). $$ The transformer-based encoder part encodes the input sequence \(\mathbf{X}{1:n}\) to a sequence of hidden states \(\mathbf{\overline{X}}{1:n}\), thus defining the mapping: $$ f_{\theta_{\text{enc}}}: \mathbf{X}{1:n} \to \mathbf{\overline{X}}{1:n}. $$ The transformer-based decoder part then models the conditional probability distribution of the target vector sequence \(\mathbf{Y}{1:n}\) given the sequence of encoded hidden states \(\mathbf{\overline{X}}{1:n}\): $$ p_{\theta_{dec}}(\mathbf{Y}{1:n} | \mathbf{\overline{X}}{1:n}).$$ By Bayes\' rule, this distribution can be factorized to a product of conditional probability distribution of the target vector \(\mathbf{y}i\) given the encoded hidden states \(\mathbf{\overline{X}}{1:n}\) and all previous target vectors \(\mathbf{Y}{0:i-1}\): $$ p{\theta_{dec}}(\mathbf{Y}{1:n} | \mathbf{\overline{X}}{1:n}) = \prod_{i=1}^{n} p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n}). $$ The transformer-based decoder hereby maps the sequence of encoded hidden states \(\mathbf{\overline{X}}{1:n}\) and all previous target vectors \(\mathbf{Y}{0:i-1}\) to the logit vector \(\mathbf{l}_i\). The logit vector \(\mathbf{l}_i\) is then processed by the softmax operation to define the conditional distribution \(p{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n})\), just as it is done for RNN-based decoders. However, in contrast to RNN-based decoders, the distribution of the target vector \(\mathbf{y}_i\) is explicitly (or directly) conditioned on all previous target vectors \(\mathbf{y}_0, \ldots, \mathbf{y}{i-1}\) as we will see later in more detail. The 0th target vector \(\mathbf{y}0\) is hereby represented by a special \"begin-of-sentence\" \(\text{BOS}\) vector. Having defined the conditional distribution \(p{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n})\), we can now auto-regressively generate the output and thus define a mapping of an input sequence \(\mathbf{X}{1:n}\) to an output sequence \(\mathbf{Y}{1:m}\) at inference. Let\'s visualize the complete process of auto-regressive generation of transformer-based encoder-decoder models. The transformer-based encoder is colored in green and the transformer-based decoder is colored in red. As in the previous section, we show how the English sentence \"I want to buy a car\", represented by \(\mathbf{x}_1 = \text{I}\), \(\mathbf{x}_2 = \text{want}\), \(\mathbf{x}_3 = \text{to}\), \(\mathbf{x}_4 = \text{buy}\), \(\mathbf{x}_5 = \text{a}\), \(\mathbf{x}_6 = \text{car}\), and \(\mathbf{x}_7 = \text{EOS}\) is translated into German: \"Ich will ein Auto kaufen\" defined as \(\mathbf{y}_0 = \text{BOS}\), \(\mathbf{y}_1 = \text{Ich}\), \(\mathbf{y}_2 = \text{will}\), \(\mathbf{y}_3 = \text{ein}\), \(\mathbf{y}_4 = \text{Auto}, \mathbf{y}_5 = \text{kaufen}\), and \(\mathbf{y}_6=\text{EOS}\). To begin with, the encoder processes the complete input sequence \(\mathbf{X}{1:7}\) = \"I want to buy a car\" (represented by the light green vectors) to a contextualized encoded sequence \(\mathbf{\overline{X}}{1:7}\). E.g. \(\mathbf{\overline{x}}_4\) defines an encoding that depends not only on the input \(\mathbf{x}_4\) = \"buy\", but also on all other words \"I\", \"want\", \"to\", \"a\", \"car\" and \"EOS\", i.e. the context. Next, the input encoding \(\mathbf{\overline{X}}{1:7}\) together with the BOS vector, i.e. \(\mathbf{y}0\), is fed to the decoder. The decoder processes the inputs \(\mathbf{\overline{X}}{1:7}\) and \(\mathbf{y}0\) to the first logit \(\mathbf{l}_1\) (shown in darker red) to define the conditional distribution of the first target vector \(\mathbf{y}_1\): $$ p{\theta_{enc, dec}}(\mathbf{y} | \mathbf{y}0, \mathbf{X}{1:7}) = p_{\theta_{enc, dec}}(\mathbf{y} | \text{BOS}, \text{I want to buy a car EOS}) = p_{\theta_{dec}}(\mathbf{y} | \text{BOS}, \mathbf{\overline{X}}{1:7}). $$ Next, the first target vector \(\mathbf{y}_1\) = \(\text{Ich}\) is sampled from the distribution (represented by the grey arrows) and can now be fed to the decoder again. The decoder now processes both \(\mathbf{y}_0\) = \"BOS\" and \(\mathbf{y}_1\) = \"Ich\" to define the conditional distribution of the second target vector \(\mathbf{y}_2\): $$ p{\theta_{dec}}(\mathbf{y} | \text{BOS Ich}, \mathbf{\overline{X}}{1:7}). $$ We can sample again and produce the target vector \(\mathbf{y}_2\) = \"will\". We continue in auto-regressive fashion until at step 6 the EOS vector is sampled from the conditional distribution: $$ \text{EOS} \sim p{\theta_{dec}}(\mathbf{y} | \text{BOS Ich will ein Auto kaufen}, \mathbf{\overline{X}}{1:7}). $$ And so on in auto-regressive fashion. It is important to understand that the encoder is only used in the first forward pass to map \(\mathbf{X}{1:n}\) to \(\mathbf{\overline{X}}{1:n}\). As of the second forward pass, the decoder can directly make use of the previously calculated encoding \(\mathbf{\overline{X}}{1:n}\). For clarity, let\'s illustrate the first and the second forward pass for our example above. As can be seen, only in step \(i=1\) do we have to encode \"I want to buy a car EOS\" to \(\mathbf{\overline{X}}{1:7}\). At step \(i=2\), the contextualized encodings of \"I want to buy a car EOS\" are simply reused by the decoder. In 🤗Transformers, this auto-regressive generation is done under-the-hood when calling the .generate() method. Let\'s use one of our translation models to see this in action. python from transformers import MarianMTModel, MarianTokenizer tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de") model = MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de") # create ids of encoded input vectors input_ids = tokenizer("I want to buy a car", return_tensors="pt").input_ids # translate example output_ids = model.generate(input_ids)[0] # decode and print print(tokenizer.decode(output_ids)) _Output: <pad> Ich will ein Auto kaufen Calling .generate() does many things under-the-hood. First, it passes the input_ids to the encoder. Second, it passes a pre-defined token, which is the \(\text{}\) symbol in the case of MarianMTModel along with the encoded input_ids to the decoder. Third, it applies the beam search decoding mechanism to auto-regressively sample the next output word of the last decoder output \({}^1\). For more detail on how beam search decoding works, one is advised to read this blog post. In the Appendix, we have included a code snippet that shows how a simple generation method can be implemented \"from scratch\". To fully understand how auto-regressive generation works under-the-hood, it is highly recommended to read the Appendix. To sum it up: - The transformer-based encoder defines a mapping from the input sequence \(\mathbf{X}{1:n}\) to a contextualized encoding sequence \(\mathbf{\overline{X}}{1:n}\). - The transformer-based decoder defines the conditional distribution \(p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n})\). - Given an appropriate decoding mechanism, the output sequence \(\mathbf{Y}{1:m}\) can auto-regressively be sampled from \(p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n}), \forall i \in {1, \ldots, m}\). Great, now that we have gotten a general overview of how transformer-based encoder-decoder models work, we can dive deeper into both the encoder and decoder part of the model. More specifically, we will see exactly how the encoder makes use of the self-attention layer to yield a sequence of context-dependent vector encodings and how self-attention layers allow for efficient parallelization. Then, we will explain in detail how the self-attention layer works in the decoder model and how the decoder is conditioned on the encoder\'s output with cross-attention layers to define the conditional distribution \(p{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{\overline{X}}{1:n})\). Along, the way it will become obvious how transformer-based encoder-decoder models solve the long-range dependencies problem of RNN-based encoder-decoder models. ------------------------------------------------------------------------ \({}^1\) In the case of "Helsinki-NLP/opus-mt-en-de", the decoding parameters can be accessed here, where we can see that model applies beam search with num_beams=6.

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

# Transformers-based Encoder-Decoder Models # Transformer-based Encoder-Decoder Models bash !pip install transformers==4.2.1 !pip install sentencepiece==0.1.95 The transformer-based encoder-decoder model was introduced by Vaswani et al. in the famous Attention is all you need paper and is today the de-facto standard encoder-decoder architecture in natural language processing (NLP). Recently, there has been a lot of research on different pre-training objectives for transformer-based encoder-decoder models, e.g. T5, Bart, Pegasus, ProphetNet, Marge, etc..., but the model architecture has stayed largely the same. The goal of the blog post is to give an in-detail explanation of how the transformer-based encoder-decoder architecture models sequence-to-sequence problems. We will focus on the mathematical model defined by the architecture and how the model can be used in inference. Along the way, we will give some background on sequence-to-sequence models in NLP and break down the transformer-based encoder-decoder architecture into its encoder and decoder parts. We provide many illustrations and establish the link between the theory of transformer-based encoder-decoder models and their practical usage in 🤗Transformers for inference. Note that this blog post does not explain how such models can be trained - this will be the topic of a future blog post. Transformer-based encoder-decoder models are the result of years of research on representation learning and model architectures. This notebook provides a short summary of the history of neural encoder-decoder models. For more context, the reader is advised to read this awesome blog post by Sebastion Ruder. Additionally, a basic understanding of the self-attention architecture is recommended. The following blog post by Jay Alammar serves as a good refresher on the original Transformer model here. At the time of writing this notebook, 🤗Transformers comprises the encoder-decoder models T5, Bart, MarianMT, and Pegasus, which are summarized in the docs under model summaries. The notebook is divided into four parts: - Background - A short history of neural encoder-decoder models is given with a focus on RNN-based models. - Encoder-Decoder - The transformer-based encoder-decoder model is presented and it is explained how the model is used for inference. - Encoder - The encoder part of the model is explained in detail. - Decoder - The decoder part of the model is explained in detail. Each part builds upon the previous part, but can also be read on its own.

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

Background Tasks in natural language generation (NLG), a subfield of NLP, are best expressed as sequence-to-sequence problems. Such tasks can be defined as finding a model that maps a sequence of input words to a sequence of target words. Some classic examples are summarization and translation. In the following, we assume that each word is encoded into a vector representation. \(n\) input words can then be represented as a sequence of \(n\) input vectors: $$\mathbf{X}{1:n} = {\mathbf{x}_1, \ldots, \mathbf{x}_n}.$$ Consequently, sequence-to-sequence problems can be solved by finding a mapping \(f\) from an input sequence of \(n\) vectors \(\mathbf{X}{1:n}\) to a sequence of \(m\) target vectors \(\mathbf{Y}{1:m}\), whereas the number of target vectors \(m\) is unknown apriori and depends on the input sequence: $$ f: \mathbf{X}{1:n} \to \mathbf{Y}{1:m}. $$ Sutskever et al. (2014) noted that deep neural networks (DNN)s, \"despite their flexibility and power can only define a mapping whose inputs and targets can be sensibly encoded with vectors of fixed dimensionality.\" \({}^1\) Using a DNN model \({}^2\) to solve sequence-to-sequence problems would therefore mean that the number of target vectors \(m\) has to be known apriori and would have to be independent of the input \(\mathbf{X}{1:n}\). This is suboptimal because, for tasks in NLG, the number of target words usually depends on the input \(\mathbf{X}{1:n}\) and not just on the input length \(n\). E.g., an article of 1000 words can be summarized to both 200 words and 100 words depending on its content. In 2014, Cho et al. and Sutskever et al. proposed to use an encoder-decoder model purely based on recurrent neural networks (RNNs) for sequence-to-sequence tasks. In contrast to DNNS, RNNs are capable of modeling a mapping to a variable number of target vectors. Let\'s dive a bit deeper into the functioning of RNN-based encoder-decoder models. During inference, the encoder RNN encodes an input sequence \(\mathbf{X}{1:n}\) by successively updating its hidden state \({}^3\). After having processed the last input vector \(\mathbf{x}n\), the encoder\'s hidden state defines the input encoding \(\mathbf{c}\). Thus, the encoder defines the mapping: $$ f{\theta_{enc}}: \mathbf{X}{1:n} \to \mathbf{c}. $$ Then, the decoder\'s hidden state is initialized with the input encoding and during inference, the decoder RNN is used to auto-regressively generate the target sequence. Let\'s explain. Mathematically, the decoder defines the probability distribution of a target sequence \(\mathbf{Y}{1:m}\) given the hidden state \(\mathbf{c}\): $$ p_{\theta_{dec}}(\mathbf{Y}{1:m} |\mathbf{c}). $$ By Bayes\' rule the distribution can be decomposed into conditional distributions of single target vectors as follows: $$ p{\theta_{dec}}(\mathbf{Y}{1:m} |\mathbf{c}) = \prod{i=1}^{m} p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c}). $$ Thus, if the architecture can model the conditional distribution of the next target vector, given all previous target vectors: $$ p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c}), \forall i \in {1, \ldots, m},$$ then it can model the distribution of any target vector sequence given the hidden state \(\mathbf{c}\) by simply multiplying all conditional probabilities. So how does the RNN-based decoder architecture model \(p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c})\)? In computational terms, the model sequentially maps the previous inner hidden state \(\mathbf{c}{i-1}\) and the previous target vector \(\mathbf{y}{i-1}\) to the current inner hidden state \(\mathbf{c}i\) and a logit vector \(\mathbf{l}_i\) (shown in dark red below): $$ f{\theta_{\text{dec}}}(\mathbf{y}{i-1}, \mathbf{c}{i-1}) \to \mathbf{l}i, \mathbf{c}_i.$$ \(\mathbf{c}_0\) is thereby defined as \(\mathbf{c}\) being the output hidden state of the RNN-based encoder. Subsequently, the softmax operation is used to transform the logit vector \(\mathbf{l}_i\) to a conditional probablity distribution of the next target vector: $$ p(\mathbf{y}_i | \mathbf{l}_i) = \textbf{Softmax}(\mathbf{l}_i), \text{ with } \mathbf{l}_i = f{\theta_{\text{dec}}}(\mathbf{y}{i-1}, \mathbf{c}{\text{prev}}). $$ For more detail on the logit vector and the resulting probability distribution, please see footnote \({}^4\). From the above equation, we can see that the distribution of the current target vector \(\mathbf{y}i\) is directly conditioned on the previous target vector \(\mathbf{y}{i-1}\) and the previous hidden state \(\mathbf{c}{i-1}\). Because the previous hidden state \(\mathbf{c}{i-1}\) depends on all previous target vectors \(\mathbf{y}0, \ldots, \mathbf{y}{i-2}\), it can be stated that the RNN-based decoder implicitly (e.g. indirectly) models the conditional distribution \(p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c})\). The space of possible target vector sequences \(\mathbf{Y}{1:m}\) is prohibitively large so that at inference, one has to rely on decoding methods \({}^5\) that efficiently sample high probability target vector sequences from \(p{\theta_{dec}}(\mathbf{Y}{1:m} |\mathbf{c})\). Given such a decoding method, during inference, the next input vector \(\mathbf{y}_i\) can then be sampled from \(p{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c})\) and is consequently appended to the input sequence so that the decoder RNN then models \(p_{\theta_{\text{dec}}}(\mathbf{y}{i+1} | \mathbf{Y}{0: i}, \mathbf{c})\) to sample the next input vector \(\mathbf{y}{i+1}\) and so on in an auto-regressive fashion. An important feature of RNN-based encoder-decoder models is the definition of special vectors, such as the \(\text{EOS}\) and \(\text{BOS}\) vector. The \(\text{EOS}\) vector often represents the final input vector \(\mathbf{x}_n\) to \"cue\" the encoder that the input sequence has ended and also defines the end of the target sequence. As soon as the \(\text{EOS}\) is sampled from a logit vector, the generation is complete. The \(\text{BOS}\) vector represents the input vector \(\mathbf{y}_0\) fed to the decoder RNN at the very first decoding step. To output the first logit \(\mathbf{l}_1\), an input is required and since no input has been generated at the first step a special \(\text{BOS}\) input vector is fed to the decoder RNN. Ok - quite complicated! Let\'s illustrate and walk through an example. The unfolded RNN encoder is colored in green and the unfolded RNN decoder is colored in red. The English sentence \"I want to buy a car\", represented by \(\mathbf{x}_1 = \text{I}\), \(\mathbf{x}_2 = \text{want}\), \(\mathbf{x}_3 = \text{to}\), \(\mathbf{x}_4 = \text{buy}\), \(\mathbf{x}_5 = \text{a}\), \(\mathbf{x}_6 = \text{car}\) and \(\mathbf{x}_7 = \text{EOS}\) is translated into German: \"Ich will ein Auto kaufen\" defined as \(\mathbf{y}_0 = \text{BOS}\), \(\mathbf{y}_1 = \text{Ich}\), \(\mathbf{y}_2 = \text{will}\), \(\mathbf{y}_3 = \text{ein}\), \(\mathbf{y}_4 = \text{Auto}, \mathbf{y}_5 = \text{kaufen}\) and \(\mathbf{y}_6=\text{EOS}\). To begin with, the input vector \(\mathbf{x}_1 = \text{I}\) is processed by the encoder RNN and updates its hidden state. Note that because we are only interested in the final encoder\'s hidden state \(\mathbf{c}\), we can disregard the RNN encoder\'s target vector. The encoder RNN then processes the rest of the input sentence \(\text{want}\), \(\text{to}\), \(\text{buy}\), \(\text{a}\), \(\text{car}\), \(\text{EOS}\) in the same fashion, updating its hidden state at each step until the vector \(\mathbf{x}_7={EOS}\) is reached \({}^6\). In the illustration above the horizontal arrow connecting the unfolded encoder RNN represents the sequential updates of the hidden state. The final hidden state of the encoder RNN, represented by \(\mathbf{c}\) then completely defines the encoding of the input sequence and is used as the initial hidden state of the decoder RNN. This can be seen as conditioning the decoder RNN on the encoded input. To generate the first target vector, the decoder is fed the \(\text{BOS}\) vector, illustrated as \(\mathbf{y}_0\) in the design above. The target vector of the RNN is then further mapped to the logit vector \(\mathbf{l}_1\) by means of the LM Head feed-forward layer to define the conditional distribution of the first target vector as explained above: $$ p{\theta_{dec}}(\mathbf{y} | \text{BOS}, \mathbf{c}). $$ The word \(\text{Ich}\) is sampled (shown by the grey arrow, connecting \(\mathbf{l}1\) and \(\mathbf{y}_1\)) and consequently the second target vector can be sampled: $$ \text{will} \sim p{\theta_{dec}}(\mathbf{y} | \text{BOS}, \text{Ich}, \mathbf{c}). $$ And so on until at step \(i=6\), the \(\text{EOS}\) vector is sampled from \(\mathbf{l}6\) and the decoding is finished. The resulting target sequence amounts to \(\mathbf{Y}{1:6} = {\mathbf{y}1, \ldots, \mathbf{y}_6}\), which is \"Ich will ein Auto kaufen\" in our example above. To sum it up, an RNN-based encoder-decoder model, represented by \(f{\theta_{\text{enc}}}\) and \( p_{\theta_{\text{dec}}} \) defines the distribution \(p(\mathbf{Y}{1:m} | \mathbf{X}{1:n})\) by factorization: $$ p_{\theta_{\text{enc}}, \theta_{\text{dec}}}(\mathbf{Y}{1:m} | \mathbf{X}{1:n}) = \prod_{i=1}^{m} p_{\theta_{\text{enc}}, \theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{X}{1:n}) = \prod{i=1}^{m} p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i-1}, \mathbf{c}), \text{ with } \mathbf{c}=f_{\theta_{enc}}(X). $$ During inference, efficient decoding methods can auto-regressively generate the target sequence \(\mathbf{Y}{1:m}\). The RNN-based encoder-decoder model took the NLG community by storm. In 2016, Google announced to fully replace its heavily feature engineered translation service by a single RNN-based encoder-decoder model (see here). Nevertheless, RNN-based encoder-decoder models have two pitfalls. First, RNNs suffer from the vanishing gradient problem, making it very difficult to capture long-range dependencies, cf. Hochreiter et al. (2001). Second, the inherent recurrent architecture of RNNs prevents efficient parallelization when encoding, cf. Vaswani et al. (2017). ------------------------------------------------------------------------ \({}^1\) The original quote from the paper is \"Despite their flexibility and power, DNNs can only be applied to problems whose inputs and targets can be sensibly encoded with vectors of fixed dimensionality\", which is slightly adapted here. \({}^2\) The same holds essentially true for convolutional neural networks (CNNs). While an input sequence of variable length can be fed into a CNN, the dimensionality of the target will always be dependent on the input dimensionality or fixed to a specific value. \({}^3\) At the first step, the hidden state is initialized as a zero vector and fed to the RNN together with the first input vector \(\mathbf{x}_1\). \({}^4\) A neural network can define a probability distribution over all words, i.e. \(p(\mathbf{y} | \mathbf{c}, \mathbf{Y}{0: i-1})\) as follows. First, the network defines a mapping from the inputs \(\mathbf{c}, \mathbf{Y}{0: i-1}\) to an embedded vector representation \(\mathbf{y'}\), which corresponds to the RNN target vector. The embedded vector representation \(\mathbf{y'}\) is then passed to the \"language model head\" layer, which means that it is multiplied by the word embedding matrix, i.e. \(\mathbf{Y}^{\text{vocab}}\), so that a score between \(\mathbf{y'}\) and each encoded vector \(\mathbf{y} \in \mathbf{Y}^{\text{vocab}}\) is computed. The resulting vector is called the logit vector \( \mathbf{l} = \mathbf{Y}^{\text{vocab}} \mathbf{y'} \) and can be mapped to a probability distribution over all words by applying a softmax operation: \(p(\mathbf{y} | \mathbf{c}) = \text{Softmax}(\mathbf{Y}^{\text{vocab}} \mathbf{y'}) = \text{Softmax}(\mathbf{l})\). \({}^5\) Beam-search decoding is an example of such a decoding method. Different decoding methods are out of scope for this notebook. The reader is advised to refer to this interactive notebook on decoding methods. \({}^6\) Sutskever et al. (2014) reverses the order of the input so that in the above example the input vectors would correspond to \(\mathbf{x}_1 = \text{car}\), \(\mathbf{x}_2 = \text{a}\), \(\mathbf{x}_3 = \text{buy}\), \(\mathbf{x}_4 = \text{to}\), \(\mathbf{x}_5 = \text{want}\), \(\mathbf{x}_6 = \text{I}\) and \(\mathbf{x}_7 = \text{EOS}\). The motivation is to allow for a shorter connection between corresponding word pairs such as \(\mathbf{x}_6 = \text{I}\) and \(\mathbf{y}_1 = \text{Ich}\). The research group emphasizes that the reversal of the input sequence was a key reason for their model\'s improved performance on machine translation.

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

Appendix As mentioned above, the following code snippet shows how one can program a simple generation method for transformer-based encoder-decoder models. Here, we implement a simple greedy decoding method using torch.argmax to sample the target vector. python from transformers import MarianMTModel, MarianTokenizer import torch tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de") model = MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de") # create ids of encoded input vectors input_ids = tokenizer("I want to buy a car", return_tensors="pt").input_ids # create BOS token decoder_input_ids = tokenizer("<pad>", add_special_tokens=False, return_tensors="pt").input_ids assert decoder_input_ids[0, 0].item() == model.config.decoder_start_token_id, "`decoder_input_ids` should correspond to `model.config.decoder_start_token_id`" # STEP 1 # pass input_ids to encoder and to decoder and pass BOS token to decoder to retrieve first logit outputs = model(input_ids, decoder_input_ids=decoder_input_ids, return_dict=True) # get encoded sequence encoded_sequence = (outputs.encoder_last_hidden_state,) # get logits lm_logits = outputs.logits # sample last token with highest prob next_decoder_input_ids = torch.argmax(lm_logits[:, -1:], axis=-1) # concat decoder_input_ids = torch.cat([decoder_input_ids, next_decoder_input_ids], axis=-1) # STEP 2 # reuse encoded_inputs and pass BOS + "Ich" to decoder to second logit lm_logits = model(None, encoder_outputs=encoded_sequence, decoder_input_ids=decoder_input_ids, return_dict=True).logits # sample last token with highest prob again next_decoder_input_ids = torch.argmax(lm_logits[:, -1:], axis=-1) # concat again decoder_input_ids = torch.cat([decoder_input_ids, next_decoder_input_ids], axis=-1) # STEP 3 lm_logits = model(None, encoder_outputs=encoded_sequence, decoder_input_ids=decoder_input_ids, return_dict=True).logits next_decoder_input_ids = torch.argmax(lm_logits[:, -1:], axis=-1) decoder_input_ids = torch.cat([decoder_input_ids, next_decoder_input_ids], axis=-1) # let's see what we have generated so far! print(f"Generated so far: {tokenizer.decode(decoder_input_ids[0], skip_special_tokens=True)}") # This can be written in a loop as well. Outputs: Generated so far: Ich will ein In this code example, we show exactly what was described earlier. We pass an input \"I want to buy a car\" together with the \(\text{BOS}\) token to the encoder-decoder model and sample from the first logit \(\mathbf{l}_1\) (i.e.* the first lm_logits line). Hereby, our sampling strategy is simple: greedily choose the next decoder input vector that has the highest probability. In an auto-regressive fashion, we then pass the sampled decoder input vector together with the previous inputs to the encoder-decoder model and sample again. We repeat this a third time. As a result, the model has generated the words \"Ich will ein\". The result is spot-on - this is the beginning of the correct translation of the input. In practice, more complicated decoding methods are used to sample the lm_logits. Most of which are covered in this blog post.

Transformer-based Encoder-Decoder Models

patrickvonplaten

October 10, 2020

encoder-decoder

research, nlp

https://huggingface.co/blog/encoder-decoder

Encoder As mentioned in the previous section, the transformer-based encoder maps the input sequence to a contextualized encoding sequence: $$ f{\theta_{\text{enc}}}: \mathbf{X}{1:n} \to \mathbf{\overline{X}}{1:n}. $$ Taking a closer look at the architecture, the transformer-based encoder is a stack of residual encoder blocks. Each encoder block consists of a bi-directional self-attention layer, followed by two feed-forward layers. For simplicity, we disregard the normalization layers in this notebook. Also, we will not further discuss the role of the two feed-forward layers, but simply see it as a final vector-to-vector mapping required in each encoder block \({}^1\). The bi-directional self-attention layer puts each input vector \(\mathbf{x'}j, \forall j \in {1, \ldots, n}\) into relation with all input vectors \(\mathbf{x'}_1, \ldots, \mathbf{x'}_n\) and by doing so transforms the input vector \(\mathbf{x'}_j\) to a more \"refined\" contextual representation of itself, defined as \(\mathbf{x''}_j\). Thereby, the first encoder block transforms each input vector of the input sequence \(\mathbf{X}{1:n}\) (shown in light green below) from a context-independent vector representation to a context-dependent vector representation, and the following encoder blocks further refine this contextual representation until the last encoder block outputs the final contextual encoding \(\mathbf{\overline{X}}{1:n}\) (shown in darker green below). Let\'s visualize how the encoder processes the input sequence \"I want to buy a car EOS\" to a contextualized encoding sequence. Similar to RNN-based encoders, transformer-based encoders also add a special \"end-of-sequence\" input vector to the input sequence to hint to the model that the input vector sequence is finished \({}^2\). Our exemplary transformer-based encoder is composed of three encoder blocks, whereas the second encoder block is shown in more detail in the red box on the right for the first three input vectors \(\mathbf{x}_1, \mathbf{x}_2 and \mathbf{x}_3\). The bi-directional self-attention mechanism is illustrated by the fully-connected graph in the lower part of the red box and the two feed-forward layers are shown in the upper part of the red box. As stated before, we will focus only on the bi-directional self-attention mechanism. As can be seen each output vector of the self-attention layer \(\mathbf{x''}_i, \forall i \in {1, \ldots, 7}\) depends directly on all input vectors \(\mathbf{x'}_1, \ldots, \mathbf{x'}_7\). This means, e.g. that the input vector representation of the word \"want\", i.e. \(\mathbf{x'}_2\), is put into direct relation with the word \"buy\", i.e. \(\mathbf{x'}_4\), but also with the word \"I\",i.e. \(\mathbf{x'}_1\). The output vector representation of \"want\", i.e. \(\mathbf{x''}_2\), thus represents a more refined contextual representation for the word \"want\". Let\'s take a deeper look at how bi-directional self-attention works. Each input vector \(\mathbf{x'}_i\) of an input sequence \(\mathbf{X'}{1:n}\) of an encoder block is projected to a key vector \(\mathbf{k}i\), value vector \(\mathbf{v}_i\) and query vector \(\mathbf{q}_i\) (shown in orange, blue, and purple respectively below) through three trainable weight matrices \(\mathbf{W}_q, \mathbf{W}_v, \mathbf{W}_k\): $$ \mathbf{q}_i = \mathbf{W}_q \mathbf{x'}_i,$$ $$ \mathbf{v}_i = \mathbf{W}_v \mathbf{x'}_i,$$ $$ \mathbf{k}_i = \mathbf{W}_k \mathbf{x'}_i, $$ $$ \forall i \in {1, \ldots n }.$$ Note, that the same weight matrices are applied to each input vector \(\mathbf{x}_i, \forall i \in {i, \ldots, n}\). After projecting each input vector \(\mathbf{x}_i\) to a query, key, and value vector, each query vector \(\mathbf{q}_j, \forall j \in {1, \ldots, n}\) is compared to all key vectors \(\mathbf{k}_1, \ldots, \mathbf{k}_n\). The more similar one of the key vectors \(\mathbf{k}_1, \ldots \mathbf{k}_n\) is to a query vector \(\mathbf{q}_j\), the more important is the corresponding value vector \(\mathbf{v}_j\) for the output vector \(\mathbf{x''}_j\). More specifically, an output vector \(\mathbf{x''}_j\) is defined as the weighted sum of all value vectors \(\mathbf{v}_1, \ldots, \mathbf{v}_n\) plus the input vector \(\mathbf{x'}_j\). Thereby, the weights are proportional to the cosine similarity between \(\mathbf{q}_j\) and the respective key vectors \(\mathbf{k}_1, \ldots, \mathbf{k}_n\), which is mathematically expressed by \(\textbf{Softmax}(\mathbf{K}{1:n}^\intercal \mathbf{q}j)\) as illustrated in the equation below. For a complete description of the self-attention layer, the reader is advised to take a look at this blog post or the original paper. Alright, this sounds quite complicated. Let\'s illustrate the bi-directional self-attention layer for one of the query vectors of our example above. For simplicity, it is assumed that our exemplary transformer-based decoder uses only a single attention head config.num_heads = 1 and that no normalization is applied. On the left, the previously illustrated second encoder block is shown again and on the right, an in detail visualization of the bi-directional self-attention mechanism is given for the second input vector \(\mathbf{x'}_2\) that corresponds to the input word \"want\". At first all input vectors \(\mathbf{x'}_1, \ldots, \mathbf{x'}_7\) are projected to their respective query vectors \(\mathbf{q}_1, \ldots, \mathbf{q}_7\) (only the first three query vectors are shown in purple above), value vectors \(\mathbf{v}_1, \ldots, \mathbf{v}_7\) (shown in blue), and key vectors \(\mathbf{k}_1, \ldots, \mathbf{k}_7\) (shown in orange). The query vector \(\mathbf{q}_2\) is then multiplied by the transpose of all key vectors, i.e. \(\mathbf{K}{1:7}^{\intercal}\) followed by the softmax operation to yield the self-attention weights. The self-attention weights are finally multiplied by the respective value vectors and the input vector \(\mathbf{x'}2\) is added to output the \"refined\" representation of the word \"want\", i.e. \(\mathbf{x''}_2\) (shown in dark green on the right). The whole equation is illustrated in the upper part of the box on the right. The multiplication of \(\mathbf{K}{1:7}^{\intercal}\) and \(\mathbf{q}2\) thereby makes it possible to compare the vector representation of \"want\" to all other input vector representations \"I\", \"to\", \"buy\", \"a\", \"car\", \"EOS\" so that the self-attention weights mirror the importance each of the other input vector representations \(\mathbf{x'}_j \text{, with } j \ne 2\) for the refined representation \(\mathbf{x''}_2\) of the word \"want\". To further understand the implications of the bi-directional self-attention layer, let\'s assume the following sentence is processed: \"The house is beautiful and well located in the middle of the city where it is easily accessible by public transport\". The word \"it\" refers to \"house\", which is 12 \"positions away\". In transformer-based encoders, the bi-directional self-attention layer performs a single mathematical operation to put the input vector of \"house\" into relation with the input vector of \"it\" (compare to the first illustration of this section). In contrast, in an RNN-based encoder, a word that is 12 \"positions away\", would require at least 12 mathematical operations meaning that in an RNN-based encoder a linear number of mathematical operations are required. This makes it much harder for an RNN-based encoder to model long-range contextual representations. Also, it becomes clear that a transformer-based encoder is much less prone to lose important information than an RNN-based encoder-decoder model because the sequence length of the encoding is kept the same, i.e. \(\textbf{len}(\mathbf{X}{1:n}) = \textbf{len}(\mathbf{\overline{X}}_{1:n}) = n\), while an RNN compresses the length from \(\textbf{len}((\mathbf{X}{1:n}) = n\) to just \(\textbf{len}(\mathbf{c}) = 1\), which makes it very difficult for RNNs to effectively encode long-range dependencies between input words. In addition to making long-range dependencies more easily learnable, we can see that the Transformer architecture is able to process text in parallel.Mathematically, this can easily be shown by writing the self-attention formula as a product of query, key, and value matrices: $$\mathbf{X''}{1:n} = \mathbf{V}{1:n} \text{Softmax}(\mathbf{Q}{1:n}^\intercal \mathbf{K}{1:n}) + \mathbf{X'}{1:n}. $$ The output \(\mathbf{X''}{1:n} = \mathbf{x''}_1, \ldots, \mathbf{x''}_n\) is computed via a series of matrix multiplications and a softmax operation, which can be parallelized effectively. Note, that in an RNN-based encoder model, the computation of the hidden state \(\mathbf{c}\) has to be done sequentially: Compute hidden state of the first input vector \(\mathbf{x}_1\), then compute the hidden state of the second input vector that depends on the hidden state of the first hidden vector, etc. The sequential nature of RNNs prevents effective parallelization and makes them much more inefficient compared to transformer-based encoder models on modern GPU hardware. Great, now we should have a better understanding of a) how transformer-based encoder models effectively model long-range contextual representations and b) how they efficiently process long sequences of input vectors. Now, let\'s code up a short example of the encoder part of our MarianMT encoder-decoder models to verify that the explained theory holds in practice. ------------------------------------------------------------------------ \({}^1\) An in-detail explanation of the role the feed-forward layers play in transformer-based models is out-of-scope for this notebook. It is argued in Yun et. al, (2017) that feed-forward layers are crucial to map each contextual vector \(\mathbf{x'}_i\) individually to the desired output space, which the _self-attention layer does not manage to do on its own. It should be noted here, that each output token \(\mathbf{x'}\) is processed by the same feed-forward layer. For more detail, the reader is advised to read the paper. \({}^2\) However, the EOS input vector does not have to be appended to the input sequence, but has been shown to improve performance in many cases. In contrast to the 0th \(\text{BOS}\) target vector of the transformer-based decoder is required as a starting input vector to predict a first target vector. python from transformers import MarianMTModel, MarianTokenizer import torch tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de") model = MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de") embeddings = model.get_input_embeddings() # create ids of encoded input vectors input_ids = tokenizer("I want to buy a car", return_tensors="pt").input_ids # pass input_ids to encoder encoder_hidden_states = model.base_model.encoder(input_ids, return_dict=True).last_hidden_state # change the input slightly and pass to encoder input_ids_perturbed = tokenizer("I want to buy a house", return_tensors="pt").input_ids encoder_hidden_states_perturbed = model.base_model.encoder(input_ids_perturbed, return_dict=True).last_hidden_state # compare shape and encoding of first vector print(f"Length of input embeddings {embeddings(input_ids).shape[1]}. Length of encoder_hidden_states {encoder_hidden_states.shape[1]}") # compare values of word embedding of "I" for input_ids and perturbed input_ids print("Is encoding for `I` equal to its perturbed version?: ", torch.allclose(encoder_hidden_states[0, 0], encoder_hidden_states_perturbed[0, 0], atol=1e-3)) Outputs: Length of input embeddings 7. Length of encoder_hidden_states 7 Is encoding for `I` equal to its perturbed version?: False We compare the length of the input word embeddings, i.e. embeddings(input_ids) corresponding to \(\mathbf{X}{1:n}\), with the length of the encoder_hidden_states, corresponding to \(\mathbf{\overline{X}}{1:n}\). Also, we have forwarded the word sequence \"I want to buy a car\" and a slightly perturbated version \"I want to buy a house\" through the encoder to check if the first output encoding, corresponding to \"I\", differs when only the last word is changed in the input sequence. As expected the output length of the input word embeddings and encoder output encodings, i.e. \(\textbf{len}(\mathbf{X}{1:n})\) and \(\textbf{len}(\mathbf{\overline{X}}{1:n})\), is equal. Second, it can be noted that the values of the encoded output vector of \(\mathbf{\overline{x}}1 = \text{"I"}\) are different when the last word is changed from \"car\" to \"house\". This however should not come as a surprise if one has understood bi-directional self-attention. On a side-note, _autoencoding models, such as BERT, have the exact same architecture as transformer-based encoder models. Autoencoding models leverage this architecture for massive self-supervised pre-training on open-domain text data so that they can map any word sequence to a deep bi-directional representation. In Devlin et al. (2018), the authors show that a pre-trained BERT model with a single task-specific classification layer on top can achieve SOTA results on eleven NLP tasks. All autoencoding models of 🤗Transformers can be found here.

Hyperparameter Search with Transformers and Ray Tune

ray-project

November 2, 2020

ray-tune

open-source-collab, nlp

https://huggingface.co/blog/ray-tune

A guest blog post by Richard Liaw from the Anyscale team With cutting edge research implementations, thousands of trained models easily accessible, the Hugging Face transformers library has become critical to the success and growth of natural language processing today. For any machine learning model to achieve good performance, users often need to implement some form of parameter tuning. Yet, nearly everyone (1, 2) either ends up disregarding hyperparameter tuning or opting to do a simplistic grid search with a small search space. However, simple experiments are able to show the benefit of using an advanced tuning technique. Below is a recent experiment run on a BERT model from Hugging Face transformers on the RTE dataset. Genetic optimization techniques like PBT can provide large performance improvements compared to standard hyperparameter optimization techniques. Algorithm Best Val Acc. Best Test Acc. Total GPU min Total $ cost Grid Search 74% 65.4% 45 min $2.30 Bayesian Optimization +Early Stop 77% 66.9% 104 min $5.30 Population-based Training 78% 70.5% 48 min $2.45 If you’re leveraging Transformers, you’ll want to have a way to easily access powerful hyperparameter tuning solutions without giving up the customizability of the Transformers framework. In the Transformers 3.1 release, Hugging Face Transformers and Ray Tune teamed up to provide a simple yet powerful integration. Ray Tune is a popular Python library for hyperparameter tuning that provides many state-of-the-art algorithms out of the box, along with integrations with the best-of-class tooling, such as Weights and Biases and tensorboard. To demonstrate this new Hugging Face + Ray Tune integration, we leverage the Hugging Face Datasets library to fine tune BERT on MRPC. To run this example, please first run: pip install "ray[tune]" transformers datasets scipy sklearn torch Simply plug in one of Ray’s standard tuning algorithms by just adding a few lines of code. python from datasets import load_dataset, load_metric from transformers import (AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments) tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased') dataset = load_dataset('glue', 'mrpc') metric = load_metric('glue', 'mrpc') def encode(examples): outputs = tokenizer( examples['sentence1'], examples['sentence2'], truncation=True) return outputs encoded_dataset = dataset.map(encode, batched=True) def model_init(): return AutoModelForSequenceClassification.from_pretrained( 'distilbert-base-uncased', return_dict=True) def compute_metrics(eval_pred): predictions, labels = eval_pred predictions = predictions.argmax(axis=-1) return metric.compute(predictions=predictions, references=labels) # Evaluate during training and a bit more often # than the default to be able to prune bad trials early. # Disabling tqdm is a matter of preference. training_args = TrainingArguments( "test", evaluation_strategy="steps", eval_steps=500, disable_tqdm=True) trainer = Trainer( args=training_args, tokenizer=tokenizer, train_dataset=encoded_dataset["train"], eval_dataset=encoded_dataset["validation"], model_init=model_init, compute_metrics=compute_metrics, ) # Default objective is the sum of all metrics # when metrics are provided, so we have to maximize it. trainer.hyperparameter_search( direction="maximize", backend="ray", n_trials=10 # number of trials ) By default, each trial will utilize 1 CPU, and optionally 1 GPU if available. You can leverage multiple GPUs for a parallel hyperparameter search by passing in a resources_per_trial argument. You can also easily swap different parameter tuning algorithms such as HyperBand, Bayesian Optimization, Population-Based Training: To run this example, first run: pip install hyperopt python from ray.tune.suggest.hyperopt import HyperOptSearch from ray.tune.schedulers import ASHAScheduler trainer = Trainer( args=training_args, tokenizer=tokenizer, train_dataset=encoded_dataset["train"], eval_dataset=encoded_dataset["validation"], model_init=model_init, compute_metrics=compute_metrics, ) best_trial = trainer.hyperparameter_search( direction="maximize", backend="ray", # Choose among many libraries: # https://docs.ray.io/en/latest/tune/api_docs/suggestion.html search_alg=HyperOptSearch(metric="objective", mode="max"), # Choose among schedulers: # https://docs.ray.io/en/latest/tune/api_docs/schedulers.html scheduler=ASHAScheduler(metric="objective", mode="max")) It also works with Weights and Biases out of the box!

Hyperparameter Search with Transformers and Ray Tune

ray-project

November 2, 2020

ray-tune

open-source-collab, nlp

https://huggingface.co/blog/ray-tune

Try it out today: * pip install -U ray * pip install -U transformers datasets * Check out the Hugging Face documentation and Discussion thread * End-to-end example of using Hugging Face hyperparameter search for text classification If you liked this blog post, be sure to check out: * Transformers + GLUE + Ray Tune example * Our Weights and Biases report on Hyperparameter Optimization for Transformers * The simplest way to serve your NLP model from scratch

Hyperparameter Search with Transformers and Ray Tune

ray-project

November 2, 2020

ray-tune

open-source-collab, nlp

https://huggingface.co/blog/ray-tune

# Hyperparameter Search with Transformers and Ray Tune

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Links to the github versions of files In order to ensure that all links work if you read this article much later after it has been written, the links were made to a specific SHA version of the code and not necessarily the latest version. This is so that if files were renamed or removed you will still find the code this article is referring to. If you want to ensure you're looking at the latest version of the code, replace the hash code in the links withmaster`. For example, a link: https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/src/transformers/modeling_fsmt.py becomes: https://github.com/huggingface/transformers/blob/master/src/transformers/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py Thank you for reading!

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

fairseq model and its support files Let's first look at what data we get with the fairseq pre-trained model. We are going to use the convenient torch.hub API, which makes it very easy to deploy models submitted to that hub: import torch torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-ru', checkpoint_file='model4.pt', tokenizer='moses', bpe='fastbpe') This code downloads the pre-trained model and its support files. I found this information at the page corresponding to fairseq on the pytorch hub. To see what's inside the downloaded files, we have to first hunt down the right folder under ~/.cache. ls -1 ~/.cache/torch/hub/pytorch_fairseq/ shows: 15bca559d0277eb5c17149cc7e808459c6e307e5dfbb296d0cf1cfe89bb665d7.ded47c1b3054e7b2d78c0b86297f36a170b7d2e7980d8c29003634eb58d973d9 15bca559d0277eb5c17149cc7e808459c6e307e5dfbb296d0cf1cfe89bb665d7.ded47c1b3054e7b2d78c0b86297f36a170b7d2e7980d8c29003634eb58d973d9.json You may have more than one entry there if you have been using the hub for other models. Let's make a symlink so that we can easily refer to that obscure cache folder name down the road: ln -s /code/data/cache/torch/hub/pytorch_fairseq/15bca559d0277eb5c17149cc7e808459c6e307e5dfbb296d0cf1cfe89bb665d7.ded47c1b3054e7b2d78c0b86297f36a170b7d2e7980d8c29003634eb58d973d9 \ ~/porting/pytorch_fairseq_model Note: the path could be different when you try it yourself, since the hash value of the model could change. You will find the right one in ~/.cache/torch/hub/pytorch_fairseq/ If we look inside that folder: ls -l ~/porting/pytorch_fairseq_model/ total 13646584 -rw-rw-r-- 1 stas stas 532048 Sep 8 21:29 bpecodes -rw-rw-r-- 1 stas stas 351706 Sep 8 21:29 dict.en.txt -rw-rw-r-- 1 stas stas 515506 Sep 8 21:29 dict.ru.txt -rw-rw-r-- 1 stas stas 3493170533 Sep 8 21:28 model1.pt -rw-rw-r-- 1 stas stas 3493170532 Sep 8 21:28 model2.pt -rw-rw-r-- 1 stas stas 3493170374 Sep 8 21:28 model3.pt -rw-rw-r-- 1 stas stas 3493170386 Sep 8 21:29 model4.pt we have: 1. model*.pt - 4 checkpoints (pytorch state_dict with all the pre-trained weights, and various other things) 2. dict.*.txt - source and target dictionaries 3. bpecodes - special map file used by the tokenizer We are going to investigate each of these files in the following sections.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Tokenizer decoder porting Once I had the portedgeneratefunction produce pretty similar results tofairseq'sgenerateI next needed to complete the last stage of decoding the outputs into the human readable text. This allowed me to use my eyes for a quick comparison and the quality of translation - something I couldn't do with output ids. Similar to the encoding process, this one was done in reverse. The steps were: 1. convert output ids into text strings 2. remove BPE encodings 3. detokenize - handle escaped characters, etc. After doing some more debugging here, I had to change the way BPE was dealt with from the original approach intokenization_xlm.pyand also run the outputs through themosesdetokenizer. ``` def convert_tokens_to_string(self, tokens): """ Converts a sequence of tokens (string) in a single string. """ - out_string = "".join(tokens).replace("</w>", " ").strip() - return out_string + # remove BPE + tokens = [t.replace(" ", "").replace("</w>", " ") for t in tokens] + tokens = "".join(tokens).split() + # detokenize + text = self.moses_detokenize(tokens, self.tgt_lang) + return text ``` And all was good.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

A guest blog post by Stas Bekman This article is an attempt to document how fairseq wmt19 translation system was ported to transformers. I was looking for some interesting project to work on and Sam Shleifer suggested I work on porting a high quality translator. I read the short paper: Facebook FAIR's WMT19 News Translation Task Submission that describes the original system and decided to give it a try. Initially, I had no idea how to approach this complex project and Sam helped me to break it down to smaller tasks, which was of a great help. I chose to work with the pre-trained en-ru/ru-en models during porting as I speak both languages. It'd have been much more difficult to work with de-en/en-de pairs as I don't speak German, and being able to evaluate the translation quality by just reading and making sense of the outputs at the advanced stages of the porting process saved me a lot of time. Also, as I did the initial porting with the en-ru/ru-en models, I was totally unaware that the de-en/en-de models used a merged vocabulary, whereas the former used 2 separate vocabularies of different sizes. So once I did the more complicated work of supporting 2 separate vocabularies, it was trivial to get the merged vocabulary to work.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting the core translation functionality Having had a relatively quick success with porting the tokenizer (obviously, thanks to most of the code being there already), the next stage was much more complex. This is thegenerate()function which takes inputs ids, runs them through the model and returns output ids. I had to break it down into multiple sub-tasks. I had to 1. port the model weights. 2. makegenerate()work for a single beam (i.e. return just one result). 3. and then multiple beams (i.e. return multiple results). I first researched which of the existing architectures were the closest to my needs. It was BART that fit the closest, so I went ahead and did: ``` cp modeling_bart.py modeling_fsmt.py perl -pi -e 's|Bart|FSMT|ig; s|bart|fsmt|g;' modeling_fsmt.py ``` This was my starting point that I needed to tweak to work with the model weights provided byfairseq.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting new models After uploading the 4 fairseq models here it was then suggested to port 3 wmt16 and 2 wmt19 AllenAI models (Jungo Kasai, et al). The porting was a breeze, as I only had to figure out how to put all the source files together, since they were spread out through several unrelated archives. Once this was done the conversion worked without a hitch. The only issue I discovered after porting is that I was getting a lower BLEU score than the original. Jungo Kasai, the creator of these models, was very helpful at suggesting that a custom hyper-parameterlength_penalty=0.6 was used, and once I plugged that in I was getting much better results. This discovery lead me to write a new script: [run_eval_search.py](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/examples/seq2seq/run_eval_search.py), which can be used to search various hyper-parameters that would lead to the best BLEU scores. Here is an example of its usage: ``` # search space export PAIR=ru-en export DATA_DIR=data/$PAIR export SAVE_DIR=data/$PAIR export BS=32 mkdir -p $DATA_DIR sacrebleu -t wmt19 -l $PAIR --echo src > $DATA_DIR/val.source sacrebleu -t wmt19 -l $PAIR --echo ref > $DATA_DIR/val.target PYTHONPATH="src:examples/seq2seq" python examples/seq2seq/run_eval_search.py stas/wmt19-$PAIR \ $DATA_DIR/val.source $SAVE_DIR/test_translations.txt --reference_path $DATA_DIR/val.target \ --score_path $SAVE_DIR/test_bleu.json --bs $BS --task translation \ --search="num_beams=5:8:11:15 length_penalty=0.6:0.7:0.8:0.9:1.0:1.1 early_stopping=true:false" ``` Here it searches though all the possible combinations ofnum_beams,length_penaltyandearly_stopping. Once finished executing it reports: ``` bleu | num_beams | length_penalty | early_stopping ----- | --------- | -------------- | -------------- 39.20 | 15 | 1.1 | 0 39.13 | 11 | 1.1 | 0 39.05 | 5 | 1.1 | 0 39.05 | 8 | 1.1 | 0 39.03 | 15 | 1.0 | 0 39.00 | 11 | 1.0 | 0 38.93 | 8 | 1.0 | 0 38.92 | 15 | 1.1 | 1 [...] ``` You can see that in the case oftransformersearly_stopping=Falseperforms better (fairsequses theearly_stopping=Trueequivalent). So for the 5 new models I used this script to find the best default parameters and I used those when converting the models. User can still override these parameters, when invokinggenerate(), but why not provide the best defaults. You will find the 5 ported AllenAI models [here](https://huggingface.co/models?filter=allenai&tag=fsmt).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting the architecture code Now that we have the model weights and the model configuration ported, we *just* need to adjust the code copied frommodeling_bart.pyto matchfairseq's functionality. The first step was to take a sentence, encode it and then feed to thegeneratefunction - forfairseqand fortransformers. After a few very failing attempts to get somewhere (*) - I quickly realized that with the current level of complexity usingprintas debugging method will get me nowhere, and neither will the basicpdbdebugger. In order to be efficient and to be able to watch multiple variables and have watches that are code-evaluations I needed a serious visual debugger. I spent a day trying all kinds of python debuggers and only when I triedpycharmI realized that it was the tool that I needed. It was my first time usingpycharm, but I quickly figured out how to use it, as it was quite intuitive. * footnote: the model was generating 'nononono' in Russian - that was fair and hilarious! Over time I found a great feature inpycharmthat allowed me to group breakpoints by functionality and I could turn whole groups on and off depending on what I was debugging. For example, here I have beam-search related break-points off and decoder ones on:  Now that I have used this debugger to port FSMT, I know that it would have taken me many times over to use pdb to do the same - I may have even given it up. I started with 2 scripts: * [fseq-translate](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fseq-translate.py) * [fsmt-translate](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fsmt-translate.py) (without thedecodepart first) running both side by side, stepping through with debugger on each side and comparing values of relevant variables - until I found the first divergence. I then studied the code, made adjustments insidemodeling_fsmt.py, restarted the debugger, quickly jumped to the point of divergence and re-checked the outputs. This cycle has been repeated multiple times until the outputs matched. The first things I had to change was to remove a few layers that weren't used byfairseqand then add some new layers it was using instead. And then the rest was primarily figuring out when to switch tosrc_vocab_sizeand when totgt_vocab_size- since in the core modules it's justvocab_size, which weren't accounting for a possible model that has 2 dictionaries. Finally, I discovered that a few hyperparameter configurations weren't the same, and so those were changed too. I first did this process for the simpler no-beam search, and once the outputs were 100% matching I repeated it with the more complicated beam search. Here, for example, I discovered thatfairseqwas using the equivalent ofearly_stopping=True, whereastransformershas it asFalseby default. When early stopping is enabled it stops looking for new candidates as soon as there are as many candidates as the beam size, whereas when it's disabled, the algorithm stops searching only when it can't find higher probability candidates than what it already has. Thefairseqpaper mentions that a huge beam size of 50 was used, which compensates for using early stopping.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

AutoConfig, AutoTokenizer, etc. One other change I needed to do is to plug the newly ported model into the automated modeltransformerssystem. This is used primarily on the [models website](https://huggingface.co/models) to load the model configuration, tokenizer and the main class without providing any specific class names. For example, in the case ofFSMTone can do: ``` from transformers import AutoTokenizer, AutoModelWithLMHead mname = "facebook/wmt19-en-ru" tokenizer = AutoTokenizer.from_pretrained(mname) model = AutoModelWithLMHead.from_pretrained(mname) ``` There are 3autofiles that have mappings to enable that: ``` -rw-rw-r-- 1 stas stas 16K Sep 23 13:53 src/transformers/configuration_auto.py -rw-rw-r-- 1 stas stas 65K Sep 23 13:53 src/transformers/modeling_auto.py -rw-rw-r-- 1 stas stas 13K Sep 23 13:53 src/transformers/tokenization_auto.py ``` Then the are the pipelines, which completely hide all the NLP complexities from the end user and provide a very simple API to just pick a model and use it for a task at hand. For example, here is how one could perform a summarization task usingpipeline: ``` summarizer = pipeline("summarization", model="t5-base", tokenizer="t5-base") summary = summarizer("Some long document here", min_length=5, max_length=20) print(summary) ``` The translation pipelines are a work in progress as of this writing, watch [this document](https://huggingface.co/transformers/main_classes/pipelines.html) for updates for when translation will be supported (currently only a few specific models/languages are supported). Finally, there issrc/transforers/init.pyto edit so that one could do: ``` from transformers import FSMTTokenizer, FSMTForConditionalGeneration ``` instead of: ``` from transformers.tokenization_fsmt import FSMTTokenizer from transformers.modeling_fsmt import FSMTForConditionalGeneration ``` but either way works. To find all the places I needed to plug FSMT in, I mimickedBartConfig,BartForConditionalGenerationandBartTokenizer. I justgrepped which files had it and inserted corresponding entries forFSMTConfig,FSMTForConditionalGenerationandFSMTTokenizer. ``` $ egrep -l "(BartConfig|BartForConditionalGeneration|BartTokenizer)" src/transformers/*.py \ | egrep -v "(marian|bart|pegasus|rag|fsmt)" src/transformers/configuration_auto.py src/transformers/generation_utils.py src/transformers/__init__.py src/transformers/modeling_auto.py src/transformers/pipelines.py src/transformers/tokenization_auto.py ``` In thegrepsearch I excluded the files that also include those classes.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Let's cheat The first step was to cheat, of course. Why make a big effort when one can make a little one. So I wrote a short notebook that in a few lines of code provided a proxy to fairseq and emulated transformers API. If no other things, but basic translation, was required, this would have been enough. But, of course, we wanted to have the full porting, so after having this small victory, I moved onto much harder things.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

SinusoidalPositionalEmbeddingfairseqused a slightly different implementation ofSinusoidalPositionalEmbeddingthan the one used bytransformers. Initially I copied thefairseqimplementation. But when trying to get the test suite to work I couldn't get thetorchscripttests to pass.SinusoidalPositionalEmbeddingwas written so that it won't be part ofstate_dictand not get saved with the model weights - all the weights generated by this class are deterministic and are not trained.fairseqused a trick to make this work transparently by not making its weights a parameter or a buffer, and then duringforwardswitching the weights to the correct device.torchscriptwasn't taking this well, as it wanted all the weights to be on the correct device before the firstforwardcall. I had to rewrite the implementation to convert it to a normalnn.Embeddingsubclass and then add functionality to not save these weights duringsave_pretrained()and forfrom_pretrained()to not complain if it can't find those weights during thestate_dictloading.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Manual testing Until now I was primarily using my own scripts to do the testing. Once I had the translator working, I converted the reversedru-enmodel and then wrote two paraphrase scripts: * [fseq-paraphrase](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fseq-paraphrase.py) * [fsmt-paraphrase](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fsmt-paraphrase.py) which took a sentence in the source language, translated it to another language and then translated the result of that back to the original language. This process usually results in a paraphrased outcome, due to differences in how different languages express similar things. With the help of these scripts I found some more problems with the detokenizer, stepped through with the debugger and made the fsmt script produce the same results as thefairseqversion. At this stage no-beam search was producing mostly identical results, but there was still some divergence in the beam search. In order to identify the special cases, I wrote a [fsmt-port-validate.py](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fsmt-port-validate.py) script that used as inputssacrebleutest data and it run that data through bothfairseqandtransformerstranslation and reported only mismatches. It quickly identified a few remaining problems and observing the patterns I was able to fix those issues as well.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

# Porting fairseq wmt19 translation system to transformers

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Notes

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Tokenizer porting The first step was to port the encoder part of the tokenizer, where text is converted to ids. The decoder part won't be needed until the very end.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting other models I next proceeded to port theen-deandde-enmodels. I was surprised to discover that these weren't built in the same way. Each of these had a merged dictionary, so for a moment I felt frustration, since I thought I'd now have to do another huge change to support that. But, I didn't need to make any changes, as the merged dictionary fit in without needing any changes. I just used 2 identical dictionaries - one as a source and a copy of it as a target. I wrote another script to test all ported models' basic functionality: [fsmt-test-all.py](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fsmt-test-all.py).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Model description This is a ported version of [...] ``` As you can see we define the languages, tags, license, datasets, and metrics. There is a full guide for writing these at [Model sharing and uploading](https://huggingface.co/transformers/model_sharing.html#add-a-model-card). The rest is the markdown document describing the model and its nuances. You can also try out the models directly from the model pages thanks to the Inference widgets. For example for English-to-russian translation: https://huggingface.co/facebook/wmt19-en-ru?text=My+name+is+Diego+and+I+live+in+Moscow. 

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Preparations For the sake of this article let's assume that we work under ~/porting, and therefore let's create this directory: mkdir ~/porting cd ~/porting We need to install a few things for this work: # install fairseq git clone https://github.com/pytorch/fairseq cd fairseq pip install -e . # install mosesdecoder under fairseq git clone https://github.com/moses-smt/mosesdecoder # install fastBPE under fairseq git clone [email protected]:glample/fastBPE.git cd fastBPE; g++ -std=c++11 -pthread -O3 fastBPE/main.cc -IfastBPE -o fast; cd - cd - # install transformers git clone https://github.com/huggingface/transformers/ pip install -e .[dev]

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Model cards One other important thing is that it's not enough to port a model and make it available to others. One needs to provide information on how to use it, nuances about hyper-parameters, sources of datasets, evaluation metrics, etc. This is all done by creating model cards, which is just aREADME.mdfile, that starts with some metadata that is used by [the models website](https://huggingface.co/models), followed by all the useful information that can be shared. For example, let's take [thefacebook/wmt19-en-rumodel card](https://github.com/huggingface/transformers/tree/129fdae04033fe4adfe013b734deaec6ec34ae2e/model_cards/facebook/wmt19-en-ru/README.md). Here is its top: ``` --- language: - en - ru thumbnail: tags: - translation - wmt19 - facebook license: apache-2.0 datasets: - wmt19 metrics: - bleu --- # FSMT

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Conversion One of the most important parts of the porting process is to create a script that will take all the available source data provided by the original developer of the model, which includes a checkpoint with pre-trained weights, model and training configuration, dictionaries and tokenizer support files, and convert them into a new set of model files supported by transformers. You will find the final conversion script here: src/transformers/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py I started this process by copying one of the existing conversion scripts src/transformers/convert_bart_original_pytorch_checkpoint_to_pytorch.py, gutted most of it out and then gradually added parts to it as I was progressing in the porting process. During the development I was testing all my code against a local copy of the converted model files, and only at the very end when everything was ready I uploaded the files to 🤗 s3 and then continued testing against the online version.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

How translation systems work Here is a very brief introduction to how computers translate text nowadays. Computers can't read text, but can only handle numbers. So when working with text we have to map one or more letters into numbers, and hand those to a computer program. When the program completes it too returns numbers, which we need to convert back into text. Let's start with two sentences in Russian and English and assign a unique number to each word: я люблю следовательно я существую 10 11 12 10 13 I love therefore I am 20 21 22 20 23 The numbers starting with 10 map Russian words to unique numbers. The numbers starting with 20 do the same for English words. If you don't speak Russian, you can still see that the word я (means 'I') repeats twice in the sentence and it gets the same number 10 associated with it. Same goes for I (20), which also repeats twice. A translation system works in the following stages: 1. [я люблю следовательно я существую] # tokenize sentence into words 2. [10 11 12 10 13] # look up words in the input dictionary and convert to ids 3. [black box] # machine learning system magic 4. [20 21 22 20 23] # look up numbers in the output dictionary and convert to text 5. [I love therefore I am] # detokenize the tokens back into a sentence If we combine the first two and the last two steps we get 3 stages: 1. Encode input: break input text into tokens, create a dictionary (vocab) of these tokens and remap each token into a unique id in that dictionary. 2. Generate translation: take input numbers, run them through a pre-trained machine learning model which predicts the best translation, and return output numbers. 3. Decode output: take output numbers, look them up in the target language dictionary, convert them back to text, and finally merge the converted tokens into the translated sentence. The second stage may return one or several possible translations. In the case of the latter the caller then can choose the most suitable outcome. In this article I will refer to the beam search algorithm, which is one of the ways multiple possible results are searched for. And the size of the beam refers to how many results are returned. If there is only one result that's requested, the model will choose the one with the highest likelihood probability. If multiple results are requested it will return those results sorted by their probabilities. Note that this same idea applies to the majority of NLP tasks, and not just translation.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Tokenization Early systems tokenized sentences into words and punctuation marks. But since many languages have hundreds of thousands of words, it is very taxing to work with huge vocabularies, as it dramatically increases the compute resource requirements and the length of time to complete the task. As of 2020 there are quite a few different tokenizing methods, but most of the recent ones are based on sub-word tokenization - that is instead of breaking input text down into words, these modern tokenizers break the input text down into word segments and letters, using some kind of training to obtain the most optimal tokenization. Let's see how this approach helps to reduce memory and computation requirements. If we have an input vocabulary of 6 common words: go, going, speak, speaking, sleep, sleeping - with word-level tokenization we end up with 6 tokens. However, if we break these down into: go, go-ing, speak, speak-ing, etc., then we have only 4 tokens in our vocabulary: go, speak, sleep, ing. This simple change made a 33% improvement! Except, the sub-word tokenizers don't use grammar rules, but they are trained on massive text inputs to find such splits. In this example I used a simple grammar rule as it's easy to understand. Another important advantage of this approach is when dealing with input text words, that aren't in our vocabulary. For example, let's say our system encounters the word grokking (), which can't be found in its vocabulary. If we split it into grokk'-'ing', then the machine learning model might not know what to do with the first part of the word, but it gets a useful insight that 'ing' indicates a continuous tense, so it'll be able to produce a better translation. In such situation the tokenizer will split the unknown segments into segments it knows, in the worst case reducing them to individual letters. * footnote: to grok was coined in 1961 by Robert A. Heinlein in "Stranger in a Strange Land": to understand (something) intuitively or by empathy. There are many other nuances to why the modern tokenization approach is much more superior than simple word tokenization, which won't be covered in the scope of this article. Most of these systems are very complex to how they do the tokenization, as compared to the simple example of splittingingendings that was just demonstrated, but the principle is similar.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

More scripts As each ported group of models has its own nuances, I made dedicated scripts to each one of them, so that it will be easy to re-build things in the future or to create new scripts to convert new models. You will find all the conversion, evaluation, and other scripts [here](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/scripts/fsmt/).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Autoprint all in Jupyter Notebook My jupyter notebook is configured to automatically print all expressions, so I don't have to explicitlyprint()them. The default behavior is to print only the last expression of each cell. So if you read the outputs in my notebooks they may not the be same as if you were to run them yourself, unless you have the same setup. You can enable the print-all feature in your jupyter notebook setup by adding the following to~/.ipython/profile_default/ipython_config.py(create it if you don't have one): ``` c = get_config() # Run all nodes interactively c.InteractiveShell.ast_node_interactivity = "all" # restore to the original behavior # c.InteractiveShell.ast_node_interactivity = "last_expr" ``` and restarting your jupyter notebook server.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

It's PR time Once I felt my work was quite complete, I was ready to submit my PR. Since this work involved many git commits, I wanted to make a clean PR, so I used the following technique to squash all the commits into one in a new branch. This kept all the initial commits in place if I wanted to access any of them later. The branch I was developing on was calledfair-wmt, and the new branch that I was going to submit the PR from I namedfair-wmt-clean, so here is what I did: ``` git checkout master git checkout -b fair-wmt-clean git merge --squash fair-wmt git commit -m "Ready for PR" git push origin fair-wmt-clean ``` Then I went to github and submitted this [PR](https://github.com/huggingface/transformers/pull/6940) based on thefair-wmt-cleanbranch. It took two weeks of several cycles of feedback, followed by modifications, and more such cycles. Eventually it was all satisfactory and the PR got merged. While this process was going on, I was finding issues here and there, adding new tests, improving the documentation, etc., so it was time well spent. I subsequently filed a few more PRs with changes after I improved and reworked a few features, adding various build scripts, models cards, etc. Since the models I ported were belonging tofacebookandallenaiorganizations, I had to ask Sam to move those model files from my account ons3to the corresponding organizations.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Evaluation I knew that the ported model was doing quite well based on my manual testing with a large body of text, but I didn't know how well the ported model performed comparatively to the original. So it was time to evaluate. For the task of translation [BLEU score](https://en.wikipedia.org/wiki/BLEU) is used as an evaluation metric.transformershas a script [run_eval.py](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/examples/seq2seq/run_eval.py) to perform the evaluation. Here is an evaluation for the ru-en pair export PAIR=ru-en export MODEL=facebook/wmt19-$PAIR export DATA_DIR=data/$PAIR export SAVE_DIR=data/$PAIR export BS=64 export NUM_BEAMS=5 export LENGTH_PENALTY=1.1 mkdir -p $DATA_DIR sacrebleu -t wmt19 -l $PAIR --echo src > $DATA_DIR/val.source sacrebleu -t wmt19 -l $PAIR --echo ref > $DATA_DIR/val.target PYTHONPATH="src:examples/seq2seq" python examples/seq2seq/run_eval.py $MODEL \ $DATA_DIR/val.source $SAVE_DIR/test_translations.txt --reference_path $DATA_DIR/val.target \ --score_path $SAVE_DIR/test_bleu.json --bs $BS --task translation --num_beams $NUM_BEAMS \ --length_penalty $LENGTH_PENALTY --info $MODEL --dump-args which took a few minutes to run and returned: {'bleu': 39.0498, 'n_obs': 2000, 'runtime': 184, 'seconds_per_sample': 0.092, 'num_beams': 5, 'length_penalty': 1.1, 'info': 'ru-en'} You can see that the BLEU score was 39.0498 and that it evaluated using 2000 test inputs, provided by sacrebleu using the wmt19 dataset. Remember, I couldn't use the model ensemble, so I next needed to find the best performing checkpoint. For that purpose I wrote a script fsmt-bleu-eval-each-chkpt.py which converted each checkpoint, run the eval script and reported the best one. As a result I knew that model4.pt was delivering the best performance, out of the 4 available checkpoints. I wasn't getting the same BLEU scores as the ones reported in the original paper, so I next needed to make sure that we were comparing the same data using the same tools. Through asking at the fairseq issue I was given the code that was used by fairseq developers to get their BLEU scores - you will find it here. But, alas, their method was using a re-ranking approach which wasn't disclosed. Moreover, they evaled on outputs before detokenization and not the real output, which apparently scores better. Bottom line - we weren't scoring in the same way (). * footnote: the paper A Call for Clarity in Reporting BLEU Scores invites developers to start using the same method for calculating the metrics (tldr: use sacrebleu). Currently, this ported model is slightly behind the original on the BLEU scores, because model ensemble is not used, but it's impossible to tell the exact difference until the same measuring method is used.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Files As a quick overview, the following files needed to be created and written: * src/transformers/configuration_fsmt.py - a short configuration class. * src/transformers/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py - a complex conversion script. * src/transformers/modeling_fsmt.py - this is where the model architecture is implemented. * src/transformers/tokenization_fsmt.py - a tokenizer code. * tests/test_modeling_fsmt.py - model tests. * tests/test_tokenization_fsmt.py - tokenizer tests. * docs/source/model_doc/fsmt.rst - a doc file. There are other files that needed to be modified as well, we will talk about those towards the end.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

fairseq's tokenizer workings Let's understand howfairseq's tokenizer works.fairseq(*) uses the [Byte Pair Encoding](https://en.wikipedia.org/wiki/Byte_pair_encoding) (BPE) algorithm for tokenization. * footnote: from here on when I refer tofairseq, I refer [to this specific model implementation](https://github.com/pytorch/fairseq/tree/master/examples/wmt19) - thefairseqproject itself has dozens of different implementations of different models. Let's see what BPE does: ``` import torch sentence = "Machine Learning is great" checkpoint_file='model4.pt' model = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-ru', checkpoint_file=checkpoint_file, tokenizer='moses', bpe='fastbpe') # encode step by step tokens = model.tokenize(sentence) print("tokenize ", tokens) bpe = model.apply_bpe(tokens) print("apply_bpe: ", bpe) bin = model.binarize(bpe) print("binarize: ", len(bin), bin) # compare to model.encode - should give us the same output expected = model.encode(sentence) print("encode: ", len(expected), expected) ``` gives us: ``` ('tokenize ', 'Machine Learning is great') ('apply_bpe: ', 'Mach@@ ine Lear@@ ning is great') ('binarize: ', 7, tensor([10217, 1419, 3, 2515, 21, 1054, 2])) ('encode: ', 7, tensor([10217, 1419, 3, 2515, 21, 1054, 2])) ``` You can see thatmodel.encodedoestokenize+apply_bpe+binarize- as we get the same output. The steps were: 1.tokenize: normally it'd escape apostrophes and do other pre-processing, in this example it just returned the input sentence without any changes 2.apply_bpe: BPE splits the input into words and sub-words according to itsbpecodesfile supplied by the tokenizer - we get 6 BPE chunks 3.binarize: this simply remaps the BPE chunks from the previous step into their corresponding ids in the vocabulary (which is also downloaded with the model) You can refer to [this notebook](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/nbs/tokenizer.ipynb) to see more details. This is a good time to look inside thebpecodesfile. Here is the top of the file: ``` $ head -15 ~/porting/pytorch_fairseq_model/bpecodes e n</w> 1423551864 e r 1300703664 e r</w> 1142368899 i n 1130674201 c h 933581741 a n 845658658 t h 811639783 e n 780050874 u n 661783167 s t 592856434 e i 579569900 a r 494774817 a l 444331573 o r 439176406 th e</w> 432025210 [...] ``` The top entries of this file include very frequent short 1-letter sequences. As we will see in a moment the bottom includes the most common multi-letter sub-words and even full long words. A special tokenindicates the end of the word. So in several lines quoted above we find: ``` e n</w> 1423551864 e r</w> 1142368899 th e</w> 432025210 ``` If the second column doesn't include, it means that this segment is found in the middle of the word and not at the end of it. The last column declares the number of times this BPE code has been encountered while being trained. Thebpecodesfile is sorted by this column - so the most common BPE codes are on top. By looking at the counts we now know that when this tokenizer was trained it encountered 1,423,551,864 words ending inen, 1,142,368,899 words ending inerand 432,025,210 words ending inthe. For the latter it most likely means the actual wordthe, but it would also include words likelathe,loathe,tithe, etc. These huge numbers also indicate to us that this tokenizer was trained on an enormous amount of text! If we look at the bottom of the same file: ``` $ tail -10 ~/porting/pytorch_fairseq_model/bpecodes 4 x 109019 F ische</w> 109018 sal aries</w> 109012 e kt 108978 ver gewal 108978 Sten cils</w> 108977 Freiwilli ge</w> 108969 doub les</w> 108965 po ckets</w> 108953 Gö tz</w> 108943 ``` we see complex combinations of sub-words which are still pretty frequent, e.g.sal ariesfor 109,012 times! So it got its own dedicated entry in thebpecodesmap file. Howapply_bpedoes its work? By looking up the various combinations of letters in thebpecodesmap file and when finding the longest fitting entry it uses that. Going back to our example, we saw that it splitMachineinto:Mach@@+ine- let's check: ``` $ grep -i ^mach ~/porting/pytorch_fairseq_model/bpecodes mach ine</w> 463985 Mach t 376252 Mach ines</w> 374223 mach ines</w> 214050 Mach th 119438 ``` You can see that it hasmach ine. We don't seeMach inein there - so it must be handling lower cased look ups when normal case is not matching. Now let's check:Lear@@+ning``` $ grep -i ^lear ~/porting/pytorch_fairseq_model/bpecodes lear n</w> 675290 lear ned</w> 505087 lear ning</w> 417623 ``` We findlear ningis there (again the case is not the same). Thinking more about it, the case probably doesn't matter for tokenization, as long as there is a unique entry forMach/Learandmach/learin the dictionary where it's very critical to have each case covered. Hopefully, you can now see how this works. One confusing thing is that if you remember theapply_bpeoutput was: ``` ('apply_bpe: ', 6, ['Mach@@', 'ine', 'Lear@@', 'ning', 'is', 'great']) ``` Instead of marking endings of the words with, it leaves those as is, but, instead, marks words that were not the endings with@@. This is probably so, becausefastBPEimplementation is used byfairseqand that's how it does things. I had to change this to fit thetransformersimplementation, which doesn't usefastBPE. One last thing to check is the remapping of the BPE codes to vocabulary ids. To repeat, we had: ``` ('apply_bpe: ', 'Mach@@ ine Lear@@ ning is great') ('binarize: ', 7, tensor([10217, 1419, 3, 2515, 21, 1054, 2])) ```2- the last token id is aeos(end of stream) token. It's used to indicate to the model the end of input. And thenMach@@gets remapped to10217, andineto1419. Let's check that the dictionary file is in agreement: ``` $ grep ^Mach@@ ~/porting/pytorch_fairseq_model/dict.en.txt Mach@@ 6410 $ grep "^ine " ~/porting/pytorch_fairseq_model/dict.en.txt ine 88376 ``` Wait a second - those aren't the ids that we got afterbinarize, which should be10217and1419correspondingly. It took some investigating to find out that the vocab file ids aren't the ids used by the model and that internally it remaps them to new ids once the vocab file is loaded. Luckily, I didn't need to figure out how exactly it was done. Instead, I just usedfairseq.data.dictionary.Dictionary.loadto load the dictionary (*), which performed all the re-mappings, - and I then saved the final dictionary. I found out about thatDictionaryclass by stepping throughfairseqcode with debugger. * footnote: the more I work on porting models and datasets, the more I realize that putting the original code to work for me, rather than trying to replicate it, is a huge time saver and most importantly that code has already been tested - it's too easy to miss something and down the road discover big problems! After all, at the end, none of this conversion code will matter, since only the data it generated will be used bytransformersand its end users. Here is the relevant part of the conversion script: ``` from fairseq.data.dictionary import Dictionary def rewrite_dict_keys(d): # (1) remove word breaking symbol # (2) add word ending symbol where the word is not broken up, # e.g.: d = {'le@@': 5, 'tt@@': 6, 'er': 7} => {'le': 5, 'tt': 6, 'er</w>': 7} d2 = dict((re.sub(r"@@$", "", k), v) if k.endswith("@@") else (re.sub(r"$", "</w>", k), v) for k, v in d.items()) keep_keys = "<s> <pad> </s> <unk>".split() # restore the special tokens for k in keep_keys: del d2[f"{k}</w>"] d2[k] = d[k] # restore return d2 src_dict_file = os.path.join(fsmt_folder_path, f"dict.{src_lang}.txt") src_dict = Dictionary.load(src_dict_file) src_vocab = rewrite_dict_keys(src_dict.indices) src_vocab_size = len(src_vocab) src_vocab_file = os.path.join(pytorch_dump_folder_path, "vocab-src.json") print(f"Generating {src_vocab_file}") with open(src_vocab_file, "w", encoding="utf-8") as f: f.write(json.dumps(src_vocab, ensure_ascii=False, indent=json_indent)) # we did the same for the target dict - omitted quoting it here # and we also had to savebpecodes, it's calledmerges.txtin the transformers land ``` After running the conversion script, let's check the converted dictionary: ``` $ grep '"Mach"' /code/huggingface/transformers-fair-wmt/data/wmt19-en-ru/vocab-src.json "Mach": 10217, $ grep '"ine</w>":' /code/huggingface/transformers-fair-wmt/data/wmt19-en-ru/vocab-src.json "ine</w>": 1419, ``` We have the correct ids in thetransformersversion of the vocab file. As you can see I also had to re-write the vocabularies to match thetransformersBPE implementation. We have to change: ``` ['Mach@@', 'ine', 'Lear@@', 'ning', 'is', 'great'] ``` to: ``` ['Mach', 'ine</w>', 'Lear', 'ning</w>', 'is</w>', 'great</w>'] ``` Instead of marking chunks that are segments of a word, with the exception of the last segment, we mark segments or words that are the final segment. One can easily go from one style of encoding to another and back. This successfully completed the porting of the first part of the model files. You can see the final version of the code [here](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/src/transformers/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py#L128). If you're curious to look deeper there are more tinkering bits in [this notebook](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/nbs/tokenizer-dev.ipynb).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting tokenizer's encoder to transformerstransformerscan't rely on [fastBPE](https://github.com/glample/fastBPE) since the latter requires a C-compiler, but luckily someone already implemented a python version of the same in [tokenization_xlm.py](https://github.com/huggingface/transformers/blob/master/src/transformers/tokenization_xlm.py). So I just copied it tosrc/transformers/tokenization_fsmt.pyand renamed the class names: ``` cp tokenization_xlm.py tokenization_fsmt.py perl -pi -e 's|XLM|FSMT|ig; s|xlm|fsmt|g;' tokenization_fsmt.py ``` and with very few changes I had a working encoder part of the tokenizer. There was a lot of code that didn't apply to the languages I needed to support, so I removed that code. Since I needed 2 different vocabularies, instead of one here in tokenizer and everywhere else I had to change the code to support both. So for example I had to override the super-class' methods: ``` def get_vocab(self) -> Dict[str, int]: return self.get_src_vocab() @property def vocab_size(self) -> int: return self.src_vocab_size ``` Sincefairseqdidn't usebos(beginning of stream) tokens, I also had to change the code to not include those (*): ``` - return bos + token_ids_0 + sep - return bos + token_ids_0 + sep + token_ids_1 + sep + return token_ids_0 + sep + return token_ids_0 + sep + token_ids_1 + sep ``` * footnote: this is the output ofdiff(1)which shows the difference between two chunks of code - lines starting with-show what was removed, and with+what was added.fairseqwas also escaping characters and performing an aggressive dash splitting, so I had to also change: ``` - [...].tokenize(text, return_str=False, escape=False) + [...].tokenize(text, return_str=False, escape=True, aggressive_dash_splits=True) ``` If you're following along, and would like to see all the changes I did to the originaltokenization_xlm.py, you can do: ``` cp tokenization_xlm.py tokenization_orig.py perl -pi -e 's|XLM|FSMT|g; s|xlm|fsmt|g;' tokenization_orig.py diff -u tokenization_orig.py tokenization_fsmt.py | less ``` Just make sure you're checking out the repository [around the time fsmt was released](https://github.com/huggingface/transformers/tree/129fdae04033fe4adfe013b734deaec6ec34ae2e), since the 2 files could have diverged since then. The final stage was to run through a bunch of inputs and to ensure that the ported tokenizer produced the same ids as the original. You can see this is done in [this notebook](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/nbs/tokenizer.ipynb), which I was running repeatedly while trying to figure out how to make the outputs match. This is how most of the porting process went, I'd take a small feature, run it thefairseq-way, get the outputs, do the same with thetransformerscode, try to make the outputs match - fiddle with the code until it did, then try a different kind of input make sure it produced the same outputs, and so on, until all inputs produced outputs that matched.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Test Coverage This next step was very important - I needed to prepare an extensive testing for the ported model. In thetransformerstest suite most tests that deal with large models are marked as@slowand those don't get to run normally on CI (Continual Integration), as they are, well, slow. So I needed to also create a tiny model, that has the same structure as a normal pre-trained model, but it had to be very small and it could have random weights. This tiny model is then can be used to test the ported functionality. It just can't be used for quality testing, since it has just a few weights and thus can't really be trained to do anything practical. [fsmt-make-tiny-model.py](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/scripts/fsmt-make-tiny-model.py) creates such a tiny model. The generated model with all of its dictionary and config files was just 3MB in size. I uploaded it tos3usingtransformers-cli uploadand now I was able to use it in the test suite. Just like with the code, I started by copyingtests/test_modeling_bart.pyand converting it to useFSMT, and then tweaking it to work with the new model. I then converted a few of my scripts I used for manual testing into unit tests - that was easy.transformershas a huge set of common tests that each model runs through - I had to do some more tweaks to make these tests work forFSMT(primarily to adjust for the 2 dictionary setup) and I had to override a few tests, that weren't possible to run due to the uniqueness of this model, in order to skip them. You can see the results [here](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/tests/test_tokenization_fsmt.py). I added one more test that performs a light BLEU evaluation - I used just 8 text inputs for each of the 4 models and measured BLEU scores on those. Here is the [test](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/examples/seq2seq/test_fsmt_bleu_score.py) and the [script that generated data](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/examples/seq2seq/test_data/fsmt/build-eval-data.py).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Documentation Finally, the documentation needed to be added. Luckily, most of the documentation is autogenerated from the docstrings in the module files. As before, I copieddocs/source/model_doc/bart.rstand adapted it toFSMT. When it was ready I linked to it by addingfsmtentry insidedocs/source/index.rstI used: ``` make docs ``` to test that the newly added document was building correctly. The file I needed to check after running that target wasdocs/_build/html/model_doc/fsmt.html- I just loaded in my browser and verified that it rendered correctly. Here is the final source document [docs/source/model_doc/fsmt.rst](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/docs/source/model_doc/fsmt.rst) and its [rendered version](https://huggingface.co/transformers/model_doc/fsmt.html).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Closing thoughts - While I couldn't port the model ensemble astransformersdoesn't support it, on the plus side the download size of the finalfacebook/wmt19-*models is 1.1GB and not 13GB as in the original. For some reason the original includes the optimizer state saved in the model - so it adds almost 9GB (4x2.2GB) of dead weight for those who just want to download the model to use it as is to translate text. - While the job of porting looked very challenging at the beginning as I didn't know the internals of neithertransformersnorfairseq, looking back it wasn't that difficult after all. This was primarily due to having most of the components already available to me in the various parts oftransformers- I *just* needed to find parts that I needed, mostly borrowing heavily from other models, and then tweak them to do what I needed. This was true for both the code and the tests. Let's rephrase that - porting was difficult - but it'd have been much more difficult if I had to write it all from scratch. And finding the right parts wasn't easy.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Porting weights and configuration The first thing I did is to look at what was inside the publicly shared checkpoint. [This notebook](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/nbs/config.ipynb) shows what I did there. I discovered that there were 4 checkpoints in there. I had no idea what to do about it, so I started with a simpler job of using just the first checkpoint. Later I discovered thatfairseqused all 4 checkpoints in an ensemble to get the best predictions, and thattransformerscurrently doesn't support that feature. When the porting was completed and I was able to measure the performance scores, I found out that themodel4.ptcheckpoint provided the best score. But during the porting performance didn't matter much. Since I was using only one checkpoint it was crucial that when I was comparing outputs, I hadfairseqalso use just one and the same checkpoint. To accomplish that I used a slightly differentfairseqAPI: ``` from fairseq import hub_utils #checkpoint_file = 'model1.pt:model2.pt:model3.pt:model4.pt' checkpoint_file = 'model1.pt' model_name_or_path = 'transformer.wmt19.ru-en' data_name_or_path = '.' cls = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel models = cls.hub_models() kwargs = {'bpe': 'fastbpe', 'tokenizer': 'moses'} ru2en = hub_utils.from_pretrained( model_name_or_path, checkpoint_file, data_name_or_path, archive_map=models, **kwargs ) ``` First I looked at the model: ``` print(ru2en["models"][0]) ``` ``` TransformerModel( (encoder): TransformerEncoder( (dropout_module): FairseqDropout() (embed_tokens): Embedding(31232, 1024, padding_idx=1) (embed_positions): SinusoidalPositionalEmbedding() (layers): ModuleList( (0): TransformerEncoderLayer( (self_attn): MultiheadAttention( (dropout_module): FairseqDropout() (k_proj): Linear(in_features=1024, out_features=1024, bias=True) (v_proj): Linear(in_features=1024, out_features=1024, bias=True) (q_proj): Linear(in_features=1024, out_features=1024, bias=True) (out_proj): Linear(in_features=1024, out_features=1024, bias=True) ) [...] # the full output is in the notebook ``` which looked very similar to BART's architecture, with some slight differences in a few layers - some were added, others removed. So this was great news as I didn't have to re-invent the wheel, but to only tweak a well-working design. Note that in the code sample above I'm not usingtorch.load()to loadstate_dict. This is what I initially did and the result was most puzzling - I was missingself_attn.(k|q|v)_projweights and instead had a singleself_attn.in_proj. When I tried loading the model usingfairseqAPI, it fixed things up - apparently that model was old and was using an old architecture that had one set of weights fork/q/vand the newer architecture has them separate. Whenfairseqloads this old model, it rewrites the weights to match the modern architecture. I also used [this notebook](https://github.com/stas00/porting/tree/master/transformers/fairseq-wmt19/nbs/visualize-models.ipynb) to compare thestate_dicts visually. In that notebook you will also see thatfairseqfetches a 2.2GB-worth of data inlast_optimizer_state, which we can safely ignore, and have a 3 times leaner final model size. In the conversion script I also had to remove somestate_dictkeys, which I wasn't going to use, e.g.model.encoder.version,model.modeland a few others. Next we look at the configuration args: ``` args = dict(vars(ru2en["args"])) pprint(args) ``` ``` 'activation_dropout': 0.0, 'activation_fn': 'relu', 'adam_betas': '(0.9, 0.98)', 'adam_eps': 1e-08, 'adaptive_input': False, 'adaptive_softmax_cutoff': None, 'adaptive_softmax_dropout': 0, 'arch': 'transformer_wmt_en_de_big', 'attention_dropout': 0.1, 'bpe': 'fastbpe', [... full output is in the notebook ...] ``` ok, we will copy those to configure the model. I had to rename some of the argument names, wherevertransformersused different names for the corresponding configuration setting. So the re-mapping of configuration looks as following: ``` model_conf = { "architectures": ["FSMTForConditionalGeneration"], "model_type": "fsmt", "activation_dropout": args["activation_dropout"], "activation_function": "relu", "attention_dropout": args["attention_dropout"], "d_model": args["decoder_embed_dim"], "dropout": args["dropout"], "init_std": 0.02, "max_position_embeddings": args["max_source_positions"], "num_hidden_layers": args["encoder_layers"], "src_vocab_size": src_vocab_size, "tgt_vocab_size": tgt_vocab_size, "langs": [src_lang, tgt_lang], [...] "bos_token_id": 0, "pad_token_id": 1, "eos_token_id": 2, "is_encoder_decoder": True, "scale_embedding": not args["no_scale_embedding"], "tie_word_embeddings": args["share_all_embeddings"], } ``` All that remains is to save the configuration intoconfig.jsonand create a newstate_dictdump intopytorch.dump: ``` print(f"Generating {fsmt_tokenizer_config_file}") with open(fsmt_tokenizer_config_file, "w", encoding="utf-8") as f: f.write(json.dumps(tokenizer_conf, ensure_ascii=False, indent=json_indent)) [...] print(f"Generating {pytorch_weights_dump_path}") torch.save(model_state_dict, pytorch_weights_dump_path) ``` We have the configuration and the model'sstate_dictported - yay! You will find the final conversion code [here](https://github.com/huggingface/transformers/blob/129fdae04033fe4adfe013b734deaec6ec34ae2e/src/transformers/convert_fsmt_original_pytorch_checkpoint_to_pytorch.py#L162).

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Uploading models to s3 Once the conversion script did a complete job of porting all the required files totransformers, I uploaded the models to my 🤗 s3 account: ``` cd data transformers-cli upload -y wmt19-ru-en transformers-cli upload -y wmt19-en-ru transformers-cli upload -y wmt19-de-en transformers-cli upload -y wmt19-en-de cd - ``` For the duration of testing I was using my 🤗 s3 account and once my PR with the complete changes was ready to be merged I asked in the PR to move the models to thefacebookorganization account, since these models belong there. Several times I had to update just the config files, and I didn't want to re-upload the large models, so I wrote this little script that produces the right upload commands, which otherwise were too long to type and as a result were error-prone: ``` perl -le 'for $f (@ARGV) { print qq[transformers-cli upload -y $_/$f --filename $_/$f] \ for map { "wmt19-$_" } ("en-ru", "ru-en", "de-en", "en-de")}' \ vocab-src.json vocab-tgt.json tokenizer_config.json config.json # add/remove files as needed ``` So if, for example, I only needed to update all theconfig.jsonfiles, the script above gave me a convenient copy-n-paste: ``` transformers-cli upload -y wmt19-en-ru/config.json --filename wmt19-en-ru/config.json transformers-cli upload -y wmt19-ru-en/config.json --filename wmt19-ru-en/config.json transformers-cli upload -y wmt19-de-en/config.json --filename wmt19-de-en/config.json transformers-cli upload -y wmt19-en-de/config.json --filename wmt19-en-de/config.json ``` Once the upload was completed, these models could be accessed as (*): ``` tokenizer = FSMTTokenizer.from_pretrained("stas/wmt19-en-ru") ``` * footnote:stasis my username at https://huggingface.co. Before I made this upload I had to use the local path to the folder with the model files, e.g.: ``` tokenizer = FSMTTokenizer.from_pretrained("/code/huggingface/transformers-fair-wmt/data/wmt19-en-ru") ``` Important: If you update the model files, and re-upload them, you must be aware that due to CDN caching the uploaded model may be unavailable for up to 24 hours after the upload - i.e. the old cached model will be delivered. So the only way to start using the new model sooner is by either: 1. downloading it to a local path and using that path as an argument that gets passed tofrom_pretrained(). 2. or using:from_pretrained(..., use_cdn=False)everywhere for the next 24h - it's not enough to do it once.

Porting fairseq wmt19 translation system to transformers

stas

November 3, 2020

porting-fsmt

open-source-collab, nlp

https://huggingface.co/blog/porting-fsmt

Appreciations - Having [Sam Shleifer](https://github.com/sshleifer) mentor me through this process was of an extreme help to me, both thanks to his technical support and just as importantly for inspiring and encouraging me when I was getting stuck. - The PR merging process took a good couple of weeks before it was accepted. During this stage, besides Sam, [Lysandre Debut](https://github.com/LysandreJik) and [Sylvain Gugger](https://github.com/sgugger) contributed a lot through their insights and suggestions, which I integrating into the codebase. - I'm grateful to everybody who has contributed to thetransformerscodebase, which paved the way for my work.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

BERT BERT is an encoder-only model, which maps an input sequence \(\mathbf{X}{1:n}\) to a contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\): $$ f{\theta_{\text{BERT}}}: \mathbf{X}{1:n} \to \mathbf{\overline{X}}{1:n}. $$ BERT\'s contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\) can then further be processed by a classification layer for NLU classification tasks, such as sentiment analysis, natural language inference, etc. To do so, the classification layer, i.e. typically a pooling layer followed by a feed-forward layer, is added as a final layer on top of BERT to map the contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\) to a class \(c\): $$ f_{\theta{\text{p,c}}}: \mathbf{\overline{X}}{1:n} \to c. $$ It has been shown that adding a pooling- and classification layer, defined as \(\theta{\text{p,c}}\), on top of a pre-trained BERT model \(\theta_{\text{BERT}}\) and subsequently fine-tuning the complete model \({\theta_{\text{p,c}}, \theta_{\text{BERT}}}\) can yield state-of-the-art performances on a variety of NLU tasks, cf. to BERT by Devlin et al.. Let\'s visualize BERT. The BERT model is shown in grey. The model stacks multiple BERT blocks, each of which is composed of bi-directional self-attention layers (shown in the lower part of the red box) and two feed-forward layers (short in the upper part of the red box). Each BERT block makes use of bi-directional self-attention to process an input sequence \(\mathbf{x'}1, \ldots, \mathbf{x'}_n\) (shown in light grey) to a more \"refined\" contextualized output sequence \(\mathbf{x''}_1, \ldots, \mathbf{x''}_n\) (shown in slightly darker grey) \({}^4\). The contextualized output sequence of the final BERT block, i.e. \(\mathbf{\overline{X}}{1:n}\), can then be mapped to a single output class \(c\) by adding a task-specific classification layer (shown in orange) as explained above. Encoder-only models can only map an input sequence to an output sequence of a priori known output length. In conclusion, the output dimension does not depend on the input sequence, which makes it disadvantageous and impractical to use encoder-only models for sequence-to-sequence tasks. As for all encoder-only models, BERT\'s architecture corresponds exactly to the architecture of the encoder part of transformer-based encoder-decoder models as shown in the \"Encoder\" section in the Encoder-Decoder notebook.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Warm-starting encoder-decoder models (Theory) Having read the introduction, we are now familiar with encoder-only- and decoder-only models. We have noticed that the encoder-decoder model architecture is essentially a composition of a stand-alone encoder model and a stand-alone decoder model, which led us to the question of how one can warm-start encoder-decoder models from stand-alone model checkpoints. There are multiple possibilities to warm-start an encoder-decoder model. One can 1. initialize both the encoder and decoder part from an encoder-only model checkpoint, e.g. BERT, 2. initialize the encoder part from an encoder-only model checkpoint, e.g. BERT, and the decoder part from and a decoder-only checkpoint, e.g. GPT2, 3. initialize only the encoder part with an encoder-only model checkpoint, or 4. initialize only the decoder part with a decoder-only model checkpoint. In the following, we will put the focus on possibilities 1. and 2. Possibilities 3. and 4. are trivial after having understood the first two.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Introduction Recently, pre-trained language models \({}^1\) have revolutionized the field of natural language processing (NLP). The first pre-trained language models were based on recurrent neural networks (RNN) as proposed Dai et al. (2015). Dai et. al showed that pre-training an RNN-based model on unlabelled data and subsequently fine-tuning \({}^2\) it on a specific task yields better results than training a randomly initialized model directly on such a task. However, it was only in 2018, when pre-trained language models become widely accepted in NLP. ELMO by Peters et al. and ULMFit by Howard et al. were the first pre-trained language model to significantly improve the state-of-the-art on an array of natural language understanding (NLU) tasks. Just a couple of months later, OpenAI and Google published transformer-based pre-trained language models, called GPT by Radford et al. and BERT by Devlin et al. respectively. The improved efficiency of transformer-based language models over RNNs allowed GPT2 and BERT to be pre-trained on massive amounts of unlabeled text data. Once pre-trained, BERT and GPT were shown to require very little fine-tuning to shatter state-of-art results on more than a dozen NLU tasks \({}^3\). The capability of pre-trained language models to effectively transfer task-agnostic knowledge to task-specific knowledge turned out to be a great catalyst for NLU. Whereas engineers and researchers previously had to train a language model from scratch, now publicly available checkpoints of large pre-trained language models can be fine-tuned at a fraction of the cost and time. This can save millions in industry and allows for faster prototyping and better benchmarks in research. Pre-trained language models have established a new level of performance on NLU tasks and more and more research has been built upon leveraging such pre-trained language models for improved NLU systems. However, standalone BERT and GPT models have been less successful for sequence-to-sequence tasks, e.g. text-summarization, machine translation, sentence-rephrasing, etc. Sequence-to-sequence tasks are defined as a mapping from an input sequence \(\mathbf{X}{1:n}\) to an output sequence \(\mathbf{Y}{1:m}\) of a-priori unknown output length \(m\). Hence, a sequence-to-sequence model should define the conditional probability distribution of the output sequence \(\mathbf{Y}{1:m}\) conditioned on the input sequence \(\mathbf{X}{1:n}\): $$ p_{\theta_{\text{model}}}(\mathbf{Y}{1:m} | \mathbf{X}{1:n}). $$ Without loss of generality, an input word sequence of \(n\) words is hereby represented by the vector sequnece \(\mathbf{X}{1:n} = \mathbf{x}_1, \ldots, \mathbf{x}_n\) and an output sequence of \(m\) words as \(\mathbf{Y}{1:m} = \mathbf{y}1, \ldots, \mathbf{y}_m\). Let\'s see how BERT and GPT2 would be fit to model sequence-to-sequence tasks.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Experiments The above models were trained and evaluated on four sequence-to-sequence tasks of increasing complexity: sentence-level fusion, sentence-level splitting, translation, and abstractive summarization. The following table shows which datasets were used for each task. |Seq2Seq Task |Datasets |Paper |🤗datasets | |-------------------------- |-----------------------------------------------------------------------|----------------------------------------------------------------------- |----------------------------------------------------------------------------------------- | |Sentence Fusion |DiscoFuse |Geva et al. (2019) |link | |Sentence Splitting |WikiSplit |Botha et al. (2018) |-| |Translation |WMT14 EN => DE |Bojar et al. (2014) |link| |WMT14 DE => EN |Bojar et al. (2014) | |link | |Abstractive Summarizaion |CNN/Dailymail | Hermann et al. (2015) |link| |BBC XSum |Narayan et al. (2018a) | |link | |Gigaword |Napoles et al. (2012) | |link | Depending on the task, a slightly different training regime was used. E.g. according to the size of the dataset and the specific task, the number of training steps ranges from 200K to 500K, the batch size is set to either 128 or 256, the input length ranges from 128 to 512 and the output length varies between 32 to 128. It shall be emphasized however that within each task, all models were trained and evaluated using the same hyperparameters to ensure a fair comparison. For more information on the task-specific hyperparameter settings, the reader is advised to see the Experiments section in the paper. We will now give a condensed overview of the results for each task.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Evaluation In a final step, we might want to evaluate the BERT2BERT model on the test data. To start, instead of loading the dummy model, let\'s load a BERT2BERT model that was finetuned on the full training dataset. Also, we load its tokenizer, which is just a copy of bert-base-cased\'s tokenizer. python from transformers import BertTokenizer bert2bert = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail").to("cuda") tokenizer = BertTokenizer.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail") Next, we load just 2% of CNN/Dailymail\'s test data. For the full evaluation, one should obviously use 100% of the data. python test_data = datasets.load_dataset("cnn_dailymail", "3.0.0", split="test[:2%]") Now, we can again leverage 🤗dataset\'s handy map() function to generate a summary for each test sample. For each data sample we: - first, tokenize the "article", - second, generate the output token ids, and - third, decode the output token ids to obtain our predicted summary. python def generate_summary(batch): # cut off at BERT max length 512 inputs = tokenizer(batch["article"], padding="max_length", truncation=True, max_length=512, return_tensors="pt") input_ids = inputs.input_ids.to("cuda") attention_mask = inputs.attention_mask.to("cuda") outputs = bert2bert.generate(input_ids, attention_mask=attention_mask) output_str = tokenizer.batch_decode(outputs, skip_special_tokens=True) batch["pred_summary"] = output_str return batch Let\'s run the map function to obtain the results dictionary that has the model\'s predicted summary stored for each sample. Executing the following cell may take ca. 10min ☕. python batch_size = 16 # change to 64 for full evaluation results = test_data.map(generate_summary, batched=True, batch_size=batch_size, remove_columns=["article"]) Finally, we compute the ROUGE score. python rouge.compute(predictions=results["pred_summary"], references=results["highlights"], rouge_types=["rouge2"])["rouge2"].mid python OUTPUT: ------- Score(precision=0.10389454113300968, recall=0.1564771201053348, fmeasure=0.12175271663717585) That\'s it. We\'ve shown how to warm-start a BERT2BERT model and fine-tune/evaluate it on the CNN/Dailymail dataset. The fully trained BERT2BERT model is uploaded to the 🤗model hub under patrickvonplaten/bert2bert_cnn_daily_mail. The model achieves a ROUGE-2 score of 18.22 on the full evaluation data, which is even a little better than reported in the paper. For some summarization examples, the reader is advised to use the online inference API of the model, here. Thanks a lot to Sascha Rothe, Shashi Narayan, and Aliaksei Severyn from Google Research, and Victor Sanh, Sylvain Gugger, and Thomas Wolf from 🤗Hugging Face for proof-reading and giving very much appreciated feedback.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

# Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models Transformer-based encoder-decoder models were proposed in Vaswani et al. (2017) and have recently experienced a surge of interest, e.g. Lewis et al. (2019), Raffel et al. (2019), Zhang et al. (2020), Zaheer et al. (2020), Yan et al. (2020). Similar to BERT and GPT2, massive pre-trained encoder-decoder models have shown to significantly boost performance on a variety of sequence-to-sequence tasks Lewis et al. (2019), Raffel et al. (2019). However, due to the enormous computational cost attached to pre-training encoder-decoder models, the development of such models is mainly limited to large companies and institutes. In Leveraging Pre-trained Checkpoints for Sequence Generation Tasks (2020), Sascha Rothe, Shashi Narayan and Aliaksei Severyn initialize encoder-decoder model with pre-trained encoder and/or decoder-only checkpoints (e.g. BERT, GPT2) to skip the costly pre-training. The authors show that such warm-started encoder-decoder models yield competitive results to large pre-trained encoder-decoder models, such as T5, and Pegasus on multiple sequence-to-sequence tasks at a fraction of the training cost. In this notebook, we will explain in detail how encoder-decoder models can be warm-started, give practical tips based on Rothe et al. (2020), and finally go over a complete code example showing how to warm-start encoder-decoder models with 🤗Transformers. This notebook is divided into 4 parts: - Introduction - Short summary of pre-trained language models in NLP and the need for warm-starting encoder-decoder models. - Warm-starting encoder-decoder models (Theory) - Illustrative explanation on how encoder-decoder models are warm-started? - Warm-starting encoder-decoder models (Analysis) - Summary of Leveraging Pre-trained Checkpoints for Sequence Generation Tasks (2020) - What model combinations are effective to warm-start encoder-decoder models; How does it differ from task to task? - Warm-starting encoder-decoder models with 🤗Transformers (Practice) - Complete code example showcasing in-detail how to use the EncoderDecoderModel framework to warm-start transformer-based encoder-decoder models. It is highly recommended (probably even necessary) to have read this blog post about transformer-based encoder-decoder models. Let\'s start by giving some back-ground on warm-starting encoder-decoder models.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Machine Translation (WMT14) Next, the authors evaluated warm-started encoder-decoder models on the probably most common benchmark in machine translation (MT) - the En \(\to\) De and De \(\to\) En WMT14 dataset. In this notebook, we present the results on the newstest2014 eval dataset. Because the benchmark requires the model to understand both an English and a German vocabulary the BERT-initialized encoder-decoder models were warm-started from the multilingual pre-trained checkpoint bert-base-multilingual-cased. Because there is no publicly available multilingual RoBERTa checkpoint, RoBERTa-initialized encoder-decoder models were excluded for MT. GPT2-initialized models were initialized from the gpt2 pre-trained checkpoint as in the previous experiment. The translation results are reported using the BLUE-4 score metric \({}^1\). |Model |En \(\to\) De (BLEU-4) |De \(\to\) En (BLEU-4) |--------------------------- |---------------------- |---------------------- |Rnd2Rnd | 26.0 | 29.1 |Rnd2BERT | 27.2 | 30.4 |BERT2Rnd | 30.1 | 32.7 |Rnd2GPT2 | 19.6 | 23.2 |BERT2BERT | 30.1 | 32.7 |BERTShare | 29.6 | 32.6 |BERT2GPT2 | 23.2 | 31.4 |--- | --- | --- |BERT2Rnd (large, custom) | 31.7 | 34.2 |BERTShare (large, custom) | 30.5 | 33.8 Again, we observe a significant performance boost by warm-starting the encoder-part, with BERT2Rnd and BERT2BERT yielding the best results on both the En \(\to\) De and De \(\to\) En tasks. GPT2 initialized models perform significantly worse even than the Rnd2Rnd baseline on En \(\to\) De. Taking into consideration that the gpt2 checkpoint was trained only on English text, it is not very surprising that BERT2GPT2 and Rnd2GPT2 models have difficulties generating German translations. This hypothesis is supported by the competitive results (e.g. 31.4 vs. 32.7) of BERT2GPT2 on the De \(\to\) En task for which GPT2\'s vocabulary fits the English output format. Contrary to the results obtained on sentence fusion and sentence splitting, sharing encoder and decoder weight parameters does not yield a performance boost in MT. Possible reasons for this as stated by the authors include - the encoder-decoder model capacity is an important factor in MT, and - the encoder and decoder have to deal with different grammar and vocabulary Since the bert-base-multilingual-cased checkpoint was trained on more than 100 languages, its vocabulary is probably undesirably large for En \(\to\) De and De \(\to\) En MT. Thus, the authors pre-trained a large BERT encoder-only checkpoint on the English and German subset of the Wikipedia dump and subsequently used it to warm-start a BERT2Rnd and BERTShare encoder-decoder model. Thanks to the improved vocabulary, another significant performance boost is observed, with BERT2Rnd (large, custom) significantly outperforming all other models.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

GPT2 GPT2 is a decoder-only model, which makes use of uni-directional (i.e. \"causal\") self-attention to define a mapping from an input sequence \(\mathbf{Y}{0: m - 1}\) \({}^1\) to a \"next-word\" logit vector sequence \(\mathbf{L}{1:m}\): $$ f_{\theta_{\text{GPT2}}}: \mathbf{Y}{0: m - 1} \to \mathbf{L}{1:m}. $$ By processing the logit vectors \(\mathbf{L}{1:m}\) with the softmax operation, the model can define the probability distribution of the word sequence \(\mathbf{Y}{1:m}\). To be exact, the probability distribution of the word sequence \(\mathbf{Y}{1:m}\) can be factorized into \(m-1\) conditional \"next word\" distributions: $$ p{\theta_{\text{GPT2}}}(\mathbf{Y}{1:m}) = \prod{i=1}^{m} p_{\theta_{\text{GPT2}}}(\mathbf{y}i | \mathbf{Y}{0:i-1}). $$ \(p_{\theta_{\text{GPT2}}}(\mathbf{y}i | \mathbf{Y}{0:i-1})\) hereby presents the probability distribution of the next word \(\mathbf{y}i\) given all previous words \(\mathbf{y}_0, \ldots, \mathbf{y}{i-1}\) \({}^3\) and is defined as the softmax operation applied on the logit vector \(\mathbf{l}i\). To summarize, the following equations hold true. $$ p{\theta_{\text{gpt2}}}(\mathbf{y}i | \mathbf{Y}{0:i-1}) = \textbf{Softmax}(\mathbf{l}i) = \textbf{Softmax}(f{\theta_{\text{GPT2}}}(\mathbf{Y}{0: i - 1})).$$ For more detail, please refer to the decoder section of the encoder-decoder blog post. Let\'s visualize GPT2 now as well. Analogous to BERT, GPT2 is composed of a stack of GPT2 blocks. In contrast to BERT block, GPT2 block makes use of uni-directional self-attention to process some input vectors \(\mathbf{y'}_0, \ldots, \mathbf{y'}{m-1}\) (shown in light blue on the bottom right) to an output vector sequence \(\mathbf{y''}0, \ldots, \mathbf{y''}{m-1}\) (shown in darker blue on the top right). In addition to the GPT2 block stack, the model also has a linear layer, called LM Head, which maps the output vectors of the final GPT2 block to the logit vectors \(\mathbf{l}1, \ldots, \mathbf{l}_m\). As mentioned earlier, a logit vector \(\mathbf{l}_i\) can then be used to sample of new input vector \(\mathbf{y}_i\) \({}^5\). GPT2 is mainly used for open-domain text generation. First, an input prompt \(\mathbf{Y}{0:i-1}\) is fed to the model to yield the conditional distribution \(p_{\theta_{\text{gpt2}}}(\mathbf{y} | \mathbf{Y}{0:i-1})\). Then the next word \(\mathbf{y}_i\) is sampled from the distribution (represented by the grey arrows in the graph above) and consequently append to the input. In an auto-regressive fashion the word \(\mathbf{y}{i+1}\) can then be sampled from \(p_{\theta_{\text{gpt2}}}(\mathbf{y} | \mathbf{Y}{0:i})\) and so on. GPT2 is therefore well-suited for language generation, but less so for conditional generation. By setting the input prompt \(\mathbf{Y}{0: i-1}\) equal to the sequence input \(\mathbf{X}{1:n}\), GPT2 can very well be used for conditional generation. However, the model architecture has a fundamental drawback compared to the encoder-decoder architecture as explained in Raffel et al. (2019) on page 17. In short, uni-directional self-attention forces the model\'s representation of the sequence input \(\mathbf{X}{1:n}\) to be unnecessarily limited since \(\mathbf{x}i\) cannot depend on \(\mathbf{x}{i+1}, \forall i \in {1,\ldots, n}\).

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Encoder-Decoder Because encoder-only models require to know the output length a priori, they seem unfit for sequence-to-sequence tasks. Decoder-only models can function well for sequence-to-sequence tasks, but also have certain architectural limitations as explained above. The current predominant approach to tackle sequence-to-sequence tasks are transformer-based encoder-decoder models - often also called seq2seq transformer models. Encoder-decoder models were introduced in Vaswani et al. (2017) and since then have been shown to perform better on sequence-to-sequence tasks than stand-alone language models (i.e. decoder-only models), e.g. Raffel et al. (2020). In essence, an encoder-decoder model is the combination of a stand-alone encoder, such as BERT, and a stand-alone decoder model, such as GPT2. For more details on the exact architecture of transformer-based encoder-decoder models, please refer to this blog post. Now, we know that freely available checkpoints of large pre-trained stand-alone encoder and decoder models, such as BERT and GPT, can boost performance and reduce training cost for many NLU tasks, We also know that encoder-decoder models are essentially the combination of stand-alone encoder and decoder models. This naturally brings up the question of how one can leverage stand-alone model checkpoints for encoder-decoder models and which model combinations are most performant on certain sequence-to-sequence tasks. In 2020, Sascha Rothe, Shashi Narayan, and Aliaksei Severyn investigated exactly this question in their paper Leveraging Pre-trained Checkpoints for Sequence Generation Tasks. The paper offers a great analysis of different encoder-decoder model combinations and fine-tuning techniques, which we will study in more detail later. Composing an encoder-decoder model of pre-trained stand-alone model checkpoints is defined as warm-starting the encoder-decoder model. The following sections show how warm-starting an encoder-decoder model works in theory, how one can put the theory into practice with 🤗Transformers, and also gives practical tips for better performance. ------------------------------------------------------------------------ \({}^1\) A pre-trained language model is defined as a neural network: - that has been trained on unlabeled text data, i.e. in a task-agnostic, unsupervised fashion, and - that processes a sequence of input words into a context-dependent embedding. E.g. the continuous bag-of-words and skip-gram model from Mikolov et al. (2013) is not considered a pre-trained language model because the embeddings are context-agnostic. \({}^2\) Fine-tuning is defined as the task-specific training of a model that has been initialized with the weights of a pre-trained language model. \({}^3\) The input vector \(\mathbf{y}0\) corresponds hereby to the \(\text{BOS}\) embedding vector required to predict the very first output word \(\mathbf{y}_1\). \({}^4\) Without loss of generalitiy, we exclude the normalization layers to not clutter the equations and illustrations. \({}^5\) For more detail on why uni-directional self-attention is used for \"decoder-only\" models, such as GPT2, and how sampling works exactly, please refer to the decoder section of the encoder-decoder blog post.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Recap Encoder-Decoder Model First, let\'s do a quick recap of the encoder-decoder architecture. The encoder (shown in green) is a stack of encoder blocks. Each encoder block is composed of a bi-directional self-attention layer, and two feed-forward layers \({}^1\). The decoder (shown in orange) is a stack of decoder blocks, followed by a dense layer, called LM Head. Each decoder block is composed of a uni-directional self-attention layer, a cross-attention layer, and two feed-forward layers. The encoder maps the input sequence \(\mathbf{X}{1:n}\) to a contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\) in the exact same way BERT does. The decoder then maps the contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\) and a target sequence \(\mathbf{Y}{0:m-1}\) to the logit vectors \(\mathbf{L}{1:m}\). Analogous to GPT2, the logits are then used to define the distribution of the target sequence \(\mathbf{Y}{1:m}\) conditioned on the input sequence \(\mathbf{X}{1:n}\) by means of a softmax operation. To put it into mathematical terms, first, the conditional distribution is factorized into \(m - 1\) conditional distributions of the next word \(\mathbf{y}i\) by Bayes\' rule. $$ p{\theta_{\text{enc, dec}}}(\mathbf{Y}{1:m} | \mathbf{X}{1:n}) = p_{\theta_{\text{dec}}}(\mathbf{Y}{1:m} | \mathbf{\overline{X}}{1:n}) = \prod_{i=1}^m p_{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i -1}, \mathbf{\overline{X}}{1:n}), \text{ with } \mathbf{\overline{X}}{1:n} = f_{\theta_{\text{enc}}}(\mathbf{X}{1:n}). $$ Each \"next-word\" conditional distributions is thereby defined by the softmax of the logit vector as follows. $$ p{\theta_{\text{dec}}}(\mathbf{y}i | \mathbf{Y}{0: i -1}, \mathbf{\overline{X}}{1:n}) = \textbf{Softmax}(\mathbf{l}_i). $$ For more detail, please refer to the Encoder-Decoder notebook.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Sentence Fusion and -Splitting (DiscoFuse, WikiSplit) Sentence Fusion is the task of combining multiple sentences into a single coherent sentence. E.g. the two sentences: As a run-blocker, Zeitler moves relatively well. Zeitler too often struggles at the point of contact in space. should be connected with a fitting linking word, such as: As a run-blocker, Zeitler moves relatively well. However, he too often struggles at the point of contact in space. As can be seen the linking word \"however\" provides a coherent transition from the first sentence to the second one. A model that is capable of generating such a linking word has arguably learned to infer that the two sentences above contrast to each other. The inverse task is called Sentence splitting and consists of splitting a single complex sentence into multiple simpler ones that together retain the same meaning. Sentence splitting is considered as an important task in text simplification, cf. to Botha et al. (2018). As an example, the sentence: Street Rod is the first in a series of two games released for the PC and Commodore 64 in 1989 can be simplified into Street Rod is the first in a series of two games . It was released for the PC and Commodore 64 in 1989 It can be seen that the long sentence tries to convey two important pieces of information. One is that the game was the first of two games being released for the PC, and the second being the year in which it was released. Sentence splitting, therefore, requires the model to understand which part of the sentence should be divided into two sentences, making the task more difficult than sentence fusion. A common metric to evaluate the performance of models on sentence fusion resp. -splitting tasks is SARI (Wu et al. (2016), which is broadly based on the F1-score of label and model output. Let\'s see how the models perform on sentence fusion and -splitting. |Model | 100% DiscoFuse (SARI) |10% DiscoFuse (SARI) |100% WikiSplit (SARI) |---------------------- |----------------------- |---------------------- |----------------------- |Rnd2Rnd | 86.9 | 81.5 | 61.7 |Rnd2BERT | 87.6 | 82.1 | 61.8 |BERT2Rnd | 89.3 | 86.1 | 63.1 |Rnd2GPT2 | 86.5 | 81.4 | 61.3 |BERT2BERT | 89.3 | 86.1 | 63.2 |BERTShare | 89.2 | 86.0 | 63.5 |RoBERTaShare | 89.7 | 86.0 | 63.4 |BERT2GPT2 | 88.4 | 84.1 | 62.4 |RoBERTa2GPT2 | 89.9 | 87.1 | 63.2 |--- | --- | --- | --- |RoBERTaShare (large) | 90.3 | 87.7 | 63.8 The first two columns show the performance of the encoder-decoder models on the DiscoFuse evaluation data. The first column states the results of encoder-decoder models trained on all (100%) of the training data, while the second column shows the results of the models trained only on 10% of the training data. We observe that warm-started models perform significantly better than the randomly initialized baseline models Rnd2Rnd, Rnd2Bert, and Rnd2GPT2. A warm-started RoBERTa2GPT2 model trained only on 10% of the training data is on par with an Rnd2Rnd model trained on 100% of the training data. Interestingly, the Bert2Rnd baseline performs equally well as a fully warm-started Bert2Bert model, which indicates that warm-starting the encoder-part is more effective than warm-starting the decoder-part. The best results are obtained by RoBERTa2GPT2, followed by RobertaShare. Sharing encoder and decoder weight parameters does seem to slightly increase the model\'s performance. On the more difficult sentence splitting task, a similar pattern emerges. Warm-started encoder-decoder models significantly outperform encoder-decoder models whose encoder is randomly initialized and encoder-decoder models with shared weight parameters yield better results than those with uncoupled weight parameters. On sentence splitting the BertShare models yields the best performance closely followed by RobertaShare. In addition to the 12-layer model variants, the authors also trained and evaluated a 24-layer RobertaShare (large) model which outperforms all 12-layer models significantly.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Warm-starting encoder-decoder models (Analysis) In this section, we will summarize the findings on warm-starting encoder-decoder models as presented in Leveraging Pre-trained Checkpoints for Sequence Generation Tasks by Sascha Rothe, Shashi Narayan, and Aliaksei Severyn. The authors compared the performance of warm-started encoder-decoder models to randomly initialized encoder-decoder models on multiple sequence-to-sequence tasks, notably summarization, translation, sentence splitting, and sentence fusion. To be more precise, the publicly available pre-trained checkpoints of BERT, RoBERTa, and GPT2 were leveraged in different variations to warm-start an encoder-decoder model. E.g. a BERT-initialised encoder was paired with a BERT-initialized decoder yielding a BERT2BERT model or a RoBERTa-initialized encoder was paired with a GPT2-initialized decoder to yield a RoBERTa2GPT2 model. Additionally, the effect of sharing the encoder and decoder weights (as explained in the previous section) was investigated for RoBERTa, i.e. RoBERTaShare, and for BERT, i.e. BERTShare. Randomly or partly randomly initialized encoder-decoder models were used as a baseline, such as a fully randomly initialized encoder-decoder model, coined Rnd2Rnd or a BERT-initialized decoder paired with a randomly initialized encoder, defined as Rnd2BERT. The following table shows a complete list of all investigated model variants including the number of randomly initialized weights, i.e. \"random\", and the number of weights initialized from the respective pre-trained checkpoints, i.e. \"leveraged\". All models are based on a 12-layer architecture with 768-dim hidden size embeddings, corresponding to the bert-base-cased, bert-base-uncased, roberta-base, and gpt2 checkpoints in the 🤗Transformers model hub. |Model |random |leveraged |total |-------------- |:------- |---------- |------- |Rnd2Rnd |221M |0 |221M |Rnd2BERT |112M |109M |221M |BERT2Rnd |112M |109M |221M |Rnd2GPT2 |114M |125M |238M |BERT2BERT |26M |195M |221M |BERTShare |26M |109M |135M |RoBERTaShare |26M |126M |152M |BERT2GPT2 |26M |234M |260M |RoBERTa2GPT2 |26M |250M |276M The model Rnd2Rnd, which is based on the BERT2BERT architecture, contains 221M weight parameters - all of which are randomly initialized. The other two \"BERT-based\" baselines Rnd2BERT and BERT2Rnd have roughly half of their weights, i.e. 112M parameters, randomly initialized. The other 109M weight parameters are leveraged from the pre-trained bert-base-uncased checkpoint for the encoder- or decoder part respectively. The models BERT2BERT, BERT2GPT2, and RoBERTa2GPT2 have all of their encoder weight parameters leveraged (from bert-base-uncased, roberta-base respectively) and most of the decoder weight parameter weights as well (from gpt2, bert-base-uncased respectively). 26M decoder weight parameters, which correspond to the 12 cross-attention layers, are thereby randomly initialized. RoBERTa2GPT2 and BERT2GPT2 are compared to the Rnd2GPT2 baseline. Also, it should be noted that the shared model variants BERTShare and RoBERTaShare have significantly fewer parameters because all encoder weight parameters are shared with the respective decoder weight parameters.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Warm-staring Encoder-Decoder with BERT Let\'s now illustrate how a pre-trained BERT model can be used to warm-start the encoder-decoder model. BERT\'s pre-trained weight parameters are used to both initialize the encoder\'s weight parameters as well as the decoder\'s weight parameters. To do so, BERT\'s architecture is compared to the encoder\'s architecture and all layers of the encoder that also exist in BERT will be initialized with the pre-trained weight parameters of the respective layers. All layers of the encoder that do not exist in BERT will simply have their weight parameters be randomly initialized. Let\'s visualize. We can see that the encoder architecture corresponds 1-to-1 to BERT\'s architecture. The weight parameters of the bi-directional self-attention layer and the two feed-forward layers of all encoder blocks are initialized with the weight parameters of the respective BERT blocks. This is illustrated examplary for the second encoder block (red boxes at bottow) whose weight parameters \(\theta{\text{enc}}^{\text{self-attn}, 2}\) and \(\theta_{\text{enc}}^{\text{feed-forward}, 2}\) are set to BERT\'s weight parameters \(\theta_{\text{BERT}}^{\text{feed-forward}, 2}\) and \(\theta_{\text{BERT}}^{\text{self-attn}, 2}\), respectively at initialization. Before fine-tuning, the encoder therefore behaves exactly like a pre-trained BERT model. Assuming the input sequence \(\mathbf{x}1, \ldots, \mathbf{x}_n\) (shown in green) passed to the encoder is equal to the input sequence \(\mathbf{x}_1^{\text{BERT}}, \ldots, \mathbf{x}_n^{\text{BERT}}\) (shown in grey) passed to BERT, this means that the respective output vector sequences \(\mathbf{\overline{x}}_1, \ldots, \mathbf{\overline{x}}_n\) (shown in darker green) and \(\mathbf{\overline{x}}_1^{\text{BERT}}, \ldots, \mathbf{\overline{x}}_n^{\text{BERT}}\) (shown in darker grey) also have to be equal. Next, let\'s illustrate how the decoder is warm-started. The architecture of the decoder is different from BERT\'s architecture in three ways. 1. First, the decoder has to be conditioned on the contextualized encoded sequence \(\mathbf{\overline{X}}{1:n}\) by means of cross-attention layers. Consequently, randomly initialized cross-attention layers are added between the self-attention layer and the two feed-forward layers in each BERT block. This is represented exemplary for the second block by \(+\theta_{\text{dec}}^{\text{cross-attention, 2}}\) and illustrated by the newly added fully connected graph in red in the lower red box on the right. This necessarily changes the behavior of each modified BERT block so that an input vector, e.g. \(\mathbf{y'}0\) now yields a random output vector \(\mathbf{y''}_0\) (highlighted by the red border around the output vector \(\mathbf{y''}_0\)). 2. Second, BERT\'s bi-directional self-attention layers have to be changed to uni-directional self-attention layers to comply with auto-regressive generation. Because both the bi-directional and the uni-directional self-attention layer are based on the same key, query and value projection weights, the decoder\'s self-attention layer weights can be initialized with BERT\'s self-attention layer weights. E.g. the query, key and value weight parameters of the decoder\'s uni-directional self-attention layer are initialized with those of BERT\'s bi-directional self-attention layer \(\theta{\text{BERT}}^{\text{self-attn}, 2} = {\mathbf{W}{\text{BERT}, k}^{\text{self-attn}, 2}, \mathbf{W}{\text{BERT}, v}^{\text{self-attn}, 2}, \mathbf{W}{\text{BERT}, q}^{\text{self-attn}, 2} } \to \theta{\text{dec}}^{\text{self-attn}, 2} = {\mathbf{W}{\text{dec}, k}^{\text{self-attn}, 2}, \mathbf{W}{\text{dec}, v}^{\text{self-attn}, 2}, \mathbf{W}{\text{dec}, q}^{\text{self-attn}, 2} }. \) However, in uni-directional self-attention each token only attends to all previous tokens, so that the decoder\'s self-attention layers yield different output vectors than BERT\'s self-attention layers even though they share the same weights. Compare e.g., the decoder\'s causally connected graph in the right box versus BERT\'s fully connected graph in the left box. 3. Third, the decoder outputs a sequence of logit vectors \(\mathbf{L}{1:m}\) in order to define the conditional probability distribution \(p_{\theta_{\text{dec}}}(\mathbf{Y}{1:n} | \mathbf{\overline{X}})\). As a result, a LM Head layer is added on top of the last decoder block. The weight parameters of the LM Head layer usually correspond to the weight parameters of the word embedding \(\mathbf{W}{\text{emb}}\) and thus are not randomly initialized. This is illustrated in the top by the initialization \(\theta_{\text{BERT}}^{\text{word-emb}} \to \theta_{\text{dec}}^{\text{lm-head}}\). To conclude, when warm-starting the decoder from a pre-trained BERT model only the cross-attention layer weights are randomly initialized. All other weights including those of the self-attention layer and LM Head are initialized with BERT\'s pre-trained weight parameters. Having warm-stared the encoder-decoder model, the weights are then fine-tuned on a sequence-to-sequence downstream task, such as summarization.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Warm-staring Encoder-Decoder with BERT and GPT2 Instead of warm-starting both the encoder and decoder with a BERT checkpoint, we can instead leverage the BERT checkpoint for the encoder and a GPT2 checkpoint for the decoder. At first glance, a decoder-only GPT2 checkpoint seems to be better-suited to warm-start the decoder because it has already been trained on causal language modeling and uses uni-directional self-attention layers. Let\'s illustrate how a GPT2 checkpoint can be used to warm-start the decoder. We can see that decoder is more similar to GPT2 than it is to BERT. The weight parameters of decoder\'s LM Head can directly be initialized with GPT2\'s LM Head weight parameters, e.g. \(\theta_{\text{GPT2}}^{\text{lm-head}} \to \theta_{\text{dec}}^{\text{lm-head}}\). In addition, the blocks of the decoder and GPT2 both make use of uni-directional self-attention so that the output vectors of the decoder\'s self-attention layer are equivalent to GPT2\'s output vectors assuming the input vectors are the same, e.g. \(\mathbf{y'}0^{\text{GPT2}} = \mathbf{y'}_0\). In contrast to the BERT-initialized decoder, the GPT2-initialized decoder, therefore, keeps the causal connected graph of the self-attention layer as can be seen in the red boxes on the bottom. Nevertheless, the GPT2-initialized decoder also has to condition the decoder on \(\mathbf{\overline{X}}{1:n}\). Analoguos to the BERT-initialized decoder, randomly initialized weight parameters for the cross-attention layer are therefore added to each decoder block. This is illustrated e.g. for the second encoder block by \(+\theta_{\text{dec}}^{\text{cross-attention, 2}}\). Even though GPT2 resembles the decoder part of an encoder-decoder model more than BERT, a GPT2-initialized decoder will also yield random logit vectors \(\mathbf{L}{1:m}\) without fine-tuning due to randomly initialized cross-attention layers in every decoder block. It would be interesting to investigate whether a GPT2-initialized decoder yields better results or can be fine-tuned more efficiently.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Data Preprocessing In this section, we show how the data can be pre-processed for training. More importantly, we try to give the reader some insight into the process of deciding how to preprocess the data. We will need datasets and transformers to be installed. python !pip install datasets==1.0.2 !pip install transformers==4.2.1 Let's start by downloading the CNN/Dailymail dataset. python import datasets train_data = datasets.load_dataset("cnn_dailymail", "3.0.0", split="train") Alright, let\'s get a first impression of the dataset. Alternatively, the dataset can also be visualized using the awesome datasets viewer online. python train_data.info.description Our input is called article and our labels are called highlights. Let\'s now print out the first example of the training data to get a feeling for the data. python import pandas as pd from IPython.display import display, HTML from datasets import ClassLabel df = pd.DataFrame(train_data[:1]) del df["id"] for column, typ in train_data.features.items(): if isinstance(typ, ClassLabel): df[column] = df[column].transform(lambda i: typ.names[i]) display(HTML(df.to_html())) python OUTPUT: ------- Article: """It's official: U.S. President Barack Obama wants lawmakers to weigh in on whether to use military force in Syria. Obama sent a letter to the heads of the House and Senate on Saturday night, hours after announcing that he believes military action against Syrian targets is the right step to take over the alleged use of chemical weapons. The proposed legislation from Obama asks Congress to approve the use of military force "to deter, disrupt, prevent and degrade the potential for future uses of chemical weapons or other weapons of mass destruction." It's a step that is set to turn an international crisis into a fierce domestic political battle. There are key questions looming over the debate: What did U.N. weapons inspectors find in Syria? What happens if Congress votes no? And how will the Syrian government react? In a televised address from the White House Rose Garden earlier Saturday, the president said he would take his case to Congress, not because he has to -- but because he wants to. "While I believe I have the authority to carry out this military action without specific congressional authorization, I know that the country will be stronger if we take this course, and our actions will be even more effective," he said. "We should have this debate, because the issues are too big for business as usual." Obama said top congressional leaders had agreed to schedule a debate when the body returns to Washington on September 9. The Senate Foreign Relations Committee will hold a hearing over the matter on Tuesday, Sen. Robert Menendez said. Transcript: Read Obama's full remarks . Syrian crisis: Latest developments . U.N. inspectors leave Syria . Obama's remarks came shortly after U.N. inspectors left Syria, carrying evidence that will determine whether chemical weapons were used in an attack early last week in a Damascus suburb. "The aim of the game here, the mandate, is very clear -- and that is to ascertain whether chemical weapons were used -- and not by whom," U.N. spokesman Martin Nesirky told reporters on Saturday. But who used the weapons in the reported toxic gas attack in a Damascus suburb on August 21 has been a key point of global debate over the Syrian crisis. Top U.S. officials have said there's no doubt that the Syrian government was behind it, while Syrian officials have denied responsibility and blamed jihadists fighting with the rebels. British and U.S. intelligence reports say the attack involved chemical weapons, but U.N. officials have stressed the importance of waiting for an official report from inspectors. The inspectors will share their findings with U.N. Secretary-General Ban Ki-moon Ban, who has said he wants to wait until the U.N. team's final report is completed before presenting it to the U.N. Security Council. The Organization for the Prohibition of Chemical Weapons, which nine of the inspectors belong to, said Saturday that it could take up to three weeks to analyze the evidence they collected. "It needs time to be able to analyze the information and the samples," Nesirky said. He noted that Ban has repeatedly said there is no alternative to a political solution to the crisis in Syria, and that "a military solution is not an option." Bergen: Syria is a problem from hell for the U.S. Obama: 'This menace must be confronted' Obama's senior advisers have debated the next steps to take, and the president's comments Saturday came amid mounting political pressure over the situation in Syria. Some U.S. lawmakers have called for immediate action while others warn of stepping into what could become a quagmire. Some global leaders have expressed support, but the British Parliament's vote against military action earlier this week was a blow to Obama's hopes of getting strong backing from key NATO allies. On Saturday, Obama proposed what he said would be a limited military action against Syrian President Bashar al-Assad. Any military attack would not be open-ended or include U.S. ground forces, he said. Syria's alleged use of chemical weapons earlier this month "is an assault on human dignity," the president said. A failure to respond with force, Obama argued, "could lead to escalating use of chemical weapons or their proliferation to terrorist groups who would do our people harm. In a world with many dangers, this menace must be confronted." Syria missile strike: What would happen next? Map: U.S. and allied assets around Syria . Obama decision came Friday night . On Friday night, the president made a last-minute decision to consult lawmakers. What will happen if they vote no? It's unclear. A senior administration official told CNN that Obama has the authority to act without Congress -- even if Congress rejects his request for authorization to use force. Obama on Saturday continued to shore up support for a strike on the al-Assad government. He spoke by phone with French President Francois Hollande before his Rose Garden speech. "The two leaders agreed that the international community must deliver a resolute message to the Assad regime -- and others who would consider using chemical weapons -- that these crimes are unacceptable and those who violate this international norm will be held accountable by the world," the White House said. Meanwhile, as uncertainty loomed over how Congress would weigh in, U.S. military officials said they remained at the ready. 5 key assertions: U.S. intelligence report on Syria . Syria: Who wants what after chemical weapons horror . Reactions mixed to Obama's speech . A spokesman for the Syrian National Coalition said that the opposition group was disappointed by Obama's announcement. "Our fear now is that the lack of action could embolden the regime and they repeat his attacks in a more serious way," said spokesman Louay Safi. "So we are quite concerned." Some members of Congress applauded Obama's decision. House Speaker John Boehner, Majority Leader Eric Cantor, Majority Whip Kevin McCarthy and Conference Chair Cathy McMorris Rodgers issued a statement Saturday praising the president. "Under the Constitution, the responsibility to declare war lies with Congress," the Republican lawmakers said. "We are glad the president is seeking authorization for any military action in Syria in response to serious, substantive questions being raised." More than 160 legislators, including 63 of Obama's fellow Democrats, had signed letters calling for either a vote or at least a "full debate" before any U.S. action. British Prime Minister David Cameron, whose own attempt to get lawmakers in his country to support military action in Syria failed earlier this week, responded to Obama's speech in a Twitter post Saturday. "I understand and support Barack Obama's position on Syria," Cameron said. An influential lawmaker in Russia -- which has stood by Syria and criticized the United States -- had his own theory. "The main reason Obama is turning to the Congress: the military operation did not get enough support either in the world, among allies of the US or in the United States itself," Alexei Pushkov, chairman of the international-affairs committee of the Russian State Duma, said in a Twitter post. In the United States, scattered groups of anti-war protesters around the country took to the streets Saturday. "Like many other Americans...we're just tired of the United States getting involved and invading and bombing other countries," said Robin Rosecrans, who was among hundreds at a Los Angeles demonstration. What do Syria's neighbors think? Why Russia, China, Iran stand by Assad . Syria's government unfazed . After Obama's speech, a military and political analyst on Syrian state TV said Obama is "embarrassed" that Russia opposes military action against Syria, is "crying for help" for someone to come to his rescue and is facing two defeats -- on the political and military levels. Syria's prime minister appeared unfazed by the saber-rattling. "The Syrian Army's status is on maximum readiness and fingers are on the trigger to confront all challenges," Wael Nader al-Halqi said during a meeting with a delegation of Syrian expatriates from Italy, according to a banner on Syria State TV that was broadcast prior to Obama's address. An anchor on Syrian state television said Obama "appeared to be preparing for an aggression on Syria based on repeated lies." A top Syrian diplomat told the state television network that Obama was facing pressure to take military action from Israel, Turkey, some Arabs and right-wing extremists in the United States. "I think he has done well by doing what Cameron did in terms of taking the issue to Parliament," said Bashar Jaafari, Syria's ambassador to the United Nations. Both Obama and Cameron, he said, "climbed to the top of the tree and don't know how to get down." The Syrian government has denied that it used chemical weapons in the August 21 attack, saying that jihadists fighting with the rebels used them in an effort to turn global sentiments against it. British intelligence had put the number of people killed in the attack at more than 350. On Saturday, Obama said "all told, well over 1,000 people were murdered." U.S. Secretary of State John Kerry on Friday cited a death toll of 1,429, more than 400 of them children. No explanation was offered for the discrepancy. Iran: U.S. military action in Syria would spark 'disaster' Opinion: Why strikes in Syria are a bad idea .""" Summary: """Syrian official: Obama climbed to the top of the tree, "doesn't know how to get down"\nObama sends a letter to the heads of the House and Senate .\nObama to seek congressional approval on military action against Syria .\nAim is to determine whether CW were used, not by whom, says U.N. spokesman""" The input data seems to consist of short news articles. Interestingly, the labels appear to be bullet-point-like summaries. At this point, one should probably take a look at a couple of other examples to get a better feeling for the data. One should also notice here that the text is case-sensitive. This means that we have to be careful if we want to use case-insensitive models. As CNN/Dailymail is a summarization dataset, the model will be evaluated using the ROUGE metric. Checking the description of ROUGE in 🤗datasets, cf. here, we can see that the metric is case-insensitive, meaning that upper case letters will be normalized to lower case letters during evaluation. Thus, we can safely leverage uncased checkpoints, such as bert-base-uncased. Cool! Next, let\'s get a sense of the length of input data and labels. As models compute length in token-length, we will make use of the bert-base-uncased tokenizer to compute the article and summary length. First, we load the tokenizer. python from transformers import BertTokenizerFast tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased") Next, we make use of .map() to compute the length of the article and its summary. Since we know that the maximum length that bert-base-uncased can process amounts to 512, we are also interested in the percentage of input samples being longer than the maximum length. Similarly, we compute the percentage of summaries that are longer than 64, and 128 respectively. We can define the .map() function as follows. python # map article and summary len to dict as well as if sample is longer than 512 tokens def map_to_length(x): x["article_len"] = len(tokenizer(x["article"]).input_ids) x["article_longer_512"] = int(x["article_len"] > 512) x["summary_len"] = len(tokenizer(x["highlights"]).input_ids) x["summary_longer_64"] = int(x["summary_len"] > 64) x["summary_longer_128"] = int(x["summary_len"] > 128) return x It should be sufficient to look at the first 10000 samples. We can speed up the mapping by using multiple processes with num_proc=4. python sample_size = 10000 data_stats = train_data.select(range(sample_size)).map(map_to_length, num_proc=4) Having computed the length for the first 10000 samples, we should now average them together. For this, we can make use of the .map() function with batched=True and batch_size=-1 to have access to all 10000 samples within the .map() function. python def compute_and_print_stats(x): if len(x["article_len"]) == sample_size: print( "Article Mean: {}, %-Articles > 512:{}, Summary Mean:{}, %-Summary > 64:{}, %-Summary > 128:{}".format( sum(x["article_len"]) / sample_size, sum(x["article_longer_512"]) / sample_size, sum(x["summary_len"]) / sample_size, sum(x["summary_longer_64"]) / sample_size, sum(x["summary_longer_128"]) / sample_size, ) ) output = data_stats.map( compute_and_print_stats, batched=True, batch_size=-1, ) python OUTPUT: ------- Article Mean: 847.6216, %-Articles > 512:0.7355, Summary Mean:57.7742, %-Summary > 64:0.3185, %-Summary > 128:0.0 We can see that on average an article contains 848 tokens with ca. 3/4 of the articles being longer than the model\'s max_length 512. The summary is on average 57 tokens long. Over 30% of our 10000-sample summaries are longer than 64 tokens, but none are longer than 128 tokens. bert-base-cased is limited to 512 tokens, which means we would have to cut possibly important information from the article. Because most of the important information is often found at the beginning of articles and because we want to be computationally efficient, we decide to stick to bert-base-cased with a max_length of 512 in this notebook. This choice is not optimal but has shown to yield good results on CNN/Dailymail. Alternatively, one could leverage long-range sequence models, such as Longformer to be used as the encoder. Regarding the summary length, we can see that a length of 128 already includes all of the summary labels. 128 is easily within the limits of bert-base-cased, so we decide to limit the generation to 128. Again, we will make use of the .map() function - this time to transform each training batch into a batch of model inputs. "article" and "highlights" are tokenized and prepared as the Encoder\'s "input_ids" and Decoder\'s "decoder_input_ids" respectively. "labels" are shifted automatically to the left for language modeling training. Lastly, it is very important to remember to ignore the loss of the padded labels. In 🤗Transformers this can be done by setting the label to -100. Great, let\'s write down our mapping function then. python encoder_max_length=512 decoder_max_length=128 def process_data_to_model_inputs(batch): # tokenize the inputs and labels inputs = tokenizer(batch["article"], padding="max_length", truncation=True, max_length=encoder_max_length) outputs = tokenizer(batch["highlights"], padding="max_length", truncation=True, max_length=decoder_max_length) batch["input_ids"] = inputs.input_ids batch["attention_mask"] = inputs.attention_mask batch["labels"] = outputs.input_ids.copy() # because BERT automatically shifts the labels, the labels correspond exactly to `decoder_input_ids`. # We have to make sure that the PAD token is ignored batch["labels"] = [[-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch["labels"]] return batch In this notebook, we train and evaluate the model just on a few training examples for demonstration and set the batch_size to 4 to prevent out-of-memory issues. The following line reduces the training data to only the first 32 examples. The cell can be commented out or not run for a full training run. Good results were obtained with a batch_size of 16. python train_data = train_data.select(range(32)) Alright, let\'s prepare the training data. python # batch_size = 16 batch_size=4 train_data = train_data.map( process_data_to_model_inputs, batched=True, batch_size=batch_size, remove_columns=["article", "highlights", "id"] ) Taking a look at the processed training dataset we can see that the column names article, highlights, and id have been replaced by the arguments expected by the EncoderDecoderModel. python train_data python OUTPUT: ------- Dataset(features: {'attention_mask': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None), 'decoder_attention_mask': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None), 'decoder_input_ids': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None), 'input_ids': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None), 'labels': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None)}, num_rows: 32) So far, the data was manipulated using Python\'s List format. Let\'s convert the data to PyTorch Tensors to be trained on GPU. python train_data.set_format( type="torch", columns=["input_ids", "attention_mask", "labels"], ) Awesome, the data processing of the training data is finished. Analogous, we can do the same for the validation data. First, we load 10% of the validation dataset: python val_data = datasets.load_dataset("cnn_dailymail", "3.0.0", split="validation[:10%]") For demonstration purposes, the validation data is then reduced to just 8 samples, python val_data = val_data.select(range(8)) the mapping function is applied, python val_data = val_data.map( process_data_to_model_inputs, batched=True, batch_size=batch_size, remove_columns=["article", "highlights", "id"] ) and, finally, the validation data is also converted to PyTorch tensors. python val_data.set_format( type="torch", columns=["input_ids", "attention_mask", "labels"], ) Great! Now we can move to warm-starting the EncoderDecoderModel.

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Fine-Tuning Warm-Started Encoder-Decoder Models In this section, we will show how one can make use of the Seq2SeqTrainer to fine-tune a warm-started encoder-decoder model. Let\'s first import the Seq2SeqTrainer and its training arguments Seq2SeqTrainingArguments. python from transformers import Seq2SeqTrainer, Seq2SeqTrainingArguments In addition, we need a couple of python packages to make the Seq2SeqTrainer work. python !pip install git-python==1.0.3 !pip install rouge_score !pip install sacrebleu The Seq2SeqTrainer extends 🤗Transformer\'s Trainer for encoder-decoder models. In short, it allows using the generate(...) function during evaluation, which is necessary to validate the performance of encoder-decoder models on most sequence-to-sequence tasks, such as summarization. For more information on the Trainer, one should read through this short tutorial. Let\'s begin by configuring the Seq2SeqTrainingArguments. The argument predict_with_generate should be set to True, so that the Seq2SeqTrainer runs the generate(...) on the validation data and passes the generated output as predictions to the compute_metric(...) function which we will define later. The additional arguments are derived from TrainingArguments and can be read upon here. For a complete training run, one should change those arguments as needed. Good default values are commented out below. For more information on the Seq2SeqTrainer, the reader is advised to take a look at the code. python training_args = Seq2SeqTrainingArguments( predict_with_generate=True, evaluation_strategy="steps", per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, fp16=True, output_dir="./", logging_steps=2, save_steps=10, eval_steps=4, # logging_steps=1000, # save_steps=500, # eval_steps=7500, # warmup_steps=2000, # save_total_limit=3, ) Also, we need to define a function to correctly compute the ROUGE score during validation. Since we activated predict_with_generate, the compute_metrics(...) function expects predictions that were obtained using the generate(...) function. Like most summarization tasks, CNN/Dailymail is typically evaluated using the ROUGE score. Let\'s first load the ROUGE metric using the 🤗datasets library. python rouge = datasets.load_metric("rouge") Next, we will define the compute_metrics(...) function. The rouge metric computes the score from two lists of strings. Thus we decode both the predictions and labels - making sure that -100 is correctly replaced by the pad_token_id and remove all special characters by setting skip_special_tokens=True. python def compute_metrics(pred): labels_ids = pred.label_ids pred_ids = pred.predictions pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True) labels_ids[labels_ids == -100] = tokenizer.pad_token_id label_str = tokenizer.batch_decode(labels_ids, skip_special_tokens=True) rouge_output = rouge.compute(predictions=pred_str, references=label_str, rouge_types=["rouge2"])["rouge2"].mid return { "rouge2_precision": round(rouge_output.precision, 4), "rouge2_recall": round(rouge_output.recall, 4), "rouge2_fmeasure": round(rouge_output.fmeasure, 4), } Great, now we can pass all arguments to the Seq2SeqTrainer and start finetuning. Executing the following cell will take ca. 10 minutes ☕. Finetuning BERT2BERT on the complete CNN/Dailymail training data takes ca. model takes ca. 8h on a single TITAN RTX GPU. python # instantiate trainer trainer = Seq2SeqTrainer( model=bert2bert, tokenizer=tokenizer, args=training_args, compute_metrics=compute_metrics, train_dataset=train_data, eval_dataset=val_data, ) trainer.train() Awesome, we should now be fully equipped to finetune a warm-started encoder-decoder model. To check the result of our fine-tuning let\'s take a look at the saved checkpoints. python !ls bash OUTPUT: ------- bert2bert checkpoint-20 runs seq2seq_trainer.py checkpoint-10 __pycache__ sample_data seq2seq_training_args.py Finally, we can load the checkpoint as usual via the EncoderDecoderModel.from_pretrained(...) method. python dummy_bert2bert = EncoderDecoderModel.from_pretrained("./checkpoint-20")

Leveraging Pre-trained Language Model Checkpoints for Encoder-Decoder Models

patrickvonplaten

November 09, 2020

warm-starting-encoder-decoder

guide, nlp

https://huggingface.co/blog/warm-starting-encoder-decoder

Conclusion Alright, let\'s draw a conclusion and try to derive some practical tips. - We have observed on all tasks that a warm-started encoder-part gives a significant performance boost compared to encoder-decoder models having a randomly initialized encoder. On the other hand, warm-starting the decoder seems to be less important, with BERT2BERT being on par with BERT2Rnd on most tasks. An intuitive reason would be that since a BERT- or RoBERTa-initialized encoder part has none of its weight parameters randomly initialized, the encoder can fully exploit the acquired knowledge of BERT\'s or RoBERTa\'s pre-trained checkpoints, respectively. In contrast, the warm-started decoder always has parts of its weight parameters randomly initialized which possibly makes it much harder to effectively leverage the knowledge acquired by the checkpoint used to initialize the decoder. - Next, we noticed that it is often beneficial to share encoder and decoder weights, especially if the target distribution is similar to the input distribution (e.g. BBC XSum). However, for datasets whose target data distribution differs more significantly from the input data distribution and for which model capacity \({}^2\) is known to play an important role, e.g. WMT14, encoder-decoder weight sharing seems to be disadvantageous. - Finally, we have seen that it is very important that the vocabulary of the pre-trained \"stand-alone\" checkpoints fit the vocabulary required to solve the sequence-to-sequence task. E.g. a warm-started BERT2GPT2 encoder-decoder will perform poorly on En \(\to\) De MT because GPT2 was pre-trained on English whereas the target language is German. The overall poor performance of the BERT2GPT2, Rnd2GPT2, and RoBERTa2GPT2 compared to BERT2BERT, BERTShared, and RoBERTaShared suggests that it is more effective to have a shared vocabulary. Also, it shows that initializing the decoder part with a pre-trained GPT2 checkpoint is not more effective than initializing it with a pre-trained BERT checkpoint besides GPT2 being more similar to the decoder in its architecture. For each of the above tasks, the most performant models were ported to 🤗Transformers and can be accessed here: - RoBERTaShared (large) - Wikisplit: google/roberta2roberta_L-24_wikisplit. - RoBERTaShared (large) - Discofuse: google/roberta2roberta_L-24_discofuse. - BERT2BERT (large) - WMT en \(\to\) de: google/bert2bert_L-24_wmt_en_de. - BERT2BERT (large) - WMT de \(\to\) en: google/bert2bert_L-24_wmt_de_en. - RoBERTaShared (large) - CNN/Dailymail: google/roberta2roberta_L-24_cnn_daily_mail. - RoBERTaShared (large) - BBC XSum: google/roberta2roberta_L-24_bbc. - RoBERTaShared (large) - Gigaword: google/roberta2roberta_L-24_gigaword. ------------------------------------------------------------------------ \({}^1\) To retrieve BLEU-4 scores, a script from the Tensorflow Official Transformer implementation https://github.com/tensorflow/models/tree master/official/nlp/transformer was used. Note that, differently from the tensor2tensor/utils/ get_ende_bleu.sh used by Vaswani et al. (2017), this script does not split noun compounds, but utf-8 quotes were normalized to ascii quotes after having noted that the pre-processed training set contains only ascii quotes. \({}^2\) Model capacity is an informal definition of how good the model is at modeling complex patterns. It is also sometimes defined as the ability of a model to learn from more and more data. Model capacity is broadly measured by the number of trainable parameters - the more parameters, the higher the model capacity. # Warm-starting encoder-decoder models with 🤗Transformers (Practice) We have explained the theory of warm-starting encoder-decoder models, analyzed empirical results on multiple datasets, and have derived practical conclusions. Let\'s now walk through a complete code example showcasing how a BERT2BERT model can be warm-started and consequently fine-tuned on the CNN/Dailymail summarization task. We will be leveraging the 🤗datasets and 🤗Transformers libraries. In addition, the following list provides a condensed version of this and other notebooks on warm-starting other combinations of encoder-decoder models. - for BERT2BERT on CNN/Dailymail (a condensed version of this notebook), click here. - for RoBERTaShare on BBC XSum, click here. - for BERT2Rnd on WMT14 En \(\to\) De, click here. - for RoBERTa2GPT2 on DiscoFuse, click here. Note: This notebook only uses a few training, validation, and test data samples for demonstration purposes. To fine-tune an encoder-decoder model on the full training data, the user should change the training and data preprocessing parameters accordingly as highlighted by the comments.