diff --git a/src/accelerate/commands/launch.py b/src/accelerate/commands/launch.py
index 7c8534e93..df4f703c3 100644
--- a/src/accelerate/commands/launch.py
+++ b/src/accelerate/commands/launch.py
@@ -61,180 +61,367 @@
 
 logger = logging.getLogger(__name__)
 
+options_to_group = {
+    "--multi-gpu": "Distributed GPUs",
+    "--tpu": "TPU",
+    "--use_mps_device": "MPS",
+    "--use_deepspeed": "DeepSpeed Arguments",
+    "--use_fsdp": "FSDP Arguments",
+    "--use_megatron_lm": "Megatron-LM Arguments",
+}
+
+
+def clean_option(option):
+    "Finds all cases of - after the first two characters and changes them to _"
+    if option.startswith("--"):
+        return option[:3] + option[3:].replace("-", "_")
+
+
+class _CustomHelpAction(argparse._HelpAction):
+    """
+    This is a custom help action that will hide all arguments that are not used in the command line when the help is
+    called. This is useful for the case where the user is using a specific platform and only wants to see the arguments
+    for that platform.
+    """
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if "accelerate" in sys.argv[0] and "launch" in sys.argv[1:]:
+            args = sys.argv[2:]
+        else:
+            args = sys.argv[1:]
+        opts = parser._actions
+        titles = [
+            "Hardware Selection Arguments",
+            "Resource Selection Arguments",
+            "Training Paradigm Arguments",
+            "positional arguments",
+            "optional arguments",
+        ]
+        if len(args) > 1:
+            used_platforms = [arg for arg in args if arg in options_to_group.keys()]
+            args = list(map(clean_option, args))
+            used_titles = [options_to_group[o] for o in used_platforms]
+            for i, arg in enumerate(opts):
+                # If the argument's container is outside of the used titles, hide it
+                if arg.container.title not in titles + used_titles:
+                    setattr(opts[i], "help", argparse.SUPPRESS)
+                # If the argument is hardware selection, but not being passed, hide it
+                elif arg.container.title == "Hardware Selection Arguments":
+                    if set(arg.option_strings).isdisjoint(set(args)):
+                        setattr(opts[i], "help", argparse.SUPPRESS)
+                    else:
+                        setattr(opts[i], "help", arg.help + " (currently selected)")
+                # If the argument is a training paradigm, but not being passed, hide it
+                elif arg.container.title == "Training Paradigm Arguments":
+                    if set(arg.option_strings).isdisjoint(set(used_platforms)):
+                        setattr(opts[i], "help", argparse.SUPPRESS)
+                    else:
+                        setattr(opts[i], "help", arg.help + " (currently selected)")
+            for i, group in enumerate(list(parser._action_groups)):
+                # If all arguments in the group are hidden, hide the group
+                if all([arg.help == argparse.SUPPRESS for arg in group._group_actions]):
+                    parser._action_groups.remove(group)
+
+        super().__call__(parser, namespace, values, option_string)
+
 
 def launch_command_parser(subparsers=None):
     if subparsers is not None:
-        parser = subparsers.add_parser("launch")
+        parser = subparsers.add_parser("launch", add_help=False)
     else:
-        parser = argparse.ArgumentParser("Accelerate launch command")
+        parser = argparse.ArgumentParser("Accelerate launch command", add_help=False)
+
+    parser.register("action", "help", _CustomHelpAction)
+    parser.add_argument("-h", "--help", action="help", help="Show this help message and exit.")
 
     parser.add_argument(
         "--config_file", default=None, help="The config file to use for the default values in the launching script."
     )
