Datasets:

---

DanielPFlorian

/

Transformers-Github-Issues

like 0

[]

[]

[ "Dig into this a little, and it looks like the answer is yes:\r\n\r\n```\r\ntext = \"the book is on the desk.\"\r\ntokenizer = GPT2Tokenizer.from_pretrained('gpt2')\r\nmodel = GPT2LMHeadModel.from_pretrained('gpt2')\r\ninput_ids = torch.tensor(tokenizer.encode(text)).unsqueeze(0) # Batch size 1\r\ntokenize_input = tokenizer.tokenize(text)\r\n#50256 is the token_id for <|endoftext|>\r\ntensor_input = torch.tensor([ [50256] + tokenizer.convert_tokens_to_ids(tokenize_input)])\r\nwith torch.no_grad():\r\n outputs = model(tensor_input, labels=tensor_input)\r\n loss, logits = outputs[:2]\r\nprint(\"a=\", loss*len(tokenize_input))\r\n\r\nlp = 0.0\r\nfor i in range(len(tokenize_input)):\r\n masked_index = i\r\n predicted_score = logits[0, masked_index]\r\n predicted_prob = softmax(np.array(predicted_score))\r\n lp += np.log(predicted_prob[tokenizer.convert_tokens_to_ids([tokenize_input[i]])[0]])\r\n\r\nprint(\"b=\", lp)\r\n```\r\nproduces:\r\na= tensor(32.5258)\r\nb= -32.52579879760742\r\n\r\nWithout prepending [50256]:\r\na= tensor(30.4421)\r\nb= -59.90513229370117\r\n", "@jhlau hello, out of curiosity, why are you multiplying the loss with length of tokenize_input? ", "The loss returned is the average loss (i.e. it is already divided by the length); since I am interested in getting the sentence probability, I need to revert that.", "Instead of hard-coding `50256` better to use:\r\n\r\n```\r\ntokenizer.convert_tokens_to_ids(tokenizer.special_tokens_map['eos_token'])\r\n```\r\n", "You can also use `tokenizer. eos_token_id` ([doc](https://huggingface.co/transformers/main_classes/tokenizer.html#transformers.PreTrainedTokenizer.eos_token_id))", "Hope this question is simple to answer: How can I run the probability calculation entirely on gpu? When I start with numpy in the for loop I am supposed to put my data back on cpu right? I'd like to avoid that as long as possible.", "@jhlau your code does not seem to be correct to me. Refer to [this](https://github.com/simonepri/lm-scorer/blob/master/lm_scorer/models/gpt2.py#L20-L60) or #2026 for a (hopefully) correct implementation.\r\n\r\nYou can also try [`lm-scorer`](https://github.com/simonepri/lm-scorer), a tiny wrapper around `transformers` I wrote that allows you to get sentences probabilities using models that support it (only GPT2 models are implemented at the time of writing).\r\n\r\n> I included this here because this issue is still the first result when searching from GitHub/Google about using transformers' models to get sentences probabilities and I think it might be useful to many.\r\n", "I see. So I should be using self.tokenizer.bos_token and self.tokenizer.eos_token to start and end a sentence properly (instead of the hardcoded 50526 |endoftext| token). I'll give it a run and see if I find much difference.", "> The loss returned is the average loss (i.e. it is already divided by the length); since I am interested in getting the sentence probability, I need to revert that.\r\n\r\nI think this is incorrect. If you multiply by length, you will get higher probability for long sentences even if they make no sense. The average aims to normalize so that the probability is independent of the number of tokens. Does that make sense?", "I understand that of course. I need the full sentence probability because I intend to do other types of normalisation myself (e.g. based unigram frequencies). I am not saying returning the average loss is wrong - I was just clarifying to another user why I multiplied the average loss with length (because I need the full sentence probability).", "> I understand that of course. I need the full sentence probability because I intend to do other types of normalisation myself (e.g. based unigram frequencies). I am not saying returning the average loss is wrong - I was just clarifying to another user why I multiplied the average loss with length (because I need the full sentence probability).\r\n\r\nAAAAh I see. Thanks", "> When computing sentence probability, do we need to prepend the sentence with a dummy start token (e.g. <|endoftext|>) to get the full sentence probability? I am currently using the following implemention (from #473):\r\n> \r\n> ```\r\n> model = GPT2LMHeadModel.from_pretrained(\"gpt2\")\r\n> model.eval()\r\n> tokenizer = GPT2Tokenizer.from_pretrained(\"gpt2\")\r\n> \r\n> def score(sentence):\r\n> tokenize_input = tokenizer.tokenize(sentence)\r\n> tensor_input = torch.tensor([tokenizer.convert_tokens_to_ids(tokenize_input)])\r\n> loss=model(tensor_input, lm_labels=tensor_input)\r\n> return -loss[0] * len(tokenize_input)\r\n> \r\n> a=['there is a book on the desk',\r\n> 'there is a plane on the desk',\r\n> 'there is a book in the desk']\r\n> print([score(i) for i in a])\r\n> ```\r\n> \r\n> With this implementation, say for the sentence \"there is a book on the desk\", is it taking into consideration all the words when computing the full sentence probability (i.e. it's computing P(there|<|endoftext|>) * P(is|there,<|endoftext|>) * ... * P(desk|the,...))? If not, what's the right way to prepend the dummy start token?\r\n\r\n```sent_probability = math.exp(-1.0 * loss * (num_of_word_piece - 1))```\r\n\r\nnum_of_word_piece is the num of encoded ids by the tokenizer.\r\nWhen calculating sent probability, it is appropriate to prepend \"<|endoftext|>\" in front of the sent text. \r\ntokenizer will tokenize the \"<|endoftext|>\" into one token_id, which is tokenizer.eos_token_id.\r\n\r\nThe loss is calculated from the cross-entropy of `shift_logits` and `shift_labels`. By default, cross_entropy gives the mean reduction. And in this case, it is the mean reduction of `num_of_word_piece - 1` word_pieces. \r\n\r\n\r\n\r\n", "For anyone who's interested in **batching** the above process, here's the code:\r\n```python\r\nlines = [tokenizer.eos_token + line for line in lines]\r\n\r\ntok_res = tokenizer.batch_encode_plus(lines, return_tensors='pt', pad_to_max_length=True)\r\ninput_ids = tok_res['input_ids']\r\nattention_mask = tok_res['attention_mask']\r\nlines_len = torch.sum(tok_res['attention_mask'], dim=1)\r\n\r\noutputs = gpt2_model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)\r\nloss, logits = outputs[:2]\r\n\r\nfor line_ind in range(len(lines)):\r\n line_log_prob = 0.0\r\n for token_ind in range(lines_len[line_ind] - 1):\r\n token_prob = F.softmax(logits[line_ind, token_ind], dim=0)\r\n token_id = input_ids[line_ind, token_ind + 1]\r\n line_log_prob += torch.log(token_prob[token_id])\r\n print(f'line_log_prob:{line_log_prob}')\r\n```\r\nA caveat was that `token_type_ids` from `tokenizer.batch_encode_plus` should not be passed to the `gpt2_model` in order to obtain the same results as the line-by-line inference.", "I think there's a mistake in the approach taken here.\r\n\r\nIt seems like the OP concluded that you can score the whole sentence including the first word, by appending a `bos_token` (`<|endoftext|>`) at the beginning of the string.\r\n\r\nFrom what I understand, though, this is probably not a good idea, since it is __unlike training__, as mentioned by @thomwolf in another thread (https://github.com/huggingface/transformers/issues/473#issuecomment-482280934) (emphasis mine):\r\n\r\n> Unfortunately, given __the way the model is trained (without using a token indicating the beginning of a sentence)__, I would say it does not make sense to try to get a score for a sentence with only one word.\r\n\r\nSo, the right way to get a sentence's probability would be \r\n\r\nIn [1]:\r\n```python\r\nimport torch\r\nimport torch.nn.functional as F\r\nimport numpy as np\r\nfrom tqdm import tqdm\r\nfrom transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForMaskedLM\r\nfrom transformers import logging\r\n\r\nmodel_spec = 'gpt2'\r\nmodel = AutoModelForCausalLM.from_pretrained(model_spec)\r\ntokenizer = AutoTokenizer.from_pretrained(model_spec)\r\n\r\ndef score(sentence):\r\n ids = tokenizer(sentence, return_tensors=\"pt\").input_ids[0]\r\n with torch.no_grad():\r\n outs = model(input_ids=ids, labels=ids)\r\n return -outs.loss * (len(ids) - 1) # the first word is not predicted\r\ntext = \"the book is on the table.\"\r\nprint(\"sentence score = \", score(text).item())\r\n```\r\nOut [1]:\r\n\r\n> sentence score = -23.651351928710938\r\n\r\nWe can verify where this score comes from. \r\nIn the spirit of the OP, I'll print each word's logprob and then sum\r\nIn [2]:\r\n```python\r\nids = tokenizer(text, return_tensors=\"pt\").input_ids[0]\r\nwith torch.no_grad():\r\n outs = model(input_ids=ids, labels=ids)\r\nlogits = outs.logits\r\nlogprob = 0.0\r\nprint(\"\", \"id\", \"token\", \"logprob\", sep='\\t')\r\nfor i in range(len(ids)-1):\r\n predicted_logprob = torch.log_softmax(logits[i], dim=-1)\r\n logprob_i = predicted_logprob[ids[i+1]]\r\n print(i, ids[i+1].item(), tokenizer.decode(ids[i+1]), logprob_i.item(), sep='\\t')\r\n logprob += logprob_i\r\nprint(\"total logprob = \", logprob.item(), sep = \"\\t\")\r\n```\r\nOut [2]:\r\n\r\n \tid\ttoken\tlogprob\r\n 0\t1492\tbook\t-7.818896770477295\r\n 1\t318\tis\t-1.9839171171188354\r\n 2\t319\ton\t-4.946821212768555\r\n 3\t262\tthe\t-1.473121166229248\r\n 4\t3084\ttable\t-4.56355619430542\r\n 5\t13\t.\t-2.865037441253662\r\n total logprob = \t-23.651350021362305\r\n\r\n\r\nBasically, I think we shouldn't prepend anything, if it wasn't like that in training, and so we shouldn't include the first word's score when we score a sentence from GPT2. Am I wrong?" ]

[]

[]

[ "This repository is especially useful if you're looking to use a pre-trained transformer of the same architecture than that of BERT, GPT, GPT-2, XLM, XLNet or TransfoXL.\r\n\r\nIf you're looking at using a simple transformer of your own making, how about using the newly released [torch.nn.Transformer](https://pytorch.org/docs/stable/nn.html?highlight=transformer#torch.nn.Transformer)?", "Thanks! But since I use pytorch v1.0.1 with cuda8.0, it's not convenient to upgrade to v1.2.0 and use torch.nn.Transformer.", "If you're looking to use an existing architecture and modifying a few things (like the number of layers, or embedding size), you can always do so by specifying these values in a config file.\r\n\r\nAs you were saying you would like to use a one-layer transformer on top of some backbone model, you could create a config and specify `num_hidden_layers = 1` and `num_attention_heads = 1` to have a very simple one-layer single-headed transformer.\r\n\r\nThe documentation for the `BertConfig` file can be found [here](https://huggingface.co/pytorch-transformers/model_doc/bert.html#bertconfig). Each model has its own configuration file.\r\n\r\nIf you're looking to build a Transformer from scratch, something you could do is re-use some of our model's logic to create your own transformer. For example if you want to use our Attention for GPT-2, you could always import it like this:\r\n\r\n```python\r\nfrom pytorch_transformers.modeling_gpt2 import Attention\r\n```\r\n\r\nYou can then re-use it as a part of your code, building your own Transformer architecture.\r\n\r\nHope that helps.", "Thanks for your patience! I will try what you told me. It really helps me a lot!\r\nThanks again." ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "You're right, it should! Thanks for pointing it out!" ]

[]

[]

