mambular.models

class mambular.models.MambularClassifier(*args: Any, **kwargs: Any)

Mambular 分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认 Mambular 配置的 Mambular 模型。

MambularClassifier 类接受的参数包括 DefaultMambularConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’avg’，’max’ 等）。

• bidirectional (bool, default=False) – 是否使用输入序列的双向处理。

• use_learnable_interaction (bool, default=False) – 是否在使用 mamba 块之前使用可学习的特征交互。

• shuffle_embeddings (bool, default=False.) – 在传递给 Mamba 层之前是否对嵌入进行洗牌。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• AD_weight_decay (bool, default=True) – 权重衰减是否也应用于A-D矩阵。

• BC_layer_norm (bool, default=False) – 是否对B-C矩阵应用层归一化。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MambularClassifier 类的接受参数与 DefaultMambularConfig 数据类中的属性相同。

• MambularClassifier 使用 SklearnBaseClassifier 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseClassifier

MambularClassifier 的父类。

示例

>>> from mambular.models import MambularClassifier
>>> model = MambularClassifier(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MambularRegressor(*args: Any, **kwargs: Any)

Mambular 回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的 Mambular 配置的 Mambular 模型。

MambularRegressor 类接受的参数包括 DefaultMambularConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’avg’，’max’ 等）。

• bidirectional (bool, default=False) – 是否使用输入序列的双向处理。

• use_learnable_interaction (bool, default=False) – 是否在使用 mamba 块之前使用可学习的特征交互。

• use_cls (bool, default=True) – 是否在每个’序列’的末尾添加一个 cls。

• shuffle_embeddings (bool, default=False.) – 在传递给 Mamba 层之前是否对嵌入进行洗牌。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• AD_weight_decay (bool, default=True) – 权重衰减是否也应用于A-D矩阵。

• BC_layer_norm (bool, default=False) – 是否对B-C矩阵应用层归一化。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MambularRegressor 类的接受参数与 DefaultMambularConfig 数据类中的属性相同。

• MambularRegressor 使用 SklearnBaseRegressor 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参阅父类。

参见

mambular.models.SklearnBaseRegressor

MambularRegressor 的父类。

示例

>>> from mambular.models import MambularRegressor
>>> model = MambularRegressor(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MambularLSS(*args: Any, **kwargs: Any)

用于分布回归的 Mambular。此类扩展了 SklearnBaseLSS 类，并使用默认 Mambular 配置的 Mambular 模型。

MambularLSS 类接受的参数包括 DefaultMambularConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• family (str, default=None) – 用于模型的分布族。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’avg’，’max’ 等）。

• bidirectional (bool, default=False) – 是否使用输入序列的双向处理。

• use_learnable_interaction (bool, default=False) – 是否在使用 mamba 块之前使用可学习的特征交互。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• shuffle_embeddings (bool, default=False.) – 在传递给 Mamba 层之前是否对嵌入进行洗牌。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• AD_weight_decay (bool, default=True) – 权重衰减是否也应用于A-D矩阵。

• BC_layer_norm (bool, default=False) – 是否对B-C矩阵应用层归一化。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• task (str, default="regression") – 指示机器学习任务的类型（’回归’ 或 ‘分类’）。这可能会影响某些预处理行为，特别是在使用基于决策树的分箱时。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MambularLSS 类的接受参数与 DefaultMambularConfig 数据类中的属性相同。

• MambularLSS 使用 SklearnBaseLSS 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseLSS

MambularLSS 的父类。

示例

>>> from mambular.models import MambularLSS
>>> model = MambularLSS(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train, family="normal")
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.FTTransformerClassifier(*args: Any, **kwargs: Any)

FTTransformer 分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认的 FTTransformer 配置的 FTTransformer 模型。

FTTransformerClassifier 类接受的参数包括 DefaultFTTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• FTTransformerClassifier 类的接受参数与 DefaultFTTransformerConfig 数据类中的属性相同。

• FTTransformerClassifier 使用 SklearnBaseClassifier 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseClassifier

FTTransformerClassifier 的父类。

示例

>>> from mambular.models import FTTransformerClassifier
>>> model = FTTransformerClassifier(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.FTTransformerRegressor(*args: Any, **kwargs: Any)

FTTransformer 回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的 FTTransformer 配置的 FTTransformer 模型。

FTTransformerRegressor 类接受的参数包括 DefaultFTTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• family (str, default=None) – 用于模型的分布族。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• FTTransformerRegressor 类的接受参数与 DefaultFTTransformerConfig 数据类中的属性相同。

• FTTransformerRegressor 使用 SklearnBaseRegressor 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseRegressor

FTTransformerRegressor 的父类。

示例

>>> from mambular.models import FTTransformerRegressor
>>> model = FTTransformerRegressor(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.FTTransformerLSS(*args: Any, **kwargs: Any)

FTTransformer 用于分布回归。此类扩展了 SklearnBaseLSS 类，并使用默认的 FTTransformer 配置的 FTTransformer 模型。

FTTransformerLSS 类接受的参数包括 DefaultFTTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• task (str, default="regression") – 指示机器学习任务的类型（’回归’ 或 ‘分类’）。这可能会影响某些预处理行为，特别是在使用基于决策树的分箱时。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• FTTransformerLSS 类的接受参数与 DefaultFTTransformerConfig 数据类中的属性相同。

• FTTransformerLSS 使用 SklearnBaseLSS 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseLSS

FTTransformerLSS 的父类。

示例

>>> from mambular.models import FTTransformerLSS
>>> model = FTTransformerLSS(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train, family="normal")
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MLPClassifier(*args: Any, **kwargs: Any)

多层感知器分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认 MLP 配置的 MLP 模型。

MLPClassifier 类接受的参数包括 DefaultMLPConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – MLP 中各层的尺寸。

• activation (callable, default=nn.SELU()) – MLP 层的激活函数。

• skip_layers (bool, default=False) – 是否在MLP中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• use_glu (bool, default=False) – 是否在 MLP 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=False) – 是否在 MLP 中使用跳跃连接。

• batch_norm (bool, default=False) – 是否在MLP层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在MLP层中使用层归一化。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MLPClassifier 类的接受参数与 DefaultMLPConfig 数据类中的属性相同。

• MLPClassifier 使用 SklearnBaseClassifier 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseRegressor

MLPClassifier 的父类。

示例

>>> from mambular.models import MLPClassifier
>>> model = MLPClassifier(layer_sizes=[128, 128, 64], activation=nn.ReLU())
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MLPRegressor(*args: Any, **kwargs: Any)

多层感知器回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的多层感知器配置的 MLP 模型。

MLPRegressor 类的接受参数包括 DefaultMLPConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – MLP 中各层的尺寸。

• activation (callable, default=nn.SELU()) – MLP 层的激活函数。

• skip_layers (bool, default=False) – 是否在MLP中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• use_glu (bool, default=False) – 是否在 MLP 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=False) – 是否在 MLP 中使用跳跃连接。

• batch_norm (bool, default=False) – 是否在MLP层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在MLP层中使用层归一化。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MLPRegressor 类的接受参数与 DefaultMLPConfig 数据类中的属性相同。

• MLPRegressor 使用 SklearnBaseRegressor 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseRegressor

MLPRegressor 的父类。

示例

>>> from mambular.models import MLPRegressor
>>> model = MLPRegressor(layer_sizes=[128, 128, 64], activation=nn.ReLU())
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MLPLSS(*args: Any, **kwargs: Any)

用于分布回归的多层感知器。此类扩展了 SklearnBaseLSS 类，并使用默认 MLP 配置的 MLP 模型。

MLPLSS 类接受的参数包括 DefaultMLPConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• family (str, default=None) – 用于模型的分布族。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – MLP 中各层的尺寸。

• activation (callable, default=nn.SELU()) – MLP 层的激活函数。

• skip_layers (bool, default=False) – 是否在MLP中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• use_glu (bool, default=False) – 是否在 MLP 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=False) – 是否在 MLP 中使用跳跃连接。

• batch_norm (bool, default=False) – 是否在MLP层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在MLP层中使用层归一化。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• task (str, default="regression") – 指示机器学习任务的类型（’回归’ 或 ‘分类’）。这可能会影响某些预处理行为，特别是在使用基于决策树的分箱时。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• MLPLSS 类的接受参数与 DefaultMLPConfig 数据类中的属性相同。

• MLPLSS 使用 SklearnBaseLSS 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseLSS

MLPLSS 的父类。

示例

>>> from mambular.models import MLPLSS
>>> model = MLPLSS(layer_sizes=[128, 128, 64], activation=nn.ReLU())
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabTransformerClassifier(*args: Any, **kwargs: Any)

TabTransformer 分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认的 TabTransformer 配置的 TabTransformer 模型。

TabTransformerClassifier 类接受的参数包括 DefaultTabTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=True) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• TabTransformerClassifier 类接受的参数与 DefaultTabTransformerConfig 数据类中的属性相同。

