Skip to content

Configs

physXAI.models.ann.configs.ann_model_configs

Classes

ClassicalANNConstruction_config

Bases: BaseModel

Source code in physXAI/models/ann/configs/ann_model_configs.py 
 5
 6
 7
 8
 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
class ClassicalANNConstruction_config(BaseModel):

    n_layers: int = Field(..., gt=0)
    n_neurons: Union[int, list[int]] = 32
    activation_function: Union[str, list[str]] = 'softplus'
    rescale_output: bool = True
    normalize: bool = True
    n_features: Optional[int] = None

    @field_validator('n_neurons')
    def validate_n_neurons(cls, v, info):
        ls = info.data.get('n_layers')
        if isinstance(v, list):
            if len(v) != ls:
                raise ValueError('List of n_neurons must have same length than n_layers')
            for i in v:
                if i <= 0:
                    raise ValueError('n_neurons must be greater than 0')
        elif v <= 0:
            raise ValueError('n_neurons must be greater than 0')
        return v

    @field_validator('activation_function')
    def validate_activation(cls, v, info):
        ls = info.data.get('n_layers')
        if isinstance(v, list):
            if len(v) != ls:
                raise ValueError('List of activation functions must have same length than n_layers')
        return v
Attributes
n_layers: int = Field(..., gt=0) class-attribute instance-attribute
n_neurons: Union[int, list[int]] = 32 class-attribute instance-attribute
activation_function: Union[str, list[str]] = 'softplus' class-attribute instance-attribute
rescale_output: bool = True class-attribute instance-attribute
normalize: bool = True class-attribute instance-attribute
n_features: Optional[int] = None class-attribute instance-attribute
Functions
validate_n_neurons(v, info)
Source code in physXAI/models/ann/configs/ann_model_configs.py 
14
15
16
17
18
19
20
21
22
23
24
25
@field_validator('n_neurons')
def validate_n_neurons(cls, v, info):
    ls = info.data.get('n_layers')
    if isinstance(v, list):
        if len(v) != ls:
            raise ValueError('List of n_neurons must have same length than n_layers')
        for i in v:
            if i <= 0:
                raise ValueError('n_neurons must be greater than 0')
    elif v <= 0:
        raise ValueError('n_neurons must be greater than 0')
    return v
validate_activation(v, info)
Source code in physXAI/models/ann/configs/ann_model_configs.py 
27
28
29
30
31
32
33
@field_validator('activation_function')
def validate_activation(cls, v, info):
    ls = info.data.get('n_layers')
    if isinstance(v, list):
        if len(v) != ls:
            raise ValueError('List of activation functions must have same length than n_layers')
    return v

RBFConstruction_config

Bases: ClassicalANNConstruction_config

Source code in physXAI/models/ann/configs/ann_model_configs.py 
36
37
38
39
40
41
42
43
44
45
class RBFConstruction_config(ClassicalANNConstruction_config):

    n_layers: int = Field(..., ge=1, le=1)
    random_state: int = 42
    rescale_mean: Optional[float] = Field(
        None, description="Mean value for z-score normalization of outputs"
    )
    rescale_sigma: Optional[float] = Field(
        None, description="Standard deviation for z-score normalization of outputs"
    )
Attributes
n_layers: int = Field(..., ge=1, le=1) class-attribute instance-attribute
random_state: int = 42 class-attribute instance-attribute
rescale_mean: Optional[float] = Field(None, description='Mean value for z-score normalization of outputs') class-attribute instance-attribute
rescale_sigma: Optional[float] = Field(None, description='Standard deviation for z-score normalization of outputs') class-attribute instance-attribute

CMNNModelConstruction_config

Bases: ClassicalANNConstruction_config

Source code in physXAI/models/ann/configs/ann_model_configs.py 
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
class CMNNModelConstruction_config(ClassicalANNConstruction_config):

    monotonicities: Optional[dict[str, int]] = None
    activation_split: Optional[list[float]] = [1, 1, 1]

    @field_validator('monotonicities')
    def validate_monotonicities(cls, v):
        if v is not None:
            for i in v.values():
                if i not in [0, -1, 1]:
                    raise ValueError('monotonicities must be 0 (no monotony), 1 (positive monotony) '
                                     'or -1 (negative monotony)')
        return v

    @field_validator('activation_split')
    def validate_activation_split(cls, v):
        if v is not None:
            if len(v) != 3:
                raise ValueError('activation_split must have 3 elements')
            for i in v:
                if i < 0:
                    raise ValueError('activation_split must be greater than 0')
            if sum(v) == 0:
                raise ValueError("activation_split should contain at least one none-zero value")
        return v
Attributes
monotonicities: Optional[dict[str, int]] = None class-attribute instance-attribute
activation_split: Optional[list[float]] = [1, 1, 1] class-attribute instance-attribute
Functions
validate_monotonicities(v)
Source code in physXAI/models/ann/configs/ann_model_configs.py 
53
54
55
56
57
58
59
60
@field_validator('monotonicities')
def validate_monotonicities(cls, v):
    if v is not None:
        for i in v.values():
            if i not in [0, -1, 1]:
                raise ValueError('monotonicities must be 0 (no monotony), 1 (positive monotony) '
                                 'or -1 (negative monotony)')
    return v
validate_activation_split(v)
Source code in physXAI/models/ann/configs/ann_model_configs.py 
62
63
64
65
66
67
68
69
70
71
72
@field_validator('activation_split')
def validate_activation_split(cls, v):
    if v is not None:
        if len(v) != 3:
            raise ValueError('activation_split must have 3 elements')
        for i in v:
            if i < 0:
                raise ValueError('activation_split must be greater than 0')
        if sum(v) == 0:
            raise ValueError("activation_split should contain at least one none-zero value")
    return v

RNNModelConstruction_config

Bases: BaseModel

Source code in physXAI/models/ann/configs/ann_model_configs.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
class RNNModelConstruction_config(BaseModel):
    rnn_units: int = Field(32, gt=0)
    rnn_layer: Literal["RNN", "GRU", "LSTM"] = "RNN"
    init_layer: Optional[Literal["dense", "RNN", "GRU", "LSTM"]] = "RNN"

    @field_validator("init_layer")
    def validate_init_layer(cls, v, info):
        if v is not None:
            if v != "dense":
                if v is not info.data.get('rnn_layer'):
                    raise ValueError(f"init_layer {v} should be the same as rnn_layer "
                                     f"{info.data.get('rnn_layer')} or dense")
        return v
Attributes
rnn_units: int = Field(32, gt=0) class-attribute instance-attribute
rnn_layer: Literal['RNN', 'GRU', 'LSTM'] = 'RNN' class-attribute instance-attribute
init_layer: Optional[Literal['dense', 'RNN', 'GRU', 'LSTM']] = 'RNN' class-attribute instance-attribute
Functions
validate_init_layer(v, info)
Source code in physXAI/models/ann/configs/ann_model_configs.py 
80
81
82
83
84
85
86
87
@field_validator("init_layer")
def validate_init_layer(cls, v, info):
    if v is not None:
        if v != "dense":
            if v is not info.data.get('rnn_layer'):
                raise ValueError(f"init_layer {v} should be the same as rnn_layer "
                                 f"{info.data.get('rnn_layer')} or dense")
    return v