RobertaTokenizerFast does not add special tokens
I'm not sure whether this should be a part of tokenizers or transformers, because it uses both. Classes that don't work are from `transformers` so I'm posting it here.


## Environment info

- `transformers` version: 4.3.3
- Platform: Colab
- PyTorch version (GPU?): n/a
- Tensorflow version (GPU?): n/a
- Using GPU in script?: no
- Using distributed or parallel set-up in script?: no

### Who can help
- tokenizers: @n1t0, @LysandreJik 

## Information

### Reproduction code
https://colab.research.google.com/drive/1iYLBLzXRkQpdPyVlIdi_qNCzfbD1uwGs?usp=sharing

When loading tokenizer trained using `tokenizers` from transformers, e.g.
```python
tfast = RobertaTokenizerFast.from_pretrained("./workdir/tokenizer", model_max_length=10)
```
it does not add special tokens
```python
tfast("asd", add_special_tokens=True)
```

```
{'input_ids': [400, 72], 'attention_mask': [1, 1]}
```

"Slow" version behaves correctly:
```python
tslow = RobertaTokenizer.from_pretrained("./workdir/tokenizer", model_max_length=10)
tslow("asd", add_special_tokens=True)
```

```
{'input_ids': [0, 400, 72, 2], 'attention_mask': [1, 1, 1, 1]}
```

## Expected behavior

Both tokenizers produce the same output.

Hi, thanks for opening an issue. Indeed, I can reproduce. The conversion to IDs happens in the `encode_batch` method in `tokenizers` directly, which doesn't return the special tokens even though it correctly receives `add_special_tokens=True`. The tokenizer object in transformers also seems to have the correct `special_tokens_map`.

@n1t0, is this an issue from `tokenizers` side? If we're not correctly passing something to the Rust tokenizer when instantiating a it from files, happy to look into it.<|||||>Discussed the issue with @n1t0 and the issue comes from the fact that the special tokens must be added to the tokenizer via a [post-processor](https://huggingface.co/docs/tokenizers/python/latest/api/reference.html?highlight=post#module-tokenizers.processors).

If it isn't done, then tokenizers cannot have their special tokens. The slow tokenizers having them anyway is linked to their initialization and not to the tokenizer you generated using the `tokenizers` library.

Here is a gist made from your colab showing how the post-processor should be used: https://gist.github.com/LysandreJik/04c7cfe3d2656ae1c4c388ce9cdd3ea4<|||||>Thanks @LysandreJik for the reply!
So it's more like a misconfiguration of the training pipeline on my side, not a bug per se?<|||||>Yes, I believe that is so. Tokenizers created with `tokenizers` need to have their post-processors/pre-tokenizers and other components defined to work correctly, otherwise it yields unexpected results as we have just seen!<|||||>Closing, but still seems odd that the behaviour for exact same files is different between those tokenizers...