-    parser.add_argument(
+    # Hardware selection arguments
+    hardware_args = parser.add_argument_group(
+        "Hardware Selection Arguments", "Arguments for selecting the hardware to be used."
+    )
+    hardware_args.add_argument(
+        "--cpu", default=False, action="store_true", help="Whether or not to force the training on the CPU."
+    )
+    hardware_args.add_argument(
         "--multi_gpu",
         default=False,
         action="store_true",
         help="Whether or not this should launch a distributed GPU training.",
     )
-    parser.add_argument(
+    hardware_args.add_argument(
+        "--tpu", default=False, action="store_true", help="Whether or not this should launch a TPU training."
+    )
+    hardware_args.add_argument(
         "--use_mps_device",
         default=False,
         action="store_true",
         help="Whether or not this should use MPS-enabled GPU device on MacOS machines.",
     )
 
-    # deepspeed args
-    parser.add_argument(
+    # Resource selection arguments
+    resource_args = parser.add_argument_group(
+        "Resource Selection Arguments", "Arguments for fine-tuning how available hardware should be used."
+    )
+    resource_args.add_argument(
+        "--mixed_precision",
+        type=str,
+        choices=["no", "fp16", "bf16"],
+        help="Whether or not to use mixed precision training. "
+        "Choose between FP16 and BF16 (bfloat16) training. "
+        "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.",
+    )
+    resource_args.add_argument(
+        "--fp16", default=False, action="store_true", help="Whether or not to use mixed precision training."
+    )
+    resource_args.add_argument(
+        "--num_processes", type=int, default=None, help="The total number of processes to be launched in parallel."
+    )
+    resource_args.add_argument(
+        "--num_machines", type=int, default=None, help="The total number of machines used in this training."
+    )
+    resource_args.add_argument(
+        "--num_cpu_threads_per_process",
+        type=int,
+        default=None,
+        help="The number of CPU threads per process. Can be tuned for optimal performance.",
+    )
+
+    # Training Paradigm arguments
+    paradigm_args = parser.add_argument_group(
+        "Training Paradigm Arguments", "Arguments for selecting which training paradigm to be used."
+    )
+    paradigm_args.add_argument(
         "--use_deepspeed",
         default=False,
         action="store_true",
         help="Whether to use deepspeed.",
     )
+    paradigm_args.add_argument(
+        "--use_fsdp",
+        default=False,
+        action="store_true",
+        help="Whether to use fsdp.",
+    )
+    paradigm_args.add_argument(
+        "--use_megatron_lm",
+        default=False,
+        action="store_true",
+        help="Whether to use Megatron-LM.",
+    )
+
+    # distributed GPU training arguments
+    distributed_args = parser.add_argument_group("Distributed GPUs", "Arguments related to distributed GPU training.")
+    distributed_args.add_argument(
+        "--gpu_ids",
+        default=None,
+        help="What GPUs (by id) should be used for training on this machine as a comma-seperated list",
+    )
+    distributed_args.add_argument(
+        "--same_network",
+        default=False,
+        action="store_true",
+        help="Whether all machines used for multinode training exist on the same local network.",
+    )
+    distributed_args.add_argument(
+        "--machine_rank", type=int, default=None, help="The rank of the machine on which this script is launched."
+    )
+    distributed_args.add_argument(
+        "--main_process_ip", type=str, default=None, help="The IP address of the machine of rank 0."
+    )
+    distributed_args.add_argument(
+        "--main_process_port",
+        type=int,
+        default=None,
+        help="The port to use to communicate with the machine of rank 0.",
+    )
+    # Rendezvous related arguments
+    distributed_args.add_argument(
+        "--rdzv_conf",
+        type=str,
+        default="",
+        help="Additional rendezvous configuration (<key1>=<value1>,<key2>=<value2>,...).",
+    )
+    distributed_args.add_argument(
+        "--max_restarts",
+        type=int,
+        default=0,
+        help="Maximum number of worker group restarts before failing.",
+    )
+    distributed_args.add_argument(
+        "--monitor_interval",
+        type=float,
+        default=5,
+        help="Interval, in seconds, to monitor the state of workers.",
+    )
+    parser.add_argument(
+        "-m",
+        "--module",
+        action="store_true",
+        help="Change each process to interpret the launch script as a Python module, executing with the same behavior as 'python -m'.",
+    )
     parser.add_argument(
+        "--no_python",
+        action="store_true",
+        help="Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.",
+    )
+
+    # tpu arguments
+    tpu_args = parser.add_argument_group("TPU", "Arguments related to TPU.")
+    tpu_args.add_argument(
+        "--main_training_function",
+        type=str,
+        default=None,
+        help="The name of the main function to be executed in your script (only for TPU training).",
+    )
+    tpu_args.add_argument(
+        "--downcast_bf16",
+        action="store_true",
+        help="Whether when using bf16 precision on TPUs if both float and double tensors are cast to bfloat16 or if double tensors remain as float32.",
+    )
+
+    # DeepSpeed arguments
+    deepspeed_args = parser.add_argument_group("DeepSpeed Arguments", "Arguments related to DeepSpeed.")
+    deepspeed_args.add_argument(
         "--deepspeed_config_file",
         default=None,
         type=str,
         help="DeepSpeed config file.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--zero_stage",
         default=None,
         type=int,
         help="DeepSpeed's ZeRO optimization stage (useful only when `use_deepspeed` flag is passed).",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--offload_optimizer_device",
         default=None,
         type=str,
         help="Decides where (none|cpu|nvme) to offload optimizer states (useful only when `use_deepspeed` flag is passed).",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--offload_param_device",
         default=None,
         type=str,
         help="Decides where (none|cpu|nvme) to offload parameters (useful only when `use_deepspeed` flag is passed).",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--gradient_accumulation_steps",
         default=None,
         type=int,
         help="No of gradient_accumulation_steps used in your training script (useful only when `use_deepspeed` flag is passed).",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--gradient_clipping",
         default=None,
         type=float,
         help="gradient clipping value used in your training script (useful only when `use_deepspeed` flag is passed).",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--zero3_init_flag",
         default=None,
         type=str,
         help="Decides Whether (true|false) to enable `deepspeed.zero.Init` for constructing massive models. "
         "Only applicable with DeepSpeed ZeRO Stage-3.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--zero3_save_16bit_model",
         default=None,
         type=str,
         help="Decides Whether (true|false) to save 16-bit model weights when using ZeRO Stage-3. "
         "Only applicable with DeepSpeed ZeRO Stage-3.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--deepspeed_hostfile",
         default=None,
         type=str,
         help="DeepSpeed hostfile for configuring multi-node compute resources.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--deepspeed_exclusion_filter",
         default=None,
         type=str,
         help="DeepSpeed exclusion filter string when using mutli-node setup.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--deepspeed_inclusion_filter",
         default=None,
         type=str,
         help="DeepSpeed inclusion filter string when using mutli-node setup.",
     )
-    parser.add_argument(
+    deepspeed_args.add_argument(
         "--deepspeed_multinode_launcher",
         default=None,
         type=str,
         help="DeepSpeed multi-node launcher to use.",
     )
 
-    # fsdp args
-    parser.add_argument(
-        "--use_fsdp",
-        default=False,
-        action="store_true",
-        help="Whether to use fsdp.",
-    )
-    parser.add_argument(
+    # fsdp arguments
+    fsdp_args = parser.add_argument_group("FSDP Arguments", "Arguments related to Fully Shared Data Parallelism.")
+    fsdp_args.add_argument(
         "--fsdp_offload_params",
         default="false",
         type=str,
         help="Decides Whether (true|false) to offload parameters and gradients to CPU. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_min_num_params",
         type=int,
         default=1e8,
         help="FSDP's minimum number of parameters for Default Auto Wrapping. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_sharding_strategy",
         type=int,
         default=1,
         help="FSDP's Sharding Strategy. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_auto_wrap_policy",
         type=str,
         default=None,
         help="FSDP's auto wrap policy. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_transformer_layer_cls_to_wrap",
         default=None,
         type=str,
         help="Transformer layer class name (case-sensitive) to wrap ,e.g, `BertLayer`, `GPTJBlock`, `T5Block` .... "
         "(useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_backward_prefetch_policy",
         default=None,
         type=str,
         help="FSDP's backward prefetch policy. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--fsdp_state_dict_type",
         default=None,
         type=str,
         help="FSDP's state dict type. (useful only when `use_fsdp` flag is passed).",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--offload_params",
         default=None,
         type=str,
         help="This argument is deprecated. Use `fsdp_offload_params` instead.",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--min_num_params",
         type=int,
         default=None,
         help="This argument is deprecated. Use `fsdp_min_num_params` instead.",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--sharding_strategy",
         type=int,
         default=None,
         help="This argument is deprecated. Use `fsdp_sharding_strategy` instead.",
     )
-    parser.add_argument(
+    fsdp_args.add_argument(
         "--transformer_layer_cls_to_wrap",
         default=None,
         type=str,
@@ -242,45 +429,40 @@ def launch_command_parser(subparsers=None):
     )
 
     # megatron_lm args
-    parser.add_argument(
-        "--use_megatron_lm",
-        default=False,
-        action="store_true",
-        help="Whether to use Megatron-LM.",
-    )
-    parser.add_argument(
+    megatron_lm_args = parser.add_argument_group("Megatron-LM Arguments", "Arguments related to Megatron-LM.")
+    megatron_lm_args.add_argument(
         "--megatron_lm_tp_degree",
         type=int,
         default=1,
         help="Megatron-LM's Tensor Parallelism (TP) degree. (useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_pp_degree",
         type=int,
         default=1,
         help="Megatron-LM's Pipeline Parallelism (PP) degree. (useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_num_micro_batches",
         type=int,
         default=None,
         help="Megatron-LM's number of micro batches when PP degree > 1. (useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_sequence_parallelism",
         default=None,
         type=str,
         help="Decides Whether (true|false) to enable Sequence Parallelism when TP degree > 1. "
         "(useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_recompute_activations",
         default=None,
         type=str,
         help="Decides Whether (true|false) to enable Selective Activation Recomputation. "
         "(useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_use_distributed_optimizer",
         default=None,
         type=str,
@@ -288,7 +470,7 @@ def launch_command_parser(subparsers=None):
         "which shards optimizer state and gradients across Data Pralellel (DP) ranks. "
         "(useful only when `use_megatron_lm` flag is passed).",
     )
-    parser.add_argument(
+    megatron_lm_args.add_argument(
         "--megatron_lm_gradient_clipping",
         default=1.0,
         type=float,
@@ -296,105 +478,15 @@ def launch_command_parser(subparsers=None):
         "(useful only when `use_megatron_lm` flag is passed).",
     )
 
-    parser.add_argument(
-        "--tpu", default=False, action="store_true", help="Whether or not this should launch a TPU training."
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        choices=["no", "fp16", "bf16"],
-        help="Whether or not to use mixed precision training. "
-        "Choose between FP16 and BF16 (bfloat16) training. "
-        "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.",
-    )
-
-    parser.add_argument(
-        "--fp16", default=False, action="store_true", help="Whether or not to use mixed precision training."
-    )
-    parser.add_argument(
-        "--cpu", default=False, action="store_true", help="Whether or not to force the training on the CPU."
-    )
-    parser.add_argument(
-        "--num_processes", type=int, default=None, help="The total number of processes to be launched in parallel."
-    )
-    parser.add_argument(
-        "--num_machines", type=int, default=None, help="The total number of machines used in this training."
-    )
-    parser.add_argument(
-        "--gpu_ids",
-        default=None,
-        help="What GPUs (by id) should be used for training on this machine as a comma-seperated list",
-    )
-    parser.add_argument(
-        "--same_network",
-        default=False,
-        action="store_true",
-        help="Whether all machines used for multinode training exist on the same local network.",
-    )
-    parser.add_argument(
-        "--machine_rank", type=int, default=None, help="The rank of the machine on which this script is launched."
-    )
-    parser.add_argument("--main_process_ip", type=str, default=None, help="The IP address of the machine of rank 0.")
-    parser.add_argument(
-        "--main_process_port",
-        type=int,
-        default=None,
-        help="The port to use to communicate with the machine of rank 0.",
-    )
-    # Rendezvous related arguments
-    parser.add_argument(
-        "--rdzv_conf",
-        type=str,
-        default="",
-        help="Additional rendezvous configuration (<key1>=<value1>,<key2>=<value2>,...).",
-    )
-    parser.add_argument(
-        "--max_restarts",
-        type=int,
-        default=0,
-        help="Maximum number of worker group restarts before failing.",
-    )
-    parser.add_argument(
-        "--monitor_interval",
-        type=float,
-        default=5,
-        help="Interval, in seconds, to monitor the state of workers.",
-    )
-    parser.add_argument(
-        "--main_training_function",
-        type=str,
-        default=None,
-        help="The name of the main function to be executed in your script (only for TPU training).",
-    )
-    parser.add_argument(
-        "--downcast_bf16",
-        action="store_true",
-        help="Whether when using bf16 precision on TPUs if both float and double tensors are cast to bfloat16 or if double tensors remain as float32.",
-    )
-    parser.add_argument(
-        "-m",
-        "--module",
-        action="store_true",
-        help="Change each process to interpret the launch script as a Python module, executing with the same behavior as 'python -m'.",
-    )
-    parser.add_argument(
-        "--no_python",
-        action="store_true",
-        help="Skip prepending the training script with 'python' - just execute it directly. Useful when the script is not a Python script.",
-    )
-    parser.add_argument(
-        "--num_cpu_threads_per_process",
-        type=int,
-        default=None,
-        help="The number of CPU threads per process. Can be tuned for optimal performance.",
-    )
-    parser.add_argument(
+    # AWS arguments
+    aws_args = parser.add_argument_group("AWS Arguments", "Arguments related to AWS.")
+    aws_args.add_argument(
         "--aws_access_key_id",
         type=str,
         default=None,
         help="The AWS_ACCESS_KEY_ID used to launch the Amazon SageMaker training job",
     )
-    parser.add_argument(
+    aws_args.add_argument(
         "--aws_secret_access_key",
         type=str,
         default=None,


Review comments: body: I hate this underscore convention in Python as it hurts readability and nothing is ever truly private. In Accelerate, like for Transformers, the convention is that things that are not in the main init are private. So no need to add all those _ :-)
diff_hunk: @@ -61,340 +61,430 @@
 
 logger = logging.getLogger(__name__)
 
+_options_to_group = {
+    "--multi-gpu": "Distributed GPUs",
+    "--tpu": "TPU",
+    "--use_mps_device": "MPS",
+    "--use_deepspeed": "DeepSpeed",
+    "--use_fsdp": "FSDP",
+    "--use_megatron_lm": "Megatron-LM",
+}
+
+
+def _clean_option(option):
body: Made public! :) Will note down for next time
diff_hunk: @@ -61,340 +61,430 @@
 
 logger = logging.getLogger(__name__)
 
+_options_to_group = {
+    "--multi-gpu": "Distributed GPUs",
+    "--tpu": "TPU",
+    "--use_mps_device": "MPS",
+    "--use_deepspeed": "DeepSpeed",
+    "--use_fsdp": "FSDP",
+    "--use_megatron_lm": "Megatron-LM",
+}
+
+
+def _clean_option(option):

Discussion: body: _The documentation is not available anymore as the PR was closed or merged._