def init_args(parser, custom_option=True, show_normal_init=True,
              show_hyper_fan_init=False):
    """This is a helper method of the method `parse_cmd_arguments` to add
    an argument group for options regarding network initialization.

    Arguments specified in this function:
        - `custom_network_init`
        - `normal_init`
        - `std_normal_init`
        - `std_normal_temb`
        - `std_normal_emb`
        - `hyper_fan_init`

    Args:
        parser: Object of class :class:`argparse.ArgumentParser`.
        custom_option (bool): Whether the option `custom_network_init` should be
            provided.
        show_normal_init (bool): Whether the option `normal_init` and
            `std_normal_init` should be provided.
        show_hyper_fan_init (bool): Whether the option `hyper_fan_init` should
            be provided.

    Returns:
        The created argument group, in case more options should be added.
    """
    ### Weight initialization.
    agroup = parser.add_argument_group('Network initialization options')
    if custom_option:
        # This option becomes important if posthoc custom init is not that
        # trivial anymore (e.g., if networks use batchnorm). Then, the network
        # init must be customized for each such network.
        agroup.add_argument('--custom_network_init', action='store_true',
                            help='Whether network parameters should be ' +
                                 'initialized in a custom way. If this flag ' +
                                 'is set, then Xavier initialization is ' +
                                 'applied to weight tensors (zero ' +
                                 'initialization for bias vectors). The ' +
                                 'initialization of chunk and task ' +
                                 'embeddings is independent of this option.')
    if show_normal_init:
        agroup.add_argument('--normal_init', action='store_true',
                            help='Use weight initialization from a zero-mean ' +
                                 'normal with std defined by the argument ' +
                                 '\'std_normal_init\'. Otherwise, Xavier ' +
                                 'initialization is used. Biases are ' +
                                 'initialized to zero.')
        agroup.add_argument('--std_normal_init', type=float, default=0.02,
                            help='If normal initialization is used, this ' +
                                 'will be the standard deviation used. ' +
                                 'Default: %(default)s.')
    agroup.add_argument('--std_normal_temb', type=float, default=1.,
                        help='Std when initializing task embeddings. ' +
                             'Default: %(default)s.')
    agroup.add_argument('--std_normal_emb', type=float, default=1.,
                        help='If a chunked hypernetwork is used (including ' +
                             'self-attention hypernet), then this will be ' +
                             'the std of their embeddings its ' +
                             'initialization. Default: %(default)s.')

    if show_hyper_fan_init:
        agroup.add_argument('--hyper_fan_init', action='store_true',
                            help='Use the hyperfan-initialization method ' +
                                 'for hypernetworks. Note, for hypernetwork ' +
                                 'that use chunking, this requires a proper ' +
                                 'setting of "std_normal_temb". When using ' +
                                 'this option, then "std_normal_emb" has no ' +
                                 'effect just like all other init options ' +
                                 'that might effect hypernet initialization.')

    return agroup