Python监督学习_五种常见回归（线性模型）+ 朴素贝叶斯分类器_线性回归、岭回归、lasso、用于分类的线性模型、用于多分类的线性模型

接下来是五种回归(线性模型)

用于回归的线性模型(可以理解为直线方程或者加权求和)

单一预测为一条直线，两个特征为一个平面，以此类推。线性模型对多个特征的数据集而言非常强大！

X, y = mglearn.datasets.make_forge()
mglearn.plots.plot_linear_regression_wave()

1.线性回归(普通最小二乘法)

两个参数w(权重/系数 NumPy数组) in  coef_属性 ,  b(偏移/截距 浮点数) in intercept_属性。寻找这两个参数使得均方误差(预测值与真实值之差的平方和除以样本数)最小。由于此算法没有参数，故无法控制模型复杂度。

from sklearn.linear_model import LinearRegression
X, y = mglearn.datasets.make_wave(n_samples=60)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
lr = LinearRegression().fit(X_train, y_train)
print("lr.coef_: {}".format(lr.coef_))
print("lr.intercept_: {}".format(lr.intercept_))

训练集和测试集的性能，可能存在欠拟合，因为在训练集和测试集的分数很接近。

print("Training set score: {}".format(lr.score(X_train, y_train)))
print("Test set score: {}".format(lr.score(X_test, y_test)))

接下来用更大的数据集去看LinearRegression的表现，会发现在训练集分数较高，测试集低很多。

X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
lr = LinearRegression().fit(X_train, y_train)
print("Training set score: {}".format(lr.score(X_train, y_train)))
print("Test set score: {}".format(lr.score(X_test, y_test)))

小结：

训练集和测试集分数接近：可能是欠拟合    训练集和测试集分数差异：可能是过拟合

2.岭回归(可以控制模型复杂度)(L2正则化 使系数趋于0)

它预测公式和最小二乘法相同，但对 w 的选择不仅要在训练数据上得到好的结果还要拟合附加约束，同时希望系数尽可能小，即 w 的所有元素接近于0。直观上看，每个特征对输出的影响尽可能小(斜率小)，同时仍给出较好的预测结果，即所谓的正则化(regularization)。正则化是指对模型做显式约定，避免过拟合，这种被称为L2正则化。L1正则化为各系数绝对值之和，L2为各系数平方和。

from sklearn.linear_model import Ridge
ridge = Ridge().fit(X_train, y_train)
print("Training set score: {}".format(ridge.score(X_train, y_train)))
print("Test set score: {}".format(ridge.score(X_test, y_test)))

此算法的泛化能力更好，而对训练集的拟合效果并不是那么理想。它通过调节参数alpha约束来平衡模型的简单性和训练集性能，我们使用的alpha=1.0的默认参数。增大alpha可能使得系数更加趋于0，可能会提高泛化能力。

from sklearn.linear_model import Ridge
ridge = Ridge(alpha=10).fit(X_train, y_train)
print("Training set score: {:.2f}".format(ridge.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge.score(X_test, y_test)))

减小alpha参数，让系数受到的限制更小，当系数几乎没有任何限制时，得到一个与LinearRegression类似的模型。

from sklearn.linear_model import Ridge
ridge = Ridge(alpha=0.1).fit(X_train, y_train)
print("Training set score: {:.2f}".format(ridge.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge.score(X_test, y_test)))

理解正则化

plt.plot(ridge.coef_, 's', label="Ridge alpha=1")
plt.plot(ridge10.coef_, '^', label="Ridge alpha=10")
plt.plot(ridge01.coef_, 'v', label="Ridge alpha=01")
plt.plot(lr.coef_, 'o', label="LinearRegression")
plt.xlabel("Coefficient index")
plt.ylabel("Coefficient magnitude")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)
plt.legend()
plt.show()

其中参数alpha数值越大，对系数的约束越大，使更多的系数趋近于0，让其泛化能力更好

以上时固定数据集改变alpha的值，接下来时固定alpha的值，改变数据集来理解正则化。

mglearn.plots.plot_ridge_n_samples()
plt.legend()
plt.show()

如果数据集足够多，则正则化变得不那么重要。同时，线性回归的训练性能在下降，数据过多，难以拟合或记住所有数据。

3.lasso(L1正则化，使系数为0)

105个特征只用4个，牛逼，欠拟合。

from sklearn.linear_model import Lasso
lasso = Lasso().fit(X_train, y_train)
print("Training set score: {:.2f}".format(lasso.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lasso.score(X_test, y_test)))
print("Number of feature used: {}".format(np.sum(lasso.coef_ != 0)))

会发现这个算法无论实在训练集还是测试集上的表现都很差。为了降低欠拟合，我们减少alpha的值，同时增大max_iter(运行的最大迭代次数)的值。

lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)
print("Training set score: {:.2f}".format(lasso001.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lasso001.score(X_test, y_test)))
print("Number of feature used: {}".format(np.sum(lasso001.coef_ != 0)))

此时用到33个特征，如果再次减低alpha的值，则会导入过拟合，得到与LinearRegression类似的值。

lasso00001 = Lasso(alpha=0.0001, max_iter=100000).fit(X_train, y_train)
print("Training set score: {:.2f}".format(lasso00001.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lasso00001.score(X_test, y_test)))
print("Number of feature used: {}".format(np.sum(lasso00001.coef_ != 0)))

用到96个特征，最后是一个不同alpha参数的总结。

lasso = Lasso().fit(X_train, y_train)
ridge = Ridge().fit(X_train, y_train)
lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)
lasso00001 = Lasso(alpha=0.0001, max_iter=100000).fit(X_train, y_train)
ridge01 = Ridge(alpha=0.1).fit(X_train, y_train)
plt.plot(lasso.coef_, 's', label="Lasso alpha=1")
plt.plot(lasso001.coef_, '^', label="Lasso alpha=0.01")
plt.plot(lasso00001.coef_, 'v', label="Lasso alpha=0.0001")
plt.plot(ridge01.coef_, 'o', label="Ridge alpha=0.01")
plt.xlabel("Coefficient index")
plt.ylabel("Coefficient magnitude")
plt.legend(ncol=2, loc=(0, 1.05))
plt.ylim(-25, 25)
plt.show()

红色和黄色拟合很相似，但是红色没有为0的系数哦。实践中，一般首先岭回归，但是如果只是想要几个特别重要的特征的话，俺还是建议您选个Lasso呢，因为它只选择一部分特征值呢。ElasticNet类结合和这两个的惩罚项，效果好，代价是调参，一个用于L1正则化，一个用于L2正则化。

4.用于分类的线性模型

回归是连续的，因此我们返回的是加权求和，而分类是离散的，因此对于而分类问题我们用0作为阈值，>0为一类<0为一类这样子。对于回归的线性模型，输出是特征的线性函数；对于分类来说，决策边界是输入的线性函数。

线性模型算法的主要区别：

    1.w和b(损失函数)，由于数学的能力有限，俺们就不考虑了。

    2.正则化---考虑这个

最常见的两种线性分类算法是：Logistic回归和线性支持向量机( 都使用L2正则化! )。喵喵喵???

from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
X, y = mglearn.datasets.make_forge()
fig, axes = plt.subplots(1, 2, figsize=(10, 3))
for model, ax in zip([LinearSVC(), LogisticRegression()], axes):
    clf = model.fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=False, eps=0.5, ax=ax, alpha=.7)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{}".format(clf.__class__.__name__))
    ax.set_xlabel("Feature 0")
    ax.set_ylabel("Feature 1")
axes[0].legend()
plt.show()

对这两个算法来说决定正则化强度的权衡参数为c，c值越大，正则化越弱，训练集拟合更好，泛化能力可能较弱。越小系数 w 越趋于0。

mglearn.plots.plot_linear_svc_regularization()

在高维空间中，用于分类的模型变得非常强大。

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, stratify=cancer.target, random_state=42)
logreg = LogisticRegression().fit(X_train, y_train)
print("Training set score: {:.2f}".format(logreg.score(X_train, y_train)))
print("Test set score: {:.2f}".format(logreg.score(X_test, y_test)))

c值较小，模型欠拟合。

logreg100 = LogisticRegression(C=100).fit(X_train, y_train)
print("Training set score: {:.2f}".format(logreg100.score(X_train, y_train)))
print("Test set score: {:.2f}".format(logreg100.score(X_test, y_test)))

c值增大，更富在的模型对应更好的性能。

logreg001 = LogisticRegression(C=0.01).fit(X_train, y_train)
print("Training set score: {:.2f}".format(logreg001.score(X_train, y_train)))
print("Test set score: {:.2f}".format(logreg001.score(X_test, y_test)))

最后对这个玩意儿来个总结

plt.plot(logreg.coef_.T, 's', label="C=1")
plt.plot(logreg100.coef_.T, '^', label="C=100")
plt.plot(logreg001.coef_.T, 'v', label="C=0.001")
plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
plt.hlines(0, 0, cancer.data.shape[1])
plt.ylim(-5, 5)
plt.xlabel("Coefficient index")
plt.ylabel("Coefficient magnitude")
plt.legend()
plt.show()

没太懂这个图= =，有两个地方，一个mean perimeter和texture error在图像上的异同，我看不懂= =，书中意思是对线性模型系数的解释持保留态度。上图是L2正则化，接下来使用L1正则化约束，选择更少的特征去模拟。

