Tokenizers save_pretrained broken when defining vocab and merges file arguments (v3.1) 
## Problem Information

Since the upgrade to transformers v3, it appears that issues arise when defining a RoBERTa or BART tokenizer using the vocab_file and merges_file arguments. 

Previously defining the tokenizer, by supplying these two arguments resulted in a correctly configured tokenizer and enabled the tokenizer to be saved using the standard .save_pretrained() function. However, since the upgrade to v3, it appears that using such arguments causes the tokenizer to default to incorrect "init_kwargs".

## Replicating the problem

```py
from transformers import RobertaTokenizer

#load the tokenizer using the standard method - results in correct init_kwargs
correct_tokenizer = RobertaTokenizer.from_pretrained("roberta-large")

#save the tokenizer so the vocab and merges file can be read in from disk
correct_tokenizer.save_pretrained("file_path/roberta_tokenizer")

#load the saved vocab and merges files to create a new tokenizer with the same properties
broken_tokenizer = RobertaTokenizer(
          vocab_file="file_path/roberta_tokenizer/vocab.json",
          merges_file = "file_path/roberta_tokenizer/merges.txt"
          )

#attempt to save the second tokenizer using the same function as above
broken_tokenizer.save_pretrained("file_path/saved_folder")
```

In the above script, loading the tokenizer using the ".from_pretrained('roberta-large')" method results in a tokenizer with the correct properties. The tokenizer's init_kwargs are as expected, and in the form of a dictionary as follows:

- merges_file: "file/path/...",
- model_max_length: 512,
- vocab_file: "file/path/...",

This tokenizer can be saved using the ".save_pretrained()" function as intended.


However, when you load a tokenizer, while defining the "vocab_file=vocab.json" and "merges_file=merges.txt", as is the case with "broken_tokenizer", it appears that the init_kwargs defaults to incorrect properties. Unlike before the init_kwargs now present a dictionary with no mention of model configurations, but instead includes the following:

- bos_token: AddedToken(bos_token, lstrip=False, rstrip=False) 
- eos_token: AddedToken(eos_token, lstrip=False, rstrip=False)
- sep_token: AddedToken(sep_token, lstrip=False, rstrip=False)
- cls_token: AddedToken(cls_token, lstrip=False, rstrip=False)
- unk_token: AddedToken(unk_token, lstrip=False, rstrip=False) 
- pad_token: AddedToken(pad_token, lstrip=False, rstrip=False) 

## Error identification

The error in saving appears to arise when you reach the following section of the "save_pretrained()" function within tokenization_utils_base:

```py
tokenizer_config = copy.deepcopy(self.init_kwargs)
if len(self.init_inputs) > 0:
    tokenizer_config["init_inputs"] = copy.deepcopy(self.init_inputs)
for file_id in self.vocab_files_names.keys():
    tokenizer_config.pop(file_id, None)

with open(tokenizer_config_file, "w", encoding="utf-8") as f:
    f.write(json.dumps(tokenizer_config, ensure_ascii=False))
```

In the scenario where the tokenizer has the correct kwargs, the vocab_file and merges_file are popped from "tokenizer_config", leaving a tokenizer config that can be saved in JSON format. 

However, where the incorrect kwargs are configured, as is the case with "broken_tokenizer" above, the resulting "tokenizer_config" contains AddedToken objects, and therefore results in the following error:
**"TypeError: Object of type AddedToken is not JSON serializable"**

## Versioning
Transformers = 3.1
Tokenizers = 0.8.1rc2
I cannot reproduce the error on master with
```
transformers           4.0.0rc1
tokenizers             0.9.4
```<|||||>@thomwolf I think it must be specific to the particular version of transformers (v3.1)<|||||>This issue has been automatically marked as stale because it has not had recent activity. If you think this still needs to be addressed please comment on this thread.

Please note that issues that do not follow the [contributing guidelines](https://github.com/huggingface/transformers/blob/master/CONTRIBUTING.md) are likely to be ignored.