Sentence-transformers model outputs different than when loaded in HuggingFace
# 🐛 Bug

## Information

The outputs I'm seeing from generating sentence embeddings with the steps in the model zoo for getting sentence-transformers embeddings deviate from those generated from the SentenceTransformers package. 

I'm assuming this is due to the lack of pooling. Is there a way to convert a ST model to HF with pooling?

English

The problem arises when using:
* [x] the official example scripts: (give details below)
* [ ] my own modified scripts: (give details below)

The tasks I am working on is:
* [ ] an official GLUE/SQUaD task: (give the name)
* [x] my own task or dataset: (give details below)

## To reproduce

Steps to reproduce the behavior:

1. Load a pre-trained model from SentenceTransformers
2. Generate sentence embeddings from tokenized inputs
3. Print sentence embeddings

HuggingFace:
```python
#Sentences we want sentence embeddings for
sentences = ['This framework generates embeddings for each input sentence',
             'Sentences are passed as a list of string.',
             'The quick brown fox jumps over the lazy dog.']
tokenizer = AutoTokenizer.from_pretrained("roberta-large-nli-stsb-mean-tokens/0_RoBERTa/")
>>> model = AutoModel.from_pretrained("roberta-large-nli-stsb-mean-tokens/0_RoBERTa/")
>>> encoded_input = tokenizer(sentences, padding=True, truncation=True, max_length=128, return_tensors='pt')
>>> with torch.no_grad():
...     model_output = model(**encoded_input)
...     sentence_embeddings = model_output[0][:,0]
...
>>> print("Sentence embeddings:")
Sentence embeddings:
>>> print(sentence_embeddings)
tensor([[ 0.0057, -0.7690,  0.0702,  ...,  0.0734, -1.4343,  0.3418],
        [ 0.2066, -0.8213,  0.1272,  ...,  0.2649, -1.2799, -0.1636],
        [-0.4860, -0.5176, -0.5924,  ..., -0.4880, -0.1880, -0.0554]])
```

SentenceTransformers

```python
model = SentenceTransformer('roberta-large-nli-stsb-mean-tokens')
sentence_embeddings = model.encode(sentences)>>> sentence_embeddings = model.encode(sentences)
>>> sentence_embeddings = model.encode(sentences)
>>> print(sentence_embeddings)
[array([ 0.6306487 , -0.2879937 ,  0.05334993, ...,  0.26865923,
       -2.2382815 ,  0.22505784], dtype=float32), array([ 0.22068763, -0.8045991 ,  0.18439776, ...,  0.6993382 ,
       -1.7670776 ,  0.11258417], dtype=float32), array([-0.17819108,  0.08762542, -0.7614953 , ..., -0.6983883 ,
       -0.13175072, -0.11123852], dtype=float32)]
```

## Expected behavior

SentenceTransformer and HF outputs should be the same

## Environment info

```
- `transformers` version: 3.0.2
- Platform: Darwin-18.7.0-x86_64-i386-64bit
- Python version: 3.7.5
- PyTorch version (GPU?): 1.5.0 (False)
- Tensorflow version (GPU?): not installed (NA)
- Using GPU in script?: <fill in>
- Using distributed or parallel set-up in script?: <fill in>
```

This is just one of those days.. There's a[ mean pooling function](https://huggingface.co/sentence-transformers/bert-base-nli-mean-tokens) here that can be adapted.