Skip to content

parameter

Parameter dataclass

A mutable parameter class that supports method chaining

Source code in slimfit/v2/parameter.py 
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
@dataclass
class Parameter:
    """A mutable parameter class that supports method chaining"""

    symbol: sp.Symbol
    guess: Numerical = 1.0
    bounds: tuple[Optional[Numerical], Optional[Numerical]] = (None, None)
    fixed: bool = False

    @property
    def name(self) -> str:
        return self.symbol.name

    @property
    def shape(self) -> tuple[int, ...]:
        shape = getattr(self.guess, "shape", tuple())
        return shape

    def fix(self) -> Parameter:
        """Fix the parameter at its current guess value"""
        self.fixed = True
        return self

    def unfix(self) -> Parameter:
        """Make the parameter free to vary"""
        self.fixed = False
        return self

    def set_bounds(
        self, lower: Optional[Numerical] = None, upper: Optional[Numerical] = None
    ) -> Parameter:
        """Set parameter bounds"""
        self.bounds = (lower, upper)
        return self

    def set_guess(self, value: Numerical) -> Parameter:
        """Set initial guess value"""
        self.guess = value
        return self

fix()

Fix the parameter at its current guess value

Source code in slimfit/v2/parameter.py 
30
31
32
33
def fix(self) -> Parameter:
    """Fix the parameter at its current guess value"""
    self.fixed = True
    return self

set_bounds(lower=None, upper=None)

Set parameter bounds

Source code in slimfit/v2/parameter.py 
40
41
42
43
44
45
def set_bounds(
    self, lower: Optional[Numerical] = None, upper: Optional[Numerical] = None
) -> Parameter:
    """Set parameter bounds"""
    self.bounds = (lower, upper)
    return self

set_guess(value)

Set initial guess value

Source code in slimfit/v2/parameter.py 
47
48
49
50
def set_guess(self, value: Numerical) -> Parameter:
    """Set initial guess value"""
    self.guess = value
    return self

unfix()

Make the parameter free to vary

Source code in slimfit/v2/parameter.py 
35
36
37
38
def unfix(self) -> Parameter:
    """Make the parameter free to vary"""
    self.fixed = False
    return self

Parameters

Container for managing multiple parameters

Source code in slimfit/v2/parameter.py 
 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
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
class Parameters:
    """Container for managing multiple parameters"""

    def __init__(self, parameters: Iterable[Parameter]):
        self._parameters = {p.name: p for p in parameters}

    def __getitem__(self, key: Union[str, Sequence[str]]) -> Union[Parameter, Parameters]:
        """Get a parameter or create a new ParameterSet with selected parameters"""
        if isinstance(key, str):
            return self._parameters[key]
        return Parameters([self._parameters[k] for k in key])

    def __iter__(self):
        return iter(self._parameters.values())

    def __len__(self):
        return len(self._parameters)

    def __add__(self, other: Parameters) -> Parameters:
        return Parameters(self.to_list() + other.to_list())

    @classmethod
    def from_symbols(
        cls,
        symbols: Iterable[sp.Symbol],
    ) -> Parameters:
        symbol_dict = {symbol.name: symbol for symbol in sorted(symbols, key=str)}

        p_list = [Parameter(symbol) for symbol in symbol_dict.values()]
        return cls(p_list)

    @property
    def guess(self) -> dict[str, Numerical]:  # other types?
        return {p.name: np.asarray(p.guess) for p in self}

    def fix(self, *names: str) -> Parameters:
        """Fix specified parameters"""
        for name in names:
            self._parameters[name].fix()
        return self

    def unfix(self, *names: str) -> Parameters:
        """Unfix specified parameters"""
        for name in names:
            self._parameters[name].unfix()
        return self

    def set_bounds(
        self, bounds_dict: dict[str, tuple[Optional[Numerical], Optional[Numerical]]]
    ) -> Parameters:
        """Set bounds for multiple parameters at once"""
        for name, (lower, upper) in bounds_dict.items():
            self._parameters[name].set_bounds(lower, upper)
        return self

    def set_guesses(self, guess_dict: dict[str, Numerical]) -> Parameters:
        """Set initial guesses for multiple parameters at once"""
        for name, guess in guess_dict.items():
            self._parameters[name].set_guess(guess)
        return self

    @property
    def fixed(self) -> Parameters:
        """Get list of fixed parameters"""
        return Parameters([p for p in self._parameters.values() if p.fixed])

    @property
    def free(self) -> Parameters:
        """Get list of free parameters"""
        return Parameters([p for p in self._parameters.values() if not p.fixed])

    def to_list(self) -> list[Parameter]:
        """Convert to parameter list"""
        return list(self._parameters.values())

    def __repr__(self) -> str:
        return f"Parameters({list(self._parameters.values())})"

fixed property

Get list of fixed parameters

free property

Get list of free parameters

__getitem__(key)

Get a parameter or create a new ParameterSet with selected parameters

Source code in slimfit/v2/parameter.py 
59
60
61
62
63
def __getitem__(self, key: Union[str, Sequence[str]]) -> Union[Parameter, Parameters]:
    """Get a parameter or create a new ParameterSet with selected parameters"""
    if isinstance(key, str):
        return self._parameters[key]
    return Parameters([self._parameters[k] for k in key])

fix(*names)

Fix specified parameters

Source code in slimfit/v2/parameter.py 
88
89
90
91
92
def fix(self, *names: str) -> Parameters:
    """Fix specified parameters"""
    for name in names:
        self._parameters[name].fix()
    return self

set_bounds(bounds_dict)

Set bounds for multiple parameters at once

Source code in slimfit/v2/parameter.py 
100
101
102
103
104
105
106
def set_bounds(
    self, bounds_dict: dict[str, tuple[Optional[Numerical], Optional[Numerical]]]
) -> Parameters:
    """Set bounds for multiple parameters at once"""
    for name, (lower, upper) in bounds_dict.items():
        self._parameters[name].set_bounds(lower, upper)
    return self

set_guesses(guess_dict)

Set initial guesses for multiple parameters at once

Source code in slimfit/v2/parameter.py 
108
109
110
111
112
def set_guesses(self, guess_dict: dict[str, Numerical]) -> Parameters:
    """Set initial guesses for multiple parameters at once"""
    for name, guess in guess_dict.items():
        self._parameters[name].set_guess(guess)
    return self

to_list()

Convert to parameter list

Source code in slimfit/v2/parameter.py 
124
125
126
def to_list(self) -> list[Parameter]:
    """Convert to parameter list"""
    return list(self._parameters.values())

unfix(*names)

Unfix specified parameters

Source code in slimfit/v2/parameter.py 
94
95
96
97
98
def unfix(self, *names: str) -> Parameters:
    """Unfix specified parameters"""
    for name in names:
        self._parameters[name].unfix()
    return self