• TabTransformerClassifier 使用 SklearnBaseClassifier 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参阅父类。

参见

mambular.models.SklearnBaseClassifier

TabTransformerClassifier 的父类。

示例

>>> from mambular.models import TabTransformerClassifier
>>> model = TabTransformerClassifier(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabTransformerRegressor(*args: Any, **kwargs: Any)

TabTransformer 回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的 TabTransformer 配置的 TabTransformer 模型。

TabTransformerRegressor 类接受的参数包括 DefaultTabTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• family (str, default=None) – 用于模型的分布族。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=True) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• TabTransformerRegressor 类的接受参数与 DefaultTabTransformerConfig 数据类中的属性相同。

• TabTransformerRegressor 使用 SklearnBaseRegressor 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseRegressor

TabTransformerRegressor 的父类。

示例

>>> from mambular.models import TabTransformerRegressor
>>> model = TabTransformerRegressor(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabTransformerLSS(*args: Any, **kwargs: Any)

用于分布回归的 TabTransformer。此类扩展了 SklearnBaseLSS 类，并使用默认的 TabTransformer 配置的 TabTransformer 模型。

TabTransformerLSS 类接受的参数包括 DefaultTabTransformerConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• n_heads (int, default=4) – transformer 中的注意力头数量。

• attn_dropout (float, default=0.3) – 注意力机制的丢弃率。

• ff_dropout (float, default=0.3) – 前馈层的丢弃率。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="avg") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=True) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• transformer_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• layer_norm_eps (float, default=1e-05) – 层归一化的Epsilon值。