[]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=h1) Report\n> Merging [#1004](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/e768f2322abd2a2f60a3a6d64a6a94c2d957fe89?src=pr&el=desc) will **decrease** coverage by `0.39%`.\n> The diff coverage is `20.75%`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #1004 +/- ##\n=========================================\n- Coverage 81.16% 80.77% -0.4% \n=========================================\n Files 57 57 \n Lines 8039 8092 +53 \n=========================================\n+ Hits 6525 6536 +11 \n- Misses 1514 1556 +42\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/modeling\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfeGxuZXQucHk=) | `74.52% <16%> (-2.9%)` | :arrow_down: |\n| [pytorch\\_transformers/modeling\\_roberta.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfcm9iZXJ0YS5weQ==) | `64.96% <25%> (-10.27%)` | :arrow_down: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=footer). Last update [e768f23...8960988](https://codecov.io/gh/huggingface/pytorch-transformers/pull/1004?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "run_multiple_choice.py and utils_multiple_choice.py with roberta and xlnet have been tested on RACE, SWAG, ARC Challenge.\r\n\r\n1. roebrta large: RACE dev 0.84, SWAG dev 0.88, ARC Challenge 0.65\r\n2. xlnet large: RACE dev 0.81, ARC challenge 0.63", "This looks really great. Thanks for updating and testing this script @erenup\r\n\r\nA few questions and remarks:\r\n- do we still need to keep `run_swag` now that there is a `run_multiple_choice`?\r\n- there should be docstrings for the new classes, can you add them, taking inspiration from the other model's docstring?\r\n- do you want to add an example on how to use the script in the doc, for instance you can add a section [here](https://github.com/huggingface/pytorch-transformers/blob/master/docs/source/examples.rst) with the commands you used to run the script and indicate the results you got with this commands for each models (good for later reference)", "@thomwolf Thank you!\r\n\r\n- SWAG dataset has been considered as one of the multiple-choice setting datasets and has a corresponding data processor in `utils_multiple_choice.py`. So I think `run_swag` will not be needed. It's also easy to add a new data processor for other multiple-choice datasets in `utils_multiple_choice.py`. \r\n- Docstrings will be added soon.\r\n- Sure, I'd like to add an example on how to use `run_multiple_choice`.", "Hi @thomwolf, Docstrings of the multiple-choice models have been added. An example of run_multiple_choice.py has been added in the README of examples. Thank you.", "Ok this looks clean and almost ready to merge, just added a quick comment to fix in the code (order of calls to step).\r\n\r\nA few things for the merge as we have re-organized the examples folder, can you:\r\n- move `run_swag` to `examples/contrib`\r\n- move your `run_multiple_choice` scripts to the main `examples` folder? ", "Hi @thomwolf. I have moved run_multiple_choice.py and utils_multiple_choice.py to examples, run_swag.py to example/contrib and scheduler.step after optimizer.step. I have also done a test of the example/contrib/run_swag.py on current pytorch-transformers. run_swag.py can get a normal result of dev 0.809 of bert-base-uncased model. Thank you.", "Awesome, thanks a lot for this contribution @erenup 🔥\r\nMerging now", "> run_multiple_choice.py and utils_multiple_choice.py with roberta and xlnet have been tested on RACE, SWAG, ARC Challenge.\r\n> \r\n> 1. roebrta large: RACE dev 0.84, SWAG dev 0.88, ARC Challenge 0.65\r\n> 2. xlnet large: RACE dev 0.81, ARC challenge 0.63\r\n\r\nCould you share your run -configuration on RACE and ARC dataset?\r\nOn SWAG, I could got 0.82 folllowing the suggested setting. \r\nTo the RACE,the best performance is 0.62. (maxLength 256, lr 1e-6, cal_gradient 8 etc). The loss is easy over-fittting. \r\nBut to the ARC. In the process of data. It show an error like this. \r\n\r\n\r\nline 638, in _create_examples\r\n contexts=[options[0][\"para\"].replace(\"_\", \"\"), options[1][\"para\"].replace(\"_\", \"\"),\r\n\r\nKeyError: 'para'\r\n(I have check the raw_data. the options item has no 'para' . \r\nCould you give me a hit how to convert the dataset of ARC? \r\nThank you!", "Hi, @PantherYan \r\nFor RACE, I checked my parameters. I run RACE with 4 P40 GPUs with roberta large: \r\n``Namespace(adam_epsilon=1e-08, cache_dir='', config_name='', data_dir='data/RACE/', device=device(type='cuda'), do_eval=True, do_lower_case=True, do_test=False, do_train=True, eval_all_checkpoints=False, evaluate_during_training=False, fp16=False, fp16_opt_level='O1', gradient_accumulation_steps=3, learning_rate=1e-05, local_rank=-1, logging_steps=50, max_grad_norm=1.0, max_seq_length=384, max_steps=-1, model_name_or_path='roberta-large', model_type='roberta', n_gpu=4, no_cuda=False, num_train_epochs=5.0, output_dir='models_bert/race_large', overwrite_cache=False, overwrite_output_dir=False, per_gpu_eval_batch_size=2, per_gpu_train_batch_size=2, save_steps=2000, seed=42, server_ip='', server_port='', task_name='race', tokenizer_name='', train_batch_size=8, warmup_steps=0, weight_decay=0.0)``, you can have a try. \r\n\r\nFor ARC, you need to ask ai2 for the retrieved text named `para` for the corresponding task of ARC Challenge, ARC Easy, OpenBookqa. you can find more details in [this page](https://leaderboard.allenai.org/arc/submission/blcotvl7rrltlue6bsv0)", "\r\n\r\n\r\n\r\n> Hi, @PantherYan\r\n> For RACE, I checked my parameters. I run RACE with 4 P40 GPUs with roberta large:\r\n> `Namespace(adam_epsilon=1e-08, cache_dir='', config_name='', data_dir='data/RACE/', device=device(type='cuda'), do_eval=True, do_lower_case=True, do_test=False, do_train=True, eval_all_checkpoints=False, evaluate_during_training=False, fp16=False, fp16_opt_level='O1', gradient_accumulation_steps=3, learning_rate=1e-05, local_rank=-1, logging_steps=50, max_grad_norm=1.0, max_seq_length=384, max_steps=-1, model_name_or_path='roberta-large', model_type='roberta', n_gpu=4, no_cuda=False, num_train_epochs=5.0, output_dir='models_bert/race_large', overwrite_cache=False, overwrite_output_dir=False, per_gpu_eval_batch_size=2, per_gpu_train_batch_size=2, save_steps=2000, seed=42, server_ip='', server_port='', task_name='race', tokenizer_name='', train_batch_size=8, warmup_steps=0, weight_decay=0.0)`, you can have a try.\r\n> \r\n> For ARC, you need to ask ai2 for the retrieved text named `para` for the corresponding task of ARC Challenge, ARC Easy, OpenBookqa. you can find more details in [this page](https://leaderboard.allenai.org/arc/submission/blcotvl7rrltlue6bsv0)\r\n\r\nThanks a lot for your prompt reply! Appreciate!\r\nIt seems is a TensorFlow-version setting. I will try on the PyTorch. I only have 4 2080Ti (11GB), is the max-lenght batch-size or model size(like roberta-base) influence the performance significantly? I will run a comparison and post it out. \r\n\r\nFor the ARC. Thanks, I have write a email to AI2 for the help.\r\n\r\nThank you!", "> Hi, @PantherYan\r\n> For RACE, I checked my parameters. I run RACE with 4 P40 GPUs with roberta large:\r\n> `Namespace(adam_epsilon=1e-08, cache_dir='', config_name='', data_dir='data/RACE/', device=device(type='cuda'), do_eval=True, do_lower_case=True, do_test=False, do_train=True, eval_all_checkpoints=False, evaluate_during_training=False, fp16=False, fp16_opt_level='O1', gradient_accumulation_steps=3, learning_rate=1e-05, local_rank=-1, logging_steps=50, max_grad_norm=1.0, max_seq_length=384, max_steps=-1, model_name_or_path='roberta-large', model_type='roberta', n_gpu=4, no_cuda=False, num_train_epochs=5.0, output_dir='models_bert/race_large', overwrite_cache=False, overwrite_output_dir=False, per_gpu_eval_batch_size=2, per_gpu_train_batch_size=2, save_steps=2000, seed=42, server_ip='', server_port='', task_name='race', tokenizer_name='', train_batch_size=8, warmup_steps=0, weight_decay=0.0)`, you can have a try.\r\n\r\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\nThank you for your sharing your training configuration to guid us.\r\n\r\nI used the pytorch backend, and strictly following your configure setting, except roberta-base and the batch_size= 2(per_gpu_train_batch_size)*4(gpu_num) , which you set [ train_batch_size=8]. In other words, you setting batch_size = 8, and my setting batch_size =2. \r\n\r\n>>>>>-------- Here is my acc on test dataset: 69.36, loss 0.8339. \r\n>>>>> Is the batch_size inflenced my test perfermance? or the loss or convergence enough?\r\n\r\ndata/nlp/MCQA/RACE/cached_test_roberta-base_384_race\r\n11/01/2019 01:49:55 - INFO - __main__ - ***** Running evaluation *****\r\n11/01/2019 01:49:55 - INFO - __main__ - Num examples = 4934\r\n11/01/2019 01:49:55 - INFO - __main__ - Batch size = 8\r\n11/01/2019 01:53:38 - INFO - __main__ - ***** Eval results is test:True *****\r\n11/01/2019 01:53:38 - INFO - __main__ - eval_acc = 0.6945683015808675\r\n11/01/2019 01:53:38 - INFO - __main__ - eval_loss = 0.8386425418383782\r\n11/01/2019 01:53:38 - INFO - __main__ - best steps of eval acc is the following checkpoints: 13000\r\n\r\n>>>>>> I give up my training logs\r\n\r\n11/01/2019 00:31:22 - INFO - transformers.configuration_utils - Configuration saved in models_race/roberta-base/checkpoint-12000/config.json\r\n11/01/2019 00:31:23 - INFO - transformers.modeling_utils - Model weights saved in models_race/roberta-base/checkpoint-12000/pytorch_model.bin\r\n11/01/2019 00:31:23 - INFO - __main__ - Saving model checkpoint to models_race/roberta-base/checkpoint-12000\r\n11/01/2019 01:12:20 - INFO - __main__ - Loading features from cached file /workspace/data/nlp/MCQA/RACE/cached_dev_roberta-base_384_race\r\n11/01/2019 01:12:22 - INFO - __main__ - ***** Running evaluation *****\r\n11/01/2019 01:12:22 - INFO - __main__ - Num examples = 4887\r\n11/01/2019 01:12:22 - INFO - __main__ - Batch size = 8\r\n11/01/2019 01:16:00 - INFO - __main__ - ***** Eval results is test:False *****\r\n11/01/2019 01:16:00 - INFO - __main__ - eval_acc = 0.7086146920401064\r\n11/01/2019 01:16:00 - INFO - __main__ - eval_loss = 0.8062708838591306\r\n11/01/2019 01:16:00 - INFO - __main__ - Loading features from cached file /workspace/data/nlp/MCQA/RACE/cached_test_roberta-base_384_race\r\n11/01/2019 01:16:02 - INFO - __main__ - ***** Running evaluation *****\r\n11/01/2019 01:16:02 - INFO - __main__ - Num examples = 4934\r\n11/01/2019 01:16:02 - INFO - __main__ - Batch size = 8\r\n11/01/2019 01:19:42 - INFO - __main__ - ***** Eval results is test:True *****\r\n11/01/2019 01:19:42 - INFO - __main__ - eval_acc = 0.6935549250101337\r\n11/01/2019 01:19:42 - INFO - __main__ - eval_loss = 0.8339384843925892\r\n11/01/2019 01:19:42 - INFO - __main__ - test acc: 0.6935549250101337, loss: 0.8339384843925892, global steps: 13000\r\n11/01/2019 01:19:42 - INFO - __main__ - Average loss: 0.6908835964873433 at global step: 13000\r\n11/01/2019 01:19:42 - INFO - transformers.configuration_utils - Configuration saved in models_race/roberta-base/checkpoint-13000/config.json\r\n11/01/2019 01:19:43 - INFO - transformers.modeling_utils - Model weights saved in models_race/roberta-base/checkpoint-13000/pytorch_model.bin\r\n11/01/2019 01:19:43 - INFO - __main__ - Saving model checkpoint to models_race/roberta-base/checkpoint-13000\r\n11/01/2019 01:49:44 - INFO - __main__ - global_step = 13730, average loss = 0.8482715931345925\r\n\r\n\r\n>>>>>> \r\n@erenup Could I learn your training loss and test loss after 5 epochs? \r\n I have runed several times, the accuray still around 70%s. Is it influencd by the roberta-large model or batch_size ? \r\nLooking forward your reply.\r\nThank you!\r\n\r\n\r\n\r\n\r\n", "Hi @PantherYan I did not run race dataset with roberta base. In my experience, I thought the results of RACE with roberta base make sense, Since Bert large can only reach about 71~72. You can check the [leaderboard ](http://www.qizhexie.com/data/RACE_leaderboard.html) for reference.", "> Hi @PantherYan I did not run race dataset with roberta base. In my experience, I thought the results of RACE with roberta base make sense, Since Bert large can only reach about 71~72. You can check the [leaderboard ](http://www.qizhexie.com/data/RACE_leaderboard.html) for reference.\r\n\r\n@erenup \r\n I appreciate for your quick reply. \r\nThank you! \r\n", "@erenup \r\nYou are nice!", "> \r\n> \r\n> > run_multiple_choice.py and utils_multiple_choice.py with roberta and xlnet have been tested on RACE, SWAG, ARC Challenge.\r\n> > \r\n> > 1. roebrta large: RACE dev 0.84, SWAG dev 0.88, ARC Challenge 0.65\r\n> > 2. xlnet large: RACE dev 0.81, ARC challenge 0.63\r\n> \r\n> Could you share your run -configuration on RACE and ARC dataset?\r\n> On SWAG, I could got 0.82 folllowing the suggested setting.\r\n> To the RACE,the best performance is 0.62. (maxLength 256, lr 1e-6, cal_gradient 8 etc). The loss is easy over-fittting.\r\n> But to the ARC. In the process of data. It show an error like this.\r\n> \r\n> line 638, in _create_examples contexts=[options[0][\"para\"].replace(\"_\", \"\"), options[1][\"para\"].replace(\"_\", \"\"),\r\n> \r\n> KeyError: 'para'\r\n> (I have check the raw_data. the options item has no 'para' .\r\n> Could you give me a hit how to convert the dataset of ARC?\r\n> Thank you!\r\n\r\nI also met the problem of missing item \"para\", have you got some methods for converting raw corpus?\r\nThank you! ", "Please see PatherYan's comments and [mine](https://github.com/huggingface/transformers/pull/1004#issuecomment-546900263)" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "I also saw #468. It will be probably added soon.\r\nBut, If someone informs new information about this, I'll thank for that.", "Passing them like so works for me:\r\n\r\n`GPT2Tokenizer.from_pretrained(args.model_name, unk_token=\"<|endoftext|>\")`\r\n\r\nYou can all pass a list to `tokenizer.add_tokens`, then call `model.resize_token_embeddings(len(tokenizer))`.", "@aburkard Thank you so much!!!! I'll try it.\r\n", "Hi, in GPT-2 there wasn't the option at first but we've added it down the line. It is available if you compile this repo from source from the master branch, or you can wait for the version 1.1 which should drop sometimes this week. In this version you're able to add special tokens to GPT-2.", "Release 1.1.0 is here :-)", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Did you pre-train your model while keeping all the line returns or did you remove them? You can keep them during the training so that the model learns to predict them.\r\n\r\nIf you remove them during training and wish to apply them later on, I guess you can always just create the long string of lyrics and split them with line returns.", "Actually, I remove them during. Do you think keeping all the line returns during training is a better way? I mean input the whole song (use encode(text) method) instead of splitting each line into echo tokens -> ids . \r\n\r\nBy the way, Can I input POS of text into the model? Is it necessary?", "I think keeping the line returns during your training is a good idea. The model is very likely to learn their position and frequency.\r\n\r\nYou can input the `position_ids` in your forward, but it is not necessary. If no position information is provided, the model will create it on its own.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "Sure, one way you could go about it would be to create a new class similar to `BertForSequenceClassification` and implement your own custom final classifier.\r\n\r\nThe lib is pretty modular so you can usually subclass/extend what you need.", "You can also replace `self.classifier` with your own model.\r\n\r\n```\r\nmodel = BertForSequenceClassification.from_pretrained(\"bert-base-multilingual-cased\")\r\nmodel.classifier = new_classifier\r\n```\r\nwhere `new_classifier` is any pytorch model that you want.", "ok... Thanks a lot. I will try it.", "@dhpollack Maybe its a little unrelated to this issue, but still I'll state the situation. I am using the BERT model to classify sentences on two different datasets. It is working fine on the first dataset but not on the second. Is it possible that it is because BERT has saved its weights according to the first dataset and is loading that for the second one also and thus not performing well. For example. the model configuration looks like this for BOTH the datasets. I suspect whether it should have the same vocabulary size.\r\n\r\n```\r\nINFO:pytorch_pretrained_bert.modeling:Model config {\r\n \"attention_probs_dropout_prob\": 0.1,\r\n \"hidden_act\": \"gelu\",\r\n \"hidden_dropout_prob\": 0.1,\r\n \"hidden_size\": 768,\r\n \"initializer_range\": 0.02,\r\n \"intermediate_size\": 3072,\r\n \"max_position_embeddings\": 512,\r\n \"num_attention_heads\": 12,\r\n \"num_hidden_layers\": 12,\r\n \"type_vocab_size\": 2,\r\n \"vocab_size\": 28996\r\n}\r\n```\r\n\r\nIt shows the same message on both the datasets\r\n```\r\nINFO:pytorch_pretrained_bert.tokenization:loading vocabulary file https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased-vocab.txt from cache at /home/pytorch/.pytorch_pretrained_bert/5e8a2b4893d13790ed4150ca1906be5f7a03d6c4ddf62296c383f6db42814db2.e13dbb970cb325137104fb2e5f36fe865f27746c6b526f6352861b1980eb80b1\r\nINFO:pytorch_pretrained_bert.modeling:loading archive file https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased.tar.gz from cache at cache/a803ce83ca27fecf74c355673c434e51c265fb8a3e0e57ac62a80e38ba98d384.681017f415dfb33ec8d0e04fe51a619f3f01532ecea04edbfd48c5d160550d9c\r\nINFO:pytorch_pretrained_bert.modeling:extracting archive file cache/a803ce83ca27fecf74c355673c434e51c265fb8a3e0e57ac62a80e38ba98d384.681017f415dfb33ec8d0e04fe51a619f3f01532ecea04edbfd48c5d160550d9c to temp dir /tmp/tmpgummmons\r\n```\r\n\r\nHow can effectively use BERT for two different datasets?", "@shivin9 this is definitely not related to the classifier layer. Also, it's a little unclear what you what to do. Are you training on one dataset and then doing inference on another? If that's the case, then you do something like\r\n```\r\n# training\r\nmodel = BertForSequenceClassification.from_pretrained(\"bert-base-cased\")\r\n...\r\nmodel.save_pretrained(\"/tmp/trained_model_dir\")\r\n\r\n# inference\r\nmodel = BertForSequenceClassification.from_pretrained(\"/tmp/trained_model_dir\")\r\n```\r\n\r\nBut as I said, it's unclear. If you are training on both datasets and getting good results on one but not the other than it probably has to do with your preprocessing. Good luck solving your problem.", "Hi, I have a related question. I am experimenting with BERT for classification task. When I use `` `BertForSequenceClassification.from_pretrained ```, I can get 100% accuracy for a small data set. But if I have a customized classification head as shown below which is almost similar to ` `BertForSequenceClassification`` I get bad accuracy.\r\n\r\nhere is my customized classification head:\r\n```\r\nclass Bertclfhead(nn.Module):\r\n def __init__(self, config, adapt_args, bertmodel):\r\n super().__init__()\r\n self.num_labels = adapt_args.num_classes\r\n self.config = config\r\n self.bert = bertmodel\r\n self.dropout = nn.Dropout(config['hidden_dropout_prob'])\r\n self.classifier = nn.Linear(config['hidden_size'], adapt_args.num_classes)\r\n\r\n def forward(self, input_ids, token_type_ids=None, attention_mask=None, labels=None, position_ids=None, head_mask=None):\r\n outputs = self.bert(input_ids, position_ids=position_ids, token_type_ids=token_type_ids,\r\n attention_mask=attention_mask, head_mask=head_mask)\r\n \r\n pooled_output = outputs[1] # see note below\r\n\r\n pooled_output = self.dropout(pooled_output)\r\n logits = self.classifier(pooled_output)\r\n\r\n outputs = (logits,) + outputs[2:] # add hidden states and attention if they are here\r\n\r\n if labels is not None:\r\n if self.num_labels == 1:\r\n # We are doing regression\r\n loss_fct = MSELoss()\r\n loss = loss_fct(logits.view(-1), labels.view(-1))\r\n else:\r\n loss_fct = CrossEntropyLoss()\r\n loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))\r\n outputs = (loss,) + outputs\r\n\r\n return outputs # (loss), logits, (hidden_states), (attentions)\r\n```\r\nand I initialize my model like this:\r\n```\r\nmodel = Bertclfhead(bertconfig, adapt_args, BertModel.from_pretrained('bert-base-uncased'))\r\n```\r\nam I missing something?", "@dhpollack I am first training on `x` and then inferring on `x`. Then I'm training on `y` and inferring on `y`.\r\n\r\nI am also trying to put a BiLSTM on top of BERT but it seems that BERT doesn't output the vectors in the required format i.e. `(#batches, seq_len, input_dim)`. Do you have any idea how it can be solved? Right now BERT is just outputting a (BATCH_SIZE, 768) sized vector. 768 being the size of hidden layer.", "@shivin9 you should read the docs. You want to output of the hidden layers but I think an lstm on top of Bert is overkill. What you are getting now is the output of the pooling layer.\r\n\r\nAlso you should close this issue since it's clear this is not an issue with the library. ", "Yeah sure. thanks for the help.", "@mehdimashayekhi Do you solve it? Ihave the same question! By directly use `BertForSequenceClassification` and custom a classification similar to `BertForSequenceClassification` , the results totally different.", "> \r\n> \r\n> @dhpollack I am first training on `x` and then inferring on `x`. Then I'm training on `y` and inferring on `y`.\r\n> \r\n> I am also trying to put a BiLSTM on top of BERT but it seems that BERT doesn't output the vectors in the required format i.e. `(#batches, seq_len, input_dim)`. Do you have any idea how it can be solved? Right now BERT is just outputting a (BATCH_SIZE, 768) sized vector. 768 being the size of hidden layer.\r\n\r\nWere you able to resolve this?", "Re dhpollack's August 12 comment. Maybe something got changed between then and now but I found you also have to set the model's number of labels to get that to work. \r\n\r\n```\r\nmodel.classifier = torch.nn.Linear(768, 8)\r\nmodel.num_labels = 8\r\n```" ]

[]

[]

[ "Hi!\r\n\r\nWhen you're talking about extracting the embeddings using a pre-trained model, what are you talking about exactly?\r\n\r\nAre you talking about using the tokenizer like :\r\n```python\r\ntokenizer.encode(text)\r\n```\r\n which returns the word ids?\r\n\r\nAre you talking about using the embedding layer inside the model like :\r\n```python\r\nmodel.embeddings.word_embeddings(value)\r\n```\r\n\r\nOr are you talking about the encoded representation returned by the transformer after a forward pass like\r\n```\r\nmodel(value)\r\n``` \r\n\r\nFor the first one, using the tokenizer, you are simply using a python dictionary so it will run on CPU. For the next two, it depends on where you put your model. If you simply loaded it, it will be on CPU, but if you put in on a specific device using `model.to(device)`, then it will be on the specified device.", "Yes, thank you. I messed up the model. ", " summarizer_cnn = pipeline('summarization')\r\nsummary_cnn = summarizer_cnn(sum_data)\r\n\r\n#where sum_data is a textual data of 1000 length.\r\n\r\nWhen I load a pretrained model and use it to extract summary, the model is running on a CPU instead of CPU and that is the reason bert is very slow. how to run the pretrained model and script on GPU." ]

[]

[]

[ "Hi!\r\n\r\nIn the forward pass of the BertSelfAttention model you’re getting the hidden state of the previous layer which is of size `(batch_size, sequence_length, 768)` (768 being the embedding dimension).\r\n\r\nThe first step of the attention is to obtain the `mixed_query_layer`, `mixed_key_layer` as well as the `mixed_value_layer`, which are all of size `(batch_size, sequence_length, 768)`.\r\n\r\nThe 768 here isn’t actually directly related to the embedding size, but it is related to the number of heads (12) and the dimension of the query/key/value (64) vectors (12 * 64 = 768).\r\n\r\nWhat we’re doing in the `transpose_for_scores` function is that we are reshaping our query/key/value layers so that they are of shape `(batch_size, number_of_heads, sequence_length, qkv_dimension)` -> `(batch_size, 12, sequence_length, 64)`.\r\n\r\nIt is then easy to compute the attention scores and apply the attention mask.\r\n\r\nIs that helpful?", "Thanks for the answer! I think I understand the code, but if you take a look at the [equation](https://imgur.com/a/WdqVG3J) from the [transformer paper](https://arxiv.org/pdf/1706.03762.pdf), here Q = `mixed_query_layer `, K = `mixed_key_layer ` and V = `mixed_value_layer`, and each of them are being multiplied by a different weight W_i^Q, W_i^K and W_i^V for each attention head i. \r\n\r\nI don't see any equivalent to these weights on your code, instead as you say you just reshape Q, K and V, do the self-attention on each Q_i, K_i, V_i and then concat and multiply by W^0 (`BertSelfOutput`). I have yet to look at the transformer code, so maybe the notation in the paper is misleading and they actually did exactly what BERT is doing?", "I believe that our implementation respects the formula in the paper. It is indeed Google's own implementation for BERT, you can check out their code and how they computed the attention scores here:\r\n\r\nResizing the [query layer](https://github.com/google-research/bert/blob/master/modeling.py#L690-L692)\r\nResizing the [key layer](https://github.com/google-research/bert/blob/master/modeling.py#L695-L696)\r\nResizing the [values layer](https://github.com/google-research/bert/blob/master/modeling.py#L727-L729)\r\n\r\nOur BERT code is very similar to the original TF code to make the import/export of weights easy, so you would find the same ideas in both implementations.", "Yes, I checked the code of the Transformer and you are right, the Multi-Head Attention is implemented in the exact same way as BERT (both original and this repo, of course). The Transformer paper explains a slightly different Multi-Head Attention, at least to my understanding, and it actually looks more powerful. Anyway, closing this issue as my doubt has been solved. Thanks again for your answers!", "Glad I could help!", "I had the same question, so I followed both steps in the implementation and paper. Since BertSelfAttention computes all heads in parallel, they look equivalent.\r\n\r\n\r\n", "Hi, I may have overlooked something, but while reading through the code for the attention mechanism in BERT, I couldn't find the multiplication of a `W_output` with the concatenation of the heads' output, as described in the original paper. Have you merged this weight with the `W_value`? or with the next FF layer (since these are two sequential linear multiplication)?", "That multiplication is implemented here.\r\n\r\nhttps://github.com/huggingface/transformers/blob/960807f62e53676723ab8281019219864ef3db4d/src/transformers/models/bert/modeling_bert.py#L386" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "More precisely it hangs on line 280:\r\n\r\n if args.local_rank == 0:\r\nHERE ---> torch.distributed.barrier() # Make sure only the first process in distributed training process the dataset, and the others will use the cache\r\n\r\n # Convert to Tensors and build dataset\r\n all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\r\n all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)\r\n", "What exact command are you using to run the script?", "I also encountered similar problems when I run the example of squad. And my pytorch and Python environment are consistent with you.\r\nMy running script is:\r\n\r\n```\r\npython -m torch.distributed.launch --nproc_per_node=4 ./examples/run_squad.py \\\r\n --model_type bert \\\r\n --model_name_or_path bert-large-uncased-whole-word-masking \\\r\n --do_eval \\\r\n --do_lower_case \\\r\n --train_file $SQUAD_DIR/train-v1.1.json \\\r\n --predict_file $SQUAD_DIR/dev-v1.1.json \\\r\n --learning_rate 3e-5 \\\r\n --num_train_epochs 2 \\\r\n --max_seq_length 384 \\\r\n --doc_stride 128 \\\r\n --output_dir ../models/wwm_uncased_finetuned_squad/ \\\r\n --per_gpu_eval_batch_size=1 \\\r\n --per_gpu_train_batch_size=1 \\\r\n --save_steps 10000\r\n```\r\nPlease Help！\r\n\r\nWhat is more， training is OK！But the evaluation has the above problem", "> I also encountered similar problems when I run the example of squad. And my pytorch and Python environment are consistent with you.\r\n> My running script is:\r\n> \r\n> ```\r\n> python -m torch.distributed.launch --nproc_per_node=4 ./examples/run_squad.py \\\r\n> --model_type bert \\\r\n> --model_name_or_path bert-large-uncased-whole-word-masking \\\r\n> --do_eval \\\r\n> --do_lower_case \\\r\n> --train_file $SQUAD_DIR/train-v1.1.json \\\r\n> --predict_file $SQUAD_DIR/dev-v1.1.json \\\r\n> --learning_rate 3e-5 \\\r\n> --num_train_epochs 2 \\\r\n> --max_seq_length 384 \\\r\n> --doc_stride 128 \\\r\n> --output_dir ../models/wwm_uncased_finetuned_squad/ \\\r\n> --per_gpu_eval_batch_size=1 \\\r\n> --per_gpu_train_batch_size=1 \\\r\n> --save_steps 10000\r\n> ```\r\n> \r\n> Please Help！\r\n\r\n\r\n\r\n> What exact command are you using to run the script?\r\n\r\nI think I have encountered a similar problem, I have already reported my running script.", "This is what I was running.\r\n\r\npython -m torch.distributed.launch --nproc_per_node 4 ./examples/run_glue.py \\\r\n --model_type bert \\\r\n --model_name_or_path bert-base-uncased \\\r\n --task_name MRPC \\\r\n --do_train \\\r\n --do_eval \\\r\n --do_lower_case \\\r\n --data_dir $GLUE_DIR/MRPC/ \\\r\n --max_seq_length 128 \\\r\n --per_gpu_eval_batch_size=8 \\\r\n --per_gpu_train_batch_size=8 \\\r\n --learning_rate 2e-5 \\\r\n --num_train_epochs 3.0 \\\r\n --output_dir /tmp/mrpc_output/ \\\r\n --overwrite_output_dir \\\r\n --overwrite_cache \\\r\n\r\nThe issue seems to be that the processes other than main never enter the evaluation section and the main process waits on a barrier for them to come join the party.\r\n\r\nI managed to fix the issue with this change, I can push a PR if you're like. Squad seems to have the same problem.\r\n\r\n```diff \r\n # Evaluation\r\n results = {}\r\n- if args.do_eval and args.local_rank in [-1, 0]:\r\n+ if args.do_eval:\r\n+ if args.local_rank != -1:\r\n+ torch.distributed.barrier()\r\n```", "We should not allow running the example script in distributed mode when only evaluation is done since the evaluation can only be done on a single GPU anyway (the reason is that the metrics cannot be computed in a distributed setting as some of the GLUE metrics are not additive with regards to the size of the evaluation dataset).\r\n\r\nIn your case, the answer is just to not run the script in distributed mode when you only do evaluation.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "Hi, there is no XLA/TPU support with the current library. Maybe in a future release!" ]

[]

[]

[ "Great, thanks !" ]

[]

[]

[ "Hi! Yes, I think your understanding is correct. Your setup seems fine to me!", "regarding the token_type_ids, shall we mark [PAD] token as 0 or 1? [PAD] by default does not belong to any of the two input sequences. Therefore it is ambiguous to determine whether it should be 0 or 1.", "The default padding value for `token_type_ids` is 0 which is defined by `tokenizer._pad_token_type_id`. You can specify it to 1 by `tokenizer._pad_token_type_id=1`." ]

[]

[]

[ "Hi! GPT-2 does not have an unknown token because of its byte-level BPE. This is a warning so it should not affect your code, but maybe we should do something about this warning for models that do not have unknown tokens. cc @thomwolf.", "However, it seems that having a defined _unk_ symbol is necessary to run other methods, like \r\n`def add_tokens(self, new_tokens)`\r\nIf the unk_token is set to None, add_special_tokens() breaks calling add_tokens() because the None type that is returned from convert_tokens_to_ids.", "Yes, it's already on master if you compile from source and will be in the next (1.1) release (which will likely be released next week).", "Thank you very much! " ]

[]

[]

[ "Indeed, there seems to be a problem here. I'll look into it.", "Thanks for the report, the error was in the docstring, we cannot use `-1` as the index for the last token, it has to be the positive index of the CLS token (in the case of the example `9`.", "The fix seems to have led to other issues. I'm getting the error: \r\n\r\n----> 1 outputs = model(input_ids, mc_token_ids)\r\n 2 lm_prediction_scores, mc_prediction_scores = outputs[:2]\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)\r\n 545 result = self._slow_forward(*input, **kwargs)\r\n 546 else:\r\n--> 547 result = self.forward(*input, **kwargs)\r\n 548 for hook in self._forward_hooks.values():\r\n 549 hook_result = hook(self, input, result)\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/pytorch_transformers/modeling_gpt2.py in forward(self, input_ids, mc_token_ids, lm_labels, mc_labels, token_type_ids, position_ids, past, head_mask)\r\n 710 position_ids=None, past=None, head_mask=None):\r\n 711 transformer_outputs = self.transformer(input_ids, position_ids=position_ids, token_type_ids=token_type_ids,\r\n--> 712 past=past, head_mask=head_mask)\r\n 713 hidden_states = transformer_outputs[0]\r\n 714 \r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)\r\n 545 result = self._slow_forward(*input, **kwargs)\r\n 546 else:\r\n--> 547 result = self.forward(*input, **kwargs)\r\n 548 for hook in self._forward_hooks.values():\r\n 549 hook_result = hook(self, input, result)\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/pytorch_transformers/modeling_gpt2.py in forward(self, input_ids, position_ids, token_type_ids, past, head_mask)\r\n 493 position_ids = position_ids.view(-1, position_ids.size(-1))\r\n 494 \r\n--> 495 inputs_embeds = self.wte(input_ids)\r\n 496 position_embeds = self.wpe(position_ids)\r\n 497 if token_type_ids is not None:\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)\r\n 545 result = self._slow_forward(*input, **kwargs)\r\n 546 else:\r\n--> 547 result = self.forward(*input, **kwargs)\r\n 548 for hook in self._forward_hooks.values():\r\n 549 hook_result = hook(self, input, result)\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/torch/nn/modules/sparse.py in forward(self, input)\r\n 112 return F.embedding(\r\n 113 input, self.weight, self.padding_idx, self.max_norm,\r\n--> 114 self.norm_type, self.scale_grad_by_freq, self.sparse)\r\n 115 \r\n 116 def extra_repr(self):\r\n\r\n/opt/anaconda/anaconda3/envs/huggingface_env/lib/python3.7/site-packages/torch/nn/functional.py in embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)\r\n 1465 # remove once script supports set_grad_enabled\r\n 1466 _no_grad_embedding_renorm_(weight, input, max_norm, norm_type)\r\n-> 1467 return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse)\r\n 1468 \r\n 1469 \r\n\r\nRuntimeError: index out of range: Tried to access index 50257 out of table with 50256 rows. at /pytorch/aten/src/TH/generic/THTensorEvenMoreMath.cpp:237", "What exact series of command did you use to get this error (maybe open a new issue with more details)" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "This is simply a warning, it won't change your results. I think it's important we keep it for people that are unaware that sequences have a max length of 512, so there's currently no option to suppress that warning.", "Just a note: if you want to avoid displaying the warning, you can raise the level of the logger with `logging.getLogger(\"pytorch_pretrained_bert.tokenization\").setLevel(logging.ERROR)`.\r\n\r\nWe did that in the Transfer Learning tutorial code (see [here](https://github.com/huggingface/naacl_transfer_learning_tutorial/blob/master/utils.py#L134))\r\n\r\nThis will avoid display all the logging message under the error level though, so use it with care ;-)", "> Just a note: if you want to avoid displaying the warning, you can raise the level of the logger with `logging.getLogger(\"pytorch_pretrained_bert.tokenization\").setLevel(logging.ERROR)`.\r\n> \r\n> We did that in the Transfer Learning tutorial code (see [here](https://github.com/huggingface/naacl_transfer_learning_tutorial/blob/master/utils.py#L134))\r\n> \r\n> This will avoid display all the logging message under the error level though, so use it with care ;-)\r\n\r\nJust a small fix. Because the names have changed, use this instead:\r\n`logging.getLogger(\"pytorch_transformers.tokenization_utils\").setLevel(logging.ERROR)`", "I encountered this problem too. As of Oct. 16, 2019, the correct way to suppress warning is:\r\n`logging.getLogger(\"transformers.tokenization_utils\").setLevel(logging.ERROR)`", "I'm not sure from which version, but the above doesn't work anymore.\r\nIf any one stumbles on the same problem, try this:\r\n`logging.getLogger(\"transformers.tokenization_utils_base\").setLevel(logging.ERROR)`", "See the global solution here: https://github.com/huggingface/transformers/issues/3050#issuecomment-682167272", "from transformers.utils import logging\r\nlogging.set_verbosity(40)\r\n\r\nThis will set your logger to only display Errors (no warnings).\r\n\r\nSee more here -> https://huggingface.co/docs/transformers/main_classes/logging" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "H! Could you please specify on which OS you have this error? I cannot reproduce this on MacOS 10.15, nor on Ubuntu 18.04 with both Python 3.5 and 3.6.", "Hi, @LysandreJik \r\n\r\nI tried these on Ubuntu 16.04.6 LTS.", "@ntubertchen\r\nJust in case helpful for you -- I had exactly the same issue with release 1.0 of pytorch-transformer, when I worked with multilingual BERT base models. (Ubuntu 19.04, training MRPC model with run_glue.py script.) Always at the end of training (e.g. MRPC), it gave me the above warning. And the eval results were quite strange. (e.g. often much lower than expected). Due to this, and also Chinese model broken issue; I installed master branch as of now (commits after Roberta models added), and the error went away. no more such warnings, and stable result. \r\n\r\nMaybe you should try to install from current master (which will install locally built 1.1); it helped me. I think some code has been changed on handling multilingual vocab file. ", "Thanks @gilnoh. @ntubertchen can you let me know if you still have the same problem with the current (1.1.0) release ?", "Yes, we had an issue in Bert tokenizer that made it lose a token in the Chinese vocabulary.\r\nThis is fixed now with the merge of #860.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi, no, Bert doesn't have a cached hidden-states option.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Are you looking for LSTM/RNN-based seq2seq architectures or Transformer-based architectures? This repository does not host any LSTM/RNN architectures.\r\n\r\nYou can find information on all our (transformer) [models here](https://huggingface.co/pytorch-transformers/pretrained_models.html), and [examples using them here](https://huggingface.co/pytorch-transformers/examples.html).", "I am looking for transformer based, pretrained model, I am not sure which of the implemented models in this repo I can use for seq2seq model? thanks for your help", "The models hosted on this repo unfortunately probably cannot be used in a traditional sequence-to-sequence manner like translation (if that's what you have in mind).", "yes, exactly, I am looking for such models, even gpt model cannot be used\nfor this purpose?\nor gpt2 by conditioning?\nAre you aware of clean implementation for seq2seq model with any of these\npretrained models hosted in your repo?\nthanks.\n\nOn Thu, Aug 8, 2019 at 5:10 PM Lysandre Debut <[email protected]>\nwrote:\n\n> The models hosted on this repo unfortunately probably cannot be used in a\n> traditional sequence-to-sequence manner like translation (if that's what\n> you have in mind).\n>\n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZM7GUYVJHJ6YKKQK3PDQDQZM5A5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD335YCY#issuecomment-519560203>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AM3GZM2PJO6J63NC4DPTFW3QDQZM5ANCNFSM4IKIFMCQ>\n> .\n>\n", "Hi @juliahane, maybe take a look at `fairseq`", "Hi\nThanks, Do you mind also suggest me a good implementation with lstm for\nseq2seq model, I need some implementation with high quality of decoding,\nthanks.\n\nOn Thu, Aug 8, 2019 at 6:52 PM Julien Chaumond <[email protected]>\nwrote:\n\n> Hi @juliahane <https://github.com/juliahane>, maybe take a look at fairseq\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZG265MHPY53WI2HNTQDRFLDA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD34HSYQ#issuecomment-519600482>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AM3GZMYF5YYWWJMDVOXH3LTQDRFLDANCNFSM4IKIFMCQ>\n> .\n>\n", "Hi\nI found FairSeq implementation not really clean and modular code. Are you\naware of more work which extend BERT, GPT, ... to a language model with\ndecoder?\nthanks\nJulia\n\nOn Thu, Aug 8, 2019 at 9:07 PM julia hane <[email protected]> wrote:\n\n> Hi\n> Thanks, Do you mind also suggest me a good implementation with lstm for\n> seq2seq model, I need some implementation with high quality of decoding,\n> thanks.\n>\n> On Thu, Aug 8, 2019 at 6:52 PM Julien Chaumond <[email protected]>\n> wrote:\n>\n>> Hi @juliahane <https://github.com/juliahane>, maybe take a look at\n>> fairseq\n>>\n>> —\n>> You are receiving this because you were mentioned.\n>> Reply to this email directly, view it on GitHub\n>> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZG265MHPY53WI2HNTQDRFLDA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD34HSYQ#issuecomment-519600482>,\n>> or mute the thread\n>> <https://github.com/notifications/unsubscribe-auth/AM3GZMYF5YYWWJMDVOXH3LTQDRFLDANCNFSM4IKIFMCQ>\n>> .\n>>\n>\n", "Then you should have a look at the \"Cross-lingual Language Model Pretraining\" from Lample and Conneau: https://arxiv.org/abs/1901.07291\r\n\r\nImplementation of supervised and unsupervised NMT can be found here: https://github.com/facebookresearch/XLM#iii-applications-supervised--unsupervised-mt :)", "Hi\nthanks a lot. I was wondering if you could also suggest me a good\nimplementation for seq2seq with LSTMs in pytorch with good accuracy.\nI have a deadline and I cannot find any, I really appreciate your help.\nthanks\nJulia\n\nOn Thu, Aug 8, 2019 at 11:41 PM Stefan Schweter <[email protected]>\nwrote:\n\n> Then you should have a look at the \"Cross-lingual Language Model\n> Pretraining\" from Lample and Conneau: https://arxiv.org/abs/1901.07291\n>\n> Implementation of supervised and unsupervised NMT can be found here:\n> https://github.com/facebookresearch/XLM#iii-applications-supervised--unsupervised-mt\n> :)\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZM3URUZ6GWYI7A4WPFTQDSHKBA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD347NXQ#issuecomment-519698142>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AM3GZM2PRHPLQBS7XBGCUBLQDSHKBANCNFSM4IKIFMCQ>\n> .\n>\n", "Hey Julia, without a specific task in mind I can't think of anything relevant, but browsing [paperswithcode.com with a seq2seq search](https://paperswithcode.com/search?q_meta=&q=seq2seq) yields quite a few interesting results.", "Hi\nMy task is a autoencoding text. So encoding and decoding it in one\nlanguage. Thanks\n\nOn Wed, Aug 14, 2019, 5:18 PM Lysandre Debut <[email protected]>\nwrote:\n\n> Hey Julia, without a specific task in mind I can't think of anything\n> relevant, but browsing paperswithcode.com with a seq2seq search\n> <https://paperswithcode.com/search?q_meta=&q=seq2seq> yields quite a few\n> interesting results.\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZ3PDZUSW7QWNQV3CDQEQO2XA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD4JEKTA#issuecomment-521291084>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AM3GZM62USCZO4Z5UGUTOBTQEQO2XANCNFSM4IKIFMCQ>\n> .\n>\n", "I was wondering if you could tell me which of these are a fast sequence to\nsequence implementation,\nthis is really hard for me to figure out which one to use. thanks\n\nOn Wed, Aug 14, 2019 at 5:19 PM julia hane <[email protected]> wrote:\n\n> Hi\n> My task is a autoencoding text. So encoding and decoding it in one\n> language. Thanks\n>\n> On Wed, Aug 14, 2019, 5:18 PM Lysandre Debut <[email protected]>\n> wrote:\n>\n>> Hey Julia, without a specific task in mind I can't think of anything\n>> relevant, but browsing paperswithcode.com with a seq2seq search\n>> <https://paperswithcode.com/search?q_meta=&q=seq2seq> yields quite a few\n>> interesting results.\n>>\n>> —\n>> You are receiving this because you were mentioned.\n>> Reply to this email directly, view it on GitHub\n>> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZ3PDZUSW7QWNQV3CDQEQO2XA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD4JEKTA#issuecomment-521291084>,\n>> or mute the thread\n>> <https://github.com/notifications/unsubscribe-auth/AM3GZM62USCZO4Z5UGUTOBTQEQO2XANCNFSM4IKIFMCQ>\n>> .\n>>\n>\n", "I did checked this implementations you sent me, I honestly cannot find a\nsingle good seq2seq one with lstm, and I really appreciate your help\n\nOn Wed, Aug 14, 2019 at 5:39 PM julia hane <[email protected]> wrote:\n\n> I was wondering if you could tell me which of these are a fast sequence to\n> sequence implementation,\n> this is really hard for me to figure out which one to use. thanks\n>\n> On Wed, Aug 14, 2019 at 5:19 PM julia hane <[email protected]> wrote:\n>\n>> Hi\n>> My task is a autoencoding text. So encoding and decoding it in one\n>> language. Thanks\n>>\n>> On Wed, Aug 14, 2019, 5:18 PM Lysandre Debut <[email protected]>\n>> wrote:\n>>\n>>> Hey Julia, without a specific task in mind I can't think of anything\n>>> relevant, but browsing paperswithcode.com with a seq2seq search\n>>> <https://paperswithcode.com/search?q_meta=&q=seq2seq> yields quite a\n>>> few interesting results.\n>>>\n>>> —\n>>> You are receiving this because you were mentioned.\n>>> Reply to this email directly, view it on GitHub\n>>> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZ3PDZUSW7QWNQV3CDQEQO2XA5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD4JEKTA#issuecomment-521291084>,\n>>> or mute the thread\n>>> <https://github.com/notifications/unsubscribe-auth/AM3GZM62USCZO4Z5UGUTOBTQEQO2XANCNFSM4IKIFMCQ>\n>>> .\n>>>\n>>\n", "@juliahane `fairseq` has an example of how to use a LSTM (encoder & decoder) for a seq2seq model:\r\n\r\nhttps://fairseq.readthedocs.io/en/latest/tutorial_simple_lstm.html\r\n\r\nAdditionally, you could also check out Joey NMT, which has a very nice and clear codebase:\r\n\r\nhttps://github.com/joeynmt/joeynmt", "Hi\nThanks, Fairseq to me is not following a good coding practice although\nFacebook has published it,\nbut the second one looks much better, thank you.\n\nI was wondering if you could tell me if torchtext is faster than using\ndataloader in pytorch for seq2seq applications?\nI wonder how torchtext impact the speed and if this is really better than\ndataloader\n\nthanks\n\nOn Fri, Aug 16, 2019 at 1:42 PM Stefan Schweter <[email protected]>\nwrote:\n\n> @juliahane <https://github.com/juliahane> fairseq has an example of how\n> to use a LSTM (encoder & decoder) for a seq2seq model:\n>\n> https://fairseq.readthedocs.io/en/latest/tutorial_simple_lstm.html\n>\n> Additionally, you could also check out Joey NMT, which has a very nice and\n> clear codebase:\n>\n> https://github.com/joeynmt/joeynmt\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/pytorch-transformers/issues/988?email_source=notifications&email_token=AM3GZMZGVNRAT6FJLOEZAB3QE2HB3A5CNFSM4IKIFMC2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOD4OMY7A#issuecomment-521981052>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AM3GZM3YNYMZ32LXZCCPSA3QE2HB3ANCNFSM4IKIFMCQ>\n> .\n>\n", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "Merging with #1506" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=h1) Report\n> Merging [#987](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/3566d2791905269b75014e8ea9db322c86f980b2?src=pr&el=desc) will **decrease** coverage by `0.12%`.\n> The diff coverage is `77.66%`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #987 +/- ##\n==========================================\n- Coverage 79.22% 79.09% -0.13% \n==========================================\n Files 38 42 +4 \n Lines 6406 6812 +406 \n==========================================\n+ Hits 5075 5388 +313 \n- Misses 1331 1424 +93\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/tokenization\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbmV0LnB5) | `84.25% <28.57%> (-3.86%)` | :arrow_down: |\n| [pytorch\\_transformers/tokenization\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX2JlcnQucHk=) | `93.39% <33.33%> (-1.75%)` | :arrow_down: |\n| [pytorch\\_transformers/tokenization\\_xlm.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbS5weQ==) | `79.67% <33.33%> (-2.38%)` | :arrow_down: |\n| [pytorch\\_transformers/tokenization\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3V0aWxzLnB5) | `83.03% <42.3%> (-3.28%)` | :arrow_down: |\n| [pytorch\\_transformers/modeling\\_roberta.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfcm9iZXJ0YS5weQ==) | `73.52% <73.52%> (ø)` | |\n| [...ytorch\\_transformers/tests/modeling\\_roberta\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvbW9kZWxpbmdfcm9iZXJ0YV90ZXN0LnB5) | `78.81% <78.81%> (ø)` | |\n| [...ch\\_transformers/tests/tokenization\\_roberta\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvdG9rZW5pemF0aW9uX3JvYmVydGFfdGVzdC5weQ==) | `90.24% <90.24%> (ø)` | |\n| [pytorch\\_transformers/tokenization\\_roberta.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3JvYmVydGEucHk=) | `92.45% <92.45%> (ø)` | |\n| [pytorch\\_transformers/file\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvZmlsZV91dGlscy5weQ==) | `71.22% <0%> (-2.88%)` | :arrow_down: |\n| [pytorch\\_transformers/modeling\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfdXRpbHMucHk=) | `83.24% <0%> (ø)` | :arrow_up: |\n| ... and [5 more](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree-more) | |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=footer). Last update [3566d27...a448941](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=h1) Report\n> Merging [#987](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/e00b4ff1de0591d5093407b16e665e5c86028f04?src=pr&el=desc) will **increase** coverage by `0.04%`.\n> The diff coverage is `100%`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #987 +/- ##\n==========================================\n+ Coverage 79.61% 79.66% +0.04% \n==========================================\n Files 42 42 \n Lines 6898 6914 +16 \n==========================================\n+ Hits 5492 5508 +16 \n Misses 1406 1406\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/tokenization\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbmV0LnB5) | `89.18% <100%> (+0.19%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX2JlcnQucHk=) | `94.88% <100%> (+0.04%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_transfo\\_xl.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3RyYW5zZm9feGwucHk=) | `33.98% <100%> (+0.37%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_openai.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX29wZW5haS5weQ==) | `81.81% <100%> (+0.3%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_gpt2.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX2dwdDIucHk=) | `96.66% <100%> (+0.05%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_xlm.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbS5weQ==) | `83.33% <100%> (+0.26%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3V0aWxzLnB5) | `86.31% <100%> (+0.08%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_roberta.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3JvYmVydGEucHk=) | `96.29% <100%> (+0.06%)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=footer). Last update [e00b4ff...06510cc](https://codecov.io/gh/huggingface/pytorch-transformers/pull/987?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "@LysandreJik I think we are good to merge this new script for fine-tuning Bert/RoBERTa/GPT and GPT-2, right?", "As a heads-up, when testing this using `--model-type=gpt2` on WikiText-103, I get this:\r\n\r\n```\r\n08/23/2019 17:57:44 - WARNING - pytorch_transformers.tokenization_utils - Token indices sequence length is longer than the specified maximum sequence length for this model (119073253 > 1024). Running this sequence through the model will result in indexing errors\r\nTraceback (most recent call last):\r\n File \"examples/run_lm_finetuning.py\", line 501, in <module>\r\n main()\r\n File \"examples/run_lm_finetuning.py\", line 450, in main\r\n train_dataset = load_and_cache_examples(args, tokenizer, evaluate=False)\r\n File \"examples/run_lm_finetuning.py\", line 99, in load_and_cache_examples\r\n dataset = TextDataset(tokenizer, file_path=args.eval_data_file if evaluate else args.train_data_file, block_size=args.block_size)\r\n File \"examples/run_lm_finetuning.py\", line 75, in __init__\r\n tokenized_text = tokenizer.add_special_tokens_single_sentence(tokenized_text)\r\n File \"~/.local/lib/python3.6/site-packages/pytorch_transformers/tokenization_utils.py\", line 593, in add_special_tokens_single_sentence\r\n raise NotImplementedError\r\nNotImplementedError\r\n```\r\n\r\nI think it is happening because `GPT2Tokenizer` doesn't implement `add_special_tokens_single_sentence`, which is used directly by `run_lm_finetuning.py` in `TextDataset.__init__`.", "Ok, this looks good to me!" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi, indeed we could move the gradient clipping just before the call to the optimizer.\r\nDo you want to send a PR to fix that on `run_squad` and `run_glue`?", "Hi, was this ever implemented? I think it makes the most sense to clip right before an optimizer step. Right now it's implemented in two different ways in [run_lim_finetuning](https://github.com/huggingface/transformers/blob/master/examples/run_lm_finetuning.py) and [run_glue](https://github.com/huggingface/transformers/blob/master/examples/run_glue.py)", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi, you are trying to download one of your own models kept on a personal AWS s3 bucket or one of our models? What string do you pass to the `from_pretrained` method?", "Thank you for your response, \r\nI am trying to use my own model kept on my personal AWS s3 bucket. \r\nThe string to from_pretrained method is the path of folder which contains three files config , vocab and model. I have also tried to zip all files (.tar.gz) and use that file rather then folder but it also didn't work.\r\nPlease let me know in case you need more information.\r\n\r\n", "Firstly, have you checked that the model in the bucket is reachable? \r\n\r\nSecondly, what is the name of the config file?", "Yes its reachable, I can read vocab.txt file .\r\nName of config file is bert_config.json", "I do have the same (similar) problem, except that I use the pretrained models (e.g. bert-base-uncased\"). The script repeatedly downloads the vocab, json and model file and often fails to load the model. Everything is works if I do it on the local machine. \r\n\r\nI also tried to download the files locally and unsuccessfully loaded the model directly. (tokenizer failed, model failed, BertConfig worked). Maybe I do something wrong here - example code would help", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=h1) Report\n> Merging [#984](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/7729ef738161a0a182b172fcb7c351f6d2b9c50d?src=pr&el=desc) will **increase** coverage by `0.06%`.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #984 +/- ##\n==========================================\n+ Coverage 79.16% 79.22% +0.06% \n==========================================\n Files 38 38 \n Lines 6406 6406 \n==========================================\n+ Hits 5071 5075 +4 \n+ Misses 1335 1331 -4\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/file\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvZmlsZV91dGlscy5weQ==) | `74.1% <0%> (+2.87%)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=footer). Last update [7729ef7...39f51cd](https://codecov.io/gh/huggingface/pytorch-transformers/pull/984?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Thanks Stefan, there were a few other typos in these models details indeed so I'll take care of this in another PR." ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "@Nealcly Could you try to use the `gpt2-medium` model? It has more layers :)", "Also I'm not sure that your testing procedure is statistically representative :)", "Any new updates on this issue? I am also facing the same question. ", "Based on the paper, only the largest model is called gpt2. The smallest model(117m) doesn't guarantee better performance than gpt.", "how to finetune the language model with dataset and then get perplexity scores\r\n", "@anonymous297 please check the [documentation examples](https://huggingface.co/transformers/examples.html#language-model-fine-tuning), in which there's exactly what you're looking for.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi I don't have any good solution for your use-case, unfortunately.\r\n\r\nThere are two \"Whole-Word_masking\" models for Bert (see the [list here](https://huggingface.co/pytorch-transformers/pretrained_models.html)) that would be better at guessing full words but they are only in English unfortunately.\r\n\r\nSpanBert (whose open-sourcing we are still waiting) may also be better but I think they also only trained an English model...", "@thomwolf thanks for the reply. \r\ncan you specify what exactly the problem lies in? I know the model is not capable of properly tokenizing polish. \r\n\r\nAssuming I have pre-trained model for Polish, or just working with English text how can I predict a sequence of masked two or three tokens side by side", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "if i want to fine-tune with my dataset,what should i do?", "> if i want to fine-tune with my dataset,what should i do?\r\n\r\nHi tom1125, to fine-tune you can run this script:\r\n\r\nexport TRAIN_FILE=/path/to/dataset/wiki.train.raw\r\nexport TEST_FILE=/path/to/dataset/wiki.test.raw\r\n\r\npython run_language_modeling.py \\\r\n --output_dir=output \\\r\n --model_type=roberta \\\r\n --model_name_or_path=roberta-base \\\r\n --do_train \\\r\n --train_data_file=$TRAIN_FILE \\\r\n --do_eval \\\r\n --eval_data_file=$TEST_FILE \\\r\n --mlm\r\n\r\nExplained here: https://huggingface.co/transformers/examples.html#roberta-bert-and-masked-language-modeling" ]

[]

[]

[ "Hi! You seem to be loading a cased model (such as the `bert-base-multilingual-cased`), but you're specifying `do_lower_case` to your tokenizer, which strips accents and lowercases every character.\r\n\r\nThe model you specified has been trained with uppercase and lowercase characters as well as accent markers, so you should use it with such characters as well. If you're looking at using only lowercase characters, it would be better for you to use an uncased model (such as the `bert-base-multilingual-uncased`).", "@LysandreJik that is correct, thank you." ]

[]

[]

[]

[]

[]

[ "Hi @ibeltagy,\r\nDoes it train on TPU?", "Not yet, it still has some issues. I will create another PR when it is in good shape. " ]

[]

[]

[ "Could you please provide more information, especially regarding the `sample_sequence` function and where it is coming from?", "Thanks for the response!\r\n\r\nMy goal is to wrap the GPT2 model interface in a function so I can input a prompt and output generated text. I'm trying to adapt one of the examples, and I'm getting there, but I wasn't able to find anything on the error specific to Pytorch-Transformers.\r\n\r\nHere's the `sample_sequence` function:\r\n\r\n def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, device='cpu'):\r\n\r\n\tcontext = torch.tensor(context, dtype=torch.long, device=device)\r\n\tcontext = context.unsqueeze(0).repeat(num_samples, 1)\r\n\tgenerated = context\r\n\twith torch.no_grad():\r\n\t\tfor _ in trange(length):\r\n\t\t\tinputs = {'input_ids': generated}\r\n\t\t\toutputs = model(**inputs)\r\n\t\t\tnext_token_logits = outputs[0][0, -1, :] / temperature\r\n\t\t\tfiltered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)\r\n\t\t\tnext_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)\r\n\t\t\tgenerated = torch.cat((generated, next_token.unsqueeze(0)), dim=1)\r\n\t\treturn generated", "Your sample sequence function returns a `torch.tensor([[int64]])`, of shape `[batch_size, sequence_length]`. In your specific case it is of size `[1, 146]`.\r\n\r\nYou cannot feed such an object to the tokenizer for decoding, as it only accepts a list of integers.\r\n\r\nYou can fetch the list of integers by calling the `tolist()` method on your output, and then feed it to the tokenizer for decoding:\r\n\r\n```\r\nout = sample_sequence(\r\n\tmodel=model,\r\n\tcontext=context_tokens,\r\n\tlength=140,\r\n\ttemperature=0.9,\r\n\ttop_k=1,\r\n\ttop_p=0.9\r\n)\r\n\r\ngenerated_list = out[0].tolist()\r\ntext = tokenizer.decode(generated_list)\r\n\r\nprint(text)\r\n```", "It worked!\r\n\r\nThis was very helpful, thank you! Just getting familiar with this package, it's awesome!" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=h1) Report\n> Merging [#977](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/4fc9f9ef54e2ab250042c55b55a2e3c097858cb7?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #977 +/- ##\n=======================================\n Coverage 79.16% 79.16% \n=======================================\n Files 38 38 \n Lines 6406 6406 \n=======================================\n Hits 5071 5071 \n Misses 1335 1335\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=footer). Last update [4fc9f9e...a6f412d](https://codecov.io/gh/huggingface/pytorch-transformers/pull/977?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Ok, thanks!" ]

[]

[]

[ "Indeed. @LysandreJik I think it should be `Indices should be in ``[0, ..., config.num_labels-1]`` for classification or torch.floats for regression`, what do you think? " ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "See #954. I got bitten by the same documentation _bug_.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "A little question because we are trying to organize the issues better:\r\n- what made you not use the issue templates we have added?", "> A little question because we are trying to organize the issues better:\r\n> \r\n> * what made you not use the issue templates we have added?\r\n\r\nDidn't know about it...", "@eladbitton Can you link lines of code to where this was done for `BertForQuestionAnswering` and `SQuAD`? I'd be willing to take a stab at implementation.", "Hey @maxzzze. I was looking at:\r\nhttps://github.com/huggingface/pytorch-transformers/blob/0d1dad6d5323cf627cb8d7ddd428856ab8475f6b/pytorch_transformers/modeling_bert.py#L1112\r\n\r\nNow that i look at it, i am not sure if they implemented it there.\r\n", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "Same issue here.\r\nSince this package is presented as a \"plug n play\" solution for this kind of task, that is really unfortunate.", "@eladbitton, I believe the start and end positions in BertForQuestionAnswering are for filtering tokens when computing the loss (since the loss is given by the cross-entropy between the predicted and true distributions of the start token, the latter of which is a one-hot vector; similarly for the end token), not for converting a large sequence into a batch of shorter sequences.\r\n\r\n@thomwolf, are there plans to add the functionality mentioned [here](https://github.com/google-research/bert/issues/27#issuecomment-435265194) by Devlin (or would you be able to suggest any alternatives that might work)?" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=h1) Report\n> Merging [#973](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/4fc9f9ef54e2ab250042c55b55a2e3c097858cb7?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #973 +/- ##\n=======================================\n Coverage 79.16% 79.16% \n=======================================\n Files 38 38 \n Lines 6406 6406 \n=======================================\n Hits 5071 5071 \n Misses 1335 1335\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/modeling\\_transfo\\_xl.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfdHJhbnNmb194bC5weQ==) | `57.53% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfeGxuZXQucHk=) | `79.01% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_xlm.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfeGxtLnB5) | `86.66% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfYmVydC5weQ==) | `87.98% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_openai.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfb3BlbmFpLnB5) | `74.76% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_gpt2.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfZ3B0Mi5weQ==) | `75.84% <ø> (ø)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=footer). Last update [4fc9f9e...6ec1ee9](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=h1) Report\n> Merging [#973](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/4fc9f9ef54e2ab250042c55b55a2e3c097858cb7?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #973 +/- ##\n=======================================\n Coverage 79.16% 79.16% \n=======================================\n Files 38 38 \n Lines 6406 6406 \n=======================================\n Hits 5071 5071 \n Misses 1335 1335\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/modeling\\_transfo\\_xl.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfdHJhbnNmb194bC5weQ==) | `57.53% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfeGxuZXQucHk=) | `79.01% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_xlm.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfeGxtLnB5) | `86.66% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfYmVydC5weQ==) | `87.98% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_openai.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfb3BlbmFpLnB5) | `74.76% <ø> (ø)` | :arrow_up: |\n| [pytorch\\_transformers/modeling\\_gpt2.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfZ3B0Mi5weQ==) | `75.84% <ø> (ø)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=footer). Last update [4fc9f9e...6ec1ee9](https://codecov.io/gh/huggingface/pytorch-transformers/pull/973?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Great! Thanks a lot @FeiWang96!" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "I'm interested in this as well. I've seen similar inference times of nearly 1.5 seconds running BERT for inference on a fine-tuned classification task on TF Serving and would like to improve it without paying for a GPU.\r\n\r\nI'm not associated with the following work, but found the paper interesting: \r\n\"tranformers.zip: Compressing Transformers with Pruning and Quantization\"\r\nhttp://web.stanford.edu/class/cs224n/reports/custom/15763707.pdf\r\n\r\nThe open source corresponding to the paper above has been published in a branch of OpenNMT here:\r\nhttps://github.com/robeld/ERNIE\r\n", "I think we could speed up significantly XLNet by refactoring the tensorflow code to use Embeddings instead of multiplication of static matrices with one-hot vectors as it's currently done in several places. We could also reduce the use of `torch.einsum` and replace them with matrix multiplications. We'll experiment with that in the coming months.", "Might even just dropping in `opt_einsum` as a substitute for the `torch.einsum` be an easy speedup?", "I'm doing some time profiling here, it looks like the time bottleneck in the forward loop of the transformer. In this case my overall forward loop for `XLNetForQuestionAnswering` is taking `2.5 s ± 310 ms per loop (mean ± std. dev. of 3 runs, 1 loop each)`. Please see below a breakdown for each forward step (in seconds). Looks like the large chunk of the time is spent in the chunk of the code below ~2.33 seconds. Will start doing some optimizations on `XLNetRelativeAttention` and `XLNetFeedForward` to see what happens.\r\n```\r\nCausal attention mask: 7e-05\r\nData mask: 3e-05\r\nWord Embedding: 0.00073\r\nSegment Embedding: 5e-05\r\n___ Pos encoding - 1 : 0.0099\r\n___ Pos encoding - 2 : 0.00012\r\n**___ Pos encoding - 3: 2.33072**\r\nPositional encoding: 2.34084\r\nPrepare output: 0.00025\r\nTransformer time: 2.3420751094818115\r\n```\r\n**___ Pos encoding - 3** - Code chunk\r\n```\r\n new_mems = ()\r\n if mems is None:\r\n mems = [None] * len(self.layer)\r\n\r\n attentions = []\r\n hidden_states = []\r\n for i, layer_module in enumerate(self.layer):\r\n # cache new mems\r\n new_mems = new_mems + (self.cache_mem(output_h, mems[i]),)\r\n if self.output_hidden_states:\r\n hidden_states.append((output_h, output_g) if output_g is not None else output_h)\r\n\r\n outputs = layer_module(output_h, output_g, attn_mask_h=non_tgt_mask, attn_mask_g=attn_mask,\r\n r=pos_emb, seg_mat=seg_mat, mems=mems[i], target_mapping=target_mapping,\r\n head_mask=head_mask[i])\r\n output_h, output_g = outputs[:2]\r\n if self.output_attentions:\r\n attentions.append(outputs[2])\r\n```", "@MiroFurtado it looks like Torch.Einsum is already as optimized as `opt_einsum` - see attached an example of multiplication of **1024x1024** matrix using `torch.einsum`, `torch.matmul`,`np.einsum` and `opt_einsum`. Looks like in fact `np.einsum` is not optimized after all.\r\nI modified the code to include `opt_einsum` using `contract` and actually it tooked ~3x more! **`5.79 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)`**\r\n\r\n[Einsum Comparison - Torch Einsum, Matmul, Numpy, Opt Contract](https://drive.google.com/open?id=1Kck35N39sGuU1pKs2NPxAuXcjlNEP8yt)\r\n", "Just FYI, a relevant blog post about this topic, will investigate: https://blog.rasa.com/compressing-bert-for-faster-prediction-2/", "More related information, **freshly** released: https://ai.facebook.com/blog/making-transformer-networks-simpler-and-more-efficient/?refid=52&__tn__=*s-R", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "You're right, will fix! cc @LysandreJik " ]

[]

[]

[ "Hi Rabeeh,\r\n\r\nPlease take a look at the [run_generation.py](https://github.com/huggingface/pytorch-transformers/blob/master/examples/run_generation.py) example which shows how to do conditional generation with the library's auto-regressive models (GPT/GPT-2/Transformer-XL/XLNet).", "What's cracking Rabeeh, \r\n\r\nlook, this code makes the trick for GPT2LMHeadModel.\r\nBut, as torch.argmax() is used to derive the next word; there is a lot of repetition.\r\n\r\n`\r\nfrom transformers import GPT2LMHeadModel, GPT2Tokenizer\r\nimport torch\r\nimport argparse\r\nparser = argparse.ArgumentParser()\r\nparser.add_argument('--input', type=str, help='Initial text for GPT2 model', required=True)\r\nparser.add_argument('--length', type=int, help='Amount of new words added to input', required=True, default=20)\r\nargs = parser.parse_args()\r\n\r\ntokenizer = GPT2Tokenizer.from_pretrained(\"gpt2\")\r\nmodel = GPT2LMHeadModel.from_pretrained('gpt2')\r\n\r\ngenerated = tokenizer.encode(args.input)\r\ncontext = torch.tensor([generated])\r\npast = None\r\n\r\nfor i in range(args.length):\r\n>>>#print(\"{}=>>{}\".format(i,tokenizer.decode(generated)))\r\n>>>output, past = model(context, past=past)\r\n>>>token = torch.argmax(output[0, :])\r\n>>>generated += [token.tolist()]\r\n>>>context = token.unsqueeze(0)\r\n\r\nsequence = tokenizer.decode(generated)\r\n\r\nprint(\"Final sequence =>>{}\".format(sequence))\r\n`\r\n\r\nAs LysandreJik pointed out, is better to clone the hugginface transformer repo in Git, and go to the examples ---they do it great.", "Hi\nThank you very much, very helpful for me.\n\nOn Wed, Jan 29, 2020 at 3:06 PM SaveTheBees-n-Seeds <\[email protected]> wrote:\n\n> What's cracking Rabeeh,\n>\n> look, this code makes the trick for GPT2LMHeadModel.\n> But, as torch.argmax() is used to derive the next word; there is a lot of\n> repetition.\n>\n> `\n> from transformers import GPT2LMHeadModel, GPT2Tokenizer\n> import torch\n> import argparse\n> parser = argparse.ArgumentParser()\n> parser.add_argument('--input', type=str, help='Initial text for GPT2\n> model', required=True)\n> parser.add_argument('--length', type=int, help='Amount of new words added\n> to input', required=True, default=20)\n> args = parser.parse_args()\n>\n> tokenizer = GPT2Tokenizer.from_pretrained(\"gpt2\")\n> model = GPT2LMHeadModel.from_pretrained('gpt2')\n>\n> generated = tokenizer.encode(args.input)\n> context = torch.tensor([generated])\n> past = None\n>\n> for i in range(args.length):\n> #print(\"{}=>>{}\".format(i,tokenizer.decode(generated)))\n> output, past = model(context, past=past)\n> token = torch.argmax(output[0, :])\n> generated += [token.tolist()]\n> context = token.unsqueeze(0)\n>\n> sequence = tokenizer.decode(generated)\n>\n> print(\"Final sequence =>>{}\".format(sequence))\n> `\n>\n> As LysandreJik pointed out, is better to clone the hugginface transformer\n> repo in Git, and go to the examples ---they do it great.\n>\n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/transformers/issues/970?email_source=notifications&email_token=ABP4ZCF2JQTV7W32PHYGAE3RAGEOLA5CNFSM4IJM4LMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEKHJRGA#issuecomment-579770520>,\n> or unsubscribe\n> <https://github.com/notifications/unsubscribe-auth/ABP4ZCE4ZATSJAEF35A7B73RAGEOLANCNFSM4IJM4LMA>\n> .\n>\n", "HI @SaveTheBees-n-Seeds ,\r\n I have a particular use case (which is somewhat related to this quest); \r\n \r\n Context: instead of a text-to-condition, I have directly a vector, which is an output from some other model (which is also learnable ). \r\n In this context, how to do conditional fine-tuning of the GPT-2 model. From the GPT-2 model's perspective, we can think that the dataset to train is a **list of tuples of the form (condition_vec,text_sample)**. But note that condition_vec is an output from some other model that is also involved in the optimisation.\r\n\r\n One naive approach is to feed this vector directly as the context vector (Assume dimensions match). \r\n Will it work? (I could test it soon)\r\n Or is there any better solution? " ]

[]

[]

[ "Hi Rabeeh,\r\n\r\nWe are currently working on an updated example on fine-tuning generative models, especially GPT-2. The example should be up later this week, keep an eye out!", "Any update on when this example will be available? Thanks!", "Hope this issue won't be closed until the example is done.", "The script is being worked on over at https://github.com/huggingface/pytorch-transformers/pull/987 ([see relevant file here](https://github.com/huggingface/pytorch-transformers/blob/master/examples/run_lm_finetuning.py)). It works for GPT/GPT-2 but it isn't ready for BERT/RoBERTa so we're not releasing it yet.\r\n\r\nIt shows how to fine-tune GPT-2 using causal language modeling on WikiText-2.", "Any update on when this example will be available? Thanks!\r\nThe link of \"see relevant file here\" is 404", "Oh yes, the script is out.\r\n\r\nIt was renamed `run_lm_fintuning.py` you can find it in the `examples` folder: https://github.com/huggingface/pytorch-transformers/blob/master/examples/run_lm_finetuning.py\r\n\r\nYou can use it to fintune GPT, GPT-2, BERT or RoBERTa on your dataset.\r\n\r\nHere is an example on how to run it: https://huggingface.co/pytorch-transformers/examples.html#causal-lm-fine-tuning-on-gpt-gpt-2-masked-lm-fine-tuning-on-bert-roberta", "Silly question but how do you know which gpt-2 model is being trained? Does it default to the largest one available. I couldn't find any indication of which size model is being used in the fine tuning script.", "Hi Henry,\nDefault to the small one.\nYou can select the size with the `model_name_or_path` argument. Just put in\nthe argument the relevant shortcut name for the model as listed [here](\nhttps://huggingface.co/transformers/pretrained_models.html).\n\nOn Wed, 6 Nov 2019 at 12:35, Henry-E <[email protected]> wrote:\n\n> Silly question but how do you know which gpt-2 model is being trained?\n> Does it default to the largest one available. I could find any indication\n> of which size model is being used in the fine tuning script.\n>\n> —\n> You are receiving this because you commented.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/huggingface/transformers/issues/969?email_source=notifications&email_token=ABYDIHNYJ3YQTDE6P6HPCOTQSKTYRA5CNFSM4IJMWQW2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEDGHRYA#issuecomment-550271200>,\n> or unsubscribe\n> <https://github.com/notifications/unsubscribe-auth/ABYDIHM7FQGTLI5UPLWJHSTQSKTYRANCNFSM4IJMWQWQ>\n> .\n>\n", "Ah got it, thanks!", "` run_lm_fintuning.py` is no longer available in the examples folder when you clone the transformers repo. Is there a reason for this? It was available a couple of months ago. ", "It’s named run_language_modeling.py now", "Great, thanks!", "This may sound silly also, but will `run_lm_fintuning.py` be able to finetune microsoft/DialoGPT model on a custom dataset? Thank you", "Yes, but it's named `run_language_modeling.py` now." ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "any updates on this?", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "You just have to upgrade your tensorflow " ]

[]

[]

[ "Hi, you can use the BertModel to give you the encoded representation of the word ids you have as input. The tensor output by the model’s last layer (of dimension `(batch_size, sequence_length, 768)` for the BertModel) can be considered as the BERT-encoded representation of your input and then be used as input for a downstream task. Is this what you were looking for?", "I want to get the word embedding.\r\nIs the following code correct?\r\n model = BertModel.from_pretrained('ms')\r\n embedding = model.embeddings.word_embeddings\r\n‘ms’ is my pretrained bert model path", "Yes, that works!", "thanks!" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=h1) Report\n> Merging [#964](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/7729ef738161a0a182b172fcb7c351f6d2b9c50d?src=pr&el=desc) will **increase** coverage by `0.43%`.\n> The diff coverage is `84.71%`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #964 +/- ##\n==========================================\n+ Coverage 79.16% 79.59% +0.43% \n==========================================\n Files 38 42 +4 \n Lines 6406 6845 +439 \n==========================================\n+ Hits 5071 5448 +377 \n- Misses 1335 1397 +62\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/tokenization\\_xlnet.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbmV0LnB5) | `88.99% <100%> (+0.87%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX2JlcnQucHk=) | `95.28% <100%> (+0.13%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_xlm.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3hsbS5weQ==) | `83.73% <100%> (+1.68%)` | :arrow_up: |\n| [...ytorch\\_transformers/tests/tokenization\\_xlm\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvdG9rZW5pemF0aW9uX3hsbV90ZXN0LnB5) | `97.72% <100%> (+0.5%)` | :arrow_up: |\n| [...torch\\_transformers/tests/tokenization\\_bert\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvdG9rZW5pemF0aW9uX2JlcnRfdGVzdC5weQ==) | `98.66% <100%> (+0.15%)` | :arrow_up: |\n| [...orch\\_transformers/tests/tokenization\\_xlnet\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvdG9rZW5pemF0aW9uX3hsbmV0X3Rlc3QucHk=) | `97.91% <100%> (+0.41%)` | :arrow_up: |\n| [pytorch\\_transformers/tokenization\\_utils.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdG9rZW5pemF0aW9uX3V0aWxzLnB5) | `86.12% <66.66%> (-0.2%)` | :arrow_down: |\n| [pytorch\\_transformers/modeling\\_roberta.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfcm9iZXJ0YS5weQ==) | `73.52% <73.52%> (ø)` | |\n| [...ytorch\\_transformers/tests/modeling\\_roberta\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvbW9kZWxpbmdfcm9iZXJ0YV90ZXN0LnB5) | `78.81% <78.81%> (ø)` | |\n| [...ch\\_transformers/tests/tokenization\\_roberta\\_test.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvdGVzdHMvdG9rZW5pemF0aW9uX3JvYmVydGFfdGVzdC5weQ==) | `92.15% <92.15%> (ø)` | |\n| ... and [7 more](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964/diff?src=pr&el=tree-more) | |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=footer). Last update [7729ef7...c4ef103](https://codecov.io/gh/huggingface/pytorch-transformers/pull/964?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "I think RoBERTa is missing in `__init__.py`, so it can't be imported :(", "Would be nice with a modified lm pretraining script to support RoBERTa (ie both removing the NSP task and adding dynamic masking). I might do it in next week.", "@julien-c Does RoBERTa uses token_type_embeddings or token_type_ids as an input? It looks like it doesn't use because token type embeddings matrix has only one row with zeros inside. Am I right?", "@avostryakov You're right.", "@julien-c I modified \r\nMODEL_CLASSES = {...\r\n'roberta': (RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer)} in run_glue.py and it started to train with a parameter \"--model_type roberta\". I think you can modify run_glue.py too to have an example of roberta usage.", "@avostryakov Yes!! I was about to add this indeed.", "Thanks for this! It would be helpful with entries in `modeling_auto` and `tokenization_auto` as well (just remember to check for `'roberta' in model_name` before `'bert' in model_name` ;) ) " ]

[]

[]

[ "for win10 cpu", "Ok!" ]

[]

[]

[ "for win10 cpu", "LGTM!" ]

[]

[]

[ "Hi! Your best bet is indeed to use the models that are state-of-the-art on question answering. It is currently a modified version of BERT (see SpanBERT). I cannot tell you what the accuracy would be on your dataset however, as unfortunately, these models are very sensitive to dataset changes. The SQuAD model (fine-tuned on Wikipedia) probably wouldn't get you groundbreaking results. \r\n\r\nYou can still try it with our BERT model fine-tuned on SQuAD (`bert-large-uncased-whole-word-masking-finetuned-squad`)\r\n\r\nIf you are looking to increase the accuracy on a specific set of documents (from my understanding you’re focusing on children stories), it might be a good idea to fine-tune your model on a similar dataset. Doing so would probably yield better results on your question answering. cc @thomwolf ", "Thank you @LysandreJik for your comment. Can \"the models that are state-of-the-art on question answering\" here answer questions which require background knowledge and reasoning not explicitly stated in the text?\r\n\r\nYes I'm focusing on children stories. Do you think The Children’s Book Test of the Facebook bAbi project (https://research.fb.com/downloads/babi/) might be a good dataset to fine tune the model on?\r\n\r\nTwo more questions please: Is there a tutorial on how to prepare a dataset for question answering to fine-tune the Bert model?\r\n\r\nIf such a dataset is hard to obtain or a lot more data would be needed, would a rule-based method be more practical? ", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "@LysandreJik @thomwolf First of all, thanks a lot for your team's great work on the Swift Core ML implementations of Bert and GPT-2. I just got the chance to try out the BERT-SQuAD iOS sample and it works pretty amazingly if the answer is located in the text, although questions that require some kind of reasoning or answers that are not explicitly stated in the text like motivations or causes/effects are still tough to get right.\r\n\r\nDo you think a hybrid approach of using rule-based common sense knowledge and reasoning with the latest deep learning NLP models would be the best way to answer questions which require background knowledge and reasoning not explicitly stated in the text?", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n", "SQuAD is extractive question answering so will only give you spans inside the original text", "By the way on common sense reasoning, you can check out this great repo by @atcbosselut: https://github.com/atcbosselut/comet-commonsense", "Thanks @julien-c. I took a brief look at the paper a few months ago and will check out the repo and study the paper more carefully." ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=h1) Report\n> Merging [#960](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #960 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=footer). Last update [44dd941...28ba345](https://codecov.io/gh/huggingface/pytorch-transformers/pull/960?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Indeed, thanks Ethan!" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi!\r\n\r\nIf you saved the model `BertForMultipleChoice` to a directory, you can then load the weights for the `BertForMaskedLM` by simply using the `from_pretrained(dir_name)` method. The transformer weights will be re-used by the `BertForMaskedLM` and the weights corresponding to the multiple-choice classifier will be ignored.", "Hi! Thanks for answering me. And this is what I have done at first, which resulted in the following:\r\n\r\nAs you can see, the output tensors are all zeros, which seems to be really weird! \r\n\r\nAlthough this might happen, I still want to confirm that I am doing the right thing, I basically calculating each masked word's probability. And some of them are zero which results in the final sentence zero probs.\r\n\r\n", "Could you share a code snippet that reproduces what you're trying to do so that I can try and see on my side?", "For sure!\r\n```\r\nimport torch\r\nfrom pytorch_pretrained_bert import BertTokenizer, BertModel, BertForMaskedLM\r\nimport numpy as np\r\nimport math\r\n\r\n# OPTIONAL: if you want to have more information on what's happening, activate the logger as follows\r\nimport logging\r\nlogging.basicConfig(level=logging.INFO)\r\n\r\ndef predict(text, bert_model, bert_tokenizer):\r\n # Tokenized input\r\n # text = \"[CLS] I got restricted because Tom reported my reply [SEP]\"\r\n text = \"[CLS] \" + text + \" [SEP]\"\r\n tokenized_text = bert_tokenizer.tokenize(text)\r\n # text = \"[CLS] Stir the mixture until it is done [SEP]\"\r\n #masked_index = 4\r\n sentence_prob = 1\r\n for masked_index in range(1,len(tokenized_text)-1):\r\n # Mask a token that we will try to predict back with `BertForMaskedLM`\r\n masked_word = tokenized_text[masked_index]\r\n #tokenized_text[masked_index] = '[MASK]'\r\n # assert tokenized_text == ['[CLS]', 'who', 'was', 'jim', 'henson', '?', '[SEP]', 'jim', '[MASK]', 'was', 'a', 'puppet', '##eer', '[SEP]']\r\n # print (tokenized_text)\r\n\r\n # Convert token to vocabulary indices\r\n indexed_tokens = bert_tokenizer.convert_tokens_to_ids(tokenized_text)\r\n # Define sentence A and B indices associated to 1st and 2nd sentences (see paper)\r\n # segments_ids = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\r\n length = len(tokenized_text)\r\n segments_ids = [0 for _ in range(length)]\r\n # Convert inputs to PyTorch tensors\r\n tokens_tensor = torch.tensor([indexed_tokens])\r\n segments_tensors = torch.tensor([segments_ids])\r\n\r\n # If you have a GPU, put everything on cuda\r\n tokens_tensor = tokens_tensor.to('cuda')\r\n segments_tensors = segments_tensors.to('cuda')\r\n\r\n # Load pre-trained model (weights)\r\n # bert_model = BertForMaskedLM.from_pretrained('bert-large-uncased')\r\n # bert_model.eval()\r\n\r\n # If you have a GPU, put everything on cuda\r\n tokens_tensor = tokens_tensor.to('cuda')\r\n segments_tensors = segments_tensors.to('cuda')\r\n bert_model.to('cuda')\r\n\r\n # Predict all tokens\r\n with torch.no_grad():\r\n predictions = bert_model(tokens_tensor, segments_tensors)\r\n\r\n predictions = torch.nn.functional.softmax(predictions, -1)\r\n\r\n index = bert_tokenizer.convert_tokens_to_ids([masked_word])[0]\r\n\r\n curr_prob = predictions[0, masked_index][index]\r\n \r\n if curr_prob.item()!=0:\r\n #print(curr_prob.item())\r\n sentence_prob *= curr_prob.item()\r\n # predict_list = predictions[0, masked_index]\r\n \r\n #tokenized_text[masked_index] = masked_word\r\n #return math.pow(sentence_prob, 1/(len(tokenized_text)-3))\r\n return sentence_prob\r\n\r\n# Load pre-trained model tokenizer (vocabulary)\r\ntokenizer = BertTokenizer.from_pretrained('./tmp/swag_output')\r\n# Load pre-trained model (weights)\r\nmodel = BertForMaskedLM.from_pretrained('./tmp/swag_output')\r\nmodel.eval()\r\n\r\n# prob = predict(sentence_1, bert_model=model, bert_tokenizer=tokenizer)\r\n\r\nwith open(\"Sentence4leyang.txt\", \"r\") as f:\r\n file = f.readlines()\r\n\r\nnum = len(file)\r\ncount = 0\r\ncurr = 0\r\nfor i in file:\r\n label, sentence_1, sentence_2, sentence_3 = i.split(\"\\001\")\r\n \r\n print (label[0])\r\n prob_1 = predict(sentence_1, bert_model=model, bert_tokenizer=tokenizer)\r\n prob_2 = predict(sentence_2, bert_model=model, bert_tokenizer=tokenizer)\r\n prob_3 = predict(sentence_3, bert_model=model, bert_tokenizer=tokenizer)\r\n answer = max(prob_1, prob_2, prob_3)\r\n print(prob_1, prob_2, prob_3)\r\n\r\n```\r\nFor the txt file, you could just create some sentences to replace it.\r\nWe used the weight after fine-tuning the Bert with official run_swag.py example.", "If you finetuned a `BertForMultipleChoice` and load it in `BertForMaskedLM`some weights will be initialized randomly and not trained.\r\n\r\nThis is indicated in this part of your output:\r\n\r\n\r\nIf you use this model with un-trained weights you will have random output. You need to train these weights on a down-stream task.", "Hi, Thanks for the response. @thomwolf \r\nHowever, from my perspective, even if you use the vanilla `Bert-base-uncased` model, the `BertForMaskedLM` still runs perfectly without any random initialization. And I assume `BertForMultipleChoice` is simply the original `Bert-base-uncased` model with an additional linear classifier layer.\r\nTherefore, I think there should be a way to only keep the 'Bert model' but without the linear layer after fine-tuning. I think this feature could be really helpful for researchers to investigate the transferability of the models.", "No unfortunately.\r\n\r\nSo the model used for pretraining bert and the one we provide on our AWS S3 bucket is `BertForPretraining` which has 2 heads: (i) the masked lm head and (ii) the next sentence prediction head.\r\n\r\n`BertForMaskedLM` is a sub-set of `BertForPretraining` which keeps only the first head => all the weights are initialized with pretrained weights if you initialize it from the provided weights, you can use it out-of-the-box.\r\n\r\n`BertForMultipleChoice` does NOT have a masked lm head and has instead a multiple-choice head => if you train this model and use it to initialize a `BertForMaskedLM` you won't initialize the language model head.\r\n\r\nIf you don't remember: just look at the log during model initialization. If it's written `Weights from XXX not initialized from pretrained model` it means you have to train the model before using it.", "We will make the documentation more clear on that.\r\n\r\nFor your specific use-case, a solution could be to make a model your-self similarly to the way they are made in the library and keep the language modeling head as well as the other heads you want. And then fine-tune the newly added head on your dataset.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=h1) Report\n> Merging [#958](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #958 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=footer). Last update [44dd941...836e513](https://codecov.io/gh/huggingface/pytorch-transformers/pull/958?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Nice!" ]

[]

[]

[]

[]

[]

[ "The framework has been updated to store all additional special tokens in `additional_special_tokens` list and custom tokens are no longer available through class attributes." ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=h1) Report\n> Merging [#955](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `100%`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #955 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/modeling\\_bert.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfYmVydC5weQ==) | `87.98% <100%> (ø)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=footer). Last update [44dd941...a24f830](https://codecov.io/gh/huggingface/pytorch-transformers/pull/955?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Thanks!" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Hi, not only they give different results, but also BertModel(BertConfig.from_pretrained('bert-base-uncased')) will give a different result each time you run it. **Other bert models also have this problem**; I think this is a bug. @thomwolf \r\n\r\nFollowing code works well and produce the same result each time you run it.\r\n___________________________\r\nimport torch\r\nfrom pytorch_transformers import BertTokenizer, BertModel, BertConfig\r\nimport numpy as np\r\n\r\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\r\nmodel = BertModel.from_pretrained('bert-base-uncased')\r\nmodel.eval()\r\ninput_ids = torch.tensor(tokenizer.encode(\"Hello, my dog is cute\")).unsqueeze(0) # Batch size 1\r\noutputs = model(input_ids)\r\na = np.squeeze(outputs[0].detach().numpy())\r\navg = np.mean(a,axis = 0)\r\nprint(avg[0])\r\n\r\n\r\n**Above code will always output -0.2769656.**\r\n___________________________\r\nFollowing code will produce a different result each time:\r\n__________________________\r\nconfig = BertConfig.from_pretrained('bert-base-uncased')\r\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\r\nmodel = BertModel(config)\r\nmodel.eval()\r\ninput_ids = torch.tensor(tokenizer.encode(\"Hello, my dog is cute\")).unsqueeze(0) \r\noutputs = model(input_ids)\r\nlast_hidden_states = outputs[0]\r\na = np.squeeze(last_hidden_states[0].detach().numpy())\r\navg = np.mean(a,axis = 0)\r\nprint(avg[0])", "It seems that BertModel(config) returns a random intialized Bert model with the architecture as the config file indicates, because the __init__ function doesn't load pretrained weights. BertModel.from_pretrained() is the right function to load both model architecture and pretrained weights. It's the same for other bert classes.", "Shouldn't BertConfig.from_pretrained('bert-base-uncased') return a config that loads pretrained weights instead of randomly initialized ones? I thought was the whole point of the example code in the [docs](https://huggingface.co/pytorch-transformers/model_doc/bert.html#bertformaskedlm):\r\n\r\n\r\nconfig = BertConfig.from_pretrained('bert-base-uncased')\r\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\r\n\r\nmodel = BertForMaskedLM(config)\r\ninput_ids = torch.tensor(tokenizer.encode(\"Hello, my dog is cute\")).unsqueeze(0) # Batch size 1\r\noutputs = model(input_ids, masked_lm_labels=input_ids)\r\nloss, prediction_scores = outputs[:2]", "It should return a config that loads pretrained models; however it does not act like this way.\n\n\nSent from Yahoo Mail for iPhone\n\n\nOn Sunday, August 4, 2019, 4:32 PM, Christian Storm <[email protected]> wrote:\n\n\nShouldn't BertConfig.from_pretrained('bert-base-uncased') return a config that loads pretrained weights instead of randomly initialized ones? I thought was the whole point of the example code in the docs:\n\nconfig = BertConfig.from_pretrained('bert-base-uncased')\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n\nmodel = BertForMaskedLM(config)\ninput_ids = torch.tensor(tokenizer.encode(\"Hello, my dog is cute\")).unsqueeze(0) # Batch size 1\noutputs = model(input_ids, masked_lm_labels=input_ids)\nloss, prediction_scores = outputs[:2]\n\n—\nYou are receiving this because you commented.\nReply to this email directly, view it on GitHub, or mute the thread.\n\n\n\n", "You are right, the example in the doc is misleading.\r\n\r\nThe only way to load pretrained weights in a `model` is to call a `model_class.from_pretrained()` method. I'll fix the doc.", "I've fixed the examples of loading pretrained models in docstrings :-) #973 ", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "You should make a class deriving from `GPT2Model` in which:\r\n- the `__init__` method\r\n * calls its super class `__init__` method (to add the original GPT2 modules),\r\n * you then add the new modules (with names differents from GPT2 original attributes so you don't overwrite over them).\r\n * you call `self.init_weights()` at the end to initalize your weights (check the `init_weights` method in `GPT2PreTrainedModel` to be sure it initialize as you want to)\r\n- the `forward` method has to be written as you want the forward pass to be.\r\n\r\nYou can then load the pretrained weights and initialize your newly added weights just by doing the usual `model = MyGPT2Model.form_pretrained('gpt2')`.", "Thanks @thomwolf . Just to clarify, does that mean if I need to change the attention layer a little bit, then I have to make three classes derived from ``` GPT2Model``` , ```Block``` ,and ```Attention```? And for that, can I use the original Attention modules inside my forward pass of myAttention?\r\n\r\nShould it be something like following?\r\n```\r\nclass myAttention(Attention):\r\n def __init__(self, nx, n_ctx, config, scale=False):\r\n super(myAttention, self).__init__()\r\n\r\n def forward(): ### my customized forward pass\r\n\r\n\r\nclass myBlock(Block):\r\n def __init__(self, n_ctx, config, scale=False):\r\n super(myBlock, self).__init__()\r\n def forward(...): ### my customized forward pass\r\n\r\nclass myGPT2Model(GPT2Mode):\r\n def __init__(self, config):\r\n super(myGPT2Model, self).__init__(config)\r\n ....\r\n self.apply(self.init_weights)\r\n def forward(...). ### my customized forward pass\r\n```\r\n", "Maybe but it depends on what you put in the `....` parts", "@thomwolf Is it right that I have to have three separate classes each derived from ```GPT2Model```, ```Block``` and ```Attention``` ?\r\nIn general, I want to have one additional input to myGPT2Model forward method and I want to incorporate that in the Attention computation.\r\nWhat I did is I added that aux input to fw of ```myGPT2Model```, I called the block inside myGPT2Model forward with original and aux input,\r\nThen in the myBlock forward method, I called Attention with the two inputs.", "Probably right.\r\n\r\nMaybe the easiest in your case would be to copy the `modeling_gpt2` file in whole and modify what you need in the copy.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=h1) Report\n> Merging [#952](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #952 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n| [Impacted Files](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=tree) | Coverage Δ | |\n|---|---|---|\n| [pytorch\\_transformers/modeling\\_gpt2.py](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952/diff?src=pr&el=tree#diff-cHl0b3JjaF90cmFuc2Zvcm1lcnMvbW9kZWxpbmdfZ3B0Mi5weQ==) | `75.84% <ø> (ø)` | :arrow_up: |\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=footer). Last update [44dd941...d40e827](https://codecov.io/gh/huggingface/pytorch-transformers/pull/952?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Thanks, I think we'll stick with `gpt2`, `gpt2-medium` and `gpt2-large` for now.\r\n(also because these number of parameters are actually wrong, the models are respectively 124M and 355M parameters as indicated in the [updated readme of gpt-2](https://github.com/openai/gpt-2#gpt-2))" ]

[]

[]

[ "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=h1) Report\n> Merging [#951](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #951 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=footer). Last update [44dd941...a5e7d11](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "# [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=h1) Report\n> Merging [#951](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=desc) into [master](https://codecov.io/gh/huggingface/pytorch-transformers/commit/44dd941efb602433b7edc29612cbdd0a03bf14dc?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=tree)\n\n```diff\n@@ Coverage Diff @@\n## master #951 +/- ##\n=======================================\n Coverage 79.04% 79.04% \n=======================================\n Files 34 34 \n Lines 6242 6242 \n=======================================\n Hits 4934 4934 \n Misses 1308 1308\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=footer). Last update [44dd941...a5e7d11](https://codecov.io/gh/huggingface/pytorch-transformers/pull/951?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n", "Added a few comments. If you take a look at the `run_glue` and `run_squad` examples, you'll see they are much simpler now in term of optimizer setup. This example could take advantage of the same refactoring if you want to give it a look!", "Thanks for this @jeff-da, we'll close this PR in favor of #1004 for now.\r\nFeel free to re-open if there are other things you would like to change." ]

[]

[]

[ "Thanks!" ]

[]

[]

[ "These weights are not pretrained, they are added for fine-tuning the model on a downstream question answering task. You have to train the `qa_output` weights.\r\nThey are initialized randomly and so will be different at each run." ]

[]

[]

[ "Hi, there are examples in the \"examples\" folder on finetuning language models. Please take a look at [the scripts available here](https://github.com/huggingface/pytorch-transformers/tree/master/examples/lm_finetuning)." ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Maybe we can use the same issue so the people following #822 can learn from your experiments as well?", "I'm using xlnet-large-cased.\r\nAt first I got \r\n{\r\n \"exact\": 75.91296121097446,\r\n \"f1\": 83.19559419987176,\r\n \"total\": 10570,\r\n \"HasAns_exact\": 75.91296121097446,\r\n \"HasAns_f1\": 83.19559419987176,\r\n \"HasAns_total\": 10570\r\n}\r\n\r\nThen I took a look at the XLNet repo and found the current preprocessing in transfomers is a little off. For the XLNet repo, they have P SEP Q SEP CLS, but the preprocessing code in this repo has CLS Q SEP P SEP. I tried to follow the XLNet repo preprocessing code and the hyper parameters in the paper and now I have \r\n{\r\n \"exact\": 84.37086092715232,\r\n \"f1\": 92.01817406538726,\r\n \"total\": 10570,\r\n \"HasAns_exact\": 84.37086092715232,\r\n \"HasAns_f1\": 92.01817406538726,\r\n \"HasAns_total\": 10570\r\n}\r\n\r\nHere are my preprocessing code with the changes. Sorry it's a bit messy. I will create a PR next week. \r\n````\r\n# xlnet\r\ncls_token = \"[CLS]\"\r\nsep_token = \"[SEP]\"\r\npad_token = 0\r\nsequence_a_segment_id = 0\r\nsequence_b_segment_id = 1\r\ncls_token_segment_id = 2\r\n# Should this be 4, or it doesn't matter?\r\npad_token_segment_id = 3\r\ncls_token_at_end = True\r\nmask_padding_with_zero = True\r\n# xlnet\r\n\r\nqa_features = []\r\n\r\n# unique_id identified unique feature/label pairs. It's different\r\n# from qa_id in that each qa_example can be broken down into\r\n# multiple feature samples if the paragraph length is longer than\r\n# maximum sequence length allowed\r\nquery_tokens = tokenizer.tokenize(example.question_text)\r\n\r\nif len(query_tokens) > max_question_length:\r\n\tquery_tokens = query_tokens[0:max_question_length]\r\n# map word-piece tokens to original tokens\r\ntok_to_orig_index = []\r\n# map original tokens to corresponding word-piece tokens\r\norig_to_tok_index = []\r\nall_doc_tokens = []\r\nfor (i, token) in enumerate(example.doc_tokens):\r\n\torig_to_tok_index.append(len(all_doc_tokens))\r\n\tsub_tokens = tokenizer.tokenize(token)\r\n\tfor sub_token in sub_tokens:\r\n\t\ttok_to_orig_index.append(i)\r\n\t\tall_doc_tokens.append(sub_token)\r\n\r\ntok_start_position = None\r\ntok_end_position = None\r\nif is_training and example.is_impossible:\r\n\ttok_start_position = -1\r\n\ttok_end_position = -1\r\nif is_training and not example.is_impossible:\r\n\ttok_start_position = orig_to_tok_index[example.start_position]\r\n\tif example.end_position < len(example.doc_tokens) - 1:\r\n\t\t# +1: move the the token after the ending token in\r\n\t\t# original tokens\r\n\t\t# -1, moves one step back\r\n\t\t# these two operations ensures word piece is covered\r\n\t\t# when it's part of the original ending token.\r\n\t\ttok_end_position = orig_to_tok_index[example.end_position + 1] - 1\r\n\telse:\r\n\t\ttok_end_position = len(all_doc_tokens) - 1\r\n\t(tok_start_position, tok_end_position) = _improve_answer_span(\r\n\t\tall_doc_tokens,\r\n\t\ttok_start_position,\r\n\t\ttok_end_position,\r\n\t\ttokenizer,\r\n\t\texample.orig_answer_text,\r\n\t)\r\n\r\n# The -3 accounts for [CLS], [SEP] and [SEP]\r\nmax_tokens_for_doc = max_seq_len - len(query_tokens) - 3\r\n\r\n# We can have documents that are longer than the maximum sequence length.\r\n# To deal with this we do a sliding window approach, where we take chunks\r\n# of the up to our max length with a stride of `doc_stride`.\r\n_DocSpan = collections.namedtuple(\"DocSpan\", [\"start\", \"length\"])\r\ndoc_spans = []\r\nstart_offset = 0\r\nwhile start_offset < len(all_doc_tokens):\r\n\tlength = len(all_doc_tokens) - start_offset\r\n\tif length > max_tokens_for_doc:\r\n\t\tlength = max_tokens_for_doc\r\n\tdoc_spans.append(_DocSpan(start=start_offset, length=length))\r\n\tif start_offset + length == len(all_doc_tokens):\r\n\t\tbreak\r\n\tstart_offset += min(length, doc_stride)\r\n\r\nfor (doc_span_index, doc_span) in enumerate(doc_spans):\r\n\tif is_training:\r\n\t\tunique_id += 1\r\n\telse:\r\n\t\tunique_id += 2\r\n\r\n\ttokens = []\r\n\ttoken_to_orig_map = {}\r\n\ttoken_is_max_context = {}\r\n\tsegment_ids = []\r\n\r\n\t# p_mask: mask with 1 for token than cannot be in the answer\r\n\t# (0 for token which can be in an answer)\r\n\t# Original TF implem also keep the classification token (set to 0), because\r\n\t# cls token represents prediction for unanswerable question\r\n\tp_mask = []\r\n\r\n\t# CLS token at the beginning\r\n\tif not cls_token_at_end:\r\n\t\ttokens.append(cls_token)\r\n\t\tsegment_ids.append(cls_token_segment_id)\r\n\t\tp_mask.append(0)\r\n\t\tcls_index = 0\r\n\r\n\r\n\t# Paragraph\r\n\tfor i in range(doc_span.length):\r\n\t\tsplit_token_index = doc_span.start + i\r\n\t\ttoken_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\r\n\r\n\t\t## TODO: maybe this can be improved to compute\r\n\t\t# is_max_context for each token only once.\r\n\t\tis_max_context = _check_is_max_context(doc_spans, doc_span_index, split_token_index)\r\n\t\ttoken_is_max_context[len(tokens)] = is_max_context\r\n\t\ttokens.append(all_doc_tokens[split_token_index])\r\n\t\t# xlnet\r\n\t\t# segment_ids.append(sequence_b_segment_id)\r\n\t\tsegment_ids.append(sequence_a_segment_id)\r\n\t\t# xlnet ends\r\n\t\tp_mask.append(0)\r\n\tparagraph_len = doc_span.length\r\n\r\n\t# xlnet\r\n\ttokens.append(sep_token)\r\n\tsegment_ids.append(sequence_a_segment_id)\r\n\tp_mask.append(1)\r\n\r\n\ttokens += query_tokens\r\n\tsegment_ids += [sequence_b_segment_id] * len(query_tokens)\r\n\tp_mask += [1] * len(query_tokens)\r\n\t# xlnet ends\r\n\r\n\t# SEP token\r\n\ttokens.append(sep_token)\r\n\tsegment_ids.append(sequence_b_segment_id)\r\n\tp_mask.append(1)\r\n\r\n\t# CLS token at the end\r\n\tif cls_token_at_end:\r\n\t\ttokens.append(cls_token)\r\n\t\tsegment_ids.append(cls_token_segment_id)\r\n\t\tp_mask.append(0)\r\n\t\tcls_index = len(tokens) - 1 # Index of classification token\r\n\r\n\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\r\n\t# tokens are attended to.\r\n\tinput_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\r\n\r\n\t# Zero-pad up to the sequence length.\r\n\tif len(input_ids) < max_seq_len:\r\n\t\tpad_token_length = max_seq_len - len(input_ids)\r\n\t\tpad_mask = 0 if mask_padding_with_zero else 1\r\n\t\tinput_ids += [pad_token] * pad_token_length\r\n\t\tinput_mask += [pad_mask] * pad_token_length\r\n\t\tsegment_ids += [pad_token_segment_id] * pad_token_length\r\n\t\tp_mask += [1] * pad_token_length\r\n\r\n\tassert len(input_ids) == max_seq_len\r\n\tassert len(input_mask) == max_seq_len\r\n\tassert len(segment_ids) == max_seq_len\r\n\tassert len(p_mask) == max_seq_len\r\n\r\n\tspan_is_impossible = example.is_impossible\r\n\tstart_position = None\r\n\tend_position = None\r\n\tif is_training and not span_is_impossible:\r\n\t\t# For training, if our document chunk does not contain an annotation\r\n\t\t# we throw it out, since there is nothing to predict.\r\n\t\tdoc_start = doc_span.start\r\n\t\tdoc_end = doc_span.start + doc_span.length - 1\r\n\t\tout_of_span = False\r\n\t\tif not (tok_start_position >= doc_start and tok_end_position <= doc_end):\r\n\t\t\tout_of_span = True\r\n\t\tif out_of_span:\r\n\t\t\tstart_position = 0\r\n\t\t\tend_position = 0\r\n\t\t\tspan_is_impossible = True\r\n\t\telse:\r\n\t\t\t# +1 for [CLS] token\r\n\t\t\t# +1 for [SEP] token\r\n\t\t\t# xlnet\r\n\t\t\t# doc_offset = len(query_tokens) + 2\r\n\t\t\tdoc_offset = 0\r\n\t\t\t# xlnet ends\r\n\t\t\tstart_position = tok_start_position - doc_start + doc_offset\r\n\t\t\tend_position = tok_end_position - doc_start + doc_offset\r\n\r\n\tif is_training and span_is_impossible:\r\n\t\tstart_position = cls_index\r\n\t\tend_position = cls_index\r\n```\r\n", "@hlums @Colanim that's amazing, thank you! did you also experiment with SQuAD 2.0? I'm having issues training anything even remotely decent, and deciding whether to answer or not (NoAnswer) seems to be the problem.", "> @hlums @Colanim that's amazing, thank you! did you also experiment with SQuAD 2.0? I'm having issues training anything even remotely decent, and deciding whether to answer or not (NoAnswer) seems to be the problem.\r\n\r\nI haven't got a chance to try SQuAD 2.0. My guess is that since the CLS token is needed in SQuAD 2.0 to predict unanswerable questions, when the CLS token is misplaced, the impact on the model performance is bigger. ", "This is great @hlums! looking forward to a PR updating the example if you have time", "Updating after I read comments in #1405 carefully. \r\nI've created a local branch with my changes. I will validate it over the weekend.\r\nI'm trying to push my branch to remote and got an access denied error. \r\nThis is how I cloned the repo\r\ngit clone https://hlums:<my personal access token\\>@github.com/huggingface/transformers/\r\nAny one can help? ", "@hlums hey you can just fork this repo, make your changes in your version of the repo, and then do a pull request - that should work", "My change is completely independent of data input and preprocessing — it just adjusts a few gemm and batchedGemm calls in the XLNetLayer to be more efficient. I referenced the related issues to give context to the exact f1 scores I was making sure I got on each version of the code. So I believe your PR is very much necessary and important :)\r\n\r\nEdit: Original context of the email I replied to as I don't see it here anymore:\r\n@slayton58 , is your change in the modelling code equivalent to changing the order of the tokens in the preprocessing code?", "Thanks for the clarification @slayton58! I figured it out after reading the comments in you PR more carefully. :)", "Thank you guys! I solved the permission denied issue by git clone using ssh instead of https. Not sure why I never had this issue with my company's repos. \r\nAnyway, I forked the repo (https://github.com/hlums/transformers) and pushed my changes to it. \r\nHowever, I'm still having issue running the run_squad.py script. I'm getting \"/data/anaconda/envs/py35/bin/python: Relative module names not supported\"\r\n\r\nHere are what I did\r\n```\r\nconda install pytorch\r\ncd transformers\r\npip install --editable .\r\nbash run_squad.sh\r\n```\r\nThe content of my bash script is following\r\n```\r\npython -m ./examples/run_squad.py \\\r\n --model_type xlnet \\\r\n --model_name_or_path xlnet-large-cased \\\r\n --do_train \\\r\n --do_eval \\\r\n --do_lower_case \\\r\n --train_file /data/home/hlu/notebooks/NLP/examples/question_answering/train-v1.1.json \\\r\n --predict_file /data/home/hlu/notebooks/NLP/examples/question_answering/dev-v1.1.json \\\r\n --learning_rate 3e-5 \\\r\n --num_train_epochs 2 \\\r\n --max_seq_length 384 \\\r\n --doc_stride 128 \\\r\n --output_dir ./wwm_cased_finetuned_squad/ \\\r\n --per_gpu_eval_batch_size=4 \\\r\n --per_gpu_train_batch_size=4 \\\r\n```", "@hlums\r\nIs your configuration single or multi-GPU?\r\nUsing Pytorch==1.3.0 and Transformers=2.1.1?\r\n\r\nThe reason I ask is that with 2 x 1080Ti NVIDIAs trying to run_squad.py on XLNet & BERT models, I experience data-parallel-run and distributed-performance-reporting (key error) failures. Perhaps you have the solution to either/both?", "@ahotrod I'm using Pytorch 1.2.0. I have 4 NVIDIA V100. \r\nHow are you running the script? Are you calling python -m torch.distributed.launch...? Can you try removing torch.distributed.launch? I think it's intended to be used for multi-node training in the way run_squad.py is written, although it can be used for multi-GPU training if we make some changes to run_squad.py. ", "@ahotrod I've been seeing key errors only when running eval in distributed -- training is fine (and I've run quite a few full 8xV100 distributed finetunings in the last few weeks), but I have to drop back to `DataParallel` for eval to work.", "@hlums @slayton58 Thank you both for informative, helpful replies.\r\n\r\n** Updated, hope I adequately explain my work-around **\r\n\r\nI prefer distributed processing for the training speed-up, plus my latest data parallel runs have been loading one of <parameters & buffers> on cuda:1 and shutting down. As recommended I dropped the `do_eval` argument and ran my distributed shell script below, which worked fine. I then ran a `do_eval` script on a single GPU to generate the `predictions_.json` file, which I don't get from a distributed script when including `do_eval` (key error).\r\n\r\nHere's my distributed fine-tuning script:\r\n```\r\nSQUAD_DIR=/media/dn/dssd/nlp/transformers/examples/squad1.1\r\nexport OMP_NUM_THREADS=6\r\n\r\npython -m torch.distributed.launch --nproc_per_node=2 ./run_squad.py \\\r\n --model_type xlnet \\\r\n --model_name_or_path xlnet-large-cased \\\r\n --do_train \\\r\n --do_lower_case \\\r\n --train_file ${SQUAD_DIR}/train-v1.1.json \\\r\n --predict_file ${SQUAD_DIR}/dev-v1.1.json \\\r\n --num_train_epochs 3 \\\r\n --learning_rate 3e-5 \\\r\n --max_seq_length 384 \\\r\n --doc_stride 128 \\\r\n --save_steps=10000 \\\r\n --per_gpu_train_batch_size 1 \\\r\n --gradient_accumulation_steps 4 \\\r\n --output_dir ./runs/xlnet_large_squad1_dist_X \\\r\n```\r\nwhich maxes-out my 2 x 1080Ti GPUs (0: hybrid, 1: open-frame cooling):\r\n```\r\n***** Running training *****\r\nNum examples = 89993\r\nNum Epochs = 3\r\nInstantaneous batch size per GPU = 1\r\nTotal train batch size (w. parallel, distributed & accumulation) = 8\r\nGradient Accumulation steps = 4\r\nTotal optimization steps = 33747\r\n\r\nNVIDIA-SMI 430.50 Driver Version: 430.50 CUDA Version: 10.1\r\n\r\n0 GeForce GTX 1080Ti\r\n0% 51C P2 256W / 250W | 10166MiB / 11178MiB | 100%\r\n\r\n1 GeForce GTX 1080Ti\r\n35% 65C P2 243W / 250W | 10166MiB / 11178MiB | 99% \r\n```\r\nAfter 3 epochs & ~21 hours, here are the results, similar to @Colanim :\r\n```\r\n***** Running evaluation *****\r\nNum examples = 11057\r\nBatch size = 32\r\n{\r\n \"exact\": 75.01419110690634,\r\n \"f1\": 82.13017516396678,\r\n \"total\": 10570,\r\n \"HasAns_exact\": 75.01419110690634,\r\n \"HasAns_f1\": 82.13017516396678,\r\n \"HasAns_total\": 10570\r\n}\r\n```\r\ngenerated from my single GPU `do_eval` script pointing to the distributed fine-tuned model (path):\r\n```\r\nCUDA_VISIBLE_DEVICES=0 python run_squad.py \\\r\n --model_type xlnet \\\r\n --model_name_or_path ${MODEL_PATH} \\\r\n --do_eval \\\r\n --do_lower_case \\\r\n --train_file ${SQUAD_DIR}/train-v1.1.json \\\r\n --predict_file ${SQUAD_DIR}/dev-v1.1.json \\\r\n --per_gpu_eval_batch_size 32 \\\r\n --output_dir ${MODEL_PATH}\r\n```\r\nThis model performs well in my Q&A application, but looking forward to @hlums pre-processing code, the imminent RoBERTa-large-SQuAD2.0, and perhaps one-day, ALBERT for the low-resource user that I am.", "OK. Figured out the relative module import issue. Code is running now and should have the PR tomorrow if nothing else goes wrong. ", "PR is here #1549. My current result is\r\n{\r\n\"exact\": 85.45884578997162,\r\n\"f1\": 92.5974600601065,\r\n\"total\": 10570,\r\n\"HasAns_exact\": 85.45884578997162,\r\n\"HasAns_f1\": 92.59746006010651,\r\n\"HasAns_total\": 10570\r\n}\r\n\r\nStill a few points lower than what's reported in the XLNet paper, but we made some progress. :)", "How to convert \r\ncls_logits: (optional, returned if start_positions or end_positions is not provided)\r\nto probabilities values between 0 to 1?", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Which command did you use to \"naively\" feed in the memory states?\r\nYou can just feed the mems that you get from the previous forward pass, but the inputs need to be the continuation of the previous input. So the batch_size, in particular, should stay the same.", "I found this post that talks about how to organize the inputs: https://mlexplained.com/2019/07/04/building-the-transformer-xl-from-scratch/\r\n\r\nIs there an example for how to adapt this for classification? Right now the data is organized as `(batch_size x max_seq_length)` and labels are `batch_size`. Each example in the batch represents a sentence, where multiple sentences may come from the same document. For simplicity we can assume they are all from the same document.", "I was looking at doing the same with TransformerXL, but ran into this same issue regarding how to adapt the label vector to work with the data matrix when trying to do classification. I'd appreciate any help from people that have successfully implemented this.", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[ { "id": 1314768611, "node_id": "MDU6TGFiZWwxMzE0NzY4NjEx", "url": "https://api.github.com/repos/huggingface/transformers/labels/wontfix", "name": "wontfix", "color": "ffffff", "default": true, "description": null } ]

[]

[ "Which command can we use to reproduce the behavior?", "Upon further testing, looks like this tokenizer doesn't like numpy arrays, the other ones seem to be fine\r\n```\r\nimport numpy as np\r\nfrom pytorch_transformers import XLNetTokenizer, TransfoXLTokenizer, BertTokenizer\r\n\r\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\r\nprint(tokenizer.convert_ids_to_tokens(np.array([3, 4, 6, 2356])))\r\ntokenizer = TransfoXLTokenizer.from_pretrained('transfo-xl-wt103')\r\nprint(tokenizer.convert_ids_to_tokens(np.array([3, 4, 6, 2356])))\r\ntokenizer = XLNetTokenizer.from_pretrained('xlnet-base-cased')\r\nprint(tokenizer.convert_ids_to_tokens(np.array([3, 4, 6, 2356]).tolist()))\r\nprint(tokenizer.convert_ids_to_tokens(np.array([3, 4, 6, 2356]))) # Above error\r\n```", "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.\n" ]

[]

[]

[ "Thanks", "@thomwolf please, note: the first example hasn't been fixed by the commit.", "Yes, doesn't look like a problem to me. Usually, people put the model in training mode inside the train function (and even inside the training loop I would recommend).", "Ok, got it!" ]