Tokenizer.tokenize return none on some utf8 string in current pypi version
Author: voidful
Pull request: no

Tokenizer.tokenize return none on some utf8 string in current pypi version
## 🐛 Bug

<!-- Important information -->

Model I am using (Bert):

Language I am using the model on (English, Chinese....):

The problem arise when using:
* [ ] the official example scripts: 

The tasks I am working on is:
* [ ] my own task or dataset: SQUaD format, Chinese, DRCD

## To Reproduce
Current seems not updated 
Cause returning null result in  Tokenizer.tokenize when input some special utf8 string 

Steps to reproduce the behavior:

1. 
```
tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-uncased')
```
2.
```
text = "ุ"
tokenized_text = tokenizer.tokenize(text)
print(len(text.split()),len(text.strip().split()),text,tokenized_text,"\n")
```
3.
```
1 1 ุ [] 
```


## Expected behavior

I have try the implementation from GitHub, It seems to be fine : 
```
def whitespace_tokenize(text):
    """Runs basic whitespace cleaning and splitting on a piece of text."""
    text = text.strip()
    if not text:
        return []
    tokens = text.split()
    return tokens

def tokenize(text):
        output_tokens = []
        for token in whitespace_tokenize(text):
            chars = list(token)
            if len(chars) > 100:
                output_tokens.append("[UNK]")
                continue

            is_bad = False
            start = 0
            sub_tokens = []

            while start < len(chars):
                end = len(chars)
                cur_substr = None
                while start < end:
                    substr = "".join(chars[start:end])
                    if start > 0:
                        substr = "##" + substr
                    if substr in tokenizer.vocab:
                        cur_substr = substr
                        break
                    end -= 1
                if cur_substr is None:
                    is_bad = True
                    break
                sub_tokens.append(cur_substr)
                start = end

            if is_bad:
                output_tokens.append("[UNK]")
            else:
                output_tokens.extend(sub_tokens)
        return output_tokens

print(len(text.split()),len(text.strip().split()),text,tokenize(text),"\n")
```
Return 
```
1 1 ุ ['[UNK]'] 
```


## Colab demo : https://colab.research.google.com/drive/1WGu4dYLWtaPRPBq_YZEPvrmMALEFlCBn  


Comments:
We've seen this issues also with other tokenizers, like XLNet. 

It would be awesome to have a unified tokenization strategy (across all `Tokenizer` classes) that return `unk_token` in these cases. And of course we should discuss other possibilities here :)


@voidful this behavior arises because `bert-base-multilingual-uncased` is lower-casing the input (as the name indicates) and as such remove accents.

Your character is classified as an accent in the Unicode category database (see "Mn" [here](https://www.fileformat.info/info/unicode/category/index.htm)).

To fix this behavior, use the recommended multilingual model for Bert: `bert-base-multilingual-cased` instead of the one you are using (see the list of models and the recommended ones [here](https://huggingface.co/transformers/pretrained_models.html))

@stefan-it I think the other issues you are referring to are likely different from this one.
Feel free to open another issue if you want us to investigate them in detail.

Thank you for your help! It really solve the problem !