• transformer_dim_feedforward (int, default=512) – transformer 中前馈层的维度。

• cat_encoding (str, default="int") – 是否对分类特征使用整数编码或独热编码。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• task (str, default="regression") – 指示机器学习任务的类型（’回归’ 或 ‘分类’）。这可能会影响某些预处理行为，特别是在使用基于决策树的分箱时。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• TabTransformerLSS 类接受的参数与 DefaultTabTransformerConfig 数据类中的属性相同。

• TabTransformerLSS 使用 SklearnBaseLSS 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseLSS

TabTransformerLSS 的父类。

示例

>>> from mambular.models import TabTransformerLSS
>>> model = TabTransformerLSS(d_model=64, n_layers=8)
>>> model.fit(X_train, y_train, family="normal")
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.ResNetClassifier(*args: Any, **kwargs: Any)

ResNet 分类器。此类扩展了 SklearnBaseClassifier 类，并使用具有默认 ResNet 配置的 ResNet 模型。

ResNetClassifier 类接受的参数包括 DefaultResNetConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – ResNet 中各层的尺寸。

• activation (callable, default=nn.SELU()) – ResNet 层的激活函数。

• skip_layers (bool, default=False) – 是否在ResNet中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• use_glu (bool, default=False) – 是否在 ResNet 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=True) – 是否在ResNet中使用跳跃连接。

• batch_norm (bool, default=True) – 是否在ResNet层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在ResNet层中使用层归一化。

• num_blocks (int, default=3) – ResNet 中残差块的数量。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• ResNetClassifier 类的接受参数与 DefaultResNetConfig 数据类中的属性相同。

• ResNetClassifier 使用 SklearnBaseClassifier 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseClassifier

ResNetClassifier 的父类。

示例

>>> from mambular.models import ResNetClassifier
>>> model = ResNetClassifier()
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.ResNetRegressor(*args: Any, **kwargs: Any)

ResNet 回归器。此类扩展了 SklearnBaseRegressor 类，并使用具有默认 ResNet 配置的 ResNet 模型。

ResNetRegressor 类接受的参数包括 DefaultResNetConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – ResNet 中各层的尺寸。

• activation (callable, default=nn.SELU()) – ResNet 层的激活函数。

