revert changes to bart

.circleci/config.yml

@@ -3,7 +3,7 @@ jobs:
     run_tests_torch_and_tf:
         working_directory: ~/transformers
         docker:
-            - image: circleci/python:3.6
+            - image: circleci/python:3.5
         environment:
             OMP_NUM_THREADS: 1
         resource_class: xlarge
@@ -46,7 +46,7 @@ jobs:
     run_tests_custom_tokenizers:
         working_directory: ~/transformers
         docker:
-            - image: circleci/python:3.6
+            - image: circleci/python:3.5
         environment:
             RUN_CUSTOM_TOKENIZERS: yes
         steps:
@@ -56,7 +56,7 @@ jobs:
     run_examples_torch:
         working_directory: ~/transformers
         docker:
-            - image: circleci/python:3.6
+            - image: circleci/python:3.5
         environment:
             OMP_NUM_THREADS: 1
         resource_class: xlarge
@@ -69,7 +69,7 @@ jobs:
     deploy_doc:
         working_directory: ~/transformers
         docker:
-            - image: circleci/python:3.6
+            - image: circleci/python:3.5
         steps:
             - add_ssh_keys:
                 fingerprints:
@@ -94,7 +94,7 @@ jobs:
     check_repository_consistency:
         working_directory: ~/transformers
         docker:
-            - image: circleci/python:3.6
+            - image: circleci/python:3.5
         resource_class: small
         parallelism: 1
         steps:

README.md

@@ -66,7 +66,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+ and TensorFlow 2.0.0-rc1
+This repo is tested on Python 3.5+, PyTorch 1.0.0+ and TensorFlow 2.0.0-rc1
 
 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/).
 
@@ -163,9 +163,8 @@ At some point in the future, you'll be able to seamlessly move from pre-training
 13. **[XLM-RoBERTa](https://github.com/pytorch/fairseq/tree/master/examples/xlmr)** (from Facebook AI), released together with the paper [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.
 14. **[MMBT](https://github.com/facebookresearch/mmbt/)** (from Facebook), released together with the paper a [Supervised Multimodal Bitransformers for Classifying Images and Text](https://arxiv.org/pdf/1909.02950.pdf) by Douwe Kiela, Suvrat Bhooshan, Hamed Firooz, Davide Testuggine.
 15. **[FlauBERT](https://github.com/getalp/Flaubert)** (from CNRS) released with the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le, Loïc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoît Crabbé, Laurent Besacier, Didier Schwab.
-16. **[BART](https://github.com/pytorch/fairseq/tree/master/examples/bart)** (from Facebook) released with the paper [BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension](https://arxiv.org/pdf/1910.13461.pdf) by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.
-17. **[Other community models](https://huggingface.co/models)**, contributed by the [community](https://huggingface.co/users).
-18. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR.
+16. **[Other community models](https://huggingface.co/models)**, contributed by the [community](https://huggingface.co/users).
+17. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR.
 
 These implementations have been tested on several datasets (see the example scripts) and should match the performances of the original implementations (e.g. ~93 F1 on SQuAD for BERT Whole-Word-Masking, ~88 F1 on RocStories for OpenAI GPT, ~18.3 perplexity on WikiText 103 for Transformer-XL, ~0.916 Peason R coefficient on STS-B for XLNet). You can find more details on the performances in the Examples section of the [documentation](https://huggingface.co/transformers/examples.html).
 

docs/source/conf.py

@@ -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.6.0'
+release = u'2.5.1'
 
 
 # -- General configuration ---------------------------------------------------

docs/source/index.rst

@@ -103,4 +103,3 @@ The library currently contains PyTorch and Tensorflow implementations, pre-train
     model_doc/xlmroberta
     model_doc/flaubert
     model_doc/bart
-    model_doc/t5

docs/source/installation.md

@@ -1,6 +1,6 @@
 # Installation
 
-Transformers is tested on Python 3.6+ and PyTorch 1.1.0
+Transformers is tested on Python 3.5+ and PyTorch 1.1.0
 
 ## With pip
 

docs/source/main_classes/pipelines.rst

@@ -61,8 +61,3 @@ QuestionAnsweringPipeline
 
 .. autoclass:: transformers.QuestionAnsweringPipeline
 
-
-SummarizationPipeline
-==========================================
-
-.. autoclass:: transformers.SummarizationPipeline

docs/source/model_doc/t5.rst

@@ -1,69 +0,0 @@
-T5
-----------------------------------------------------
-**DISCLAIMER:** This model is still a work in progress, if you see something strange,
-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: 
-
-*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.*
-
-The Authors' code can be found `here <https://github.com/google-research/text-to-text-transfer-transformer>`_ .
-
-Tips
-~~~~~~~~~~~~~~~~~~~~
-- T5 is an encoder-decoder model pre-trained on a multi-task mixture of unsupervised 
-  and supervised tasks and which each task is cast as a sequence to sequence task. 
-  Therefore 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 the 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 generating the decoder output.
-- T5 uses relative scalar embeddings. Encoder input padding can be done on the left and on the right.
-
-
-T5Config
-~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.T5Config
-    :members:
-
-
-T5Tokenizer
-~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.T5Tokenizer
-    :members: build_inputs_with_special_tokens, get_special_tokens_mask,
-        create_token_type_ids_from_sequences, save_vocabulary
-
-
-T5Model
-~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.T5Model
-    :members:
-
-
-T5ForConditionalGeneration
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.T5ForConditionalGeneration
-    :members:
-
-
-TFBertModel
-~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFT5Model
-    :members:
-
-
-TFT5ForConditionalGeneration
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autoclass:: transformers.TFT5ForConditionalGeneration
-    :members:

examples/benchmarks.py

@@ -24,15 +24,7 @@ import timeit
 from time import time
 from typing import List
 
-from transformers import (
-    AutoConfig,
-    AutoTokenizer,
-    MemorySummary,
-    is_tf_available,
-    is_torch_available,
-    start_memory_tracing,
-    stop_memory_tracing,
-)
+from transformers import AutoConfig, AutoTokenizer, is_tf_available, is_torch_available
 
 
 if is_tf_available():
@@ -258,21 +250,15 @@ as they entered."""
 
 def create_setup_and_compute(
     model_names: List[str],
-    batch_sizes: List[int],
-    slice_sizes: List[int],
     gpu: bool = True,
     tensorflow: bool = False,
     average_over: int = 3,
-    no_speed: bool = False,
-    no_memory: bool = False,
-    verbose: bool = False,
     torchscript: bool = False,
     xla: bool = False,
     amp: bool = False,
     fp16: bool = False,
     save_to_csv: bool = False,
     csv_filename: str = f"results_{round(time())}.csv",
-    csv_memory_filename: str = f"memory_{round(time())}.csv",
 ):
     if xla:
         tf.config.optimizer.set_jit(True)
@@ -281,25 +267,11 @@ def create_setup_and_compute(
 
     if tensorflow:
         dictionary = {model_name: {} for model_name in model_names}
-        results = _compute_tensorflow(
-            model_names, batch_sizes, slice_sizes, dictionary, average_over, amp, no_speed, no_memory, verbose
-        )
+        results = _compute_tensorflow(model_names, dictionary, average_over, amp)
     else:
         device = "cuda" if (gpu and torch.cuda.is_available()) else "cpu"
         dictionary = {model_name: {} for model_name in model_names}
-        results = _compute_pytorch(
-            model_names,
-            batch_sizes,
-            slice_sizes,
-            dictionary,
-            average_over,
-            device,
-            torchscript,
-            fp16,
-            no_speed,
-            no_memory,
-            verbose,
-        )
+        results = _compute_pytorch(model_names, dictionary, average_over, device, torchscript, fp16)
 
     print("=========== RESULTS ===========")
     for model_name in model_names:
@@ -308,19 +280,13 @@ def create_setup_and_compute(
             print("\t\t" + f"===== BATCH SIZE: {batch_size} =====")
             for slice_size in results[model_name]["ss"]:
                 result = results[model_name]["results"][batch_size][slice_size]
-                memory = results[model_name]["memory"][batch_size][slice_size]
                 if isinstance(result, str):
-                    print(f"\t\t{model_name}/{batch_size}/{slice_size}: " f"{result} " f"{memory}")
+                    print(f"\t\t{model_name}/{batch_size}/{slice_size}: " f"{result}")
                 else:
-                    print(
-                        f"\t\t{model_name}/{batch_size}/{slice_size}: "
-                        f"{(round(1000 * result) / 1000)}"
-                        f"s "
-                        f"{memory}"
-                    )
+                    print(f"\t\t{model_name}/{batch_size}/{slice_size}: " f"{(round(1000 * result) / 1000)}" f"s")
 
     if save_to_csv:
-        with open(csv_filename, mode="w") as csv_file, open(csv_memory_filename, mode="w") as csv_memory_file:
+        with open(csv_filename, mode="w") as csv_file:
             fieldnames = [
                 "model",
                 "1x8",
@@ -351,8 +317,6 @@ def create_setup_and_compute(
 
             writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
             writer.writeheader()
-            memory_writer = csv.DictWriter(csv_memory_file, fieldnames=fieldnames)
-            memory_writer.writeheader()
 
             for model_name in model_names:
                 model_results = {
@@ -362,52 +326,8 @@ def create_setup_and_compute(
                 }
                 writer.writerow({"model": model_name, **model_results})
 
-                model_memory_results = {
-                    f"{bs}x{ss}": results[model_name]["memory"][bs][ss]
-                    for bs in results[model_name]["memory"]
-                    for ss in results[model_name]["memory"][bs]
-                }
-                memory_writer.writerow({"model": model_name, **model_memory_results})
 
-
-def print_summary_statistics(summary: MemorySummary):
-    print(
-        "\nLines by line memory consumption:\n"
-        + "\n".join(
-            f"{state.frame.filename}:{state.frame.line_number}: mem {state.cpu_gpu}: {state.frame.line_text}"
-            for state in summary.sequential
-        )
-    )
-    print(
-        "\nLines with top memory consumption:\n"
-        + "\n".join(
-            f"=> {state.frame.filename}:{state.frame.line_number}: mem {state.cpu_gpu}: {state.frame.line_text}"
-            for state in summary.cumulative[:6]
-        )
-    )
-    print(
-        "\nLines with lowest memory consumption:\n"
-        + "\n".join(
-            f"=> {state.frame.filename}:{state.frame.line_number}: mem {state.cpu_gpu}: {state.frame.line_text}"
-            for state in summary.cumulative[-6:]
-        )
-    )
-    print(f"\nTotal memory increase: {summary.total}")
-
-
-def _compute_pytorch(
-    model_names,
-    batch_sizes,
-    slice_sizes,
-    dictionary,
-    average_over,
-    device,
-    torchscript,
-    fp16,
-    no_speed,
-    no_memory,
-    verbose,
-):
+def _compute_pytorch(model_names, dictionary, average_over, device, torchscript, fp16):
     for c, model_name in enumerate(model_names):
         print(f"{c + 1} / {len(model_names)}")
         config = AutoConfig.from_pretrained(model_name, torchscript=torchscript)
@@ -417,17 +337,17 @@ def _compute_pytorch(
         tokenized_sequence = tokenizer.encode(input_text, add_special_tokens=False)
 
         max_input_size = tokenizer.max_model_input_sizes[model_name]
+        batch_sizes = [1, 2, 4, 8]
+        slice_sizes = [8, 64, 128, 256, 512, 1024]
 
-        dictionary[model_name] = {"bs": batch_sizes, "ss": slice_sizes, "results": {}, "memory": {}}
+        dictionary[model_name] = {"bs": batch_sizes, "ss": slice_sizes, "results": {}}
         dictionary[model_name]["results"] = {i: {} for i in batch_sizes}
-        dictionary[model_name]["memory"] = {i: {} for i in batch_sizes}
 
         for batch_size in batch_sizes:
             if fp16:
                 model.half()
             model.to(device)
             model.eval()
-
             for slice_size in slice_sizes:
                 if max_input_size is not None and slice_size > max_input_size:
                     dictionary[model_name]["results"][batch_size][slice_size] = "N/A"
@@ -442,40 +362,18 @@ def _compute_pytorch(
                             inference = model
                             inference(sequence)
 
-                        if not no_memory:
-                            # model.add_memory_hooks()  # Forward method tracing (only for PyTorch models)
-
-                            # Line by line memory tracing (all code in the module `transformers`) works for all models/arbitrary code
-                            trace = start_memory_tracing("transformers")
-                            inference(sequence)
-                            summary = stop_memory_tracing(trace)
-
-                            if verbose:
-                                print_summary_statistics(summary)
-
-                            dictionary[model_name]["memory"][batch_size][slice_size] = str(summary.total)
-                        else:
-                            dictionary[model_name]["memory"][batch_size][slice_size] = "N/A"
-
-                        if not no_speed:
-                            print("Going through model with sequence of shape", sequence.shape)
-                            runtimes = timeit.repeat(lambda: inference(sequence), repeat=average_over, number=3)
-                            average_time = sum(runtimes) / float(len(runtimes)) / 3.0
-                            dictionary[model_name]["results"][batch_size][slice_size] = average_time
-                        else:
-                            dictionary[model_name]["results"][batch_size][slice_size] = "N/A"
-
+                        print("Going through model with sequence of shape", sequence.shape)
+                        runtimes = timeit.repeat(lambda: inference(sequence), repeat=average_over, number=3)
+                        average_time = sum(runtimes) / float(len(runtimes)) / 3.0
+                        dictionary[model_name]["results"][batch_size][slice_size] = average_time
                     except RuntimeError as e:
                         print("Doesn't fit on GPU.", e)
                         torch.cuda.empty_cache()
                         dictionary[model_name]["results"][batch_size][slice_size] = "N/A"
-                        dictionary[model_name]["memory"][batch_size][slice_size] = "N/A"
     return dictionary
 
 
-def _compute_tensorflow(
-    model_names, batch_sizes, slice_sizes, dictionary, average_over, amp, no_speed, no_memory, verbose
-):
+def _compute_tensorflow(model_names, dictionary, average_over, amp):
     for c, model_name in enumerate(model_names):
         print(f"{c + 1} / {len(model_names)}")
         config = AutoConfig.from_pretrained(model_name)
@@ -485,10 +383,11 @@ def _compute_tensorflow(
         tokenized_sequence = tokenizer.encode(input_text, add_special_tokens=False)
 
         max_input_size = tokenizer.max_model_input_sizes[model_name]
+        batch_sizes = [1, 2, 4, 8]
+        slice_sizes = [8, 64, 128, 256, 512, 1024]
 
-        dictionary[model_name] = {"bs": batch_sizes, "ss": slice_sizes, "results": {}, "memory": {}}
+        dictionary[model_name] = {"bs": batch_sizes, "ss": slice_sizes, "results": {}}
         dictionary[model_name]["results"] = {i: {} for i in batch_sizes}
-        dictionary[model_name]["memory"] = {i: {} for i in batch_sizes}
 
         print("Using model", model)
 
@@ -510,30 +409,13 @@ def _compute_tensorflow(
                         # To make sure that the model is traced + that the tensors are on the appropriate device
                         inference(sequence)
 
-                        if not no_memory:
-                            # Line by line memory tracing (all code in the module `transformers`) works for all models/arbitrary code
-                            trace = start_memory_tracing("transformers")
-                            inference(sequence)
-                            summary = stop_memory_tracing(trace)
-
-                            if verbose:
-                                print_summary_statistics(summary)
-
-                            dictionary[model_name]["memory"][batch_size][slice_size] = str(summary.total)
-                        else:
-                            dictionary[model_name]["memory"][batch_size][slice_size] = "N/A"
-
-                        if not no_speed:
-                            runtimes = timeit.repeat(lambda: inference(sequence), repeat=average_over, number=3)
-                            average_time = sum(runtimes) / float(len(runtimes)) / 3.0
-                            dictionary[model_name]["results"][batch_size][slice_size] = average_time
-                        else:
-                            dictionary[model_name]["results"][batch_size][slice_size] = "N/A"
-
+                        runtimes = timeit.repeat(lambda: inference(sequence), repeat=average_over, number=3)
+                        average_time = sum(runtimes) / float(len(runtimes)) / 3.0
+                        dictionary[model_name]["results"][batch_size][slice_size] = average_time
                     except tf.errors.ResourceExhaustedError as e:
                         print("Doesn't fit on GPU.", e)
+                        torch.cuda.empty_cache()
                         dictionary[model_name]["results"][batch_size][slice_size] = "N/A"
-                        dictionary[model_name]["memory"][batch_size][slice_size] = "N/A"
     return dictionary
 
 
@@ -551,9 +433,6 @@ def main():
         "of all available model "
         "architectures.",
     )
-    parser.add_argument("--verbose", required=False, action="store_true", help="Verbose memory tracing")
-    parser.add_argument("--no_speed", required=False, action="store_true", help="Don't perform speed measurments")
-    parser.add_argument("--no_memory", required=False, action="store_true", help="Don't perform memory measurments")
     parser.add_argument(
         "--torch", required=False, action="store_true", help="Benchmark the Pytorch version of the " "models"
     )
@@ -598,8 +477,6 @@ def main():
     parser.add_argument(
         "--average_over", required=False, default=30, type=int, help="Times an experiment will be run."
     )
-    parser.add_argument("--batch_sizes", nargs="+", type=int, default=[1, 2, 4, 8])
-    parser.add_argument("--slice_sizes", nargs="+", type=int, default=[8, 64, 128, 256, 512, 1024])
 
     args = parser.parse_args()
     if args.models == "all":
@@ -624,8 +501,6 @@ def main():
         if is_torch_available():
             create_setup_and_compute(
                 model_names=args.models,
-                batch_sizes=args.batch_sizes,
-                slice_sizes=args.slice_sizes,
                 tensorflow=False,
                 gpu=args.torch_cuda,
                 torchscript=args.torchscript,
@@ -633,9 +508,6 @@ def main():
                 save_to_csv=args.save_to_csv,
                 csv_filename=args.csv_filename,
                 average_over=args.average_over,
-                no_speed=args.no_speed,
-                no_memory=args.no_memory,
-                verbose=args.verbose,
             )
         else:
             raise ImportError("Trying to run a PyTorch benchmark but PyTorch was not found in the environment.")
@@ -644,17 +516,12 @@ def main():
         if is_tf_available():
             create_setup_and_compute(
                 model_names=args.models,
-                batch_sizes=args.batch_sizes,
-                slice_sizes=args.slice_sizes,
                 tensorflow=True,
                 xla=args.xla,
                 amp=args.amp,
                 save_to_csv=args.save_to_csv,
                 csv_filename=args.csv_filename,
                 average_over=args.average_over,
-                no_speed=args.no_speed,
-                no_memory=args.no_memory,
-                verbose=args.verbose,
             )
         else:
             raise ImportError("Trying to run a TensorFlow benchmark but TensorFlow was not found in the environment.")

examples/contrib/run_openai_gpt.py

@@ -249,8 +249,8 @@ def main():
                 losses = model(input_ids, mc_token_ids=mc_token_ids, lm_labels=lm_labels, mc_labels=mc_labels)
                 loss = args.lm_coef * losses[0] + losses[1]
                 loss.backward()
-                optimizer.step()
                 scheduler.step()
+                optimizer.step()
                 optimizer.zero_grad()
                 tr_loss += loss.item()
                 exp_average_loss = (

examples/distillation/requirements.txt

@@ -3,5 +3,5 @@ transformers
 gitpython==3.0.2
 tensorboard>=1.14.0
 tensorboardX==1.8
-psutil==5.6.6
+psutil==5.6.3
 scipy==1.3.1

examples/glue/README.md

@@ -1,9 +0,0 @@
-# GLUE Benchmark
-
-Based on the script [`run_glue.py`](https://github.com/huggingface/transformers/blob/master/examples/run_glue.py).
-
-#### Run PyTorch version using PyTorch-Lightning
-
-Run `bash run_pl.sh` from the `glue` directory. This will also install `pytorch-lightning` and the requirements in `examples/requirements.txt`. It is a shell pipeline that will automatically download, pre-process the data and run the specified models. Logs are saved in `lightning_logs` directory.
-
-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}`

examples/glue/run_pl.sh

@@ -1,38 +0,0 @@
-# Install newest ptl.
-pip install -U git+http://github.com/PyTorchLightning/pytorch-lightning/
-# Install example requirements
-pip install -r ../requirements.txt
-
-# Download glue data
-python3 ../../utils/download_glue_data.py
-
-export TASK=mrpc
-export DATA_DIR=./glue_data/MRPC/
-export MAX_LENGTH=128
-export LEARNING_RATE=2e-5
-export BERT_MODEL=bert-base-cased
-export MODEL_TYPE=bert
-export BATCH_SIZE=32
-export NUM_EPOCHS=3
-export SEED=2
-export OUTPUT_DIR_NAME=mrpc-pl-bert
-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 transformer_base.py
-export PYTHONPATH="../":"${PYTHONPATH}"
-
-python3 run_pl_glue.py --data_dir $DATA_DIR \
---model_type $MODEL_TYPE \
---task $TASK \
---model_name_or_path $BERT_MODEL \
---output_dir $OUTPUT_DIR \
---max_seq_length  $MAX_LENGTH \
---learning_rate $LEARNING_RATE \
---num_train_epochs $NUM_EPOCHS \
---train_batch_size $BATCH_SIZE \
---seed $SEED \
---do_train \
---do_predict

examples/glue/run_pl_glue.py

@@ -1,196 +0,0 @@
-import argparse
-import glob
-import logging
-import os
-import time
-
-import numpy as np
-import torch
-from torch.utils.data import DataLoader, TensorDataset
-
-from transformer_base import BaseTransformer, add_generic_args, generic_train
-from transformers import glue_compute_metrics as compute_metrics
-from transformers import glue_convert_examples_to_features as convert_examples_to_features
-from transformers import glue_output_modes
-from transformers import glue_processors as processors
-from transformers import glue_tasks_num_labels
-
-
-logger = logging.getLogger(__name__)
-
-
-class GLUETransformer(BaseTransformer):
-
-    mode = "sequence-classification"
-
-    def __init__(self, hparams):
-        hparams.glue_output_mode = glue_output_modes[hparams.task]
-        num_labels = glue_tasks_num_labels[hparams.task]
-
-        super().__init__(hparams, num_labels, self.mode)
-
-    def forward(self, **inputs):
-        return self.model(**inputs)
-
-    def training_step(self, batch, batch_idx):
-        inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
-
-        if self.hparams.model_type != "distilbert":
-            inputs["token_type_ids"] = batch[2] if self.hparams.model_type in ["bert", "xlnet", "albert"] else None
-
-        outputs = self(**inputs)
-        loss = outputs[0]
-
-        tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]}
-        return {"loss": loss, "log": tensorboard_logs}
-
-    def prepare_data(self):
-        "Called to initialize data. Use the call to construct features"
-        args = self.hparams
-        processor = processors[args.task]()
-        self.labels = processor.get_labels()
-
-        for mode in ["train", "dev"]:
-            cached_features_file = self._feature_file(mode)
-            if not os.path.exists(cached_features_file) and not args.overwrite_cache:
-                logger.info("Creating features from dataset file at %s", args.data_dir)
-                examples = (
-                    processor.get_dev_examples(args.data_dir)
-                    if mode == "dev"
-                    else processor.get_train_examples(args.data_dir)
-                )
-                features = convert_examples_to_features(
-                    examples,
-                    self.tokenizer,
-                    max_length=args.max_seq_length,
-                    task=args.task,
-                    label_list=self.labels,
-                    output_mode=args.glue_output_mode,
-                    pad_on_left=bool(args.model_type in ["xlnet"]),  # pad on the left for xlnet
-                    pad_token=self.tokenizer.convert_tokens_to_ids([self.tokenizer.pad_token])[0],
-                    pad_token_segment_id=4 if args.model_type in ["xlnet"] else 0,
-                )
-                logger.info("Saving features into cached file %s", cached_features_file)
-                torch.save(features, cached_features_file)
-
-    def load_dataset(self, mode, batch_size):
-        "Load datasets. Called after prepare data."
-
-        # We test on dev set to compare to benchmarks without having to submit to GLUE server
-        mode = "dev" if mode == "test" else mode
-
-        cached_features_file = self._feature_file(mode)
-        logger.info("Loading features from cached file %s", cached_features_file)
-        features = torch.load(cached_features_file)
-        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 self.hparams.glue_output_mode == "classification":
-            all_labels = torch.tensor([f.label for f in features], dtype=torch.long)
-        elif self.hparams.glue_output_mode == "regression":
-            all_labels = torch.tensor([f.label for f in features], dtype=torch.float)
-
-        return DataLoader(
-            TensorDataset(all_input_ids, all_attention_mask, all_token_type_ids, all_labels),
-            batch_size=batch_size,
-            shuffle=True,
-        )
-
-    def validation_step(self, batch, batch_idx):
-        inputs = {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
-
-        if self.hparams.model_type != "distilbert":
-            inputs["token_type_ids"] = batch[2] if self.hparams.model_type in ["bert", "xlnet", "albert"] else None
-
-        outputs = self(**inputs)
-        tmp_eval_loss, logits = outputs[:2]
-        preds = logits.detach().cpu().numpy()
-        out_label_ids = inputs["labels"].detach().cpu().numpy()
-
-        return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}
-
-    def _eval_end(self, outputs):
-        val_loss_mean = torch.stack([x["val_loss"] for x in outputs]).mean().detach().cpu().item()
-        preds = np.concatenate([x["pred"] for x in outputs], axis=0)
-
-        if self.hparams.glue_output_mode == "classification":
-            preds = np.argmax(preds, axis=1)
-        elif self.hparams.glue_output_mode == "regression":
-            preds = np.squeeze(preds)
-
-        out_label_ids = np.concatenate([x["target"] for x in outputs], axis=0)
-        out_label_list = [[] for _ in range(out_label_ids.shape[0])]
-        preds_list = [[] for _ in range(out_label_ids.shape[0])]
-
-        results = {**{"val_loss": val_loss_mean}, **compute_metrics(self.hparams.task, preds, out_label_ids)}
-
-        ret = {k: v for k, v in results.items()}
-        ret["log"] = results
-        return ret, preds_list, out_label_list
-
-    def validation_end(self, outputs: list) -> dict:
-        ret, preds, targets = self._eval_end(outputs)
-        logs = ret["log"]
-        return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}
-
-    def test_epoch_end(self, outputs):
-        # updating to test_epoch_end instead of deprecated test_end
-        ret, predictions, targets = self._eval_end(outputs)
-
-        # Converting to the dic required by pl
-        # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\
-        # pytorch_lightning/trainer/logging.py#L139
-        logs = ret["log"]
-        # `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
-        return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}
-
-    @staticmethod
-    def add_model_specific_args(parser, root_dir):
-        # Add NER specific options
-        BaseTransformer.add_model_specific_args(parser, root_dir)
-        parser.add_argument(
-            "--max_seq_length",
-            default=128,
-            type=int,
-            help="The maximum total input sequence length after tokenization. Sequences longer "
-            "than this will be truncated, sequences shorter will be padded.",
-        )
-
-        parser.add_argument(
-            "--task", default="", type=str, required=True, help="The GLUE task to run",
-        )
-
-        parser.add_argument(
-            "--data_dir",
-            default=None,
-            type=str,
-            required=True,
-            help="The input data dir. Should contain the training files for the CoNLL-2003 NER task.",
-        )
-
-        parser.add_argument(
-            "--overwrite_cache", action="store_true", help="Overwrite the cached training and evaluation sets"
-        )
-
-        return parser
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    add_generic_args(parser, os.getcwd())
-    parser = GLUETransformer.add_model_specific_args(parser, os.getcwd())
-    args = parser.parse_args()
-
-    # If output_dir not provided, a folder will be generated in pwd
-    if args.output_dir is None:
-        args.output_dir = os.path.join("./results", f"{args.task}_{args.model_type}_{time.strftime('%Y%m%d_%H%M%S')}",)
-        os.makedirs(args.output_dir)
-
-    model = GLUETransformer(args)
-    trainer = generic_train(model, args)
-
-    # Optionally, predict on dev set and write to output_dir
-    if args.do_predict:
-        checkpoints = list(sorted(glob.glob(os.path.join(args.output_dir, "checkpointepoch=*.ckpt"), recursive=True)))
-        GLUETransformer.load_from_checkpoint(checkpoints[-1])
-        trainer.test(model)

examples/ner/run_ner.py

@@ -31,12 +31,26 @@ from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange
 
 from transformers import (
-    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     WEIGHTS_NAME,
     AdamW,
-    AutoConfig,
-    AutoModelForTokenClassification,
-    AutoTokenizer,
+    AlbertConfig,
+    AlbertForTokenClassification,
+    AlbertTokenizer,
+    BertConfig,
+    BertForTokenClassification,
+    BertTokenizer,
+    CamembertConfig,
+    CamembertForTokenClassification,
+    CamembertTokenizer,
+    DistilBertConfig,
+    DistilBertForTokenClassification,
+    DistilBertTokenizer,
+    RobertaConfig,
+    RobertaForTokenClassification,
+    RobertaTokenizer,
+    XLMRobertaConfig,
+    XLMRobertaForTokenClassification,
+    XLMRobertaTokenizer,
     get_linear_schedule_with_warmup,
 )
 from utils_ner import convert_examples_to_features, get_labels, read_examples_from_file
@@ -50,10 +64,22 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-MODEL_CONFIG_CLASSES = list(MODEL_FOR_TOKEN_CLASSIFICATION_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 (BertConfig, RobertaConfig, DistilBertConfig, CamembertConfig, XLMRobertaConfig)
+    ),
+    (),
+)
 
-ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in MODEL_CONFIG_CLASSES), ())
+MODEL_CLASSES = {
+    "albert": (AlbertConfig, AlbertForTokenClassification, AlbertTokenizer),
+    "bert": (BertConfig, BertForTokenClassification, BertTokenizer),
+    "roberta": (RobertaConfig, RobertaForTokenClassification, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForTokenClassification, DistilBertTokenizer),
+    "camembert": (CamembertConfig, CamembertForTokenClassification, CamembertTokenizer),
+    "xlmroberta": (XLMRobertaConfig, XLMRobertaForTokenClassification, XLMRobertaTokenizer),
+}
 
 TOKENIZER_ARGS = ["do_lower_case", "strip_accents", "keep_accents", "use_fast"]
 
@@ -196,8 +222,8 @@ def train(args, train_dataset, model, tokenizer, labels, pad_token_label_id):
                 else:
                     torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
 
-                optimizer.step()
                 scheduler.step()  # Update learning rate schedule
+                optimizer.step()
                 model.zero_grad()
                 global_step += 1
 
@@ -385,7 +411,7 @@ def main():
         default=None,
         type=str,
         required=True,
-        help="Model type selected in the list: " + ", ".join(MODEL_TYPES),
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
     )
     parser.add_argument(
         "--model_name_or_path",
@@ -568,7 +594,8 @@ def main():
         torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab
 
     args.model_type = args.model_type.lower()
-    config = AutoConfig.from_pretrained(
+    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,
         id2label={str(i): label for i, label in enumerate(labels)},
@@ -577,12 +604,12 @@ def main():
     )
     tokenizer_args = {k: v for k, v in vars(args).items() if v is not None and k in TOKENIZER_ARGS}
     logger.info("Tokenizer arguments: %s", tokenizer_args)
-    tokenizer = AutoTokenizer.from_pretrained(
+    tokenizer = tokenizer_class.from_pretrained(
         args.tokenizer_name if args.tokenizer_name else args.model_name_or_path,
         cache_dir=args.cache_dir if args.cache_dir else None,
         **tokenizer_args,
     )
-    model = AutoModelForTokenClassification.from_pretrained(
+    model = model_class.from_pretrained(
         args.model_name_or_path,
         from_tf=bool(".ckpt" in args.model_name_or_path),
         config=config,
@@ -623,7 +650,7 @@ def main():
     # Evaluation
     results = {}
     if args.do_eval and args.local_rank in [-1, 0]:
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir, **tokenizer_args)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir, **tokenizer_args)
         checkpoints = [args.output_dir]
         if args.eval_all_checkpoints:
             checkpoints = list(
@@ -633,7 +660,7 @@ def main():
         logger.info("Evaluate the following checkpoints: %s", checkpoints)
         for checkpoint in checkpoints:
             global_step = checkpoint.split("-")[-1] if len(checkpoints) > 1 else ""
-            model = AutoModelForTokenClassification.from_pretrained(checkpoint)
+            model = model_class.from_pretrained(checkpoint)
             model.to(args.device)
             result, _ = evaluate(args, model, tokenizer, labels, pad_token_label_id, mode="dev", prefix=global_step)
             if global_step:
@@ -645,8 +672,8 @@ def main():
                 writer.write("{} = {}\n".format(key, str(results[key])))
 
     if args.do_predict and args.local_rank in [-1, 0]:
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir, **tokenizer_args)
-        model = AutoModelForTokenClassification.from_pretrained(args.output_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir, **tokenizer_args)
+        model = model_class.from_pretrained(args.output_dir)
         model.to(args.device)
         result, predictions = evaluate(args, model, tokenizer, labels, pad_token_label_id, mode="test")
         # Save results

examples/ner/run_pl.sh

@@ -27,9 +27,6 @@ export CURRENT_DIR=${PWD}
 export OUTPUT_DIR=${CURRENT_DIR}/${OUTPUT_DIR_NAME}
 mkdir -p $OUTPUT_DIR
 
-# Add parent directory to python path to access transformer_base.py
-export PYTHONPATH="../":"${PYTHONPATH}"
-
 python3 run_pl_ner.py --data_dir ./ \
 --model_type bert \
 --labels ./labels.txt \
@@ -37,7 +34,7 @@ python3 run_pl_ner.py --data_dir ./ \
 --output_dir $OUTPUT_DIR \
 --max_seq_length  $MAX_LENGTH \
 --num_train_epochs $NUM_EPOCHS \
---train_batch_size $BATCH_SIZE \
+--train_batch_size 32 \
 --seed $SEED \
 --do_train \
 --do_predict

examples/ner/run_pl_ner.py

@@ -21,13 +21,11 @@ class NERTransformer(BaseTransformer):
     A training module for NER. See BaseTransformer for the core options.
     """
 
-    mode = "token-classification"
-
     def __init__(self, hparams):
         self.labels = get_labels(hparams.labels)
         num_labels = len(self.labels)
         self.pad_token_label_id = CrossEntropyLoss().ignore_index
-        super(NERTransformer, self).__init__(hparams, num_labels, self.mode)
+        super(NERTransformer, self).__init__(hparams, num_labels)
 
     def forward(self, **inputs):
         return self.model(**inputs)
@@ -40,11 +38,21 @@ class NERTransformer(BaseTransformer):
                 batch[2] if self.hparams.model_type in ["bert", "xlnet"] else None
             )  # XLM and RoBERTa don"t use segment_ids
 
-        outputs = self(**inputs)
+        outputs = self.forward(**inputs)
         loss = outputs[0]
         tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]}
         return {"loss": loss, "log": tensorboard_logs}
 
+    def _feature_file(self, mode):
+        return os.path.join(
+            self.hparams.data_dir,
+            "cached_{}_{}_{}".format(
+                mode,
+                list(filter(None, self.hparams.model_name_or_path.split("/"))).pop(),
+                str(self.hparams.max_seq_length),
+            ),
+        )
+
     def prepare_data(self):
         "Called to initialize data. Use the call to construct features"
         args = self.hparams
@@ -92,7 +100,7 @@ class NERTransformer(BaseTransformer):
             inputs["token_type_ids"] = (
                 batch[2] if self.hparams.model_type in ["bert", "xlnet"] else None
             )  # XLM and RoBERTa don"t use segment_ids
-        outputs = self(**inputs)
+        outputs = self.forward(**inputs)
         tmp_eval_loss, logits = outputs[:2]
         preds = logits.detach().cpu().numpy()
         out_label_ids = inputs["labels"].detach().cpu().numpy()
@@ -122,8 +130,14 @@ class NERTransformer(BaseTransformer):
             "f1": f1_score(out_label_list, preds_list),
         }
 
+        if self.is_logger():
+            logger.info("***** Eval results *****")
+            for key in sorted(results.keys()):
+                logger.info("  %s = %s", key, str(results[key]))
+
+        tensorboard_logs = results
         ret = {k: v for k, v in results.items()}
-        ret["log"] = results
+        ret["log"] = tensorboard_logs
         return ret, preds_list, out_label_list
 
     def validation_end(self, outputs):
@@ -137,7 +151,32 @@ class NERTransformer(BaseTransformer):
         # updating to test_epoch_end instead of deprecated test_end
         ret, predictions, targets = self._eval_end(outputs)
 
-        # Converting to the dict required by pl
+        if self.is_logger():
+            # Write output to a file:
+            # Save results
+            output_test_results_file = os.path.join(self.hparams.output_dir, "test_results.txt")
+            with open(output_test_results_file, "w") as writer:
+                for key in sorted(ret.keys()):
+                    if key != "log":
+                        writer.write("{} = {}\n".format(key, str(ret[key])))
+            # Save predictions
+            output_test_predictions_file = os.path.join(self.hparams.output_dir, "test_predictions.txt")
+            with open(output_test_predictions_file, "w") as writer:
+                with open(os.path.join(self.hparams.data_dir, "test.txt"), "r") as f:
+                    example_id = 0
+                    for line in f:
+                        if line.startswith("-DOCSTART-") or line == "" or line == "\n":
+                            writer.write(line)
+                            if not predictions[example_id]:
+                                example_id += 1
+                        elif predictions[example_id]:
+                            output_line = line.split()[0] + " " + predictions[example_id].pop(0) + "\n"
+                            writer.write(output_line)
+                        else:
+                            logger.warning(
+                                "Maximum sequence length exceeded: No prediction for '%s'.", line.split()[0]
+                            )
+        # Converting to the dic required by pl
         # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\
         # pytorch_lightning/trainer/logging.py#L139
         logs = ret["log"]
@@ -191,6 +230,6 @@ if __name__ == "__main__":
         # pl use this format to create a checkpoint:
         # https://github.com/PyTorchLightning/pytorch-lightning/blob/master\
         # /pytorch_lightning/callbacks/model_checkpoint.py#L169
-        checkpoints = list(sorted(glob.glob(os.path.join(args.output_dir, "checkpointepoch=*.ckpt"), recursive=True)))
+        checkpoints = list(sorted(glob.glob(args.output_dir + "/checkpointepoch=*.ckpt", recursive=True)))
         NERTransformer.load_from_checkpoint(checkpoints[-1])
         trainer.test(model)

examples/ner/run_tf_ner.py

@@ -13,11 +13,16 @@ from seqeval import metrics
 
 from transformers import (
     TF2_WEIGHTS_NAME,
-    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
-    AutoConfig,
-    AutoTokenizer,
+    BertConfig,
+    BertTokenizer,
+    DistilBertConfig,
+    DistilBertTokenizer,
     GradientAccumulator,
-    TFAutoModelForTokenClassification,
+    RobertaConfig,
+    RobertaTokenizer,
+    TFBertForTokenClassification,
+    TFDistilBertForTokenClassification,
+    TFRobertaForTokenClassification,
     create_optimizer,
 )
 from utils_ner import convert_examples_to_features, get_labels, read_examples_from_file
@@ -29,17 +34,22 @@ except ImportError:
     from fastprogress.fastprogress import master_bar, progress_bar
 
 
-MODEL_CONFIG_CLASSES = list(TF_MODEL_FOR_TOKEN_CLASSIFICATION_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 (BertConfig, RobertaConfig, DistilBertConfig)), ()
+)
 
-ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in MODEL_CONFIG_CLASSES), (),)
+MODEL_CLASSES = {
+    "bert": (BertConfig, TFBertForTokenClassification, BertTokenizer),
+    "roberta": (RobertaConfig, TFRobertaForTokenClassification, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, TFDistilBertForTokenClassification, DistilBertTokenizer),
+}
 
 
 flags.DEFINE_string(
     "data_dir", None, "The input data dir. Should contain the .conll files (or other data files) " "for the task."
 )
 
