Allow argument dependencies

Is your feature request related to a problem? Please describe.

I am wondering if its possible to tie some argument values together. For example, when I train an Encoder-Decoder architecture, the encoder.output_dim should be the same like decoder.input_dim.

Describe the solution you’d like

I would like to specify only one of them in the CLI and have the other be set automatically. And if I accidentally specify both, I would like to be yelled at for doing something wrong.

How it could work:

dim: int = TiedParam(default=25)

@dataclass
class Encoder:
    output_dim: int = dim

@dataclass
class Decoder:
    input_dim: int = dim

Let me know what you think (or forgive my ignorance if its already possible!! 😃) Thanks!

[mauvilsa]

@janvainer what you propose already exists in jsonargparse, see argument-linking. You might want to try that out.

[lebrice]

Hey there @janvainer, thanks for posting this!

Hmm that’s interesting. From what is currently implemented, you have two options to take a look at, none of which do exactly what you want… 😞

• Option one: Conditional Fields

This isn’t directly related to simple-parsing, it’s just a little feature for dataclasses that I’ve made into a shareable code snippet using GitHub Gist. Here’s the idea:

@dataclass
class Bob(HasConditionalFields):
    name: str = "Bob Jones"
    age: int = 26

    gamer_name: str = conditional_field(
        lambda name, age: f"xXx_{name}_{2022-age}_xXx",
    )

    email: str = conditional_field(
        lambda gamer_name: f"{gamer_name}@gmail.com"
    )


bob = Bob()
print(bob)
# Bob(name='Bob Jones', age=26, gamer_name='xXx_Bob Jones_1995_xXx',
#     email='Bob [e-mail]', gamer_email='xXx_Bob [e-mail]')

The problem with this though is that I don’t think it works if the fields are on different dataclasses… You might be able to tweak the conditional_field function to achieve it though. If you do, please do let me know!

• Option 2: Using passing a dest to the field function:

from argparse import Namespace
from dataclasses import dataclass
from simple_parsing import ArgumentParser, field
from simple_parsing.wrappers.field_wrapper import ArgumentGenerationMode


@dataclass
class Encoder:
    output_dim: int = field(default=128, dest="model.decoder.input_dim")


@dataclass
class Decoder:
    input_dim: int = field(default=128, cmd=False)


@dataclass
class ModelConfig:
    encoder: Encoder = field(default_factory=Encoder)
    decoder: Decoder = field(default_factory=Decoder)


def test_repro_issue_143():
    parser = ArgumentParser(argument_generation_mode=ArgumentGenerationMode.NESTED)
    parser.add_arguments(ModelConfig, dest="model")
    args = parser.parse_args("--model.encoder.output_dim 256".split())

    # Doesn't exactly work at the moment:
    assert args == Namespace(
        model=ModelConfig(encoder=Encoder(output_dim=128), decoder=Decoder(input_dim=128)),
        **{"model.decoder.input_dim": 256}
    )

This doesn’t really do what you want, and doesn’t really work as intended, in its current state. (I wrote this waaaaay back, and haven’t used it or tested it since…)

Hope this is somewhat helpful. I’d be really curious to hear some more ideas on how we could design this! The TiedField idea seems interesting. Perhaps we could also make use of type annotations for this somehow?

Let me know what you think! 😃