Sampling instead of argmax

Reverting part of latest commit
Addressing @mfuntowicz's comments
2020-06-17 10:25:16 -04:00 · 2020-06-08 14:22:40 -04:00 · 2020-06-01 20:34:12 -04:00 · 2020-06-01 20:23:30 -04:00 · 2020-06-01 20:23:30 -04:00 · 2020-06-01 20:23:30 -04:00
249 changed files with 7501 additions and 13692 deletions
@@ -8,10 +8,6 @@ __pycache__/
 # C extensions
 *.so

-# tests and logs
-tests/fixtures
-logs/
-
 # Distribution / packaging
 .Python
 build/
@@ -120,7 +116,6 @@ dmypy.json
 .pyre/

 # vscode
-.vs
 .vscode

 # Pycharm
@@ -63,7 +63,7 @@ Choose the right framework for every part of a model's lifetime

 ## Installation

-This repo is tested on Python 3.6+, PyTorch 1.0.0+ (PyTorch 1.3.1+ for examples) and TensorFlow 2.0.
+This repo is tested on Python 3.6+, PyTorch 1.0.0+ and TensorFlow 2.0.

 You should install 🤗 Transformers in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).

@@ -1,6 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        informational: true
-    patch: off
@@ -7,14 +7,6 @@ you can install them with the following command, at the root of the code reposit
 pip install -e ".[docs]"
 ```

---
-**NOTE**
-
-You only need to generate the documentation to inspect it locally (if you're planning changes and want to 
-check how they look like before committing for instance). You don't have to commit the built documentation.
-
---
-
 ## Packages installed

 Here's an overview of all the packages installed. If you ran the previous command installing all packages from
@@ -76,18 +68,6 @@ It should build the static app that will be available under `/docs/_build/html`
 Accepted files are reStructuredText (.rst) and Markdown (.md). Create a file with its extension and put it
 in the source directory. You can then link it to the toc-tree by putting the filename without the extension.

-## Preview the documentation in a pull request
-
-Once you have made your pull request, you can check what the documentation will look like after it's merged by
-following these steps:
-
- Look at the checks at the bottom of the conversation page of your PR (you may need to click on "show all checks" to
-  expand them).
- Click on "details" next to the `ci/circleci: build_doc` check.
- In the new window, click on the "Artifacts" tab.
- Locate the file "docs/_build/html/index.html" (or any specific page you want to check) and click on it to get a 
-  preview.
-
 ## Writing Documentation - Specification

 The `huggingface/transformers` documentation follows the
@@ -26,7 +26,7 @@ author = u'huggingface'
 # The short X.Y version
 version = u''
 # The full version, including alpha/beta/rc tags
-release = u'2.11.0'
+release = u'2.10.0'


 # -- General configuration ---------------------------------------------------
@@ -60,7 +60,6 @@ The library currently contains PyTorch and Tensorflow implementations, pre-train
    installation
    quickstart
    glossary
-    summary
    pretrained_models
    usage
    model_sharing
@@ -8,7 +8,7 @@ Recognition, Masked Language Modeling, Sentiment Analysis, Feature Extraction an
 There are two categories of pipeline abstractions to be aware about:

 - The :class:`~transformers.pipeline` which is the most powerful object encapsulating all other pipelines
- The other task-specific pipelines, such as :class:`~transformers.TokenClassificationPipeline`
+- The other task-specific pipelines, such as :class:`~transformers.NerPipeline`
  or :class:`~transformers.QuestionAnsweringPipeline`

 The pipeline abstraction
@@ -30,15 +30,15 @@ Parent class: Pipeline
 .. autoclass:: transformers.Pipeline
    :members: predict, transform, save_pretrained

-TokenClassificationPipeline
-==========================================
-
-.. autoclass:: transformers.TokenClassificationPipeline
-
 NerPipeline
 ==========================================

-This class is an alias of the :class:`~transformers.TokenClassificationPipeline` defined above. Please refer to that pipeline for
+.. autoclass:: transformers.NerPipeline
+
+TokenClassificationPipeline
+==========================================
+
+This class is an alias of the :class:`~transformers.NerPipeline` defined above. Please refer to that pipeline for
 documentation and usage examples.

 FillMaskPipeline
@@ -17,14 +17,12 @@ The base classes ``PreTrainedTokenizer`` and ``PreTrainedTokenizerFast`` impleme
 ~~~~~~~~~~~~~~~~~~~~~~~~

 .. autoclass:: transformers.PreTrainedTokenizer
-    :special-members: __call__
    :members:

 ``PreTrainedTokenizerFast``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~

 .. autoclass:: transformers.PreTrainedTokenizerFast
-    :special-members: __call__
    :members:

 ``BatchEncoding``
@@ -68,20 +68,6 @@ AlbertForSequenceClassification
    :members:


-AlbertForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.AlbertForMultipleChoice
-    :members:
-
-
-AlbertForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.AlbertForTokenClassification
-    :members:
-
-
 AlbertForQuestionAnswering
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -117,13 +103,6 @@ TFAlbertForMultipleChoice
    :members:


-TFAlbertForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFAlbertForTokenClassification
-    :members:
-
-
 TFAlbertForQuestionAnswering
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -4,9 +4,8 @@ Bart
 file a `Github Issue <https://github.com/huggingface/transformers/issues/new?assignees=&labels=&template=bug-report.md&title>`__ and assign
@sshleifer

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
+Paper
+~~~~~
 The Bart model was `proposed <https://arxiv.org/abs/1910.13461>`_ by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer on 29 Oct, 2019.
 According to the abstract,

@@ -17,26 +16,14 @@ According to the abstract,
 The Authors' code can be found `here <https://github.com/pytorch/fairseq/tree/master/examples/bart>`_


-Implementation Notes:
-
+Implementation Notes
+~~~~~~~~~~~~~~~~~~~~
 - Bart doesn't use :obj:`token_type_ids` for sequence classification. Use BartTokenizer.encode to get the proper splitting.
 - The forward pass of ``BartModel`` will create decoder inputs (using the helper function ``transformers.modeling_bart._prepare_bart_decoder_inputs``)  if they are not passed. This is different than some other modeling APIs.
 - Model predictions are intended to be identical to the original implementation. This only works, however, if the string you pass to ``fairseq.encode`` starts with a space.
 - ``BartForConditionalGeneration.generate`` should be used for conditional generation tasks like summarization, see the example in that docstrings
- Models that load the ``"facebook/bart-large-cnn"`` weights will not have a ``mask_token_id``, or be able to perform mask filling tasks.
+- Models that load the ``"bart-large-cnn"`` weights will not have a ``mask_token_id``, or be able to perform mask filling tasks.

-BartConfig
-~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.BartConfig
-    :members:
-
-
-BartTokenizer
-~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.BartTokenizer
-    :members:


 BartModel
@@ -48,20 +35,6 @@ BartModel
 .. autofunction:: transformers.modeling_bart._prepare_bart_decoder_inputs


-BartForSequenceClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.BartForSequenceClassification
-    :members: forward
-
-
-BartForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.BartForQuestionAnswering
-    :members: forward
-
-
 BartForConditionalGeneration
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -69,3 +42,15 @@ BartForConditionalGeneration
    :members: generate, forward


+BartForSequenceClassification
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: transformers.BartForSequenceClassification
+    :members: forward
+
+BartConfig
+~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: transformers.BartConfig
+    :members:
+
@@ -1,9 +1,6 @@
 CamemBERT
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The CamemBERT model was proposed in `CamemBERT: a Tasty French Language Model <https://arxiv.org/abs/1911.03894>`__
 by Louis Martin, Benjamin Muller, Pedro Javier Ortiz Suárez, Yoann Dupont, Laurent Romary, Éric Villemonte de la
 Clergerie, Djamé Seddah, and Benoît Sagot. It is based on Facebook's RoBERTa model released in 2019. It is a model
@@ -77,13 +74,6 @@ CamembertForTokenClassification
    :members:


-CamembertForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.CamembertForQuestionAnswering
-    :members:
-
-
 TFCamembertModel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -110,10 +100,3 @@ TFCamembertForTokenClassification

 .. autoclass:: transformers.TFCamembertForTokenClassification
    :members:
-
-
-TFCamembertForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFCamembertForQuestionAnswering
-    :members:
@@ -1,9 +1,6 @@
 CTRL
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 CTRL model was proposed in `CTRL: A Conditional Transformer Language Model for Controllable Generation <https://arxiv.org/abs/1909.05858>`_
 by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.
 It's a causal (unidirectional) transformer pre-trained using language modeling on a very large
@@ -1,9 +1,6 @@
 DistilBERT
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The DistilBERT model was proposed in the blog post
 `Smaller, faster, cheaper, lighter: Introducing DistilBERT, a distilled version of BERT <https://medium.com/huggingface/distilbert-8cf3380435b5>`__,
 and the paper `DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter <https://arxiv.org/abs/1910.01108>`__.
@@ -75,20 +72,6 @@ DistilBertForSequenceClassification
    :members:


-DistilBertForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.DistilBertForMultipleChoice
-    :members:
-
-
-DistilBertForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.DistilBertForTokenClassification
-    :members:
-
-
 DistilBertForQuestionAnswering
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -116,22 +99,6 @@ TFDistilBertForSequenceClassification
    :members:


-
-TFDistilBertForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFDistilBertForMultipleChoice
-    :members:
-
-
-
-TFDistilBertForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFDistilBertForTokenClassification
-    :members:
-
-
 TFDistilBertForQuestionAnswering
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -1,9 +1,6 @@
 ELECTRA
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The ELECTRA model was proposed in the paper.
 `ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators <https://openreview.net/pdf?id=r1xMH1BtvB>`__.
 ELECTRA is a new pre-training approach which trains two transformer models: the generator and the discriminator. The
@@ -92,13 +89,6 @@ ElectraForMaskedLM
    :members:


-ElectraForSequenceClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.ElectraForSequenceClassification
-    :members:
-
-
 ElectraForTokenClassification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -106,13 +96,6 @@ ElectraForTokenClassification
    :members:


-ElectraForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.ElectraForQuestionAnswering
-    :members:
-
-
 TFElectraModel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -139,10 +122,3 @@ TFElectraForTokenClassification

 .. autoclass:: transformers.TFElectraForTokenClassification
    :members:
-
-
-TFElectraForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFElectraForQuestionAnswering
-    :members:
@@ -1,9 +1,6 @@
 FlauBERT
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The FlauBERT model was proposed in the paper
 `FlauBERT: Unsupervised Language Model Pre-training for French <https://arxiv.org/abs/1912.05372>`__ by Hang Le et al.
 It's a transformer pre-trained using a masked language modeling (MLM) objective (BERT-like).
@@ -75,43 +72,3 @@ FlaubertForQuestionAnswering
    :members:


-TFFlaubertModel
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertModel
-    :members:
-
-
-TFFlaubertWithLMHeadModel
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertWithLMHeadModel
-    :members:
-
-
-TFFlaubertForSequenceClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertForSequenceClassification
-    :members:
-
-
-TFFlaubertForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertForMultipleChoice
-    :members:
-
-
-TFFlaubertForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertForTokenClassification
-    :members:
-
-
-TFFlaubertForQuestionAnsweringSimple
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFFlaubertForQuestionAnsweringSimple
-    :members:
@@ -4,7 +4,7 @@ Longformer
 file a `Github Issue <https://github.com/huggingface/transformers/issues/new?assignees=&labels=&template=bug-report.md&title>`_

 Overview
-~~~~~~~~~
+~~~~~
 The Longformer model was presented in `Longformer: The Long-Document Transformer <https://arxiv.org/pdf/2004.05150.pdf>`_ by Iz Beltagy, Matthew E. Peters, Arman Cohan.
 Here the abstract: 

@@ -13,7 +13,7 @@ Here the abstract:
 The Authors' code can be found `here <https://github.com/allenai/longformer>`_ .

 Longformer Self Attention
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~
 Longformer self attention employs self attention on both a "local" context and a "global" context.
 Most tokens only attend "locally" to each other meaning that each token attends to its :math:`\frac{1}{2} w` previous tokens and :math:`\frac{1}{2} w` succeding tokens with :math:`w` being the window length as defined in `config.attention_window`. Note that `config.attention_window` can be of type ``list`` to define a different :math:`w` for each layer. 
 A selecetd few tokens attend "globally" to all other tokens, as it is conventionally done for all tokens in *e.g.* `BertSelfAttention`.
@@ -55,13 +55,6 @@ LongformerTokenizer
    :members: 


-LongformerTokenizerFast
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.LongformerTokenizerFast
-    :members: 
-
-
 LongformerModel
 ~~~~~~~~~~~~~~~~~~~~

@@ -76,10 +69,10 @@ LongformerForMaskedLM
    :members:


-LongformerForSequenceClassification
+LongformerForQuestionAnswering
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-.. autoclass:: transformers.LongformerForSequenceClassification
+.. autoclass:: transformers.LongformerForQuestionAnswering
    :members:


@@ -96,9 +89,3 @@ LongformerForTokenClassification
 .. autoclass:: transformers.LongformerForTokenClassification
    :members:

-
-LongformerForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.LongformerForQuestionAnswering
-    :members:
@@ -6,11 +6,11 @@ file a `Github Issue <https://github.com/huggingface/transformers/issues/new?ass

 Implementation Notes
 ~~~~~~~~~~~~~~~~~~~~
- Each model is about 298 MB on disk, there are 1,000+ models.
+- each model is about 298 MB on disk, there are 1,000+ models.
 - The list of supported language pairs can be found `here <https://huggingface.co/Helsinki-NLP>`__.
 - The 1,000+ models were originally trained by `Jörg Tiedemann <https://researchportal.helsinki.fi/en/persons/j%C3%B6rg-tiedemann>`__ using the `Marian <https://marian-nmt.github.io/>`_ C++ library, which supports fast training and translation.
 - All models are transformer encoder-decoders with 6 layers in each component. Each model's performance is documented in a model card.
- The 80 opus models that require BPE preprocessing are not supported.
+- the 80 opus models that require BPE preprocessing are not supported.
 - The modeling code is the same as ``BartForConditionalGeneration`` with a few minor modifications:
    - static (sinusoid) positional embeddings (``MarianConfig.static_position_embeddings=True``)
    - a new final_logits_bias (``MarianConfig.add_bias_logits=True``)
@@ -86,19 +86,6 @@ Code to see available pretrained models:
    suffix = [x.split('/')[1] for x in model_ids]
    multi_models = [f'{org}/{s}' for s in suffix if s != s.lower()]

-MarianConfig
-~~~~~~~~~~~~~~~~~~~
-.. autoclass:: transformers.MarianConfig
-    :members:
-
-
-MarianTokenizer
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.MarianTokenizer
-    :members: prepare_translation_batch
-
-
 MarianMTModel
 ~~~~~~~~~~~~~

@@ -109,3 +96,10 @@ This class inherits all functionality from ``BartForConditionalGeneration``, see

 .. autoclass:: transformers.MarianMTModel
    :members:
+
+
+MarianTokenizer
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: transformers.MarianTokenizer
+    :members: prepare_translation_batch
@@ -1,9 +1,6 @@
 RoBERTa
 ----------------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The RoBERTa model was proposed in `RoBERTa: A Robustly Optimized BERT Pretraining Approach <https://arxiv.org/abs/1907.11692>`_
 by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer,
 Veselin Stoyanov. It is based on Google's BERT model released in 2018.
@@ -90,14 +87,6 @@ RobertaForTokenClassification
 .. autoclass:: transformers.RobertaForTokenClassification
    :members:

-
-RobertaForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.RobertaForQuestionAnswering
-    :members:
-
-
 TFRobertaModel
 ~~~~~~~~~~~~~~~~~~~~

@@ -119,22 +108,8 @@ TFRobertaForSequenceClassification
    :members:


-TFRobertaForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFRobertaForMultipleChoice
-    :members:
-
-
 TFRobertaForTokenClassification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. autoclass:: transformers.TFRobertaForTokenClassification
    :members:
-
-
-TFRobertaForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFRobertaForQuestionAnswering
-    :members:
@@ -4,8 +4,7 @@ T5
 file a `Github Issue <https://github.com/huggingface/transformers/issues/new?assignees=&labels=&template=bug-report.md&title>`_

 Overview
-~~~~~~~~~~~~~~~~~~~~~
-
+~~~~~
 The T5 model was presented in `Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer <https://arxiv.org/pdf/1910.10683.pdf>`_ by Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu in 
 Here the abstract: 

@@ -15,20 +14,10 @@ Our systematic study compares pre-training objectives, architectures, unlabeled
 By combining the insights from our exploration with scale and our new "Colossal Clean Crawled Corpus", we achieve state-of-the-art results on many benchmarks covering summarization, question answering, text classification, and more. 
 To facilitate future work on transfer learning for NLP, we release our dataset, pre-trained models, and code.*

-Tips:
-
- T5 is an encoder-decoder model pre-trained on a multi-task mixture of unsupervised 
-  and supervised tasks and for which each task is converted into a text-to-text format.
-  T5 works well on a variety of tasks out-of-the-box by prepending a different prefix to the input corresponding to each task, e.g.: for translation: *translate English to German: ..., summarize: ...*.
-  For more information about which prefix to use, it is easiest to look into Appendix D of the `paper <https://arxiv.org/pdf/1910.10683.pdf>`_ .
- For sequence to sequence generation, it is recommended to use ``T5ForConditionalGeneration.generate()``. The method takes care of feeding the encoded input via cross-attention layers to the decoder and auto-regressively generates the decoder output.
- T5 uses relative scalar embeddings. Encoder input padding can be done on the left and on the right.
-
-The original code can be found `here <https://github.com/google-research/text-to-text-transfer-transformer>`_.
+The Authors' code can be found `here <https://github.com/google-research/text-to-text-transfer-transformer>`_ .

 Training
-~~~~~~~~~~~~~~~~~~~~~
-
+~~~~~~~~~~~~~~~~~~~~
 T5 is an encoder-decoder model and converts all NLP problems into a text-to-text format. It is trained using teacher forcing.
 This means that for training we always need an input sequence and a target sequence. 
 The input sequence is fed to the model using ``input_ids``. The target sequence is shifted to the right, *i.e.* prepended by a start-sequence token and fed to the decoder using the `decoder_input_ids`. In teacher-forcing style, the target sequence is then appended by the EOS token and corresponds to the ``lm_labels``. The PAD token is hereby used as the start-sequence token.
@@ -61,6 +50,17 @@ T5 can be trained / fine-tuned both in a supervised and unsupervised fashion.
  # the forward function automatically creates the correct decoder_input_ids
  model(input_ids=input_ids, lm_labels=lm_labels)

+Tips
+~~~~~~~~~~~~~~~~~~~~
+- T5 is an encoder-decoder model pre-trained on a multi-task mixture of unsupervised 
+  and supervised tasks and for which each task is converted into a text-to-text format.
+  T5 works well on a variety of tasks out-of-the-box by prepending a different prefix to the input corresponding to each task, e.g.: for translation: *translate English to German: ..., summarize: ...*.
+  For more information about which prefix to use, it is easiest to look into Appendix D of the `paper <https://arxiv.org/pdf/1910.10683.pdf>`_ .
+- For sequence to sequence generation, it is recommended to use ``T5ForConditionalGeneration.generate()``. The method takes care of feeding the encoded input via cross-attention layers to the decoder and auto-regressively generates the decoder output.
+- T5 uses relative scalar embeddings. Encoder input padding can be done on the left and on the right.
+
+The original code can be found `here <https://github.com/google-research/text-to-text-transfer-transformer>`_.
+

 T5Config
 ~~~~~~~~~~~~~~~~~~~~~
@@ -99,7 +99,7 @@ TFT5Model


 TFT5ForConditionalGeneration
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. autoclass:: transformers.TFT5ForConditionalGeneration
    :members:
@@ -102,21 +102,6 @@ TFXLMForSequenceClassification
    :members:


-TFXLMForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLMForMultipleChoice
-    :members:
-
-
-TFXLMForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLMForTokenClassification
-    :members:
-
-
-
 TFXLMForQuestionAnsweringSimple
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -1,9 +1,6 @@
 XLM-RoBERTa
 ------------------------------------------

-Overview
-~~~~~~~~~~~~~~~~~~~~~
-
 The XLM-RoBERTa model was proposed in `Unsupervised Cross-lingual Representation Learning at Scale <https://arxiv.org/abs/1911.02116>`__
 by Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán,
 Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov. It is based on Facebook's RoBERTa model released in 2019.
@@ -84,13 +81,6 @@ XLMRobertaForTokenClassification
    :members:


-XLMRobertaForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.XLMRobertaForQuestionAnswering
-    :members:
-
-
 TFXLMRobertaModel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -112,22 +102,8 @@ TFXLMRobertaForSequenceClassification
    :members:


-TFXLMRobertaForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLMRobertaForMultipleChoice
-    :members:
-
-
 TFXLMRobertaForTokenClassification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. autoclass:: transformers.TFXLMRobertaForTokenClassification
    :members:
-
-
-TFXLMRobertaForQuestionAnswering
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLMRobertaForQuestionAnswering
-    :members:
@@ -71,13 +71,6 @@ XLNetForSequenceClassification
    :members:


-XLNetForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.XLNetForMultipleChoice
-    :members:
-
-
 XLNetForTokenClassification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -85,6 +78,13 @@ XLNetForTokenClassification
    :members:


+XLNetForMultipleChoice
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: transformers.XLNetForMultipleChoice
+    :members:
+
+
 XLNetForQuestionAnsweringSimple
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -120,20 +120,6 @@ TFXLNetForSequenceClassification
    :members:


-TFLNetForMultipleChoice
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLNetForMultipleChoice
-    :members:
-
-
-TFXLNetForTokenClassification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFXLNetForTokenClassification
-    :members:
-
-
 TFXLNetForQuestionAnsweringSimple
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

@@ -63,33 +63,33 @@ For a list that includes community-uploaded models, refer to `https://huggingfac
 |                   |                                                            | | Trained on uncased German text by DBMDZ                                                                                             |
 |                   |                                                            | (see `details on dbmdz repository <https://github.com/dbmdz/german-bert>`__).                                                         |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``cl-tohoku/bert-base-japanese``                           | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-japanese``                                     | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on Japanese text. Text is tokenized with MeCab and WordPiece.                                                               |
 |                   |                                                            | | `MeCab <https://taku910.github.io/mecab/>`__ is required for tokenization.                                                          |
 |                   |                                                            | (see `details on cl-tohoku repository <https://github.com/cl-tohoku/bert-japanese>`__).                                               |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``cl-tohoku/bert-base-japanese-whole-word-masking``        | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-japanese-whole-word-masking``                  | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on Japanese text using Whole-Word-Masking. Text is tokenized with MeCab and WordPiece.                                      |
 |                   |                                                            | | `MeCab <https://taku910.github.io/mecab/>`__ is required for tokenization.                                                          |
 |                   |                                                            | (see `details on cl-tohoku repository <https://github.com/cl-tohoku/bert-japanese>`__).                                               |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``cl-tohoku/bert-base-japanese-char``                      | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-japanese-char``                                | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on Japanese text. Text is tokenized into characters.                                                                        |
 |                   |                                                            | (see `details on cl-tohoku repository <https://github.com/cl-tohoku/bert-japanese>`__).                                               |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``cl-tohoku/bert-base-japanese-char-whole-word-masking``   | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-japanese-char-whole-word-masking``             | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on Japanese text using Whole-Word-Masking. Text is tokenized into characters.                                               |
 |                   |                                                            | (see `details on cl-tohoku repository <https://github.com/cl-tohoku/bert-japanese>`__).                                               |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``TurkuNLP/bert-base-finnish-cased-v1``                    | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-finnish-cased-v1``                             | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on cased Finnish text.                                                                                                      |
 |                   |                                                            | (see `details on turkunlp.org <http://turkunlp.org/FinBERT/>`__).                                                                     |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``TurkuNLP/bert-base-finnish-uncased-v1``                  | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-finnish-uncased-v1``                           | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on uncased Finnish text.                                                                                                    |
 |                   |                                                            | (see `details on turkunlp.org <http://turkunlp.org/FinBERT/>`__).                                                                     |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``wietsedv/bert-base-dutch-cased``                         | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
+|                   | ``bert-base-dutch-cased``                                  | | 12-layer, 768-hidden, 12-heads, 110M parameters.                                                                                    |
 |                   |                                                            | | Trained on cased Dutch text.                                                                                                        |
 |                   |                                                            | (see `details on wietsedv repository <https://github.com/wietsedv/bertje/>`__).                                                       |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
@@ -259,34 +259,32 @@ For a list that includes community-uploaded models, refer to `https://huggingfac
 |                   | ``xlm-roberta-large``                                      | | ~355M parameters with 24-layers, 1027-hidden-state, 4096 feed-forward hidden-state, 16-heads,                                       |
 |                   |                                                            | | Trained on 2.5 TB of newly created clean CommonCrawl data in 100 languages                                                          |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-| FlauBERT          | ``flaubert/flaubert_small_cased``                          | | 6-layer, 512-hidden, 8-heads, 54M parameters                                                                                        |
+| FlauBERT          | ``flaubert-small-cased``                                   | | 6-layer, 512-hidden, 8-heads, 54M parameters                                                                                        |
 |                   |                                                            | | FlauBERT small architecture                                                                                                         |
 |                   |                                                            | (see `details <https://github.com/getalp/Flaubert>`__)                                                                                |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``flaubert/flaubert_base_uncased``                         | | 12-layer, 768-hidden, 12-heads, 137M parameters                                                                                     |
+|                   | ``flaubert-base-uncased``                                  | | 12-layer, 768-hidden, 12-heads, 137M parameters                                                                                     |
 |                   |                                                            | | FlauBERT base architecture with uncased vocabulary                                                                                  |
 |                   |                                                            | (see `details <https://github.com/getalp/Flaubert>`__)                                                                                |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``flaubert/flaubert_base_cased``                           | | 12-layer, 768-hidden, 12-heads, 138M parameters                                                                                     |
+|                   | ``flaubert-base-cased``                                    | | 12-layer, 768-hidden, 12-heads, 138M parameters                                                                                     |
 |                   |                                                            | | FlauBERT base architecture with cased vocabulary                                                                                    |
 |                   |                                                            | (see `details <https://github.com/getalp/Flaubert>`__)                                                                                |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``flaubert/flaubert_large_cased``                          | | 24-layer, 1024-hidden, 16-heads, 373M parameters                                                                                    |
+|                   | ``flaubert-large-cased``                                   | | 24-layer, 1024-hidden, 16-heads, 373M parameters                                                                                    |
 |                   |                                                            | | FlauBERT large architecture                                                                                                         |
 |                   |                                                            | (see `details <https://github.com/getalp/Flaubert>`__)                                                                                |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-| Bart              | ``facebook/bart-large``                                    | | 24-layer, 1024-hidden, 16-heads, 406M parameters                                                                                    |
+| Bart              | ``bart-large``                                             | | 24-layer, 1024-hidden, 16-heads, 406M parameters                                                                                    |
 |                   |                                                            | (see `details <https://github.com/pytorch/fairseq/tree/master/examples/bart>`_)                                                       |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``facebook/bart-base``                                     | | 12-layer, 768-hidden, 16-heads, 139M parameters                                                                                     |
-|                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``facebook/bart-large-mnli``                               | | Adds a 2 layer classification head with 1 million parameters                                                                        |
+|                   | ``bart-large-mnli``                                        | | Adds a 2 layer classification head with 1 million parameters                                                                        |
 |                   |                                                            | | bart-large base architecture with a classification head, finetuned on MNLI                                                          |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``facebook/bart-large-cnn``                                | | 12-layer, 1024-hidden, 16-heads, 406M parameters       (same as base)                                                               |
+|                   | ``bart-large-cnn``                                         | | 12-layer, 1024-hidden, 16-heads, 406M parameters       (same as base)                                                               |
 |                   |                                                            | | bart-large base architecture finetuned on cnn summarization task                                                                    |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``facebook/mbart-large-en-ro``                             | | 12-layer, 1024-hidden, 16-heads, 880M parameters                                                                                    |
+|                   | ``mbart-large-en-ro``                                      | | 12-layer, 1024-hidden, 16-heads, 880M parameters                                                                                    |
 |                   |                                                            | | bart-large architecture pretrained on cc25 multilingual data , finetuned on WMT english romanian translation.                       |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
 | DialoGPT          | ``DialoGPT-small``                                         | | 12-layer, 768-hidden, 12-heads, 124M parameters                                                                                     |
@@ -307,9 +305,9 @@ For a list that includes community-uploaded models, refer to `https://huggingfac
 | MarianMT          | ``Helsinki-NLP/opus-mt-{src}-{tgt}``                       | | 12-layer, 512-hidden, 8-heads, ~74M parameter Machine translation models. Parameter counts vary depending on vocab size.            |
 |                   |                                                            | | (see `model list <https://huggingface.co/Helsinki-NLP>`_)                                                                           |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-| Longformer        | ``allenai/longformer-base-4096``                           | | 12-layer, 768-hidden, 12-heads, ~149M parameters                                                                                    |
+| Longformer        | ``longformer-base-4096``                                   | | 12-layer, 768-hidden, 12-heads, ~149M parameters                                                                                    |
 |                   |                                                            | | Starting from RoBERTa-base checkpoint, trained on documents of max length 4,096                                                     |
 |                   +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-|                   | ``allenai/longformer-large-4096``                          | | 24-layer, 1024-hidden, 16-heads, ~435M parameters                                                                                   |
+|                   | ``longformer-large-4096``                                  | | 24-layer, 1024-hidden, 16-heads, ~435M parameters                                                                                   |
 |                   |                                                            | | Starting from RoBERTa-large checkpoint, trained on documents of max length 4,096                                                    |
 +-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