-flags.DEFINE_string("model_type", None, "Model type selected in the list: " + ", ".join(MODEL_TYPES))
+flags.DEFINE_string("model_type", None, "Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
 
 flags.DEFINE_string(
     "model_name_or_path",
@@ -499,7 +509,8 @@ def main(_):
     labels = get_labels(args["labels"])
     num_labels = len(labels) + 1
     pad_token_label_id = 0
-    config = AutoConfig.from_pretrained(
+    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,
         cache_dir=args["cache_dir"] if args["cache_dir"] else None,
@@ -509,14 +520,14 @@ def main(_):
 
     # Training
     if args["do_train"]:
-        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"] if args["cache_dir"] else None,
         )
 
         with strategy.scope():
-            model = TFAutoModelForTokenClassification.from_pretrained(
+            model = model_class.from_pretrained(
                 args["model_name_or_path"],
                 from_pt=bool(".bin" in args["model_name_or_path"]),
                 config=config,
@@ -551,7 +562,7 @@ def main(_):
 
     # Evaluation
     if args["do_eval"]:
-        tokenizer = AutoTokenizer.from_pretrained(args["output_dir"], do_lower_case=args["do_lower_case"])
+        tokenizer = tokenizer_class.from_pretrained(args["output_dir"], do_lower_case=args["do_lower_case"])
         checkpoints = []
         results = []
 
@@ -573,7 +584,7 @@ def main(_):
             global_step = checkpoint.split("-")[-1] if re.match(".*checkpoint-[0-9]", checkpoint) else "final"
 
             with strategy.scope():
-                model = TFAutoModelForTokenClassification.from_pretrained(checkpoint)
+                model = model_class.from_pretrained(checkpoint)
 
             y_true, y_pred, eval_loss = evaluate(
                 args, strategy, model, tokenizer, labels, pad_token_label_id, mode="dev"
@@ -600,8 +611,8 @@ def main(_):
                         writer.write("\n")
 
     if args["do_predict"]:
-        tokenizer = AutoTokenizer.from_pretrained(args["output_dir"], do_lower_case=args["do_lower_case"])
-        model = TFAutoModelForTokenClassification.from_pretrained(args["output_dir"])
+        tokenizer = tokenizer_class.from_pretrained(args["output_dir"], do_lower_case=args["do_lower_case"])
+        model = model_class.from_pretrained(args["output_dir"])
         eval_batch_size = args["per_device_eval_batch_size"] * args["n_device"]
         predict_dataset, _ = load_and_cache_examples(
             args, tokenizer, labels, pad_token_label_id, eval_batch_size, mode="test"

examples/ner/transformer_base.py

@@ -7,34 +7,43 @@ import pytorch_lightning as pl
 import torch
 
 from transformers import (
-    ALL_PRETRAINED_MODEL_ARCHIVE_MAP,
     AdamW,
-    AutoConfig,
-    AutoModel,
-    AutoModelForPreTraining,
-    AutoModelForQuestionAnswering,
-    AutoModelForSequenceClassification,
-    AutoModelForTokenClassification,
-    AutoModelWithLMHead,
-    AutoTokenizer,
+    BertConfig,
+    BertForTokenClassification,
+    BertTokenizer,
+    CamembertConfig,
+    CamembertForTokenClassification,
+    CamembertTokenizer,
+    DistilBertConfig,
+    DistilBertForTokenClassification,
+    DistilBertTokenizer,
+    RobertaConfig,
+    RobertaForTokenClassification,
+    RobertaTokenizer,
+    XLMRobertaConfig,
+    XLMRobertaForTokenClassification,
+    XLMRobertaTokenizer,
     get_linear_schedule_with_warmup,
 )
-from transformers.modeling_auto import MODEL_MAPPING
 
 
 logger = logging.getLogger(__name__)
 
 
-ALL_MODELS = tuple(ALL_PRETRAINED_MODEL_ARCHIVE_MAP)
-MODEL_CLASSES = tuple(m.model_type for m in MODEL_MAPPING)
+ALL_MODELS = sum(
+    (
+        tuple(conf.pretrained_config_archive_map.keys())
+        for conf in (BertConfig, RobertaConfig, DistilBertConfig, CamembertConfig, XLMRobertaConfig)
+    ),
+    (),
+)
 
-MODEL_MODES = {
-    "base": AutoModel,
-    "sequence-classification": AutoModelForSequenceClassification,
-    "question-answering": AutoModelForQuestionAnswering,
-    "pretraining": AutoModelForPreTraining,
-    "token-classification": AutoModelForTokenClassification,
-    "language-modeling": AutoModelWithLMHead,
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertForTokenClassification, BertTokenizer),
+    "roberta": (RobertaConfig, RobertaForTokenClassification, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForTokenClassification, DistilBertTokenizer),
+    "camembert": (CamembertConfig, CamembertForTokenClassification, CamembertTokenizer),
+    "xlmroberta": (XLMRobertaConfig, XLMRobertaForTokenClassification, XLMRobertaTokenizer),
 }
 
 
@@ -47,23 +56,25 @@ def set_seed(args):
 
 
 class BaseTransformer(pl.LightningModule):
-    def __init__(self, hparams, num_labels=None, mode="base"):
+    def __init__(self, hparams, num_labels=None):
         "Initialize a model."
 
         super(BaseTransformer, self).__init__()
         self.hparams = hparams
         self.hparams.model_type = self.hparams.model_type.lower()
-        config = AutoConfig.from_pretrained(
+
+        config_class, model_class, tokenizer_class = MODEL_CLASSES[self.hparams.model_type]
+        config = config_class.from_pretrained(
             self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path,
-            **({"num_labels": num_labels} if num_labels is not None else {}),
+            num_labels=num_labels,
             cache_dir=self.hparams.cache_dir if self.hparams.cache_dir else None,
         )
-        tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer = tokenizer_class.from_pretrained(
             self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path,
             do_lower_case=self.hparams.do_lower_case,
             cache_dir=self.hparams.cache_dir if self.hparams.cache_dir else None,
         )
-        model = MODEL_MODES[mode].from_pretrained(
+        model = model_class.from_pretrained(
             self.hparams.model_name_or_path,
             from_tf=bool(".ckpt" in self.hparams.model_name_or_path),
             config=config,
@@ -133,16 +144,6 @@ class BaseTransformer(pl.LightningModule):
     def test_dataloader(self):
         return self.load_dataset("test", self.hparams.eval_batch_size)
 
-    def _feature_file(self, mode):
-        return os.path.join(
-            self.hparams.data_dir,
-            "cached_{}_{}_{}".format(
-                mode,
-                list(filter(None, self.hparams.model_name_or_path.split("/"))).pop(),
-                str(self.hparams.max_seq_length),
-            ),
-        )
-
     @staticmethod
     def add_model_specific_args(parser, root_dir):
         parser.add_argument(
@@ -150,7 +151,7 @@ class BaseTransformer(pl.LightningModule):
             default=None,
             type=str,
             required=True,
-            help="Model type selected in the list: " + ", ".join(MODEL_CLASSES),
+            help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
         )
         parser.add_argument(
             "--model_name_or_path",
@@ -189,31 +190,6 @@ class BaseTransformer(pl.LightningModule):
         parser.add_argument("--eval_batch_size", default=32, type=int)
 
 
-class LoggingCallback(pl.Callback):
-    def on_validation_end(self, trainer, pl_module):
-        logger.info("***** Validation results *****")
-        if pl_module.is_logger():
-            metrics = trainer.callback_metrics
-            # Log results
-            for key in sorted(metrics):
-                if key not in ["log", "progress_bar"]:
-                    logger.info("{} = {}\n".format(key, str(metrics[key])))
-
-    def on_test_end(self, trainer, pl_module):
-        logger.info("***** Test results *****")
-
-        if pl_module.is_logger():
-            metrics = trainer.callback_metrics
-
-            # Log and save results to file
-            output_test_results_file = os.path.join(pl_module.hparams.output_dir, "test_results.txt")
-            with open(output_test_results_file, "w") as writer:
-                for key in sorted(metrics):
-                    if key not in ["log", "progress_bar"]:
-                        logger.info("{} = {}\n".format(key, str(metrics[key])))
-                        writer.write("{} = {}\n".format(key, str(metrics[key])))
-
-
 def add_generic_args(parser, root_dir):
     parser.add_argument(
         "--output_dir",
@@ -281,7 +257,6 @@ def generic_train(model, args):
         early_stop_callback=False,
         gradient_clip_val=args.max_grad_norm,
         checkpoint_callback=checkpoint_callback,
-        callbacks=[LoggingCallback()],
     )
 
     if args.fp16:

examples/requirements.txt

@@ -2,7 +2,3 @@ tensorboardX
 tensorboard
 scikit-learn
 seqeval
-psutil
-sacrebleu
-rouge-score
-tensorflow_datasets

examples/run_glue.py

@@ -30,12 +30,32 @@ from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange
 
 from transformers import (
-    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     WEIGHTS_NAME,
     AdamW,
-    AutoConfig,
-    AutoModelForSequenceClassification,
-    AutoTokenizer,
+    AlbertConfig,
+    AlbertForSequenceClassification,
+    AlbertTokenizer,
+    BertConfig,
+    BertForSequenceClassification,
+    BertTokenizer,
+    DistilBertConfig,
+    DistilBertForSequenceClassification,
+    DistilBertTokenizer,
+    FlaubertConfig,
+    FlaubertForSequenceClassification,
+    FlaubertTokenizer,
+    RobertaConfig,
+    RobertaForSequenceClassification,
+    RobertaTokenizer,
+    XLMConfig,
+    XLMForSequenceClassification,
+    XLMRobertaConfig,
+    XLMRobertaForSequenceClassification,
+    XLMRobertaTokenizer,
+    XLMTokenizer,
+    XLNetConfig,
+    XLNetForSequenceClassification,
+    XLNetTokenizer,
     get_linear_schedule_with_warmup,
 )
 from transformers import glue_compute_metrics as compute_metrics
@@ -52,10 +72,33 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-MODEL_CONFIG_CLASSES = list(MODEL_FOR_SEQUENCE_CLASSIFICATION_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 (
+            BertConfig,
+            XLNetConfig,
+            XLMConfig,
+            RobertaConfig,
+            DistilBertConfig,
+            AlbertConfig,
+            XLMRobertaConfig,
+            FlaubertConfig,
+        )
+    ),
+    (),
+)
 
-ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in MODEL_CONFIG_CLASSES), (),)
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertForSequenceClassification, BertTokenizer),
+    "xlnet": (XLNetConfig, XLNetForSequenceClassification, XLNetTokenizer),
+    "xlm": (XLMConfig, XLMForSequenceClassification, XLMTokenizer),
+    "roberta": (RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForSequenceClassification, DistilBertTokenizer),
+    "albert": (AlbertConfig, AlbertForSequenceClassification, AlbertTokenizer),
+    "xlmroberta": (XLMRobertaConfig, XLMRobertaForSequenceClassification, XLMRobertaTokenizer),
+    "flaubert": (FlaubertConfig, FlaubertForSequenceClassification, FlaubertTokenizer),
+}
 
 
 def set_seed(args):
@@ -190,11 +233,7 @@ def train(args, train_dataset, model, tokenizer):
                 loss.backward()
 
             tr_loss += loss.item()
-            if (step + 1) % args.gradient_accumulation_steps == 0 or (
-                # last step in epoch but step is always smaller than gradient_accumulation_steps
-                len(epoch_iterator) <= args.gradient_accumulation_steps
-                and (step + 1) == len(epoch_iterator)
-            ):
+            if (step + 1) % args.gradient_accumulation_steps == 0:
                 if args.fp16:
                     torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
                 else:
@@ -399,7 +438,7 @@ def main():
         default=None,
         type=str,
         required=True,
-        help="Model type selected in the list: " + ", ".join(MODEL_TYPES),
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
     )
     parser.add_argument(
         "--model_name_or_path",
@@ -579,18 +618,19 @@ def main():
         torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab
 
     args.model_type = args.model_type.lower()
-    config = AutoConfig.from_pretrained(
+    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 if args.cache_dir else None,
     )
-    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 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,
@@ -629,14 +669,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 = AutoTokenizer.from_pretrained(args.output_dir, do_lower_case=args.do_lower_case)
+        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(
@@ -648,7 +688,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())

examples/run_language_modeling.py

@@ -38,14 +38,28 @@ from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange
 
 from transformers import (
-    MODEL_WITH_LM_HEAD_MAPPING,
     WEIGHTS_NAME,
     AdamW,
-    AutoConfig,
-    AutoModelWithLMHead,
-    AutoTokenizer,
+    BertConfig,
+    BertForMaskedLM,
+    BertTokenizer,
+    CamembertConfig,
+    CamembertForMaskedLM,
+    CamembertTokenizer,
+    DistilBertConfig,
+    DistilBertForMaskedLM,
+    DistilBertTokenizer,
+    GPT2Config,
+    GPT2LMHeadModel,
+    GPT2Tokenizer,
+    OpenAIGPTConfig,
+    OpenAIGPTLMHeadModel,
+    OpenAIGPTTokenizer,
     PreTrainedModel,
     PreTrainedTokenizer,
+    RobertaConfig,
+    RobertaForMaskedLM,
+    RobertaTokenizer,
     get_linear_schedule_with_warmup,
 )
 
@@ -59,8 +73,14 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-MODEL_CONFIG_CLASSES = list(MODEL_WITH_LM_HEAD_MAPPING.keys())
-MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+MODEL_CLASSES = {
+    "gpt2": (GPT2Config, GPT2LMHeadModel, GPT2Tokenizer),
+    "openai-gpt": (OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
+    "bert": (BertConfig, BertForMaskedLM, BertTokenizer),
+    "roberta": (RobertaConfig, RobertaForMaskedLM, RobertaTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer),
+    "camembert": (CamembertConfig, CamembertForMaskedLM, CamembertTokenizer),
+}
 
 
 class TextDataset(Dataset):
@@ -673,26 +693,23 @@ def main():
     if args.local_rank not in [-1, 0]:
         torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training download model & vocab
 
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+
     if args.config_name:
-        config = AutoConfig.from_pretrained(args.config_name, cache_dir=args.cache_dir)
+        config = config_class.from_pretrained(args.config_name, cache_dir=args.cache_dir)
     elif args.model_name_or_path:
-        config = AutoConfig.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
+        config = config_class.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
     else:
-        # When we release a pip version exposing CONFIG_MAPPING,
-        # we can do `config = CONFIG_MAPPING[args.model_type]()`.
-        raise ValueError(
-            "You are instantiating a new config instance from scratch. This is not supported, but you can do it from another script, save it,"
-            "and load it from here, using --config_name"
-        )
+        config = config_class()
 
     if args.tokenizer_name:
-        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, cache_dir=args.cache_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name, cache_dir=args.cache_dir)
     elif args.model_name_or_path:
-        tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
+        tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
     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"
+            "You are instantiating a new {} tokenizer. This is not supported, but you can do it from another script, save it,"
+            "and load it from here, using --tokenizer_name".format(tokenizer_class.__name__)
         )
 
     if args.block_size <= 0:
@@ -702,7 +719,7 @@ def main():
         args.block_size = min(args.block_size, tokenizer.max_len)
 
     if args.model_name_or_path:
-        model = AutoModelWithLMHead.from_pretrained(
+        model = model_class.from_pretrained(
             args.model_name_or_path,
             from_tf=bool(".ckpt" in args.model_name_or_path),
             config=config,
@@ -710,7 +727,7 @@ def main():
         )
     else:
         logger.info("Training new model from scratch")
-        model = AutoModelWithLMHead.from_config(config)
+        model = model_class(config=config)
 
     model.to(args.device)
 
@@ -751,8 +768,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 = AutoModelWithLMHead.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
@@ -769,7 +786,7 @@ def main():
             global_step = checkpoint.split("-")[-1] if len(checkpoints) > 1 else ""
             prefix = checkpoint.split("/")[-1] if checkpoint.find("checkpoint") != -1 else ""
 
-            model = AutoModelWithLMHead.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())

examples/run_squad.py

@@ -30,12 +30,29 @@ from torch.utils.data.distributed import DistributedSampler
 from tqdm import tqdm, trange
 
 from transformers import (
-    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     WEIGHTS_NAME,
     AdamW,
-    AutoConfig,
-    AutoModelForQuestionAnswering,
-    AutoTokenizer,
+    AlbertConfig,
+    AlbertForQuestionAnswering,
+    AlbertTokenizer,
+    BertConfig,
+    BertForQuestionAnswering,
+    BertTokenizer,
+    CamembertConfig,
+    CamembertForQuestionAnswering,
+    CamembertTokenizer,
+    DistilBertConfig,
+    DistilBertForQuestionAnswering,
+    DistilBertTokenizer,
+    RobertaConfig,
+    RobertaForQuestionAnswering,
+    RobertaTokenizer,
+    XLMConfig,
+    XLMForQuestionAnswering,
+    XLMTokenizer,
+    XLNetConfig,
+    XLNetForQuestionAnswering,
+    XLNetTokenizer,
     get_linear_schedule_with_warmup,
     squad_convert_examples_to_features,
 )
@@ -55,10 +72,23 @@ except ImportError:
 
 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 (BertConfig, CamembertConfig, RobertaConfig, XLNetConfig, XLMConfig)
+    ),
+    (),
+)
 
-ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in MODEL_CONFIG_CLASSES), (),)
+MODEL_CLASSES = {
+    "bert": (BertConfig, BertForQuestionAnswering, BertTokenizer),
+    "camembert": (CamembertConfig, CamembertForQuestionAnswering, CamembertTokenizer),
+    "roberta": (RobertaConfig, RobertaForQuestionAnswering, RobertaTokenizer),
+    "xlnet": (XLNetConfig, XLNetForQuestionAnswering, XLNetTokenizer),
+    "xlm": (XLMConfig, XLMForQuestionAnswering, XLMTokenizer),
+    "distilbert": (DistilBertConfig, DistilBertForQuestionAnswering, DistilBertTokenizer),
+    "albert": (AlbertConfig, AlbertForQuestionAnswering, AlbertTokenizer),
+}
 
 
 def set_seed(args):
