- 贝叶斯回归
- sklearn.linear_model.BayesianRidge
- sklearn.linear_model.ARDRegression
贝叶斯回归
sklearn.linear_model.BayesianRidge
class sklearn.linear_model.BayesianRidge(*, n_iter=300, tol=0.001, alpha_1=1e-06,
alpha_2=1e-06, lambda_1=1e-06, lambda_2=1e-06, alpha_init=None, lambda_init=None,
compute_score=False, fit_intercept=True, normalize=False, copy_X=True, verbose=False)参数：
n_iter：int, default=300
最大迭代次数。应大于或等于1。
tol：float, default=1e-3
如果w已收敛，则停止算法。
alpha_1：float, default=1e-6
超参数：在alpha参数之前的Gamma分布的形状参数。
alpha_2：float, default=1e-6
超参数：反比例参数（速率参数）Gamma分布在alpha参数之前。
lambda_1：float, default=1e-6
超参数：在lambda参数之前的Gamma分布的形状参数。
lambda_2:float, default=1e-6
超参数：在lambda参数之前的Gamma分布的逆比例参数（速率参数）。
alpha_init:float, default=None
alpha的初始值（噪声的精度）。
lambda_init:float, default=None
lambda的初始值（权重的精度）。如果未设置，则lambda_init为1。
compute_score:bool, default=False
如果为真，则在每次优化迭代时计算对数边际似然。
fit_intercept:bool, default=True
是否计算此模型的截距。截距不作为概率参数，因此没有相关的方差。如果设置为False，
则计算中将不使用截距（即数据应居中）。
normalize:bool, default=False
当fit_intercept设置为False时，忽略此参数。如果为真，则回归前，通过减去平均值并除以l2范数，
对回归数X进行归一化。
copy_X:bool, default=True
如果为True，将复制X；否则，可能会覆盖它。
verbose:bool, default=False
拟合模型时的详细模式。属性：
coef_：array-like of shape (n_features,)
回归模型系数（分布均值）
intercept_：float
决策函数中的独立项。如果fit_intercept=False，则设置为0.0。
alpha_：float
噪声的估计精度。
lambda_：float
估计权重的精度。
sigma_：array-like of shape (n_features, n_features)
权的估计方差协方差矩阵
scores_：array-like of shape (n_iter_+1,)
如果计算出的_得分为真，则在每次优化迭代时的对数边际似然值（要最大化）。
该数组从为alpha和lambda的初始值获得的对数边缘似然值开始，以为估计的alpha和lambda获得的值结束。
n_iter_：int
达到停止标准的实际迭代次数。例子：
>>> from sklearn import linear_model
>>> clf = linear_model.BayesianRidge()
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
BayesianRidge()
>>> clf.predict([[1, 1]])
array([1.])方法：
__init__(self, *, n_iter=300, tol=0.001, alpha_1=1e-06, alpha_2=1e-06, lambda_1=1e-06, lambda_2=1e-06, alpha_init=None, lambda_init=None, compute_score=False, fit_intercept=True, normalize=False, copy_X=True, verbose=False)
初始化自身。
fit(self, X, y, Xy=None)
使用X，y作为训练数据拟合模型。
参数：
X：array-like of shape (n_samples, n_features)
训练数据
Y：array-like of shape (n_samples,) or (n_samples, n_targets)
目标值
返回：
self：object
返回self的实例。
get_params(self, deep=True)
获取此估计器的参数。
参数：
deep：bool, default=True
如果为True，则返回此估计器的参数以及包含的子对象（即估计器）。
返回：
params：mapping of string to any
映射到其值的参数名。
predict(self, X)
参数：
X：array_like or sparse matrix, shape (n_samples, n_features)
返回：
C：array, shape (n_samples,)
返回预测值
score(self, X, y, sample_weight=None)
返回预测的决定系数R^2。
系数R^2定义为(1-u/v)，其中u是残差平方和((y_true-y_pred)**2).sum()，
v是平方和的总和((y_true-y_true.mean())**2).sum()。最好的分数是1.0，
它可以是负的(因为模型可以任意恶化)。一个常数模型总是预测y的期望值，而不考虑输入特性，
则得到R^2分数为0.0。
参数：
X：array-like of shape (n_samples, n_features)
测试样本。
y：array-like of shape (n_samples,) or (n_samples, n_outputs)
X的真值。
sample_weight：array-like of shape (n_samples,), default=None
样本权重。
返回：
scorefloat
得分
set_params(self, **params)
设置此估计器的参数。
参数：
**params：dict
估计参数
返回：
Self：object
估计实例import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from sklearn.linear_model import BayesianRidge, LinearRegression
"""贝叶斯岭回归"""
# #############################################################################
# Generating simulated data with Gaussian weights
np.random.seed(0)
n_samples, n_features = 100, 100
X = np.random.randn(n_samples, n_features) # Create Gaussian data
# Create weights with a precision lambda_ of 4.
lambda_ = 4.
w = np.zeros(n_features)
# Only keep 10 weights of interest
relevant_features = np.random.randint(0, n_features, 10)
for i in relevant_features:
w[i] = stats.norm.rvs(loc=0, scale=1. / np.sqrt(lambda_))
# Create noise with a precision alpha of 50.
alpha_ = 50.
noise = stats.norm.rvs(loc=0, scale=1. / np.sqrt(alpha_), size=n_samples)
# Create the target
y = np.dot(X, w) + noise
# #############################################################################
# Fit the Bayesian Ridge Regression and an OLS for comparison
clf = BayesianRidge(compute_score=True)
clf.fit(X, y)
ols = LinearRegression()
ols.fit(X, y)
# #############################################################################
# Plot true weights, estimated weights, histogram of the weights, and
# predictions with standard deviations
lw = 2
plt.figure(figsize=(6, 5))
plt.title("Weights of the model")
plt.plot(clf.coef_, color='lightgreen', linewidth=lw,
label="Bayesian Ridge estimate")
plt.plot(w, color='gold', linewidth=lw, label="Ground truth")
plt.plot(ols.coef_, color='navy', linestyle='--', label="OLS estimate")
plt.xlabel("Features")
plt.ylabel("Values of the weights")
plt.legend(loc="best", prop=dict(size=12))
plt.figure(figsize=(6, 5))
plt.title("Histogram of the weights")
plt.hist(clf.coef_, bins=n_features, color='gold', log=True,
edgecolor='black')
plt.scatter(clf.coef_[relevant_features], np.full(len(relevant_features), 5.),
color='navy', label="Relevant features")
plt.ylabel("Features")
plt.xlabel("Values of the weights")
plt.legend(loc="upper left")
plt.figure(figsize=(6, 5))
plt.title("Marginal log-likelihood")
plt.plot(clf.scores_, color='navy', linewidth=lw)
plt.ylabel("Score")
plt.xlabel("Iterations")
# Plotting some predictions for polynomial regression
def f(x, noise_amount):
y = np.sqrt(x) * np.sin(x)
noise = np.random.normal(0, 1, len(x))
return y + noise_amount * noise
degree = 10
X = np.linspace(0, 10, 100)
y = f(X, noise_amount=0.1)
clf_poly = BayesianRidge()
clf_poly.fit(np.vander(X, degree), y)
X_plot = np.linspace(0, 11, 25)
y_plot = f(X_plot, noise_amount=0)
y_mean, y_std = clf_poly.predict(np.vander(X_plot, degree), return_std=True)
plt.figure(figsize=(6, 5))
plt.errorbar(X_plot, y_mean, y_std, color='navy',
label="Polynomial Bayesian Ridge Regression", linewidth=lw)
plt.plot(X_plot, y_plot, color='gold', linewidth=lw,
label="Ground Truth")
plt.ylabel("Output y")
plt.xlabel("Feature X")
plt.legend(loc="lower left")
plt.show()sklearn.linear_model.ARDRegression
class sklearn.linear_model.ARDRegression(*, n_iter=300, tol=0.001,
alpha_1=1e-06, alpha_2=1e-06, lambda_1=1e-06, lambda_2=1e-06, compute_score=False,
threshold_lambda=10000.0, fit_intercept=True, normalize=False, copy_X=True, verbose=False)参数：
n_iter：int, default=300
最大迭代次数。应大于或等于1。
tol：float, default=1e-3
如果w已收敛，则停止算法。
alpha_1：float, default=1e-6
超参数：在alpha参数之前的Gamma分布的形状参数。
alpha_2：float, default=1e-6
超参数：反比例参数（速率参数）Gamma分布在alpha参数之前。
lambda_1：float, default=1e-6
超参数：在lambda参数之前的Gamma分布的形状参数。
lambda_2:float, default=1e-6
超参数：在lambda参数之前的Gamma分布的逆比例参数（速率参数）。
compute_score：bool, default=False
如果为真，则在模型的每个步骤计算目标函数。
threshold_lambda：float, default=10 000
从计算中高精度移除（修剪）权重的阈值。
fit_intercept：bool, default=True
是否计算此模型的截距。如果设置为false，则计算中将不使用截距（即数据应居中）。
normalize：bool, default=False
当fit_intercept设置为False时，忽略此参数。如果为真，则回归前，通过减去平均值并除以l2范数，
对回归数X进行归一化。
copy_X：bool, default=True
如果为True，将复制X；否则，可能会覆盖它。
verbose：bool, default=False
拟合模型时的详细模式。属性：
alpha_：float
噪声的估计精度。
coef_：array-like of shape (n_features,)
回归模型系数（分布均值）
lambda_：float
估计权重的精度。
sigma_：array-like of shape (n_features, n_features)
权的估计方差协方差矩阵
scores_：array-like of shape (n_iter_+1,)
如果计算出的_得分为真，则在每次优化迭代时的对数边际似然值（要最大化）。该数组从为alpha和lambda的初始值获得的对数边缘似然值开始，以为估计的alpha和lambda获得的值结束。
intercept_：float
决策函数中的独立项。如果fit_intercept=False，则设置为0.0。例子
>>> from sklearn import linear_model
>>> clf = linear_model.ARDRegression()
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
ARDRegression()
>>> clf.predict([[1, 1]])
array([1.])方法：
__init__(self, *, n_iter=300, tol=0.001, alpha_1=1e-06, alpha_2=1e-06,
lambda_1=1e-06, lambda_2=1e-06, compute_score=False,
threshold_lambda=10000.0, fit_intercept=True, normalize=False, copy_X=True, verbose=False)
fit(self, X, y, Xy=None)
使用X，y作为训练数据拟合模型。
参数：
X：array-like of shape (n_samples, n_features)
训练数据
Y：array-like of shape (n_samples,) or (n_samples, n_targets)
目标值
返回：
self：object
返回self的实例。
get_params(self, deep=True)
获取此估计器的参数。
参数：
deep：bool, default=True
如果为True，则返回此估计器的参数以及包含的子对象（即估计器）。
返回：
params：mapping of string to any
映射到其值的参数名。
predict(self, X)
参数：
X：array_like or sparse matrix, shape (n_samples, n_features)
返回：
C：array, shape (n_samples,)
返回预测值
score(self, X, y, sample_weight=None)
返回预测的决定系数R^2。
系数R^2定义为(1-u/v)，其中u是残差平方和((y_true-y_pred)**2).sum()，
v是平方和的总和((y_true-y_true.mean())**2).sum()。
最好的分数是1.0，它可以是负的(因为模型可以任意恶化)。
一个常数模型总是预测y的期望值，而不考虑输入特性，则得到R^2分数为0.0。
参数：
X：array-like of shape (n_samples, n_features)
测试样本。
y：array-like of shape (n_samples,) or (n_samples, n_outputs)
X的真值。
sample_weight：array-like of shape (n_samples,), default=None
样本权重。
返回：
scorefloat
得分
set_params(self, **params)
设置此估计器的参数。
参数：
**params：dict
估计参数
返回：
Self：object
估计实例
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