@@ -1,618 +0,0 @@
-Summary of the models
-================================================
-
-This is a summary of the models available in the transformers library. It assumes you’re familiar with the original 
-`transformer model <https://arxiv.org/abs/1706.03762>`_. For a gentle introduction check the `annotated transformer 
-<http://nlp.seas.harvard.edu/2018/04/03/attention.html>`_. Here we focus on the high-level differences between the
-models. You can check them more in detail in their respective documentation. Also checkout the 
-:doc:`pretrained model page </pretrained_models>` to see the checkpoints available for each type of model and all `the 
-community models <https://huggingface.co/models>`_.
-
-Each one of the models in the library falls into one of the following categories:
-
-  * :ref:`autoregressive-models`
-  * :ref:`autoencoding-models`
-  * :ref:`seq-to-seq-models`
-  * :ref:`multimodal-models`
-
-Autoregressive models are pretrained on the classic language modeling task: guess the next token having read all the 
-previous ones. They correspond to the decoder of the original transformer model, and a mask is used on top of the full 
-sentence so that the attention heads can only see what was before in the next, and not what’s after. Although those 
-models can be fine-tuned and achieve great results on many tasks, the most natural application is text generation. 
-A typical example of such models is GPT.
-
-Autoencoding models are pretrained by corrupting the input tokens in some way and trying to reconstruct the original 
-sentence. They correspond to the encoder of the original transformer model in the sense that they get access to the 
-full inputs without any mask. Those models usually build a bidirectional representation of the whole sentence. They can 
-be fine-tuned and achieve great results on many tasks such as text generation, but their most natural application is 
-sentence classification or token classification. A typical example of such models is BERT.
-
-Note that the only difference between autoregressive models and autoencoding models is in the way the model is 
-pretrained. Therefore, the same architecture can be used for both autoregressive and autoencoding models. When a given
-model has been used for both pretraining, we have put it in the category corresponding to the article it was first
-introduced.
-
-Sequence-to-sequence models use both the encoder and the decoder of the original transformer, either for translation 
-tasks or by transforming other tasks to sequence-to-sequence problems. They can be fine-tuned to many tasks but their 
-most natural applications are translation, summarization and question answering. The original transformer model is an 
-example of such a model (only for translation), T5 is an example that can be fine-tuned on other tasks.
-
-Multimodal models mix text inputs with other kinds (like image) and are more specific to a given task.
-
-.. _autoregressive-models:
-
-Autoregressive models
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-As mentioned before, these models rely on the decoder part of the original transformer and use an attention mask so 
-that at each position, the model can only look at the tokens before in the attention heads.
-
-Original GPT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=openai-gpt">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-openai--gpt-blueviolet">
-   </a>
-   <a href="/model_doc/gpt">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-openai--gpt-blueviolet">
-   </a>
-
-`Improving Language Understanding by Generative Pre-Training <https://cdn.openai.com/research-covers/language-unsupervised/language_understanding_paper.pdf>`_, 
-Alec Radford et al.
-
-The first autoregressive model based on the transformer architecture, pretrained on the Book Corpus dataset.
-
-The library provides versions of the model for language modeling and multitask language modeling/multiple choice 
-classification.
-
-GPT-2
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=gpt2">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-gpt2-blueviolet">
-   </a>
-   <a href="/model_doc/gpt2">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-gpt2-blueviolet">
-   </a>
-
-`Language Models are Unsupervised Multitask Learners <https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf>`_, 
-Alec Radford et al.
-
-A bigger and better version of GPT, pretrained on WebText (web pages from outgoing links in Reddit with 3 karmas or 
-more).
-
-The library provides versions of the model for language modeling and multitask language modeling/multiple choice 
-classification.
-
-CTRL
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=ctrl">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-ctrl-blueviolet">
-   </a>
-   <a href="/model_doc/ctrl">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-ctrl-blueviolet">
-   </a>
-
-`CTRL: A Conditional Transformer Language Model for Controllable Generation <https://arxiv.org/abs/1909.05858>`_, 
-Nitish Shirish Keskar et al.
-
-Same as the GPT model but adds the idea of control codes. Text is generated from a prompt (can be empty) and one (or 
-several) of those control codes which are then used to influence the text generation: generate with the style of 
-wikipedia article, a book or a movie review.
-
-The library provides a version of the model for language modeling only.
-
-Transformer-XL
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=transfo-xl">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-transfo--xl-blueviolet">
-   </a>
-   <a href="/model_doc/transformerxl">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-transfo--xl-blueviolet">
-   </a>
-
-`Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context <https://arxiv.org/abs/1901.02860>`_, 
-Zihang Dai et al.
-
-Same as a regular GPT model, but introduces a recurrence mechanism for two consecutive segments (similar to a regular 
-RNNs with two consecutive inputs). In this context, a segment is a number of consecutive tokens (for instance 512) that 
-may span across multiple documents, and segments are fed in order to the model.
-
-Basically, the hidden states of the previous segment are concatenated to the current input to compute the attention 
-scores. This allows the model to pay attention to information that was in the previous segment as well as the current 
-one. By stacking multiple attention layers, the receptive field can be increased to multiple previous segments.
-
-This changes the positional embeddings to positional relative embeddings (as the regular positional embeddings would 
-give the same results in the current input and the current hidden state at a given position) and needs to make some 
-adjustments in the way attention scores are computed.
-
-The library provides a version of the model for language modeling only.
-
-.. _reformer:
-
-Reformer
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=reformer">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-reformer-blueviolet">
-   </a>
-   <a href="/model_doc/reformer">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-reformer-blueviolet">
-   </a>
-
-`Reformer: The Efficient Transformer <https://arxiv.org/abs/2001.04451>`_,
-Nikita Kitaev et al .
-
-An autoregressive transformer model with lots of tricks to reduce memory footprint and compute time. Those tricks 
-include:
-
-  * Use :ref:`Axial position encoding <axial-pos-encoding>` (see below for more details). It’s a mechanism to avoid 
-    having a huge positional encoding matrix (when the sequence length is very big) by factorizing it in smaller 
-    matrices.
-  * Replace traditional attention by :ref:`LSH (local-sensitive hashing) attention <lsh-attention>` (see below for more 
-    details). It's a technique to avoid compute the full product query-key in the attention layers.
-  * Avoid storing the intermediate results of each layer by using reversible transformer layers to obtain them during 
-    the backward pass (subtracting the residuals from the input of the next layer gives them back) or recomputing them 
-    for results inside a given layer (less efficient than storing them but saves memory).
-  * Compute the feedforward operations by chunks and not on the whole batch.
-
-With those tricks, the model can be fed much larger sentences than traditional transformer autoregressive models.
-
-**Note:** This model could be very well be used in an autoencoding setting, there is no checkpoint for such a
-pretraining yet, though.
-
-The library provides a version of the model for language modeling only.
-
-XLNet
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=xlnet">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-xlnet-blueviolet">
-   </a>
-   <a href="/model_doc/xlnet">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-xlnet-blueviolet">
-   </a>
-
-`XLNet: Generalized Autoregressive Pretraining for Language Understanding <https://arxiv.org/abs/1906.08237>`_,
-Zhilin Yang et al.
-
-XLNet is not a traditional autoregressive model but uses a training strategy that builds on that. It permutes the 
-tokens in the sentence, then allows the model to use the last n tokens to predict the token n+1. Since this is all done 
-with a mask, the sentence is actually fed in the model in the right order, but instead of masking the first n tokens 
-for n+1, XLNet uses a mask that hides the previous tokens in some given permutation of 1,...,sequence length.
-
-XLNet also uses the same recurrence mechanism as TransformerXL to build long-term dependencies. 
-
-The library provides a version of the model for language modeling, token classification, sentence classification, 
-multiple choice classification and question answering.
-
-.. _autoencoding-models:
-
-Autoencoding models
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-As mentioned before, these models rely on the encoder part of the original transformer and use no mask so the model can
-look at all the tokens in the attention heads. For pretraining, inputs are a corrupted version of the sentence, usually 
-obtained by masking tokens, and targets are the original sentences.
-
-BERT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=bert">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-bert-blueviolet">
-   </a>
-   <a href="/model_doc/bert">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-bert-blueviolet">
-   </a>
-
-`BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding <https://arxiv.org/abs/1810.04805>`_,
-Jacob Devlin et al.
-
-Corrupts the inputs by using random masking, more precisely, during pretraining, a given percentage of tokens (usually 
-15%) are masked by
- 
-  * a special mask token with probability 0.8
-  * a random token different from the one masked with probability 0.1
-  * the same token with probability 0.1
-
-The model must predict the original sentence, but has a second objective: inputs are two sentences A and B (with a 
-separation token in between). With probability 50%, the sentences are consecutive in the corpus, in the remaining 50% 
-they are not related. The model has to predict if the sentences are consecutive or not.
-
-The library provides a version of the model for language modeling (traditional or masked), next sentence prediction, 
-token classification, sentence classification, multiple choice classification and question answering.
-
-ALBERT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=albert">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-albert-blueviolet">
-   </a>
-   <a href="/model_doc/albert">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-albert-blueviolet">
-   </a>
-
-`ALBERT: A Lite BERT for Self-supervised Learning of Language Representations <https://arxiv.org/abs/1909.11942>`_,
-Zhenzhong Lan et al.
-
-Same as BERT but with a few tweaks:
-
-  * Embedding size E is different from hidden size H justified because the embeddings are context independent (one 
-    embedding vector represents one token) whereas hidden states are context dependent (one hidden state represents a 
-    sequence of tokens) so it's more logical to have H >> E. Als, the embedding matrix is large since it's V x E (V 
-    being the vocab size). If E < H, it has less parameters.
-  * Layers are split in groups that share parameters (to save memory).
-  * Next sentence prediction is replaced by a sentence ordering prediction: in the inputs, we have two sentences A et B 
-    (that are consecutive) and we either feed A followed by B or B followed by A. The model must predict if they have 
-    been swapped or not.
-
-The library provides a version of the model for masked language modeling, token classification, sentence 
-classification, multiple choice classification and question answering.
-
-RoBERTa
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=roberta">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-roberta-blueviolet">
-   </a>
-   <a href="/model_doc/roberta">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-roberta-blueviolet">
-   </a>
-
-`RoBERTa: A Robustly Optimized BERT Pretraining Approach <https://arxiv.org/abs/1907.11692>`_,
-Yinhan Liu et al.
-
-Same as BERT with better pretraining tricks:
-
-  * dynamic masking: tokens are masked differently at each epoch whereas BERT does it once and for all
-  * no NSP (next sentence prediction) loss and instead of putting just two sentences together, put a chunk of 
-    contiguous texts together to reach 512 tokens (so sentences in in an order than may span other several documents)
-  * train with larger batches
-  * use BPE with bytes as a subunit and not characters (because of unicode characters)
-
-The library provides a version of the model for masked language modeling, token classification, sentence 
-classification, multiple choice classification and question answering.
-
-DistilBERT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=distilbert">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-distilbert-blueviolet">
-   </a>
-   <a href="/model_doc/distilbert">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-distilbert-blueviolet">
-   </a>
-
-`DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter <https://arxiv.org/abs/1910.01108>`_,
-Victor Sanh et al.
-
-Same as BERT but smaller. Trained by distillation of the pretrained BERT model, meaning it's been trained to predict 
-the same probabilities as the larger model. The actual objective is a combination of:
-
-  * finding the same probabilities as the teacher model
-  * predicting the masked tokens correctly (but no next-sentence objective)
-  * a cosine similarity between the hidden states of the student and the teacher model
-
-The library provides a version of the model for masked language modeling, token classification, sentence classification 
-and question answering.
-
-XLM
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=xlm">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-xlm-blueviolet">
-   </a>
-   <a href="/model_doc/xlm">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-xlm-blueviolet">
-   </a>
-
-`Cross-lingual Language Model Pretraining <https://arxiv.org/abs/1901.07291>`_, Guillaume Lample and Alexis Conneau
-
-A transformer model trained on several languages. There are three different type of training for this model and the 
-library provides checkpoints for all of them:
-
-  * Causal language modeling (CLM) which is the traditional autoregressive training (so this model could be in the 
-    previous section as well). One of the languages is selected for each training sample, and the model input is a 
-    sentence of 256 tokens that may span on several documents in one one those languages.
-  * Masked language modeling (MLM) which is like RoBERTa. One of the languages is selected for each training sample, 
-    and the model input is a sentence of 256 tokens that may span on several documents in one one those languages, with
-    dynamic masking of the tokens.
-  * A combination of MLM and translation language modeling (TLM). This consists of concatenating a sentence in two 
-    different languages, with random masking. To predict one of the masked token, the model can use both the 
-    surrounding context in language 1 as well as the context given by language 2.
-
-Checkpoints refer to which method was used for pretraining by having `clm`, `mlm` or `mlm-tlm` in their names. On top
-of positional embeddings, the model has language embeddings. When training using MLM/CLM, this gives the model an
-indication of the language used, and when training using MLM+TLM, an indication of which part of the input is in which
-language.
-
-The library provides a version of the model for language modeling, token classification, sentence classification and 
-question answering.
-
-XLM-RoBERTa
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=xlm-roberta">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-xlm--roberta-blueviolet">
-   </a>
-   <a href="/model_doc/xlmroberta">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-xlm--roberta-blueviolet">
-   </a>
-
-`Unsupervised Cross-lingual Representation Learning at Scale <https://arxiv.org/abs/1911.02116>`_, Alexis Conneau et 
-al.
-
-Uses RoBERTa tricks on the XLM approach, but does not use the translation language modeling objective, only using 
-masked language modeling on sentences coming from one language. However, the model is trained on many more languages 
-(100) and doesn't use the language embeddings, so it's capable of detecting the input language by itself.
-
-The library provides a version of the model for masked language modeling, token classification, sentence 
-classification, multiple choice classification and question answering.
-
-FlauBERT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=flaubert">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-flaubert-blueviolet">
-   </a>
-   <a href="/model_doc/flaubert">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-flaubert-blueviolet">
-   </a>
-
-`FlauBERT: Unsupervised Language Model Pre-training for French <https://arxiv.org/abs/1912.05372>`_, Hang Le et al.
-
-Like RoBERTa, without the sentence ordering prediction (so just trained on the MLM objective).
-
-The library provides a version of the model for language modeling and sentence classification.
-
-ELECTRA
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=electra">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-electra-blueviolet">
-   </a>
-   <a href="/model_doc/electra">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-electra-blueviolet">
-   </a>
-
-`ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators <https://arxiv.org/abs/2003.10555>`_, 
-Kevin Clark et al.
-
-ELECTRA is a transformer model pretrained with the use of another (small) masked language model. The inputs are 
-corrupted by that language model, which takes an input text that is randomly masked and outputs a text in which ELECTRA 
-has to predict which token is an original and which one has been replaced. Like for GAN training, the small language 
-model is trained for a few steps (but with the original texts as objective, not to fool the ELECTRA model like in a 
-traditional GAN setting) then the ELECTRA model is trained for a few steps.
-
-The library provides a version of the model for masked language modeling, token classification and sentence 
-classification.
-
-.. _longformer:
-
-Longformer
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=longformer">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-longformer-blueviolet">
-   </a>
-   <a href="/model_doc/longformer">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-longformer-blueviolet">
-   </a>
-
-`Longformer: The Long-Document Transformer <https://arxiv.org/abs/2004.05150>`_, Iz Beltagy et al.
-
-A transformer model replacing the attention matrices by sparse matrices to go faster. Often, the local context (e.g., 
-what are the two tokens left and right?) is enough to take action for a given token. Some preselected input tokens are 
-still given global attention, but the attention matrix has way less parameters, resulting in a speed-up. See the 
-:ref:`local attention section <local-attention>` for more information.
-
-It is pretrained the same way a RoBERTa otherwise.
-
-**Note:** This model could be very well be used in an autoregressive setting, there is no checkpoint for such a
-pretraining yet, though.
-
-The library provides a version of the model for masked language modeling, token classification, sentence 
-classification, multiple choice classification and question answering.
-
-.. _seq-to-seq-models:
-
-Sequence-to-sequence models
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-As mentioned before, these models keep both the encoder and the decoder of the original transformer.
-
-BART
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=bart">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-bart-blueviolet">
-   </a>
-   <a href="/model_doc/bart">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-bart-blueviolet">
-   </a>
-
-`BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension 
-<https://arxiv.org/abs/1910.13461>`_, Mike Lewis et al.
-
-Sequence-to-sequence model with an encoder and a decoder. Encoder is fed a corrupted version of the tokens, decoder is 
-fed the tokens (but has a mask to hide the future words like a regular transformers decoder). For the encoder, on the 
-pretraining tasks, a composition of the following transformations are applied:
-
-  * mask random tokens (like in BERT)
-  * delete random tokens
-  * mask a span of k tokens with a single mask token (a span of 0 tokens is an insertion of a mask token)
-  * permute sentences
-  * rotate the document to make it start by a specific token
-
-The library provides a version of this model for conditional generation and sequence classification.
-
-MarianMT
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=marian">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-marian-blueviolet">
-   </a>
-   <a href="/model_doc/marian">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-marian-blueviolet">
-   </a>
-
-`Marian: Fast Neural Machine Translation in C++ <https://arxiv.org/abs/1804.00344>`_, Marcin Junczys-Dowmunt et al.
-
-A framework for translation models, using the same models as BART
-
-The library provides a version of this model for conditional generation.
-
-T5
----------------------------------------------
-
-.. raw:: html
-
-   <a href="https://huggingface.co/models?filter=t5">
-       <img alt="Models" src="https://img.shields.io/badge/All_model_pages-t5-blueviolet">
-   </a>
-   <a href="/model_doc/t5">
-       <img alt="Doc" src="https://img.shields.io/badge/Model_documentation-t5-blueviolet">
-   </a>
-
-`Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer <https://arxiv.org/abs/1910.10683>`_, 
-Colin Raffel et al.
-
-Uses the traditional transformer model (except a slight change with the positional embeddings, which are learned at 
-each layer). To be able to operate on all NLP tasks, it transforms them in text-to-text problems by using certain 
-prefixes: “Summarize: …”, “question: …”, “translate English to German: …” and so forth.
-
-The pretraining includes both supervised and self-supervised training. Supervised training is conducted on downstream 
-tasks provided by the GLUE and SuperGLUE benchmarks (changing them to text-to-text tasks as explained above).
-
-Self-supervised training consists of corrupted pretrained, which means randomly removing 15% of the tokens and 
-replacing them by individual sentinel tokens (if several consecutive tokens are marked for removal, they are replaced 
-by one single sentinel token). The input of the encoder is the corrupted sentence, the input of the decoder the 
-original sentence and the target is then the dropped out tokens delimited by their sentinel tokens.
-
-For instance, if we have the sentence “My dog is very cute .”, and we decide to remove the token dog, is and cute, the 
-input becomes “My <x> very <y> .” and the target is “<x> dog is <y> . <z>”
-
-The library provides a version of this model for conditional generation.
-
-.. _multimodal-models:
-
-Multimodal models
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-There is one multimodal model in the library which has not been pretrained in the self-supervised fashion like the 
-others.
-
-MMBT
----------------------------------------------
-
-`Supervised Multimodal Bitransformers for Classifying Images and Text <https://arxiv.org/abs/1909.02950>`_, Douwe Kiela 
-et al.
-
-A transformers model used in multimodal settings, combining a text and an image to make predictions. The transformer 
-model takes as inputs the embeddings of the tokenized text and a the final activations of a pretrained resnet on the 
-images (after the pooling layer) that goes through a linear layer (to go from number of features at the end of the 
-resnet to the hidden state dimension of the transformer).
-
-The different inputs are concatenated, and on top of the positional embeddings, a segment embedding is added to let the 
-model know which part of the input vector corresponds to the text or the image.
-
-The pretrained model only works for classification.
-
-..
-    More information in this :doc:`model documentation </model_doc/mmbt>`.
-    TODO: write this page
-
-More technical aspects
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Full vs sparse attention
----------------------------------------------
-
-Most transformer models use full attention in the sense that the attention matrix is square. It can be a big 
-computational bottleneck when you have long texts. Longformer and reformer are models that try to be more efficient and 
-use a sparse version of the attention matrix to speed up training.
-
-.. _lsh-attention:
-
-**LSH attention**
-
-:ref:`Reformer <reformer>` uses LSH attention. In the softmax(QK^t), only the biggest elements (in the softmax 
-dimension) of the matrix QK^t are going to give useful contributions. So for each query q in Q, we can only consider 
-the keys k in K that are close to q. A hash function is used to determine if q and k are close. The attention mask is 
-modified to mask the current token (except at the first position) because it will give a query and key equal (so very 
-similar to each other). Since the hash can be a bit random, several hash functions are used in practice (determined by 
-a n_rounds parameter) then are averaged together.
-
-.. _local-attention:
-
-**Local attention**
-
-:ref:`Longformer <longformer>` uses local attention: often, the local context (e.g., what are the two tokens left and 
-right?) is enough to take action for a given token. Also, by stacking attention layers that have a small window, the 
-last layer will have a receptive field of more than just the tokens on the window, allowing them to build a 
-representation of the whole sentence.
-
-Some preselected input tokens are also given global attention: for those few tokens, the attention matrix can access 
-all tokens and this process is symmetric: all other tokens have access to those specific tokens (on top of the ones in 
-their local window). This is shown in Figure 2d of the paper, see below for a sample attention mask:
-
-.. image:: imgs/local_attention_mask.png
-   :scale: 50 %
-   :align: center
-
-Using those attention matrices with less parameters then allows the model to have inputs having a bigger sequence 
-length.
-
-Other tricks
----------------------------------------------
-
-.. _axial-pos-encoding:
-
-**Axial positional encodings**
-
-:ref:`Reformer <reformer>` uses axial positional encodings: in traditional transformer models, the positional encoding 
-E is a matrix of size :math:`l` by :math:`d`, :math:`l` being the sequence length and :math:`d` the dimension of the 
-hidden state. If you have very long texts, this matrix can be huge and take way too much space on the GPU.
-
-To alleviate that, axial positional encodings consists in factorizing that big matrix E in two smaller matrices E1 and 
-E2, with dimensions :math:`l_{1} \times d_{1}` and :math:`l_{2} \times d_{2}`, such that :math:`l_{1} \times l_{2} = l`
-and :math:`d_{1} + d_{2} = d` (with the product for the lengths, this ends up being way smaller). The embedding for 
-time step :math:`j` in E is obtained by concatenating the embeddings for timestep :math:`j \% l1` in E1 and 
-:math:`j // l1` in E2.
-
@@ -1,7 +1,6 @@
 ## Examples

 Version 2.9 of `transformers` introduces a new [`Trainer`](https://github.com/huggingface/transformers/blob/master/src/transformers/trainer.py) class for PyTorch, and its equivalent [`TFTrainer`](https://github.com/huggingface/transformers/blob/master/src/transformers/trainer_tf.py) for TF 2.
-Running the examples requires PyTorch 1.3.1+ or TensorFlow 2.0+.

 Here is the list of all our examples:
 - **grouped by task** (all official examples work for multiple models)
@@ -22,7 +21,7 @@ This is still a work-in-progress – in particular documentation is still sparse
 | [**`token-classification`**](https://github.com/huggingface/transformers/tree/master/examples/token-classification) | CoNLL NER       | ✅ | ✅ | ✅ | -
 | [**`multiple-choice`**](https://github.com/huggingface/transformers/tree/master/examples/multiple-choice)           | SWAG, RACE, ARC | ✅ | ✅ | -  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ViktorAlm/notebooks/blob/master/MPC_GPU_Demo_for_TF_and_PT.ipynb)
 | [**`question-answering`**](https://github.com/huggingface/transformers/tree/master/examples/question-answering)     | SQuAD           | -  | ✅ | -  | -
-| [**`text-generation`**](https://github.com/huggingface/transformers/tree/master/examples/text-generation)           | -               | n/a | n/a | n/a | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/blog/blob/master/notebooks/02_how_to_generate.ipynb)
+| [**`text-generation`**](https://github.com/huggingface/transformers/tree/master/examples/text-generation)     | -           | -  | - | -  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/blog/blob/master/notebooks/02_how_to_generate.ipynb)
 | [**`distillation`**](https://github.com/huggingface/transformers/tree/master/examples/distillation)       | All               | -  | -  | -  | -
 | [**`summarization`**](https://github.com/huggingface/transformers/tree/master/examples/summarization)     | CNN/Daily Mail    | -  | -  | -  | -
 | [**`translation`**](https://github.com/huggingface/transformers/tree/master/examples/translation)         | WMT               | -  | -  | -  | -
@@ -11,7 +11,7 @@ export HANS_DIR=path-to-hans
 export MODEL_TYPE=type-of-the-model-e.g.-bert-roberta-xlnet-etc
 export MODEL_PATH=path-to-the-model-directory-that-is-trained-on-NLI-e.g.-by-using-run_glue.py

-python examples/adversarial/test_hans.py \
+python examples/hans/test_hans.py \
        --task_name hans \
        --model_type $MODEL_TYPE \
        --do_eval \
@@ -0,0 +1,221 @@
+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" GLUE processors and helpers """
+
+import logging
+import os
+
+from transformers.file_utils import is_tf_available
+from utils_hans import DataProcessor, InputExample, InputFeatures
+
+
+if is_tf_available():
+    import tensorflow as tf
+
+logger = logging.getLogger(__name__)
+
+
+def hans_convert_examples_to_features(
+    examples,
+    tokenizer,
+    max_length=512,
+    task=None,
+    label_list=None,
+    output_mode=None,
+    pad_on_left=False,
+    pad_token=0,
+    pad_token_segment_id=0,
+    mask_padding_with_zero=True,
+):
+    """
+    Loads a data file into a list of ``InputFeatures``
+
+    Args:
+        examples: List of ``InputExamples`` or ``tf.data.Dataset`` containing the examples.
+        tokenizer: Instance of a tokenizer that will tokenize the examples
+        max_length: Maximum example length
+        task: HANS
+        label_list: List of labels. Can be obtained from the processor using the ``processor.get_labels()`` method
+        output_mode: String indicating the output mode. Either ``regression`` or ``classification``
+        pad_on_left: If set to ``True``, the examples will be padded on the left rather than on the right (default)
+        pad_token: Padding token
+        pad_token_segment_id: The segment ID for the padding token (It is usually 0, but can vary such as for XLNet where it is 4)
+        mask_padding_with_zero: If set to ``True``, the attention mask will be filled by ``1`` for actual values
+            and by ``0`` for padded values. If set to ``False``, inverts it (``1`` for padded values, ``0`` for
+            actual values)
+
+    Returns:
+        If the ``examples`` input is a ``tf.data.Dataset``, will return a ``tf.data.Dataset``
+        containing the task-specific features. If the input is a list of ``InputExamples``, will return
+        a list of task-specific ``InputFeatures`` which can be fed to the model.
+
+    """
+    is_tf_dataset = False
+    if is_tf_available() and isinstance(examples, tf.data.Dataset):
+        is_tf_dataset = True
+
+    if task is not None:
+        processor = glue_processors[task]()
+        if label_list is None:
+            label_list = processor.get_labels()
+            logger.info("Using label list %s for task %s" % (label_list, task))
+        if output_mode is None:
+            output_mode = glue_output_modes[task]
+            logger.info("Using output mode %s for task %s" % (output_mode, task))
+
+    label_map = {label: i for i, label in enumerate(label_list)}
+
+    features = []
+    for (ex_index, example) in enumerate(examples):
+        if ex_index % 10000 == 0:
+            logger.info("Writing example %d" % (ex_index))
+        if is_tf_dataset:
+            example = processor.get_example_from_tensor_dict(example)
+            example = processor.tfds_map(example)
+
+        inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)
+        input_ids, token_type_ids = inputs["input_ids"], inputs["token_type_ids"]
+
+        # The mask has 1 for real tokens and 0 for padding tokens. Only real
+        # tokens are attended to.
+        attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)
+
+        # Zero-pad up to the sequence length.
+        padding_length = max_length - len(input_ids)
+        if pad_on_left:
+            input_ids = ([pad_token] * padding_length) + input_ids
+            attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
+            token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids
+        else:
+            input_ids = input_ids + ([pad_token] * padding_length)
+            attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)
+            token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)
+
+        assert len(input_ids) == max_length, "Error with input length {} vs {}".format(len(input_ids), max_length)
+        assert len(attention_mask) == max_length, "Error with input length {} vs {}".format(
+            len(attention_mask), max_length
+        )
+        assert len(token_type_ids) == max_length, "Error with input length {} vs {}".format(
+            len(token_type_ids), max_length
+        )
+
+        if output_mode == "classification":
+            label = label_map[example.label] if example.label in label_map else 0
+        elif output_mode == "regression":
+            label = float(example.label)
+        else:
+            raise KeyError(output_mode)
+        pairID = str(example.pairID)
+
+        if ex_index < 10:
+            logger.info("*** Example ***")
+            logger.info("text_a: %s" % (example.text_a))
+            logger.info("text_b: %s" % (example.text_b))
+            logger.info("guid: %s" % (example.guid))
+            logger.info("input_ids: %s" % " ".join([str(x) for x in input_ids]))
+            logger.info("attention_mask: %s" % " ".join([str(x) for x in attention_mask]))
+            logger.info("token_type_ids: %s" % " ".join([str(x) for x in token_type_ids]))
+            logger.info("label: %s (id = %d)" % (example.label, label))
+
+        features.append(
+            InputFeatures(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                token_type_ids=token_type_ids,
+                label=label,
+                pairID=pairID,
+            )
+        )
+
+    if is_tf_available() and is_tf_dataset:
+
+        def gen():
+            for ex in features:
+                yield (
+                    {
+                        "input_ids": ex.input_ids,
+                        "attention_mask": ex.attention_mask,
+                        "token_type_ids": ex.token_type_ids,
+                    },
+                    ex.label,
+                )
+
+        return tf.data.Dataset.from_generator(
+            gen,
+            ({"input_ids": tf.int32, "attention_mask": tf.int32, "token_type_ids": tf.int32}, tf.int64),
+            (
+                {
+                    "input_ids": tf.TensorShape([None]),
+                    "attention_mask": tf.TensorShape([None]),
+                    "token_type_ids": tf.TensorShape([None]),
+                },
+                tf.TensorShape([]),
+            ),
+        )
+
+    return features
+
+
+class HansProcessor(DataProcessor):
+    """Processor for the HANS data set."""
+
+    def get_example_from_tensor_dict(self, tensor_dict):
+        """See base class."""
+        return InputExample(
+            tensor_dict["idx"].numpy(),
+            tensor_dict["premise"].numpy().decode("utf-8"),
+            tensor_dict["hypothesis"].numpy().decode("utf-8"),
+            str(tensor_dict["label"].numpy()),
+        )
+
+    def get_train_examples(self, data_dir):
+        """See base class."""
+        return self._create_examples(self._read_tsv(os.path.join(data_dir, "heuristics_train_set.txt")), "train")
+
+    def get_dev_examples(self, data_dir):
+        """See base class."""
+        return self._create_examples(self._read_tsv(os.path.join(data_dir, "heuristics_evaluation_set.txt")), "dev")
+
+    def get_labels(self):
+        """See base class."""
+        return ["contradiction", "entailment", "neutral"]
+
+    def _create_examples(self, lines, set_type):
+        """Creates examples for the training and dev sets."""
+        examples = []
+        for (i, line) in enumerate(lines):
+            if i == 0:
+                continue
+            guid = "%s-%s" % (set_type, line[0])
+            text_a = line[5]
+            text_b = line[6]
+            pairID = line[7][2:] if line[7].startswith("ex") else line[7]
+            label = line[-1]
+            examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))
+        return examples
+
+
+glue_tasks_num_labels = {
+    "hans": 3,
+}
+
+glue_processors = {
+    "hans": HansProcessor,
+}
+
+glue_output_modes = {
+    "hans": "classification",
+}
@@ -25,10 +25,13 @@ import random

 import numpy as np
 import torch
-from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
+from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
 from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange

+from hans_processors import glue_output_modes as output_modes
+from hans_processors import glue_processors as processors
+from hans_processors import hans_convert_examples_to_features as convert_examples_to_features
 from transformers import (
    WEIGHTS_NAME,
    AdamW,
@@ -50,10 +53,8 @@ from transformers import (
    XLNetConfig,
    XLNetForSequenceClassification,
    XLNetTokenizer,
-    default_data_collator,
    get_linear_schedule_with_warmup,
 )
-from utils_hans import HansDataset, hans_output_modes, hans_processors


 try:
@@ -64,6 +65,13 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum(
+    (
+        tuple(conf.pretrained_config_archive_map.keys())
+        for conf in (BertConfig, XLNetConfig, XLMConfig, RobertaConfig, DistilBertConfig)
+    ),
+    (),
+)

 MODEL_CLASSES = {
    "bert": (BertConfig, BertForSequenceClassification, BertTokenizer),
@@ -90,9 +98,7 @@ def train(args, train_dataset, model, tokenizer):

    args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
    train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
-    train_dataloader = DataLoader(
-        train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, collate_fn=default_data_collator,
-    )
+    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size)

    if args.max_steps > 0:
        t_total = args.max_steps
@@ -154,7 +160,12 @@ def train(args, train_dataset, model, tokenizer):
        epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=args.local_rank not in [-1, 0])
        for step, batch in enumerate(epoch_iterator):
            model.train()
-            inputs = {k: t.to(args.device) for k, t in batch.items() if k != "pairID"}
+            batch = tuple(t.to(args.device) for t in batch)
+            inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
+            if args.model_type != "distilbert":
+                inputs["token_type_ids"] = (
+                    batch[2] if args.model_type in ["bert", "xlnet"] else None
+                )  # XLM, DistilBERT and RoBERTa don't use segment_ids
            outputs = model(**inputs)
            loss = outputs[0]  # model outputs are always tuple in transformers (see doc)

@@ -226,21 +237,14 @@ def train(args, train_dataset, model, tokenizer):
    return global_step, tr_loss / global_step


-def evaluate(args, model, tokenizer, label_list, prefix=""):
+def evaluate(args, model, tokenizer, prefix=""):
    # Loop to handle MNLI double evaluation (matched, mis-matched)
    eval_task_names = ("mnli", "mnli-mm") if args.task_name == "mnli" else (args.task_name,)
    eval_outputs_dirs = (args.output_dir, args.output_dir + "-MM") if args.task_name == "mnli" else (args.output_dir,)

    results = {}
    for eval_task, eval_output_dir in zip(eval_task_names, eval_outputs_dirs):
-        eval_dataset = HansDataset(
-            args.data_dir,
-            tokenizer,
-            args.task_name,
-            args.max_seq_length,
-            overwrite_cache=args.overwrite_cache,
-            evaluate=True,
-        )
+        eval_dataset, label_list = load_and_cache_examples(args, eval_task, tokenizer, evaluate=True)

        if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
            os.makedirs(eval_output_dir)
@@ -248,9 +252,7 @@ def evaluate(args, model, tokenizer, label_list, prefix=""):
        args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
        # Note that DistributedSampler samples randomly
        eval_sampler = SequentialSampler(eval_dataset)
-        eval_dataloader = DataLoader(
-            eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size, collate_fn=default_data_collator,
-        )
+        eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)

        # multi-gpu eval
        if args.n_gpu > 1 and not isinstance(model, torch.nn.DataParallel):
@@ -266,9 +268,14 @@ def evaluate(args, model, tokenizer, label_list, prefix=""):
        out_label_ids = None
        for batch in tqdm(eval_dataloader, desc="Evaluating"):
            model.eval()
-            inputs = {k: t.to(args.device) for k, t in batch.items() if k != "pairID"}
-            pair_ids = batch.pop("pairID", None)
+            batch = tuple(t.to(args.device) for t in batch)
+
            with torch.no_grad():
+                inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
+                if args.model_type != "distilbert":
+                    inputs["token_type_ids"] = (
+                        batch[2] if args.model_type in ["bert", "xlnet"] else None
+                    )  # XLM, DistilBERT and RoBERTa don't use segment_ids
                outputs = model(**inputs)
                tmp_eval_loss, logits = outputs[:2]

@@ -277,11 +284,11 @@ def evaluate(args, model, tokenizer, label_list, prefix=""):
            if preds is None:
                preds = logits.detach().cpu().numpy()
                out_label_ids = inputs["labels"].detach().cpu().numpy()
-                pair_ids = pair_ids.detach().cpu().numpy()
+                pair_ids = batch[4].detach().cpu().numpy()
            else:
                preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)
                out_label_ids = np.append(out_label_ids, inputs["labels"].detach().cpu().numpy(), axis=0)
-                pair_ids = np.append(pair_ids, pair_ids.detach().cpu().numpy(), axis=0)
+                pair_ids = np.append(pair_ids, batch[4].detach().cpu().numpy(), axis=0)

        eval_loss = eval_loss / nb_eval_steps
        if args.output_mode == "classification":
@@ -298,6 +305,67 @@ def evaluate(args, model, tokenizer, label_list, prefix=""):
    return results


+def load_and_cache_examples(args, task, tokenizer, evaluate=False):
+    if args.local_rank not in [-1, 0] and not evaluate:
+        torch.distributed.barrier()  # Make sure only the first process in distributed training process the dataset, and the others will use the cache
+
+    processor = processors[task]()
+    output_mode = output_modes[task]
+    # Load data features from cache or dataset file
+    cached_features_file = os.path.join(
+        args.data_dir,
+        "cached_{}_{}_{}_{}".format(
+            "dev" if evaluate else "train",
+            list(filter(None, args.model_name_or_path.split("/"))).pop(),
+            str(args.max_seq_length),
+            str(task),
+        ),
+    )
+
+    label_list = processor.get_labels()
+
+    if os.path.exists(cached_features_file) and not args.overwrite_cache:
+        logger.info("Loading features from cached file %s", cached_features_file)
+        features = torch.load(cached_features_file)
+    else:
+        logger.info("Creating features from dataset file at %s", args.data_dir)
+        if task in ["mnli", "mnli-mm"] and args.model_type in ["roberta"]:
+            # HACK(label indices are swapped in RoBERTa pretrained model)
+            label_list[1], label_list[2] = label_list[2], label_list[1]
+        examples = (
+            processor.get_dev_examples(args.data_dir) if evaluate else processor.get_train_examples(args.data_dir)
+        )
+        features = convert_examples_to_features(
+            examples,
+            tokenizer,
+            label_list=label_list,
+            max_length=args.max_seq_length,
+            output_mode=output_mode,
+            pad_on_left=bool(args.model_type in ["xlnet"]),  # pad on the left for xlnet
+            pad_token=tokenizer.pad_token_id,
+            pad_token_segment_id=tokenizer.pad_token_type_id,
+        )
+        if args.local_rank in [-1, 0]:
+            logger.info("Saving features into cached file %s", cached_features_file)
+            torch.save(features, cached_features_file)
+
+    if args.local_rank == 0 and not evaluate:
+        torch.distributed.barrier()  # Make sure only the first process in distributed training process the dataset, and the others will use the cache
+
+    # Convert to Tensors and build dataset
+    all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)
+    all_attention_mask = torch.tensor([f.attention_mask for f in features], dtype=torch.long)
+    all_token_type_ids = torch.tensor([f.token_type_ids for f in features], dtype=torch.long)
+    if output_mode == "classification":
+        all_labels = torch.tensor([f.label for f in features], dtype=torch.long)
+    elif output_mode == "regression":
+        all_labels = torch.tensor([f.label for f in features], dtype=torch.float)
+    all_pair_ids = torch.tensor([int(f.pairID) for f in features], dtype=torch.long)
+
+    dataset = TensorDataset(all_input_ids, all_attention_mask, all_token_type_ids, all_labels, all_pair_ids)
+    return dataset, label_list
+
+
 def main():
    parser = argparse.ArgumentParser()