@@ -483,7 +513,7 @@ def main():
         default=None,
         type=str,
         required=True,
-        help="Model type selected in the list: " + ", ".join(MODEL_TYPES),
+        help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()),
     )
     parser.add_argument(
         "--model_name_or_path",
@@ -727,16 +757,17 @@ def main():
         torch.distributed.barrier()
 
     args.model_type = args.model_type.lower()
-    config = AutoConfig.from_pretrained(
+    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,
         cache_dir=args.cache_dir if args.cache_dir else None,
     )
-    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 if args.cache_dir else None,
     )
-    model = AutoModelForQuestionAnswering.from_pretrained(
+    model = model_class.from_pretrained(
         args.model_name_or_path,
         from_tf=bool(".ckpt" in args.model_name_or_path),
         config=config,
@@ -786,8 +817,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 = AutoModelForQuestionAnswering.from_pretrained(args.output_dir)  # , force_download=True)
-        tokenizer = AutoTokenizer.from_pretrained(args.output_dir, do_lower_case=args.do_lower_case)
+        model = model_class.from_pretrained(args.output_dir)  # , force_download=True)
+        tokenizer = tokenizer_class.from_pretrained(args.output_dir, do_lower_case=args.do_lower_case)
         model.to(args.device)
 
     # Evaluation - we can ask to evaluate all the checkpoints (sub-directories) in a directory
@@ -811,7 +842,7 @@ def main():
         for checkpoint in checkpoints:
             # Reload the model
             global_step = checkpoint.split("-")[-1] if len(checkpoints) > 1 else ""
-            model = AutoModelForQuestionAnswering.from_pretrained(checkpoint)  # , force_download=True)
+            model = model_class.from_pretrained(checkpoint)  # , force_download=True)
             model.to(args.device)
 
             # Evaluate

examples/summarization/bart/README.md

@@ -14,19 +14,6 @@ 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.
 
-
-### Training
-
-
-
-After downloading the CNN and Daily Mail datasets, preprocess the dataset:
-```commandline
-git clone https://github.com/artmatsak/cnn-dailymail
-cd cnn-dailymail && python make_datafiles.py ../cnn/stories/ ../dailymail/stories/
-```
-
-Run the training script: `run_train.sh`
-
 ### Where is the code?
 The core model is in `src/transformers/modeling_bart.py`. This directory only contains examples.
 

examples/summarization/bart/evaluate_cnn.py

@@ -20,10 +20,6 @@ def generate_summaries(lns, out_file, batch_size=8, device=DEFAULT_DEVICE):
     fout = Path(out_file).open("w")
     model = BartForConditionalGeneration.from_pretrained("bart-large-cnn", output_past=True,).to(device)
     tokenizer = BartTokenizer.from_pretrained("bart-large")
-
-    max_length = 140
-    min_length = 55
-
     for batch in tqdm(list(chunks(lns, batch_size))):
         dct = tokenizer.batch_encode_plus(batch, max_length=1024, return_tensors="pt", pad_to_max_length=True)
         summaries = model.generate(
@@ -31,11 +27,9 @@ def generate_summaries(lns, out_file, batch_size=8, device=DEFAULT_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
+            max_length=140,
+            min_len=55,
             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:

examples/summarization/bart/run_bart_sum.py

@@ -1,172 +0,0 @@
-import argparse
-import glob
-import logging
-import os
-import time
-
-import torch
-from torch.utils.data import DataLoader
-
-from transformer_base import BaseTransformer, add_generic_args, generic_train, get_linear_schedule_with_warmup
-from utils import SummarizationDataset
-
-
-logger = logging.getLogger(__name__)
-
-
-class BartSystem(BaseTransformer):
-
-    mode = "language-modeling"
-
-    def __init__(self, hparams):
-        super(BartSystem, self).__init__(hparams, num_labels=None, mode=self.mode)
-
-    def forward(
-        self, input_ids, attention_mask=None, decoder_input_ids=None, decoder_attention_mask=None, lm_labels=None
-    ):
-        return self.model(
-            input_ids,
-            attention_mask=attention_mask,
-            decoder_input_ids=decoder_input_ids,
-            decoder_attention_mask=decoder_attention_mask,
-            lm_labels=lm_labels,
-        )
-
-    def _step(self, batch):
-        y = batch["target_ids"]
-        y_ids = y[:, :-1].contiguous()
-        lm_labels = y[:, 1:].clone()
-        lm_labels[y[:, 1:] == self.tokenizer.pad_token_id] = -100
-        outputs = self(
-            input_ids=batch["source_ids"],
-            attention_mask=batch["source_mask"],
-            decoder_input_ids=y_ids,
-            lm_labels=lm_labels,
-        )
-
-        loss = outputs[0]
-
-        return loss
-
-    def training_step(self, batch, batch_idx):
-        loss = self._step(batch)
-
-        tensorboard_logs = {"train_loss": loss}
-        return {"loss": loss, "log": tensorboard_logs}
-
-    def validation_step(self, batch, batch_idx):
-        loss = self._step(batch)
-        return {"val_loss": loss}
-
-    def validation_end(self, outputs):
-        avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean()
-        tensorboard_logs = {"val_loss": avg_loss}
-        return {"avg_val_loss": avg_loss, "log": tensorboard_logs}
-
-    def test_step(self, batch, batch_idx):
-        generated_ids = self.model.generate(
-            batch["source_ids"],
-            attention_mask=batch["source_mask"],
-            num_beams=1,
-            max_length=80,
-            repetition_penalty=2.5,
-            length_penalty=1.0,
-            early_stopping=True,
-        )
-        preds = [
-            self.tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=True)
-            for g in generated_ids
-        ]
-        target = [
-            self.tokenizer.decode(t, skip_special_tokens=True, clean_up_tokenization_spaces=True)
-            for t in batch["target_ids"]
-        ]
-        loss = self._step(batch)
-
-        return {"val_loss": loss, "preds": preds, "target": target}
-
-    def test_end(self, outputs):
-        return self.validation_end(outputs)
-
-    def test_epoch_end(self, outputs):
-        output_test_predictions_file = os.path.join(self.hparams.output_dir, "test_predictions.txt")
-        output_test_targets_file = os.path.join(self.hparams.output_dir, "test_targets.txt")
-        # write predictions and targets for later rouge evaluation.
-        with open(output_test_predictions_file, "w+") as p_writer, open(output_test_targets_file, "w+") as t_writer:
-            for output_batch in outputs:
-                p_writer.writelines(s + "\n" for s in output_batch["preds"])
-                t_writer.writelines(s + "\n" for s in output_batch["target"])
-            p_writer.close()
-            t_writer.close()
-
-        return self.test_end(outputs)
-
-    def train_dataloader(self):
-        train_dataset = SummarizationDataset(
-            self.tokenizer, data_dir=self.hparams.data_dir, type_path="train", block_size=self.hparams.max_seq_length
-        )
-        dataloader = DataLoader(train_dataset, batch_size=self.hparams.train_batch_size)
-        t_total = (
-            (len(dataloader.dataset) // (self.hparams.train_batch_size * max(1, self.hparams.n_gpu)))
-            // self.hparams.gradient_accumulation_steps
-            * float(self.hparams.num_train_epochs)
-        )
-        scheduler = get_linear_schedule_with_warmup(
-            self.opt, num_warmup_steps=self.hparams.warmup_steps, num_training_steps=t_total
-        )
-        self.lr_scheduler = scheduler
-        return dataloader
-
-    def val_dataloader(self):
-        val_dataset = SummarizationDataset(
-            self.tokenizer, data_dir=self.hparams.data_dir, type_path="val", block_size=self.hparams.max_seq_length
-        )
-        return DataLoader(val_dataset, batch_size=self.hparams.eval_batch_size)
-
-    def test_dataloader(self):
-        test_dataset = SummarizationDataset(
-            self.tokenizer, data_dir=self.hparams.data_dir, type_path="test", block_size=self.hparams.max_seq_length
-        )
-        return DataLoader(test_dataset, batch_size=self.hparams.eval_batch_size)
-
-    @staticmethod
-    def add_model_specific_args(parser, root_dir):
-        BaseTransformer.add_model_specific_args(parser, root_dir)
-        # Add BART specific options
-        parser.add_argument(
-            "--max_seq_length",
-            default=1024,
-            type=int,
-            help="The maximum total input sequence length after tokenization. Sequences longer "
-            "than this will be truncated, sequences shorter will be padded.",
-        )
-
-        parser.add_argument(
-            "--data_dir",
-            default=None,
-            type=str,
-            required=True,
-            help="The input data dir. Should contain the dataset files for the CNN/DM summarization task.",
-        )
-        return parser
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    add_generic_args(parser, os.getcwd())
-    parser = BartSystem.add_model_specific_args(parser, os.getcwd())
-    args = parser.parse_args()
-
-    # If output_dir not provided, a folder will be generated in pwd
-    if args.output_dir is None:
-        args.output_dir = os.path.join("./results", f"{args.task}_{args.model_type}_{time.strftime('%Y%m%d_%H%M%S')}",)
-        os.makedirs(args.output_dir)
-
-    model = BartSystem(args)
-    trainer = generic_train(model, args)
-
-    # Optionally, predict on dev set and write to output_dir
-    if args.do_predict:
-        checkpoints = list(sorted(glob.glob(os.path.join(args.output_dir, "checkpointepoch=*.ckpt"), recursive=True)))
-        BartSystem.load_from_checkpoint(checkpoints[-1])
-        trainer.test(model)

examples/summarization/bart/run_train.sh

@@ -1,23 +0,0 @@
-# Install newest ptl.
-pip install -U git+http://github.com/PyTorchLightning/pytorch-lightning/
-
-
-export OUTPUT_DIR_NAME=bart_sum
-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 transformer_base.py
-export PYTHONPATH="../../":"${PYTHONPATH}"
-
-python run_bart_sum.py \
---data_dir=./cnn-dailymail/cnn_dm \
---model_type=bart \
---model_name_or_path=bart-large \
---learning_rate=3e-5 \
---train_batch_size=4 \
---eval_batch_size=4 \
---output_dir=$OUTPUT_DIR \
---do_train

examples/summarization/bart/utils.py

@@ -1,43 +0,0 @@
-import os
-
-from torch.utils.data import Dataset
-
-
-class SummarizationDataset(Dataset):
-    def __init__(self, tokenizer, data_dir="./cnn-dailymail/cnn_dm/", type_path="train", block_size=1024):
-        super(SummarizationDataset,).__init__()
-        self.tokenizer = tokenizer
-
-        self.source = []
-        self.target = []
-
-        print("loading " + type_path + " source.")
-
-        with open(os.path.join(data_dir, type_path + ".source"), "r") as f:
-            for text in f.readlines():  # each text is a line and a full story
-                tokenized = tokenizer.batch_encode_plus(
-                    [text], max_length=block_size, pad_to_max_length=True, return_tensors="pt"
-                )
-                self.source.append(tokenized)
-            f.close()
-
-        print("loading " + type_path + " target.")
-
-        with open(os.path.join(data_dir, type_path + ".target"), "r") as f:
-            for text in f.readlines():  # each text is a line and a summary
-                tokenized = tokenizer.batch_encode_plus(
-                    [text], max_length=56, pad_to_max_length=True, return_tensors="pt"
-                )
-                self.target.append(tokenized)
-            f.close()
-
-    def __len__(self):
-        return len(self.source)
-
-    def __getitem__(self, index):
-        source_ids = self.source[index]["input_ids"].squeeze()
-        target_ids = self.target[index]["input_ids"].squeeze()
-
-        src_mask = self.source[index]["attention_mask"].squeeze()  # might need to squeeze
-
-        return {"source_ids": source_ids, "source_mask": src_mask, "target_ids": target_ids}

examples/summarization/bertabs/configuration_bertabs.py

@@ -23,7 +23,7 @@ logger = logging.getLogger(__name__)
 
 
 BERTABS_FINETUNED_CONFIG_MAP = {
-    "bertabs-finetuned-cnndm": "https://s3.amazonaws.com/models.huggingface.co/bert/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization/config.json",
+    "bertabs-finetuned-cnndm": "https://s3.amazonaws.com/models.huggingface.co/bert/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization-config.json",
 }
 
 

examples/summarization/bertabs/convert_bertabs_original_pytorch_checkpoint.py

@@ -157,7 +157,7 @@ def convert_bertabs_checkpoints(path_to_checkpoints, dump_path):
     # directory structure. We save the state_dict instead.
     logging.info("saving the model's state dictionary")
     torch.save(
-        new_model.state_dict(), "./bertabs-finetuned-cnndm-extractive-abstractive-summarization/pytorch_model.bin"
+        new_model.state_dict(), "bertabs-finetuned-cnndm-extractive-abstractive-summarization-pytorch_model.bin"
     )
 
 

examples/summarization/bertabs/modeling_bertabs.py

@@ -34,7 +34,7 @@ from transformers import BertConfig, BertModel, PreTrainedModel
 MAX_SIZE = 5000
 
 BERTABS_FINETUNED_MODEL_MAP = {
-    "bertabs-finetuned-cnndm": "https://s3.amazonaws.com/models.huggingface.co/bert/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization/pytorch_model.bin",
+    "bertabs-finetuned-cnndm": "https://s3.amazonaws.com/models.huggingface.co/bert/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization-pytorch_model.bin",
 }
 
 
@@ -844,7 +844,7 @@ class Translator(object):
             dec_out, dec_states = self.model.decoder(decoder_input, src_features, dec_states, step=step)
 
             # Generator forward.
-            log_probs = self.generator(dec_out.transpose(0, 1).squeeze(0))
+            log_probs = self.generator.forward(dec_out.transpose(0, 1).squeeze(0))
             vocab_size = log_probs.size(-1)
 
             if step < min_length:

examples/summarization/t5/README.md

@@ -1,25 +0,0 @@
-***This script evaluates the the multitask pre-trained checkpoint for ``t5-large`` (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
-```
-
-### Usage
-
-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``.

examples/summarization/t5/download_cnn_daily_mail.py

@@ -1,31 +0,0 @@
-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)

examples/summarization/t5/evaluate_cnn.py

@@ -1,95 +0,0 @@
-import argparse
-from pathlib import Path
-
-import torch
-from tqdm import tqdm
-
-from rouge_score import rouge_scorer, scoring
-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, batch_size, device):
-    output_file = Path(output_file_path).open("w")
-
-    model = T5ForConditionalGeneration.from_pretrained("t5-large")
-    model.to(device)
-
-    tokenizer = T5Tokenizer.from_pretrained("t5-large")
-
-    # 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(
-        "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.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()

examples/summarization/t5/test_t5_examples.py

@@ -1,29 +0,0 @@
-import logging
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from .evaluate_cnn import run_generate
-
-
-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.hypo"
-        with tmp.open("w") as f:
-            f.write("\n".join(articles))
-        testargs = ["evaluate_cnn.py", str(tmp), "output.txt", str(tmp), "score.txt"]
-        with patch.object(sys, "argv", testargs):
-            run_generate()
-            self.assertTrue(Path("output.txt").exists())
-            self.assertTrue(Path("score.txt").exists())

examples/translation/t5/README.md

@@ -1,51 +0,0 @@
-***This script evaluates the multitask pre-trained checkpoint for ``t5-base`` (see paper [here](https://arxiv.org/pdf/1910.10683.pdf)) on the English to German WMT dataset. Please note that the results in the paper were attained using a model fine-tuned on translation, so that results will be worse here by approx. 1.5 BLEU points***
-
-### Intro
-
-This example shows how T5 (here the official [paper](https://arxiv.org/abs/1910.10683)) can be
-evaluated on the WMT English-German dataset.
-
-### Get the WMT Data
-
-To be able to reproduce the authors' results on WMT English to German, you first need to download 
-the WMT14 en-de news datasets.
-Go on Stanford's official NLP [website](https://nlp.stanford.edu/projects/nmt/) and find "newstest2013.en" and "newstest2013.de" under WMT'14 English-German data or download the dataset directly via:
-
-```bash
-curl https://nlp.stanford.edu/projects/nmt/data/wmt14.en-de/newstest2013.en > newstest2013.en
-curl https://nlp.stanford.edu/projects/nmt/data/wmt14.en-de/newstest2013.de > newstest2013.de
-```
-
-You should have 3000 sentence in each file. You can verify this by running:
-
-```bash
-wc -l newstest2013.en  # should give 3000
-```
-
-### Usage
-
-Let's check the longest and shortest sentence in our file to find reasonable decoding hyperparameters: 
-
-Get the longest and shortest sentence:
-
-```bash 
-awk '{print NF}' newstest2013.en | sort -n | head -1 # shortest sentence has 1 word
-awk '{print NF}' newstest2013.en | sort -n | tail -1 # longest sentence has 106 words
-```
-
-We will set our `max_length` to ~3 times the longest sentence and leave `min_length` to its default value of 0.
-We decode with beam search `num_beams=4` as proposed in the paper. Also as is common in beam search we set `early_stopping=True` and `length_penalty=2.0`.
-
-To create translation for each in dataset and get a final BLEU score, run:
-```bash
-python evaluate_wmt.py <path_to_newstest2013.en> newstest2013_de_translations.txt <path_to_newstest2013.de> newsstest2013_en_de_bleu.txt
-```
-the default batch size, 16, fits in 16GB GPU memory, but may need to be adjusted to fit your system.
-
-### Where is the code?
-The core model is in `src/transformers/modeling_t5.py`. This directory only contains examples.
-
-### BLEU Scores
-
-The BLEU score is calculated using [sacrebleu](https://github.com/mjpost/sacreBLEU) by mjpost.
-To get the BLEU score we used 

examples/translation/t5/evaluate_wmt.py

@@ -1,90 +0,0 @@
-import argparse
-from pathlib import Path
-
-import torch
-from tqdm import tqdm
-
-from sacrebleu import corpus_bleu
-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_translations(lns, output_file_path, batch_size, device):
-    output_file = Path(output_file_path).open("w")
-
-    model = T5ForConditionalGeneration.from_pretrained("t5-base")
-    model.to(device)
-
-    tokenizer = T5Tokenizer.from_pretrained("t5-base")
-
-    # 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("translation_en_to_de", {}))
-
-    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)
-
-        translations = 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 translations]
-
-        for hypothesis in dec:
-            output_file.write(hypothesis + "\n")
-            output_file.flush()
-
-
-def calculate_bleu_score(output_lns, refs_lns, score_path):
-    bleu = corpus_bleu(output_lns, [refs_lns])
-    result = "BLEU score: {}".format(bleu.score)
-    score_file = Path(score_path).open("w")
-    score_file.write(result)
-
-
-def run_generate():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "input_path", type=str, help="like wmt/newstest2013.en",
-    )
-    parser.add_argument(
-        "output_path", type=str, help="where to save translation",
-    )
-    parser.add_argument(
-        "reference_path", type=str, help="like wmt/newstest2013.de",
-    )
-    parser.add_argument(
-        "score_path", type=str, help="where to save the bleu score",
-    )
-    parser.add_argument(
-        "--batch_size", type=int, default=16, 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")
-
-    dash_pattern = (" ##AT##-##AT## ", "-")
-
-    input_lns = [x.strip().replace(dash_pattern[0], dash_pattern[1]) for x in open(args.input_path).readlines()]
-
-    generate_translations(input_lns, args.output_path, args.batch_size, args.device)
-
-    output_lns = [x.strip() for x in open(args.output_path).readlines()]
-    refs_lns = [x.strip().replace(dash_pattern[0], dash_pattern[1]) for x in open(args.reference_path).readlines()]
-
-    calculate_bleu_score(output_lns, refs_lns, args.score_path)
-
-
-if __name__ == "__main__":
-    run_generate()

examples/translation/t5/test_t5_examples.py

@@ -1,28 +0,0 @@
-import logging
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from .evaluate_wmt import run_generate
-
-
-text = [" 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.hypo"
-        with tmp.open("w") as f:
-            f.write("\n".join(text))
-        testargs = ["evaluate_cnn.py", str(tmp), "output.txt", str(tmp), "score.txt"]
-        with patch.object(sys, "argv", testargs):
-            run_generate()
-            self.assertTrue(Path("output.txt").exists())

examples/utils_multiple_choice.py

@@ -320,9 +320,7 @@ def convert_examples_to_features(
             else:
                 text_b = example.question + " " + ending
 
-            inputs = tokenizer.encode_plus(
-                text_a, text_b, add_special_tokens=True, max_length=max_length, return_token_type_ids=True
-            )
+            inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)
             if "num_truncated_tokens" in inputs and inputs["num_truncated_tokens"] > 0:
                 logger.info(
                     "Attention! you are cropping tokens (swag task is ok). "

model_cards/TurkuNLP/bert-base-finnish-cased-v1/README.md

@@ -1,84 +0,0 @@
----
-language: finnish
----
-
-## Quickstart
-
-**Release 1.0** (November 25, 2019)
-
-Download the models here:
-
-* Cased Finnish BERT Base: [bert-base-finnish-cased-v1.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-cased-v1.zip)
-* Uncased Finnish BERT Base: [bert-base-finnish-uncased-v1.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-uncased-v1.zip)
-
-We generally recommend the use of the cased model.
-
-Paper presenting Finnish BERT: [arXiv:1912.07076](https://arxiv.org/abs/1912.07076)
-
-## What's this?
-
-A version of Google's [BERT](https://github.com/google-research/bert) deep transfer learning model for Finnish. The model can be fine-tuned to achieve state-of-the-art results for various Finnish natural language processing tasks.
-
-FinBERT features a custom 50,000 wordpiece vocabulary that has much better coverage of Finnish words than e.g. the previously released [multilingual BERT](https://github.com/google-research/bert/blob/master/multilingual.md) models from Google:
-
-| Vocabulary | Example |
-|------------|---------|
-| FinBERT    | Suomessa vaihtuu kesän aikana sekä pääministeri että valtiovarain ##ministeri . |
-| Multilingual BERT | Suomessa vai ##htuu kes ##än aikana sekä p ##ää ##minister ##i että valt ##io ##vara ##in ##minister ##i . |
-
-FinBERT has been pre-trained for 1 million steps on over 3 billion tokens (24B characters) of Finnish text drawn from news, online discussion, and internet crawls. By contrast, Multilingual BERT was trained on Wikipedia texts, where the Finnish Wikipedia text is approximately 3% of the amount used to train FinBERT.
-
-These features allow FinBERT to outperform not only Multilingual BERT but also all previously proposed models when fine-tuned for Finnish natural language processing tasks.
-
-## Results
-
-### Document classification
-
-![learning curves for Yle and Ylilauta document classification](https://raw.githubusercontent.com/TurkuNLP/FinBERT/master/img/yle-ylilauta-curves.png)
-
-FinBERT outperforms multilingual BERT (M-BERT) on document classification over a range of training set sizes on the Yle news (left) and Ylilauta online discussion (right) corpora. (Baseline classification performance with [FastText](https://fasttext.cc/) included for reference.)
-
-[[code](https://github.com/spyysalo/finbert-text-classification)][[Yle data](https://github.com/spyysalo/yle-corpus)] [[Ylilauta data](https://github.com/spyysalo/ylilauta-corpus)]
-
-### Named Entity Recognition
-
-Evaluation on FiNER corpus ([Ruokolainen et al 2019](https://arxiv.org/abs/1908.04212))
-
-| Model          | Accuracy |
-|--------------------|----------|
-| **FinBERT**  | **92.40%** |
-| Multilingual BERT | 90.29% |
-| [FiNER-tagger](https://github.com/Traubert/FiNer-rules) (rule-based) | 86.82%      |
-
-(FiNER tagger results from [Ruokolainen et al. 2019](https://arxiv.org/pdf/1908.04212.pdf))
-
-[[code](https://github.com/jouniluoma/keras-bert-ner)][[data](https://github.com/mpsilfve/finer-data)]
-
-### Part of speech tagging
-
-Evaluation on three Finnish corpora annotated with [Universal Dependencies](https://universaldependencies.org/) part-of-speech tags: the Turku Dependency Treebank (TDT), FinnTreeBank (FTB), and Parallel UD treebank (PUD)
-
-| Model             |     TDT     |     FTB     |     PUD     |
-|-------------------|-------------|-------------|-------------|
-| **FinBERT**       | **98.23%**  | **98.39%**  | **98.08%**  |
-| Multilingual BERT |   96.97%    |   95.87%    |   97.58%    |
-
-[[code](https://github.com/spyysalo/bert-pos)][[data](http://hdl.handle.net/11234/1-2837)]
-
-## Use with PyTorch
-
-If you want to use the model with the huggingface/transformers library, follow the steps in [huggingface_transformers.md](https://github.com/TurkuNLP/FinBERT/blob/master/huggingface_transformers.md)
-
-## Previous releases
-
-### Release 0.2
-
-**October 24, 2019** Beta version of the BERT base uncased model trained from scratch on a corpus of Finnish news, online discussions, and crawled data. 
-
-Download the model here: [bert-base-finnish-uncased.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-uncased.zip)
-
-### Release 0.1
-
-**September 30, 2019** We release a beta version of the BERT base cased model trained from scratch on a corpus of Finnish news, online discussions, and crawled data. 
-
-Download the model here: [bert-base-finnish-cased.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-cased.zip)

model_cards/TurkuNLP/bert-base-finnish-uncased-v1/README.md

@@ -1,84 +0,0 @@
----
-language: finnish
----
-
-## Quickstart
-
-**Release 1.0** (November 25, 2019)
-
-Download the models here:
-
-* Cased Finnish BERT Base: [bert-base-finnish-cased-v1.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-cased-v1.zip)
-* Uncased Finnish BERT Base: [bert-base-finnish-uncased-v1.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-uncased-v1.zip)
-
-We generally recommend the use of the cased model.
-
-Paper presenting Finnish BERT: [arXiv:1912.07076](https://arxiv.org/abs/1912.07076)
-
-## What's this?
-
-A version of Google's [BERT](https://github.com/google-research/bert) deep transfer learning model for Finnish. The model can be fine-tuned to achieve state-of-the-art results for various Finnish natural language processing tasks.
-
-FinBERT features a custom 50,000 wordpiece vocabulary that has much better coverage of Finnish words than e.g. the previously released [multilingual BERT](https://github.com/google-research/bert/blob/master/multilingual.md) models from Google:
-
-| Vocabulary | Example |
-|------------|---------|
-| FinBERT    | Suomessa vaihtuu kesän aikana sekä pääministeri että valtiovarain ##ministeri . |
-| Multilingual BERT | Suomessa vai ##htuu kes ##än aikana sekä p ##ää ##minister ##i että valt ##io ##vara ##in ##minister ##i . |
-
-FinBERT has been pre-trained for 1 million steps on over 3 billion tokens (24B characters) of Finnish text drawn from news, online discussion, and internet crawls. By contrast, Multilingual BERT was trained on Wikipedia texts, where the Finnish Wikipedia text is approximately 3% of the amount used to train FinBERT.
-
-These features allow FinBERT to outperform not only Multilingual BERT but also all previously proposed models when fine-tuned for Finnish natural language processing tasks.
-
-## Results
-
-### Document classification
-
-![learning curves for Yle and Ylilauta document classification](https://raw.githubusercontent.com/TurkuNLP/FinBERT/master/img/yle-ylilauta-curves.png)
-
-FinBERT outperforms multilingual BERT (M-BERT) on document classification over a range of training set sizes on the Yle news (left) and Ylilauta online discussion (right) corpora. (Baseline classification performance with [FastText](https://fasttext.cc/) included for reference.)
-
-[[code](https://github.com/spyysalo/finbert-text-classification)][[Yle data](https://github.com/spyysalo/yle-corpus)] [[Ylilauta data](https://github.com/spyysalo/ylilauta-corpus)]
-
-### Named Entity Recognition
-
-Evaluation on FiNER corpus ([Ruokolainen et al 2019](https://arxiv.org/abs/1908.04212))
-
-| Model          | Accuracy |
-|--------------------|----------|
-| **FinBERT**  | **92.40%** |
-| Multilingual BERT | 90.29% |
-| [FiNER-tagger](https://github.com/Traubert/FiNer-rules) (rule-based) | 86.82%      |
-
-(FiNER tagger results from [Ruokolainen et al. 2019](https://arxiv.org/pdf/1908.04212.pdf))
-
-[[code](https://github.com/jouniluoma/keras-bert-ner)][[data](https://github.com/mpsilfve/finer-data)]
-
-### Part of speech tagging
-
-Evaluation on three Finnish corpora annotated with [Universal Dependencies](https://universaldependencies.org/) part-of-speech tags: the Turku Dependency Treebank (TDT), FinnTreeBank (FTB), and Parallel UD treebank (PUD)
-
-| Model             |     TDT     |     FTB     |     PUD     |
-|-------------------|-------------|-------------|-------------|
-| **FinBERT**       | **98.23%**  | **98.39%**  | **98.08%**  |
-| Multilingual BERT |   96.97%    |   95.87%    |   97.58%    |
-
-[[code](https://github.com/spyysalo/bert-pos)][[data](http://hdl.handle.net/11234/1-2837)]
-
-## Use with PyTorch
-
-If you want to use the model with the huggingface/transformers library, follow the steps in [huggingface_transformers.md](https://github.com/TurkuNLP/FinBERT/blob/master/huggingface_transformers.md)
-
-## Previous releases
-
-### Release 0.2
-
-**October 24, 2019** Beta version of the BERT base uncased model trained from scratch on a corpus of Finnish news, online discussions, and crawled data. 
-
-Download the model here: [bert-base-finnish-uncased.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-uncased.zip)
-
-### Release 0.1
-
-**September 30, 2019** We release a beta version of the BERT base cased model trained from scratch on a corpus of Finnish news, online discussions, and crawled data. 
-
-Download the model here: [bert-base-finnish-cased.zip](http://dl.turkunlp.org/finbert/bert-base-finnish-cased.zip)

model_cards/allenai/scibert_scivocab_cased/README.md

@@ -1,26 +0,0 @@
-# SciBERT
-
-This is the pretrained model presented in [SciBERT: A Pretrained Language Model for Scientific Text](https://www.aclweb.org/anthology/D19-1371/), which is a BERT model trained on scientific text.
-
-The training corpus was papers taken from [Semantic Scholar](https://www.semanticscholar.org). Corpus size is 1.14M papers, 3.1B tokens. We use the full text of the papers in training, not just abstracts.
-
-SciBERT has its own wordpiece vocabulary (scivocab) that's built to best match the training corpus. We trained cased and uncased versions. 
-
-Available models include:
-* `scibert_scivocab_cased`
-* `scibert_scivocab_uncased`
-
-
-The original repo can be found [here](https://github.com/allenai/scibert).
-
-If using these models, please cite the following paper:
-```
-@inproceedings{beltagy-etal-2019-scibert,
-    title = "SciBERT: A Pretrained Language Model for Scientific Text",
-    author = "Beltagy, Iz  and Lo, Kyle  and Cohan, Arman",
-    booktitle = "EMNLP",
-    year = "2019",
-    publisher = "Association for Computational Linguistics",
-    url = "https://www.aclweb.org/anthology/D19-1371"
-}
-```

model_cards/allenai/scibert_scivocab_uncased/README.md

@@ -1,26 +0,0 @@
-# SciBERT
-
-This is the pretrained model presented in [SciBERT: A Pretrained Language Model for Scientific Text](https://www.aclweb.org/anthology/D19-1371/), which is a BERT model trained on scientific text.
-
-The training corpus was papers taken from [Semantic Scholar](https://www.semanticscholar.org). Corpus size is 1.14M papers, 3.1B tokens. We use the full text of the papers in training, not just abstracts.
-
-SciBERT has its own wordpiece vocabulary (scivocab) that's built to best match the training corpus. We trained cased and uncased versions. 
-
-Available models include:
-* `scibert_scivocab_cased`
-* `scibert_scivocab_uncased`
-
-
-The original repo can be found [here](https://github.com/allenai/scibert).
-
-If using these models, please cite the following paper:
-```
-@inproceedings{beltagy-etal-2019-scibert,
-    title = "SciBERT: A Pretrained Language Model for Scientific Text",
-    author = "Beltagy, Iz  and Lo, Kyle  and Cohan, Arman",
-    booktitle = "EMNLP",
-    year = "2019",
-    publisher = "Association for Computational Linguistics",
-    url = "https://www.aclweb.org/anthology/D19-1371"
-}
-```

model_cards/camembert-base-README.md

@@ -1,9 +0,0 @@
-# CamemBERT 
-
-CamemBERT is a state-of-the-art language model for French based on the RoBERTa architecture pretrained on the French subcorpus of the newly available multilingual corpus OSCAR.  
-
-CamemBERT was originally evaluated on four different downstream tasks for French: part-of-speech (POS) tagging, dependency parsing, named entity recognition (NER) and natural language inference (NLI); improving the state of the art for most tasks over previous monolingual and multilingual approaches, which confirms the effectiveness of large pretrained language models for French.   
-
-CamemBERT was trained and evaluated 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.  
-
-Preprint can be found [CamemBERT: a Tasty French Language Model](https://arxiv.org/abs/1911.03894)  

model_cards/clue/albert_chinese_small/README.md

@@ -1,31 +0,0 @@
-## albert_chinese_small
-
-### Overview
-
-**Language model:** albert-small
-**Model size:** 18.5M
-**Language:** Chinese
-**Training data:** [CLUECorpusSmall](https://github.com/CLUEbenchmark/CLUECorpus2020)
-**Eval data:** [CLUE dataset](https://github.com/CLUEbenchmark/CLUE)
-
-### Results
-
-For results on downstream tasks like text classification, please refer to [this repository](https://github.com/CLUEbenchmark/CLUE).
-
-### Usage
-
-**NOTE:**Since sentencepiece is not used in `albert_chinese_small` model, you have to call **BertTokenizer** instead of AlbertTokenizer !!!
-
-```
-import torch
-from transformers import BertTokenizer, AlbertModel
-tokenizer = BertTokenizer.from_pretrained("clue/albert_chinese_small")
-albert = AlbertModel.from_pretrained("clue/albert_chinese_small")
-```
-
-### About CLUE benchmark
-
-Organization of Language Understanding Evaluation benchmark for Chinese: tasks & datasets, baselines, pre-trained Chinese models, corpus and leaderboard.
-
-Github: https://github.com/CLUEbenchmark
-Website: https://www.cluebenchmarks.com/

model_cards/clue/albert_chinese_tiny/README.md

@@ -1,31 +0,0 @@
-## albert_chinese_tiny
-
-### Overview
-
-**Language model:** albert-tiny
-**Model size:** 16M
-**Language:** Chinese
-**Training data:** [CLUECorpusSmall](https://github.com/CLUEbenchmark/CLUECorpus2020)
-**Eval data:** [CLUE dataset](https://github.com/CLUEbenchmark/CLUE)
-
-### Results
-
-For results on downstream tasks like text classification, please refer to [this repository](https://github.com/CLUEbenchmark/CLUE).
-
-### Usage
-
-**NOTE:**Since sentencepiece is not used in `albert_chinese_tiny` model, you have to call **BertTokenizer** instead of AlbertTokenizer !!!
-
-```
-import torch
-from transformers import BertTokenizer, AlbertModel
-tokenizer = BertTokenizer.from_pretrained("clue/albert_chinese_tiny")
-albert = AlbertModel.from_pretrained("clue/albert_chinese_tiny")
-```
-
-### About CLUE benchmark
-
-Organization of Language Understanding Evaluation benchmark for Chinese: tasks & datasets, baselines, pre-trained Chinese models, corpus and leaderboard.
-
-Github: https://github.com/CLUEbenchmark
-Website: https://www.cluebenchmarks.com/

model_cards/clue/roberta_chinese_3L312_clue_tiny/README.md

@@ -1,39 +0,0 @@
-# Introduction
-This model was trained on TPU and the details are as follows:
-
-## Model 
-## 
-
-| Model_name                                    | params | size | Training_corpus               |    Vocab |    
-| :------------------------------------------ | :----- | :------- | :----------------- | :-----------: | 
-| **`RoBERTa-tiny-clue`** <br/>Super_small_model       | 7.5M   | 28.3M    | **CLUECorpus2020** | **CLUEVocab** |
-| **`RoBERTa-tiny-pair`** <br/>Super_small_sentence_pair_model | 7.5M   | 28.3M    | **CLUECorpus2020** | **CLUEVocab** | 
-| **`RoBERTa-tiny3L768-clue`** <br/>small_model    | 38M    | 110M     | **CLUECorpus2020** | **CLUEVocab** | 
-| **`RoBERTa-tiny3L312-clue`** <br/>small_model    | <7.5M  | 24M      | **CLUECorpus2020** | **CLUEVocab** | 
-| **`RoBERTa-large-clue`** <br/> Large_model       | 290M   | 1.20G    | **CLUECorpus2020** | **CLUEVocab** | 
-| **`RoBERTa-large-pair`** <br/>Large_sentence_pair_model  | 290M   | 1.20G    | **CLUECorpus2020** | **CLUEVocab** | 
-
-### Usage
-
-With the help of[Huggingface-Transformers 2.5.1](https://github.com/huggingface/transformers), you could use these model as follows
-
-```
-tokenizer = BertTokenizer.from_pretrained("MODEL_NAME")
-model = BertModel.from_pretrained("MODEL_NAME")
-```
-
-`MODEL_NAME`：
-
-| Model_NAME                 | MODEL_LINK                                                   |
-| -------------------------- | ------------------------------------------------------------ |
-| **RoBERTa-tiny-clue**      | [`clue/roberta_chinese_clue_tiny`](https://huggingface.co/clue/roberta_chinese_clue_tiny) |
-| **RoBERTa-tiny-pair**      | [`clue/roberta_chinese_pair_tiny`](https://huggingface.co/clue/roberta_chinese_pair_tiny) |
-| **RoBERTa-tiny3L768-clue** | [`clue/roberta_chinese_3L768_clue_tiny`](https://huggingface.co/clue/roberta_chinese_3L768_clue_tiny) |
-| **RoBERTa-tiny3L312-clue** | [`clue/roberta_chinese_3L312_clue_tiny`](https://huggingface.co/clue/roberta_chinese_3L312_clue_tiny) |
-| **RoBERTa-large-clue**     | [`clue/roberta_chinese_clue_large`](https://huggingface.co/clue/roberta_chinese_clue_large) |
-| **RoBERTa-large-pair**     | [`clue/roberta_chinese_pair_large`](https://huggingface.co/clue/roberta_chinese_pair_large) |
-
-## Details
-Please read <a href='https://arxiv.org/pdf/2003.01355'>https://arxiv.org/pdf/2003.01355.
-
-Please visit our repository: https://github.com/CLUEbenchmark/CLUEPretrainedModels.git

model_cards/clue/roberta_chinese_base/README.md

@@ -1,31 +0,0 @@
-## roberta_chinese_base
-
-### Overview
-
-**Language model:** roberta-base
-**Model size:** 392M
-**Language:** Chinese
-**Training data:** [CLUECorpusSmall](https://github.com/CLUEbenchmark/CLUECorpus2020)
-**Eval data:** [CLUE dataset](https://github.com/CLUEbenchmark/CLUE)
-
-### Results
-
-For results on downstream tasks like text classification, please refer to [this repository](https://github.com/CLUEbenchmark/CLUE).
-
-### Usage
-
-**NOTE:** You have to call **BertTokenizer** instead of RobertaTokenizer !!!
-
-```
-import torch
-from transformers import BertTokenizer, BertModel
-tokenizer = BertTokenizer.from_pretrained("clue/roberta_chinese_base")
-roberta = BertModel.from_pretrained("clue/roberta_chinese_base")
-```
-
-### About CLUE benchmark
-
-Organization of Language Understanding Evaluation benchmark for Chinese: tasks & datasets, baselines, pre-trained Chinese models, corpus and leaderboard.
-
-Github: https://github.com/CLUEbenchmark
-Website: https://www.cluebenchmarks.com/

model_cards/dbmdz/bert-base-turkish-128k-cased/README.md

@@ -1,76 +0,0 @@
----
-language: turkish
----
-
-# 🤗 + 📚 dbmdz Turkish BERT model
-
-In this repository the MDZ Digital Library team (dbmdz) at the Bavarian State
-Library open sources a cased model for Turkish 🎉
-
-# 🇹🇷 BERTurk
-
-BERTurk is a community-driven cased BERT model for Turkish.
-
-Some datasets used for pretraining and evaluation are contributed from the
-awesome Turkish NLP community, as well as the decision for the model name: BERTurk.
-
-## Stats
-
-The current version of the model is trained on a filtered and sentence
-segmented version of the Turkish [OSCAR corpus](https://traces1.inria.fr/oscar/),
-a recent Wikipedia dump, various [OPUS corpora](http://opus.nlpl.eu/) and a
-special corpus provided by [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/).
-
-The final training corpus has a size of 35GB and 44,04,976,662 tokens.
-
-Thanks to Google's TensorFlow Research Cloud (TFRC) we could train a cased model
-on a TPU v3-8 for 2M steps.
-
-For this model we use a vocab size of 128k.
-
-## Model weights
-
-Currently only PyTorch-[Transformers](https://github.com/huggingface/transformers)
-compatible weights are available. If you need access to TensorFlow checkpoints,
-please raise an issue!
-
-| Model                                | Downloads
-| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------
-| `dbmdz/bert-base-turkish-128k-cased` | [`config.json`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-cased/config.json) • [`pytorch_model.bin`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-cased/pytorch_model.bin) • [`vocab.txt`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-cased/vocab.txt)
-
-## Usage
-
-With Transformers >= 2.3 our BERTurk cased model can be loaded like:
-
-```python
-from transformers import AutoModel, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-128k-cased")
-model = AutoModel.from_pretrained("dbmdz/bert-base-turkish-128k-cased")
-```
-
-## Results
-
-For results on PoS tagging or NER tasks, please refer to
-[this repository](https://github.com/stefan-it/turkish-bert).
-
-# Huggingface model hub
-
-All models are available on the [Huggingface model hub](https://huggingface.co/dbmdz).
-
-# Contact (Bugs, Feedback, Contribution and more)
-
-For questions about our BERT models just open an issue
-[here](https://github.com/dbmdz/berts/issues/new) 🤗
-
-# Acknowledgments
-
-Thanks to [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/) for providing us
-additional large corpora for Turkish. Many thanks to Reyyan Yeniterzi for providing
-us the Turkish NER dataset for evaluation.
-
-Research supported with Cloud TPUs from Google's TensorFlow Research Cloud (TFRC).
-Thanks for providing access to the TFRC ❤️
-
-Thanks to the generous support from the [Hugging Face](https://huggingface.co/) team,
-it is possible to download both cased and uncased models from their S3 storage 🤗

model_cards/dbmdz/bert-base-turkish-128k-uncased/README.md

@@ -1,76 +0,0 @@
----
-language: turkish
----
-
-# 🤗 + 📚 dbmdz Turkish BERT model
-
-In this repository the MDZ Digital Library team (dbmdz) at the Bavarian State
-Library open sources an uncased model for Turkish 🎉
-
-# 🇹🇷 BERTurk
-
-BERTurk is a community-driven uncased BERT model for Turkish.
-
-Some datasets used for pretraining and evaluation are contributed from the
-awesome Turkish NLP community, as well as the decision for the model name: BERTurk.
-
-## Stats
-
-The current version of the model is trained on a filtered and sentence
-segmented version of the Turkish [OSCAR corpus](https://traces1.inria.fr/oscar/),
-a recent Wikipedia dump, various [OPUS corpora](http://opus.nlpl.eu/) and a
-special corpus provided by [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/).
-
-The final training corpus has a size of 35GB and 44,04,976,662 tokens.
-
-Thanks to Google's TensorFlow Research Cloud (TFRC) we could train an uncased model
-on a TPU v3-8 for 2M steps.
-
-For this model we use a vocab size of 128k.
-
-## Model weights
-
-Currently only PyTorch-[Transformers](https://github.com/huggingface/transformers)
-compatible weights are available. If you need access to TensorFlow checkpoints,
-please raise an issue!
-
-| Model                                  | Downloads
-| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------
-| `dbmdz/bert-base-turkish-128k-uncased` | [`config.json`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-uncased/config.json) • [`pytorch_model.bin`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-uncased/pytorch_model.bin) • [`vocab.txt`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-128k-uncased/vocab.txt)
-
-## Usage
-
-With Transformers >= 2.3 our BERTurk uncased model can be loaded like:
-
-```python
-from transformers import AutoModel, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-128k-uncased")
-model = AutoModel.from_pretrained("dbmdz/bert-base-turkish-128k-uncased")
-```
-
-## Results
-
-For results on PoS tagging or NER tasks, please refer to
-[this repository](https://github.com/stefan-it/turkish-bert).
-
-# Huggingface model hub
-
-All models are available on the [Huggingface model hub](https://huggingface.co/dbmdz).
-
-# Contact (Bugs, Feedback, Contribution and more)
-
-For questions about our BERT models just open an issue
-[here](https://github.com/dbmdz/berts/issues/new) 🤗
-
-# Acknowledgments
-
-Thanks to [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/) for providing us
-additional large corpora for Turkish. Many thanks to Reyyan Yeniterzi for providing
-us the Turkish NER dataset for evaluation.
-
-Research supported with Cloud TPUs from Google's TensorFlow Research Cloud (TFRC).
-Thanks for providing access to the TFRC ❤️
-
-Thanks to the generous support from the [Hugging Face](https://huggingface.co/) team,
-it is possible to download both cased and uncased models from their S3 storage 🤗

model_cards/dbmdz/bert-base-turkish-uncased/README.md

@@ -1,74 +0,0 @@
----
-language: turkish
----
-
-# 🤗 + 📚 dbmdz Turkish BERT model
-
-In this repository the MDZ Digital Library team (dbmdz) at the Bavarian State
-Library open sources an uncased model for Turkish 🎉
-
-# 🇹🇷 BERTurk
-
-BERTurk is a community-driven uncased BERT model for Turkish.
-
-Some datasets used for pretraining and evaluation are contributed from the
-awesome Turkish NLP community, as well as the decision for the model name: BERTurk.
-
-## Stats
-
-The current version of the model is trained on a filtered and sentence
-segmented version of the Turkish [OSCAR corpus](https://traces1.inria.fr/oscar/),
-a recent Wikipedia dump, various [OPUS corpora](http://opus.nlpl.eu/) and a
-special corpus provided by [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/).
-
-The final training corpus has a size of 35GB and 44,04,976,662 tokens.
-
-Thanks to Google's TensorFlow Research Cloud (TFRC) we could train an uncased model
-on a TPU v3-8 for 2M steps.
-
-## Model weights
-
-Currently only PyTorch-[Transformers](https://github.com/huggingface/transformers)
-compatible weights are available. If you need access to TensorFlow checkpoints,
-please raise an issue!
-
-| Model                             | Downloads
-| --------------------------------- | ---------------------------------------------------------------------------------------------------------------
-| `dbmdz/bert-base-turkish-uncased`   | [`config.json`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-uncased/config.json) • [`pytorch_model.bin`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-uncased/pytorch_model.bin) • [`vocab.txt`](https://cdn.huggingface.co/dbmdz/bert-base-turkish-uncased/vocab.txt)
-
-## Usage
-
-With Transformers >= 2.3 our BERTurk uncased model can be loaded like:
-
-```python
-from transformers import AutoModel, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-uncased")
-model = AutoModel.from_pretrained("dbmdz/bert-base-turkish-uncased")
-```
-
-## Results
-
-For results on PoS tagging or NER tasks, please refer to
-[this repository](https://github.com/stefan-it/turkish-bert).
-
-# Huggingface model hub
-
-All models are available on the [Huggingface model hub](https://huggingface.co/dbmdz).
-
-# Contact (Bugs, Feedback, Contribution and more)
-
-For questions about our BERT models just open an issue
-[here](https://github.com/dbmdz/berts/issues/new) 🤗
-
-# Acknowledgments
-
-Thanks to [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/) for providing us
-additional large corpora for Turkish. Many thanks to Reyyan Yeniterzi for providing
-us the Turkish NER dataset for evaluation.
-
-Research supported with Cloud TPUs from Google's TensorFlow Research Cloud (TFRC).
-Thanks for providing access to the TFRC ❤️
-
-Thanks to the generous support from the [Hugging Face](https://huggingface.co/) team,
-it is possible to download both cased and uncased models from their S3 storage 🤗

model_cards/deepset/sentence_bert/README.md

@@ -1 +0,0 @@
-This is an upload of the bert-base-nli-stsb-mean-tokens pretrained model from the Sentence Transformers Repo (https://github.com/UKPLab/sentence-transformers)

model_cards/elgeish/cs224n-squad2.0-albert-base-v2/README.md

@@ -1,74 +0,0 @@
-## CS224n SQuAD2.0 Project Dataset
-The goal of this model is to save CS224n students GPU time when establising
-baselines to beat for the [Default Final Project](http://web.stanford.edu/class/cs224n/project/default-final-project-handout.pdf).
-The training set used to fine-tune this model is the same as
-the [official one](https://rajpurkar.github.io/SQuAD-explorer/); however,
-evaluation and model selection were performed using roughly half of the official
-dev set, 6078 examples, picked at random. The data files can be found at
-<https://github.com/elgeish/squad/tree/master/data> — this is the Winter 2020
-version. Given that the official SQuAD2.0 dev set contains the project's test
-set, students must make sure not to use the official SQuAD2.0 dev set in any way
-— including the use of models fine-tuned on the official SQuAD2.0, since they
-used the official SQuAD2.0 dev set for model selection.
-
-## Results
-```json
-{
-  "exact": 78.94044093451794,
-  "f1": 81.7724930324639,
-  "total": 6078,
-  "HasAns_exact": 76.28865979381443,
-  "HasAns_f1": 82.20385314478195,
-  "HasAns_total": 2910,
-  "NoAns_exact": 81.37626262626263,
-  "NoAns_f1": 81.37626262626263,
-  "NoAns_total": 3168,
-  "best_exact": 78.95689371503784,
-  "best_exact_thresh": 0.0,
-  "best_f1": 81.78894581298378,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Notable Arguments
-```json
-{
-  "do_lower_case": true,
-  "doc_stride": 128,
-  "fp16": false,
-  "fp16_opt_level": "O1",
-  "gradient_accumulation_steps": 24,
-  "learning_rate": 3e-05,
-  "max_answer_length": 30,
-  "max_grad_norm": 1,
-  "max_query_length": 64,
-  "max_seq_length": 384,
-  "model_name_or_path": "albert-base-v2",
-  "model_type": "albert",
-  "num_train_epochs": 3,
-  "per_gpu_train_batch_size": 8,
-  "save_steps": 5000,
-  "seed": 42,
-  "train_batch_size": 8,
-  "version_2_with_negative": true,
-  "warmup_steps": 0,
-  "weight_decay": 0
-}
-```
-
-## Environment Setup
-```json
-{
-  "transformers": "2.5.1",
-  "pytorch": "1.4.0=py3.6_cuda10.1.243_cudnn7.6.3_0",
-  "python": "3.6.5=hc3d631a_2",
-  "os": "Linux 4.15.0-1060-aws #62-Ubuntu SMP Tue Feb 11 21:23:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux",
-  "gpu": "Tesla V100-SXM2-16GB"
-}
-```
-
-## Related Models
-* [elgeish/cs224n-squad2.0-albert-large-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-large-v2)
-* [elgeish/cs224n-squad2.0-albert-xxlarge-v1](https://huggingface.co/elgeish/cs224n-squad2.0-albert-xxlarge-v1)
-* [elgeish/cs224n-squad2.0-distilbert-base-uncased](https://huggingface.co/elgeish/cs224n-squad2.0-distilbert-base-uncased)
-* [elgeish/cs224n-squad2.0-roberta-base](https://huggingface.co/elgeish/cs224n-squad2.0-roberta-base)

model_cards/elgeish/cs224n-squad2.0-albert-large-v2/README.md

@@ -1,74 +0,0 @@
-## CS224n SQuAD2.0 Project Dataset
-The goal of this model is to save CS224n students GPU time when establising
-baselines to beat for the [Default Final Project](http://web.stanford.edu/class/cs224n/project/default-final-project-handout.pdf).
-The training set used to fine-tune this model is the same as
-the [official one](https://rajpurkar.github.io/SQuAD-explorer/); however,
-evaluation and model selection were performed using roughly half of the official
-dev set, 6078 examples, picked at random. The data files can be found at
-<https://github.com/elgeish/squad/tree/master/data> — this is the Winter 2020
-version. Given that the official SQuAD2.0 dev set contains the project's test
-set, students must make sure not to use the official SQuAD2.0 dev set in any way
-— including the use of models fine-tuned on the official SQuAD2.0, since they
-used the official SQuAD2.0 dev set for model selection.
-
-## Results
-```json
-{
-  "exact": 79.2694965449161,
-  "f1": 82.50844352970152,
-  "total": 6078,
-  "HasAns_exact": 74.87972508591065,
-  "HasAns_f1": 81.64478342732858,
-  "HasAns_total": 2910,
-  "NoAns_exact": 83.30176767676768,
-  "NoAns_f1": 83.30176767676768,
-  "NoAns_total": 3168,
-  "best_exact": 79.2694965449161,
-  "best_exact_thresh": 0.0,
-  "best_f1": 82.50844352970155,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Notable Arguments
-```json
-{
-  "do_lower_case": true,
-  "doc_stride": 128,
-  "fp16": false,
-  "fp16_opt_level": "O1",
-  "gradient_accumulation_steps": 1,
-  "learning_rate": 3e-05,
-  "max_answer_length": 30,
-  "max_grad_norm": 1,
-  "max_query_length": 64,
-  "max_seq_length": 384,
-  "model_name_or_path": "albert-large-v2",
-  "model_type": "albert",
-  "num_train_epochs": 5,
-  "per_gpu_train_batch_size": 8,
-  "save_steps": 5000,
-  "seed": 42,
-  "train_batch_size": 8,
-  "version_2_with_negative": true,
-  "warmup_steps": 0,
-  "weight_decay": 0
-}
-```
-
-## Environment Setup
-```json
-{
-  "transformers": "2.5.1",
-  "pytorch": "1.4.0=py3.6_cuda10.1.243_cudnn7.6.3_0",
-  "python": "3.6.5=hc3d631a_2",
-  "os": "Linux 4.15.0-1060-aws #62-Ubuntu SMP Tue Feb 11 21:23:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux",
-  "gpu": "Tesla V100-SXM2-16GB"
-}
-```
-
-## Related Models
-* [elgeish/cs224n-squad2.0-albert-base-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-base-v2)
-* [elgeish/cs224n-squad2.0-albert-xxlarge-v1](https://huggingface.co/elgeish/cs224n-squad2.0-albert-xxlarge-v1)
-* [elgeish/cs224n-squad2.0-distilbert-base-uncased](https://huggingface.co/elgeish/cs224n-squad2.0-distilbert-base-uncased)
-* [elgeish/cs224n-squad2.0-roberta-base](https://huggingface.co/elgeish/cs224n-squad2.0-roberta-base)

model_cards/elgeish/cs224n-squad2.0-albert-xxlarge-v1/README.md

@@ -1,74 +0,0 @@
-## CS224n SQuAD2.0 Project Dataset
-The goal of this model is to save CS224n students GPU time when establising
-baselines to beat for the [Default Final Project](http://web.stanford.edu/class/cs224n/project/default-final-project-handout.pdf).
-The training set used to fine-tune this model is the same as
-the [official one](https://rajpurkar.github.io/SQuAD-explorer/); however,
-evaluation and model selection were performed using roughly half of the official
-dev set, 6078 examples, picked at random. The data files can be found at
-<https://github.com/elgeish/squad/tree/master/data> — this is the Winter 2020
-version. Given that the official SQuAD2.0 dev set contains the project's test
-set, students must make sure not to use the official SQuAD2.0 dev set in any way
-— including the use of models fine-tuned on the official SQuAD2.0, since they
-used the official SQuAD2.0 dev set for model selection.
-
-## Results
-```json
-{
-  "exact": 85.93287265547877,
-  "f1": 88.91258331187983,
-  "total": 6078,
-  "HasAns_exact": 84.36426116838489,
-  "HasAns_f1": 90.58786301361013,
-  "HasAns_total": 2910,
-  "NoAns_exact": 87.37373737373737,
-  "NoAns_f1": 87.37373737373737,
-  "NoAns_total": 3168,
-  "best_exact": 85.93287265547877,
-  "best_exact_thresh": 0.0,
-  "best_f1": 88.91258331187993,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Notable Arguments
-```json
-{
-  "do_lower_case": true,
-  "doc_stride": 128,
-  "fp16": false,
-  "fp16_opt_level": "O1",
-  "gradient_accumulation_steps": 24,
-  "learning_rate": 3e-05,
-  "max_answer_length": 30,
-  "max_grad_norm": 1,
-  "max_query_length": 64,
-  "max_seq_length": 512,
-  "model_name_or_path": "albert-xxlarge-v1",
-  "model_type": "albert",
-  "num_train_epochs": 4,
-  "per_gpu_train_batch_size": 1,
-  "save_steps": 1000,
-  "seed": 42,
-  "train_batch_size": 1,
-  "version_2_with_negative": true,
-  "warmup_steps": 814,
-  "weight_decay": 0
-}
-```
-
-## Environment Setup
-```json
-{
-  "transformers": "2.5.1",
-  "pytorch": "1.4.0=py3.6_cuda10.1.243_cudnn7.6.3_0",
-  "python": "3.6.5=hc3d631a_2",
-  "os": "Linux 4.15.0-1060-aws #62-Ubuntu SMP Tue Feb 11 21:23:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux",
-  "gpu": "Tesla V100-SXM2-16GB"
-}
-```
-
-## Related Models
-* [elgeish/cs224n-squad2.0-albert-base-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-base-v2)
-* [elgeish/cs224n-squad2.0-albert-large-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-large-v2)
-* [elgeish/cs224n-squad2.0-distilbert-base-uncased](https://huggingface.co/elgeish/cs224n-squad2.0-distilbert-base-uncased)
-* [elgeish/cs224n-squad2.0-roberta-base](https://huggingface.co/elgeish/cs224n-squad2.0-roberta-base)

model_cards/elgeish/cs224n-squad2.0-distilbert-base-uncased/README.md

@@ -1,74 +0,0 @@
-## CS224n SQuAD2.0 Project Dataset
-The goal of this model is to save CS224n students GPU time when establising
-baselines to beat for the [Default Final Project](http://web.stanford.edu/class/cs224n/project/default-final-project-handout.pdf).
-The training set used to fine-tune this model is the same as
-the [official one](https://rajpurkar.github.io/SQuAD-explorer/); however,
-evaluation and model selection were performed using roughly half of the official
-dev set, 6078 examples, picked at random. The data files can be found at
-<https://github.com/elgeish/squad/tree/master/data> — this is the Winter 2020
-version. Given that the official SQuAD2.0 dev set contains the project's test
-set, students must make sure not to use the official SQuAD2.0 dev set in any way
-— including the use of models fine-tuned on the official SQuAD2.0, since they
-used the official SQuAD2.0 dev set for model selection.
-
-## Results
-```json
-{
-  "exact": 65.16946363935504,
-  "f1": 67.87348075352251,
-  "total": 6078,
-  "HasAns_exact": 69.51890034364261,
-  "HasAns_f1": 75.16667217179045,
-  "HasAns_total": 2910,
-  "NoAns_exact": 61.17424242424242,
-  "NoAns_f1": 61.17424242424242,
-  "NoAns_total": 3168,
-  "best_exact": 65.16946363935504,
-  "best_exact_thresh": 0.0,
-  "best_f1": 67.87348075352243,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Notable Arguments
-```json
-{
-  "do_lower_case": true,
-  "doc_stride": 128,
-  "fp16": false,
-  "fp16_opt_level": "O1",
-  "gradient_accumulation_steps": 24,
-  "learning_rate": 3e-05,
-  "max_answer_length": 30,
-  "max_grad_norm": 1,
-  "max_query_length": 64,
-  "max_seq_length": 384,
-  "model_name_or_path": "distilbert-base-uncased-distilled-squad",
-  "model_type": "distilbert",
-  "num_train_epochs": 4,
-  "per_gpu_train_batch_size": 32,
-  "save_steps": 5000,
-  "seed": 42,
-  "train_batch_size": 32,
-  "version_2_with_negative": true,
-  "warmup_steps": 0,
-  "weight_decay": 0
-}
-```
-
-## Environment Setup
-```json
-{
-  "transformers": "2.5.1",
-  "pytorch": "1.4.0=py3.6_cuda10.1.243_cudnn7.6.3_0",
-  "python": "3.6.5=hc3d631a_2",
-  "os": "Linux 4.15.0-1060-aws #62-Ubuntu SMP Tue Feb 11 21:23:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux",
-  "gpu": "Tesla V100-SXM2-16GB"
-}
-```
-
-## Related Models
-* [elgeish/cs224n-squad2.0-albert-base-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-base-v2)
-* [elgeish/cs224n-squad2.0-albert-large-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-large-v2)
-* [elgeish/cs224n-squad2.0-albert-xxlarge-v1](https://huggingface.co/elgeish/cs224n-squad2.0-albert-xxlarge-v1)
-* [elgeish/cs224n-squad2.0-roberta-base](https://huggingface.co/elgeish/cs224n-squad2.0-roberta-base)

model_cards/elgeish/cs224n-squad2.0-roberta-base/README.md

@@ -1,74 +0,0 @@
-## CS224n SQuAD2.0 Project Dataset
-The goal of this model is to save CS224n students GPU time when establising
-baselines to beat for the [Default Final Project](http://web.stanford.edu/class/cs224n/project/default-final-project-handout.pdf).
-The training set used to fine-tune this model is the same as
-the [official one](https://rajpurkar.github.io/SQuAD-explorer/); however,
-evaluation and model selection were performed using roughly half of the official
-dev set, 6078 examples, picked at random. The data files can be found at
-<https://github.com/elgeish/squad/tree/master/data> — this is the Winter 2020
-version. Given that the official SQuAD2.0 dev set contains the project's test
-set, students must make sure not to use the official SQuAD2.0 dev set in any way
-— including the use of models fine-tuned on the official SQuAD2.0, since they
-used the official SQuAD2.0 dev set for model selection.
-
-## Results
-```json
-{
-  "exact": 75.32082922013821,
-  "f1": 78.66699523704254,
-  "total": 6078,
-  "HasAns_exact": 74.84536082474227,
-  "HasAns_f1": 81.83436324767868,
-  "HasAns_total": 2910,
-  "NoAns_exact": 75.75757575757575,
-  "NoAns_f1": 75.75757575757575,
-  "NoAns_total": 3168,
-  "best_exact": 75.32082922013821,
-  "best_exact_thresh": 0.0,
-  "best_f1": 78.66699523704266,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Notable Arguments
-```json
-{
-  "do_lower_case": true,
-  "doc_stride": 128,
-  "fp16": false,
-  "fp16_opt_level": "O1",
-  "gradient_accumulation_steps": 24,
-  "learning_rate": 3e-05,
-  "max_answer_length": 30,
-  "max_grad_norm": 1,
-  "max_query_length": 64,
-  "max_seq_length": 384,
-  "model_name_or_path": "roberta-base",
-  "model_type": "roberta",
-  "num_train_epochs": 4,
-  "per_gpu_train_batch_size": 16,
-  "save_steps": 5000,
-  "seed": 42,
-  "train_batch_size": 16,
-  "version_2_with_negative": true,
-  "warmup_steps": 0,
-  "weight_decay": 0
-}
-```
-
-## Environment Setup
-```json
-{
-  "transformers": "2.5.1",
-  "pytorch": "1.4.0=py3.6_cuda10.1.243_cudnn7.6.3_0",
-  "python": "3.6.5=hc3d631a_2",
-  "os": "Linux 4.15.0-1060-aws #62-Ubuntu SMP Tue Feb 11 21:23:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux",
-  "gpu": "Tesla V100-SXM2-16GB"
-}
-```
-
-## Related Models
-* [elgeish/cs224n-squad2.0-albert-base-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-base-v2)
-* [elgeish/cs224n-squad2.0-albert-large-v2](https://huggingface.co/elgeish/cs224n-squad2.0-albert-large-v2)
-* [elgeish/cs224n-squad2.0-albert-xxlarge-v1](https://huggingface.co/elgeish/cs224n-squad2.0-albert-xxlarge-v1)
-* [elgeish/cs224n-squad2.0-distilbert-base-uncased](https://huggingface.co/elgeish/cs224n-squad2.0-distilbert-base-uncased)

model_cards/google/bert_uncased_L-10_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-10_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-10_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-10_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-12_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-12_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-12_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-12_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-2_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-2_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-2_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-2_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-4_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-4_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-4_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-4_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-6_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-6_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-6_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-6_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-8_H-128_A-2/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-8_H-256_A-4/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-8_H-512_A-8/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/google/bert_uncased_L-8_H-768_A-12/README.md

@@ -1 +0,0 @@
-../../iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

model_cards/gsarti/biobert-nli/README.md

@@ -1,37 +0,0 @@
-# BioBERT-NLI
-
-This is the model [BioBERT](https://github.com/dmis-lab/biobert) [1] fine-tuned on the [SNLI](https://nlp.stanford.edu/projects/snli/) and the [MultiNLI](https://www.nyu.edu/projects/bowman/multinli/) datasets using the [`sentence-transformers` library](https://github.com/UKPLab/sentence-transformers/) to produce universal sentence embeddings [2].
-
-The model uses the original BERT wordpiece vocabulary and was trained using the **average pooling strategy** and a **softmax loss**.
-
-**Base model**: `monologg/biobert_v1.1_pubmed` from HuggingFace's `AutoModel`.
-
-**Training time**: ~6 hours on the NVIDIA Tesla P100 GPU provided in Kaggle Notebooks.
-
-**Parameters**:
-
-| Parameter        | Value |
-|------------------|-------|
-| Batch size       | 64    |
-| Training steps   | 30000 |
-| Warmup steps     | 1450  |
-| Lowercasing      | False |
-| Max. Seq. Length | 128   |
-
-**Performances**: The performance was evaluated on the test portion of the [STS dataset](http://ixa2.si.ehu.es/stswiki/index.php/STSbenchmark) using Spearman rank correlation and compared to the performances of a general BERT base model obtained with the same procedure to verify their similarity.
-
-| Model                         | Score       |
-|-------------------------------|-------------|
-| `biobert-nli` (this)          | 73.40       |
-| `gsarti/scibert-nli`          | 74.50       |
-| `bert-base-nli-mean-tokens`[3]| 77.12       |
-
-An example usage for similarity-based scientific paper retrieval is provided in the [Covid Papers Browser](https://github.com/gsarti/covid-papers-browser) repository.
-
-**References:**
-
-[1] J. Lee et al, [BioBERT: a pre-trained biomedical language representation model for biomedical text mining](https://academic.oup.com/bioinformatics/article/36/4/1234/5566506)
-
-[2] A. Conneau et al., [Supervised Learning of Universal Sentence Representations from Natural Language Inference Data](https://www.aclweb.org/anthology/D17-1070/)
-
-[3] N. Reimers et I. Gurevych, [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://www.aclweb.org/anthology/D19-1410/)

model_cards/gsarti/scibert-nli/README.md

@@ -1,36 +0,0 @@
-# SciBERT-NLI
-
-This is the model [SciBERT](https://github.com/allenai/scibert) [1] fine-tuned on the [SNLI](https://nlp.stanford.edu/projects/snli/) and the [MultiNLI](https://www.nyu.edu/projects/bowman/multinli/) datasets using the [`sentence-transformers` library](https://github.com/UKPLab/sentence-transformers/) to produce universal sentence embeddings [2].
-
-The model uses the original `scivocab` wordpiece vocabulary and was trained using the **average pooling strategy** and a **softmax loss**.
-
-**Base model**: `allenai/scibert-scivocab-cased` from HuggingFace's `AutoModel`.
-
-**Training time**: ~4 hours on the NVIDIA Tesla P100 GPU provided in Kaggle Notebooks.
-
-**Parameters**:
-
-| Parameter        | Value |
-|------------------|-------|
-| Batch size       | 64    |
-| Training steps   | 20000 |
-| Warmup steps     | 1450  |
-| Lowercasing      | True  |
-| Max. Seq. Length | 128   |
-
-**Performances**: The performance was evaluated on the test portion of the [STS dataset](http://ixa2.si.ehu.es/stswiki/index.php/STSbenchmark) using Spearman rank correlation and compared to the performances of a general BERT base model obtained with the same procedure to verify their similarity.
-
-| Model                         | Score       |
-|-------------------------------|-------------|
-| `scibert-nli` (this)          | 74.50       |
-| `bert-base-nli-mean-tokens`[3]| 77.12       |
-
-An example usage for similarity-based scientific paper retrieval is provided in the [Covid Papers Browser](https://github.com/gsarti/covid-papers-browser) repository.
-
-**References:**
-
-[1] I. Beltagy et al, [SciBERT: A Pretrained Language Model for Scientific Text](https://www.aclweb.org/anthology/D19-1371/)
-
-[2] A. Conneau et al., [Supervised Learning of Universal Sentence Representations from Natural Language Inference Data](https://www.aclweb.org/anthology/D17-1070/)
-
-[3] N. Reimers et I. Gurevych, [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://www.aclweb.org/anthology/D19-1410/)

model_cards/huggingface/CodeBERTa-language-id/README.md

@@ -1,298 +0,0 @@
----
-language: code
-thumbnail: https://hf-dinosaur.huggingface.co/CodeBERTa/CodeBERTa.png
----
-
-# CodeBERTa-language-id: The World’s fanciest programming language identification algo 🤯
-
-
-To demonstrate the usefulness of our CodeBERTa pretrained model on downstream tasks beyond language modeling, we fine-tune the [`CodeBERTa-small-v1`](https://huggingface.co/huggingface/CodeBERTa-small-v1) checkpoint on the task of classifying a sample of code into the programming language it's written in (*programming language identification*).
-
-We add a sequence classification head on top of the model.
-
-On the evaluation dataset, we attain an eval accuracy and F1 > 0.999 which is not surprising given that the task of language identification is relatively easy (see an intuition why, below).
-
-## Quick start: using the raw model
-
-```python
-CODEBERTA_LANGUAGE_ID = "huggingface/CodeBERTa-language-id"
-
-tokenizer = RobertaTokenizer.from_pretrained(CODEBERTA_LANGUAGE_ID)
-model = RobertaForSequenceClassification.from_pretrained(CODEBERTA_LANGUAGE_ID)
-
-input_ids = tokenizer.encode(CODE_TO_IDENTIFY)
-logits = model(input_ids)[0]
-
-language_idx = logits.argmax() # index for the resulting label
-```
-
-
-## Quick start: using Pipelines 💪
-
-```python
-from transformers import TextClassificationPipeline
-
-pipeline = TextClassificationPipeline(
-    model=RobertaForSequenceClassification.from_pretrained(CODEBERTA_LANGUAGE_ID),
-    tokenizer=RobertaTokenizer.from_pretrained(CODEBERTA_LANGUAGE_ID)
-)
-
-pipeline(CODE_TO_IDENTIFY)
-```
-
-Let's start with something very easy:
-
-```python
-pipeline("""
-def f(x):
-    return x**2
-""")
-# [{'label': 'python', 'score': 0.9999965}]
-```
-
-Now let's probe shorter code samples:
-
-```python
-pipeline("const foo = 'bar'")
-# [{'label': 'javascript', 'score': 0.9977546}]
-```
-
-What if I remove the `const` token from the assignment?
-```python
-pipeline("foo = 'bar'")
-# [{'label': 'javascript', 'score': 0.7176245}]
-```
-
-For some reason, this is still statistically detected as JS code, even though it's also valid Python code. However, if we slightly tweak it:
-
-```python
-pipeline("foo = u'bar'")
-# [{'label': 'python', 'score': 0.7638422}]
-```
-This is now detected as Python (Notice the `u` string modifier).
-
-Okay, enough with the JS and Python domination already! Let's try fancier languages:
-
-```python
-pipeline("echo $FOO")
-# [{'label': 'php', 'score': 0.9995257}]
-```
-
-(Yes, I used the word "fancy" to describe PHP 😅)
-
-```python
-pipeline("outcome := rand.Intn(6) + 1")
-# [{'label': 'go', 'score': 0.9936151}]
-```
-
-Why is the problem of language identification so easy (with the correct toolkit)? Because code's syntax is rigid, and simple tokens such as `:=` (the assignment operator in Go) are perfect predictors of the underlying language:
-
-```python
-pipeline(":=")
-# [{'label': 'go', 'score': 0.9998052}]
-```
-
-By the way, because we trained our own custom tokenizer on the [CodeSearchNet](https://github.blog/2019-09-26-introducing-the-codesearchnet-challenge/) dataset, and it handles streams of bytes in a very generic way, syntactic constructs such `:=` are represented by a single token:
-
-```python
-self.tokenizer.encode(" :=", add_special_tokens=False)
-# [521]
-```
-
-<br>
-
-## Fine-tuning code
-
-<details>
-
-```python
-import gzip
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-import numpy as np
-import torch
-from sklearn.metrics import f1_score
-from tokenizers.implementations.byte_level_bpe import ByteLevelBPETokenizer
-from tokenizers.processors import BertProcessing
-from torch.nn.utils.rnn import pad_sequence
-from torch.utils.data import DataLoader, Dataset
-from torch.utils.data.dataset import Dataset
-from torch.utils.tensorboard.writer import SummaryWriter
-from tqdm import tqdm, trange
-
-from transformers import RobertaForSequenceClassification
-from transformers.data.metrics import acc_and_f1, simple_accuracy
-
-
-logging.basicConfig(level=logging.INFO)
-
-
-CODEBERTA_PRETRAINED = "huggingface/CodeBERTa-small-v1"
-
-LANGUAGES = [
-    "go",
-    "java",
-    "javascript",
-    "php",
-    "python",
-    "ruby",
-]
-FILES_PER_LANGUAGE = 1
-EVALUATE = True
-
-# Set up tokenizer
-tokenizer = ByteLevelBPETokenizer("./pretrained/vocab.json", "./pretrained/merges.txt",)
-tokenizer._tokenizer.post_processor = BertProcessing(
-    ("</s>", tokenizer.token_to_id("</s>")), ("<s>", tokenizer.token_to_id("<s>")),
-)
-tokenizer.enable_truncation(max_length=512)
-
-# Set up Tensorboard
-tb_writer = SummaryWriter()
-
-
-class CodeSearchNetDataset(Dataset):
-    examples: List[Tuple[List[int], int]]
-
-    def __init__(self, split: str = "train"):
-        """
-        train | valid | test
-        """
-
-        self.examples = []
-
-        src_files = []
-        for language in LANGUAGES:
-            src_files += list(
-                Path("../CodeSearchNet/resources/data/").glob(f"{language}/final/jsonl/{split}/*.jsonl.gz")
-            )[:FILES_PER_LANGUAGE]
-        for src_file in src_files:
-            label = src_file.parents[3].name
-            label_idx = LANGUAGES.index(label)
-            print("🔥", src_file, label)
-            lines = []
-            fh = gzip.open(src_file, mode="rt", encoding="utf-8")
-            for line in fh:
-                o = json.loads(line)
-                lines.append(o["code"])
-            examples = [(x.ids, label_idx) for x in tokenizer.encode_batch(lines)]
-            self.examples += examples
-        print("🔥🔥")
-
-    def __len__(self):
-        return len(self.examples)
-
-    def __getitem__(self, i):
-        # We’ll pad at the batch level.
-        return self.examples[i]
-
-
-model = RobertaForSequenceClassification.from_pretrained(CODEBERTA_PRETRAINED, num_labels=len(LANGUAGES))
-
-train_dataset = CodeSearchNetDataset(split="train")
-eval_dataset = CodeSearchNetDataset(split="test")
-
-
-def collate(examples):
-    input_ids = pad_sequence([torch.tensor(x[0]) for x in examples], batch_first=True, padding_value=1)
-    labels = torch.tensor([x[1] for x in examples])
-    # ^^  uncessary .unsqueeze(-1)
-    return input_ids, labels
-
-
-train_dataloader = DataLoader(train_dataset, batch_size=256, shuffle=True, collate_fn=collate)
-
-batch = next(iter(train_dataloader))
-
-
-model.to("cuda")
-model.train()
-for param in model.roberta.parameters():
-    param.requires_grad = False
-## ^^ Only train final layer.
-
-print(f"num params:", model.num_parameters())
-print(f"num trainable params:", model.num_parameters(only_trainable=True))
-
-
-def evaluate():
-    eval_loss = 0.0
-    nb_eval_steps = 0
-    preds = np.empty((0), dtype=np.int64)
-    out_label_ids = np.empty((0), dtype=np.int64)
-
-    model.eval()
-
-    eval_dataloader = DataLoader(eval_dataset, batch_size=512, collate_fn=collate)
-    for step, (input_ids, labels) in enumerate(tqdm(eval_dataloader, desc="Eval")):
-        with torch.no_grad():
-            outputs = model(input_ids=input_ids.to("cuda"), labels=labels.to("cuda"))
-            loss = outputs[0]
-            logits = outputs[1]
-            eval_loss += loss.mean().item()
-            nb_eval_steps += 1
-        preds = np.append(preds, logits.argmax(dim=1).detach().cpu().numpy(), axis=0)
-        out_label_ids = np.append(out_label_ids, labels.detach().cpu().numpy(), axis=0)
-    eval_loss = eval_loss / nb_eval_steps
-    acc = simple_accuracy(preds, out_label_ids)
-    f1 = f1_score(y_true=out_label_ids, y_pred=preds, average="macro")
-    print("=== Eval: loss ===", eval_loss)
-    print("=== Eval: acc. ===", acc)
-    print("=== Eval: f1 ===", f1)
-    # print(acc_and_f1(preds, out_label_ids))
-    tb_writer.add_scalars("eval", {"loss": eval_loss, "acc": acc, "f1": f1}, global_step)
-
-
-### Training loop
-
-global_step = 0
-train_iterator = trange(0, 4, desc="Epoch")
-optimizer = torch.optim.AdamW(model.parameters())
-for _ in train_iterator:
-    epoch_iterator = tqdm(train_dataloader, desc="Iteration")
-    for step, (input_ids, labels) in enumerate(epoch_iterator):
-        optimizer.zero_grad()
-        outputs = model(input_ids=input_ids.to("cuda"), labels=labels.to("cuda"))
-        loss = outputs[0]
-        loss.backward()
-        tb_writer.add_scalar("training_loss", loss.item(), global_step)
-        optimizer.step()
-        global_step += 1
-        if EVALUATE and global_step % 50 == 0:
-            evaluate()
-            model.train()
-
-
-evaluate()
-
-os.makedirs("./models/CodeBERT-language-id", exist_ok=True)
-model.save_pretrained("./models/CodeBERT-language-id")
-```
-
-</details>
-
-<br>
-
-## CodeSearchNet citation
-
-<details>
-
-```bibtex
-@article{husain_codesearchnet_2019,
-	title = {{CodeSearchNet} {Challenge}: {Evaluating} the {State} of {Semantic} {Code} {Search}},
-	shorttitle = {{CodeSearchNet} {Challenge}},
-	url = {http://arxiv.org/abs/1909.09436},
-	urldate = {2020-03-12},
-	journal = {arXiv:1909.09436 [cs, stat]},
-	author = {Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
-	month = sep,
-	year = {2019},
-	note = {arXiv: 1909.09436},
-}
-```
-
-</details>

model_cards/huggingface/CodeBERTa-small-v1/README.md

@@ -1,128 +0,0 @@
----
-language: code
-thumbnail: https://hf-dinosaur.huggingface.co/CodeBERTa/CodeBERTa.png
----
-
-# CodeBERTa
-
-CodeBERTa is a RoBERTa-like model trained on the [CodeSearchNet](https://github.blog/2019-09-26-introducing-the-codesearchnet-challenge/) dataset from GitHub.
-
-Supported languages:
-
-```shell
-"go"
-"java"
-"javascript"
-"php"
-"python"
-"ruby"
-```
-
-The **tokenizer** is a Byte-level BPE tokenizer trained on the corpus using Hugging Face `tokenizers`.
-
-Because it is trained on a corpus of code (vs. natural language), it encodes the corpus efficiently (the sequences are between 33% to 50% shorter, compared to the same corpus tokenized by gpt2/roberta).
-
-The (small) **model** is a 6-layer, 84M parameters, RoBERTa-like Transformer model – that’s the same number of layers & heads as DistilBERT – initialized from the default initialization settings and trained from scratch on the full corpus (~2M functions) for 5 epochs.
-
-### Tensorboard for this training ⤵️
-
-[![tb](https://hf-dinosaur.huggingface.co/CodeBERTa/tensorboard.png)](https://tensorboard.dev/experiment/irRI7jXGQlqmlxXS0I07ew/#scalars)
-
-## Quick start: masked language modeling prediction
-
-```python
-PHP_CODE = """
-public static <mask> set(string $key, $value) {
-	if (!in_array($key, self::$allowedKeys)) {
-		throw new \InvalidArgumentException('Invalid key given');
-	}
-	self::$storedValues[$key] = $value;
-}
-""".lstrip()
-```
-
-### Does the model know how to complete simple PHP code?
-
-```python
-from transformers import pipeline
-
-fill_mask = pipeline(
-    "fill-mask",
-    model="huggingface/CodeBERTa-small-v1",
-    tokenizer="huggingface/CodeBERTa-small-v1"
-)
-
-fill_mask(PHP_CODE)
-
-## Top 5 predictions:
-# 
-' function' # prob 0.9999827146530151
-'function'  # 
-' void'     # 
-' def'      # 
-' final'    # 
-```
-
-### Yes! That was easy 🎉 What about some Python (warning: this is going to be meta)
-
-```python
-PYTHON_CODE = """
-def pipeline(
-    task: str,
-    model: Optional = None,
-    framework: Optional[<mask>] = None,
-    **kwargs
-) -> Pipeline:
-	pass
-""".lstrip()
-```
-
-Results:
-```python
-'framework', 'Framework', ' framework', 'None', 'str'
-```
-
-> This program can auto-complete itself! 😱
-
-### Just for fun, let's try to mask natural language (not code):
-
-```python
-fill_mask("My name is <mask>.")
-
-# {'sequence': '<s> My name is undefined.</s>', 'score': 0.2548016905784607, 'token': 3353}
-# {'sequence': '<s> My name is required.</s>', 'score': 0.07290805131196976, 'token': 2371}
-# {'sequence': '<s> My name is null.</s>', 'score': 0.06323737651109695, 'token': 469}
-# {'sequence': '<s> My name is name.</s>', 'score': 0.021919190883636475, 'token': 652}
-# {'sequence': '<s> My name is disabled.</s>', 'score': 0.019681859761476517, 'token': 7434}
-```
-
-This (kind of) works because code contains comments (which contain natural language).
-
-Of course, the most frequent name for a Computer scientist must be undefined 🤓.
-
-
-## Downstream task: [programming language identification](https://huggingface.co/huggingface/CodeBERTa-language-id)
-
-See the model card for **[`huggingface/CodeBERTa-language-id`](https://huggingface.co/huggingface/CodeBERTa-language-id)** 🤯.
-
-<br>
-
-## CodeSearchNet citation
-
-<details>
-
-```bibtex
-@article{husain_codesearchnet_2019,
-	title = {{CodeSearchNet} {Challenge}: {Evaluating} the {State} of {Semantic} {Code} {Search}},
-	shorttitle = {{CodeSearchNet} {Challenge}},
-	url = {http://arxiv.org/abs/1909.09436},
-	urldate = {2020-03-12},
-	journal = {arXiv:1909.09436 [cs, stat]},
-	author = {Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
-	month = sep,
-	year = {2019},
-	note = {arXiv: 1909.09436},
-}
-```
-
-</details>

model_cards/huseinzol05/bert-base-bahasa-cased/README.md

@@ -1,92 +0,0 @@
----
-language: malay
----
-
-# Bahasa BERT Model
-
-Pretrained BERT base language model for Malay and Indonesian. 
-
-## Pretraining Corpus
-
-`bert-base-bahasa-cased` model was pretrained on ~1.8 Billion words. We trained on both standard and social media language structures, and below is list of data we trained on,
-
-1. [dumping wikipedia](https://github.com/huseinzol05/Malaya-Dataset#wikipedia-1).
-2. [local instagram](https://github.com/huseinzol05/Malaya-Dataset#instagram).
-3. [local twitter](https://github.com/huseinzol05/Malaya-Dataset#twitter-1).
-4. [local news](https://github.com/huseinzol05/Malaya-Dataset#public-news).
-5. [local parliament text](https://github.com/huseinzol05/Malaya-Dataset#parliament).
-6. [local singlish/manglish text](https://github.com/huseinzol05/Malaya-Dataset#singlish-text).
-7. [IIUM Confession](https://github.com/huseinzol05/Malaya-Dataset#iium-confession).
-8. [Wattpad](https://github.com/huseinzol05/Malaya-Dataset#wattpad).
-9. [Academia PDF](https://github.com/huseinzol05/Malaya-Dataset#academia-pdf).
-
-Preprocessing steps can reproduce from here, [Malaya/pretrained-model/preprocess](https://github.com/huseinzol05/Malaya/tree/master/pretrained-model/preprocess).
-
-## Pretraining details
-
-- This model was trained using Google BERT's github [repository](https://github.com/google-research/bert) on 3 Titan V100 32GB VRAM.
-- All steps can reproduce from here, [Malaya/pretrained-model/bert](https://github.com/huseinzol05/Malaya/tree/master/pretrained-model/bert).
-
-## Load Pretrained Model
-
-You can use this model by installing `torch` or `tensorflow` and Huggingface library `transformers`. And you can use it directly by initializing it like this:  
-
-```python
-from transformers import AlbertTokenizer, BertModel
-
-model = BertModel.from_pretrained('huseinzol05/bert-base-bahasa-cased')
-tokenizer = AlbertTokenizer.from_pretrained(
-    'huseinzol05/bert-base-bahasa-cased',
-    unk_token = '[UNK]',
-    pad_token = '[PAD]',
-    do_lower_case = False,
-)
-```
-
-We use [google/sentencepiece](https://github.com/google/sentencepiece) to train the tokenizer, so to use it, need to load from `AlbertTokenizer`.
-
-## Example using AutoModelWithLMHead
-
-```python
-from transformers import AlbertTokenizer, AutoModelWithLMHead, pipeline
-
-model = AutoModelWithLMHead.from_pretrained('huseinzol05/bert-base-bahasa-cased')
-tokenizer = AlbertTokenizer.from_pretrained(
-    'huseinzol05/bert-base-bahasa-cased',
-    unk_token = '[UNK]',
-    pad_token = '[PAD]',
-    do_lower_case = False,
-)
-fill_mask = pipeline('fill-mask', model = model, tokenizer = tokenizer)
-print(fill_mask('makan ayam dengan [MASK]'))
-```
-
-Output is,
-
-```text
-[{'sequence': '[CLS] makan ayam dengan rendang[SEP]',
-  'score': 0.10812027007341385,
-  'token': 2446},
- {'sequence': '[CLS] makan ayam dengan kicap[SEP]',
-  'score': 0.07653367519378662,
-  'token': 12928},
- {'sequence': '[CLS] makan ayam dengan nasi[SEP]',
-  'score': 0.06839974224567413,
-  'token': 450},
- {'sequence': '[CLS] makan ayam dengan ayam[SEP]',
-  'score': 0.059544261544942856,
-  'token': 638},
- {'sequence': '[CLS] makan ayam dengan sayur[SEP]',
-  'score': 0.05294966697692871,
-  'token': 1639}]
-```
-
-## Results
-
-For further details on the model performance, simply checkout accuracy page from Malaya, https://malaya.readthedocs.io/en/latest/Accuracy.html, we compared with traditional models.
-
-## Acknowledgement
-
-Thanks to [Im Big](https://www.facebook.com/imbigofficial/), [LigBlou](https://www.facebook.com/ligblou), [Mesolitica](https://mesolitica.com/) and [KeyReply](https://www.keyreply.com/) for sponsoring AWS, Google and GPU clouds to train BERT for Bahasa. 
-
-

model_cards/huseinzol05/xlnet-base-bahasa-cased/README.md

@@ -1,64 +0,0 @@
----
-language: malay
----
-
-# Bahasa XLNet Model
-
-Pretrained XLNet base language model for Malay and Indonesian. 
-
-## Pretraining Corpus
-
-`XLNET-base-bahasa-cased` model was pretrained on ~1.8 Billion words. We trained on both standard and social media language structures, and below is list of data we trained on,
-
-1. [dumping wikipedia](https://github.com/huseinzol05/Malaya-Dataset#wikipedia-1).
-2. [local instagram](https://github.com/huseinzol05/Malaya-Dataset#instagram).
-3. [local twitter](https://github.com/huseinzol05/Malaya-Dataset#twitter-1).
-4. [local news](https://github.com/huseinzol05/Malaya-Dataset#public-news).
-5. [local parliament text](https://github.com/huseinzol05/Malaya-Dataset#parliament).
-6. [local singlish/manglish text](https://github.com/huseinzol05/Malaya-Dataset#singlish-text).
-7. [IIUM Confession](https://github.com/huseinzol05/Malaya-Dataset#iium-confession).
-8. [Wattpad](https://github.com/huseinzol05/Malaya-Dataset#wattpad).
-9. [Academia PDF](https://github.com/huseinzol05/Malaya-Dataset#academia-pdf).
-
-Preprocessing steps can reproduce from here, [Malaya/pretrained-model/preprocess](https://github.com/huseinzol05/Malaya/tree/master/pretrained-model/preprocess).
-
-## Pretraining details
-
-- This model was trained using zihangdai XLNet's github [repository](https://github.com/zihangdai/xlnet) on 3 Titan V100 32GB VRAM.
-- All steps can reproduce from here, [Malaya/pretrained-model/xlnet](https://github.com/huseinzol05/Malaya/tree/master/pretrained-model/xlnet).
-
-## Load Pretrained Model
-
-You can use this model by installing `torch` or `tensorflow` and Huggingface library `transformers`. And you can use it directly by initializing it like this:  
-
-```python
-from transformers import XLNetTokenizer, XLNetModel
-
-model = XLNetModel.from_pretrained('huseinzol05/xlnet-base-bahasa-cased')
-tokenizer = XLNetTokenizer.from_pretrained(
-    'huseinzol05/xlnet-base-bahasa-cased', do_lower_case = False
-)
-```
-
-## Example using AutoModelWithLMHead
-
-```python
-from transformers import AlbertTokenizer, AutoModelWithLMHead, pipeline
-
-model = AutoModelWithLMHead.from_pretrained('huseinzol05/xlnet-base-bahasa-cased')
-tokenizer = XLNetTokenizer.from_pretrained(
-    'huseinzol05/xlnet-base-bahasa-cased', do_lower_case = False
-)
-fill_mask = pipeline('fill-mask', model = model, tokenizer = tokenizer)
-print(fill_mask('makan ayam dengan [MASK]'))
-```
-
-## Results
-
-For further details on the model performance, simply checkout accuracy page from Malaya, https://malaya.readthedocs.io/en/latest/Accuracy.html, we compared with traditional models.
-
-## Acknowledgement
-
-Thanks to [Im Big](https://www.facebook.com/imbigofficial/), [LigBlou](https://www.facebook.com/ligblou), [Mesolitica](https://mesolitica.com/) and [KeyReply](https://www.keyreply.com/) for sponsoring AWS, Google and GPU clouds to train XLNet for Bahasa. 
-
-

model_cards/iuliaturc/bert_uncased_L-2_H-128_A-2/README.md

@@ -1,74 +0,0 @@
----
-thumbnail: https://huggingface.co/front/thumbnails/google.png
----
-
-BERT Miniatures
-===
-
-This is the set of 24 BERT models referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962) (English only, uncased, trained with WordPiece masking).
-
-We have shown that the standard BERT recipe (including model architecture and training objective) is effective on a wide range of model sizes, beyond BERT-Base and BERT-Large. The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
-
-Our goal is to enable research in institutions with fewer computational resources and encourage the community to seek directions of innovation alternative to increasing model capacity.
-
-You can download the 24 BERT miniatures either from the [official BERT Github page](https://github.com/google-research/bert/), or via HuggingFace from the links below:
-
-|   |H=128|H=256|H=512|H=768|
-|---|:---:|:---:|:---:|:---:|
-| **L=2**  |[**2/128 (BERT-Tiny)**][2_128]|[2/256][2_256]|[2/512][2_512]|[2/768][2_768]|
-| **L=4**  |[4/128][4_128]|[**4/256 (BERT-Mini)**][4_256]|[**4/512 (BERT-Small)**][4_512]|[4/768][4_768]|
-| **L=6**  |[6/128][6_128]|[6/256][6_256]|[6/512][6_512]|[6/768][6_768]|
-| **L=8**  |[8/128][8_128]|[8/256][8_256]|[**8/512 (BERT-Medium)**][8_512]|[8/768][8_768]|
-| **L=10** |[10/128][10_128]|[10/256][10_256]|[10/512][10_512]|[10/768][10_768]|
-| **L=12** |[12/128][12_128]|[12/256][12_256]|[12/512][12_512]|[**12/768 (BERT-Base)**][12_768]|
-
-Note that the BERT-Base model in this release is included for completeness only; it was re-trained under the same regime as the original model.
-
-Here are the corresponding GLUE scores on the test set:
-
-|Model|Score|CoLA|SST-2|MRPC|STS-B|QQP|MNLI-m|MNLI-mm|QNLI(v2)|RTE|WNLI|AX|
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-|BERT-Tiny|64.2|0.0|83.2|81.1/71.1|74.3/73.6|62.2/83.4|70.2|70.3|81.5|57.2|62.3|21.0|
-|BERT-Mini|65.8|0.0|85.9|81.1/71.8|75.4/73.3|66.4/86.2|74.8|74.3|84.1|57.9|62.3|26.1|
-|BERT-Small|71.2|27.8|89.7|83.4/76.2|78.8/77.0|68.1/87.0|77.6|77.0|86.4|61.8|62.3|28.6|
-|BERT-Medium|73.5|38.0|89.6|86.6/81.6|80.4/78.4|69.6/87.9|80.0|79.1|87.7|62.2|62.3|30.5|
-
-For each task, we selected the best fine-tuning hyperparameters from the lists below, and trained for 4 epochs:
-- batch sizes: 8, 16, 32, 64, 128
-- learning rates: 3e-4, 1e-4, 5e-5, 3e-5
-
-If you use these models, please cite the following paper:
-
-```
-@article{turc2019,
-  title={Well-Read Students Learn Better: On the Importance of Pre-training Compact Models},
-  author={Turc, Iulia and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
-  journal={arXiv preprint arXiv:1908.08962v2 },
-  year={2019}
-}
-```
-
-[2_128]: https://huggingface.co/google/bert_uncased_L-2_H-128_A-2
-[2_256]: https://huggingface.co/google/bert_uncased_L-2_H-256_A-4
-[2_512]: https://huggingface.co/google/bert_uncased_L-2_H-512_A-8
-[2_768]: https://huggingface.co/google/bert_uncased_L-2_H-768_A-12
-[4_128]: https://huggingface.co/google/bert_uncased_L-4_H-128_A-2
-[4_256]: https://huggingface.co/google/bert_uncased_L-4_H-256_A-4
-[4_512]: https://huggingface.co/google/bert_uncased_L-4_H-512_A-8
-[4_768]: https://huggingface.co/google/bert_uncased_L-4_H-768_A-12
-[6_128]: https://huggingface.co/google/bert_uncased_L-6_H-128_A-2
-[6_256]: https://huggingface.co/google/bert_uncased_L-6_H-256_A-4
-[6_512]: https://huggingface.co/google/bert_uncased_L-6_H-512_A-8
-[6_768]: https://huggingface.co/google/bert_uncased_L-6_H-768_A-12
-[8_128]: https://huggingface.co/google/bert_uncased_L-8_H-128_A-2
-[8_256]: https://huggingface.co/google/bert_uncased_L-8_H-256_A-4
-[8_512]: https://huggingface.co/google/bert_uncased_L-8_H-512_A-8
-[8_768]: https://huggingface.co/google/bert_uncased_L-8_H-768_A-12
-[10_128]: https://huggingface.co/google/bert_uncased_L-10_H-128_A-2
-[10_256]: https://huggingface.co/google/bert_uncased_L-10_H-256_A-4
-[10_512]: https://huggingface.co/google/bert_uncased_L-10_H-512_A-8
-[10_768]: https://huggingface.co/google/bert_uncased_L-10_H-768_A-12
-[12_128]: https://huggingface.co/google/bert_uncased_L-12_H-128_A-2
-[12_256]: https://huggingface.co/google/bert_uncased_L-12_H-256_A-4
-[12_512]: https://huggingface.co/google/bert_uncased_L-12_H-512_A-8
-[12_768]: https://huggingface.co/google/bert_uncased_L-12_H-768_A-12

model_cards/jannesg/bertsson/README.md

@@ -1,20 +0,0 @@
----
-language: swedish
----
-
-# BERTSSON Models
-
-The models are trained on:
-- Government Text
-- Swedish Literature
-- Swedish News
-
-Corpus size: Roughly 6B tokens.
-
-The following models are currently available:
-
-- **bertsson** - A BERT base model trained with the same hyperparameters as first published by Google.
-
-All models are cased and trained with whole word masking.
-
-Stay tuned for evaluations. 

model_cards/mrm8488/CodeBERTaPy/README.md

@@ -1,123 +0,0 @@
----
-language: code
-thumbnail:
----
-
-# CodeBERTaPy
-
-CodeBERTaPy is a RoBERTa-like model trained on the [CodeSearchNet](https://github.blog/2019-09-26-introducing-the-codesearchnet-challenge/) dataset from GitHub for `python` by [Manuel Romero](https://twitter.com/mrm8488)
-
-The **tokenizer** is a Byte-level BPE tokenizer trained on the corpus using Hugging Face `tokenizers`.
-
-Because it is trained on a corpus of code (vs. natural language), it encodes the corpus efficiently (the sequences are between 33% to 50% shorter, compared to the same corpus tokenized by gpt2/roberta).
-
-The (small) **model** is a 6-layer, 84M parameters, RoBERTa-like Transformer model – that’s the same number of layers & heads as DistilBERT – initialized from the default initialization settings and trained from scratch on the full `python` corpus for 4 epochs.
-
-## Quick start: masked language modeling prediction
-
-```python
-PYTHON_CODE = """
-fruits = ['apples', 'bananas', 'oranges']
-for idx, <mask> in enumerate(fruits):
-  print("index is %d and value is %s" % (idx, val))
-""".lstrip()
-```
-
-### Does the model know how to complete simple Python code?
-
-```python
-from transformers import pipeline
-
-fill_mask = pipeline(
-    "fill-mask",
-    model="mrm8488/CodeBERTaPy",
-    tokenizer="mrm8488/CodeBERTaPy"
-)
-
-fill_mask(PYTHON_CODE)
-
-## Top 5 predictions:
-
-'val' # prob  0.980728805065155
-'value'
-'idx'
-',val'
-'_'
-```
-
-### Yes! That was easy 🎉 Let's try with another Flask like example
-
-```python
-PYTHON_CODE2 = """
-@app.route('/<name>')
-def hello_name(name):
-    return "Hello {}!".format(<mask>)
-
-if __name__ == '__main__':
-    app.run()
-""".lstrip()
-
-
-fill_mask(PYTHON_CODE2)
-
-## Top 5 predictions:
-
-'name' # prob  0.9961813688278198
-' name'
-'url'
-'description'
-'self'
-```
-
-### Yeah! It works 🎉 Let's try with another Tensorflow/Keras like example
-
-```python
-PYTHON_CODE3="""
-model = keras.Sequential([
-    keras.layers.Flatten(input_shape=(28, 28)),
-    keras.layers.<mask>(128, activation='relu'),
-    keras.layers.Dense(10, activation='softmax')
-])
-""".lstrip()
-
-
-fill_mask(PYTHON_CODE3)
-
-## Top 5 predictions:
-
-'Dense' # prob   0.4482928514480591
-'relu'
-'Flatten'
-'Activation'
-'Conv'
-```
-
-> Great! 🎉
-
-## This work is heavely inspired on [CodeBERTa](https://github.com/huggingface/transformers/blob/master/model_cards/huggingface/CodeBERTa-small-v1/README.md) by huggingface team
-
-<br>
-
-## CodeSearchNet citation
-
-<details>
-
-```bibtex
-@article{husain_codesearchnet_2019,
-	title = {{CodeSearchNet} {Challenge}: {Evaluating} the {State} of {Semantic} {Code} {Search}},
-	shorttitle = {{CodeSearchNet} {Challenge}},
-	url = {http://arxiv.org/abs/1909.09436},
-	urldate = {2020-03-12},
-	journal = {arXiv:1909.09436 [cs, stat]},
-	author = {Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
-	month = sep,
-	year = {2019},
-	note = {arXiv: 1909.09436},
-}
-```
-
-</details>
-
-> Created by [Manuel Romero/@mrm8488](https://twitter.com/mrm8488)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in Spain

model_cards/mrm8488/GPT-2-finetuned-CORD19/README.md

@@ -1,60 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# GPT-2 + CORD19 dataset : 🦠 ✍ ⚕
-
-**GPT-2** fine-tuned on **biorxiv_medrxiv** and **comm_use_subset files** from [CORD-19](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) dataset.
-
-
-## Datasets details:
-
-| Dataset                | # Files |
-| ---------------------- | ----- |
-| biorxiv_medrxiv        | 885  |
-| comm_use_subse         | 9K   |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM with the following command:
-
-```bash
-
-export TRAIN_FILE=/path/to/dataset/train.txt
-
-python run_language_modeling.py \
-    --model_type gpt2 \
-    --model_name_or_path gpt2 \
-    --do_train \
-    --train_data_file $TRAIN_FILE \
-    --num_train_epochs 4 \
-    --output_dir model_output \
-    --overwrite_output_dir \
-    --save_steps 10000 \
-    --per_gpu_train_batch_size 3
-```
-
-<img alt="training loss" src="https://svgshare.com/i/JTf.svg' title='GTP-2-finetuned-CORDS19-loss" width="600" height="300" />
-
-## Model in action / Example of usage: ✒
-
-You can get the following script [here](https://github.com/huggingface/transformers/blob/master/examples/run_generation.py)
-
-```bash
-python run_generation.py \
-    --model_type gpt2 \
-    --model_name_or_path mrm8488/GPT-2-finetuned-CORD19 \
-    --length 200
-```
-```txt
-# Input: the effects of COVID-19 on the lungs
-# Output: === GENERATED SEQUENCE 1 ===
-the effects of COVID-19 on the lungs are currently debated (86). The role of this virus in the pathogenesis of pneumonia and lung cancer is still debated. MERS-CoV is also known to cause acute respiratory distress syndrome (87) and is associated with increased expression of pulmonary fibrosis markers (88). Thus, early airway inflammation may play an important role in the pathogenesis of coronavirus pneumonia and may contribute to the severe disease and/or mortality observed in coronavirus patients.
-Pneumonia is an acute, often fatal disease characterized by severe edema, leakage of oxygen and bronchiolar inflammation. Viruses include coronaviruses, and the role of oxygen depletion is complicated by lung injury and fibrosis in the lung, in addition to susceptibility to other lung diseases. The progression of the disease may be variable, depending on the lung injury, pathologic role, prognosis, and the immune status of the patient. Inflammatory responses to respiratory viruses cause various pathologies of the respiratory
-```
-
-
-> 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

model_cards/mrm8488/bert-medium-finetuned-squadv2/README.md

@@ -1,122 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# BERT-Medium fine-tuned on SQuAD v2
-
-[BERT-Medium](https://github.com/google-research/bert/) created by [Google Research](https://github.com/google-research) and fine-tuned on [SQuAD 2.0](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-**Mode size** (after training): **157.46 MB**
-
-## Details of BERT-Small and its 'family' (from their documentation)
-
-Released on March 11th, 2020
-
-This is model is a part of 24 smaller BERT models (English only, uncased, trained with WordPiece masking) referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962).
-
-The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD2.0](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 |
-| -------- | ----- | --------- |
-| SQuAD2.0 | train | 130k      |
-| SQuAD2.0 | eval  | 12.3k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **65.95** |
-| **F1** | **70.11** |
-
-### Raw metrics from benchmark included in training script:
-
-```json
-{
-  "exact": 65.95637159942727,
-  "f1": 70.11632254245896,
-  "total": 11873,
-  "HasAns_exact": 67.79689608636977,
-  "HasAns_f1": 76.12872765631123,
-  "HasAns_total": 5928,
-  "NoAns_exact": 64.12111017661901,
-  "NoAns_f1": 64.12111017661901,
-  "NoAns_total": 5945,
-  "best_exact": 65.96479407058031,
-  "best_exact_thresh": 0.0,
-  "best_f1": 70.12474501361196,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Comparison:
-
-| Model                                                                                         | EM        | F1 score  | SIZE (MB) |
-| --------------------------------------------------------------------------------------------- | --------- | --------- | --------- |
-| [bert-tiny-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-finetuned-squadv2)     | 48.60     | 49.73     | **16.74** |
-| [bert-tiny-5-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-5-finetuned-squadv2) | 57.12     | 60.86     | 24.34     |
-| [bert-mini-finetuned-squadv2](https://huggingface.co/mrm8488/bert-mini-finetuned-squadv2)     | 56.31     | 59.65     | 42.63     |
-| [bert-mini-5-finetuned-squadv2](https://huggingface.co/mrm8488/bert-mini-5-finetuned-squadv2) | 63.51     | 66.78     | 66.76     |
-| [bert-small-finetuned-squadv2](https://huggingface.co/mrm8488/bert-small-finetuned-squadv2)   | 60.49     | 64.21     | 109.74    |
-| [bert-medium-finetuned-squadv2](https://huggingface.co/mrm8488/bert-medium-finetuned-squadv2) | **65.95** | **70.11** | 157.46    |
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/bert-small-finetuned-squadv2",
-    tokenizer="mrm8488/bert-small-finetuned-squadv2"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "Manuel Romero",
-  "end": 13,
-  "score": 0.9939319924374637,
-  "start": 0
-}
-```
-
-### Yes! That was easy 🎉 Let's try with another example
-
-```python
-qa_pipeline({
-    'context': "Manuel Romero has been working remotely in the repository hugginface/transformers lately",
-    'question': "How has been working Manuel Romero?"
-})
-
-# Output:
-```
-
-```json
-{ "answer": "remotely", "end": 39, "score": 0.3612058272768017, "start": 31 }
-```
-
-### It works!! 🎉 🎉 🎉
-
-> 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

model_cards/mrm8488/bert-mini-finetuned-squadv2/README.md

@@ -1,105 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# BERT-Mini fine-tuned on SQuAD v2
-
-[BERT-Mini](https://github.com/google-research/bert/) created by [Google Research](https://github.com/google-research) and fine-tuned on [SQuAD 2.0](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-**Mode size** (after training): **42.63 MB**
-
-## Details of BERT-Mini and its 'family' (from their documentation)
-
-Released on March 11th, 2020
-
-This is model is a part of 24 smaller BERT models (English only, uncased, trained with WordPiece masking) referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962).
-
-The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD2.0](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 |
-| -------- | ----- | --------- |
-| SQuAD2.0 | train | 130k      |
-| SQuAD2.0 | eval  | 12.3k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **56.31** |
-| **F1** | **59.65** |
-
-## Comparison:
-
-| Model                                                                                     | EM        | F1 score  | SIZE (MB) |
-| ----------------------------------------------------------------------------------------- | --------- | --------- | --------- |
-| [bert-tiny-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-finetuned-squadv2) | 48.60     | 49.73     | **16.74** |
-| [bert-tiny-5-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-5-finetuned-squadv2) | 57.12     | 60.86     | 24.34 |
-| [bert-mini-finetuned-squadv2](https://huggingface.co/mrm8488/bert-mini-finetuned-squadv2) | 56.31 | 59.65 | 42.63     |
-| [bert-mini-5-finetuned-squadv2](https://huggingface.co/mrm8488/bert-mini-5-finetuned-squadv2) | **63.51** | **66.78** | 66.76 |
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/bert-mini-finetuned-squadv2",
-    tokenizer="mrm8488/bert-mini-finetuned-squadv2"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "Manuel Romero",
-  "end": 13,
-  "score": 0.9676484207783673,
-  "start": 0
-}
-```
-
-### Yes! That was easy 🎉 Let's try with another example
-
-```python
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "For which company has worked Manuel Romero?"
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "hugginface/transformers",
-  "end": 79,
-  "score": 0.5301655914731853,
-  "start": 56
-}
-```
-
-### It works!! 🎉 🎉 🎉
-
-> 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

model_cards/mrm8488/bert-small-finetuned-squadv2/README.md

@@ -1,104 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# BERT-Small fine-tuned on SQuAD v2
-
-[BERT-Small](https://github.com/google-research/bert/) created by [Google Research](https://github.com/google-research) and fine-tuned on [SQuAD 2.0](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-**Mode size** (after training): **109.74 MB**
-
-## Details of BERT-Small and its 'family' (from their documentation)
-
-Released on March 11th, 2020
-
-This is model is a part of 24 smaller BERT models (English only, uncased, trained with WordPiece masking) referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962).
-
-The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD2.0](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 |
-| -------- | ----- | --------- |
-| SQuAD2.0 | train | 130k      |
-| SQuAD2.0 | eval  | 12.3k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **60.49** |
-| **F1** | **64.21** |
-
-## Comparison:
-
-| Model                                                                                       | EM        | F1 score  | SIZE (MB) |
-| ------------------------------------------------------------------------------------------- | --------- | --------- | --------- |
-| [bert-tiny-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-finetuned-squadv2)   | 48.60     | 49.73     | **16.74** |
-| [bert-mini-finetuned-squadv2](https://huggingface.co/mrm8488/bert-mini-finetuned-squadv2)   | 56.31     | 59.65     | 42.63     |
-| [bert-small-finetuned-squadv2](https://huggingface.co/mrm8488/bert-small-finetuned-squadv2) | **60.49** | **64.21** | 109.74    |
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/bert-small-finetuned-squadv2",
-    tokenizer="mrm8488/bert-small-finetuned-squadv2"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "Manuel Romero",
-  "end": 13,
-  "score": 0.9939319924374637,
-  "start": 0
-}
-```
-
-### Yes! That was easy 🎉 Let's try with another example
-
-```python
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "For which company has worked Manuel Romero?"
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "hugginface/transformers",
-  "end": 79,
-  "score": 0.6024888734447131,
-  "start": 56
-}
-```
-
-### It works!! 🎉 🎉 🎉
-
-> 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

model_cards/mrm8488/bert-spanish-cased-finetuned-pos/README.md

@@ -5,7 +5,7 @@ thumbnail: https://i.imgur.com/jgBdimh.png
 
 # Spanish BERT (BETO) + POS
 
-This model is a fine-tuned on Spanish [CONLL CORPORA](https://www.kaggle.com/nltkdata/conll-corpora) version of the Spanish BERT cased [(BETO)](https://github.com/dccuchile/beto) for **POS** (Part of Speech tagging) downstream task.
+This model is a fine-tuned on [NER-C](https://www.kaggle.com/nltkdata/conll-corpora) Of the Spanish BERT cased [(BETO)](https://github.com/dccuchile/beto) for **POS** (Part of Speech tagging) downstream task.
 
 ## Details of the downstream task (POS) - Dataset
 

model_cards/mrm8488/bert-tiny-finetuned-squadv2/README.md

@@ -1,102 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# BERT-Tiny fine-tuned on SQuAD v2
-
-[BERT-Tiny](https://github.com/google-research/bert/) created by [Google Research](https://github.com/google-research) and fine-tuned on [SQuAD 2.0](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-**Mode size** (after training): **16.74 MB**
-
-## Details of BERT-Tiny and its 'family' (from their documentation)
-
-Released on March 11th, 2020
-
-This is model is a part of 24 smaller BERT models (English only, uncased, trained with WordPiece masking) referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962).
-
-The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD2.0](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 |
-| -------- | ----- | --------- |
-| SQuAD2.0 | train | 130k      |
-| SQuAD2.0 | eval  | 12.3k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **48.60** |
-| **F1** | **49.73** |
-
-
-| Model                                                                                     | EM        | F1 score  | SIZE (MB) |
-| ----------------------------------------------------------------------------------------- | --------- | --------- | --------- |
-| [bert-tiny-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-finetuned-squadv2) | 48.60     | 49.73     | **16.74** |
-| [bert-tiny-5-finetuned-squadv2](https://huggingface.co/mrm8488/bert-tiny-5-finetuned-squadv2) | **57.12** | **60.86** | 24.34  
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/bert-tiny-finetuned-squadv2",
-    tokenizer="mrm8488/bert-tiny-finetuned-squadv2"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "Manuel Romero",
-  "end": 13,
-  "score": 0.05684709993458714,
-  "start": 0
-}
-```
-
-### Yes! That was easy 🎉 Let's try with another example
-
-```python
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "For which company has worked Manuel Romero?"
-})
-
-# Output:
-```
-
-```json
-{
-  "answer": "hugginface/transformers",
-  "end": 79,
-  "score": 0.11613431826808274,
-  "start": 56
-}
-```
-
-### It works!! 🎉 🎉 🎉
-
-> 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

model_cards/mrm8488/codeBERTaJS/README.md

@@ -1,100 +0,0 @@
----
-language: code
-thumbnail:
----
-
-# CodeBERTaJS
-
-CodeBERTaJS is a RoBERTa-like model trained on the [CodeSearchNet](https://github.blog/2019-09-26-introducing-the-codesearchnet-challenge/) dataset from GitHub for `javaScript` by [Manuel Romero](https://twitter.com/mrm8488)
-
-The **tokenizer** is a Byte-level BPE tokenizer trained on the corpus using Hugging Face `tokenizers`.
-
-Because it is trained on a corpus of code (vs. natural language), it encodes the corpus efficiently (the sequences are between 33% to 50% shorter, compared to the same corpus tokenized by gpt2/roberta).
-
-The (small) **model** is a 6-layer, 84M parameters, RoBERTa-like Transformer model – that’s the same number of layers & heads as DistilBERT – initialized from the default initialization settings and trained from scratch on the full `javascript` corpus (120M after preproccessing) for 2 epochs.
-
-## Quick start: masked language modeling prediction
-
-```python
-JS_CODE = """
-async function createUser(req, <mask>) {
-  if (!validUser(req.body.user)) {
-	  return res.status(400);
-  }
-  user = userService.createUser(req.body.user);
-  return res.json(user);
-}
-""".lstrip()
-```
-
-### Does the model know how to complete simple JS/express like code?
-
-```python
-from transformers import pipeline
-
-fill_mask = pipeline(
-    "fill-mask",
-    model="mrm8488/codeBERTaJS",
-    tokenizer="mrm8488/codeBERTaJS"
-)
-
-fill_mask(JS_CODE)
-
-## Top 5 predictions:
-#
-'res' # prob  0.069489665329
-'next'
-'req'
-'user'
-',req'
-```
-
-### Yes! That was easy 🎉 Let's try with another example
-
-```python
-JS_CODE_= """
-function getKeys(obj) {
-  keys = [];
-  for (var [key, value] of Object.entries(obj)) {
-     keys.push(<mask>);
-  }
-  return keys
-}
-""".lstrip()
-```
-
-Results:
-
-```python
-'obj', 'key', ' value', 'keys', 'i'
-```
-
-> Not so bad! Right token was predicted as second option! 🎉
-
-## This work is heavely inspired on [codeBERTa](https://github.com/huggingface/transformers/blob/master/model_cards/huggingface/CodeBERTa-small-v1/README.md) by huggingface team
-
-<br>
-
-## CodeSearchNet citation
-
-<details>
-
-```bibtex
-@article{husain_codesearchnet_2019,
-	title = {{CodeSearchNet} {Challenge}: {Evaluating} the {State} of {Semantic} {Code} {Search}},
-	shorttitle = {{CodeSearchNet} {Challenge}},
-	url = {http://arxiv.org/abs/1909.09436},
-	urldate = {2020-03-12},
-	journal = {arXiv:1909.09436 [cs, stat]},
-	author = {Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
-	month = sep,
-	year = {2019},
-	note = {arXiv: 1909.09436},
-}
-```
-
-</details>
-
-> Created by [Manuel Romero/@mrm8488](https://twitter.com/mrm8488)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in Spain

model_cards/mrm8488/spanbert-finetuned-squadv1/README.md

@@ -1,84 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# SpanBERT (spanbert-base-cased) fine-tuned on SQuAD v1.1
-
-
-[SpanBERT](https://github.com/facebookresearch/SpanBERT) created by [Facebook Research](https://github.com/facebookresearch) and fine-tuned on [SQuAD 1.1](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-## Details of SpanBERT
-
- A pre-training method that is designed to better represent and predict spans of text.
-
-[SpanBERT: Improving Pre-training by Representing and Predicting Spans](https://arxiv.org/abs/1907.10529)
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD 1.1](https://rajpurkar.github.io/SQuAD-explorer/) contains 100,000+ question-answer pairs on 500+ articles.
-
-| Dataset  | Split | # samples |
-| -------- | ----- | --------- |
-| SQuAD1.1 | train | 87.7k     |
-| SQuAD1.1 | eval  | 10.6k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **85.49** |
-| **F1** | **91.98** |
-
-### Raw metrics:
-
-```json
-{
-  "exact": 85.49668874172185,
-  "f1": 91.9845699540379,
-  "total": 10570,
-  "HasAns_exact": 85.49668874172185,
-  "HasAns_f1": 91.9845699540379,
-  "HasAns_total": 10570,
-  "best_exact": 85.49668874172185,
-  "best_exact_thresh": 0.0,
-  "best_f1": 91.9845699540379,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Comparison:
-
-| Model                                                                                     | EM        | F1 score  |
-| ----------------------------------------------------------------------------------------- | --------- | --------- |
-| [SpanBert official repo](https://github.com/facebookresearch/SpanBERT#pre-trained-models) | -         | 92.4\* |
-| [spanbert-finetuned-squadv1](https://huggingface.co/mrm8488/spanbert-finetuned-squadv1)   | **85.49** | **91.98** |
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/spanbert-finetuned-squadv1",
-    tokenizer="mrm8488/spanbert-finetuned-squadv1"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-```
-
-> 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

model_cards/mrm8488/spanbert-finetuned-squadv2/README.md

@@ -1,86 +0,0 @@
----
-language: english
-thumbnail:
----
-
-# SpanBERT (spanbert-base-cased) fine-tuned on SQuAD v2
-
-[SpanBERT](https://github.com/facebookresearch/SpanBERT) created by [Facebook Research](https://github.com/facebookresearch) and fine-tuned on [SQuAD 2.0](https://rajpurkar.github.io/SQuAD-explorer/) for **Q&A** downstream task.
-
-## Details of SpanBERT
-
-[SpanBERT: Improving Pre-training by Representing and Predicting Spans](https://arxiv.org/abs/1907.10529)
-
-## Details of the downstream task (Q&A) - Dataset
-
-[SQuAD2.0](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 |
-| -------- | ----- | --------- |
-| SQuAD2.0 | train | 130k      |
-| SQuAD2.0 | eval  | 12.3k     |
-
-## Model training
-
-The model was trained on a Tesla P100 GPU and 25GB of RAM.
-The script for fine tuning can be found [here](https://github.com/huggingface/transformers/blob/master/examples/run_squad.py)
-
-## Results:
-
-| Metric | # Value   |
-| ------ | --------- |
-| **EM** | **78.80** |
-| **F1** | **82.22** |
-
-### Raw metrics:
-
-```json
-{
-  "exact": 78.80064010780762,
-  "f1": 82.22801347271162,
-  "total": 11873,
-  "HasAns_exact": 78.74493927125506,
-  "HasAns_f1": 85.60951483831069,
-  "HasAns_total": 5928,
-  "NoAns_exact": 78.85618166526493,
-  "NoAns_f1": 78.85618166526493,
-  "NoAns_total": 5945,
-  "best_exact": 78.80064010780762,
-  "best_exact_thresh": 0.0,
-  "best_f1": 82.2280134727116,
-  "best_f1_thresh": 0.0
-}
-```
-
-## Comparison:
-
-| Model                                                                                     | EM        | F1 score  |
-| ----------------------------------------------------------------------------------------- | --------- | --------- |
-| [SpanBert official repo](https://github.com/facebookresearch/SpanBERT#pre-trained-models) | -         | 83.6\*    |
-| [spanbert-finetuned-squadv2](https://huggingface.co/mrm8488/spanbert-finetuned-squadv2)   | **78.80** | **82.22** |
-
-## Model in action
-
-Fast usage with **pipelines**:
-
-```python
-from transformers import pipeline
-
-qa_pipeline = pipeline(
-    "question-answering",
-    model="mrm8488/spanbert-finetuned-squadv2",
-    tokenizer="mrm8488/spanbert-finetuned-squadv2"
-)
-
-qa_pipeline({
-    'context': "Manuel Romero has been working hardly in the repository hugginface/transformers lately",
-    'question': "Who has been working hard for hugginface/transformers lately?"
-
-})
-
-# Output: {'answer': 'Manuel Romero','end': 13,'score': 6.836378586818937e-09, 'start': 0}
-```
-
-> Created by [Manuel Romero/@mrm8488](https://twitter.com/mrm8488)
-
-> Made with <span style="color: #e25555;">&hearts;</span> in Spain