Handle shape mismatch when restoring pretrained weights
This is not a good approach imo, because it allows the chance that model weights are skipped with a warning only and training progresses as is. When developing on scheduled dispatchers like Slurm, we rarely every take constant look at slurm logs so this can silently introduce bugs.

The official way to change the decoder is using the provided method - it contructs a new randomly initialized decoder for you. If you only wish to load encoder weights, that is possibly as below

```python
old_ckpt = torch.load(...)
new_model = EncDecCTCModel(...)

# change decoder vocabular
new_model.change_vocabulary(...)

# do things manually (NOT ADVISED)
new_model.decoder = torch.nn.Sequential(...)
new_model.encoder.load_state_dict(old_ckpt['state_dict']['encoder'])
...
``` Thank you for the response! Yeah, that's a fair point. I'll just stick with the provided method then.
**Is your feature request related to a problem? Please describe.**
Loading pretrained weights onto a model with a slightly different architecture results in a shape mismatch error. This makes it unwieldy to use pretrained weights for fine-tuning a model with a different decoder shape (for example, ASR with a different vocab size). modelPT.restore_from has a strict=False option but will error if a layer has a similar name but different shape.

**Describe the solution you'd like**
My preferred approach is for restore_from to warn of shape mismatch and ignore loading weights in that circumstance. Something like this perhaps:
```
instance = cls.from_config_dict(config=conf)
instance = instance.to(map_location)

instance_state_dict = instance.state_dict()
state_dict = torch.load(model_weights, map_location=map_location)
if not strict:
    mismatched_layers = set()
    for k, v in state_dict.items():
        if k in instance_state_dict and instance_state_dict[k].shape != v.shape:
            mismatched_layers.add(k)
            logging.warning(f"Size mismatch for {k}: ignoring weights")
    [state_dict.pop(name) for name in mismatched_layers]

instance.load_state_dict(state_dict=state_dict, strict=strict)

logging.info(f'Model {cls.__name__} was successfully restored from {restore_path}.')
```