Estimators

def __init__(
    self,
    *,
    input_configs: list[InputConfig] | None = None,
    n_mfs: int = 5,
    mf_init: str = "kmeans",
    sigma_scale: float | str = 1.0,
    random_state: int | None = None,
    epochs: int = 10,
    learning_rate: float = 1e-2,
    verbose: bool | int = False,
    rule_base: str | None = None,
    batch_size: int | None = 512,
    shuffle: bool = True,
    ur_weight: float = 0.0,
    ur_target: float | None = None,
    consequent_batch_norm: bool = False,
    pfrb_max_rules: int | None = None,
    patience: int | None = 20,
    restore_best: bool = True,
    validation_data: tuple[Any, Any] | None = None,
    weight_decay: float = 1e-8,
    adaptive: bool = True,
    lambda_: float = 1.0,
    lower_bound: float = 1.0 / math.e,
    K: float = 10.0,
) -> None:
    """Initialize an ADMTSK classifier estimator.

    Args:
        input_configs: Optional list of per-feature input configurations.
        n_mfs: Number of membership functions per input when using
            ``mf_init="kmeans"`` or ``mf_init="grid"``.
        mf_init: Initialisation strategy for MFs, either ``"kmeans"``
            or ``"grid"``.
        sigma_scale: Scale factor used to initialise Gaussian MF sigma
            values.
        random_state: Random seed for MF initialisation and weights.
        epochs: Maximum number of training epochs.
        learning_rate: Learning rate for the optimizer.
        verbose: Verbosity level for training output.
        rule_base: Rule base strategy override, typically ``"coco"`` or
            ``"cartesian"``.
        batch_size: Mini-batch size for training.
        shuffle: Whether to shuffle training data each epoch.
        ur_weight: Uniform-rule regularisation weight.
        ur_target: Target average rule activation for uniform regularisation.
        consequent_batch_norm: If True, apply batch normalization to
            consequent inputs.
        pfrb_max_rules: Maximum number of rules for point-based FRB.
        patience: Early stopping patience. Use ``None`` to disable.
        restore_best: If True, restore the best validation weights.
        validation_data: Validation dataset used for early stopping.
        weight_decay: Weight decay applied during training.
        adaptive: If True, use adaptive lambda selection for Dombi T-norm.
        lambda_: Fixed Dombi parameter when adaptive is False.
        lower_bound: Lower bound used by Composite GMF.
        K: Heuristic constant used to compute adaptive lambda.

    Raises:
        ValueError: If estimator hyperparameters are invalid.
    """
    super().__init__(
        input_configs=input_configs,
        n_mfs=n_mfs,
        mf_init=mf_init,
        sigma_scale=sigma_scale,
        random_state=random_state,
        epochs=epochs,
        learning_rate=learning_rate,
        verbose=verbose,
        rule_base=rule_base,
        batch_size=batch_size,
        shuffle=shuffle,
        ur_weight=ur_weight,
        ur_target=ur_target,
        consequent_batch_norm=consequent_batch_norm,
        pfrb_max_rules=pfrb_max_rules,
        patience=patience,
        restore_best=restore_best,
        validation_data=validation_data,
        weight_decay=weight_decay,
    )
    self.adaptive = bool(adaptive)
    self.lambda_ = float(lambda_)
    self.lower_bound = float(lower_bound)
    self.K = float(K)