• skip_layers (bool, default=False) – 是否在ResNet中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• use_glu (bool, default=False) – 是否在 ResNet 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=True) – 是否在ResNet中使用跳跃连接。

• batch_norm (bool, default=True) – 是否在ResNet层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在ResNet层中使用层归一化。

• num_blocks (int, default=3) – ResNet 中残差块的数量。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• ResNetRegressor 类的接受参数与 DefaultResNetConfig 数据类中的属性相同。

• ResNetRegressor 使用 SklearnBaseRegressor 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseRegressor

ResNetRegressor 的父类。

示例

>>> from mambular.models import ResNetRegressor
>>> model = ResNetRegressor()
>>> model.fit(X_train, y_train)
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.ResNetLSS(*args: Any, **kwargs: Any)

用于分布回归的 ResNet。此类扩展了 SklearnBaseLSS 类，并使用默认的 ResNet 配置的 ResNet 模型。

ResNetLSS 类接受的参数包括 DefaultResNetConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• layer_sizes (list, default=(128, 128, 32)) – ResNet 中各层的尺寸。

• activation (callable, default=nn.SELU()) – ResNet 层的激活函数。

• skip_layers (bool, default=False) – 是否在ResNet中跳过层。

• dropout (float, default=0.5) – 用于正则化的丢弃率。

• norm (str, default=None) – 如果使用，将使用的标准化方法。

• family (str, default=None) – 用于模型的分布族。

• use_glu (bool, default=False) – 是否在 ResNet 中使用门控线性单元 (GLU)。

• skip_connections (bool, default=True) – 是否在ResNet中使用跳跃连接。

• batch_norm (bool, default=True) – 是否在ResNet层中使用批量归一化。

• layer_norm (bool, default=False) – 是否在ResNet层中使用层归一化。

• num_blocks (int, default=3) – ResNet 中残差块的数量。

• use_embeddings (bool, default=False) – 是否为所有特征使用嵌入层。

• embedding_activation (callable, default=nn.Identity()) – 嵌入的激活函数。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• d_model (int, default=32) – 嵌入的维度。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• task (str, default="regression") – 指示机器学习任务的类型（’回归’ 或 ‘分类’）。这可能会影响某些预处理行为，特别是在使用基于决策树的分箱时。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

备注

• ResNetLSS 类的接受参数与 DefaultResNetConfig 数据类中的属性相同。

• ResNetLSS 使用 SklearnBaseLSS 作为父类。拟合、预测和评估模型的方法继承自父类。更多信息请参考父类。

参见

mambular.models.SklearnBaseLSS

ResNetLSS 的父类。

示例

>>> from mambular.models import ResNetLSS
>>> model = ResNetLSS()
>>> model.fit(X_train, y_train, family="normal")
>>> preds = model.predict(X_test)
>>> model.evaluate(X_test, y_test)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MambaTabClassifier(*args: Any, **kwargs: Any)

MambaTab 分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认 MambaTab 配置的 MambaTab 模型。

MambaTabClassifier 类接受的参数包括 DefaultMambaTabConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="LayerNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• num_embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• norm – 要使用的归一化方法。

• axis (int, default=1) – Mamba 迭代的轴。如果是 1，它迭代行；如果是 0，它迭代列。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MambaTabRegressor(*args: Any, **kwargs: Any)

MambaTab 回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的 MambaTab 配置的 MambaTab 模型。

MambaTabRegressor 类接受的参数包括 DefaultMambaTabConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="LayerNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• num_embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• norm – 要使用的归一化方法。

• axis (int, default=1) – Mamba 迭代的轴。如果是 1，它迭代行；如果是 0，它迭代列。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.MambaTabLSS(*args: Any, **kwargs: Any)

用于分布回归的 MambaTab。此类扩展了 SklearnBaseLSS 类，并使用默认 MambaTab 配置的 MambaTab 模型。

MambaTabLSS 类接受的参数包括 DefaultMambaTabConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• family (str, default=None) – 用于模型的分布族。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – 模型中的层数。

• expand_factor (int, default=2) – 前馈层的扩展因子。

• bias (bool, default=False) – 是否在线性层中使用偏置。

• d_conv (int, default=16) – 卷积层的维度。

• conv_bias (bool, default=True) – 是否在卷积层中使用偏置。

• dropout (float, default=0.05) – 用于正则化的丢弃率。