@@ -321,14 +389,14 @@ def main():
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--task_name",
        default=None,
        type=str,
        required=True,
-        help="The name of the task to train selected in the list: " + ", ".join(hans_processors.keys()),
+        help="The name of the task to train selected in the list: " + ", ".join(processors.keys()),
    )
    parser.add_argument(
        "--output_dir",
@@ -480,10 +548,10 @@ def main():

    # Prepare GLUE task
    args.task_name = args.task_name.lower()
-    if args.task_name not in hans_processors:
+    if args.task_name not in processors:
        raise ValueError("Task not found: %s" % (args.task_name))
-    processor = hans_processors[args.task_name]()
-    args.output_mode = hans_output_modes[args.task_name]
+    processor = processors[args.task_name]()
+    args.output_mode = output_modes[args.task_name]
    label_list = processor.get_labels()
    num_labels = len(label_list)

@@ -520,9 +588,7 @@ def main():

    # Training
    if args.do_train:
-        train_dataset = HansDataset(
-            args.data_dir, tokenizer, args.task_name, args.max_seq_length, overwrite_cache=args.overwrite_cache
-        )
+        train_dataset, _ = load_and_cache_examples(args, args.task_name, tokenizer, evaluate=False)
        global_step, tr_loss = train(args, train_dataset, model, tokenizer)
        logger.info(" global_step = %s, average loss = %s", global_step, tr_loss)

@@ -566,7 +632,7 @@ def main():

            model = model_class.from_pretrained(checkpoint)
            model.to(args.device)
-            result = evaluate(args, model, tokenizer, label_list, prefix=prefix)
+            result = evaluate(args, model, tokenizer, prefix=prefix)
            result = dict((k + "_{}".format(global_step), v) for k, v in result.items())
            results.update(result)

@@ -14,339 +14,108 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-import logging
-import os
-from dataclasses import dataclass
-from typing import List, Optional, Union
-
-import tqdm
-from filelock import FileLock
-
-from transformers import (
-    DataProcessor,
-    PreTrainedTokenizer,
-    RobertaTokenizer,
-    RobertaTokenizerFast,
-    XLMRobertaTokenizer,
-    is_tf_available,
-    is_torch_available,
-)
+import copy
+import csv
+import json


-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class InputExample:
+class InputExample(object):
    """
    A single training/test example for simple sequence classification.

    Args:
        guid: Unique id for the example.
        text_a: string. The untokenized text of the first sequence. For single
-            sequence tasks, only this sequence must be specified.
+        sequence tasks, only this sequence must be specified.
        text_b: (Optional) string. The untokenized text of the second sequence.
-            Only must be specified for sequence pair tasks.
+        Only must be specified for sequence pair tasks.
        label: (Optional) string. The label of the example. This should be
-            specified for train and dev examples, but not for test examples.
-        pairID: (Optional) string. Unique identifier for the pair of sentences.
+        specified for train and dev examples, but not for test examples.
    """

-    guid: str
-    text_a: str
-    text_b: Optional[str] = None
-    label: Optional[str] = None
-    pairID: Optional[str] = None
+    def __init__(self, guid, text_a, text_b=None, label=None, pairID=None):
+        self.guid = guid
+        self.text_a = text_a
+        self.text_b = text_b
+        self.label = label
+        self.pairID = pairID
+
+    def __repr__(self):
+        return str(self.to_json_string())
+
+    def to_dict(self):
+        """Serializes this instance to a Python dictionary."""
+        output = copy.deepcopy(self.__dict__)
+        return output
+
+    def to_json_string(self):
+        """Serializes this instance to a JSON string."""
+        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"


-@dataclass(frozen=True)
-class InputFeatures:
+class InputFeatures(object):
    """
    A single set of features of data.
-    Property names are the same names as the corresponding inputs to a model.

    Args:
        input_ids: Indices of input sequence tokens in the vocabulary.
        attention_mask: Mask to avoid performing attention on padding token indices.
            Mask values selected in ``[0, 1]``:
            Usually  ``1`` for tokens that are NOT MASKED, ``0`` for MASKED (padded) tokens.
-        token_type_ids: (Optional) Segment token indices to indicate first and second
-            portions of the inputs. Only some models use them.
-        label: (Optional) Label corresponding to the input. Int for classification problems,
-            float for regression problems.
-        pairID: (Optional) Unique identifier for the pair of sentences.
+        token_type_ids: Segment token indices to indicate first and second portions of the inputs.
+        label: Label corresponding to the input
    """

-    input_ids: List[int]
-    attention_mask: Optional[List[int]] = None
-    token_type_ids: Optional[List[int]] = None
-    label: Optional[Union[int, float]] = None
-    pairID: Optional[int] = None
+    def __init__(self, input_ids, attention_mask, token_type_ids, label, pairID=None):
+        self.input_ids = input_ids
+        self.attention_mask = attention_mask
+        self.token_type_ids = token_type_ids
+        self.label = label
+        self.pairID = pairID
+
+    def __repr__(self):
+        return str(self.to_json_string())
+
+    def to_dict(self):
+        """Serializes this instance to a Python dictionary."""
+        output = copy.deepcopy(self.__dict__)
+        return output
+
+    def to_json_string(self):
+        """Serializes this instance to a JSON string."""
+        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"


-if is_torch_available():
-    import torch
-    from torch.utils.data.dataset import Dataset
-
-    class HansDataset(Dataset):
-        """
-        This will be superseded by a framework-agnostic approach
-        soon.
-        """
-
-        features: List[InputFeatures]
-
-        def __init__(
-            self,
-            data_dir: str,
-            tokenizer: PreTrainedTokenizer,
-            task: str,
-            max_seq_length: Optional[int] = None,
-            overwrite_cache=False,
-            evaluate: bool = False,
-        ):
-            processor = hans_processors[task]()
-            output_mode = hans_output_modes[task]
-
-            cached_features_file = os.path.join(
-                data_dir,
-                "cached_{}_{}_{}_{}".format(
-                    "dev" if evaluate else "train", tokenizer.__class__.__name__, str(max_seq_length), task,
-                ),
-            )
-
-            # Make sure only the first process in distributed training processes the dataset,
-            # and the others will use the cache.
-            lock_path = cached_features_file + ".lock"
-            with FileLock(lock_path):
-
-                if os.path.exists(cached_features_file) and not overwrite_cache:
-                    logger.info(f"Loading features from cached file {cached_features_file}")
-                    self.features = torch.load(cached_features_file)
-                else:
-                    logger.info(f"Creating features from dataset file at {data_dir}")
-                    label_list = processor.get_labels()
-
-                    if task in ["mnli", "mnli-mm"] and tokenizer.__class__ in (
-                        RobertaTokenizer,
-                        RobertaTokenizerFast,
-                        XLMRobertaTokenizer,
-                    ):
-                        # HACK(label indices are swapped in RoBERTa pretrained model)
-                        label_list[1], label_list[2] = label_list[2], label_list[1]
-                    examples = (
-                        processor.get_dev_examples(data_dir) if evaluate else processor.get_train_examples(data_dir)
-                    )
-
-                    logger.info("Training examples: %s", len(examples))
-                    # TODO clean up all this to leverage built-in features of tokenizers
-                    self.features = hans_convert_examples_to_features(
-                        examples, label_list, max_seq_length, tokenizer, output_mode
-                    )
-                    logger.info("Saving features into cached file %s", cached_features_file)
-                    torch.save(self.features, cached_features_file)
-
-        def __len__(self):
-            return len(self.features)
-
-        def __getitem__(self, i) -> InputFeatures:
-            return self.features[i]
-
-
-if is_tf_available():
-    import tensorflow as tf
-
-    class TFHansDataset:
-        """
-        This will be superseded by a framework-agnostic approach
-        soon.
-        """
-
-        features: List[InputFeatures]
-
-        def __init__(
-            self,
-            data_dir: str,
-            tokenizer: PreTrainedTokenizer,
-            task: str,
-            max_seq_length: Optional[int] = 128,
-            overwrite_cache=False,
-            evaluate: bool = False,
-        ):
-            processor = hans_processors[task]()
-            output_mode = hans_output_modes[task]
-            label_list = processor.get_labels()
-
-            if task in ["mnli", "mnli-mm"] and tokenizer.__class__ in (
-                RobertaTokenizer,
-                RobertaTokenizerFast,
-                XLMRobertaTokenizer,
-            ):
-                # HACK(label indices are swapped in RoBERTa pretrained model)
-                label_list[1], label_list[2] = label_list[2], label_list[1]
-
-            examples = processor.get_dev_examples(data_dir) if evaluate else processor.get_train_examples(data_dir)
-            self.features = hans_convert_examples_to_features(
-                examples, label_list, max_seq_length, tokenizer, output_mode
-            )
-
-            def gen():
-                for (ex_index, ex) in tqdm.tqdm(enumerate(self.features), desc="convert examples to features"):
-                    if ex_index % 10000 == 0:
-                        logger.info("Writing example %d of %d" % (ex_index, len(examples)))
-
-                    yield (
-                        {
-                            "example_id": 0,
-                            "input_ids": ex.input_ids,
-                            "attention_mask": ex.attention_mask,
-                            "token_type_ids": ex.token_type_ids,
-                        },
-                        ex.label,
-                    )
-
-            self.dataset = tf.data.Dataset.from_generator(
-                gen,
-                (
-                    {
-                        "example_id": tf.int32,
-                        "input_ids": tf.int32,
-                        "attention_mask": tf.int32,
-                        "token_type_ids": tf.int32,
-                    },
-                    tf.int64,
-                ),
-                (
-                    {
-                        "example_id": tf.TensorShape([]),
-                        "input_ids": tf.TensorShape([None, None]),
-                        "attention_mask": tf.TensorShape([None, None]),
-                        "token_type_ids": tf.TensorShape([None, None]),
-                    },
-                    tf.TensorShape([]),
-                ),
-            )
-
-        def get_dataset(self):
-            return self.dataset
-
-        def __len__(self):
-            return len(self.features)
-
-        def __getitem__(self, i) -> InputFeatures:
-            return self.features[i]
-
-
-class HansProcessor(DataProcessor):
-    """Processor for the HANS data set."""
+class DataProcessor(object):
+    """Base class for data converters for sequence classification data sets."""

    def get_example_from_tensor_dict(self, tensor_dict):
-        """See base class."""
-        return InputExample(
-            tensor_dict["idx"].numpy(),
-            tensor_dict["premise"].numpy().decode("utf-8"),
-            tensor_dict["hypothesis"].numpy().decode("utf-8"),
-            str(tensor_dict["label"].numpy()),
-        )
+        """Gets an example from a dict with tensorflow tensors
+
+        Args:
+            tensor_dict: Keys and values should match the corresponding Glue
+                tensorflow_dataset examples.
+        """
+        raise NotImplementedError()

    def get_train_examples(self, data_dir):
-        """See base class."""
-        return self._create_examples(self._read_tsv(os.path.join(data_dir, "heuristics_train_set.txt")), "train")
+        """Gets a collection of `InputExample`s for the train set."""
+        raise NotImplementedError()

    def get_dev_examples(self, data_dir):
-        """See base class."""
-        return self._create_examples(self._read_tsv(os.path.join(data_dir, "heuristics_evaluation_set.txt")), "dev")
+        """Gets a collection of `InputExample`s for the dev set."""
+        raise NotImplementedError()

    def get_labels(self):
-        """See base class."""
-        return ["contradiction", "entailment", "neutral"]
+        """Gets the list of labels for this data set."""
+        raise NotImplementedError()

-    def _create_examples(self, lines, set_type):
-        """Creates examples for the training and dev sets."""
-        examples = []
-        for (i, line) in enumerate(lines):
-            if i == 0:
-                continue
-            guid = "%s-%s" % (set_type, line[0])
-            text_a = line[5]
-            text_b = line[6]
-            pairID = line[7][2:] if line[7].startswith("ex") else line[7]
-            label = line[-1]
-            examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))
-        return examples
-
-
-def hans_convert_examples_to_features(
-    examples: List[InputExample],
-    label_list: List[str],
-    max_length: int,
-    tokenizer: PreTrainedTokenizer,
-    output_mode: str,
-):
-    """
-    Loads a data file into a list of ``InputFeatures``
-
-    Args:
-        examples: List of ``InputExamples`` containing the examples.
-        tokenizer: Instance of a tokenizer that will tokenize the examples.
-        max_length: Maximum example length.
-        label_list: List of labels. Can be obtained from the processor using the ``processor.get_labels()`` method.
-        output_mode: String indicating the output mode. Either ``regression`` or ``classification``.
-
-    Returns:
-        A list of task-specific ``InputFeatures`` which can be fed to the model.
-
-    """
-
-    label_map = {label: i for i, label in enumerate(label_list)}
-
-    features = []
-    for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc="convert examples to features"):
-        if ex_index % 10000 == 0:
-            logger.info("Writing example %d" % (ex_index))
-
-        inputs = tokenizer.encode_plus(
-            example.text_a,
-            example.text_b,
-            add_special_tokens=True,
-            max_length=max_length,
-            pad_to_max_length=True,
-            return_overflowing_tokens=True,
-        )
-        if "num_truncated_tokens" in inputs and inputs["num_truncated_tokens"] > 0:
-            logger.info(
-                "Attention! you are cropping tokens (swag task is ok). "
-                "If you are training ARC and RACE and you are poping question + options,"
-                "you need to try to use a bigger max seq length!"
-            )
-
-        if output_mode == "classification":
-            label = label_map[example.label] if example.label in label_map else 0
-        elif output_mode == "regression":
-            label = float(example.label)
-        else:
-            raise KeyError(output_mode)
-
-        pairID = int(example.pairID)
-
-        features.append(InputFeatures(**inputs, label=label, pairID=pairID))
-
-    for i, example in enumerate(examples[:5]):
-        logger.info("*** Example ***")
-        logger.info(f"guid: {example}")
-        logger.info(f"features: {features[i]}")
-
-    return features
-
-
-hans_tasks_num_labels = {
-    "hans": 3,
-}
-
-hans_processors = {
-    "hans": HansProcessor,
-}
-
-hans_output_modes = {
-    "hans": "classification",
-}
+    @classmethod
+    def _read_tsv(cls, input_file, quotechar=None):
+        """Reads a tab separated value file."""
+        with open(input_file, "r", encoding="utf-8-sig") as f:
+            reader = csv.reader(f, delimiter="\t", quotechar=quotechar)
+            lines = []
+            for line in reader:
+                lines.append(line)
+            return lines
@@ -3,9 +3,9 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import Optional

-import matplotlib.pyplot as plt
 import numpy as np

+import matplotlib.pyplot as plt
 from transformers import HfArgumentParser


@@ -34,8 +34,8 @@ from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
+    DefaultDataCollator,
    GlueDataset,
-    default_data_collator,
    glue_compute_metrics,
    glue_output_modes,
    glue_processors,
@@ -424,7 +424,7 @@ def main():
        eval_dataset = Subset(eval_dataset, list(range(min(args.data_subset, len(eval_dataset)))))
    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
    eval_dataloader = DataLoader(
-        eval_dataset, sampler=eval_sampler, batch_size=args.batch_size, collate_fn=default_data_collator
+        eval_dataset, sampler=eval_sampler, batch_size=args.batch_size, collate_fn=DefaultDataCollator().collate_batch
    )

    # Compute head entropy and importance score
@@ -34,11 +34,26 @@ from tqdm import tqdm, trange
 from transformers import (
    WEIGHTS_NAME,
    AdamW,
-    AutoConfig,
-    AutoModel,
-    AutoTokenizer,
+    AlbertConfig,
+    AlbertModel,
+    AlbertTokenizer,
+    BertConfig,
+    BertModel,
+    BertTokenizer,
+    DistilBertConfig,
+    DistilBertModel,
+    DistilBertTokenizer,
    MMBTConfig,
    MMBTForClassification,
+    RobertaConfig,
+    RobertaModel,
+    RobertaTokenizer,
+    XLMConfig,
+    XLMModel,
+    XLMTokenizer,
+    XLNetConfig,
+    XLNetModel,
+    XLNetTokenizer,
    get_linear_schedule_with_warmup,
 )
 from utils_mmimdb import ImageEncoder, JsonlDataset, collate_fn, get_image_transforms, get_mmimdb_labels
@@ -52,6 +67,23 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum(
+    (
+        tuple(conf.pretrained_config_archive_map.keys())
+        for conf in (BertConfig, XLNetConfig, XLMConfig, RobertaConfig, DistilBertConfig)
+    ),
+    (),
+)
+
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertModel, BertTokenizer),
+    "xlnet": (XLNetConfig, XLNetModel, XLNetTokenizer),
+    "xlm": (XLMConfig, XLMModel, XLMTokenizer),
+    "roberta": (RobertaConfig, RobertaModel, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertModel, DistilBertTokenizer),
+    "albert": (AlbertConfig, AlbertModel, AlbertTokenizer),
+}
+

 def set_seed(args):
    random.seed(args.seed)
@@ -319,12 +351,19 @@ def main():
        required=True,
        help="The input data dir. Should contain the .jsonl files for MMIMDB.",
    )
+    parser.add_argument(
+        "--model_type",
+        default=None,
+        type=str,
+        required=True,
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
+    )
    parser.add_argument(
        "--model_name_or_path",
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--output_dir",
@@ -346,7 +385,7 @@ def main():
    )
    parser.add_argument(
        "--cache_dir",
-        default=None,
+        default="",
        type=str,
        help="Where do you want to store the pre-trained models downloaded from s3",
    )
@@ -487,14 +526,18 @@ def main():
    # Setup model
    labels = get_mmimdb_labels()
    num_labels = len(labels)
-    transformer_config = AutoConfig.from_pretrained(args.config_name if args.config_name else args.model_name_or_path)
-    tokenizer = AutoTokenizer.from_pretrained(
+    args.model_type = args.model_type.lower()
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    transformer_config = config_class.from_pretrained(
+        args.config_name if args.config_name else args.model_name_or_path
+    )
+    tokenizer = tokenizer_class.from_pretrained(
        args.tokenizer_name if args.tokenizer_name else args.model_name_or_path,
        do_lower_case=args.do_lower_case,
-        cache_dir=args.cache_dir,
+        cache_dir=args.cache_dir if args.cache_dir else None,
    )
-    transformer = AutoModel.from_pretrained(
-        args.model_name_or_path, config=transformer_config, cache_dir=args.cache_dir
+    transformer = model_class.from_pretrained(
+        args.model_name_or_path, config=transformer_config, cache_dir=args.cache_dir if args.cache_dir else None
    )
    img_encoder = ImageEncoder(args)
    config = MMBTConfig(transformer_config, num_labels=num_labels)
@@ -540,12 +583,13 @@ def main():
        # Load a trained model and vocabulary that you have fine-tuned
        model = MMBTForClassification(config, transformer, img_encoder)
        model.load_state_dict(torch.load(os.path.join(args.output_dir, WEIGHTS_NAME)))
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir)
        model.to(args.device)

    # Evaluation
    results = {}
    if args.do_eval and args.local_rank in [-1, 0]:
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir, do_lower_case=args.do_lower_case)
        checkpoints = [args.output_dir]
        if args.eval_all_checkpoints:
            checkpoints = list(
@@ -31,8 +31,14 @@ from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, Tenso
 from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange

-from transformers import WEIGHTS_NAME, AdamW, AutoConfig, AutoTokenizer, get_linear_schedule_with_warmup
-from transformers.modeling_auto import AutoModelForMultipleChoice
+from transformers import (
+    WEIGHTS_NAME,
+    AdamW,
+    BertConfig,
+    BertForMultipleChoice,
+    BertTokenizer,
+    get_linear_schedule_with_warmup,
+)


 try:
@@ -43,6 +49,12 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in [BertConfig]), ())
+
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertForMultipleChoice, BertTokenizer),
+}
+

 class SwagExample(object):
    """A single training/test example for the SWAG dataset."""
@@ -480,12 +492,19 @@ def main():
        required=True,
        help="SWAG csv for predictions. E.g., val.csv or test.csv",
    )
