Accelerator FSDP state does not reflect the arguments fsdp_config
### System Info

- `transformers` version: 4.31.0
- Platform: Linux-4.18.0-477.15.1.el8_8.x86_64-x86_64-with-glibc2.28
- Python version: 3.9.17
- Huggingface_hub version: 0.16.4
- Safetensors version: 0.3.1
- Accelerate version: 0.21.0
- Accelerate config: not found
- PyTorch version (GPU?): 2.0.1 (True)
- Tensorflow version (GPU?): not installed (NA)
- Flax version (CPU?/GPU?/TPU?): not installed (NA)
- Jax version: not installed
- JaxLib version: not installed
- Using GPU in script?: yes
- Using distributed or parallel set-up in script?: yes, running in SLURM with multi-node and multi-GPU 

### Who can help?

_No response_

### Information

- [X] The official example scripts
- [ ] My own modified scripts

### Tasks

- [X] An officially supported task in the `examples` folder (such as GLUE/SQuAD, ...)
- [ ] My own task or dataset (give details below)

### Reproduction

Using the official `run_clm.py` script with FSDP enabled:
```
python run_clm.py \
    --model_name_or_path facebook/opt-350m \
    --dataset_name wikitext \
    --dataset_config_name wikitext-2-raw-v1 \
    --per_device_train_batch_size 8 \
    --per_device_eval_batch_size 8 \
    --do_train \
    --do_eval \
    --output_dir output \
    --fsdp "shard_grad_op auto_wrap"  --fsdp_config fsdp_config.json
```

where `fsdp_config.json` looks like:
```
{                                                                                                                                            
    "sharding_strategy": "shard_grad_op auto_wrap",                                                                                    
    "fsdp_transformer_layer_cls_to_wrap": "OPTDecoderLayer",                                                                                  
    "sync_module_states": true                                                                                                               
} 
```

### Expected behavior

We expect to use the sharding strategy `shard_grad_op`, but the accelerator is not instantiated with the fsdp config in `create_accelerator_and_postprocess()`. As a result, if we print out `self.accelerator.state.fsdp_plugin.sharding_strategy` at the end of `__init__`, we get the default sharding strategy `full_shard`, even though `self.fsdp == shard_grad_op`.

I did not set the sharding strategy using `accelerate config` since I'm experimenting with different strategy and I believe it would make sense to overwrite the default strategy with the input config.

I'm not completely sure if this would be the correct fix, but I found the following to work with the intended behavior:
```
            if FSDPOption.FULL_SHARD in args.fsdp:        
                self.fsdp = ShardingStrategy.FULL_SHARD   
            elif FSDPOption.SHARD_GRAD_OP in args.fsdp: 
                self.fsdp = ShardingStrategy.SHARD_GRAD_OP
            elif FSDPOption.NO_SHARD in args.fsdp:
                self.fsdp = ShardingStrategy.NO_SHARD 
            
            if self.is_fsdp_enabled:                                                                                                         
                self.accelerator.state.fsdp_plugin.sharding_strategy=self.fsdp
```
where we update the sharding_strategy after determining the strategy used for fsdp from args in `__init__()`. 
cc @pacman100 