def __init__(
    self,
    *,
    input_configs: list[InputConfig] | None = None,
    n_mfs: int = 5,
    mf_init: str = "kmeans",
    sigma_scale: float | str = 1.0,
    random_state: int | None = None,
    epochs: int = 10,
    learning_rate: float = 1e-2,
    verbose: bool | int = False,
    rule_base: str | None = None,
    batch_size: int | None = 512,
    shuffle: bool = True,
    ur_weight: float = 0.0,
    ur_target: float | None = None,
    consequent_batch_norm: bool = False,
    patience: int | None = 20,
    restore_best: bool = True,
    validation_data: tuple[Any, Any] | None = None,
    weight_decay: float = 1e-8,
    adaptive: bool = True,
    lambda_: float = 1.0,
    lower_bound: float = 1.0 / math.e,
    K: float = 10.0,
) -> None:
    """Initialize an ADMTSK regressor estimator.

    Args:
        input_configs: Optional list of per-feature input configurations.
        n_mfs: Number of membership functions per input when using
            ``mf_init="kmeans"`` or ``mf_init="grid"``.
        mf_init: Initialisation strategy for MFs, either ``"kmeans"``
            or ``"grid"``.
        sigma_scale: Scale factor used to initialise Gaussian MF sigma
            values.
        random_state: Random seed for MF initialisation and weights.
        epochs: Maximum number of training epochs.
        learning_rate: Learning rate for the optimizer.
        verbose: Verbosity level for training output.
        rule_base: Rule base strategy override, typically ``"coco"`` or
            ``"cartesian"``.
        batch_size: Mini-batch size for training.
        shuffle: Whether to shuffle training data each epoch.
        ur_weight: Uniform-rule regularisation weight.
        ur_target: Target average rule activation for uniform regularisation.
        consequent_batch_norm: If True, apply batch normalization to
            consequent inputs.
        patience: Early stopping patience. Use ``None`` to disable.
        restore_best: If True, restore the best validation weights.
        validation_data: Validation dataset used for early stopping.
        weight_decay: Weight decay applied during training.
        adaptive: If True, use adaptive lambda selection for Dombi T-norm.
        lambda_: Fixed Dombi parameter when adaptive is False.
        lower_bound: Lower bound used by Composite GMF.
        K: Heuristic constant used to compute adaptive lambda.

    Raises:
        ValueError: If estimator hyperparameters are invalid.
    """
    super().__init__(
        input_configs=input_configs,
        n_mfs=n_mfs,
        mf_init=mf_init,
        sigma_scale=sigma_scale,
        random_state=random_state,
        epochs=epochs,
        learning_rate=learning_rate,
        verbose=verbose,
        rule_base=rule_base,
        batch_size=batch_size,
        shuffle=shuffle,
        ur_weight=ur_weight,
        ur_target=ur_target,
        consequent_batch_norm=consequent_batch_norm,
        patience=patience,
        restore_best=restore_best,
        validation_data=validation_data,
        weight_decay=weight_decay,
    )
    self.adaptive = bool(adaptive)
    self.lambda_ = float(lambda_)
    self.lower_bound = float(lower_bound)
    self.K = float(K)

def __init__(
    self,
    *,
    input_configs: list[InputConfig] | None = None,
    n_mfs: int = 3,
    mf_init: str = "kmeans",
    sigma_scale: float | str = 1.0,
    random_state: int | None = None,
    epochs: int = 10,
    learning_rate: float = 1e-2,
    verbose: bool | int = False,
    rule_base: str | None = None,
    batch_size: int | None = 512,
    shuffle: bool = True,
    ur_weight: float = 0.0,
    ur_target: float | None = None,
    consequent_batch_norm: bool = False,
    pfrb_max_rules: int | None = None,
    patience: int | None = 20,
    restore_best: bool = True,
    validation_data: tuple[Any, Any] | None = None,
    weight_decay: float = 1e-8,
    kappa: float = 690.0,
    xi: float = 730.0,
    K: float = 1.0,
    eps: float | None = None,
) -> None:
    """Initialise an ADPTSK classifier estimator.

    Args:
        input_configs: Optional list of :class:`InputConfig` instances,
            one per feature. Only ``name`` is used when
            ``mf_init="kmeans"``.
        n_mfs: Number of membership functions per feature or k-means
            clusters.
        mf_init: Membership-function initialization strategy.
            ``"kmeans"`` or ``"grid"``.
        sigma_scale: Scale factor for Gaussian MF sigma initialization.
        random_state: Seed for k-means and PyTorch weight initialization.
        epochs: Maximum number of training epochs.
        learning_rate: Initial learning rate for the Adam optimizer.
        verbose: Verbosity level for training output.
        rule_base: Rule-base strategy, e.g. ``"coco"`` or ``"cartesian"``.
        batch_size: Mini-batch size. ``None`` uses the full dataset.
        shuffle: Whether to shuffle training samples each epoch.
        ur_weight: Uniform-rule regularization weight.
        ur_target: Target average rule activation for UR.
        consequent_batch_norm: Apply batch normalization to consequent
            linear layers.
        pfrb_max_rules: Maximum rules for point-based FRB when
            ``rule_base="pfrb"``.
        patience: Early-stopping patience. ``None`` disables early stopping.
        restore_best: Restore the best validation model weights after
            training.
        validation_data: Optional ``(X_val, y_val)`` tuple for early
            stopping.
        weight_decay: L2 weight decay coefficient for consequent parameters.
        kappa: ADPTSK ``κ`` parameter controlling the double-softmin
            geometry.
        xi: ADPTSK ``ξ`` parameter controlling adaptive softmin sharpness.
        K: Gaussian PIMF scaling constant used when wrapping the input MFs.
        eps: Optional lower bound for Gaussian PIMF values.
    """
    super().__init__(
        input_configs=input_configs,
        n_mfs=n_mfs,
        mf_init=mf_init,
        sigma_scale=sigma_scale,
        random_state=random_state,
        epochs=epochs,
        learning_rate=learning_rate,
        verbose=verbose,
        rule_base=rule_base,
        batch_size=batch_size,
        shuffle=shuffle,
        ur_weight=ur_weight,
        ur_target=ur_target,
        consequent_batch_norm=consequent_batch_norm,
        pfrb_max_rules=pfrb_max_rules,
        patience=patience,
        restore_best=restore_best,
        validation_data=validation_data,
        weight_decay=weight_decay,
    )
    self.kappa = float(kappa)
    self.xi = float(xi)
    self.K = float(K)
    self.eps = eps