+    parser.add_argument(
+        "--model_type",
+        default=None,
+        type=str,
+        required=True,
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
+    )
    parser.add_argument(
        "--model_name_or_path",
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--output_dir",
@@ -517,6 +536,9 @@ def main():
    parser.add_argument(
        "--evaluate_during_training", action="store_true", help="Rul evaluation during training at each logging step."
    )
+    parser.add_argument(
+        "--do_lower_case", action="store_true", help="Set this flag if you are using an uncased model."
+    )

    parser.add_argument("--per_gpu_train_batch_size", default=8, type=int, help="Batch size per GPU/CPU for training.")
    parser.add_argument(
@@ -630,9 +652,13 @@ def main():
    if args.local_rank not in [-1, 0]:
        torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab

-    config = AutoConfig.from_pretrained(args.config_name if args.config_name else args.model_name_or_path)
-    tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name if args.tokenizer_name else args.model_name_or_path,)
-    model = AutoModelForMultipleChoice.from_pretrained(
+    args.model_type = args.model_type.lower()
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    config = config_class.from_pretrained(args.config_name if args.config_name else args.model_name_or_path)
+    tokenizer = tokenizer_class.from_pretrained(
+        args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case
+    )
+    model = model_class.from_pretrained(
        args.model_name_or_path, from_tf=bool(".ckpt" in args.model_name_or_path), config=config
    )

@@ -668,8 +694,8 @@ def main():
        torch.save(args, os.path.join(args.output_dir, "training_args.bin"))

        # Load a trained model and vocabulary that you have fine-tuned
-        model = AutoModelForMultipleChoice.from_pretrained(args.output_dir)
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir)
+        model = model_class.from_pretrained(args.output_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir)
        model.to(args.device)

    # Evaluation - we can ask to evaluate all the checkpoints (sub-directories) in a directory
@@ -692,8 +718,8 @@ def main():
        for checkpoint in checkpoints:
            # Reload the model
            global_step = checkpoint.split("-")[-1] if len(checkpoints) > 1 else ""
-            model = AutoModelForMultipleChoice.from_pretrained(checkpoint)
-            tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+            model = model_class.from_pretrained(checkpoint)
+            tokenizer = tokenizer_class.from_pretrained(checkpoint)
            model.to(args.device)

            # Evaluate
@@ -67,6 +67,9 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum(
+    (tuple(conf.pretrained_config_archive_map.keys()) for conf in (BertConfig, XLNetConfig, XLMConfig)), ()
+)

 MODEL_CLASSES = {
    "bert": (BertConfig, BertForQuestionAnswering, BertTokenizer),
@@ -502,7 +505,7 @@ def main():
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--output_dir",
@@ -0,0 +1,756 @@
+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Pre-training language models using the ELECTRA method.
+"""
+
+
+import logging
+import math
+import multiprocessing
+import os
+import tarfile
+from dataclasses import dataclass, field
+from itertools import chain
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import IterableDataset
+from tqdm import tqdm
+
+from transformers import (
+    AutoConfig,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    ElectraForMaskedLM,
+    ElectraForPreTraining,
+    EvalPrediction,
+    HfArgumentParser,
+    PreTrainedTokenizer,
+    TextDataset,
+    Trainer,
+    set_seed,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.training_args import TrainingArguments
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    discriminator_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The discriminator checkpoint for weights initialization. Leave None if you want to train a model "
+            "from scratch."
+        },
+    )
+
+    discriminator_config_name: Optional[str] = field(
+        default=None,
+        metadata={"help": "Pretrained config name or path if not the same as the discriminator model_name"},
+    )
+
+    generator_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The generator checkpoint for weights initialization. Leave None if you want to train a model "
+            "from scratch."
+        },
+    )
+
+    generator_config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as the generator model_name"}
+    )
+
+    tokenizer_name: Optional[str] = field(
+        default=None,
+        metadata={"help": "Pretrained tokenizer name or path if not the same as discriminator model_name"},
+    )
+
+    cache_dir: Optional[str] = field(
+        default=None, metadata={"help": "Where do you want to store the pretrained models downloaded from s3"}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    train_data_file: Optional[str] = field(
+        default=None, metadata={"help": "The input training data file (a text file)."}
+    )
+
+    eval_data_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+
+    open_web_text_directory: Optional[str] = field(
+        default=None,
+        metadata={"help": "The directory containing files that will be used for training and evaluation."},
+    )
+
+    block_size: int = field(
+        default=-1,
+        metadata={
+            "help": "Optional input sequence length after tokenization."
+            "The training dataset will be truncated in block of this size for training."
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+
+    num_dataset_building_processes: int = field(
+        default=1, metadata={"help": "The number of workers that will be used to build the dataset."}
+    )
+
+    num_tensors_per_file: int = field(
+        default=2048,
+        metadata={
+            "help": "The number of tensors that will be stored in each file after tokenization."
+            "The smaller the amount, the smaller the filesize, but the larger the amount"
+            "of files that will be created."
+        },
+    )
+
+    mask_probability: float = field(
+        default=0.15, metadata={"help": "Percentage of the input that will be masked or replaced."}
+    )
+
+    max_predictions_per_sequence: int = field(
+        default=-1, metadata={"help": "Maximum tokens that will be masked in a sequence."},
+    )
+
+
+@dataclass
+class ElectraTrainingArguments(TrainingArguments):
+    max_steps: int = field(
+        default=1_000_000,
+        metadata={"help": "If > 0: set total number of training steps to perform. Override num_train_epochs."},
+    )
+
+    max_eval_steps: int = field(
+        default=100, metadata={"help": "If > 0: set total number of eval steps to perform."},
+    )
+    warmup_steps: int = field(default=10_000, metadata={"help": "Linear warmup over warmup_steps."})
+
+    weight_decay: float = field(default=0.1, metadata={"help": "Weight decay if we apply some."})
+
+    generator_weight: float = field(default=1.0, metadata={"help": "Weight coefficient for the generator loss"})
+
+    discriminator_weight: float = field(
+        default=50.0, metadata={"help": "Weight coefficient for the discriminator loss"}
+    )
+
+
+def get_dataset(
+    data_args: DataTrainingArguments,
+    training_args: TrainingArguments,
+    model_args: ModelArguments,
+    tokenizer: Union[PreTrainedTokenizer, str],
+    evaluate=False,
+    local_rank=-1,
+):
+    if data_args.open_web_text_directory is not None:
+        # Whether to overwrite the cache. We don't want to overwrite the cache when evaluating if we're both training
+        # and evaluating, as the same dataset is used. We don't need to tokenize twice for training
+        # and evaluation.
+        should_overwrite_cache = False
+
+        # If argument is specified and training, then respect the argument
+        if data_args.overwrite_cache and not evaluate:
+            should_overwrite_cache = True
+        if data_args.overwrite_cache and training_args.do_eval and not training_args.do_train:
+            should_overwrite_cache = True
+
+        return OpenWebTextDataset(data_args, model_args, overwrite_cache=should_overwrite_cache)
+    else:
+        file_path = data_args.eval_data_file if evaluate else data_args.train_data_file
+        return TextDataset(
+            tokenizer=tokenizer, file_path=file_path, block_size=data_args.block_size, local_rank=local_rank,
+        )
+
+
+class OpenWebTextDataset(IterableDataset):
+    def __init__(self, data_args, model_args, overwrite_cache=False):
+        self.tokenizer_cache = model_args.cache_dir
+        self.directory = Path(data_args.open_web_text_directory)
+        self.archives = os.listdir(self.directory)
+        self.tokenizer_identifier = model_args.tokenizer_name
+        self.num_tensors_per_file = data_args.num_tensors_per_file
+        self.feature_directory = (
+            self.directory
+            / f"features_{self.tokenizer_identifier.replace('/', '_')}_{data_args.block_size if data_args.block_size is not None else 'no-max-seq'}_{self.num_tensors_per_file}"
+        )
+        self.block_size = data_args.block_size
+
+        # The dataset was already processed
+        if os.path.exists(self.feature_directory) and not overwrite_cache:
+            logger.info(
+                f"Re-using cache from {self.feature_directory}. Warning: we have no way of detecting an "
+                f"incomplete cache. If the tokenization was started but not finished, please use the "
+                f"`--ignore_cache=True` flag."
+            )
+            self.feature_set_paths = [
+                self.feature_directory / feature_set_path for feature_set_path in os.listdir(self.feature_directory)
+            ]
+            return
+
+        logger.info(f"Writing features at {self.feature_directory}")
+        os.makedirs(self.feature_directory, exist_ok=overwrite_cache)
+
+        n_archives_per_job = math.ceil(len(self.archives) / data_args.num_dataset_building_processes)
+        self.job_archives = [
+            self.archives[i * n_archives_per_job : (i + 1) * n_archives_per_job]
+            for i in range(data_args.num_dataset_building_processes)
+        ]
+        # Sanity check: make sure we're not leaving any archive behind.
+        assert sum([len(archive) for archive in self.job_archives]) == len(self.archives)
+
+        if data_args.num_dataset_building_processes == 1:
+            self.feature_set_paths = self._extract_open_web_text()
+        else:
+            pool = multiprocessing.Pool(processes=data_args.num_dataset_building_processes)
+            self.feature_set_paths = pool.map(
+                self._extract_open_web_text, range(data_args.num_dataset_building_processes)
+            )
+            self.feature_set_paths = [file_path for feature_set in self.feature_set_paths for file_path in feature_set]
+
+    def _extract_open_web_text(self, job_id=0):
+        """
+        OpenWebText is saved under the following format:
+
+        openwebtext.zip
+            |-> archive_xxx.zip
+                |-> file_xxx.txt
+                |-> file_xxz.txt
+                ...
+            |-> archive_xxz.zip
+                |-> file_xxy.txt
+                ...
+            ...
+        """
+        tokenizer = AutoTokenizer.from_pretrained(
+            self.tokenizer_identifier, use_fast=True, cache_dir=self.tokenizer_cache
+        )
+
+        # Create openwebtext/tmp directory to store temporary files
+        temporary_directory = self.directory / "tmp" / f"job_{job_id}"
+        feature_index = 0
+        feature_set_paths = []
+
+        os.makedirs(temporary_directory, exist_ok=True)
+
+        # Extract archives and tokenize in directory
+        progress_bar = tqdm(
+            self.job_archives[job_id], desc="Extracting archives", total=len(self.job_archives[0]), disable=job_id != 0
+        )
+
+        features = []
+        for archive in progress_bar:
+            if os.path.isdir(self.directory / archive):
+                logger.info("Ignoring rogue directory.")
+                continue
+            with tarfile.open(self.directory / archive) as t:
+                extracted_archive = temporary_directory / f"{archive}-extracted"
+                t.extractall(extracted_archive)
+
+            files = os.listdir(extracted_archive)
+            for file in files:
+                file_path = extracted_archive / file
+
+                with open(file_path, "r") as f:
+                    text = f.read()
+                    block_size = tokenizer.model_max_length if self.block_size is None else self.block_size
+                    encoding = tokenizer.encode_plus(text, return_overflowing_tokens=True, max_length=block_size)
+
+                    features.append(torch.tensor(encoding["input_ids"]))
+
+                    for overflowing_encoding in encoding.encodings[0].overflowing:
+                        features.append(torch.tensor(overflowing_encoding.ids))
+
+            while len(features) > self.num_tensors_per_file:
+                feature_set_path = self.feature_directory / f"feature_set_{job_id}_{feature_index}.pt"
+                torch.save(features[: self.num_tensors_per_file], feature_set_path)
+                features = features[self.num_tensors_per_file :]
+                feature_index += 1
+                feature_set_paths.append(feature_set_path)
+
+        if len(features) > 0:
+            feature_set_path = self.feature_directory / f"feature_set_{job_id}_{feature_index}.pt"
+            torch.save(features, feature_set_path)
+            feature_set_paths.append(feature_set_path)
+
+        return feature_set_paths
+
+    @staticmethod
+    def parse_file(file_index):
+        try:
+            features = torch.load(file_index)
+            yield from features
+        except RuntimeError:
+            raise RuntimeError(f"Corrupted file {file_index}")
+
+    def __len__(self):
+        return len(self.feature_set_paths) * self.num_tensors_per_file
+
+    def __iter__(self):
+        return chain.from_iterable(map(self.parse_file, self.feature_set_paths))
+
+
+class CombinedModel(nn.Module):
+    def __init__(
+        self,
+        discriminator: PreTrainedModel,
+        generator: PreTrainedModel,
+        tokenizer: PreTrainedTokenizer,
+        training_args: ElectraTrainingArguments,
+        data_args: DataTrainingArguments,
+    ):
+        super().__init__()
+
+        self.discriminator = discriminator
+        self.generator = generator
+
+        # Embeddings are shared
+        self.discriminator.set_input_embeddings(self.generator.get_input_embeddings())
+
+        self.tokenizer = tokenizer
+
+        self.discriminator_weight = training_args.discriminator_weight
+        self.generator_weight = training_args.generator_weight
+        self.mask_probability = data_args.mask_probability
+        self.max_predictions_per_sequence = data_args.max_predictions_per_sequence
+
+        # Original implementation has a default of :(mask_probability + 0.005) * max_sequence_length
+        if self.max_predictions_per_sequence == -1:
+            self.max_predictions_per_sequence = (self.mask_probability + 0.005) * data_args.block_size
+
+        class Config:
+            xla_device: bool = False
+
+        self.config = Config()
+
+    def mask_inputs(
+        self, input_ids: torch.Tensor, tokens_to_ignore, proposal_distribution=1.0,
+    ):
+        input_ids = input_ids.clone()
+        inputs_which_can_be_masked = torch.ones_like(input_ids)
+        for token in tokens_to_ignore:
+            inputs_which_can_be_masked -= torch.eq(input_ids, token).long()
+
+        total_number_of_tokens = input_ids.shape[-1]
+
+        # Identify the number of tokens to be masked, which should be: 1 < num < max_predictions per seq.
+        # It is set to be: n_tokens * mask_probability, but is truncated if it goes beyond bounds.
+        number_of_tokens_to_be_masked = torch.max(
+            torch.tensor(1),
+            torch.min(
+                torch.tensor(self.max_predictions_per_sequence, dtype=torch.long),
+                torch.tensor(int(total_number_of_tokens * self.mask_probability), dtype=torch.long),
+            ),
+        )
+
+        # The probability of each token being masked
+        sample_prob = proposal_distribution * inputs_which_can_be_masked
+        sample_prob /= torch.sum(sample_prob)
+
+        # Sample from the probabilities
+        masked_lm_positions = sample_prob.multinomial(number_of_tokens_to_be_masked)
+
+        # Gather the IDs from the positions
+        masked_lm_ids = input_ids.gather(-1, masked_lm_positions)
+
+        return masked_lm_ids, masked_lm_positions
+
+    @staticmethod
+    def gather_positions(sequence, positions):
+        batch_size, sequence_length, dimension = sequence.shape
+        position_shift = (sequence_length * torch.arange(batch_size, device=sequence.device)).unsqueeze(-1)
+        flat_positions = torch.reshape(positions + position_shift, [-1]).long()
+        flat_sequence = torch.reshape(sequence, [batch_size * sequence_length, dimension])
+        gathered = flat_sequence.index_select(0, flat_positions)
+        return torch.reshape(gathered, [batch_size, -1, dimension])
+
+    def forward(
+        self, input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, labels=None,
+    ):
+        # get the masked positions as well as their original values
+        masked_input_ids, masked_lm_positions = self.mask_inputs(
+            input_ids, [self.tokenizer.cls_token_id, self.tokenizer.sep_token_id, self.tokenizer.mask_token_id],
+        )
+
+        # only masked values should be counted in the loss; build a tensor containing the true values and -100 otherwise
+        masked_lm_labels = torch.full_like(input_ids, -100)
+        masked_lm_labels.scatter_(-1, masked_lm_positions, masked_input_ids)
+
+        # Create a tensor filled with masks
+        masked_tokens = torch.full_like(masked_input_ids, self.tokenizer.mask_token_id)
+        masked_lm_inputs = input_ids.clone()
+
+        # Of the evaluated tokens, 15% of those will keep their original tokens
+        replace_with_mask_positions = masked_lm_positions * (
+            torch.rand(masked_lm_positions.shape, device=masked_lm_positions.device) < (1 - self.mask_probability)
+        )
+
+        # Scatter the masks at the masked positions
+        masked_lm_inputs.scatter_(-1, replace_with_mask_positions, masked_tokens)
+        masked_lm_inputs[..., 0] = 101
+
+        generator_loss, generator_output = self.generator(
+            masked_lm_inputs,
+            attention_mask,
+            token_type_ids,
+            position_ids,
+            head_mask,
+            position_ids,
+            masked_lm_labels=masked_lm_labels,
+        )[:2]
+
+        # get the generator's predicted value on each masked position
+        fake_logits = self.gather_positions(generator_output, masked_lm_positions)
+        fake_softmaxed = torch.softmax(fake_logits, dim=-1)
+        fake_sampled = fake_softmaxed\
+            .view(fake_logits.shape[0] * fake_logits.shape[1], fake_logits.shape[2])\
+            .multinomial(1)\
+            .view(fake_logits.shape[:-1])
+
+        # create a tensor containing the predicted tokens
+        fake_tokens = input_ids.scatter(-1, masked_lm_positions, fake_sampled)
+        fake_tokens[:, 0] = input_ids[:, 0]
+        discriminator_labels = (labels != fake_tokens).int()
+
+        discriminator_loss, discriminator_output = self.discriminator(
+            fake_tokens,
+            attention_mask,
+            token_type_ids,
+            position_ids,
+            head_mask,
+            position_ids,
+            labels=discriminator_labels,
+        )[:2]
+
+        discriminator_predictions = torch.round((torch.sign(discriminator_output) + 1.0) * 0.5)
+
+        total_loss = (self.discriminator_weight * discriminator_loss) + (self.generator_weight * generator_loss)
+
+        return (
+            total_loss,
+            (generator_output, discriminator_output),
+            (masked_input_ids, fake_sampled),
+            (discriminator_labels, discriminator_predictions),
+        )
+
+    def save_pretrained(self, directory):
+        if self.config.xla_device:
+            self.discriminator.config.xla_device = True
+            self.generator.config.xla_device = True
+        else:
+            self.discriminator.config.xla_device = False
+            self.generator.config.xla_device = False
+
+        generator_path = os.path.join(directory, "generator")
+        discriminator_path = os.path.join(directory, "discriminator")
+
+        if not os.path.exists(generator_path):
+            os.makedirs(generator_path)
+
+        if not os.path.exists(discriminator_path):
+            os.makedirs(discriminator_path)
+
+        self.generator.save_pretrained(generator_path)
+        self.discriminator.save_pretrained(discriminator_path)
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, ElectraTrainingArguments))
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    if data_args.open_web_text_directory is None and data_args.eval_data_file is None and training_args.do_eval:
+        raise ValueError(
+            "Cannot do evaluation without an evaluation data file. Either supply a file to --eval_data_file "
+            "or remove the --do_eval argument."
+        )
+
+    if (
+        os.path.exists(training_args.output_dir)
+        and os.listdir(training_args.output_dir)
+        and training_args.do_train
+        and not training_args.overwrite_output_dir
+    ):
+        raise ValueError(
+            f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
+        )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
+    )
+    logger.warning(
+        "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
+        training_args.local_rank,
+        training_args.device,
+        training_args.n_gpu,
+        bool(training_args.local_rank != -1),
+        training_args.fp16,
+    )
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # Set seed
+    set_seed(training_args.seed)
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    if model_args.discriminator_config_name:
+        discriminator_config = AutoConfig.from_pretrained(
+            model_args.discriminator_config_name, cache_dir=model_args.cache_dir
+        )
+    elif model_args.discriminator_name_or_path:
+        discriminator_config = AutoConfig.from_pretrained(
+            model_args.discriminator_name_or_path, cache_dir=model_args.cache_dir
+        )
+    else:
+        raise ValueError("Either --discriminator_config_name or --discriminator_name_or_path should be specified.")
+
+    if model_args.generator_config_name:
+        generator_config = AutoConfig.from_pretrained(model_args.generator_config_name, cache_dir=model_args.cache_dir)
+    elif model_args.generator_name_or_path:
+        generator_config = AutoConfig.from_pretrained(
+            model_args.generator_name_or_path, cache_dir=model_args.cache_dir
+        )
+    else:
+        raise ValueError("Either --generator_config_name or --generator_name_or_path should be specified.")
+
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, cache_dir=model_args.cache_dir)
+    elif model_args.discriminator_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_args.discriminator_name_or_path, cache_dir=model_args.cache_dir
+        )
+        model_args.tokenizer_name = model_args.discriminator_name_or_path
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported, but you can do it from another "
+            "script, save it, and load it from here, using --tokenizer_name"
+        )
+
+    if model_args.discriminator_name_or_path:
+        discriminator = ElectraForPreTraining.from_pretrained(
+            model_args.discriminator_name_or_path,
+            from_tf=bool(".ckpt" in model_args.discriminator_name_or_path),
+            config=discriminator_config,
+            cache_dir=model_args.cache_dir,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        discriminator = ElectraForPreTraining(discriminator_config)
+
+    if model_args.generator_name_or_path:
+        generator = ElectraForMaskedLM.from_pretrained(
+            model_args.generator_name_or_path,
+            from_tf=bool(".ckpt" in model_args.generator_name_or_path),
+            config=generator_config,
+            cache_dir=model_args.cache_dir,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        generator = ElectraForMaskedLM(generator_config)
+
+    discriminator.resize_token_embeddings(len(tokenizer))
+    generator.resize_token_embeddings(len(tokenizer))
+
+    if data_args.block_size <= 0:
+        data_args.block_size = tokenizer.max_len
+        # Our input block size will be the max possible for the model
+    else:
+        data_args.block_size = min(data_args.block_size, tokenizer.max_len)
+
+    # Need to update this to something cleaner
+    try:
+        import torch_xla.core.xla_model as xm
+
+        if xm.is_master_ordinal(local=True):
+            get_dataset(data_args, training_args, model_args, tokenizer=tokenizer, local_rank=training_args.local_rank)
+
+        xm.rendezvous("dataset building")
+    except ImportError:
+        logger.info("Not running on TPU")
+
+    # Get datasets
+    train_dataset = (
+        get_dataset(data_args, training_args, model_args, tokenizer=tokenizer, local_rank=training_args.local_rank)
+        if training_args.do_train
+        else None
+    )
+    eval_dataset = (
+        get_dataset(
+            data_args,
+            training_args,
+            model_args,
+            tokenizer=tokenizer,
+            local_rank=training_args.local_rank,
+            evaluate=True,
+        )
+        if training_args.do_eval
+        else None
+    )
+
+    # Masking is done inside the CombinedModel
+    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False, mlm_probability=0)
+
+    model = CombinedModel(discriminator, generator, tokenizer, training_args, data_args)
+
+    def compute_metrics(evaluation_predictions: EvalPrediction) -> Dict[str, int]:
+        predictions: Dict[str, np.ndarray] = evaluation_predictions.predictions
+        labels: Dict[str, np.ndarray] = evaluation_predictions.label_ids
+
+        generator_labels, generator_predictions = labels["generator"], predictions["generator"]
+        discriminator_labels, discriminator_predictions = labels["discriminator"], predictions["discriminator"]
+
+        true_positives = (
+            np.logical_and(
+                np.equal(discriminator_predictions, discriminator_labels), np.equal(discriminator_labels, 1)
+            )
+            .sum()
+            .astype(float)
+        )
+        false_negatives = (
+            np.logical_and(
+                np.not_equal(discriminator_predictions, discriminator_labels), np.equal(discriminator_labels, 1)
+            )
+            .sum()
+            .astype(float)
+        )
+        false_positives = (
+            np.logical_and(
+                np.not_equal(discriminator_predictions, discriminator_labels), np.equal(discriminator_labels, 0)
+            )
+            .sum()
+            .astype(float)
+        )
+
+        generator_accuracy = (
+            np.equal(generator_labels, generator_predictions).sum().astype(float) / generator_predictions.size
+        )
+        discriminator_accuracy = (
+            np.equal(discriminator_labels, discriminator_predictions).sum().astype(float) / discriminator_labels.size
+        )
+        discriminator_precision = true_positives / (true_positives + false_positives)
+        discriminator_recall = true_positives / (true_positives + false_negatives)
+
+        return {
+            "generator_accuracy": generator_accuracy,
+            "discriminator_accuracy": discriminator_accuracy,
+            "discriminator_precision": discriminator_precision,
+            "discriminator_recall": discriminator_recall,
+        }
+
+    def manage_evaluation_predictions(model_outputs: Tuple[torch.Tensor]) -> Dict[str, torch.Tensor]:
+        total_loss, models_output, generator_evaluation_values, discriminator_evaluation_values = model_outputs
+        generator_labels, generator_predictions = generator_evaluation_values
+        discriminator_labels, discriminator_predictions = discriminator_evaluation_values
+
+        return {
+            "generator_labels": generator_labels.detach(),
+            "generator_predictions": generator_predictions.detach(),
+            "discriminator_labels": discriminator_labels.detach(),
+            "discriminator_predictions": discriminator_predictions.detach(),
+        }
+
+    def eval_prediction_mapping(dictionary: Dict[str, np.ndarray]) -> EvalPrediction:
+        labels = {"generator": dictionary["generator_labels"], "discriminator": dictionary["discriminator_labels"]}
+        predictions = {
+            "generator": dictionary["generator_predictions"],
+            "discriminator": dictionary["discriminator_predictions"],
+        }
+
+        return EvalPrediction(labels, predictions)
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        data_collator=data_collator,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        compute_metrics=compute_metrics,
+        manage_evaluation_predictions=manage_evaluation_predictions,
+        eval_prediction_mapping=eval_prediction_mapping,
+        prediction_loss_only=True,
+    )
+
+    # Training
+    if training_args.do_train:
+        model_path = (
+            model_args.discriminator_name_or_path
+            if model_args.discriminator_name_or_path is not None
+            and os.path.isdir(model_args.discriminator_name_or_path)
+            else None
+        )
+        trainer.train(model_path=model_path)
+        trainer.save_model()
+
+    # Evaluation
+    results = {}
+    if training_args.do_eval and training_args.local_rank in [-1, 0]:
+        logger.info("*** Evaluate ***")
+
+        result = trainer.evaluate()
+
+        output_eval_file = os.path.join(training_args.output_dir, "eval_results_lm.txt")
+        with open(output_eval_file, "w") as writer:
+            logger.info("***** Eval results *****")
+            for key in sorted(result.keys()):
+                logger.info("  %s = %s", key, str(result[key]))
+                writer.write("%s = %s\n" % (key, str(result[key])))
+
+        results.update(result)
+
+    return results
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()
@@ -18,9 +18,7 @@
    "\n",
    "We experiment with a question answering model with only 6% of total remaining weights in the encoder (previously obtained with movement pruning). **We are able to reduce the memory size of the encoder from 340MB (original dense BERT) to 11MB**, which fits on a [91' floppy disk](https://en.wikipedia.org/wiki/Floptical)!\n",
    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/0/00/Floptical_disk_21MB.jpg/440px-Floptical_disk_21MB.jpg\" width=\"200\">\n",
-    "\n",
-    "*Note: this notebook is compatible with `torch>=1.5.0` If you are using, `torch==1.4.0`, please refer to [this previous version of the notebook](https://github.com/huggingface/transformers/commit/b11386e158e86e62d4041eabd86d044cd1695737).*"
+    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/0/00/Floptical_disk_21MB.jpg/440px-Floptical_disk_21MB.jpg\" width=\"200\">"
   ]
  },
  {
@@ -69,7 +67,10 @@
   "source": [
    "# Load fine-pruned model and quantize the model\n",
    "\n",
-    "model = BertForQuestionAnswering.from_pretrained(\"huggingface/prunebert-base-uncased-6-finepruned-w-distil-squad\")\n",
+    "model_path = \"serialization_dir/bert-base-uncased/92/squad/l1\"\n",
+    "model_name = \"bertarized_l1_with_distil_0._0.1_1_2_l1_1100._3e-5_1e-2_sigmoied_threshold_constant_0._10_epochs\"\n",
+    "\n",
+    "model = BertForQuestionAnswering.from_pretrained(os.path.join(model_path, model_name))\n",
    "model.to('cpu')\n",
    "\n",
    "quantized_model = torch.quantization.quantize_dynamic(\n",
@@ -195,7 +196,7 @@
    "\n",
    "elementary_qtz_st = {}\n",
    "for name, param in qtz_st.items():\n",
-    "    if \"dtype\" not in name and param.is_quantized:\n",
+    "    if param.is_quantized:\n",
    "        print(\"Decompose quantization for\", name)\n",
    "        # We need to extract the scale, the zero_point and the int_repr for the quantized tensor and modules\n",
    "        scale = param.q_scale()                                # torch.tensor(1,) - float32\n",
@@ -220,17 +221,6 @@
  {
   "cell_type": "code",
   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create mapping from torch.dtype to string description (we could also used an int8 instead of string)\n",
-    "str_2_dtype = {\"qint8\": torch.qint8}\n",
-    "dtype_2_str = {torch.qint8: \"qint8\"}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
@@ -255,7 +245,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
@@ -276,10 +266,9 @@
      "Skip bert.pooler.dense._packed_params.weight.int_repr.indices\n",
      "Skip bert.pooler.dense._packed_params.weight.int_repr.shape\n",
      "Skip bert.pooler.dense._packed_params.bias\n",
-      "Skip bert.pooler.dense._packed_params.dtype\n",
      "\n",
-      "Encoder Size (MB) - Dense:              340.26\n",
-      "Encoder Size (MB) - Sparse & Quantized: 11.28\n"
+      "Encoder Size (MB) - Dense:              340.25\n",
+      "Encoder Size (MB) - Sparse & Quantized: 11.27\n"
     ]
    }
   ],
@@ -311,14 +300,10 @@
    "\n",
    "        elif type(param) == float or type(param) == int or type(param) == tuple:\n",
    "            # float - tensor _packed_params.weight.scale\n",
-    "            # int   - tensor _packed_params.weight.zero_point\n",
+    "            # int   - tensor_packed_params.weight.zero_point\n",
    "            # tuple - tensor _packed_params.weight.shape\n",
    "            hf.attrs[name] = param\n",
    "\n",
-    "        elif type(param) == torch.dtype:\n",
-    "            # dtype - tensor _packed_params.dtype\n",
-    "            hf.attrs[name] = dtype_2_str[param]\n",
-    "            \n",
    "        else:\n",
    "            hf.create_dataset(name, data=param, compression=\"gzip\", compression_opts=9)\n",
    "\n",
@@ -334,7 +319,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
@@ -342,7 +327,7 @@
     "output_type": "stream",
     "text": [
      "\n",
-      "Size (MB): 99.41\n"
+      "Size (MB): 99.39\n"
     ]
    }
   ],
@@ -378,15 +363,10 @@
    "            # tuple - tensor _packed_params.weight.shape\n",
    "            hf.attrs[name] = param\n",
    "\n",
-    "        elif type(param) == torch.dtype:\n",
-    "            # dtype - tensor _packed_params.dtype\n",
-    "            hf.attrs[name] = dtype_2_str[param]\n",
-    "            \n",
    "        else:\n",
    "            hf.create_dataset(name, data=param, compression=\"gzip\", compression_opts=9)\n",
    "\n",
    "\n",
-    "\n",
    "with open('dbg/metadata.json', 'w') as f:\n",
    "    f.write(json.dumps(qtz_st._metadata))   \n",
    "\n",
@@ -403,7 +383,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
@@ -426,8 +406,6 @@
    "            attr_param = int(attr_param)\n",
    "        else:\n",
    "            attr_param = torch.tensor(attr_param)\n",
-    "    elif \".dtype\" in attr_name:\n",
-    "        attr_param = str_2_dtype[attr_param]\n",
    "    reconstructed_elementary_qtz_st[attr_name] = attr_param\n",
    "    # print(f\"Unpack {attr_name}\")\n",
    "    \n",
@@ -450,7 +428,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
@@ -473,7 +451,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
@@ -509,7 +487,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
@@ -539,7 +517,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
@@ -548,7 +526,7 @@
       "<All keys matched successfully>"
      ]
     },
-     "execution_count": 13,
+     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
@@ -575,7 +553,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
@@ -19,6 +19,7 @@ and adapts it to the specificities of MaskedBert (`pruning_method`, `mask_init`

 import logging

+from transformers.configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP
 from transformers.configuration_utils import PretrainedConfig


@@ -30,6 +31,7 @@ class MaskedBertConfig(PretrainedConfig):
    A class replicating the `~transformers.BertConfig` with additional parameters for pruning/masking configuration.
    """

+    pretrained_config_archive_map = BERT_PRETRAINED_CONFIG_ARCHIVE_MAP
    model_type = "masked_bert"

    def __init__(
@@ -29,7 +29,12 @@ from torch.nn import CrossEntropyLoss, MSELoss
 from emmental import MaskedBertConfig
 from emmental.modules import MaskedLinear
 from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_callable
-from transformers.modeling_bert import ACT2FN, BertLayerNorm, load_tf_weights_in_bert
+from transformers.modeling_bert import (
+    ACT2FN,
+    BERT_PRETRAINED_MODEL_ARCHIVE_MAP,
+    BertLayerNorm,
+    load_tf_weights_in_bert,
+)
 from transformers.modeling_utils import PreTrainedModel, prune_linear_layer


@@ -390,6 +395,7 @@ class MaskedBertPreTrainedModel(PreTrainedModel):
    """

    config_class = MaskedBertConfig
+    pretrained_model_archive_map = BERT_PRETRAINED_MODEL_ARCHIVE_MAP
    load_tf_weights = load_tf_weights_in_bert
    base_model_prefix = "bert"

@@ -53,6 +53,8 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (BertConfig,)), (),)
+
 MODEL_CLASSES = {
    "bert": (BertConfig, BertForSequenceClassification, BertTokenizer),
    "masked_bert": (MaskedBertConfig, MaskedBertForSequenceClassification, BertTokenizer),
@@ -574,7 +576,7 @@ def main():
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--task_name",
@@ -57,6 +57,8 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (BertConfig,)), (),)
+
 MODEL_CLASSES = {
    "bert": (BertConfig, BertForQuestionAnswering, BertTokenizer),
    "masked_bert": (MaskedBertConfig, MaskedBertForQuestionAnswering, BertTokenizer),
@@ -671,7 +673,7 @@ def main():
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--output_dir",
@@ -121,7 +121,16 @@ if is_torch_available():
                    else:
                        examples = processor.get_train_examples(data_dir)
                    logger.info("Training examples: %s", len(examples))
-                    self.features = convert_examples_to_features(examples, label_list, max_seq_length, tokenizer,)
+                    # TODO clean up all this to leverage built-in features of tokenizers
+                    self.features = convert_examples_to_features(
+                        examples,
+                        label_list,
+                        max_seq_length,
+                        tokenizer,
+                        pad_on_left=bool(tokenizer.padding_side == "left"),
+                        pad_token=tokenizer.pad_token_id,
+                        pad_token_segment_id=tokenizer.pad_token_type_id,
+                    )
                    logger.info("Saving features into cached file %s", cached_features_file)
                    torch.save(self.features, cached_features_file)

@@ -163,8 +172,16 @@ if is_tf_available():
            else:
                examples = processor.get_train_examples(data_dir)
            logger.info("Training examples: %s", len(examples))
-
-            self.features = convert_examples_to_features(examples, label_list, max_seq_length, tokenizer,)
+            # TODO clean up all this to leverage built-in features of tokenizers
+            self.features = convert_examples_to_features(
+                examples,
+                label_list,
+                max_seq_length,
+                tokenizer,
+                pad_on_left=bool(tokenizer.padding_side == "left"),
+                pad_token=tokenizer.pad_token_id,
+                pad_token_segment_id=tokenizer.pad_token_type_id,
+            )

            def gen():
                for (ex_index, ex) in tqdm.tqdm(enumerate(self.features), desc="convert examples to features"):
@@ -489,7 +506,14 @@ class ArcProcessor(DataProcessor):


 def convert_examples_to_features(
-    examples: List[InputExample], label_list: List[str], max_length: int, tokenizer: PreTrainedTokenizer,
+    examples: List[InputExample],
+    label_list: List[str],
+    max_length: int,
+    tokenizer: PreTrainedTokenizer,
+    pad_token_segment_id=0,
+    pad_on_left=False,
+    pad_token=0,
+    mask_padding_with_zero=True,
 ) -> List[InputFeatures]:
    """
    Loads a data file into a list of `InputFeatures`
@@ -165,15 +165,17 @@ Larger batch size may improve the performance while costing more memory.
 python run_tf_squad.py \
    --model_name_or_path bert-base-uncased \
    --output_dir model \
-    --max_seq_length 384 \
+    --max-seq-length 384 \
    --num_train_epochs 2 \
    --per_gpu_train_batch_size 8 \
    --per_gpu_eval_batch_size 16 \
    --do_train \
-    --logging_dir logs \    
+    --logging_dir logs \
+    --mode question-answering \
    --logging_steps 10 \
    --learning_rate 3e-5 \
-    --doc_stride 128    
+    --doc_stride 128 \
+    --optimizer_name adamw
 ```

-For the moment the evaluation is not available in the Tensorflow Trainer only the training.
+For the moment the evaluation is not available in the Tensorflow Trainer only the training.
@@ -58,6 +58,8 @@ logger = logging.getLogger(__name__)
 MODEL_CONFIG_CLASSES = list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys())
 MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)

+ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in MODEL_CONFIG_CLASSES), (),)
+

 def set_seed(args):
    random.seed(args.seed)
@@ -489,7 +491,7 @@ def main():
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--output_dir",
@@ -1,4 +1,4 @@
-### Get CNN Data
+### Get Preprocessed CNN Data
 To be able to reproduce the authors' results on the CNN/Daily Mail dataset you first need to download both CNN and Daily Mail datasets [from Kyunghyun Cho's website](https://cs.nyu.edu/~kcho/DMQA/) (the links next to "Stories") in the same folder. Then uncompress the archives by running:

 ```bash
@@ -6,19 +6,24 @@ wget https://s3.amazonaws.com/datasets.huggingface.co/summarization/cnn_dm.tgz
 tar -xzvf cnn_dm.tgz
 ```

-this should make a directory called cnn_dm/ with files like `test.source`.
+this should make a directory called cnn_dm/ with files like `test.source`. 
 To use your own data, copy that files format. Each article to be summarized is on its own line.

 ### Evaluation
-
 To create summaries for each article in dataset, run:
 ```bash
-python evaluate_cnn.py <path_to_test.source> test_generations.txt <model-name>  --score_path rouge_scores.txt
+python evaluate_cnn.py <path_to_test.source> cnn_test_summaries.txt
 ```
-The default batch size, 8, fits in 16GB GPU memory, but may need to be adjusted to fit your system.
+the default batch size, 8, fits in 16GB GPU memory, but may need to be adjusted to fit your system.
+

 ### Training
-Run/modify `finetune_bart.sh` or `finetune_t5.sh`
+Run/modify `run_train.sh`
+    
+### Where is the code?
+The core model is in `src/transformers/modeling_bart.py`. This directory only contains examples.
+
+## (WIP) Rouge Scores

 ### Stanford CoreNLP Setup
 ```
@@ -0,0 +1,71 @@
+import argparse
+from pathlib import Path
+
+import torch
+from tqdm import tqdm
+
+from transformers import BartForConditionalGeneration, BartTokenizer
+
+
+DEFAULT_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+def generate_summaries(
+    examples: list, out_file: str, model_name: str, batch_size: int = 8, device: str = DEFAULT_DEVICE
+):
+    fout = Path(out_file).open("w")
+    model = BartForConditionalGeneration.from_pretrained(model_name).to(device)
+    tokenizer = BartTokenizer.from_pretrained("bart-large")
+
+    max_length = 140
+    min_length = 55
+
+    for batch in tqdm(list(chunks(examples, batch_size))):
+        dct = tokenizer.batch_encode_plus(batch, max_length=1024, return_tensors="pt", pad_to_max_length=True)
+        summaries = model.generate(
+            input_ids=dct["input_ids"].to(device),
+            attention_mask=dct["attention_mask"].to(device),
+            num_beams=4,
+            length_penalty=2.0,
+            max_length=max_length + 2,  # +2 from original because we start at step=1 and stop before max_length
+            min_length=min_length + 1,  # +1 from original because we start at step=1
+            no_repeat_ngram_size=3,
+            early_stopping=True,
+            decoder_start_token_id=model.config.eos_token_id,
+        )
+        dec = [tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=False) for g in summaries]
+        for hypothesis in dec:
+            fout.write(hypothesis + "\n")
+            fout.flush()
+
+
+def run_generate():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "source_path", type=str, help="like cnn_dm/test.source",
+    )
+    parser.add_argument(
+        "output_path", type=str, help="where to save summaries",
+    )
+    parser.add_argument(
+        "model_name", type=str, default="bart-large-cnn", help="like bart-large-cnn",
+    )
+    parser.add_argument(
+        "--device", type=str, required=False, default=DEFAULT_DEVICE, help="cuda, cuda:1, cpu etc.",
+    )
+    parser.add_argument(
+        "--bs", type=int, default=8, required=False, help="batch size: how many to summarize at a time",
+    )
+    args = parser.parse_args()
+    examples = [" " + x.rstrip() for x in open(args.source_path).readlines()]
+    generate_summaries(examples, args.output_path, args.model_name, batch_size=args.bs, device=args.device)
+
+
+if __name__ == "__main__":
+    run_generate()
@@ -6,7 +6,7 @@ export OUTPUT_DIR=${CURRENT_DIR}/${OUTPUT_DIR_NAME}
 mkdir -p $OUTPUT_DIR

 # Add parent directory to python path to access lightning_base.py
-export PYTHONPATH="../":"${PYTHONPATH}"
+export PYTHONPATH="../../":"${PYTHONPATH}"

 python finetune.py \
 --data_dir=./cnn-dailymail/cnn_dm \
@@ -13,7 +13,7 @@ export OUTPUT_DIR=${CURRENT_DIR}/${OUTPUT_DIR_NAME}
 mkdir -p $OUTPUT_DIR

 # Add parent directory to python path to access lightning_base.py and utils.py
-export PYTHONPATH="../":"${PYTHONPATH}"
+export PYTHONPATH="../../":"${PYTHONPATH}"
 python finetune.py \
 --data_dir=cnn_tiny/ \
 --model_type=bart \
@@ -129,7 +129,7 @@ class TestBartExamples(unittest.TestCase):
        summaries = ["A very interesting story about what I ate for lunch.", "Avocado, celery, turkey, coffee"]
        _dump_articles((tmp_dir / "train.source"), articles)
        _dump_articles((tmp_dir / "train.target"), summaries)
-        tokenizer = BartTokenizer.from_pretrained("facebook/bart-large")
+        tokenizer = BartTokenizer.from_pretrained("bart-large")
        max_len_source = max(len(tokenizer.encode(a)) for a in articles)
        max_len_target = max(len(tokenizer.encode(a)) for a in summaries)
        trunc_target = 4
@@ -146,34 +146,3 @@ class TestBartExamples(unittest.TestCase):
            # show that targets were truncated
            self.assertEqual(batch["target_ids"].shape[1], trunc_target)  # Truncated
            self.assertGreater(max_len_target, trunc_target)  # Truncated
-
-
-class TestT5Examples(unittest.TestCase):
-    def test_t5_cli(self):
-        output_file_name = "output_t5_sum.txt"
-        score_file_name = "score_t5_sum.txt"
-        articles = ["New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County."]
-        stream_handler = logging.StreamHandler(sys.stdout)
-        logger.addHandler(stream_handler)
-        tmp = Path(tempfile.gettempdir()) / "utest_generations_t5_sum.hypo"
-        with tmp.open("w", encoding="utf-8") as f:
-            f.write("\n".join(articles))
-
-        output_file_name = Path(tempfile.gettempdir()) / "utest_output_t5_sum.hypo"
-        score_file_name = Path(tempfile.gettempdir()) / "utest_score_t5_sum.hypo"
-
-        testargs = [
-            "evaluate_cnn.py",
-            str(tmp),
-            str(output_file_name),
-            "patrickvonplaten/t5-tiny-random",
-            "--reference_path",
-            str(tmp),
-            "--score_path",
-            str(score_file_name),
-        ]
-
-        with patch.object(sys, "argv", testargs):
-            run_generate()
-            self.assertTrue(Path(output_file_name).exists())
-            self.assertTrue(Path(score_file_name).exists())
@@ -3,6 +3,8 @@ import os
 import torch
 from torch.utils.data import Dataset

+from transformers.tokenization_utils import trim_batch
+

 def encode_file(tokenizer, data_path, max_length, pad_to_max_length=True, return_tensors="pt"):
    examples = []
@@ -15,17 +17,6 @@ def encode_file(tokenizer, data_path, max_length, pad_to_max_length=True, return
    return examples


-def trim_batch(
-    input_ids, pad_token_id, attention_mask=None,
-):
-    """Remove columns that are populated exclusively by pad_token_id"""
-    keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)
-    if attention_mask is None:
-        return input_ids[:, keep_column_mask]
-    else:
-        return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
-
-
 class SummarizationDataset(Dataset):
    def __init__(
        self,
@@ -61,6 +61,7 @@ class BertAbsConfig(PretrainedConfig):
            the decoder.
    """

+    pretrained_config_archive_map = BERTABS_FINETUNED_CONFIG_MAP
    model_type = "bertabs"

    def __init__(
@@ -33,13 +33,14 @@ from transformers import BertConfig, BertModel, PreTrainedModel

 MAX_SIZE = 5000

-BERTABS_FINETUNED_MODEL_ARCHIVE_LIST = [
-    "remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization",
-]
+BERTABS_FINETUNED_MODEL_MAP = {
+    "bertabs-finetuned-cnndm": "https://cdn.huggingface.co/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization/pytorch_model.bin",
+}


 class BertAbsPreTrainedModel(PreTrainedModel):
    config_class = BertAbsConfig
+    pretrained_model_archive_map = BERTABS_FINETUNED_MODEL_MAP
    load_tf_weights = False
    base_model_prefix = "bert"

@@ -1,100 +0,0 @@
-import argparse
-from pathlib import Path
-
-import torch
-from rouge_score import rouge_scorer, scoring
-from tqdm import tqdm
-
-from transformers import AutoModelWithLMHead, AutoTokenizer
-
-
-DEFAULT_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-
-def chunks(lst, n):
-    """Yield successive n-sized chunks from lst."""
-    for i in range(0, len(lst), n):
-        yield lst[i : i + n]
-
-
-def generate_summaries(
-    examples: list, out_file: str, model_name: str, batch_size: int = 8, device: str = DEFAULT_DEVICE
-):
-    fout = Path(out_file).open("w", encoding="utf-8")
-    model = AutoModelWithLMHead.from_pretrained(model_name).to(device)
-
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-
-    # update config with summarization specific params
-    task_specific_params = model.config.task_specific_params
-    if task_specific_params is not None:
-        model.config.update(task_specific_params.get("summarization", {}))
-
-    for batch in tqdm(list(chunks(examples, batch_size))):
-        if "t5" in model_name:
-            batch = [model.config.prefix + text for text in batch]
-        dct = tokenizer.batch_encode_plus(batch, max_length=1024, return_tensors="pt", pad_to_max_length=True).to(
-            device
-        )
-        summaries = model.generate(**dct)
-
-        dec = tokenizer.batch_decode(summaries, skip_special_tokens=True, clean_up_tokenization_spaces=False)
-        for hypothesis in dec:
-            fout.write(hypothesis + "\n")
-            fout.flush()
-
-
-def calculate_rouge(output_lns, reference_lns, score_path):
-    score_file = Path(score_path).open("w")
-    scorer = rouge_scorer.RougeScorer(["rouge1", "rouge2", "rougeL"], use_stemmer=True)
-    aggregator = scoring.BootstrapAggregator()
-
-    for reference_ln, output_ln in zip(reference_lns, output_lns):
-        scores = scorer.score(reference_ln, output_ln)
-        aggregator.add_scores(scores)
-
-    result = aggregator.aggregate()
-    score_file.write(
-        "ROUGE_1: \n{} \n\n ROUGE_2: \n{} \n\n ROUGE_L: \n{} \n\n".format(
-            result["rouge1"], result["rouge2"], result["rougeL"]
-        )
-    )
-
-
-def run_generate():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_path", type=str, help="like cnn_dm/test.source or cnn_dm/test_articles_input.txt",
-    )
-    parser.add_argument(
-        "output_path", type=str, help="where to save summaries",
-    )
-    parser.add_argument(
-        "model_name",
-        type=str,
-        default="facebook/bart-large-cnn",
-        help="like bart-large-cnn,'t5-small', 't5-base', 't5-large', 't5-3b', 't5-11b",
-    )
-    parser.add_argument("--reference_path", type=str, required=False, help="like cnn_dm/test_reference_summaries.txt")
-    parser.add_argument(
-        "--score_path", type=str, required=False, help="where to save the rouge score",
-    )
-    parser.add_argument(
-        "--device", type=str, required=False, default=DEFAULT_DEVICE, help="cuda, cuda:1, cpu etc.",
-    )
-    parser.add_argument(
-        "--bs", type=int, default=8, required=False, help="batch size: how many to summarize at a time",
-    )
-    args = parser.parse_args()
-    examples = [" " + x.rstrip() if "t5" in args.model_name else x.rstrip() for x in open(args.input_path).readlines()]
-
-    generate_summaries(examples, args.output_path, args.model_name, batch_size=args.bs, device=args.device)
-    if args.score_path is not None:
-        output_lns = [x.rstrip() for x in open(args.output_path).readlines()]
-        reference_lns = [x.rstrip() for x in open(args.reference_path).readlines()]
-
-        calculate_rouge(output_lns, reference_lns, args.score_path)
-
-
-if __name__ == "__main__":
-    run_generate()
@@ -1,19 +0,0 @@
-export OUTPUT_DIR_NAME=t5
-export CURRENT_DIR=${PWD}
-export OUTPUT_DIR=${CURRENT_DIR}/${OUTPUT_DIR_NAME}
-
-# Make output directory if it doesn't exist
-mkdir -p $OUTPUT_DIR
-
-# Add parent directory to python path to access lightning_base.py
-export PYTHONPATH="../":"${PYTHONPATH}"
-
-python finetune.py \
--data_dir=./cnn-dailymail/cnn_dm \
--model_name_or_path=t5-large \
--model_type=t5
--learning_rate=3e-5 \
--train_batch_size=4 \
--eval_batch_size=4 \
--output_dir=$OUTPUT_DIR \
--do_train  $@
@@ -0,0 +1,29 @@
+***This script evaluates the the multitask pre-trained checkpoint for ``t5-base`` (see paper [here](https://arxiv.org/pdf/1910.10683.pdf)) on the CNN/Daily Mail test dataset. Please note that the results in the paper were attained using a model fine-tuned on summarization, so that results will be worse here by approx. 0.5 ROUGE points***
+
+### Get the CNN Data
+First, you need to download the CNN data. It's about ~400 MB and can be downloaded by 
+running 
+
+```bash
+python download_cnn_daily_mail.py cnn_articles_input_data.txt cnn_articles_reference_summaries.txt
+```
+
+You should confirm that each file has 11490 lines:
+
+```bash
+wc -l cnn_articles_input_data.txt # should print 11490
+wc -l cnn_articles_reference_summaries.txt # should print 11490
+```
+
+### Generating Summaries
+
+To create summaries for each article in dataset, run:
+```bash
+python evaluate_cnn.py cnn_articles_input_data.txt cnn_generated_articles_summaries.txt cnn_articles_reference_summaries.txt rouge_score.txt
+```
+The default batch size, 8, fits in 16GB GPU memory, but may need to be adjusted to fit your system.
+The rouge scores "rouge1, rouge2, rougeL" are automatically created and saved in ``rouge_score.txt``.
+
+
+### Finetuning
+Pass model_type=t5 and model `examples/summarization/bart/finetune.py`
@@ -0,0 +1,31 @@
+import argparse
+from pathlib import Path
+
+import tensorflow_datasets as tfds
+
+
+def main(input_path, reference_path, data_dir):
+    cnn_ds = tfds.load("cnn_dailymail", split="test", shuffle_files=False, data_dir=data_dir)
+    cnn_ds_iter = tfds.as_numpy(cnn_ds)
+
+    test_articles_file = Path(input_path).open("w")
+    test_summaries_file = Path(reference_path).open("w")
+
+    for example in cnn_ds_iter:
+        test_articles_file.write(example["article"].decode("utf-8") + "\n")
+        test_articles_file.flush()
+        test_summaries_file.write(example["highlights"].decode("utf-8").replace("\n", " ") + "\n")
+        test_summaries_file.flush()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_path", type=str, help="where to save the articles input data")
+    parser.add_argument(
+        "reference_path", type=str, help="where to save the reference summaries",
+    )
+    parser.add_argument(
+        "--data_dir", type=str, default="~/tensorflow_datasets", help="where to save the tensorflow datasets.",
+    )
+    args = parser.parse_args()
+    main(args.input_path, args.reference_path, args.data_dir)
@@ -0,0 +1,101 @@
+import argparse
+from pathlib import Path
+
+import torch
+from rouge_score import rouge_scorer, scoring
+from tqdm import tqdm
+
+from transformers import T5ForConditionalGeneration, T5Tokenizer
+
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+def generate_summaries(lns, output_file_path, model_size, batch_size, device):
+    output_file = Path(output_file_path).open("w")
+
+    model = T5ForConditionalGeneration.from_pretrained(model_size)
+    model.to(device)
+
+    tokenizer = T5Tokenizer.from_pretrained(model_size)
+
+    # update config with summarization specific params
+    task_specific_params = model.config.task_specific_params
+    if task_specific_params is not None:
+        model.config.update(task_specific_params.get("summarization", {}))
+
+    for batch in tqdm(list(chunks(lns, batch_size))):
+        batch = [model.config.prefix + text for text in batch]
+
+        dct = tokenizer.batch_encode_plus(batch, max_length=512, return_tensors="pt", pad_to_max_length=True)
+        input_ids = dct["input_ids"].to(device)
+        attention_mask = dct["attention_mask"].to(device)
+
+        summaries = model.generate(input_ids=input_ids, attention_mask=attention_mask)
+        dec = [tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=False) for g in summaries]
+
+        for hypothesis in dec:
+            output_file.write(hypothesis + "\n")
+            output_file.flush()
+
+
+def calculate_rouge(output_lns, reference_lns, score_path):
+    score_file = Path(score_path).open("w")
+    scorer = rouge_scorer.RougeScorer(["rouge1", "rouge2", "rougeL"], use_stemmer=True)
+    aggregator = scoring.BootstrapAggregator()
+
+    for reference_ln, output_ln in zip(reference_lns, output_lns):
+        scores = scorer.score(reference_ln, output_ln)
+        aggregator.add_scores(scores)
+
+    result = aggregator.aggregate()
+    score_file.write(
+        "ROUGE_1: \n{} \n\n ROUGE_2: \n{} \n\n ROUGE_L: \n{} \n\n".format(
+            result["rouge1"], result["rouge2"], result["rougeL"]
+        )
+    )
+
+
+def run_generate():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "model_size",
+        type=str,
+        help="T5 model size, either 't5-small', 't5-base', 't5-large', 't5-3b', 't5-11b'. Defaults to 't5-base'.",
+        default="t5-base",
+    )
+    parser.add_argument(
+        "input_path", type=str, help="like cnn_dm/test_articles_input.txt",
+    )
+    parser.add_argument(
+        "output_path", type=str, help="where to save summaries",
+    )
+    parser.add_argument("reference_path", type=str, help="like cnn_dm/test_reference_summaries.txt")
+    parser.add_argument(
+        "score_path", type=str, help="where to save the rouge score",
+    )
+    parser.add_argument(
+        "--batch_size", type=int, default=8, required=False, help="batch size: how many to summarize at a time",
+    )
+    parser.add_argument(
+        "--no_cuda", default=False, type=bool, help="Whether to force the execution on CPU.",
+    )
+
+    args = parser.parse_args()
+    args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
+
+    source_lns = [x.rstrip() for x in open(args.input_path).readlines()]
+
+    generate_summaries(source_lns, args.output_path, args.model_size, args.batch_size, args.device)
+
+    output_lns = [x.rstrip() for x in open(args.output_path).readlines()]
+    reference_lns = [x.rstrip() for x in open(args.reference_path).readlines()]
+
+    calculate_rouge(output_lns, reference_lns, args.score_path)
+
+
+if __name__ == "__main__":
+    run_generate()
@@ -0,0 +1,44 @@
+import logging
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from .evaluate_cnn import run_generate
+
+
+output_file_name = "output_t5_sum.txt"
+score_file_name = "score_t5_sum.txt"
+
+articles = ["New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County."]
+
+logging.basicConfig(level=logging.DEBUG)
+
+logger = logging.getLogger()
+
+
+class TestT5Examples(unittest.TestCase):
+    def test_t5_cli(self):
+        stream_handler = logging.StreamHandler(sys.stdout)
+        logger.addHandler(stream_handler)
+        tmp = Path(tempfile.gettempdir()) / "utest_generations_t5_sum.hypo"
+        with tmp.open("w") as f:
+            f.write("\n".join(articles))
+
+        output_file_name = Path(tempfile.gettempdir()) / "utest_output_t5_sum.hypo"
+        score_file_name = Path(tempfile.gettempdir()) / "utest_score_t5_sum.hypo"
+
+        testargs = [
+            "evaluate_cnn.py",
+            "patrickvonplaten/t5-tiny-random",
+            str(tmp),
+            str(output_file_name),
+            str(tmp),
+            str(score_file_name),
+        ]
+
+        with patch.object(sys, "argv", testargs):
+            run_generate()
+            self.assertTrue(Path(output_file_name).exists())
+            self.assertTrue(Path(score_file_name).exists())
@@ -61,6 +61,7 @@ export GLUE_DIR=/path/to/glue
 export TASK_NAME=MRPC

 python run_glue.py \
+  --model_type bert \
  --model_name_or_path bert-base-cased \
  --task_name $TASK_NAME \
  --do_train \
@@ -71,18 +72,6 @@ python run_glue.py \
  --learning_rate 2e-5 \
  --num_train_epochs 3.0 \
  --output_dir /tmp/$TASK_NAME/
-
-python run_nlp_glue.py \
-  --model_name_or_path bert-base-cased \
-  --task_name mrpc \
-  --do_train \
-  --do_eval \
-  --max_seq_length 128 \
-  --per_device_train_batch_size 32 \
-  --learning_rate 2e-5 \
-  --num_train_epochs 3.0 \
-  --output_dir /tmp/mrpc/ \
-  --overwrite_output_dir
 ```

 where task name can be one of CoLA, SST-2, MRPC, STS-B, QQP, MNLI, QNLI, RTE, WNLI.
@@ -269,7 +258,7 @@ TEST RESULTS {'val_loss': tensor(0.0707), 'precision': 0.852427800698191, 'recal

 Based on the script [`run_xnli.py`](https://github.com/huggingface/transformers/blob/master/examples/text-classification/run_xnli.py).

-[XNLI](https://www.nyu.edu/projects/bowman/xnli/) is a crowd-sourced dataset based on [MultiNLI](http://www.nyu.edu/projects/bowman/multinli/). It is an evaluation benchmark for cross-lingual text representations. Pairs of text are labeled with textual entailment annotations for 15 different languages (including both high-resource language such as English and low-resource languages such as Swahili).
+[XNLI](https://www.nyu.edu/projects/bowman/xnli/) is crowd-sourced dataset based on [MultiNLI](http://www.nyu.edu/projects/bowman/multinli/). It is an evaluation benchmark for cross-lingual text representations. Pairs of text are labeled with textual entailment annotations for 15 different languages (including both high-resource language such as English and low-resource languages such as Swahili).

 #### Fine-tuning on XNLI

@@ -284,6 +273,7 @@ on a single tesla V100 16GB. The data for XNLI can be downloaded with the follow
 export XNLI_DIR=/path/to/XNLI

 python run_xnli.py \
+  --model_type bert \
  --model_name_or_path bert-base-multilingual-cased \
  --language de \
  --train_language en \
@@ -21,7 +21,7 @@ import logging
 import os
 import sys
 from dataclasses import dataclass, field
-from typing import Callable, Dict, Optional
+from typing import Dict, Optional

 import numpy as np

@@ -134,29 +134,16 @@ def main():
    )

    # Get datasets
-    train_dataset = (
-        GlueDataset(data_args, tokenizer=tokenizer, cache_dir=model_args.cache_dir) if training_args.do_train else None
-    )
-    eval_dataset = (
-        GlueDataset(data_args, tokenizer=tokenizer, mode="dev", cache_dir=model_args.cache_dir)
-        if training_args.do_eval
-        else None
-    )
-    test_dataset = (
-        GlueDataset(data_args, tokenizer=tokenizer, mode="test", cache_dir=model_args.cache_dir)
-        if training_args.do_predict
-        else None
-    )
+    train_dataset = GlueDataset(data_args, tokenizer=tokenizer) if training_args.do_train else None
+    eval_dataset = GlueDataset(data_args, tokenizer=tokenizer, mode="dev") if training_args.do_eval else None
+    test_dataset = GlueDataset(data_args, tokenizer=tokenizer, mode="test") if training_args.do_predict else None

-    def build_compute_metrics_fn(task_name: str) -> Callable[[EvalPrediction], Dict]:
-        def compute_metrics_fn(p: EvalPrediction):
-            if output_mode == "classification":
-                preds = np.argmax(p.predictions, axis=1)
-            elif output_mode == "regression":
-                preds = np.squeeze(p.predictions)
-            return glue_compute_metrics(task_name, preds, p.label_ids)
-
-        return compute_metrics_fn
+    def compute_metrics(p: EvalPrediction) -> Dict:
+        if output_mode == "classification":
+            preds = np.argmax(p.predictions, axis=1)
+        elif output_mode == "regression":
+            preds = np.squeeze(p.predictions)
+        return glue_compute_metrics(data_args.task_name, preds, p.label_ids)

    # Initialize our Trainer
    trainer = Trainer(
@@ -164,7 +151,7 @@ def main():
        args=training_args,
        train_dataset=train_dataset,
        eval_dataset=eval_dataset,
-        compute_metrics=build_compute_metrics_fn(data_args.task_name),
+        compute_metrics=compute_metrics,
    )

    # Training
@@ -187,12 +174,9 @@ def main():
        eval_datasets = [eval_dataset]
        if data_args.task_name == "mnli":
            mnli_mm_data_args = dataclasses.replace(data_args, task_name="mnli-mm")
-            eval_datasets.append(
-                GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="dev", cache_dir=model_args.cache_dir)
-            )
+            eval_datasets.append(GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="dev"))

        for eval_dataset in eval_datasets:
-            trainer.compute_metrics = build_compute_metrics_fn(eval_dataset.args.task_name)
            eval_result = trainer.evaluate(eval_dataset=eval_dataset)

            output_eval_file = os.path.join(
@@ -212,9 +196,7 @@ def main():
        test_datasets = [test_dataset]
        if data_args.task_name == "mnli":
            mnli_mm_data_args = dataclasses.replace(data_args, task_name="mnli-mm")
-            test_datasets.append(
-                GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="test", cache_dir=model_args.cache_dir)
-            )
+            test_datasets.append(GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="test"))

        for test_dataset in test_datasets:
            predictions = trainer.predict(test_dataset=test_dataset).predictions
@@ -1,289 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
-# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-""" Finetuning the library models for sequence classification on GLUE (Bert, XLM, XLNet, RoBERTa, Albert, XLM-RoBERTa)."""
-
-
-import dataclasses
-import logging
-import os
-import sys
-from dataclasses import dataclass, field
-from typing import Callable, Dict, Optional
-
-import numpy as np
-
-import torch
-
-import nlp
-
-from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer, EvalPrediction
-from transformers import (
-    HfArgumentParser,
-    Trainer,
-    TrainingArguments,
-    glue_compute_metrics,
-    set_seed,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class GlueDataTrainingArguments:
-    """
-    Arguments pertaining to what data we are going to input our model for training and eval.
-
-    Using `HfArgumentParser` we can turn this class
-    into argparse arguments to be able to specify them on
-    the command line.
-    """
-
-    task_name: str = field(metadata={"help": "The name of the task to train and/or evaluate on: "
-        "['cola', 'sst2', 'mrpc', 'qqp', 'stsb', 'mnli', 'mnli_mismatched', 'mnli_matched', 'qnli', 'rte', 'wnli', 'ax']"})
-
-    max_seq_length: int = field(
-        default=128,
-        metadata={
-            "help": "The maximum total input sequence length after tokenization. Sequences longer "
-            "than this will be truncated, sequences shorter will be padded."
-        },
-    )
-
-    def __post_init__(self):
-        self.task_name = self.task_name.lower().replace('-', '')  # We used to allow 'sts-b' for 'stsb'
-
-
-@dataclass
-class ModelArguments:
-    """
-    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
-    """
-
-    model_name_or_path: str = field(
-        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
-    )
-    config_name: Optional[str] = field(
-        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
-    )
-    tokenizer_name: Optional[str] = field(
-        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
-    )
-    cache_dir: Optional[str] = field(
-        default=None, metadata={"help": "Where do you want to store the pretrained models downloaded from s3"}
-    )
-
-
-def main():
-    # See all possible arguments in src/transformers/training_args.py
-    # or by passing the --help flag to this script.
-    # We now keep distinct sets of args, for a cleaner separation of concerns.
-
-    parser = HfArgumentParser((ModelArguments, GlueDataTrainingArguments, TrainingArguments))
-
-    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
-        # If we pass only one argument to the script and it's the path to a json file,
-        # let's parse it to get our arguments.
-        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
-    else:
-        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
-
-    if (
-        os.path.exists(training_args.output_dir)
-        and os.listdir(training_args.output_dir)
-        and training_args.do_train
-        and not training_args.overwrite_output_dir
-    ):
-        raise ValueError(
-            f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
-        )
-
-    # Setup logging
-    logging.basicConfig(
-        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
-        datefmt="%m/%d/%Y %H:%M:%S",
-        level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
-    )
-    logger.warning(
-        "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
-        training_args.local_rank,
-        training_args.device,
-        training_args.n_gpu,
-        bool(training_args.local_rank != -1),
-        training_args.fp16,
-    )
-    logger.info("Training/evaluation parameters %s", training_args)
-
-    # Set seed
-    set_seed(training_args.seed)
-
-    # Get tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(
-        model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
-        cache_dir=model_args.cache_dir,
-        # use_fast=True,
-    )
-
-    # Download, tokenize and prepare datasets for training a PyTorch model
-    task_name = data_args.task_name.replace('-', '')  # We used to allow 'sts-b' for 'stsb'
-    glue = nlp.load_dataset('glue', name=task_name)
-
-    def tokenize(example):
-        return tokenizer.batch_encode_plus(list(zip(example['sentence1'], example['sentence2'])),
-                                           max_length=data_args.max_seq_length,
-                                           pad_to_max_length=True)
-    for split_name, split in glue.items():
-        # Tokenize the dataset (this adds columns to the dataset)
-        glue[split_name] = split.map(tokenize, batched=True)
-        # Set the format of the dataset to output only the column our model can digest
-        glue[split_name].set_format(columns=['input_ids', 'attention_mask', 'token_type_ids', 'label'])
-
-    # Get the splits
-    train_dataset, eval_dataset, test_dataset = None, None, None
-    if training_args.do_train:
-        train_dataset = glue['train']
-    if training_args.do_eval:
-        eval_dataset = glue['validation' + ('_matched' if task_name == 'mnli' else '')]
-    if training_args.do_predict:
-        test_dataset = glue['test' + ('_matched' if task_name == 'mnli' else '')]
-
-    # Define output mode (regression or classification) and num labels (to define the size of the last layer of the model)
-    output_mode = "regression" if 'float' in glue['train'].features['label'].dtype else "classification"
-    if output_mode == "regression":
-        num_labels = 1
-    else:
-        num_labels = len(train_dataset.unique('label'))
-
-
-    if task_name in ["mnli", "mnli-mm"] and tokenizer.__class__.__name__ in (
-        "RobertaTokenizer",
-        "RobertaTokenizerFast",
-        "XLMRobertaTokenizer",
-    ):
-        raise NotImplementedError("""
-        # HACK(label indices are swapped in RoBERTa pretrained model)
-        label_list[1], label_list[2] = label_list[2], label_list[1]
-        """)
-
-    # Load pretrained model and tokenizer
-    #
-    # Distributed training:
-    # The .from_pretrained methods guarantee that only one local process can concurrently
-    # download model & vocab.
-
-    config = AutoConfig.from_pretrained(
-        model_args.config_name if model_args.config_name else model_args.model_name_or_path,
-        num_labels=num_labels,
-        finetuning_task=data_args.task_name,
-        cache_dir=model_args.cache_dir,
-    )
-    model = AutoModelForSequenceClassification.from_pretrained(
-        model_args.model_name_or_path,
-        from_tf=bool(".ckpt" in model_args.model_name_or_path),
-        config=config,
-        cache_dir=model_args.cache_dir,
-    )
-
-    def build_compute_metrics_fn(task_name: str) -> Callable[[EvalPrediction], Dict]:
-        def compute_metrics_fn(p: EvalPrediction):
-            if output_mode == "classification":
-                preds = np.argmax(p.predictions, axis=1)
-            elif output_mode == "regression":
-                preds = np.squeeze(p.predictions)
-            return glue_compute_metrics(task_name, preds, p.label_ids)
-
-        return compute_metrics_fn
-
-    # Initialize our Trainer
-    trainer = Trainer(
-        model=model,
-        args=training_args,
-        train_dataset=train_dataset,
-        eval_dataset=eval_dataset,
-        compute_metrics=build_compute_metrics_fn(data_args.task_name),
-    )
-
-    # Training
-    if training_args.do_train:
-        trainer.train(
-            model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path) else None
-        )
-        trainer.save_model()
-        # For convenience, we also re-save the tokenizer to the same directory,
-        # so that you can share your model easily on huggingface.co/models =)
-        if trainer.is_world_master():
-            tokenizer.save_pretrained(training_args.output_dir)
-
-    # Evaluation
-    eval_results = {}
-    if training_args.do_eval:
-        logger.info("*** Evaluate ***")
-
-        # Loop to handle MNLI double evaluation (matched, mis-matched)
-        eval_datasets = [eval_dataset]
-        if data_args.task_name == "mnli":
-            eval_datasets.append(glue["validation_mismatched"])
-
-        for eval_dataset in eval_datasets:
-            trainer.compute_metrics = build_compute_metrics_fn(eval_dataset.args.task_name)
-            eval_result = trainer.evaluate(eval_dataset=eval_dataset)
-
-            output_eval_file = os.path.join(
-                training_args.output_dir, f"eval_results_{eval_dataset.args.task_name}.txt"
-            )
-            if trainer.is_world_master():
-                with open(output_eval_file, "w") as writer:
-                    logger.info("***** Eval results {} *****".format(eval_dataset.args.task_name))
-                    for key, value in eval_result.items():
-                        logger.info("  %s = %s", key, value)
-                        writer.write("%s = %s\n" % (key, value))
-
-            eval_results.update(eval_result)
-
-    if training_args.do_predict:
-        logging.info("*** Test ***")
-        test_datasets = [test_dataset]
-        if data_args.task_name == "mnli":
-            test_datasets.append(glue["test_mismatched"])
-
-        for test_dataset in test_datasets:
-            predictions = trainer.predict(test_dataset=test_dataset).predictions
-            if output_mode == "classification":
-                predictions = np.argmax(predictions, axis=1)
-
-            output_test_file = os.path.join(
-                training_args.output_dir, f"test_results_{test_dataset.args.task_name}.txt"
-            )
-            if trainer.is_world_master():
-                with open(output_test_file, "w") as writer:
-                    logger.info("***** Test results {} *****".format(test_dataset.args.task_name))
-                    writer.write("index\tprediction\n")
-                    for index, item in enumerate(predictions):
-                        if output_mode == "regression":
-                            writer.write("%d\t%3.3f\n" % (index, item))
-                        else:
-                            item = test_dataset.get_labels()[item]
-                            writer.write("%d\t%s\n" % (index, item))
-    return eval_results
-
-
-def _mp_fn(index):
-    # For xla_spawn (TPUs)
-    main()
-
-
-if __name__ == "__main__":
-    main()
@@ -13,7 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" Finetuning multi-lingual models on XNLI (e.g. Bert, DistilBERT, XLM).
+""" Finetuning multi-lingual models on XNLI (Bert, DistilBERT, XLM).
    Adapted from `examples/text-classification/run_glue.py`"""


@@ -32,9 +32,15 @@ from tqdm import tqdm, trange
 from transformers import (
    WEIGHTS_NAME,
    AdamW,
-    AutoConfig,
-    AutoModelForSequenceClassification,
-    AutoTokenizer,
+    BertConfig,
+    BertForSequenceClassification,
+    BertTokenizer,
+    DistilBertConfig,
+    DistilBertForSequenceClassification,
+    DistilBertTokenizer,
+    XLMConfig,
+    XLMForSequenceClassification,
+    XLMTokenizer,
    get_linear_schedule_with_warmup,
 )
 from transformers import glue_convert_examples_to_features as convert_examples_to_features
@@ -51,6 +57,16 @@ except ImportError:

 logger = logging.getLogger(__name__)

+ALL_MODELS = sum(
+    (tuple(conf.pretrained_config_archive_map.keys()) for conf in (BertConfig, DistilBertConfig, XLMConfig)), ()
+)
+
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertForSequenceClassification, BertTokenizer),
+    "xlm": (XLMConfig, XLMForSequenceClassification, XLMTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForSequenceClassification, DistilBertTokenizer),
+}
+

 def set_seed(args):
    random.seed(args.seed)
@@ -361,12 +377,19 @@ def main():
        required=True,
        help="The input data dir. Should contain the .tsv files (or other data files) for the task.",
    )
+    parser.add_argument(
+        "--model_type",
+        default=None,
+        type=str,
+        required=True,
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
+    )
    parser.add_argument(
        "--model_name_or_path",
        default=None,
        type=str,
        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models",
+        help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS),
    )
    parser.add_argument(
        "--language",
@@ -398,7 +421,7 @@ def main():
    )
    parser.add_argument(
        "--cache_dir",
-        default=None,
+        default="",
        type=str,
        help="Where do you want to store the pre-trained models downloaded from s3",
    )
@@ -539,23 +562,24 @@ def main():
    if args.local_rank not in [-1, 0]:
        torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab

-    config = AutoConfig.from_pretrained(
+    args.model_type = args.model_type.lower()
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    config = config_class.from_pretrained(
        args.config_name if args.config_name else args.model_name_or_path,
        num_labels=num_labels,
        finetuning_task=args.task_name,
-        cache_dir=args.cache_dir,
+        cache_dir=args.cache_dir if args.cache_dir else None,
    )
-    args.model_type = config.model_type
-    tokenizer = AutoTokenizer.from_pretrained(
+    tokenizer = tokenizer_class.from_pretrained(
        args.tokenizer_name if args.tokenizer_name else args.model_name_or_path,
        do_lower_case=args.do_lower_case,
-        cache_dir=args.cache_dir,
+        cache_dir=args.cache_dir if args.cache_dir else None,
    )
-    model = AutoModelForSequenceClassification.from_pretrained(
+    model = model_class.from_pretrained(
        args.model_name_or_path,
        from_tf=bool(".ckpt" in args.model_name_or_path),
        config=config,
-        cache_dir=args.cache_dir,
+        cache_dir=args.cache_dir if args.cache_dir else None,
    )

    if args.local_rank == 0:
@@ -590,13 +614,14 @@ def main():
        torch.save(args, os.path.join(args.output_dir, "training_args.bin"))

        # Load a trained model and vocabulary that you have fine-tuned
-        model = AutoModelForSequenceClassification.from_pretrained(args.output_dir)
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir)
+        model = model_class.from_pretrained(args.output_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir)
        model.to(args.device)

    # Evaluation
    results = {}
    if args.do_eval and args.local_rank in [-1, 0]:
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir, do_lower_case=args.do_lower_case)
        checkpoints = [args.output_dir]
        if args.eval_all_checkpoints:
            checkpoints = list(
@@ -608,7 +633,7 @@ def main():
            global_step = checkpoint.split("-")[-1] if len(checkpoints) > 1 else ""
            prefix = checkpoint.split("/")[-1] if checkpoint.find("checkpoint") != -1 else ""

-            model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+            model = model_class.from_pretrained(checkpoint)
            model.to(args.device)
            result = evaluate(args, model, tokenizer, prefix=prefix)
            result = dict((k + "_{}".format(global_step), v) for k, v in result.items())
@@ -17,7 +17,7 @@ Please check out the repo under uber-research for more information: https://gith
 git clone https://github.com/huggingface/transformers && cd transformers
 pip install .
 pip install nltk torchtext # additional requirements.
-cd examples/text-generation/pplm
+cd examples/pplm
 ```

 ## PPLM-BoW 
@@ -31,6 +31,7 @@ from typing import List, Optional, Tuple, Union
 import numpy as np
 import torch
 import torch.nn.functional as F
+from torch.autograd import Variable
 from tqdm import trange

 from pplm_classification_head import ClassificationHead
@@ -75,6 +76,14 @@ DISCRIMINATOR_MODELS_PARAMS = {
 }


+def to_var(x, requires_grad=False, volatile=False, device="cuda"):
+    if torch.cuda.is_available() and device == "cuda":
+        x = x.cuda()
+    elif device != "cuda":
+        x = x.to(device)
+    return Variable(x, requires_grad=requires_grad, volatile=volatile)
+
+
 def top_k_filter(logits, k, probs=False):
    """
    Masks everything but the k top entries as -infinity (1e10).
@@ -147,10 +156,9 @@ def perturb_past(
    new_accumulated_hidden = None
    for i in range(num_iterations):
        print("Iteration ", i + 1)
-        curr_perturbation = [torch.from_numpy(p_).requires_grad_(True).to(device=device) for p_ in grad_accumulator]
-        # make sure p_.grad is not None
-        for p_ in curr_perturbation:
-            p_.retain_grad()
+        curr_perturbation = [
+            to_var(torch.from_numpy(p_), requires_grad=True, device=device) for p_ in grad_accumulator
+        ]

        # Compute hidden using perturbed past
        perturbed_past = list(map(add, past, curr_perturbation))
@@ -239,7 +247,7 @@ def perturb_past(
        past = new_past

    # apply the accumulated perturbations to the past
-    grad_accumulator = [torch.from_numpy(p_).requires_grad_(True).to(device=device) for p_ in grad_accumulator]
+    grad_accumulator = [to_var(torch.from_numpy(p_), requires_grad=True, device=device) for p_ in grad_accumulator]
    pert_past = list(map(add, past, grad_accumulator))

    return pert_past, new_accumulated_hidden, grad_norms, loss_per_iter
@@ -258,7 +266,7 @@ def get_classifier(
    elif "path" in params:
        resolved_archive_file = params["path"]
    else:
-        raise ValueError("Either url or path have to be specified in the discriminator model parameters")
+        raise ValueError("Either url or path have to be specified " "in the discriminator model parameters")
    classifier.load_state_dict(torch.load(resolved_archive_file, map_location=device))
    classifier.eval()

@@ -561,9 +569,9 @@ def generate_text_pplm(

 def set_generic_model_params(discrim_weights, discrim_meta):
    if discrim_weights is None:
-        raise ValueError("When using a generic discriminator, discrim_weights need to be specified")
+        raise ValueError("When using a generic discriminator, " "discrim_weights need to be specified")
    if discrim_meta is None:
-        raise ValueError("When using a generic discriminator, discrim_meta need to be specified")
+        raise ValueError("When using a generic discriminator, " "discrim_meta need to be specified")

    with open(discrim_meta, "r") as discrim_meta_file:
        meta = json.load(discrim_meta_file)
@@ -611,7 +619,7 @@ def run_pplm_example(

    if discrim is not None:
        pretrained_model = DISCRIMINATOR_MODELS_PARAMS[discrim]["pretrained_model"]
-        print("discrim = {}, pretrained_model set to discriminator's = {}".format(discrim, pretrained_model))
+        print("discrim = {}, pretrained_model set " "to discriminator's = {}".format(discrim, pretrained_model))

    # load pretrained model
    model = GPT2LMHeadModel.from_pretrained(pretrained_model, output_hidden_states=True)
@@ -698,7 +706,7 @@ def run_pplm_example(
                for word_id in pert_gen_tok_text.tolist()[0]:
                    if word_id in bow_word_ids:
                        pert_gen_text += "{}{}{}".format(
-                            colorama.Fore.RED, tokenizer.decode([word_id]), colorama.Style.RESET_ALL,
+                            colorama.Fore.RED, tokenizer.decode([word_id]), colorama.Style.RESET_ALL
                        )
                    else:
                        pert_gen_text += tokenizer.decode([word_id])
@@ -736,11 +744,9 @@ if __name__ == "__main__":
        "-B",
        type=str,
        default=None,
-        help=(
-            "Bags of words used for PPLM-BoW. "
-            "Either a BOW id (see list in code) or a filepath. "
-            "Multiple BoWs separated by ;"
-        ),
+        help="Bags of words used for PPLM-BoW. "
+        "Either a BOW id (see list in code) or a filepath. "
+        "Multiple BoWs separated by ;",
    )
    parser.add_argument(
        "--discrim",
@@ -750,11 +756,9 @@ if __name__ == "__main__":
        choices=("clickbait", "sentiment", "toxicity", "generic"),
        help="Discriminator to use",
    )
+    parser.add_argument("--discrim_weights", type=str, default=None, help="Weights for the generic discriminator")
    parser.add_argument(
-        "--discrim_weights", type=str, default=None, help="Weights for the generic discriminator",
-    )
-    parser.add_argument(
-        "--discrim_meta", type=str, default=None, help="Meta information for the generic discriminator",
+        "--discrim_meta", type=str, default=None, help="Meta information for the generic discriminator"
    )
    parser.add_argument(
        "--class_label", type=int, default=-1, help="Class label used for the discriminator",
@@ -770,7 +774,7 @@ if __name__ == "__main__":
        "--window_length",
        type=int,
        default=0,
-        help="Length of past which is being optimized; 0 corresponds to infinite window length",
+        help="Length of past which is being optimized; " "0 corresponds to infinite window length",
    )
    parser.add_argument(
        "--horizon_length", type=int, default=1, help="Length of future to optimize over",
@@ -2,17 +2,10 @@

 Based on the scripts [`run_ner.py`](https://github.com/huggingface/transformers/blob/master/examples/token-classification/run_ner.py) for Pytorch and
 [`run_tf_ner.py`](https://github.com/huggingface/transformers/blob/master/examples/token-classification/run_tf_ner.py) for Tensorflow 2.
-
-The following examples are covered in this section:
-
-* NER on the GermEval 2014 (German NER) dataset
-* Emerging and Rare Entities task: WNUT’17 (English NER) dataset
-
+This example fine-tune Bert Multilingual on GermEval 2014 (German NER).
 Details and results for the fine-tuning provided by @stefan-it.

-### GermEval 2014 (German NER) dataset
-
-#### Data (Download and pre-processing steps)
+### Data (Download and pre-processing steps)

 Data can be obtained from the [GermEval 2014](https://sites.google.com/site/germeval2014ner/data) shared task page.

@@ -27,10 +20,11 @@ curl -L 'https://sites.google.com/site/germeval2014ner/data/NER-de-test.tsv?attr
 | grep -v "^#" | cut -f 2,3 | tr '\t' ' ' > test.txt.tmp
 ```

-The GermEval 2014 dataset contains some strange "control character" tokens like `'\x96', '\u200e', '\x95', '\xad' or '\x80'`.
-One problem with these tokens is, that `BertTokenizer` returns an empty token for them, resulting in misaligned `InputExample`s.
-The `preprocess.py` script located in the `scripts` folder a) filters these tokens and b) splits longer sentences into smaller ones (once the max. subtoken length is reached).
+The GermEval 2014 dataset contains some strange "control character" tokens like `'\x96', '\u200e', '\x95', '\xad' or '\x80'`. One problem with these tokens is, that `BertTokenizer` returns an empty token for them, resulting in misaligned `InputExample`s. I wrote a script that a) filters these tokens and b) splits longer sentences into smaller ones (once the max. subtoken length is reached).

+```bash
+wget "https://raw.githubusercontent.com/stefan-it/fine-tuned-berts-seq/master/scripts/preprocess.py"
+```
 Let's define some variables that we need for further pre-processing steps and training the model:

 ```bash
@@ -41,9 +35,9 @@ export BERT_MODEL=bert-base-multilingual-cased
 Run the pre-processing script on training, dev and test datasets:

 ```bash
-python3 scripts/preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
-python3 scripts/preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
-python3 scripts/preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
+python3 preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
+python3 preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
+python3 preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
 ```

 The GermEval 2014 dataset has much more labels than CoNLL-2002/2003 datasets, so an own set of labels must be used:
@@ -52,7 +46,7 @@ The GermEval 2014 dataset has much more labels than CoNLL-2002/2003 datasets, so
 cat train.txt dev.txt test.txt | cut -d " " -f 2 | grep -v "^$"| sort | uniq > labels.txt
 ```

-#### Prepare the run
+### Prepare the run

 Additional environment variables must be set:

@@ -64,7 +58,7 @@ export SAVE_STEPS=750
 export SEED=1
 ```

-#### Run the Pytorch version
+### Run the Pytorch version

 To start training, just run:

@@ -85,7 +79,7 @@ python3 run_ner.py --data_dir ./ \

 If your GPU supports half-precision training, just add the `--fp16` flag. After training, the model will be both evaluated on development and test datasets.

-#### JSON-based configuration file
+### JSON-based configuration file

 Instead of passing all parameters via commandline arguments, the `run_ner.py` script also supports reading parameters from a json-based configuration file:

@@ -130,6 +124,16 @@ On the test dataset the following results could be achieved:
 10/04/2019 00:42:42 - INFO - __main__ -     recall = 0.8624150210424085
 ```

+#### Comparing BERT (large, cased), RoBERTa (large, cased) and DistilBERT (base, uncased)
+
+Here is a small comparison between BERT (large, cased), RoBERTa (large, cased) and DistilBERT (base, uncased) with the same hyperparameters as specified in the [example documentation](https://huggingface.co/transformers/examples.html#named-entity-recognition) (one run):
+
+| Model | F-Score Dev | F-Score Test
+| --------------------------------- | ------- | --------
+| `bert-large-cased`            | 95.59 | 91.70
+| `roberta-large`                  | 95.96 | 91.87
+| `distilbert-base-uncased` | 94.34 | 90.32
+
 #### Run PyTorch version using PyTorch-Lightning

 Run `bash run_pl.sh` from the `ner` directory. This would also install `pytorch-lightning` and the `examples/requirements.txt`. It is a shell pipeline which would automatically download, pre-process the data and run the models in `germeval-model` directory. Logs are saved in `lightning_logs` directory.
@@ -137,7 +141,7 @@ Run `bash run_pl.sh` from the `ner` directory. This would also install `pytorch-
 Pass `--n_gpu` flag to change the number of GPUs. Default uses 1. At the end, the expected results are: `TEST RESULTS {'val_loss': tensor(0.0707), 'precision': 0.852427800698191, 'recall': 0.869537067011978, 'f1': 0.8608974358974358}`


-#### Run the Tensorflow 2 version
+### Run the Tensorflow 2 version

 To start training, just run:

@@ -201,102 +205,3 @@ On the test dataset the following results could be achieved:
 micro avg     0.8722    0.8774    0.8748     13869
 macro avg     0.8712    0.8774    0.8740     13869
 ```
-
-### Emerging and Rare Entities task: WNUT’17 (English NER) dataset
-
-Description of the WNUT’17 task from the [shared task website](http://noisy-text.github.io/2017/index.html):
-
-> The WNUT’17 shared task focuses on identifying unusual, previously-unseen entities in the context of emerging discussions.
-> Named entities form the basis of many modern approaches to other tasks (like event clustering and summarization), but recall on
-> them is a real problem in noisy text - even among annotators. This drop tends to be due to novel entities and surface forms.
-
-Six labels are available in the dataset. An overview can be found on this [page](http://noisy-text.github.io/2017/files/).
-
-#### Data (Download and pre-processing steps)
-
-The dataset can be downloaded from the [official GitHub](https://github.com/leondz/emerging_entities_17) repository.
-
-The following commands show how to prepare the dataset for fine-tuning:
-
-```bash
-mkdir -p data_wnut_17
-
-curl -L 'https://github.com/leondz/emerging_entities_17/raw/master/wnut17train.conll'  | tr '\t' ' ' > data_wnut_17/train.txt.tmp
-curl -L 'https://github.com/leondz/emerging_entities_17/raw/master/emerging.dev.conll' | tr '\t' ' ' > data_wnut_17/dev.txt.tmp
-curl -L 'https://raw.githubusercontent.com/leondz/emerging_entities_17/master/emerging.test.annotated' | tr '\t' ' ' > data_wnut_17/test.txt.tmp
-```
-
-Let's define some variables that we need for further pre-processing steps:
-
-```bash
-export MAX_LENGTH=128
-export BERT_MODEL=bert-large-cased
-```
-
-Here we use the English BERT large model for fine-tuning.
-The `preprocess.py` scripts splits longer sentences into smaller ones (once the max. subtoken length is reached):
-
-```bash
-python3 scripts/preprocess.py data_wnut_17/train.txt.tmp $BERT_MODEL $MAX_LENGTH > data_wnut_17/train.txt
-python3 scripts/preprocess.py data_wnut_17/dev.txt.tmp $BERT_MODEL $MAX_LENGTH > data_wnut_17/dev.txt
-python3 scripts/preprocess.py data_wnut_17/test.txt.tmp $BERT_MODEL $MAX_LENGTH > data_wnut_17/test.txt
-```
-
-In the last pre-processing step, the `labels.txt` file needs to be generated. This file contains all available labels:
-
-```bash
-cat data_wnut_17/train.txt data_wnut_17/dev.txt data_wnut_17/test.txt | cut -d " " -f 2 | grep -v "^$"| sort | uniq > data_wnut_17/labels.txt
-```
-
-#### Run the Pytorch version
-
-Fine-tuning with the PyTorch version can be started using the `run_ner.py` script. In this example we use a JSON-based configuration file.
-
-This configuration file looks like:
-
-```json
-{
-    "data_dir": "./data_wnut_17",
-    "labels": "./data_wnut_17/labels.txt",
-    "model_name_or_path": "bert-large-cased",
-    "output_dir": "wnut-17-model-1",
-    "max_seq_length": 128,
-    "num_train_epochs": 3,
-    "per_device_train_batch_size": 32,
-    "save_steps": 425,
-    "seed": 1,
-    "do_train": true,
-    "do_eval": true,
-    "do_predict": true,
-    "fp16": false
-}
-```
-
-If your GPU supports half-precision training, please set `fp16` to `true`.
-
-Save this JSON-based configuration under `wnut_17.json`. The fine-tuning can be started with `python3 run_ner.py wnut_17.json`.
-
-#### Evaluation
-
-Evaluation on development dataset outputs the following:
-
-```bash
-05/29/2020 23:33:44 - INFO - __main__ -   ***** Eval results *****
-05/29/2020 23:33:44 - INFO - __main__ -     eval_loss = 0.26505235286212275
-05/29/2020 23:33:44 - INFO - __main__ -     eval_precision = 0.7008264462809918
-05/29/2020 23:33:44 - INFO - __main__ -     eval_recall = 0.507177033492823
-05/29/2020 23:33:44 - INFO - __main__ -     eval_f1 = 0.5884802220680084
-05/29/2020 23:33:44 - INFO - __main__ -     epoch = 3.0
-```
-
-On the test dataset the following results could be achieved:
-
-```bash
-05/29/2020 23:33:44 - INFO - transformers.trainer -   ***** Running Prediction *****
-05/29/2020 23:34:02 - INFO - __main__ -     eval_loss = 0.30948806500973547
-05/29/2020 23:34:02 - INFO - __main__ -     eval_precision = 0.5840108401084011
-05/29/2020 23:34:02 - INFO - __main__ -     eval_recall = 0.3994439295644115
-05/29/2020 23:34:02 - INFO - __main__ -     eval_f1 = 0.47440836543753434
-```
-
-WNUT’17 is a very difficult task. Current state-of-the-art results on this dataset can be found [here](http://nlpprogress.com/english/named_entity_recognition.html).
@@ -4,12 +4,12 @@ curl -L 'https://sites.google.com/site/germeval2014ner/data/NER-de-dev.tsv?attre
 | grep -v "^#" | cut -f 2,3 | tr '\t' ' ' > dev.txt.tmp
 curl -L 'https://sites.google.com/site/germeval2014ner/data/NER-de-test.tsv?attredirects=0&d=1' \
 | grep -v "^#" | cut -f 2,3 | tr '\t' ' ' > test.txt.tmp
-
+wget "https://raw.githubusercontent.com/stefan-it/fine-tuned-berts-seq/master/scripts/preprocess.py"
 export MAX_LENGTH=128
 export BERT_MODEL=bert-base-multilingual-cased
-python3 scripts/preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
-python3 scripts/preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
-python3 scripts/preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
+python3 preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
+python3 preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
+python3 preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
 cat train.txt dev.txt test.txt | cut -d " " -f 2 | grep -v "^$"| sort | uniq > labels.txt
 export OUTPUT_DIR=germeval-model
 export BATCH_SIZE=32
@@ -13,7 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" Fine-tuning the library models for named entity recognition on CoNLL-2003. """
+""" Fine-tuning the library models for named entity recognition on CoNLL-2003 (Bert or Roberta). """


 import logging
@@ -11,12 +11,12 @@ curl -L 'https://sites.google.com/site/germeval2014ner/data/NER-de-dev.tsv?attre
 | grep -v "^#" | cut -f 2,3 | tr '\t' ' ' > dev.txt.tmp
 curl -L 'https://sites.google.com/site/germeval2014ner/data/NER-de-test.tsv?attredirects=0&d=1' \
 | grep -v "^#" | cut -f 2,3 | tr '\t' ' ' > test.txt.tmp
-
+wget "https://raw.githubusercontent.com/stefan-it/fine-tuned-berts-seq/master/scripts/preprocess.py"
 export MAX_LENGTH=128
 export BERT_MODEL=bert-base-multilingual-cased
-python3 scripts/preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
-python3 scripts/preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
-python3 scripts/preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
+python3 preprocess.py train.txt.tmp $BERT_MODEL $MAX_LENGTH > train.txt
+python3 preprocess.py dev.txt.tmp $BERT_MODEL $MAX_LENGTH > dev.txt
+python3 preprocess.py test.txt.tmp $BERT_MODEL $MAX_LENGTH > test.txt
 cat train.txt dev.txt test.txt | cut -d " " -f 2 | grep -v "^$"| sort | uniq > labels.txt
 export BATCH_SIZE=32
 export NUM_EPOCHS=3
@@ -65,7 +65,7 @@ class NERTransformer(BaseTransformer):
                    cls_token=self.tokenizer.cls_token,
                    cls_token_segment_id=2 if self.config.model_type in ["xlnet"] else 0,
                    sep_token=self.tokenizer.sep_token,
-                    sep_token_extra=False,
+                    sep_token_extra=bool(self.config.model_type in ["roberta"]),
                    pad_on_left=bool(self.config.model_type in ["xlnet"]),
                    pad_token=self.tokenizer.pad_token_id,
                    pad_token_segment_id=self.tokenizer.pad_token_type_id,
@@ -1,41 +0,0 @@
-import sys
-
-from transformers import AutoTokenizer
-
-
-dataset = sys.argv[1]
-model_name_or_path = sys.argv[2]
-max_len = int(sys.argv[3])
-
-subword_len_counter = 0
-
-tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
-max_len -= tokenizer.num_special_tokens_to_add()
-
-with open(dataset, "rt") as f_p:
-    for line in f_p:
-        line = line.rstrip()
-
-        if not line:
-            print(line)
-            subword_len_counter = 0
-            continue
-
-        token = line.split()[0]
-
-        current_subwords_len = len(tokenizer.tokenize(token))
-
-        # Token contains strange control characters like \x96 or \x95
-        # Just filter out the complete line
-        if current_subwords_len == 0:
-            continue
-
-        if (subword_len_counter + current_subwords_len) > max_len:
-            print("")
-            print(line)
-            subword_len_counter = current_subwords_len
-            continue
-
-        subword_len_counter += current_subwords_len
-
-        print(line)
@@ -119,7 +119,7 @@ if is_torch_available():
                        cls_token=tokenizer.cls_token,
                        cls_token_segment_id=2 if model_type in ["xlnet"] else 0,
                        sep_token=tokenizer.sep_token,
-                        sep_token_extra=False,
+                        sep_token_extra=bool(model_type in ["roberta"]),
                        # roberta uses an extra separator b/w pairs of sentences, cf. github.com/pytorch/fairseq/commit/1684e166e3da03f5b600dbb7855cb98ddfcd0805
                        pad_on_left=bool(tokenizer.padding_side == "left"),
                        pad_token=tokenizer.pad_token_id,
@@ -172,7 +172,7 @@ if is_tf_available():
                cls_token=tokenizer.cls_token,
                cls_token_segment_id=2 if model_type in ["xlnet"] else 0,
                sep_token=tokenizer.sep_token,
-                sep_token_extra=False,
+                sep_token_extra=bool(model_type in ["roberta"]),
                # roberta uses an extra separator b/w pairs of sentences, cf. github.com/pytorch/fairseq/commit/1684e166e3da03f5b600dbb7855cb98ddfcd0805
                pad_on_left=bool(tokenizer.padding_side == "left"),
                pad_token=tokenizer.pad_token_id,
@@ -1,26 +0,0 @@
-# BERT-Small CORD-19 fine-tuned on SQuAD 2.0
-
-[bert-small-cord19 model](https://huggingface.co/NeuML/bert-small-cord19) fine-tuned on SQuAD 2.0
-
-## Building the model
-
-```bash
-python run_squad.py
-    --model_type bert
-    --model_name_or_path bert-small-cord19
-    --do_train
-    --do_eval
-    --do_lower_case
-    --version_2_with_negative
-    --train_file train-v2.0.json
-    --predict_file dev-v2.0.json
-    --per_gpu_train_batch_size 8
-    --learning_rate 3e-5
-    --num_train_epochs 3.0
-    --max_seq_length 384
-    --doc_stride 128
-    --output_dir bert-small-cord19-squad2
-    --save_steps 0
-    --threads 8
-    --overwrite_cache
-    --overwrite_output_dir
@@ -1,25 +0,0 @@
-# BERT-Small fine-tuned on CORD-19 dataset
-
-[BERT L6_H-512_A-8 model](https://huggingface.co/google/bert_uncased_L-6_H-512_A-8) fine-tuned on the [CORD-19 dataset](https://www.semanticscholar.org/cord19).
-
-## CORD-19 data subset
-The training data for this dataset is stored as a [Kaggle dataset](https://www.kaggle.com/davidmezzetti/cord19-qa?select=cord19.txt). The training
-data is a subset of the full corpus, focusing on high-quality, study-design detected articles.
-
-## Building the model
-
-```bash
-python run_language_modeling.py
-    --model_type bert
-    --model_name_or_path google/bert_uncased_L-6_H-512_A-8
-    --do_train
-    --mlm
-    --line_by_line
-    --block_size 512
-    --train_data_file cord19.txt
-    --per_gpu_train_batch_size 4
-    --learning_rate 3e-5
-    --num_train_epochs 3.0
-    --output_dir bert-small-cord19
-    --save_steps 0
-    --overwrite_output_dir
@@ -1,63 +0,0 @@
-# BERT-Small fine-tuned on CORD-19 QA dataset
-
-[bert-small-cord19-squad model](https://huggingface.co/NeuML/bert-small-cord19-squad2) fine-tuned on the [CORD-19 QA dataset](https://www.kaggle.com/davidmezzetti/cord19-qa?select=cord19-qa.json).
-
-## CORD-19 QA dataset
-The CORD-19 QA dataset is a SQuAD 2.0 formatted list of question, context, answer combinations covering the [CORD-19 dataset](https://www.semanticscholar.org/cord19).
-
-## Building the model
-
-```bash
-python run_squad.py \
-    --model_type bert \
-    --model_name_or_path bert-small-cord19-squad \
-    --do_train \
-    --do_lower_case \
-    --version_2_with_negative \
-    --train_file cord19-qa.json \
-    --per_gpu_train_batch_size 8 \
-    --learning_rate 5e-5 \
-    --num_train_epochs 10.0 \
-    --max_seq_length 384 \
-    --doc_stride 128 \
-    --output_dir bert-small-cord19qa \
-    --save_steps 0 \
-    --threads 8 \
-    --overwrite_cache \
-    --overwrite_output_dir
-```
-
-## Testing the model
-
-Example usage below:
-
-```python
-from transformers import pipeline
-
-qa = pipeline(
-    "question-answering",
-    model="NeuML/bert-small-cord19qa",
-    tokenizer="NeuML/bert-small-cord19qa"
-)
-
-qa({
-    "question": "What is the median incubation period?",
-    "context": "The incubation period is around 5 days (range: 4-7 days) with a maximum of 12-13 day"
-})
-
-qa({
-    "question": "What is the incubation period range?",
-    "context": "The incubation period is around 5 days (range: 4-7 days) with a maximum of 12-13 day"
-})
-
-qa({
-    "question": "What type of surfaces does it persist?",
-    "context": "The virus can survive on surfaces for up to 72 hours such as plastic and stainless steel ."
-})
-```
-
-```json
-{"score": 0.5970273583242793, "start": 32, "end": 38, "answer": "5 days"}
-{"score": 0.999555868193891, "start": 39, "end": 56, "answer": "(range: 4-7 days)"}
-{"score": 0.9992726505196998, "start": 61, "end": 88, "answer": "plastic and stainless steel"}
-```
@@ -1,7 +1,5 @@
 ---
 thumbnail: https://raw.githubusercontent.com/JetRunner/BERT-of-Theseus/master/bert-of-theseus.png
-datasets:
- multi_nli
 ---

 # BERT-of-Theseus
@@ -1,8 +1,3 @@
---
-datasets:
- squad_v2
---
-
 # roberta-base for QA 

 ## Overview
@@ -1,10 +0,0 @@
-The Bart model was proposed by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer on 29 Oct, 2019. According to the abstract,
-
-Bart uses a standard seq2seq/machine translation architecture with a bidirectional encoder (like BERT) and a left-to-right decoder (like GPT).
-
-The pretraining task involves randomly shuffling the order of the original sentences and a novel in-filling scheme, where spans of text are replaced with a single mask token.
-
-BART is particularly effective when fine tuned for text generation but also works well for comprehension tasks. It matches the performance of RoBERTa with comparable training resources on GLUE and SQuAD, achieves new state-of-the-art results on a range of abstractive dialogue, question answering, and summarization tasks, with gains of up to 6 ROUGE.
-
-The Authors’ code can be found here:
-https://github.com/pytorch/fairseq/tree/master/examples/bart
@@ -1,3 +0,0 @@
-GPT-2 (774M model) finetuned on 0.5m PubMed abstracts. Used in the [writemeanabstract.com](writemeanabstract.com) and the following preprint:
-
-[Papanikolaou, Yannis, and Andrea Pierleoni. "DARE: Data Augmented Relation Extraction with GPT-2." arXiv preprint arXiv:2004.13845 (2020).](https://arxiv.org/abs/2004.13845)
@@ -1,3 +0,0 @@
-GPT-2 (355M model) finetuned on 0.5m PubMed abstracts. Used in the [writemeanabstract.com](writemeanabstract.com) and the following preprint:
-
-[Papanikolaou, Yannis, and Andrea Pierleoni. "DARE: Data Augmented Relation Extraction with GPT-2." arXiv preprint arXiv:2004.13845 (2020).](https://arxiv.org/abs/2004.13845)
@@ -1,3 +0,0 @@
-## FinBERT
-
-Code for importing and using this model is available [here](https://github.com/ipuneetrathore/BERT_models)
@@ -1,7 +1,6 @@
 ---
 language: english
-datasets:
- squad_v2
+thumbnail:
 ---

 # Longformer-base-4096 fine-tuned on SQuAD v2
@@ -18,19 +17,13 @@ Longformer uses a combination of a sliding window (local) attention and global a

 ## Details of the downstream task (Q&A) - Dataset 📚 🧐 ❓

-Dataset ID: ```squad_v2``` from  [HugginFace/NLP](https://github.com/huggingface/nlp)
+[SQuAD v2](https://rajpurkar.github.io/SQuAD-explorer/) combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions written adversarially by crowdworkers to look similar to answerable ones. To do well on SQuAD2.0, systems must not only answer questions when possible, but also determine when no answer is supported by the paragraph and abstain from answering.
+
 | Dataset  | Split | # samples |
 | -------- | ----- | --------- |
-| squad_v2 | train | 130319      |
-| squad_v2 | valid  | 11873     |
+| SQuAD2.0 | train | 130k      |
+| SQuAD2.0 | eval  | 12.3k     |

-How to load it from [nlp](https://github.com/huggingface/nlp)
-
-```python
-train_dataset  = nlp.load_dataset('squad_v2', split=nlp.Split.TRAIN)
-valid_dataset = nlp.load_dataset('squad_v2', split=nlp.Split.VALIDATION)
-```
-Check out more about this dataset and others in [NLP Viewer](https://huggingface.co/nlp/viewer/)


 ## Model fine-tuning 🏋️‍
@@ -1,73 +0,0 @@
---
-language: english
-thumbnail:
---
-
-# T5-base fine-tuned for Sentiment Span Extraction
-
-All credits to [Lorenzo Ampil](https://twitter.com/AND__SO)
-
-[Google's T5](https://ai.googleblog.com/2020/02/exploring-transfer-learning-with-t5.html) base fine-tuned on [Tweet Sentiment Extraction Dataset](https://www.kaggle.com/c/tweet-sentiment-extraction) for **Span Sentiment Extraction** downstream task.
-
-## Details of T5
-
-The **T5** model was presented in [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/pdf/1910.10683.pdf) by *Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu* in Here the abstract:
-
-Transfer learning, where a model is first pre-trained on a data-rich task before being fine-tuned on a downstream task, has emerged as a powerful technique in natural language processing (NLP). The effectiveness of transfer learning has given rise to a diversity of approaches, methodology, and practice. In this paper, we explore the landscape of transfer learning techniques for NLP by introducing a unified framework that converts every language problem into a text-to-text format. Our systematic study compares pre-training objectives, architectures, unlabeled datasets, transfer approaches, and other factors on dozens of language understanding tasks. By combining the insights from our exploration with scale and our new “Colossal Clean Crawled Corpus”, we achieve state-of-the-art results on many benchmarks covering summarization, question answering, text classification, and more. To facilitate future work on transfer learning for NLP, we release our dataset, pre-trained models, and code.
-
-
-## Details of the downstream task (Span Sentiment Extraction) - Dataset 📚
-
-[Tweet Sentiment Extraction Dataset](https://www.kaggle.com/c/tweet-sentiment-extraction)
-
-"My ridiculous dog is amazing." [sentiment: positive]
-
-With all of the tweets circulating every second it is hard to tell whether the sentiment behind a specific tweet will impact a company, or a person's, brand for being viral (positive), or devastate profit because it strikes a negative tone. Capturing sentiment in language is important in these times where decisions and reactions are created and updated in seconds. But, which words actually lead to the sentiment description? In this competition you will need to pick out the part of the tweet (word or phrase) that reflects the sentiment.
-
-Help build your skills in this important area with this broad dataset of tweets. Work on your technique to grab a top spot in this competition. What words in tweets support a positive, negative, or neutral sentiment? How can you help make that determination using machine learning tools?
-
-In this competition we've extracted support phrases from Figure Eight's Data for Everyone platform. The dataset is titled Sentiment Analysis: Emotion in Text tweets with existing sentiment labels, used here under creative commons attribution 4.0. international licence. Your objective in this competition is to construct a model that can do the same - look at the labeled sentiment for a given tweet and figure out what word or phrase best supports it.
-
-Disclaimer: The dataset for this competition contains text that may be considered profane, vulgar, or offensive.
-
-| Dataset  | Split | # samples |
-| -------- | ----- | --------- |
-| TSE | train | 23907      |
-| TSE | eval  | 3573     |
-
-
-
-## Model fine-tuning 🏋️‍
-
-The training script is a slightly modified version of [this Colab Notebook](https://github.com/enzoampil/t5-intro/blob/master/t5_qa_training_pytorch_span_extraction.ipynb) created by [Lorenzo Ampil](https://github.com/enzoampil), so all credits to him!
-
-
-## Model in Action 🚀
-
-```python
-from transformers import AutoModelWithLMHead, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-span-sentiment-extraction")
-model = AutoModelWithLMHead.from_pretrained("mrm8488/t5-base-finetuned-span-sentiment-extraction")
-
-def get_sentiment_span(text):
-  input_ids = tokenizer.encode(text, return_tensors="pt", add_special_tokens=True)  # Batch size 1
-  
-  generated_ids = model.generate(input_ids=input_ids, num_beams=1, max_length=80).squeeze()
-  
-  predicted_span = tokenizer.decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
-    
-  return predicted_span
-  
-get_sentiment_span("question: negative context: My bike was put on hold...should have known that.... argh total bummer")
-
-# output: 'argh total bummer'
-
-get_sentiment_span("question: positive context: On the monday, so i wont be able to be with you! i love you")
-
-# output: 'i love you'
-```
-
-> Created by [Manuel Romero/@mrm8488](https://twitter.com/mrm8488) | [LinkedIn](https://www.linkedin.com/in/manuel-romero-cs/)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in Spain
@@ -1,7 +1,6 @@
 ---
 language: english
-datasets:
- squad_v2
+thumbnail:
 ---

 # T5-base fine-tuned on SQuAD v2
@@ -17,19 +16,13 @@ Transfer learning, where a model is first pre-trained on a data-rich task before

 ## Details of the downstream task (Q&A) - Dataset 📚 🧐 ❓

-Dataset ID: ```squad_v2``` from  [HugginFace/NLP](https://github.com/huggingface/nlp)
+[SQuAD v2](https://rajpurkar.github.io/SQuAD-explorer/) combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions written adversarially by crowdworkers to look similar to answerable ones. To do well on SQuAD2.0, systems must not only answer questions when possible, but also determine when no answer is supported by the paragraph and abstain from answering.
+
 | Dataset  | Split | # samples |
 | -------- | ----- | --------- |
-| squad_v2 | train | 130319      |
-| squad_v2 | valid  | 11873     |
+| SQuAD2.0 | train | 130k      |
+| SQuAD2.0 | eval  | 12.3k     |

-How to load it from [nlp](https://github.com/huggingface/nlp)
-
-```python
-train_dataset  = nlp.load_dataset('squad_v2', split=nlp.Split.TRAIN)
-valid_dataset = nlp.load_dataset('squad_v2', split=nlp.Split.VALIDATION)
-```
-Check out more about this dataset and others in [NLP Viewer](https://huggingface.co/nlp/viewer/)


 ## Model fine-tuning 🏋️‍
@@ -1,64 +0,0 @@
---
-language: english
-thumbnail:
---
-
-# T5-base fine-tuned fo News Summarization 📖✏️🧾
-
-All credits to [Abhishek Kumar Mishra](https://github.com/abhimishra91)
-
-[Google's T5](https://ai.googleblog.com/2020/02/exploring-transfer-learning-with-t5.html) base fine-tuned on [News Summary](https://www.kaggle.com/sunnysai12345/news-summary) dataset for **summarization** downstream task.
-
-## Details of T5
-
-The **T5** model was presented in [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/pdf/1910.10683.pdf) by *Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu* in Here the abstract:
-
-Transfer learning, where a model is first pre-trained on a data-rich task before being fine-tuned on a downstream task, has emerged as a powerful technique in natural language processing (NLP). The effectiveness of transfer learning has given rise to a diversity of approaches, methodology, and practice. In this paper, we explore the landscape of transfer learning techniques for NLP by introducing a unified framework that converts every language problem into a text-to-text format. Our systematic study compares pre-training objectives, architectures, unlabeled datasets, transfer approaches, and other factors on dozens of language understanding tasks. By combining the insights from our exploration with scale and our new “Colossal Clean Crawled Corpus”, we achieve state-of-the-art results on many benchmarks covering summarization, question answering, text classification, and more. To facilitate future work on transfer learning for NLP, we release our dataset, pre-trained models, and code.
-
-![model image](https://camo.githubusercontent.com/623b4dea0b653f2ad3f36c71ebfe749a677ac0a1/68747470733a2f2f6d69726f2e6d656469756d2e636f6d2f6d61782f343030362f312a44304a31674e51663876727255704b657944387750412e706e67)
-
-## Details of the downstream task (Summarization) - Dataset 📚
-
-[News Summary](https://www.kaggle.com/sunnysai12345/news-summary)
-
-The dataset consists of **4515 examples** and contains Author_name, Headlines, Url of Article, Short text, Complete Article. I gathered the summarized news from Inshorts and only scraped the news articles from Hindu, Indian times and Guardian. Time period ranges from febrauary to august 2017.
-
-
-
-
-## Model fine-tuning 🏋️‍
-
-The training script is a slightly modified version of [this Colab Notebook](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_summarization_wandb.ipynb) created by [Abhishek Kumar Mishra](https://github.com/abhimishra91), so all credits to him!
-I also trained the model for more epochs (6).
-
-
-## Model in Action 🚀
-
-```python
-from transformers import AutoModelWithLMHead, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-summarize-news")
-model = AutoModelWithLMHead.from_pretrained("mrm8488/t5-base-finetuned-summarize-news")
-
-def summarize(text, max_length=150):
-  input_ids = tokenizer.encode(text, return_tensors="pt", add_special_tokens=True)
-
-  generated_ids = model.generate(input_ids=input_ids, num_beams=2, max_length=max_length,  repetition_penalty=2.5, length_penalty=1.0, early_stopping=True)
-
-  preds = [tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=True) for g in generated_ids]
-
-  return preds[0]
-```
-Given the following article from **NYT** (2020/06/09) with title *George Floyd’s death energized a movement. He will be buried in Houston today*:
-
-After the sound and the fury, weeks of demonstrations and anguished calls for racial justice, the man whose death gave rise to an international movement, and whose last words — “I can’t breathe” — have been a rallying cry, will be laid to rest on Tuesday at a private funeral in Houston.George Floyd, who was 46, will then be buried in a grave next to his mother’s.The service, scheduled to begin at 11 a.m. at the Fountain of Praise church, comes after five days of public memorials in Minneapolis, North Carolina and Houston and two weeks after a Minneapolis police officer was caught on video pressing his knee into Mr. Floyd’s neck for nearly nine minutes before Mr. Floyd died. That officer, Derek Chauvin, has been charged with second-degree murder and second-degree manslaughter. His bail was set at $1.25 million in a court appearance on Monday. The outpouring of anger and outrage after Mr. Floyd’s death — and the speed at which protests spread from tense, chaotic demonstrations in the city where he died to an international movement from Rome to Rio de Janeiro — has reflected the depth of frustration borne of years of watching black people die at the hands of the police or vigilantes while calls for change went unmet.
-```
-summarize('After the sound and the fury, weeks of demonstrations and anguished calls for racial justice, the man whose death gave rise to an international movement, and whose last words — “I can’t breathe” — have been a rallying cry, will be laid to rest on Tuesday at a private funeral in Houston.George Floyd, who was 46, will then be buried in a grave next to his mother’s.The service, scheduled to begin at 11 a.m. at the Fountain of Praise church, comes after five days of public memorials in Minneapolis, North Carolina and Houston and two weeks after a Minneapolis police officer was caught on video pressing his knee into Mr. Floyd’s neck for nearly nine minutes before Mr. Floyd died. That officer, Derek Chauvin, has been charged with second-degree murder and second-degree manslaughter. His bail was set at $1.25 million in a court appearance on Monday. The outpouring of anger and outrage after Mr. Floyd’s death — and the speed at which protests spread from tense, chaotic demonstrations in the city where he died to an international movement from Rome to Rio de Janeiro — has reflected the depth of frustration borne of years of watching black people die at the hands of the police or vigilantes while calls for change went unmet.', 80)
-```
-We would obtain:
-
-At a private funeral in Houston. Floyd, who was 46 years old when his death occurred, will be buried next to the grave of his mother. A Minnesota police officer was caught on video pressing his knee into Mr's neck for nearly nine minutes before his death. The officer has been charged with second-degree manslaughter and $1.2 million bail is set at
-
-> Created by [Manuel Romero/@mrm8488](https://twitter.com/mrm8488) | [LinkedIn](https://www.linkedin.com/in/manuel-romero-cs/)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in Spain
@@ -1,99 +0,0 @@
---
-language: sanskrit
---
-
-# RoBERTa trained on Sanskrit (SanBERTa)
-
-**Mode size** (after training): **340MB**
-
-### Dataset:
-
-[Wikipedia articles](https://www.kaggle.com/disisbig/sanskrit-wikipedia-articles) (used in [iNLTK](https://github.com/goru001/nlp-for-sanskrit)).
-It contains evaluation set.
-
-[Sanskrit scraps from CLTK](http://cltk.org/)
-
-### Configuration
-
-| Parameter | Value |
-|---|---|
-| `num_attention_heads` | 12 |
-| `num_hidden_layers` | 6 |
-| `hidden_size` | 768 |
-| `vocab_size` | 29407 |
-
-### Training :
- On TPU
- For language modelling
- Iteratively increasing `--block_size` from 128 to 256 over epochs
-
-### Evaluation
-
-|Metric| # Value |
-|---|---|
-|Perplexity (`block_size=256`)|4.04|
-
-## Example of usage:
-
-### For Embeddings
-
-```
-
-tokenizer = AutoTokenizer.from_pretrained("surajp/SanBERTa")
-model = RobertaModel.from_pretrained("surajp/SanBERTa")
-
-op = tokenizer.encode("इयं भाषा न केवलं भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।", return_tensors="pt")
-ps = model(op)
-ps[0].shape
-
-```
-```
-'''
-Output:
--------
-torch.Size([1, 47, 768])
-
-```
-
-
-### For \<mask\> Prediction
-
-```
-from transformers import pipeline
-
-fill_mask = pipeline(
-    "fill-mask",
-    model="surajp/SanBERTa",
-    tokenizer="surajp/SanBERTa"
-)
-
-## इयं भाषा न केवलं भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।
-fill_mask("इयं भाषा न केवल<mask> भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।")
-
-ps = model(torch.tensor(enc).unsqueeze(1))
-print(ps[0].shape)
-```
-```
-'''
-Output:
--------
-[{'score': 0.7516744136810303,
-  'sequence': '<s> इयं भाषा न केवलं भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।</s>',
-  'token': 280,
-  'token_str': 'à¤Ĥ'},
- {'score': 0.06230105459690094,
-  'sequence': '<s> इयं भाषा न केवली भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।</s>',
-  'token': 289,
-  'token_str': 'à¥Ģ'},
- {'score': 0.055410224944353104,
-  'sequence': '<s> इयं भाषा न केवला भारतस्य अपि तु विश्वस्य प्राचीनतमा भाषा इति मन्यते।</s>',
-  'token': 265,
-  'token_str': 'à¤¾'},
-  ...]
-```
-
-### It works!! 🎉 🎉 🎉
-
-> Created by [Suraj Parmar/@parmarsuraj99](https://twitter.com/parmarsuraj99) | [LinkedIn](https://www.linkedin.com/in/parmarsuraj99/)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in India
@@ -1,40 +0,0 @@
---
-language: french
---
-
-# tf-allociné
-
-A french sentiment analysis model, based on [CamemBERT](https://camembert-model.fr/), and finetuned on a large-scale dataset scraped from [Allociné.fr](http://www.allocine.fr/) user reviews.
-
-## Results
-
-| Validation Accuracy | Validation F1-Score | Test Accuracy | Test F1-Score |
-|--------------------:| -------------------:| -------------:|--------------:|
-|               97.39 |               97.36 |         97.44 |         97.34 |
-
-The dataset and the evaluation code are available on [this repo](https://github.com/TheophileBlard/french-sentiment-analysis-with-bert).
-
-## Usage
-
-```python
-from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
-from transformers import pipeline
-
-tokenizer = AutoTokenizer.from_pretrained("tblard/tf-allocine")
-model = TFAutoModelForSequenceClassification.from_pretrained("tblard/tf-allocine")
-
-nlp = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)
-
-print(nlp("Alad'2 est clairement le meilleur film de l'année 2018.")) # POSITIVE
-print(nlp("Juste whoaaahouuu !")) # POSITIVE
-print(nlp("NUL...A...CHIER ! FIN DE TRANSMISSION.")) # NEGATIVE
-print(nlp("Je m'attendais à mieux de la part de Franck Dubosc !")) # NEGATIVE
-```
-
-## Author
-
-Théophile Blard – :email: theophile.blard@gmail.com
-
-If you use this work (code, model or dataset), please cite as:
-
-> Théophile Blard, French sentiment analysis with BERT, (2020), GitHub repository, <https://github.com/TheophileBlard/french-sentiment-analysis-with-bert>
@@ -1,67 +0,0 @@
---
-datasets:
- squad
---
-
-# BART-LARGE finetuned on SQuADv1
-
-This is bart-large model finetuned on SQuADv1 dataset for question answering task
-
-## Model details
-BART was propsed in the [paper](https://arxiv.org/abs/1910.13461) **BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension**.
-BART is a seq2seq model intended for both NLG and NLU tasks. 
-
-To use BART for question answering tasks, we feed the complete document into the encoder and decoder, and use the top
-hidden state of the decoder as a representation for each
-word. This representation is used to classify the token. As given in the paper bart-large achives comparable to ROBERTa on SQuAD.
-Another notable thing about BART is that it can handle sequences with upto 1024 tokens.
-
-| Param               | #Value |
-|---------------------|--------|
-| encoder layers      | 12     |
-| decoder layers      | 12     |
-| hidden size         | 4096   |
-| num attetion heads  | 16     |
-| on disk size        | 1.63GB |
-
-
-## Model training
-This model was trained on google colab v100 GPU. 
-You can find the fine-tuning colab here
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1I5cK1M_0dLaf5xoewh6swcm5nAInfwHy?usp=sharing).
-
-
-## Results
-The results are actually slightly worse than given in the paper. 
-In the paper the authors mentioned that bart-large achieves 88.8 EM and 94.6 F1
-
-| Metric | #Value |
-|--------|--------|
-| EM     | 86.8022|
-| F1     | 92.7342|
-
-
-## Model in Action  🚀
-```python3
-from transformers import BartTokenizer, BartForQuestionAnswering
-import torch
-
-tokenizer = BartTokenizer.from_pretrained('valhalla/bart-large-finetuned-squadv1')
-model = BartForQuestionAnswering.from_pretrained('valhalla/bart-large-finetuned-squadv1')
-
-question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
-encoding = tokenizer.encode_plus(question, text, return_tensors='pt')
-input_ids = encoding['input_ids']
-attention_mask = encoding['attention_mask']
-
-start_scores, end_scores = model(input_ids, attention_mask=attention_mask, output_attentions=False)[:2]
-
-all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0])
-answer = ' '.join(all_tokens[torch.argmax(start_scores) : torch.argmax(end_scores)+1])
-answer = tokenizer.convert_tokens_to_ids(answer.split())
-answer = tokenizer.decode(answer)
-#answer => 'a nice puppet' 
-```
-
-> Created with ❤️ by Suraj Patil [![Github icon](https://cdn0.iconfinder.com/data/icons/octicons/1024/mark-github-32.png)](https://github.com/patil-suraj/)
-[![Twitter icon](https://cdn0.iconfinder.com/data/icons/shift-logotypes/32/Twitter-32.png)](https://twitter.com/psuraj28)
@@ -1,47 +0,0 @@
-# ELECTRA-BASE-DISCRIMINATOR finetuned on SQuADv1
-
-This is electra-base-discriminator model finetuned on SQuADv1 dataset for for question answering task.
-
-## Model details
-As mentioned in the original paper: ELECTRA is a new method for self-supervised language representation learning.
-It can be used to pre-train transformer networks using relatively little compute. 
-ELECTRA models are trained to distinguish "real" input tokens vs "fake" input tokens generated by another neural network, 
-similar to the discriminator of a GAN. At small scale, ELECTRA achieves strong results even when trained on a single GPU.
-At large scale, ELECTRA achieves state-of-the-art results on the SQuAD 2.0 dataset.
-
-| Param               | #Value |
-|---------------------|--------|
-| layers              | 12     |
-| hidden size         | 768    |
-| num attetion heads  | 12     |
-| on disk size        | 436MB  |
-
-## Model training
-This model was trained on google colab v100 GPU. 
-You can find the fine-tuning colab here
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/11yo-LaFsgggwmDSy2P8zD3tzf5cCb-DU?usp=sharing).
-
-## Results
-The results are actually slightly better than given in the paper. 
-In the paper the authors mentioned that electra-base achieves 84.5 EM and 90.8 F1
-
-| Metric | #Value |
-|--------|--------|
-| EM     | 85.0520|
-| F1     | 91.6050|
-
-
-## Model in Action  🚀
-```python3
-from transformers import pipeline
-
-nlp = pipeline('question-answering', model='valhalla/electra-base-discriminator-finetuned_squadv1')
-nlp({
-    'question': 'What is the answer to everything ?',
-    'context': '42 is the answer to life the universe and everything'
-})
-=> {'answer': '42', 'end': 2, 'score': 0.981274963050339, 'start': 0}
-```
-
-> Created with ❤️ by Suraj Patil [![Github icon](https://cdn0.iconfinder.com/data/icons/octicons/1024/mark-github-32.png)](https://github.com/patil-suraj/)
-[![Twitter icon](https://cdn0.iconfinder.com/data/icons/shift-logotypes/32/Twitter-32.png)](https://twitter.com/psuraj28)
@@ -33,7 +33,3 @@ Pull Request so it can be included under the Community notebooks.
 | [Pretrain Longformer](https://github.com/allenai/longformer/blob/master/scripts/convert_model_to_long.ipynb)  | How to build a "long" version of existing pretrained models |  [Iz Beltagy](https://beltagy.net) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/allenai/longformer/blob/master/scripts/convert_model_to_long.ipynb) |
 | [Fine-tune Longformer for QA](https://github.com/patil-suraj/Notebooks/blob/master/longformer_qa_training.ipynb) | How to fine-tune longformer model for QA task | [Suraj Patil](https://github.com/patil-suraj) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/patil-suraj/Notebooks/blob/master/longformer_qa_training.ipynb) |
 | [Evaluate Model with 🤗nlp](https://github.com/patrickvonplaten/notebooks/blob/master/How_to_evaluate_Longformer_on_TriviaQA_using_NLP.ipynb) | How to evaluate longformer on TriviaQA with `nlp` | [Patrick von Platen](https://github.com/patrickvonplaten) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1m7eTGlPmLRgoPkkA7rkhQdZ9ydpmsdLE?usp=sharing) |
-| [Fine-tune T5 for Sentiment Span Extraction](https://github.com/enzoampil/t5-intro/blob/master/t5_qa_training_pytorch_span_extraction.ipynb)  | How to fine-tune T5 for sentiment span extraction using a text-to-text format with PyTorch Lightning |  [Lorenzo Ampil](https://github.com/enzoampil) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/enzoampil/t5-intro/blob/master/t5_qa_training_pytorch_span_extraction.ipynb) |
-| [Fine-tune DistilBert for Multiclass Classification](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb) | How to fine-tune DistilBert for multiclass classification with PyTorch | [Abhishek Kumar Mishra](https://github.com/abhimishra91) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb)|
-|[Fine-tune BERT for Multi-label Classification](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_multi_label_classification.ipynb)|How to fine-tune BERT for multi-label classification using PyTorch|[Abhishek Kumar Mishra](https://github.com/abhimishra91) |[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multi_label_classification.ipynb)|
-|[Fine-tune T5 for Summarization](https://github.com/abhimishra91/transformers-tutorials/blob/master/transformers_summarization_wandb.ipynb)|How to fine-tune T5 for summarization in PyTorch and track experiments with WandB|[Abhishek Kumar Mishra](https://github.com/abhimishra91) |[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_summarization_wandb.ipynb)|
@@ -9,7 +9,6 @@ known_third_party =
    fastprogress
    git
    h5py
-    matplotlib
    MeCab
    nltk
    numpy
@@ -84,7 +84,7 @@ extras["torch"] = ["torch"]
 extras["serving"] = ["pydantic", "uvicorn", "fastapi", "starlette"]
 extras["all"] = extras["serving"] + ["tensorflow", "torch"]

-extras["testing"] = ["pytest", "pytest-xdist", "timeout-decorator", "psutil"]
+extras["testing"] = ["pytest", "pytest-xdist", "timeout-decorator"]
 extras["docs"] = ["recommonmark", "sphinx", "sphinx-markdown-tables", "sphinx-rtd-theme"]
 extras["quality"] = [
    "black",
@@ -95,7 +95,7 @@ extras["dev"] = extras["testing"] + extras["quality"] + ["mecab-python3", "sciki

 setup(
    name="transformers",
-    version="2.11.0",
+    version="2.10.0",
    author="Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Sam Shleifer, Patrick von Platen, Google AI Language Team Authors, Open AI team Authors, Facebook AI Authors, Carnegie Mellon University Authors",
    author_email="thomas@huggingface.co",
    description="State-of-the-art Natural Language Processing for TensorFlow 2.0 and PyTorch",
@@ -108,7 +108,7 @@ setup(
    packages=find_packages("src"),
    install_requires=[
        "numpy",
-        "tokenizers == 0.8.0-rc1",
+        "tokenizers == 0.7.0",
        # dataclasses for Python versions that don't have it
        "dataclasses;python_version<'3.7'",
        # utilities from PyPA to e.g. compare versions
@@ -2,7 +2,7 @@
 # There's no way to ignore "F401 '...' imported but unused" warnings in this
 # module, but to preserve other warnings. So, don't check this module at all.

-__version__ = "2.9.1"
+__version__ = "2.10.0"

 # Work around to update TensorFlow's absl.logging threshold which alters the
 # default Python logging output behavior when present.
@@ -19,19 +19,6 @@ else:

 import logging

-# Benchmarking
-from .benchmark_utils import (
-    Frame,
-    Memory,
-    MemoryState,
-    MemorySummary,
-    MemoryTrace,
-    UsedMemoryState,
-    bytes_to_human_readable,
-    start_memory_tracing,
-    stop_memory_tracing,
-)
-
 # Configurations
 from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig
 from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, AutoConfig
@@ -139,15 +126,13 @@ from .tokenization_distilbert import DistilBertTokenizer, DistilBertTokenizerFas
 from .tokenization_electra import ElectraTokenizer, ElectraTokenizerFast
 from .tokenization_flaubert import FlaubertTokenizer
 from .tokenization_gpt2 import GPT2Tokenizer, GPT2TokenizerFast
-from .tokenization_longformer import LongformerTokenizer
+from .tokenization_longformer import LongformerTokenizer, LongformerTokenizerFast
 from .tokenization_openai import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
 from .tokenization_reformer import ReformerTokenizer
 from .tokenization_roberta import RobertaTokenizer, RobertaTokenizerFast
 from .tokenization_t5 import T5Tokenizer
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer, TransfoXLTokenizerFast
 from .tokenization_utils import PreTrainedTokenizer
-from .tokenization_utils_base import BatchEncoding, CharSpan, PreTrainedTokenizerBase, SpecialTokensMixin, TokenSpan
-from .tokenization_utils_fast import PreTrainedTokenizerFast
 from .tokenization_xlm import XLMTokenizer
 from .tokenization_xlm_roberta import XLMRobertaTokenizer
 from .tokenization_xlnet import SPIECE_UNDERLINE, XLNetTokenizer
@@ -323,6 +308,7 @@ if is_torch_available():
        ElectraForMaskedLM,
        ElectraForTokenClassification,
        ElectraPreTrainedModel,
+        ElectraForSequenceClassification,
        ElectraModel,
        load_tf_weights_in_electra,
        ELECTRA_PRETRAINED_MODEL_ARCHIVE_MAP,
@@ -336,7 +322,15 @@ if is_torch_available():
        REFORMER_PRETRAINED_MODEL_ARCHIVE_MAP,
    )

-    from .modeling_longformer import LONGFORMER_PRETRAINED_MODEL_ARCHIVE_MAP, LongformerModel, LongformerForMaskedLM
+    from .modeling_longformer import (
+        LongformerModel,
+        LongformerForMaskedLM,
+        LongformerForSequenceClassification,
+        LongformerForMultipleChoice,
+        LongformerForTokenClassification,
+        LongformerForQuestionAnswering,
+        LONGFORMER_PRETRAINED_MODEL_ARCHIVE_MAP,
+    )

    # Optimization
    from .optimization import (
@@ -353,6 +347,9 @@ if is_torch_available():
    from .data.data_collator import DefaultDataCollator, DataCollator, DataCollatorForLanguageModeling
    from .data.datasets import GlueDataset, TextDataset, LineByLineTextDataset, GlueDataTrainingArguments

+    # Benchmarks
+    from .benchmark import PyTorchBenchmark, PyTorchBenchmarkArguments
+
 # TensorFlow
 if is_tf_available():
    from .modeling_tf_utils import (
@@ -18,18 +18,13 @@
 """


+import inspect
 import logging
 import timeit

-from transformers import (
-    MODEL_MAPPING,
-    MODEL_WITH_LM_HEAD_MAPPING,
-    PretrainedConfig,
-    is_torch_available,
-    is_torch_tpu_available,
-)
+from transformers import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING, PretrainedConfig, is_torch_available

-from .benchmark_utils import Benchmark, Memory, measure_peak_memory_cpu, start_memory_tracing, stop_memory_tracing
+from .benchmark_utils import Benchmark, Memory, start_memory_tracing, stop_memory_tracing


 if is_torch_available():
@@ -53,158 +48,70 @@ class PyTorchBenchmark(Benchmark):
    def train(self, model_name, batch_size, sequence_length, trace_memory=False):
        try:
            config = self.config_dict[model_name]
-
-            if self.args.torchscript:
-                config.torchscript = True
-
            model = MODEL_WITH_LM_HEAD_MAPPING[config.__class__](config)
            model.to(self.args.device)
            model.train()

-            # encoder-decoder has vocab size saved differently
-            vocab_size = config.vocab_size if hasattr(config, "vocab_size") else config.encoder.vocab_size
            input_ids = torch.randint(
-                vocab_size, (batch_size, sequence_length), dtype=torch.long, device=self.args.device
+                model.config.vocab_size, (batch_size, sequence_length), dtype=torch.long, device=self.args.device
            )

-            if self.args.torchscript:
-                raise NotImplementedError("Training for torchscript is currently not implemented")
-            else:
-                train_model = model
+            def compute_loss_and_backprob():
+                # TODO: Not all models call labels argument labels => this hack using the function signature should be corrected once all models have a common name for labels
+                function_argument_names = inspect.getfullargspec(model.forward).args
+                if "labels" in function_argument_names:
+                    loss = model(input_ids, labels=input_ids)[0]
+                elif "lm_labels" in function_argument_names:
+                    loss = model(input_ids, lm_labels=input_ids)[0]
+                elif "masked_lm_labels" in function_argument_names:
+                    loss = model(input_ids, masked_lm_labels=input_ids)[0]
+                else:
+                    NotImplementedError(f"{model_name} does not seem to allow training with labels")

-            def compute_loss_and_backprob_encoder():
-                loss = train_model(input_ids, labels=input_ids)[0]
                loss.backward()
-                train_model.zero_grad()
-
-            def compute_loss_and_backprob_encoder_decoder():
-                loss = train_model(input_ids, decoder_input_ids=input_ids, labels=input_ids)[0]
-                loss.backward()
-                train_model.zero_grad()
-
-            _train = (
-                compute_loss_and_backprob_encoder_decoder
-                if config.is_encoder_decoder
-                else compute_loss_and_backprob_encoder
-            )
+                model.zero_grad()

            if trace_memory is True:
-                if self.args.trace_memory_line_by_line:
+                if self.args.trace_memory_line_by_line or self.args.n_gpu == 0:
                    trace = start_memory_tracing("transformers")
-
-                if self.args.n_gpu > 0:
-                    # gpu
-                    # clear gpu cache
+                else:
+                    # clear cuda cache
                    torch.cuda.empty_cache()
-                    if hasattr(torch.cuda, "max_memory_reserved"):
-                        torch.cuda.reset_peak_memory_stats()
-                    else:
-                        logger.info(
-                            "Please consider updating PyTorch to version 1.4 to get more accuracy on GPU memory usage"
-                        )
-                        torch.cuda.reset_max_memory_cached()
+                    torch.cuda.reset_peak_memory_stats()

-                    # calculate loss and do backpropagation
-                    _train()
-                elif not self.args.no_tpu and is_torch_tpu_available():
-                    # tpu
-                    raise NotImplementedError(
-                        "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with `args.no_memory=True`"
-                    )
-                else:
-                    # cpu
-                    memory_bytes = measure_peak_memory_cpu(_train)
-                    memory = Memory(memory_bytes) if isinstance(memory_bytes, int) else memory_bytes
+                # calculate loss and do backpropagation
+                compute_loss_and_backprob()

-                if self.args.trace_memory_line_by_line:
+                if self.args.trace_memory_line_by_line or self.args.n_gpu == 0:
                    summary = stop_memory_tracing(trace)
+                    memory = summary.total
                else:
-                    summary = None
+                    memory = Memory(torch.cuda.max_memory_reserved())

-                if self.args.n_gpu > 0:
-                    # gpu
-                    if hasattr(torch.cuda, "max_memory_reserved"):
-                        memory = Memory(torch.cuda.max_memory_reserved())
-                    else:
-                        logger.info(
-                            "Please consider updating PyTorch to version 1.4 to get more accuracy on GPU memory usage"
-                        )
-                        memory = Memory(torch.cuda.max_memory_reserved())
-
-                return memory, summary
+                return memory
            else:
-                if (not self.args.no_tpu and is_torch_tpu_available()) or self.args.torchscript:
-                    # run additional 10 times to stabilize compilation for tpu and torchscript
-                    logger.info("Do inference on TPU or torchscript. Running model 5 times to stabilize compilation")
-                    timeit.repeat(
-                        _train, repeat=1, number=5,
-                    )
-
                # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
-                runtimes = timeit.repeat(_train, repeat=self.args.repeat, number=10,)
-
-                if not self.args.no_tpu and is_torch_tpu_available() and self.args.tpu_print_metrics:
-                    import torch_xla.debug.metrics as met
-
-                    self.print_fn(met.metrics_report())
-
+                runtimes = timeit.repeat(lambda: compute_loss_and_backprob(), repeat=self.args.repeat, number=10,)
                return min(runtimes) / 10.0
        except RuntimeError as e:
            self.print_fn("Doesn't fit on GPU. {}".format(e))
-            if trace_memory:
-                return "N/A", None
-            else:
-                return "N/A"
+            return "N/A"

    def inference(self, model_name, batch_size, sequence_length, trace_memory=False):
        try:
            config = self.config_dict[model_name]
-            model = None
-
-            if self.args.torchscript:
-                config.torchscript = True
-
-            if self.args.with_lm_head:
-                model = MODEL_WITH_LM_HEAD_MAPPING[config.__class__](config)
-            else:
-                model = MODEL_MAPPING[config.__class__](config)
-
-            model.eval()
+            model = MODEL_MAPPING[config.__class__](config)
            model.to(self.args.device)
-
-            # encoder-decoder has vocab size saved differently
-            vocab_size = config.vocab_size if hasattr(config, "vocab_size") else config.encoder.vocab_size
+            model.eval()

            input_ids = torch.randint(
-                vocab_size, (batch_size, sequence_length), dtype=torch.long, device=self.args.device
+                config.vocab_size, (batch_size, sequence_length), dtype=torch.long, device=self.args.device
            )
-
-            if self.args.torchscript:
-                with torch.no_grad():
-                    if config.is_encoder_decoder:
-                        raise NotImplementedError("Torchscript is currently not supported for EncoderDecoder models")
-                    else:
-                        inference_model = torch.jit.trace(model, input_ids)
-            else:
-                inference_model = model
-
-            def encoder_decoder_forward():
-                with torch.no_grad():
-                    inference_model(input_ids, decoder_input_ids=input_ids)
-
-            def encoder_forward():
-                with torch.no_grad():
-                    inference_model(input_ids)
-
-            _forward = encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
-
            if trace_memory is True:
-                if self.args.trace_memory_line_by_line:
+                if self.args.trace_memory_line_by_line or self.args.n_gpu == 0:
                    trace = start_memory_tracing("transformers")
-
-                if self.args.n_gpu > 0:
-                    # gpu
-                    # clear gpu cache
+                else:
+                    # clear cuda cache
                    torch.cuda.empty_cache()
                    if hasattr(torch.cuda, "max_memory_reserved"):
                        torch.cuda.reset_peak_memory_stats()
@@ -214,25 +121,12 @@ class PyTorchBenchmark(Benchmark):
                        )
                        torch.cuda.reset_max_memory_cached()

-                    # run forward
-                    _forward()
-                elif not self.args.no_tpu and is_torch_tpu_available():
-                    # tpu
-                    raise NotImplementedError(
-                        "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with `args.no_memory=True`"
-                    )
-                else:
-                    # cpu
-                    memory_bytes = measure_peak_memory_cpu(_forward)
-                    memory = Memory(memory_bytes) if isinstance(memory_bytes, int) else memory_bytes
+                model(input_ids)

-                if self.args.trace_memory_line_by_line:
+                if self.args.trace_memory_line_by_line or self.args.n_gpu == 0:
                    summary = stop_memory_tracing(trace)
+                    memory = summary.total
                else:
-                    summary = None
-
-                if self.args.n_gpu > 0:
-                    # gpu
                    if hasattr(torch.cuda, "max_memory_reserved"):
                        memory = Memory(torch.cuda.max_memory_reserved())
                    else:
@@ -241,29 +135,12 @@ class PyTorchBenchmark(Benchmark):
                        )
                        memory = Memory(torch.cuda.max_memory_cached())

-                return memory, summary
+                return memory
            else:
-
-                if (not self.args.no_tpu and is_torch_tpu_available()) or self.args.torchscript:
-                    # run additional 10 times to stabilize compilation for tpu and torchscript
-                    logger.info("Do inference on TPU or torchscript. Running model 5 times to stabilize compilation")
-                    timeit.repeat(
-                        _forward, repeat=1, number=5,
-                    )
-
                # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
-                runtimes = timeit.repeat(_forward, repeat=self.args.repeat, number=10,)
-
-                if not self.args.no_tpu and is_torch_tpu_available() and self.args.tpu_print_metrics:
-                    import torch_xla.debug.metrics as met
-
-                    self.print_fn(met.metrics_report())
-
+                runtimes = timeit.repeat(lambda: model(input_ids), repeat=self.args.repeat, number=10,)
                return min(runtimes) / 10.0

        except RuntimeError as e:
            self.print_fn("Doesn't fit on GPU. {}".format(e))
-            if trace_memory:
-                return "N/A", None
-            else:
-                return "N/A"
+            return "N/A"
@@ -18,16 +18,25 @@ import logging
 from dataclasses import dataclass, field
 from typing import Tuple

-from ..file_utils import cached_property, is_torch_available, is_torch_tpu_available, torch_required
+from ..file_utils import cached_property, is_torch_available, torch_required
 from .benchmark_args_utils import BenchmarkArguments


 if is_torch_available():
    import torch

-if is_torch_tpu_available():
+try:
    import torch_xla.core.xla_model as xm

+    _has_tpu = True
+except ImportError:
+    _has_tpu = False
+
+
+@torch_required
+def is_tpu_available():
+    return _has_tpu
+

 logger = logging.getLogger(__name__)

@@ -36,9 +45,7 @@ logger = logging.getLogger(__name__)
 class PyTorchBenchmarkArguments(BenchmarkArguments):
    no_cuda: bool = field(default=False, metadata={"help": "Whether to run on available cuda devices"})
    torchscript: bool = field(default=False, metadata={"help": "Trace the models using torchscript"})
-    no_tpu: bool = field(default=False, metadata={"help": "Whether to run on available tpu devices"})
    fp16: bool = field(default=False, metadata={"help": "Use FP16 to accelerate inference."})
-    tpu_print_metrics: bool = field(default=False, metadata={"help": "Use FP16 to accelerate inference."})

    @cached_property
    @torch_required
@@ -47,7 +54,7 @@ class PyTorchBenchmarkArguments(BenchmarkArguments):
        if self.no_cuda:
            device = torch.device("cpu")
            n_gpu = 0
-        elif is_torch_tpu_available():
+        elif is_tpu_available():
            device = xm.xla_device()
            n_gpu = 0
        else:
@@ -61,12 +61,6 @@ class BenchmarkArguments:
    save_to_csv: bool = field(default=False, metadata={"help": "Save result to a CSV file"})
    log_print: bool = field(default=False, metadata={"help": "Save all print statements in a log file"})
    no_env_print: bool = field(default=False, metadata={"help": "Don't print environment information"})
-    with_lm_head: bool = field(
-        default=False,
-        metadata={
-            "help": "Use model with its language model head (MODEL_WITH_LM_HEAD_MAPPING instead of MODEL_MAPPING)"
-        },
-    )
    inference_time_csv_file: str = field(
        default=f"inference_time_{round(time())}.csv",
        metadata={"help": "CSV filename used if saving time results to csv."},
@@ -14,14 +14,12 @@ import sys
 from abc import ABC, abstractmethod
 from collections import defaultdict, namedtuple
 from datetime import datetime
-from multiprocessing import Pipe, Process
-from multiprocessing.connection import Connection
-from typing import Callable, Iterable, List, NamedTuple, Optional, Union
+from typing import Iterable, List, NamedTuple, Optional, Union

 from transformers import AutoConfig, PretrainedConfig
 from transformers import __version__ as version

-from ..file_utils import is_tf_available, is_torch_available, is_torch_tpu_available
+from ..file_utils import is_tf_available, is_torch_available
 from .benchmark_args_utils import BenchmarkArguments


@@ -32,27 +30,13 @@ if is_tf_available():
    from tensorflow.python.eager import context as tf_context


-if platform.system() == "Windows":
-    from signal import CTRL_C_EVENT as SIGKILL
-else:
-    from signal import SIGKILL
-
-
 logger = logging.getLogger(__name__)  # pylint: disable=invalid-name


 _is_memory_tracing_enabled = False

 BenchmarkOutput = namedtuple(
-    "BenchmarkOutput",
-    [
-        "time_inference_result",
-        "memory_inference_result",
-        "time_train_result",
-        "memory_train_result",
-        "inference_summary",
-        "train_summary",
-    ],
+    "BenchmarkOutput", ["time_inference_result", "memory_inference_result", "time_train_result", "memory_train_result"]
 )


@@ -136,127 +120,6 @@ class MemorySummary(NamedTuple):
 MemoryTrace = List[UsedMemoryState]


-def measure_peak_memory_cpu(function: Callable[[], None], interval=0.5) -> int:
-    """
-        measures peak cpu memory consumption of a given `function`
-        running the function for at least interval seconds
-        and at most 20 * interval seconds.
-        This function is heavily inspired by: `memory_usage`
-        of the package `memory_profiler`: https://github.com/pythonprofilers/memory_profiler/blob/895c4ac7a08020d66ae001e24067da6dcea42451/memory_profiler.py#L239
-
-        Args:
-            - `function`: (`callable`): function() -> ...
-                function without any arguments to measure for which to measure the peak memory
-
-            - `interval`: (`float`)
-                interval in second for which to measure the memory usage
-
-        Returns:
-            - `max_memory`: (`int`)
-                cosumed memory peak in Bytes
-    """
-    try:
-        import psutil
-    except (ImportError):
-        logger.warning(
-            "Psutil not installed, we won't log CPU memory usage. "
-            "Install Psutil (pip install psutil) to use CPU memory tracing."
-        )
-        max_memory = "N/A"
-    else:
-
-        def _get_memory(process_id: int) -> int:
-            """
-                measures current cpu memory usage of a given `process_id`
-
-                Args:
-                    - `process_id`: (`int`)
-                        process_id for which to measure memory
-
-                Returns
-                    - `memory`: (`int`)
-                        cosumed memory in Bytes
-            """
-            process = psutil.Process(process_id)
-            try:
-                meminfo_attr = "memory_info" if hasattr(process, "memory_info") else "get_memory_info"
-                memory = getattr(process, meminfo_attr)()[0]
-            except psutil.AccessDenied:
-                raise ValueError("Error with Psutil.")
-            return memory
-
-        class MemoryMeasureProcess(Process):
-
-            """
-                `MemoryMeasureProcess` inherits from `Process` and overwrites
-                its `run()` method. Used to measure the memory usage of a process
-            """
-
-            def __init__(self, process_id: int, child_connection: Connection, interval: float):
-                super().__init__()
-                self.process_id = process_id
-                self.interval = interval
-                self.connection = child_connection
-                self.num_measurements = 1
-                self.mem_usage = _get_memory(process_id)
-
-            def run(self):
-                self.connection.send(0)
-                stop = False
-                while True:
-                    self.mem_usage = max(self.mem_usage, _get_memory(self.process_id))
-                    self.num_measurements += 1
-
-                    if stop:
-                        break
-
-                    stop = self.connection.poll(self.interval)
-
-                # send results to parent pipe
-                self.connection.send(self.mem_usage)
-                self.connection.send(self.num_measurements)
-
-        while True:
-            # create child, parent connection
-            child_connection, parent_connection = Pipe()
-
-            # instantiate process
-            mem_process = MemoryMeasureProcess(os.getpid(), child_connection, interval)
-            mem_process.start()
-
-            # wait until we get memory
-            parent_connection.recv()
-
-            try:
-                # execute function
-                function()
-
-                # start parent connection
-                parent_connection.send(0)
-
-                # receive memory and num measurements
-                max_memory = parent_connection.recv()
-                num_measurements = parent_connection.recv()
-            except Exception:
-                # kill process in a clean way
-                parent = psutil.Process(os.getpid())
-                for child in parent.children(recursive=True):
-                    os.kill(child.pid, SIGKILL)
-                mem_process.join(0)
-                raise RuntimeError("Process killed. Error in Process")
-
-            # run process at least 20 * interval or until it finishes
-            mem_process.join(20 * interval)
-
-            if (num_measurements > 4) or (interval < 1e-6):
-                break
-
-            # reduce interval
-            interval /= 10
-
-        return max_memory
-
-
 def start_memory_tracing(
    modules_to_trace: Optional[Union[str, Iterable[str]]] = None,
    modules_not_to_trace: Optional[Union[str, Iterable[str]]] = None,
@@ -538,10 +401,15 @@ class Benchmark(ABC):
    def print_fn(self):
        if self._print_fn is None:
            if self.args.log_print:
+                logging.basicConfig(
+                    level=logging.DEBUG,
+                    filename=self.args.log_filename,
+                    filemode="a+",
+                    format="%(asctime)-15s %(levelname)-8s %(message)s",
+                )

                def print_and_log(*args):
-                    with open(self.args.log_filename, "a") as log_file:
-                        log_file.write(str(*args) + "\n")
+                    logging.info(*args)
                    print(*args)

                self._print_fn = print_and_log
@@ -553,10 +421,6 @@ class Benchmark(ABC):
    def is_gpu(self):
        return self.args.n_gpu > 0

-    @property
-    def is_tpu(self):
-        return is_torch_tpu_available() and not self.args.no_tpu
-
    @property
    @abstractmethod
    def framework_version(self):
@@ -590,15 +454,11 @@ class Benchmark(ABC):
            train_result_time[model_name] = copy.deepcopy(model_dict)
            train_result_memory[model_name] = copy.deepcopy(model_dict)

-            inference_summary = train_summary = None
-
            for batch_size in self.args.batch_sizes:
                for sequence_length in self.args.sequence_lengths:
                    if not self.args.no_inference:
                        if not self.args.no_memory:
-                            memory, inference_summary = self.inference(
-                                model_name, batch_size, sequence_length, trace_memory=True
-                            )
+                            memory = self.inference(model_name, batch_size, sequence_length, trace_memory=True)
                            inference_result_memory[model_name]["result"][batch_size][sequence_length] = memory
                        if not self.args.no_speed:
                            time = self.inference(model_name, batch_size, sequence_length, trace_memory=False)
@@ -606,9 +466,7 @@ class Benchmark(ABC):

                    if self.args.training:
                        if not self.args.no_memory:
-                            memory, train_summary = self.train(
-                                model_name, batch_size, sequence_length, trace_memory=True
-                            )
+                            memory = self.train(model_name, batch_size, sequence_length, trace_memory=True)
                            train_result_memory[model_name]["result"][batch_size][sequence_length] = memory
                        if not self.args.no_speed:
                            time = self.inference(model_name, batch_size, sequence_length, trace_memory=False)
@@ -619,39 +477,23 @@ class Benchmark(ABC):
                self.print_fn("======= INFERENCE - SPEED - RESULT =======")
                self.print_results(inference_result_time)
                self.save_to_csv(inference_result_time, self.args.inference_time_csv_file)
-                if self.is_tpu:
-                    self.print_fn(
-                        "TPU was used for inference. Note that the time after compilation stabilized (after ~10 inferences model.forward(..) calls) was measured."
-                    )

            if not self.args.no_memory:
                self.print_fn("======= INFERENCE - MEMORY - RESULT =======")
                self.print_results(inference_result_memory)
                self.save_to_csv(inference_result_memory, self.args.inference_memory_csv_file)

-            if self.args.trace_memory_line_by_line:
-                self.print_fn("======= INFERENCE - MEMORY LINE BY LINE TRACE - SUMMARY =======")
-                self.print_memory_trace_statistics(inference_summary)
-
        if self.args.training:
            if not self.args.no_speed:
                self.print_fn("======= TRAIN - SPEED - RESULT =======")
                self.print_results(train_result_time)
                self.save_to_csv(train_result_time, self.args.train_time_csv_file)
-                if self.is_tpu:
-                    self.print_fn(
-                        "TPU was used for training. Note that the time after compilation stabilized (after ~10 train loss=model.forward(...) + loss.backward() calls) was measured."
-                    )

            if not self.args.no_memory:
                self.print_fn("======= TRAIN - MEMORY - RESULT =======")
                self.print_results(train_result_memory)
                self.save_to_csv(train_result_memory, self.args.train_memory_csv_file)

-            if self.args.trace_memory_line_by_line:
-                self.print_fn("======= TRAIN - MEMORY LINE BY LINE TRACE - SUMMARY =======")
-                self.print_memory_trace_statistics(train_summary)
-
        if not self.args.no_env_print:
            self.print_fn("\n======== ENVIRONMENT - INFORMATION ========")
            self.print_fn(
@@ -664,14 +506,7 @@ class Benchmark(ABC):
                for key, value in self.environment_info.items():
                    writer.writerow([key, value])

-        return BenchmarkOutput(
-            inference_result_time,
-            inference_result_memory,
-            train_result_time,
-            train_result_memory,
-            inference_summary,
-            train_summary,
-        )
+        return BenchmarkOutput(inference_result_time, inference_result_memory, train_result_time, train_result_memory)

    @property
    def environment_info(self):
@@ -679,8 +514,6 @@ class Benchmark(ABC):
            info = {}
            info["transformers_version"] = version
            info["framework"] = self.framework
-            if self.framework == "PyTorch":
-                info["use_torchscript"] = self.args.torchscript
            info["framework_version"] = self.framework_version
            info["python_version"] = platform.python_version()
            info["system"] = platform.system()
@@ -733,10 +566,6 @@ class Benchmark(ABC):
                    info["gpu_performance_state"] = py3nvml.nvmlDeviceGetPerformanceState(handle)
                    py3nvml.nvmlShutdown()

-            info["use_tpu"] = self.is_tpu
-            # TODO(PVP): See if we can add more information about TPU
-            # see: https://github.com/pytorch/xla/issues/2180
-
            self._environment_info = info
        return self._environment_info

@@ -32,7 +32,7 @@ ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP = {

 class AlbertConfig(PretrainedConfig):
    r"""
-        This is the configuration class to store the configuration of a :class:`~transformers.AlbertModel`.
+        This is the configuration class to store the configuration of an :class:`~transformers.AlbertModel`.
        It is used to instantiate an ALBERT model according to the specified arguments, defining the model
        architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of
        the ALBERT `xxlarge <https://huggingface.co/albert-xxlarge-v2>`__ architecture.
@@ -97,8 +97,13 @@ class AlbertConfig(PretrainedConfig):

            # Accessing the model configuration
            configuration = model.config
+
+        Attributes:
+            pretrained_config_archive_map (Dict[str, str]):
+                A dictionary containing all the available pre-trained checkpoints.
    """

+    pretrained_config_archive_map = ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP
    model_type = "albert"

    def __init__(
Author	SHA1	Message	Date
Lysandre	e50654c03c	Sampling instead of argmax	2020-06-17 10:25:16 -04:00
Lysandre	218ae1ed18	Reverting part of latest commit	2020-06-08 14:22:40 -04:00
Lysandre	50fd3479f3	Addressing @mfuntowicz's comments	2020-06-01 20:34:12 -04:00
Lysandre	ce1e6c3d74	Fix trainer	2020-06-01 20:23:30 -04:00
Lysandre	343157dd96	Final tests	2020-06-01 20:23:30 -04:00
Lysandre	0c75018138	Tests	2020-06-01 20:23:30 -04:00
Lysandre	1477c8aa89	Further cleanup	2020-06-01 20:23:30 -04:00
Lysandre	1b1b94ed8f	Cleanup	2020-06-01 20:23:30 -04:00
Lysandre	edb64e8ac3	Remove unused arg	2020-06-01 20:23:30 -04:00
Lysandre	f49448aa15	Remove bogus files	2020-06-01 20:23:30 -04:00
Lysandre	b5b9633e2c	Remove bogus files	2020-06-01 20:23:30 -04:00
Lysandre	f842f7c764	update	2020-06-01 20:23:30 -04:00
Lysandre	ea3e2cebd8	Evaluation	2020-06-01 20:23:30 -04:00
Lysandre	a6f5989bd9	wip	2020-06-01 20:23:30 -04:00
Lysandre	3488e5a8b8	Additional arguments	2020-06-01 20:23:30 -04:00
Lysandre	f1c91f8fad	wip	2020-06-01 20:23:30 -04:00
Lysandre	75af46eada	It trains	2020-06-01 20:23:30 -04:00
Lysandre	ac396b2787	Dataset length	2020-06-01 20:23:30 -04:00
Lysandre	75d900e7c4	Efficient pre-training	2020-06-01 20:23:30 -04:00
Lysandre	91dc392e57	nth wip	2020-06-01 20:23:30 -04:00
Lysandre	30b2dbbba6	Pre-training Utils Initial wip wip	2020-06-01 20:23:30 -04:00