Skip to content

Run time parameters

Defines run-time parameterization capabilities.

Attributes

Classes

DynamicParameter

A dynamicly determined parameter, determined at runtime.

This class represents a dynamic parameter that is decided at fit time when there is access to the given dataframe. This allows the parameter to be decided at "run time" depending on the given dataframe

Parameters:

Name Type Description Default
parameter_selector Callable

Performs logic in order to decide on a given parameter at run time, using the given DataFrame and optionally y label series.

 required
fittable bool

Denotes whether the parameter can be fitted, or should perform the deciding logic every time.

 True
Source code in pdpipe/run_time_parameters.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
class DynamicParameter:
    """
    A dynamicly determined parameter, determined at runtime.

    This class represents a dynamic parameter that is decided at fit time when
    there is access to the given dataframe. This allows the parameter to be
    decided at "run time" depending on the given dataframe

    Parameters
    ----------
    parameter_selector : Callable
        Performs logic in order to decide on a given parameter at run time,
        using the given DataFrame and optionally y label series.
    fittable : bool
        Denotes whether the parameter can be fitted, or should perform the
        deciding logic every time.
    """

    def __init__(
        self,
        parameter_selector: Callable,
        fittable: Optional[bool] = True,  # if False, fit in each use
    ) -> None:
        self._parameter_selector = parameter_selector
        self._fittable = fittable
        self._parameter: Any

    def fit_transform(
        self,
        X: pd.DataFrame,
        y: Optional[pd.Series] = None,
    ):
        """
        Compute and return the value of this dynamic parameter.

        Parameters
        ----------
        X : pandas.DataFrame
            Input dataframe upon which the parameter selector decides which
            parameter to use.
        y : pandas.Series
            Label column, if separated from X dataframe at an earlier stage.
            Optional.

        Returns
        -------
        object
            The dynamically determined value of this parameter.
        """
        try:
            self._parameter = self._parameter_selector(X, y)
        except TypeError as e:
            if len(POS_ARG_MISMTCH_PAT.findall(str(e))) > 0:
                self._parameter = self._parameter_selector(X)
            else:
                raise TypeError("Parameter selector must be callable") from e
        return self._parameter

    def transform(self) -> object:
        """
        Return the fitted value of this dynamic parameter.

        Returns
        -------
        object
            The fitted value of this dynamic parameter.
        """
        if not hasattr(self, "_parameter"):
            raise AttributeError("Parameter not fitted")  # pragma: no cover
        return self._parameter

    def __call__(
        self,
        X: pd.DataFrame,
        y: Optional[pd.Series] = None,
        *args,
        **kwargs,
    ):
        if self._fittable and hasattr(self, "_parameter"):
            return self.transform()
        else:
            return self.fit_transform(X, y)

Functions

fit_transform(X, y=None)

Compute and return the value of this dynamic parameter.

Parameters:

Name Type Description Default
X pandas.DataFrame

Input dataframe upon which the parameter selector decides which parameter to use.

 required
y pandas.Series

Label column, if separated from X dataframe at an earlier stage. Optional.

 None

Returns:

Type Description
object

The dynamically determined value of this parameter.
Source code in pdpipe/run_time_parameters.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def fit_transform(
    self,
    X: pd.DataFrame,
    y: Optional[pd.Series] = None,
):
    """
    Compute and return the value of this dynamic parameter.

    Parameters
    ----------
    X : pandas.DataFrame
        Input dataframe upon which the parameter selector decides which
        parameter to use.
    y : pandas.Series
        Label column, if separated from X dataframe at an earlier stage.
        Optional.

    Returns
    -------
    object
        The dynamically determined value of this parameter.
    """
    try:
        self._parameter = self._parameter_selector(X, y)
    except TypeError as e:
        if len(POS_ARG_MISMTCH_PAT.findall(str(e))) > 0:
            self._parameter = self._parameter_selector(X)
        else:
            raise TypeError("Parameter selector must be callable") from e
    return self._parameter
transform()

Return the fitted value of this dynamic parameter.

Returns:

Type Description
object

The fitted value of this dynamic parameter.
Source code in pdpipe/run_time_parameters.py 
67
68
69
70
71
72
73
74
75
76
77
78
def transform(self) -> object:
    """
    Return the fitted value of this dynamic parameter.

    Returns
    -------
    object
        The fitted value of this dynamic parameter.
    """
    if not hasattr(self, "_parameter"):
        raise AttributeError("Parameter not fitted")  # pragma: no cover
    return self._parameter

Functions

dynamic(parameter_selector, fittable=True)

Return a dynamic parameter.

Parameters:

Name Type Description Default
parameter_selector callable

The function or callable implementing the parameter value selection logic based on an input dataframe.

 required
fittable bool

Determines whether this dynamic parameter's value should be determined once on fit - in which case all future transforms get the saved value - or, alternatively, the value-selection logic should be performed on both every fit-transform and every transform operation.

 True

Returns:

Type Description
DynamicParameter

An object with the parameter selecting logic.
Source code in pdpipe/run_time_parameters.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
def dynamic(
    parameter_selector: Callable,
    fittable: Optional[bool] = True,
) -> DynamicParameter:
    """
    Return a dynamic parameter.

    Parameters
    ----------
    parameter_selector : callable
        The function or callable implementing the parameter value selection
        logic based on an input dataframe.
    fittable : bool
        Determines whether this dynamic parameter's value should be determined
        once on fit - in which case all future transforms get the saved value
        - or, alternatively, the value-selection logic should be performed on
        both every fit-transform and every transform operation.

    Returns
    -------
    DynamicParameter
        An object with the parameter selecting logic.
    """
    return DynamicParameter(parameter_selector, fittable)
Last update: 2022-09-19