• dt_rank (str, default="auto") – 决策树的等级。

• d_state (int, default=32) – 循环层中状态的维度。

• dt_scale (float, default=1.0) – 决策树的缩放因子。

• dt_init (str, default="random") – 决策树的初始化方法。

• dt_max (float, default=0.1) – 决策树初始化的最大值。

• dt_min (float, default=1e-04) – 决策树初始化的最小值。

• dt_init_floor (float, default=1e-04) – 决策树初始化的地板值。

• norm (str, default="LayerNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – 模型的激活函数。

• num_embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• norm – 要使用的归一化方法。

• axis (int, default=1) – Mamba 迭代的轴。如果是 1，它迭代行；如果是 0，它迭代列。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabulaRNNClassifier(*args: Any, **kwargs: Any)

RNN 分类器。此类扩展了 SklearnBaseClassifier 类，并使用默认的 TabulaRNN 配置的 TabulaRNN 模型。

TabulaRNNClassifier 类接受的参数包括 DefaultTabulaRNNConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• model_type (str, default="RNN") – 模型类型，可选值为 “RNN”、”LSTM”、”GRU”

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• rnn_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• bidirectional (bool, default=False.) – 是否双向处理数据

• cat_encoding (str, default="int") – 分类特征的编码方法。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabulaRNNRegressor(*args: Any, **kwargs: Any)

RNN 回归器。此类扩展了 SklearnBaseRegressor 类，并使用默认的 TabulaRNN 配置的 TabulaRNN 模型。

TabulaRNNRegressor 类接受的参数包括 DefaultTabulaRNNConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• model_type (str, default="RNN") – 模型类型，可选值为 “RNN”、”LSTM”、”GRU”

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• rnn_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• bidirectional (bool, default=False.) – 是否双向处理数据

• cat_encoding (str, default="int") – 分类特征的编码方法。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.TabulaRNNLSS(*args: Any, **kwargs: Any)

RNN LSS。此类扩展了 SklearnBaseLSS 类，并使用默认的 TabulaRNN 配置的 TabulaRNN 模型。

TabulaRNNLSS 类接受的参数包括 DefaultTabulaRNNConfig 数据类中的属性和 Preprocessor 类的参数。

参数:

• lr (float, default=1e-04) – 优化器的学习率。

• model_type (str, default="RNN") – 模型类型，可选值为 “RNN”、”LSTM”、”GRU”

• family (str, default=None) – 用于模型的分布族。

• lr_patience (int, default=10) – 在降低学习率之前，没有改进的时期数。

• weight_decay (float, default=1e-06) – 优化器的权重衰减（L2 惩罚）。

• lr_factor (float, default=0.1) – 学习率将减少的倍数。

• d_model (int, default=64) – 模型的维度。

• n_layers (int, default=8) – Transformer 中的层数。

• norm (str, default="RMSNorm") – 要使用的归一化方法。

• activation (callable, default=nn.SELU()) – transformer 的激活函数。

• embedding_activation (callable, default=nn.Identity()) – 数值嵌入的激活函数。

• head_layer_sizes (list, default=(128, 64, 32)) – 模型头部各层的尺寸。

• head_dropout (float, default=0.5) – 头部层的丢弃率。

• head_skip_layers (bool, default=False) – 是否在头部跳过层。

• head_activation (callable, default=nn.SELU()) – 头部层的激活函数。

• head_use_batch_norm (bool, default=False) – 是否在头部层中使用批量归一化。

• layer_norm_after_embedding (bool, default=False) – 是否在嵌入后应用层归一化。

• pooling_method (str, default="cls") – 要使用的池化方法（’cls’、’avg’ 等）。

• norm_first (bool, default=False) – 是否在每个转换器块中的其他操作之前应用归一化。

• bias (bool, default=True) – 是否在线性层中使用偏置。

• rnn_activation (callable, default=nn.SELU()) – 变压器层的激活函数。

• bidirectional (bool, default=False.) – 是否双向处理数据

• cat_encoding (str, default="int") – 分类特征的编码方法。

• n_bins (int, default=50) – 用于数值特征分箱的箱数。仅当 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时，此参数才相关。

• numerical_preprocessing (str, default="ple") – 数值特征的预处理策略。有效选项包括 ‘分箱’、’独热编码’、’标准化’ 和 ‘归一化’。

• use_decision_tree_bins (bool, default=False) – 如果为 True，则使用决策树回归/分类来确定数值特征分箱的最佳边缘。此参数仅在 numerical_preprocessing 设置为 ‘binning’ 或 ‘one_hot’ 时相关。

• binning_strategy (str, default="uniform") – 定义数值特征的分箱策略。选项包括 ‘uniform’、’quantile’ 或其他与 sklearn 兼容的策略。

• cat_cutoff (float or int, default=0.03) – 指示整数值被视为分类后的截止点。如果是浮点数，则视为百分比。如果是整数，则是一个列被视为分类的最大唯一值数。

• treat_all_integers_as_numerical (bool, default=False) – 如果为True，所有整数列将被视为数值型，无论其唯一值的数量或比例如何。

• degree (int, default=3) – 在预处理中要使用的多项式特征的次数。

• knots (int, default=12) – 在样条变换中要使用的节点数。

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.SklearnBaseClassifier(*args: Any, **kwargs: Any)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 构建的分类器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练分类模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• rebuild (bool, default=True) – 当模型已经构建时，是否重新构建模型。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 已拟合的分类器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

predict_proba(X)

预测给定输入样本的类别概率。

参数:

X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 用于预测类别概率的输入样本。

备注

该方法使用训练期间使用的相同预处理器对输入数据进行预处理，将模型设置为评估模式，然后执行推理以预测类概率。对logits应用Softmax以获得概率，然后将其从PyTorch张量转换为NumPy数组，最后返回。

示例

>>> from sklearn.metrics import accuracy_score, precision_score, f1_score, roc_auc_score
>>> # Define the metrics you want to evaluate
>>> metrics = {
...     'Accuracy': (accuracy_score, False),
...     'Precision': (precision_score, False),
...     'F1 Score': (f1_score, False),
...     'AUC Score': (roc_auc_score, True)
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = classifier.evaluate(X_test, y_test, metrics=metrics)

返回:

probabilities – 每个输入样本的预测类别概率。

返回类型:

ndarray of shape (n_samples, n_classes)

score(X, y, metric=(sklearn.metrics.log_loss, True))

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metric (tuple, default=(log_loss, True)) – 包含度量函数的元组，以及一个布尔值，指示该度量是否需要概率分数（True）或类别标签（False）。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.SklearnBaseLSS(*args: Any, **kwargs: Any)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的分布回归器。

返回类型:

object

evaluate(X, y_true, metrics=None, distribution_family=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,)) – 用于评估预测结果的真实类别标签。

• metrics (dict) – 一个字典，其中键是指标名称，值是包含指标函数和一个布尔值的元组，该布尔值指示指标是否需要概率分数（True）或类别标签（False）。

• distribution_family (str, optional) – 指定模型预测的分布族。如果为 None，它将尝试根据模型的设置推断。

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

备注

此方法根据指标要求使用 predict 或 predict_proba 方法。

fit(X, y, family, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', distributional_kwargs=None, dataloader_kwargs={}, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• family (str) – 用于损失函数的分布族名称。例如，’normal’ 用于回归任务。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• distributional_kwargs (dict, default=None) – 特定发行版专用的任何参数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_default_metrics(distribution_family)

基于分布族提供默认指标。

参数:

distribution_family (str) – 要为其提供默认指标的分布族。

返回:

metrics – 默认度量函数的字典。

返回类型:

dict

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X, raw=False)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric='NLL')

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (str, default="NLL") – 到目前为止，仅支持负对数似然

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object