for C, marker in zip([0.001, 1, 100], ['o', '^', 'v']):
    lr_l1 = LogisticRegression(C=C, penalty="l1").fit(X_train, y_train)
    print("Training accuracy of l1 logreg with C={:.3f}: {:.2f}".format(
        C, lr_l1.score(X_train, y_train)))
    print("Test accuracy of l1 logreg with C={:.3f}: {:.2f}".format(
        C, lr_l1.score(X_test, y_test)))
    plt.plot(lr_l1.coef_.T, marker, label="C={:.3f}".format(C))
    # print("Training set score: {:.2f}".format(logreg001.score(X_train, y_train)))
    # print("Test set score: {:.2f}".format(logreg001.score(X_test, y_test)))
    plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
    plt.hlines(0, 0, cancer.data.shape[1])
    plt.ylim(-5, 5)
    plt.xlabel("Coefficient index")
    plt.ylabel("Coefficient magnitude")
    plt.legend(loc=3)
plt.show()

L1选择特征的子集，L2使用所有可用特征。

5.用于多分类的线性模型

大多数模型只适用于二分类问题(除了Logistic回归)，将二分类推广到多分类问题的一种常见方法为“一对其余”，每个类别对应一个二类分类器，每个类别对应一个w和b，有个分类置信方程..接下来是一个三分类问题，用一个二位数据集，每个类别的数据都是从一个高斯分布中采样得出。

from sklearn.datasets import make_blobs
X, y = make_blobs(random_state=42)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend(["Class 0", "Class 1", "Class 2"])
plt.show()

linear_svm = LinearSVC().fit(X, y)
print("Coefficient shape: ", linear_svm.coef_.shape)
print("Intercept shape: ",linear_svm.intercept_.shape)

系数3行2列，包换每个类别的2个特征(之前说了是个二维数据的哟)，然后截距有3个对应每个类别，接下来将其可视化。

mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
linear_svm = LinearSVC().fit(X, y)
line = np.linspace(-15, 15)
for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
    plt.plot(line, -(coef[0]*line + intercept)/coef[1], color)
    plt.ylim(-10, 15)
    plt.xlim(-10, 8)
    plt.xlabel("Feature 0")
    plt.ylabel("Feature 1")
    plt.legend(['Class 0', 'Class 1', 'Class 2', 'Line class 0', 'Line class 1', 'Line class 2'], loc="best")
plt.show()

这个线没看懂咋画的= =就像wx+b，但是为啥要加负号，还要除个数牛逼。而图中的三角区域被所有的类别都划分在了其余的类别里，那它是个啥呐？它被划分为最接近那条线的类别哟。下面的图让你更好的理解中间三角区域呢。

X, y = make_blobs(random_state=42)
linear_svm = LinearSVC().fit(X, y)
mglearn.plots.plot_2d_classification(linear_svm, X, fill=True, alpha=.7)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
line = np.linspace(-15, 15)
for coef, intercept, color in zip(linear_svm.coef_, linear_svm.intercept_, ['b', 'r', 'g']):
    plt.plot(line, -(coef[0]*line + intercept)/coef[1], color)
    plt.xlabel("Feature 0")
    plt.ylabel("Feature 1")
    plt.legend(['Class 0', 'Class 1', 'Class 2', 'Line class 0', 'Line class 1', 'Line class 2'])
plt.show()

大大总结：

通常线性模型，主要考虑正则化的参数，alpha或者分类线性模型中的C，前者越大后者越小，系数为0的更多，模型更简单，泛化能力可能更好。利用线性模型的时候，数据之间最好不要线性相关哦，否则难以理解 其 系 数 的 呢！当特征数量大于样本数量即特征张成的空间更加高维的时候，线性模型蛮不错的，不过低维空间下，其他模型的泛化能力会更好一点， 嗯(确信

方法链 (我想起了继承那个链= =)，可以在一行代码中完成模型初始化、拟合和预测

        y_pred = LogisticRegression().fit(X_train, y_train,).predict(X_test)

---

朴素贝叶斯分类器

朴素(naive在于它是假设独立)贝叶斯分类器和线性模型很相似，效率更高，代价是泛化能力比线性分类器稍差。原因在于，它通过单独查看每个特征来学习参数，并从每个特征中收集简单的类别统计数据。scikit-learn 中实现了三种朴素贝叶斯分类器：GaussianNB, BernoulliNB, MultinomiaNB ( 三个 NB 呢！)一号选手可应用于任意连续数据，二号选手假定输入数据为二分类数据，三号选手假定输入数据为计数数据(比如一个单词在句子里出现的次数)，后两者主要运用于文本数据分类！

第二个牛逼BernoulliNB 分类器计算每个特征不为0的元素个数。

X = np.array([
    [0, 1, 0, 1],
    [1, 0, 1, 1],
    [0, 0, 0, 1],
    [1, 0, 1, 0]])
y = np.array([0, 1, 0, 1])
count = {}
for label in np.unique(y):
    count[label] = X[y == label].sum(axis=0)
print("Feature counts:\n {}".format(count))

喵喵喵 这坨没懂  大大教我TAT