学习目标：
◇ 监督学习的概念
◇ K近邻算法
◇ 朴素贝叶斯模型
◇ 决策树模型
◇ 线性模型
◇ 逻辑回归
◇ 支持向量机
◇ 集成学习方法
◇ 神经网络
◇ 分类器的不确定度
学习内容：
监督学习是利用一组带标签的数据，学习从输入到输出的映射，然后将这种映射关系应用到未知数据的一类机器学习方法。在监督学习中，每个实例都由一个输入对象和一个输出标签值(也称为监督信号)组成。监督学习算法的过程是分析训练数据，产生推断(也称为假设),将假设值与实际标签值进行比较，使得误差最小，不断迭代，最终学习到一个模型。 监督学习是最常用也是最成功的机器学习类型之一。本章将会详细介绍监督学习，分析几种常用的监督学习算法。每当想要根据给定输入预测某个结果，并且还有输入/输出对的示例时，都应该使用监督学习。这些输入/输出对构成了训练集，利用它来构建机器学习模型，其目标是对从未见过的新数据作出准确预测。
监督学习
1.监督学习工作原理
监督学习是根据已有的数据集中输入特征(Feature)和输出标签(Label)之间的关系，根据这种已知的关系，算法不停迭代(训练)得到一个最优的模型。通过训练，让算法可以自己找到特征和标签之间的联系，当有新的数据(只有特征没有标签)到来时，可以通过训练的模型判断出标签。
2. 分类与回归
- 分类是指识别出一组数据的所属类别，如识别输入图像数据是猫还是狗。分类问题的目标是预测类别标签(Class
Label),分类问题可分为二分类和多分类，在两个类别之间进行区分的情况为二分类，在两个以上的类别之间进行区分的情况为多分类。 - 回归的目标是预测一组连续值，编程术语叫作浮点数，数学术语叫作实数。分类与回归的区别是输出空间的度量不同。回归与分类的根本区别在于输出空间是否为度量空间。
- 回归与分类本质上都要建立映射关系，而两者的区别则在于：
(1)对于回归问题，其输出空间θ是一个度量空间，即“定量”。也就是说，回归问题的输出空间定义了一个度量去衡量输出值与真实值之间的“误差大小”。
(2)对于分类问题，其输出空间θ不是度量空间，即“定性”。也就是说，在分类问题中，只有分类“正确”与“错误”之分，至于错误是将Class5分到Class 6或Class 7并没有区别。
3.泛化
泛化能力(Generalization Ability)指一个机器学习算法对于没有见过的样本的识别能力，也可以形象地称为举一反三的能力，或者称为学以致用的能力。根据测试数据预测的结果对比测试数据的标签，能够检测出此模型的泛化能力。监督学习的目标是构建一个泛化精度尽可能高的模型。机器学习的目标是构建模型使其在训练集上能够准确预测，如果训练集和测试集足够相似，预计模型在测试集上也能准确预测。因为在拟合的时候使用的是训练数据，并没有牵扯到测试数据。这样用训练数据拟合模型后，在测试数据上预测，就能够看出这个模型的泛化能力。
4.欠拟合
欠拟合(Under-fitting)指模型没有能够很好地学习到训练数据中的规律，不能很好地拟合数据，表现为训练标签值和测试标签值与真实值之间存在较大的误差。
欠拟合的原因有模型的复杂度过低，数据特征过少等，导致没法很好地学习到数据集中的规律。
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# 生成特征 X，范围在 -3 到 3 之间，共 100 个样本
x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1) # 将 x 变成 100 行 1 列的矩阵
# 模拟生成标记 y 对应的二次函数关系，加上一些噪声
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, size=100)
# 使用线性回归模型拟合数据
reg = LinearRegression()
reg.fit(X, y)
# 输出模型的 R^2 分数（拟合优度）
print(reg.score(X, y))
# 预测值 y_pre，并画出预测值与真实值的对比图
y_pre = reg.predict(X)
plt.scatter(x, y)
plt.plot(np.sort(x), y_pre[np.argsort(x)], color='r')
# 计算并输出均方误差 MSE
mse = mean_squared_error(y, y_pre)
print("Mean Squared Error (MSE):", mse)
plt.show()
5.过拟合
过拟合(Over-fitting)通常可以理解为模型的复杂度要高于实际的问题，模型学习数据的能力太强，除了学习到数据整体的特性以外，还额外学习到了训练集的一些细节特 性。主要表现为能够很好地拟合训练集，但是不能很好地预测测试样本，即泛化能力 太差。
导致过拟合的原因：模型过于复杂，并且往往训练集样本过少。下面这段程序表现 出了过拟合。
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.metrics import mean_squared_error
def PolynomialRegression(degree):
return Pipeline([
("poly", PolynomialFeatures(degree=degree)),
("std_scaler", StandardScaler()),
("lin_reg", LinearRegression())
])
# 假设 X 和 y 已经定义好了
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])
y = np.array([1, 2, 3, 4])
# 设置 degree=2 进行 fit 拟合
poly2_reg = PolynomialRegression(2)
poly2_reg.fit(X, y)
# 求出均方误差 MSE
y2_pre = poly2_reg.predict(X)
mse = mean_squared_error(y2_pre, y)
print("Mean Squared Error (MSE):", mse)
2. K近邻分类
代码清单 2-3:使用K近邻算法进行分类
# 使用k近邻算法进行分类
from sklearn.datasets._samples_generator import make_blobs
#生成数据
centers=[[-2,2],[2,2],[0,4]]
X,y=make_blobs(n_samples=60,centers=centers,random_state=0,cluster_std=0.60)
#画出数据
import matplotlib.pyplot as plt
import numpy as np
plt.figure(figsize=(5,3),dpi=144)
c= np.array(centers)
#画出样本
plt.scatter(X[:,0],X[:,1],c=y,s=10,cmap= 'cool')
#画出中心点
plt.scatter(c[:,0],c[:,1],s=50,marker= '^',c= 'orange')
#plt.savefig( 'knn centers. png')
plt.savefig('knn_centers.png', format='png')
plt.show()
#使用KNeighborsClassifier对算法进行训练，选择参数k=5
from sklearn.neighbors import KNeighborsClassifier
# 模拟训练
k=5
clf=KNeighborsClassifier(n_neighbors=k)
clf.fit(X,y)
# 对一个新样本数据进行预测
X_sample=np.array([[0,2]])
y_sample=clf.predict(X_sample)
neighbors=clf.kneighbors(X_sample,return_distance=False)
#画出示意图
plt.figure(figsize=(5,3),dpi= 144)
c = np.array(centers)
plt.scatter(X[:,0],X[:,1],c=y,s=10,cmap= 'cool')
#出样本
plt.scatter(c[:,0],c[:,1],s=50,marker ='^',c='k')
#中心点
plt.scatter(X_sample[0][0],X_sample[0 ][1], marker = "x",s=100,cmap='cool')
#待预测的点
for i in neighbors[0]:
plt.plot([X[i][0],X_sample[0][0]],[X[i][1],X_sample[0][1]],'k--',linewidth=0.6)
#预测点与距离最近的5个样本的连线
plt.savefig('knn predict.png')
plt.show()
3.K近邻回归
KNN算法不仅可以用于分类，还可以用于回归。通过找出一个样本的K 个最近邻居，将这些邻居的属性的平均值赋给该样本，就可以得到该样本的值。
#生成数据集,在余弦曲线的基础上加入了噪声
import numpy as np
n_dots=40
X=5*np.random.rand(n_dots,1)
y= np.cos(X).ravel()
#添加一些噪声
y+=0.2*np.random.rand(n_dots)-0.1
#使用KNeighborsRegressor来训练模型#训练模型
from sklearn.neighbors import KNeighborsRegressor
k=5
knn= KNeighborsRegressor(k)
knn.fit(X,y)
回归拟合一个方法是，在X轴上的指定区间内生成足够多的点，针对
这些足够密集的点，使用训练出来的模型去预测，得到预测值y_pred,然后在坐标轴上把所有的预测点连接起来，这样就画出了拟合曲线。
#生成足够密集的点并进行预测
T=np.linspace(0,5,500)[:,np.newaxis]
y_pred = knn.predict(T)
print(knn.score(X,y))
#计算拟合曲线对训练样本的拟合准确性
#Out[ 12]:0.9804488058034699
#KNN回归预测的score为0.98
#把ypred中这些预测点的数据连接起来,构成拟合曲线#画出拟合曲线
import matplotlib.pyplot as plt
plt.figure(figsize=(5,3),dpi=144)
plt.scatter(X,y,c='g',label='train data',s=10)
#画出训练样本
plt.plot(T,y_pred,c='k',label='prediction',lw=1)
#画出拟合曲线
plt.axis('tight')
plt.title('KNeighborsRegressor(k=%i)'% k)
plt.legend( )
#plt.savefig('knn regressor.png')
plt.savefig('knn_regressor.png', format='png')
plt.show()
4.朴素贝叶斯
朴素贝叶斯算法是一种基于贝叶斯定理的分类算法。它假设特征之间是相互独立的，即一个特征对于其他特征的条件概率没有影响，因此称为“朴素”。
朴素贝叶斯算法的基本思想是根据已知类别的训练样本，计算出各个特征在不同类别下的条件概率，然后根据新的特征向量，通过贝叶斯定理计算出属于不同类别的概率，从而进行分类。
具体步骤如下：
- 准备训练样本：每个样本包含多个特征和对应的类别标签。
- 计算先验概率：统计每个类别在训练样本中的出现频率，计算先验概率。
- 计算条件概率：对于每个特征，统计在每个类别下的出现频率，计算条件概率。
- 根据贝叶斯定理计算后验概率：对于新的特征向量，根据先验概率和条件概率计算出属于每个类别的后验概率。
- 根据后验概率进行分类：选择后验概率最大的类别作为分类结果。
朴素贝叶斯算法的优点是简单、快速，适合处理大规模数据集。它对于部分特征缺失或者不完整的情况下仍然能够进行分类。然而，它假设特征之间是相互独立的，这在某些实际问题中可能不成立，因此分类结果可能存在一定的误差。
# 朴素贝叶斯分类
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.naive_bayes import GaussianNB
#高斯分布型
iris = load_iris()
gnb =GaussianNB()
#构造
pred= gnb.fit(iris.data,iris.target)
#拟合
y_pred= pred.predict(iris.data)
#预测
print( iris. data. shape[ 0])
print((iris.target !=y_pred).sum())
#iris.target人工标注出的分类,为真实的类别。y_pred模型预测产生的类别,比较#两个值什么不一样,即为模型的误差。然后将不同的值的个数求出来,150个结果中,有
#6个和人工标注的值不同
#采用10折交叉验证查看贝叶斯模型的性能
scores=cross_val_score(gnb,iris.data,iris.target,cv=10)
print("Accuracy:$,3f"%scores.mean( ))
5.决策树
决策树学习常见的算法包括CART(Classification And Regression Tree)、ID3、C4.5、随机森林(Random Forest)等。
# 决策树分类
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
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)
tree =DecisionTreeClassifier(random_state=0)
tree.fit(X_train,y_train)
print("Accuracy on training set: {:.3f}". format(tree.score(X_train, y_train)))
print("Accuracy on test set:{:.3f}".format(tree.score(X_test, y_test)))
print("tree_max_depth: {}". format(tree.tree_.max_depth))
# 设置max_depth=4
tree =DecisionTreeClassifier(max_depth=4,random_state=0)
tree.fit(X_train,y_train)
print("Accuracy on training set: {:.3f}". format(tree.score(X_train, y_train)))
print("Accuracy on test set:{:.3f}".format(tree.score(X_test, y_test)))
#决策树可视化
from sklearn.datasets import load_breast_cancer
from sklearn.tree import export_graphviz
from sklearn.tree import DecisionTreeClassifier
#import graphviz
# 导入数据集
cancer = load_breast_cancer()
X = cancer.data
y = cancer.target
# 使用决策树算法构建模型并拟合数据
tree = DecisionTreeClassifier()
tree.fit(X, y)
# 导出决策树的可视化表示
export_graphviz(tree, out_file="tree.dot", class_names=["malignant", "benign"], feature_names=cancer.feature_names, impurity=False, filled=True)
# 使用Graphviz模块读取文件并将其可视化
with open("tree.dot") as f:
dot_graph = f.read()
#graphviz.Source(dot_graph)
6.线性模型回归
线性回归模型是一种用来预测连续型变量的统计模型。它基于自变量和因变量之间的线性关系建立模型，并寻找最佳拟合直线来描述这种关系。线性回归模型的基本形式为：
Y = β0 + β1X1 + β2X2 + … + βnXn + ε
其中，Y是因变量，X1、X2、…、Xn是自变量，β0、β1、β2、…、βn是回归系数，ε是误差项。
线性回归模型的目标是找到最佳的回归系数，使得模型所预测的值与实际观测值之间的误差最小化。这一过程通常使用最小二乘法来求解。
线性回归模型有多种变体，包括简单线性回归（只有一个自变量）、多元线性回归（有多个自变量）、岭回归（用来解决多重共线性问题）等。线性回归模型在实践中广泛应用于经济学、社会科学、工程学等领域，可以用来解决各种问题，例如预测销售量、分析市场需求、评估投资回报等。
#线性模型回归
#用matplotlib画出图形
%matplotlib inline
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
font = FontProperties(fname = r"c:\windows\fonts\msyh.ttc",size=10)
def runplt(size= None):
plt.figure(figsize=size)
plt.title('匹萨价格与直径数据',fontproperties=font)
plt.xlabel('直径/英寸',fontproperties= font)
plt.ylabel('价格/美元',fontproperties=font)
plt.axis([0,25,0,25])
plt. grid( True)
return plt
plt=runplt()
X=[[6],[8],[10],[14],[18]]
y=[[7],[9],[13],[17.5],[18]]
plt.plot(X,y,'k')
plt.show()
import numpy as np
from sklearn import linear_model
#调用Scikit-learn中的linear model模块进行线性回归
model=linear_model.LinearRegression()
model.fit(X,y)
print(model.intercept_)
#截距
print(model.coef_)
#线性模型的系数
a = model.predict([[12]])
a[0][0]
print("预测一张12英寸匹萨的价格:{:.2f}".format(model.predict([[12]])[0][0]))
plt =runplt()
plt.plot(X,y,'k.')
X2 =[[0],[10],[14],[25]]
model =linear_model.LinearRegression()
model.fit(X,y)
y2 = model.predict(X2)
plt.plot(X2,y2,'g-')
plt.show()
7.岭回归
岭回归（Ridge Regression）是一种用于处理多重共线性问题的线性回归方法。多重共线性指的是自变量之间存在高度相关性的情况，这将导致普通最小二乘法（OLS）的估计结果不稳定，甚至无法得出合理的结果。
岭回归通过对回归系数进行惩罚，可以减小共线性引起的不确定性，提高回归模型的稳定性和预测性能。其核心思想是在最小化残差平方和的基础上，增加一个正则化项，该项由回归系数的平方和乘以一个调节参数lambda来控制。当lambda为0时，岭回归就变成了普通最小二乘法；当lambda趋向于无穷大时，回归系数将趋向于零。
岭回归的优点是可以稳定建模结果、降低过拟合风险，特别适用于样本量较小、自变量之间存在共线性的情况。然而，岭回归也有一些局限性，例如需要事先设定lambda的取值、不能自动选择变量、对异常值和离群点敏感等。
实际应用中，常通过交叉验证等方法选择合适的lambda值，以达到最佳的预测性能。岭回归在数据分析、金融领域、生物科学等多个领域都有广泛的应用。
# 岭回归模型
import numpy as np
np. random.seed( 42 )
x=np.random.uniform(-3,3,size=100)
X=x.reshape(-1,1)
y=0.5*x+3 +np.random.normal(0,1,size=100)
#该模拟数据集服从y=0.5x+3,加入了标准高斯噪声,首先不使用正则化用20次幂多项#式回归训练模型
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
def PolynomialRegression(degree):
'''传人步骤对应的类组成多项式回归函数'''
return Pipeline([(" poly",PolynomialFeatures(degree = degree)),("std_scaler",StandardScaler()),("lin_reg",lin_reg)])
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test= train_test_split(X,y,random_state=666)
from sklearn.metrics import mean_squared_error
poly20_reg=PolynomialRegression(degree=20)
poly20_reg.fit(X_train,y_train)
y20_predict=poly20_reg.predict(X_test)
print(mean_squared_error(y_test,y20_predict))
#均方差误差值为167.94，如图所示
X_plot=np.linspace(-3,3,100).reshape(100,1)
y_plot=poly20_reg.predict(X_plot)
plt.scatter(x,y)
plt.plot(X_plot,y_plot,color='r')
# 有序排序后绘制曲线
plt.axis([-3,3,-1,6])
plt.show()
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import Ridge
import numpy as np
import matplotlib.pyplot as plt
def RidgeRegression(degree, alpha):
'''传入步骤对应的类组成岭回归函数'''
return Pipeline([
("poly", PolynomialFeatures(degree=degree)),
("std_scaler", StandardScaler()),
("ridge_reg", Ridge(alpha=alpha))
])
def plot_model(model):
X_plot = np.linspace(-3, 3, 100).reshape(100, 1)
y_plot = model.predict(X_plot)
plt.scatter(x, y)
plt.plot(X_plot, y_plot, color='r')
plt.axis([-3, 3, -1, 6])
plt.show()
# 使用岭回归模型
ridge1_reg = RidgeRegression(20, 0.0001)
ridge1_reg.fit(X_train, y_train)
y1_predict = ridge1_reg.predict(X_test)
print(mean_squared_error(y_test, y1_predict))
plot_model(ridge1_reg)
8.loss回归
Loss回归是一种机器学习算法，用于预测连续型变量的值。它可以用于回归问题，其中目标是根据输入变量的值预测出一个连续型的输出变量。在Loss回归中，我们通过最小化预测值与实际值之间的差异来训练模型。
常见的Loss函数包括均方误差（MSE）、平均绝对误差（MAE）和Huber损失函数等。这些Loss函数的特点是在计算预测值与实际值之间的差异时，会考虑差异的绝对值或平方等因素。通过选择合适的Loss函数，可以使得模型在拟合数据时更加准确。
Loss回归的训练过程通常使用梯度下降法来最小化Loss函数。梯度下降法是一种迭代的优化算法，通过反复调整模型的参数来逐步减小Loss函数的值。在每次迭代中，梯度下降法会计算Loss函数关于参数的梯度，并将参数沿着梯度的负方向进行更新。
在训练过程中，可以使用一些技巧来提高Loss回归模型的性能。例如，可以使用正则化技术来避免过拟合问题，或者使用交叉验证来选择合适的模型参数。此外，还可以使用特征选择和特征工程等方法来提取有用的特征，以提高模型的预测能力。
from sklearn.linear_model import Lasso
def LassoRegression(degree,alpha):
'''传人步骤对应的类组成Lasso回归'''
return Pipeline([("poly",PolynomialFeatures(degree = degree)),
("std scaler",StandardScaler()),
("ridge reg",Lasso(alpha= alpha))])
#使用a=0.01的Lasso回归
lasso1_reg =LassoRegression(20,0.01)
lasso1_reg.fit(X_train,y_train)
yl_predict =lasso1_reg.predict(X_test)
print(mean_squared_error(y_test,yl_predict))
plot_model(lasso1_reg)
9.多项式回归
多项式回归是一种将自变量的多项式函数拟合到因变量的回归方法。在简单线性回归中，我们将自变量和因变量之间的关系拟合为一个直线方程。而在多项式回归中，我们将自变量和因变量之间的关系拟合为一个多项式函数。
多项式回归的一般形式为：y = β0 + β1x + β2x^2 + … + βnx^n
其中，y为因变量，x为自变量，n为多项式的次数，β0, β1, β2, …, βn为回归系数。
多项式回归可以通过最小二乘法来确定回归系数，使得拟合的多项式函数与样本数据的残差平方和最小。通过拟合多项式函数，我们可以更准确地描述自变量和因变量之间的关系。
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# 使用的数据是函数y=x^2+2加入随机误差生成的，取100个数据点
data=np.array([[-2.95507616,10.94533252],
[-0.44226119,2.96705822],
[-2.13294087,6.57336839],
[ 1.84990823,5.44244467],
[ 0.35139795, 2.83533936],
[-1.77443098,5.6800407 ],
[-1.8657203,6.34470814],
[ 1.61526823, 4.77833358],
[-2.38043687,8.51887713],
[-1.40513866,4.18262786]])
m = data.shape[0] #样本大小
X= data[:,0].reshape(-1,1) #将array转换成矩阵
y = data[:,1].reshape(-1,1)
plt.plot(X,y,"b.")
plt.xlabel('X')
plt.ylabel('y')
plt.show()
# 直线方程拟合上面的数据点
lin_reg = LinearRegression()
lin_reg.fit(X,y)
print(lin_reg.intercept_,lin_reg.coef_)
X_plot = np.linspace(-3,3,1000).reshape(-1,1)
y_plot = np.dot(X_plot,lin_reg.coef_.T)+lin_reg.intercept_
plt.plot(X_plot,y_plot,'r-')
plt.plot(X,y,'b.')
plt.xlabel('X')
plt.ylabel('y')
#使用mean_squared_error函数来计算误差
h = np.dot(X.reshape(-1,1),lin_reg.coef_.T)+lin_reg.intercept_
print(mean_squared_error(h,y))
# 使用多项式方程
#拟合二次方程，这里使用PolynomialFeatures函数
poly_features = PolynomialFeatures(degree=2,include_bias=False)
X_poly = poly_features.fit_transform(X)
print(X_poly)
#利用X_poly的数据作线性回归分析
lin_reg = LinearRegression()
lin_reg.fit(X_poly,y)
print(lin_reg.intercept_,lin_reg.coef_)
X_plot = np.linspace(-3,3,1000).reshape(-1,1)
X_plot_poly = poly_features.fit_transform(X_plot)
y_plot = np.dot(X_plot_poly,lin_reg.coef_.T)+lin_reg.intercept_
plt.plot(X_plot,y_plot,'r-')
plt.plot(X,y,'b.')
plt.show()
#均方误差MSE
h = np.dot(X_poly,lin_reg.coef_.T)+ lin_reg.intercept_
print(mean_squared_error(h,y))
[[-2.95507616 8.73247511]
[-0.44226119 0.19559496]
[-2.13294087 4.54943675]
[ 1.84990823 3.42216046]
[ 0.35139795 0.12348052]
[-1.77443098 3.1486053 ]
[-1.8657203 3.48091224]
[ 1.61526823 2.60909145]
[-2.38043687 5.66647969]
[-1.40513866 1.97441465]]
[2.60996757] [[-0.12759678 0.9144504 ]]
# 持续降低训练误差与过拟合
#test different degree and return loss
def try_degree(degree,X,y):
poly_features_d=PolynomialFeatures(degree= degree,include_bias=False)
X_poly_d = poly_features_d.fit_transform(X)
lin_reg_d = LinearRegression()
lin_reg_d.fit(X_poly_d,y)
return{'X_poly':X_poly_d,'intercept':lin_reg_d.intercept_,'coef':lin_reg_d.coef_}
degree2loss_paras =[]
for i in range(2,20):
paras = try_degree(i,X,y)
h=np.dot(paras['X_poly'],paras['coef'].T)+paras['intercept']
_loss = mean_squared_error(h,y)
degree2loss_paras.append({'d':i,'loss':_loss,'coef':
paras['coef'],'intercept':
paras['intercept']})
min_index = np.argmin(np.array([i['loss'] for i in degree2loss_paras]))
min_loss_para = degree2loss_paras[min_index]
print(min_loss_para)
X_plot = np.linspace(-3,1.9,1000).reshape(-1,1)
poly_features_d = PolynomialFeatures(degree=min_loss_para['d'],include_bias=False)
X_plot_poly = poly_features_d.fit_transform(X_plot)
y_plot = np.dot(X_plot_poly,min_loss_para['coef'].T)+min_loss_para['intercept']
fig, ax = plt.subplots(1,1)
ax.plot(X_plot,y_plot,'r-',label='degree=11')
ax.plot(X,y,'b.',label='X')
plt.xlabel('X')
plt.ylabel('y')
ax.legend(loc='best',frameon=False)
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