class mambular.models.SklearnBaseRegressor(*args: Any, **kwargs: Any)

build_model(X, y, val_size=0.2, X_val=None, y_val=None, random_state=101, batch_size=128, shuffle=True, lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, dataloader_kwargs={})

使用提供的训练数据构建模型。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

返回:

self – 内置的回归器。

返回类型:

object

evaluate(X, y_true, metrics=None)

使用指定的指标对给定数据上的模型进行评估。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y_true (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metrics (dict) – 一个字典，其中键是指标名称，值是指标函数。

备注

此方法使用 predict 方法生成预测并计算每个指标。

示例

>>> from sklearn.metrics import mean_squared_error, r2_score
>>> from sklearn.model_selection import train_test_split
>>> from mambular.models import MambularRegressor
>>> metrics = {
...     'Mean Squared Error': mean_squared_error,
...     'R2 Score': r2_score
... }
>>> # Assuming 'X_test' and 'y_test' are your test dataset and labels
>>> # Evaluate using the specified metrics
>>> results = regressor.evaluate(X_test, y_test, metrics=metrics)

返回:

scores – 一个字典，键为指标名称，值为相应的分数。

返回类型:

dict

fit(X, y, val_size=0.2, X_val=None, y_val=None, max_epochs=100, random_state=101, batch_size=128, shuffle=True, patience=15, monitor='val_loss', mode='min', lr=0.0001, lr_patience=10, factor=0.1, weight_decay=1e-06, checkpoint_path='model_checkpoints', dataloader_kwargs={}, rebuild=True, **trainer_kwargs)

使用提供的训练数据训练回归模型。可选地，可以使用单独的验证集。

参数:

• X (DataFrame or array-like, shape (n_samples, n_features)) – 训练输入样本。

• y (array-like, shape (n_samples,) or (n_samples, n_targets)) – 目标值（实数）。

• val_size (float, default=0.2) – 如果 X_val 为 None，则在验证分割中包含的数据集的比例。如果提供了 X_val，则忽略此参数。

• X_val (DataFrame or array-like, shape (n_samples, n_features), optional) – 验证输入样本。如果提供，X 和 y 不会被分割，而是使用这些数据进行验证。

• y_val (array-like, shape (n_samples,) or (n_samples, n_targets), optional) – 验证目标值。如果提供了 X_val，则这是必需的。

• max_epochs (int, default=100) – 训练的最大轮数。

• random_state (int, default=101) – 在应用分割之前，控制应用于数据的洗牌操作。

• batch_size (int, default=64) – 每个梯度更新的样本数量。

• shuffle (bool, default=True) – 是否在每个epoch之前打乱训练数据。

• patience (int, default=10) – 在验证损失没有改善的情况下，等待提前停止的轮数。

• monitor (str, default="val_loss") – 用于监控提前停止的指标。

• mode (str, default="min") – 监控的指标应被最小化（min）还是最大化（max）。

• lr (float, default=1e-3) – 优化器的学习率。

• lr_patience (int, default=10) – 在验证损失没有改善的情况下，等待减少学习率的轮数。

• factor (float, default=0.1) – 学习率将减少的倍数。

• weight_decay (float, default=0.025) – 权重衰减（L2 惩罚）系数。

• checkpoint_path (str, default="model_checkpoints") – 保存检查点的路径。

• dataloader_kwargs (dict, default={}) – pytorch dataloader 类的 kwargs。

• **trainer_kwargs (Additional keyword arguments for PyTorch Lightning's Trainer class.) –

返回:

self – 拟合的回归器。

返回类型:

object

get_number_of_params(requires_grad=True)

计算模型中的参数数量。

参数:

requires_grad (bool, optional) – 如果为True，则仅计算需要梯度的参数（可训练参数）。如果为False，则计算所有参数。默认为True。

返回:

模型中的参数总数。

返回类型:

int

抛出:

ValueError – 如果在调用此方法之前尚未构建模型。

get_params(deep=True)

获取此估计器的参数。

参数:

deep (bool, default=True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。

返回:

params – 参数名称映射到它们的值。

返回类型:

dict

predict(X)

预测给定输入样本的目标值。

参数:

X (DataFrame or array-like, shape (n_samples, n_features)) – 用于预测目标值的输入样本。

返回:

predictions – 预测的目标值。

返回类型:

ndarray, shape (n_samples,) or (n_samples, n_outputs)

score(X, y, metric=sklearn.metrics.mean_squared_error)

使用指定的指标计算模型的分数。

参数:

• X (array-like or pd.DataFrame of shape (n_samples, n_features)) – 要预测的输入样本。

• y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – 用于评估预测结果的真实目标值。

• metric (callable, default=mean_squared_error) – 用于评估的度量函数。必须是一个具有 metric(y_true, y_pred) 签名的可调用对象。

返回:

score – 使用指定指标计算的分数。

返回类型:

float

set_params(**parameters)

设置此估计器的参数。

参数:

**parameters (dict) – 估计器参数。

返回:

self – 估计器实例。

返回类型:

object