Tokenizer.tokenize return none on some utf8 string in current pypi version
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  

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 !