Model call with `inputs_embeds` does not match that with `input_ids`
# 🐛 Bug

## Information

Model I am using (Bert, XLNet ...): Bert

Language I am using the model on (English, Chinese ...): English

The problem arises when using: my own modified scripts: (details below)

## To reproduce

Steps to reproduce the behavior:

```
import tensorflow as tf
from transformers import BertConfig, BertTokenizer, TFBertModel

bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

input_ids = tf.constant(bert_tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[None, :]
attention_mask = tf.stack([tf.ones(shape=(len(sent),)) for sent in input_ids])
token_type_ids = tf.stack([tf.ones(shape=(len(sent),)) for sent in input_ids])

config = BertConfig.from_pretrained('bert-base-uncased', output_hidden_states=True)
bert_model = TFBertModel.from_pretrained('bert-base-uncased', config=config)

result = bert_model(inputs={'input_ids': input_ids, 
                            'attention_mask': attention_mask, 
                             'token_type_ids': token_type_ids})
inputs_embeds = result[-1][0]
result2 = bert_model(inputs={'inputs_embeds': inputs_embeds, 
                            'attention_mask': attention_mask, 
                             'token_type_ids': token_type_ids})

print(tf.reduce_sum(tf.abs(result[0] - result2[0])))  # 458.2522, should be 0
```

## Expected behavior

The HuggingFace BERT TensorFlow implementation allows us to feed in a precomputed embedding in place of the embedding lookup that is native to BERT. This is done using the model's `call` method's optional parameter `inputs_embeds` (in place of `input_ids`). To test this out, I wanted to make sure that if I did feed in BERT's embedding lookup, I would get the same result as having fed in the `input_ids` themselves.

The result of BERT's embedding lookup can be obtained by setting the BERT configuration parameter `output_hidden_states` to `True` and extracting the first tensor from the last output of the call method. (The remaining 12 outputs correspond to each of the 12 hidden layers.)

Thus, I wrote the above code to test my hypothesis. The output of the `call` method is a tuple, and the first element of this tuple is the output of the last layer of BERT. Thus, I expected `result[0]` and `result2[0]` to match. Why is this not the case?

## Environment info
<!-- You can run the command `transformers-cli env` and copy-and-paste its output below.
     Don't forget to fill out the missing fields in that output! -->
     
- `transformers` version: 2.5.1
- Platform: Linux-3.10.0-1127.el7.x86_64-x86_64-with-debian-stretch-sid
- Python version: 3.6.10
- PyTorch version (GPU?): not installed (NA)
- Tensorflow version (GPU?): 2.1.0 (True)
- Using GPU in script?: No
- Using distributed or parallel set-up in script?: No

I was incorrectly treating the output of the first layer as the actual embedding lookup when it is in fact the embedding lookup *plus* positional and token type embeddings. See [here](https://stackoverflow.com/a/61704348/424306) for more details.