Camembert-base MaskedLM has different config settings that actual camambert-base
## Environment info
- `transformers` version: 4.1.1
- Platform: Linux-4.15.0-45-generic-x86_64-with-debian-10.2
- Python version: 3.7.3
- PyTorch version (GPU?): 1.7.1 (True)
- Tensorflow version (GPU?): 2.4.1 (False)
- Using GPU in script?: yes
- Using distributed or parallel set-up in script?: no

### Who can help
 @LysandreJik @sgugger 

## Information
Model I am using: [CamemBERT](https://huggingface.co/transformers/model_doc/camembert.html#camembert):

The problem arises when using:
[CamembertForMaskedLM](https://huggingface.co/transformers/model_doc/camembert.html#camembertformaskedlm)

The tasks I am working on is:
I am training Camambert model with MaskedLM head. (using a private dataset)

## To reproduce

Steps to reproduce the behaviour:

1. load camambert config file:
```python
from transformers import CamembertConfig
config = CamembertConfig()
config
```
output:
```
CamembertConfig {
  "attention_probs_dropout_prob": 0.1,
  "bos_token_id": 0,
  "eos_token_id": 2,
  "gradient_checkpointing": false,
  "hidden_act": "gelu",
  "hidden_dropout_prob": 0.1,
  "hidden_size": 768,
  "initializer_range": 0.02,
  "intermediate_size": 3072,
  "layer_norm_eps": 1e-12,
  "max_position_embeddings": 512,
  "model_type": "camembert",
  "num_attention_heads": 12,
  "num_hidden_layers": 12,
  "pad_token_id": 1,
  "position_embedding_type": "absolute",
  "type_vocab_size": 2,
  "vocab_size": 30522
}
```
2. load camambert tokenizer
```python
from transformers import CamembertTokenizer
tokenizer = CamembertTokenizer.from_pretrained(TOKENIZER_DIR)
```
3. load camembert for MLM
```
from transformers import CamembertForMaskedLM
model = CamembertForMaskedLM.from_pretrained( model_name_or_path, config=config)
```
output:
```python
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-94-3a1a4ae80b3a> in <module>
      1 from transformers import CamembertForMaskedLM
----> 2 model = CamembertForMaskedLM.from_pretrained( model_name_or_path, config=config)

/usr/local/lib/python3.7/site-packages/transformers/modeling_utils.py in from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs)
   1154                 raise RuntimeError(
   1155                     "Error(s) in loading state_dict for {}:\n\t{}".format(
-> 1156                         model.__class__.__name__, "\n\t".join(error_msgs)
   1157                     )
   1158                 )

RuntimeError: Error(s) in loading state_dict for CamembertForMaskedLM:
	size mismatch for roberta.embeddings.word_embeddings.weight: copying a param with shape torch.Size([32005, 768]) from checkpoint, the shape in current model is torch.Size([30522, 768]).
	size mismatch for roberta.embeddings.position_embeddings.weight: copying a param with shape torch.Size([514, 768]) from checkpoint, the shape in current model is torch.Size([512, 768]).
	size mismatch for roberta.embeddings.token_type_embeddings.weight: copying a param with shape torch.Size([1, 768]) from checkpoint, the shape in current model is torch.Size([2, 768]).
	size mismatch for lm_head.bias: copying a param with shape torch.Size([32005]) from checkpoint, the shape in current model is torch.Size([30522]).
	size mismatch for lm_head.decoder.weight: copying a param with shape torch.Size([32005, 768]) from checkpoint, the shape in current model is torch.Size([30522, 768]).

```

## Expected behavior

If I replace step 3 with:
```python
from transformers import CamembertForMaskedLM
model = CamembertForMaskedLM.from_pretrained( model_name_or_path)
````
I won't receive any error, but it's not the correct config details (`model.config`) when I print out the config details:
output:
```
CamembertConfig {
  "_name_or_path": "./models_weight/camembert-base",
  "architectures": [
    "CamembertForMaskedLM"
  ],
  "attention_probs_dropout_prob": 0.1,
  "bos_token_id": 5,
  "eos_token_id": 6,
  "gradient_checkpointing": false,
  "hidden_act": "gelu",
  "hidden_dropout_prob": 0.1,
  "hidden_size": 768,
  "initializer_range": 0.02,
  "intermediate_size": 3072,
  "layer_norm_eps": 1e-05,
  "max_position_embeddings": 514,
  "model_type": "camembert",
  "num_attention_heads": 12,
  "num_hidden_layers": 12,
  "output_past": true,
  "pad_token_id": 1,
  "position_embedding_type": "absolute",
  "type_vocab_size": 1,
  "vocab_size": 32005
}
```
The correct camembert config is provided [here](https://huggingface.co/camembert-base/resolve/main/config.json).
This issue has been automatically marked as stale because it has not had recent activity. If you think this still needs to be addressed please comment on this thread.

Please note that issues that do not follow the [contributing guidelines](https://github.com/huggingface/transformers/blob/master/CONTRIBUTING.md) are likely to be ignored.<|||||>This is still a problem and if someone could address this would be great. 
<|||||>Hello! You're instantiating a `CamembertConfig` without specifying any parameters, so it is initialized with the defaults (which are based on the BERT architecture as the configuration inherits from it).

It is not expected to be the same as `camembert-base`, nor is it specified in the documentation.

If you would like to obtain a configuration object that is the exact same as `camembert-base`, I would recommend instantiating your configuration object from that checkpoint:

```py
from transformers import CamembertConfig
config = CamembertConfig.from_pretrained("camembert-base")
```

You won't have a problem to load the model then:

```py
from transformers import CamembertForMaskedLM
model = CamembertForMaskedLM.from_pretrained("camembert-base", config=config)
```<|||||>This issue has been automatically marked as stale because it has not had recent activity. If you think this still needs to be addressed please comment on this thread.

Please note that issues that do not follow the [contributing guidelines](https://github.com/huggingface/transformers/blob/master/CONTRIBUTING.md) are likely to be ignored.