Choice of subparser groups

[lebrice]

This is a draft of how I plan to implement a new feature: choice of subgroups of arguments.

This roughly follows what I described previously in #130

Idea:

#inside ArgumentParser.parse_args method:

self.subgroups: list[str] = []
# add all arguments, resolve conflicts, etc.
self.preprocessing() 

if subgroups:
    # do a "first pass" of argument parsing
    # to detect what the subgroup choice was (e.g. "--optimizer adam")
    self.add_help = False
    args, _ = self.parse_known_args(argv)
    
    # parser for the second round:
    parser = ArgumentParser(parents=[self], add_help=True)
    for dest in self.subgroups:
        # add arguments for the Adam optimizer
        # (since it was chosen in the first phase)
        chosen_dataclass_type = getattr(args, dest)
        parser.add_arguments(chosen_dataclass_type, dest=dest, prefix=f"{dest}.")
    # "recurse", which should enable arbitrary nesting
    return parser.parse_args(argv)
else:
    # do what we usually do. No change.
    ...

[idoby]

This could be nice for unions but I still need to think about implementing polymorphic types.
We also need to support this if the user calls parse_known_args instead of parse_args, to maintain consistency.

[lebrice]

@idoby this is in no way tied to PyTorch: you can pass any class or callable to Partial.

The example I was showing above would be in user code.
However I"m not against doing something like simple_parsing.helpers.torch or something similar.

[idoby]

Creating the optimizer directly from the config is torch-specific. Can't do it without knowing the optimizer tajes the model parameters. It should probably be a separate module, yeah.

[lebrice]

Not to be annoying, but I believe you are incorrect: This creates a Partial object that behaves just like a functools.partial: It just populates some of the arguments of any callable. In this particular case, the Optimizers need a params required argument, which can't be parsed from the command-line. Therefore, you still have to pass the model parameters to the AdamConfig object to get an Adam instance:

# Create a config dataclass that partially configures the Adam optimizer
# (with a --lr, betas, etc arguments)
AdamConfig = Partial[Adam]
# Create a config dataclass that partially configures the Adam optimizer
# (with a different default value for the `lr` argument)
AdamConfig = Partial[Adam](lr=3e-4)

model = nn.Sequential(...)

adam = AdamConfig(model.parameters()) # Use the lr value from the config
adam = AdamConfig(model.parameters(), lr=1.23) # overwrite the value
adam = AdamConfig(model.parameters(), betas=[0.9, 0.99])  # use the lr from the config, overwrite the defaults for betas

Is this clearer? Like, this works for any callable, even if it has required positional arguments (like the optimizer classes do).

[idoby]

How do you decide which argument can come from the command line and which doesn't? Seems to me like this might work for this particular case but it doesn't generalize so well...

[lebrice]

Good question! I'm open to suggestions on this, but at the moment, only the arguments that have an annotation that is understood by simple-parsing will have their arguments added.

It's also possible to do AdamConfig = config_dataclass_for(Adam, ignore_args=("params",)) to explicitly specify the arguments that should be ignored.

[janvainer]

The subgroup parser looks pretty nice and relatively simple :) Can't wait to start using this instead of my hacky code :D

[lebrice]

There is now a PR for this feature: #136