def __init__(
    self,
    *,
    input_configs: list[InputConfig] | None = None,
    n_mfs: int = 3,
    mf_init: str = "kmeans",
    sigma_scale: float | str = 1.0,
    random_state: int | None = None,
    epochs: int = 10,
    learning_rate: float = 1e-2,
    verbose: bool | int = False,
    rule_base: str | None = None,
    batch_size: int | None = 512,
    shuffle: bool = True,
    ur_weight: float = 0.0,
    ur_target: float | None = None,
    consequent_batch_norm: bool = False,
    pfrb_max_rules: int | None = None,
    patience: int | None = 20,
    restore_best: bool = True,
    validation_data: tuple[Any, Any] | None = None,
    weight_decay: float = 1e-8,
    kappa: float = 690.0,
    xi: float = 730.0,
    K: float = 1.0,
    eps: float | None = None,
) -> None:
    """Initialise an ADPTSK regressor estimator.

    Args:
        input_configs: Optional list of :class:`InputConfig` instances,
            one per feature. Only ``name`` is used when
            ``mf_init="kmeans"``.
        n_mfs: Number of membership functions per feature or k-means
            clusters.
        mf_init: Membership-function initialization strategy.
            ``"kmeans"`` or ``"grid"``.
        sigma_scale: Scale factor for Gaussian MF sigma initialization.
        random_state: Seed for k-means and PyTorch weight initialization.
        epochs: Maximum number of training epochs.
        learning_rate: Initial learning rate for the Adam optimizer.
        verbose: Verbosity level for training output.
        rule_base: Rule-base strategy, e.g. ``"coco"`` or ``"cartesian"``.
        batch_size: Mini-batch size. ``None`` uses the full dataset.
        shuffle: Whether to shuffle training samples each epoch.
        ur_weight: Uniform-rule regularization weight.
        ur_target: Target average rule activation for UR.
        consequent_batch_norm: Apply batch normalization to consequent
            linear layers.
        pfrb_max_rules: Maximum rules for point-based FRB when
            ``rule_base="pfrb"``.
        patience: Early-stopping patience. ``None`` disables early stopping.
        restore_best: Restore the best validation model weights after
            training.
        validation_data: Optional ``(X_val, y_val)`` tuple for early
            stopping.
        weight_decay: L2 weight decay coefficient for consequent parameters.
        kappa: ADPTSK ``κ`` parameter controlling the double-softmin
            geometry.
        xi: ADPTSK ``ξ`` parameter controlling adaptive softmin sharpness.
        K: Gaussian PIMF scaling constant used when wrapping the input MFs.
        eps: Optional lower bound for Gaussian PIMF values.
    """
    super().__init__(
        input_configs=input_configs,
        n_mfs=n_mfs,
        mf_init=mf_init,
        sigma_scale=sigma_scale,
        random_state=random_state,
        epochs=epochs,
        learning_rate=learning_rate,
        verbose=verbose,
        rule_base=rule_base,
        batch_size=batch_size,
        shuffle=shuffle,
        ur_weight=ur_weight,
        ur_target=ur_target,
        consequent_batch_norm=consequent_batch_norm,
        pfrb_max_rules=pfrb_max_rules,
        patience=patience,
        restore_best=restore_best,
        validation_data=validation_data,
        weight_decay=weight_decay,
    )
    self.kappa = float(kappa)
    self.xi = float(xi)
    self.K = float(K)
    self.eps = eps