How to pass a reference to a function in yaml config file

[kenenbek]

If I want to use CLI to initialize datamodule object I should use:

python train.py --config data.yaml

data:
  class_path: foo.datasets.my_data
  init_args:
    data_dir: data

But what if one the init_arguments is a function? How can I pass a reference to it like this?

data:
  class_path: foo.datasets.my_data
  init_args:
    data_dir: data
    filter: foo.datasets.filter1

foo.datasets.filter1 is a function.

Thank you for attention.

[tshu-w]

[kenenbek]

Why it is possible to use class_path, but not function_path in yaml?

[tshu-w]

For a detailed reason, I thought you might ask mauvilsa at https://github.com/omni-us/jsonargparse.

[mauvilsa]

From jsonargparse v4.30.0, it is now allowed to give the import path of a function in class_path. In init_args the parameters to the function would be expected. Though, it is required that the function have as return annotation a subclass of the typehint.

[mauvilsa]

This is supported in jsonargparse. Just use Callable as type hint, see its mention in the docs. Basically you would have:

class MyData:
    def __init__(self, data_dir: str, filter: Callable):
        ...

Then the config could be as you had it:

class_path: foo.datasets.my_data
init_args:
  data_dir: data
  filter: foo.datasets.filter1

Or filter could be a class that once instantiated becomes callable, like:

class_path: foo.datasets.my_data
init_args:
  data_dir: data
  filter:
    class_path: path.to.callable.class
    init_args:
      param1: val1
      ...

[chenjoya]

Hi, it seems that lightning CLI can not still parse the function to an instantiated class, like the above scenario. More specific,

class_path: torchvision.models.detection.retinanet_resnet50_fpn_v2
init_args:
  weights: DEFAULT

I can only obtain dict type by this. It cannot support instantiating an object detector (nn.Module). Could you tell me how to do? Thank you.

[mauvilsa]

@chenjoya as the name suggests, class_path is expected to be an import path to a class, not a function. retinanet_resnet50_fpn_v2 is a function, so it will not work. I am not sure what you mean by "object detector (nn.Module)". Modules are classes, and they are supported with the class_path and init_args.

As I mentioned before, functions are supported with Callable as type hint. Though, this only supports providing the import path of the function, not arguments for the function or automatically calling this function. The parameter with Callable would just get the function object. You could have a separate parameter with dict type to provide arguments and then internally use them to call the function. Though these arguments would not have the same support as all other signature parameters.

Maybe the best fit for this case, that is currently supported, is to use class_from_function. In one of your py files you do SomeName = class_from_function(retinanet_resnet50_fpn_v2) and then you can specify the class_path to your SomeName.

If you want to create a feature request, please do so at jsonargparse/issues/new

[chenjoya]

Yes, I totally understand you. Thank you for your patience! I am just wondering why lightning CLI does not use class_from_function to parse the .yaml config file. It only supports class_path and init_args to instantiate a class.

[mauvilsa]

class_from_function creates a class, which if defined in a module, could be used to import this new class from this module. What class_path expects is an import path of a class. If class_from_function would be used internally (not by the developer in a module), then what would be the import path of the class? There wouldn't be one.

The reason why this is not supported is simply because it is not implemented. As I said, if you want to request a feature, please create a github issue jsonargparse/issues/new. Otherwise, this will be just forgotten.

[klieret]

@chenjoya If retinanet_resnet50_fpn_v2 is a convenience function creating a model, you should be able to use the workaround that I posted as a separate answer. I use it for exactly this use case.

[klieret]

Using the Callable type hint did not solve the issue for me (for a slightly different application). But you can create a class that mimics what a function does by using __new__:

class UseInsteadOfFunction(ReturnTypeClass):  # <-- return type class is the class that you would have your function return 
    def __new__(*args, **kwargs) -> ReturnTypeClass:  # <-- not __init__!
         return your_function(*args, **kwargs)

[chenjoya]

cool. this is feasible. thank you. I wonder now if there is a way can directly call in yaml, since there are many convenient apis from 3rd lib