线性回归
模型：
ps:x是实例的特征向量，包含从x0到xn，x0始终等于1
性能指标：均方误差MSE。
1. 为了获得使成本函数MSE最小值时的 值，可以直接用标准方程解。
import numpy as np
X = 2 * np.random.rand(100,1)
y = 4 + 3 * X + np.random.randn(100,1)
X_b = np.c_[np.ones((100,1)),X]
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y) # 用标准方程解theta值
print(theta_best) # [[4.187806 ][2.88698048]]
import matplotlib.pyplot as plt
y_predict = X_b.dot(theta_best) # 用计算出的theta值做预测
plt.plot(X,y_predict,'r--')
plt.plot(X,y,'b.')
plt.axis([0,2,0,15])
plt.show()
2. 使用Scikit-Learn执行线性回归
该函数使用被称为奇异值分解（Singular Value Decomposition，SVD）的标准矩阵分解技术来计算theta值
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X,y)
print(lin_reg.intercept_,lin_reg.coef_) # [4.187806] [[2.88698048]]
梯度下降
梯度下降是一种优化算法，能够为大范围的问题找到最优解。其中心思想就是迭代地调整参数从而使成本函数最小化。
书本一个很好的解释是：假设你迷失在山上的浓雾之中，你能感觉到的只有你脚下路面的坡度。快速到达山脚的一个策略就是沿着最陡的方向下坡。
梯度下降就是通过测量参数向量θ相关的误差函数的局部梯度，并不断沿着降低梯度的方向调整，直到梯度降为0，到达最小值。
具体来说，首先使用一个随机的θ值，然后逐步改进，每踏出一步都尝试降低一点成本函数（如MSE），直到算法收敛出一个最小值（参见下图，图片来自书本）。
在梯度下降的描述中，模型参数被随机初始化并反复调整使成本函数最小化。学习步长与成本函数的斜率成正比，因此，当参数接近最小值时，步长逐渐变小
梯度下降一个最重要的参数就是每一步的步长，这取决于超参数学习率（其实就是每一点的斜率） 。学习率过高过低都不好，下面是学习率过高过低的现象（对于第三种情况，由于线性回归模型的MSE成本函数是个凸函数，连接曲线上任意两点的线段永远不会跟曲线相交。也就是说，不存在局部最小值，只有一个全局最小值。在应用梯度下降对线性回归的
求解时，要对数据进行标准化处理，否则时间可能会很长）
批量梯度下降
批量梯度下降计算梯度下降的每一步时，都是基于完整的训练集的。耗时长，但梯度下降算法随特征数量扩展的表现比较好，优于标准方程和SVD。要实现梯度下降，需要计算每个模型关于参数
的成本函数的梯度。换言之，需要计算的是如果改变，成本函数会改变多少，也就是计算成本函数相对于所有偏导数。公式如下：
一旦有了梯度向量，哪个点向上，就朝反方向下坡（想象在四面环山的地方下坡就行了）。也就是从θ中减去▽θMSE（θ）。这时学习率η就发挥作用，用梯度向量乘以η确定下坡步长的大小，公式如下：
eta = 0.1 # 学习率，要找到合适的学习率可以使用网格搜索，迭代次数要设置合理
n_iterations = 1000
m = 100
theta = np.random.randn(2,1) # 初始化theta值
for iteration in range(n_iterations):
gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)
theta = theta - eta * gradients
print(theta) # [[4.187806 ][2.88698048]]，跟之前的结果相似
随机梯度下降
随机梯度下降（SGD）计算梯度时，每一步都是在训练集中随机选择一个实例，然后基于该单个实例来计算梯度。这让算法变得快多了，因为每次迭代都只需要操作少量的数据。它也可以被用来训练海量的数据集，因为每次迭代只需要在内存中运行一个实例即可。
另一方面，由于算法的随机性质，它比批量梯度下降要不规则得多。成本函数将不再是缓缓降低直到抵达最小值，而是不断上上下下，但是从整体来看，还是在慢慢下降。随着时间的推移，最终会非常接近最小值，但是即使它到达了最小值，依旧还会持续反弹，永远不会停止（如下图）。所以算法停下来的参数值肯定是足够好的，但不是最优的。
另外，当成本函数不规则时，随机梯度下降其实可以帮助算法跳出局部最小值，所以相比批量梯度下降，它对找到全局最小值更有优势。
随机梯度的缺点是永远定位不出最小值，可以通过逐步降低学习率解决这个问题。开始步长很大（这有助于快速进展和逃离局部最小值），然后越来越小，让算法尽量靠近全局最小值，这个过程叫模拟退火。确定每个迭代学习率的函数叫作学习率调度。下面代码使用了一个简单的学习率调度实现随机梯度下降：
使用随机梯度下降时，训练实例必须独立且均匀分布（IID），以确保平均而言将参数拉向全局最优值。确保这一点的一种简单方法是在训练过程中对实例进行随机混洗，np.random.shuffle(data)
#简单学习率调度实现随机梯度下降
n_epochs = 50
m = 100
t0,t1 = 5,50 # learning schedule hyperparameters
def learning_schedule(t):
# 学习率越来越低
return t0/(t+t1)
theta = np.random.randn(2,1) # 随机初始化
for epochs in range(n_epochs): # 迭代了50次
for i in range(m):
# 随机获取一个实例
random_index = np.random.randint(m)
xi = X_b[random_index:random_index+1]
yi = y[random_index:random_index+1]
gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
eta = learning_schedule(epoch * m + i)
theta = theta - eta * gradients
print(theta) # array([[4.14923999],[2.94687738]])
使用带有Scikit-Learn的随机梯度下降执行线性回归
SGDRegressor类默认优化平方误差成本函数
from sklearn.linear_model import SGDRegressor
停止条件：迭代次数到达1000次或者一个轮次期间损失下降小于0.001
学习率：0.1
正则化：无
sgd_reg = SGDRegressor(max_iter=1000,tol=1e-3,penalty=None,eta0=0.1)
sgd_reg.fit(X,y.ravel())
print(sgd_reg.intercept_,sgd_reg.coef_) # [4.17734271] [2.91498169]
小批量梯度下降
小批量梯度下降在每一步中，不是根据完整的训练集（如批量梯度下降）或仅基于一个实例（如随机梯度下降）来计算梯度，小批量梯度下降在称为小型批量的随机实例集上计算梯度。
小批量梯度下降优于随机梯度下降的主要优点是，可以通过矩阵操作的硬件优化来提高性能，特别是在使用GPU时。
与随机梯度下降相比，该算法在参数空间上的进展更稳定，尤其是在相当大的小批次中。结果，小批量梯度下降最终将比随机梯度下降走得更接近最小值，但它可能很难摆脱局部最小值（在受局部最小值影响的情况下，不像线性回归）。如果使用良好的学习率调度，随机梯度下降和小批量梯度下降也会达到最小值。
线性回归算法比较
m是训练实例的数量，n是特征的数量
多项式回归
将LineraRegression扩展到多项式回归中
创建数据
m = 100
X = 6 * np.random.rand(m,1) - 3
y = 0.5 * X**2 + X + 2 + np.random.randn(m,1)
生成多项式和交互特征
from sklearn.preprocessing import PolynomialFeatures
poly_features = PolynomialFeatures(degree=2,interaction_only = False,include_bias=False)
X_poly = poly_features.fit_transform(X)
print(X[0],X_poly[0]) # [-2.63450728] [-2.63450728 6.9406286 ] X_poly现在包含X的原始特征以及该特征的平方
将LinearRegression扩展到多项式回归
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
lin_reg = LinearRegression()
lin_reg.fit(X_poly,y)
print(lin_reg.intercept_,lin_reg.coef_) # [2.06178331] [[1.05219127 0.48230376]]
y_predict = X_poly.dot(lin_reg.coef_.T) + lin_reg.intercept_
plt.plot(X,y_predict,'r.')
plt.plot(X,y,'b.')
plt.show()
ps：PolynomialFeatures（degree=d）可以将一个包含n个特征的数组转换为包含
个特征的数组，其中n!是n的阶乘，等于1×2×3×…×n。
例如：如果有两个特征a和b，则degree=3的PolynomialFeatures会添加特征
学习曲线
判断模型是过拟合数据还是欠拟合数据可以通过交叉验证来估计模型的泛化性能。如果模型在训练数据上表现良好，但根据交叉验证的指标泛化较差，则你的模型过拟合。如果两者的表现均不理想，则说明欠拟合。这是一种区别模型是否过于简单或过于复杂的方法。还有一种方法是观察学习曲线：这个曲线绘制的是模型在训练集和验证集上关于训练集大小（或训练迭代）的性能函数。要生成这个曲线，只需要在不同大小的训练子集上多次训练模型即可。
下面这段代码在给定训练集下定义了一个函数，绘制模型的学习曲线：
m = 100
X = 6 * np.random.rand(m,1) - 3
y = 0.5 * X**2 + X + 2 + np.random.randn(m,1)
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
def plot_learning_curves(model,X,y):
X_train, X_val, y_train, y_val = train_test_split(X,y,test_size=0.2) # 划分测试集和训练集
train_errors, val_errors = [],[]
for m in range(1,len(X_train)):
model.fit(X_train[:m], y_train[:m]) # 训练模型
y_train_predict = model.predict(X_train[:m]) # 训练集的预测结果
y_val_predict = model.predict(X_val) # 测试集的预测结果
train_errors.append(mean_squared_error(y_train[:m],y_train_predict)) # 训练集的均方误差
val_errors.append(mean_squared_error(y_val,y_val_predict)) # 测试集的均方误差
plt.plot(np.sqrt(train_errors),'r-+',linewidth=2,label='train') # 绘制训练集的均方根误差
plt.plot(np.sqrt(val_errors),'b-',linewidth=3,label='val')
plt.grid()
plt.legend()
plt.show()
t调用函数plot_learning_curves(model,X,y)，看普通线性回归模型的学习曲线
lin_reg = LinearRegression()
plot_learning_curves(lin_reg,X,y)
这种欠拟合的模型值得解释一下。首先，让我们看一下在训练数据上的性能：当训练集中只有一个或两个实例时，模型可以很好地拟合它们，这就是曲线从零开始的原因。但是，随着将新实例添加到训练集中，模型就不可能完美地拟合训练数据，这既因为数据有噪声，又因为它根本不是线性的。因此，训练数据上的误差会一直上升，直到达到平稳状态，此时在训练集中添加新实例并不会使平均误差变好或变差。现在让我们看一下模型在验证数据上的性能。当在很少的训练实例上训练模型时，它无法正确泛化，这就是验证误差最初很大的原因。然后，随着模型经历更多的训练示例，它开始学习，因此验证错误逐渐降低。但是，直线不能很好地对数据进行建模，因此误差最终达到一个平稳的状态，非常接近另外一条曲线。这些学习曲线是典型的欠拟合模型。两条曲线都达到了平稳状态。它们很接近而且很高。
现在看一下在相同数据上的3阶多项式模型的学习曲线
from sklearn.pipeline import Pipeline
polynomial_regression = Pipeline([
("poly_features",PolynomialFeatures(degree=3,include_bias=False)),
("lin_reg",LinearRegression()),
])
plot_learning_curves(polynomial_regression,X,y)
从图可以看出，与线性回归模型相比，训练数据上的误差要低得多。
ps:偏差/方差权衡
统计学和机器学习的重要理论成果是以下事实：
模型的泛化误差可以表示为三个非常不同的误差之和：
偏差这部分泛化误差的原因在于错误的假设，比如假设数据是线性的，而实际上是二次的。高偏差模型最有可能欠拟合训练数据。
方差这部分是由于模型对训练数据的细微变化过于敏感。具有许多自由度的模型（例如高阶多项式模型）可能具有较高的方差，因此可能过拟合训练数据。
不可避免的误差这部分误差是因为数据本身的噪声所致。减少这部分误差的唯一方法就是清理数据（例如修复数据源（如损坏的传感器），或者检测并移除异常值）。
增加模型的复杂度通常会显著提升模型的方差并减少偏差。反过来，降低模型的复杂度则会提升模型的偏差并降低方差。这就是为什么称其为权衡。
正则化线性模型
减少过拟合的一个好方法是对模型进行正则化（即约束模型）：它拥有的自由度越少，则过拟合数据的难度就越大。正则化多项式模型的一种简单方法是减少多项式的次数。对于线性模型，正则化通常是通过约束模型的权重来实现的。有岭回归、Lasso回归和弹性网络，三种限制权重的方法
岭回归
岭回归之前文章提过，不重复说明，注意以下几点：
- 仅在训练期间将正则化项添加到成本函数中。训练完模型后，要使用非正则化的性能度量来评估模型的性能
- 执行岭回归需要缩放数据（例如使用StandardScaler），因为它对输入特征的缩放敏感。大多数正则化模型都需要如此
Lasso回归
注意点：Lasso回归的一个重要特点是它倾向于完全消除掉最不重要特征的权重
弹性网络
弹性网络是介于岭回归和Lasso回归之间的中间地带。正则项是岭和Lasso正则项的简单混合，你可以控制混合比r。当r=0时，弹性网络等效于岭回归，而当r=1时，弹性网络等效于Lasso回归
那么什么时候应该使用普通的线性回归（即不进行任何正则化）、岭、Lasso或弹性网络呢？通常来说，有正则化——哪怕很小，总比没有更可取一些。所以大多数情况下，你应该避免使用纯线性回归。岭回归是个不错的默认选择，但是如果你觉得实际用到的特征只有少数几个，那就应该更倾向于Lasso回归或是弹性网络，因为它们会将无用特征的权重降为零。一般而言，弹性网络优于Lasso回归，因为当特征数量超过训练实例数量，又或者是几个特征强相关时，Lasso回归的表现可能非常不稳定。
下面是一个使用Scikit-Learn的ElasticNet的小示例（l1_ratio对应于混合比r）：
from sklearn.linear_model import ElasticNet
elastic_net = ElasticNet(alpha=0.1,l1_ration=0.5)
elastic_net.fit(X,y)
elastic_net.predict([[1.5]])
逻辑回归
参数求解
逻辑回归（Logistic回归）被广泛用于估算一个实例属于某个特定类别的概率
上面式子中的g(z)则为Logistic回归模型，是一个sigmoid函数（S型函数）,它是将线性回归模型的预测值经过非线性的Logit函数转换为[0,1]之间的概率值
如果预估概率超过0.5，则模型预测该实例属于该类别（称为正类，标记y为”1″），反之，则预测不是（称为负类，标记y为”0″）
这个函数没有已知的闭式方程（即不存在一个标准方程的等价方程）来计算出最小化成本函数的
值。但这是个凸函数，所以可以通过梯度下降（或是其他任意优化算法）保证能够找出全局最小值（只要学习率不是太高且能长时间等待）
案例
1.1 鸢尾花数据集，仅基于花瓣宽度这一个特征，创建一个分类器来检测维吉尼亚鸢尾花
下载数据
from sklearn import datasets
iris = datasets.load_iris()
print(list(iris.keys())) # ['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename']
X取花瓣宽度这一特征，并给y打上标签
X = iris["data"][:,3:]
y = (iris['target']==2).astype(np.int) # 1 if target = 2 else 0
训练模型
from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X,y)
做出预测,估算概率
X_new = np.linspace(0,3,1000).reshape(-1,1)
y_proba = log_reg.predict_proba(X_new) # predict_proba()-->估算概率，predict()-->预测类别
plt.plot(X_new,y_proba[:,1],'g-',label = 'Iris virginica(target=2)') # 绘制是维吉尼亚鸢尾花(target=2)的概率
plt.plot(X_new,y_proba[:,0],'b--',label = 'Not Iris virginica(target!=2)') # 绘制不是维吉尼亚鸢尾花(target=2)的概率
plt.legend()
plt.show()
1.2 鸢尾花数据集，基于花瓣宽度和长度，创建一个分类器来检测维吉尼亚鸢尾花，并绘制决策边界
X取花瓣宽度和花瓣宽度这两特征，并给y打上标签
X = iris["data"][:,2:]
y = (iris['target']==2).astype(np.int) # 1 if target = 2 else 0
训练模型
from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X,y)
做出预测,估算概率
X_new = np.c_[np.linspace(0,3,1000).reshape(-1,1),np.linspace(1,7,1000).reshape(-1,1)]
y_predict = log_reg.predict(X_new)
生成网格矩阵
x_min, x_max = X[:,0].min() - 0.5, X[:,0].max() + 0.5
y_min, y_max = X[:,1].min() - 0.5, X[:,1].max() + 0.5
h = 0.02
xx, yy = np.meshgrid(np.arange(x_min,x_max,h),np.arange(y_min,y_max,h))
用生成的网格矩阵的点作为测试集预测
z_predict = log_reg.predict(np.c_[xx.ravel(),yy.ravel()])
plt.figure(1,figsize = (6,4))
plt.pcolormesh(xx,yy,z_predict.reshape(xx.shape),cmap = 'Greys',alpha = 0.4)
plt.scatter(X[:,0],X[:,1],c=iris['target'],edgecolors='r')
plt.plot(X)
plt.xlabel('petal length (cm)')
plt.ylabel('petal width (cm)')
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.show()
2. 运动员数据集，基于多个特征，创建一个分类器来分类
读取数据，数据字段如下：
代码如下（训练+评估）：
导入第三方模块
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn import model_selection
sports = pd.read_csv(r'C:\Users\zxzy\Downloads\query\第13章 Logistic回归模型\Run or Walk.csv')
准备训练集和测试集
X = sports.iloc[:,4:]
y = sports.activity
X_train,X_test,y_train,y_test = model_selection.train_test_split(X,y,test_size=0.25,random_state=42)
训练模型
log_reg = LogisticRegression()
log_reg.fit(X_train,y_train)
print(log_reg.intercept_,log_reg.coef_) #[4.35938182] [[ 0.48182456 6.84861303 -2.4342337 -0.01525809 -0.15973756 0.13667148]]
模型预测
y_predict = log_reg.predict(X_test)
pd.Series(y_predict).value_counts() # 0:12086,1:10061
模型评估
## 1.混淆矩阵评估
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test,y_predict,labels=[0,1]) # 混淆矩阵
print(cm) [[10026 1136][ 2060 8925]]
from sklearn.metrics import precision_score,recall_score,accuracy_score
accuracy = accuracy_score(y_test,y_predict) # (10026+8925)/(10026+8925+1136+2060)，准确度
precision = precision_score(y_test,y_predict) # 8925/(8925+1136)，精确度
recall = recall_score(y_test,y_predict) # 8925/(8925+2060),tpr，灵敏度
fpr = 1 - recall_score(y_test,y_predict,pos_label=0) # 1-10026/(10026+1136),fpr
print("精确度：%.2f%%"%(precision*100))
print("灵敏度：%.2f%%"%(recall*100))
print("准确度：%.2f%%"%(accuracy*100))
print("1-特异度：%.2f%%"%(fpr*100))
'''
精确度：88.71%
灵敏度：81.25%
准确度：85.57%
1-特异度：10.18%
'''
## 2.绘制ROC曲线，计算AUC值评估
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.metrics import roc_auc_score,roc_curve
y得分为模型预测正例的概率
y_score = log_reg.predict_proba(X_test)[:,1]
计算不同阈值下，fpr和tpr的组合值，其中fpr表示1-特异度，tpr表示灵敏度
fpr,tpr,threshold = roc_curve(y_test,y_score)
计算AUC的值
roc_auc = roc_auc_score(y_test,y_score)
绘制面积图
plt.stackplot(fpr,tpr,color='steelblue',alpha=0.5,edgecolor='black')
添加ROC曲线的轮廓
plt.plot(fpr,tpr,color='black',lw=1)
添加对角线
plt.plot([0,1],[0,1],color='red',linestyle='--')
添加文本信息
plt.text(0.5,0.3,'ROC curve(area = %.2f)'%roc_auc)
plt.xlabel('1-Specificity')
plt.xlabel('1-Sensitivity')
plt.show()
## 3.计算KS值评估
'''
KS = Sensitivity-(1-Specificity) = Sensitivity + Specificity - 1
即模型对正类和负类的召回率相加减去1，对于KS值，值越大越好，至少大于0.4。
'''
ks = tpr - fpr # 计算ks
max_ks = ks.max() # 最大ks
ks_index = np.argmax(ks) # 最大ks索引
max_ks_threshold = threshold[ks_index] # 最大ks对应threshold
max_ks_fpr = fpr[ks_index] # 最大ks对应fpr
max_ks_tpr = tpr[ks_index] # 最大ks对应tpr
plt.plot(threshold,fpr,label = '1-Specificity')
plt.plot(threshold,tpr,label = 'Sensitivity')
plt.plot([max_ks_threshold,max_ks_threshold],[max_ks_tpr,max_ks_fpr],'r--',label = 'max_ks',)
plt.text(x = max_ks_threshold+0.01,y = max_ks_fpr+0.2,s='ks=%.2f'%max_ks)
plt.xlabel('threshold')
plt.xlim(0,1)
plt.legend()
plt.show()
练习题
1. 如果训练集具有数百万个特征，那么可以使用哪种线性回归训练算法？
随机梯度下降或小批量梯度下降；如果训练集适合容纳于内存，则可以使用批量梯度下降。但不能用标准方程或SVD方法，因为随着特征梳理的增加，计算复杂度会快速增长就（超过二次方）
2 .如果训练集里特征的数值大小迥异，哪种算法可能会受到影响？受影响程度如何？你应该怎么做？
梯度下降算法会受到影响，很长时间才能收敛。为了解决这个问题，在训练模型之前应先缩放数据（归一化，标准化，对数化等）。此外，如果特征未按比例缩放，则正则化模型可能会手里至次优解，因为正则化会惩罚较大的权重，与具有较大值的特征相比，具有较小值的特征往往会被忽略。另外标准方程和SVD方法不用缩放数据也可以正常工作。
3.训练逻辑回归模型时，梯度下降会卡在局部最小值中吗？
不会，因为该成本函数是凸函数
4.如果你让它们运行足够长的时间，是否所有的梯度下降算法都能得出相同的模型？
如果优化问题是凸的，并且假设学习率不是太高，那么所有梯度下降算法都将接近全局最优并产生很相似的模型。但除非逐步降低学习率，否则随机梯度下降和小批量梯度下降将永远不会真正收敛，会在全局最优值来回跳跃。这意味着即使运行足够长的时间，这些梯度下降算法得出的模型也会有差异。
5.假设你使用批量梯度下降，并在每个轮次绘制验证误差。如果你发现验证错误持续上升，可能是什么情况？你该如何解决？
可能是学习率过高并且算法在发散。如果训练数据错误也增加，则应降低学习率。但如果训练数据错误没有增加，则模型过拟合，应停止训练。
6.当验证错误上升时立即停止小批量梯度下降是个好主意吗？
由于随机性，随机梯度下降和小批量下降都不能保证在每次训练迭代中都取得进展。因此，如果在验证错误上升时立即停止训练，则可能在达到最优值之前就停止太早了。更好的选择是按照一定的间隔时间保存模型。然后当它很长时间没有改善时，可以恢复到保存的最佳模型
7.哪种梯度下降算法（在我们讨论过的算法中）将最快到达最佳解附近？哪个实际上会收敛？如何使其他的也收敛？
随机梯度下降法具有最快的训练迭代速度，因为它一次只考虑一个训练实例。批量梯度下降实际会收敛。逐步降低学习率可以使随机GD和小批量GD收敛
8.假设你正在使用多项式回归。绘制学习曲线后，你会发现训练误差和验证误差之间存在很大的差距。发生了什么？解决此问题的三种方法是什么？
可能是模型过拟合了数据集。三种方法：1.降低多项式阶数，较小自由度的模型不太可能过拟合；2.对模型进行正则化，添加L2或L1范式惩罚到成本函数；3.增加训练集的大小
9.假设你正在使用岭回归，并且你注意到训练误差和验证误差几乎相等且相当高。你是否会说模型存在高偏差或高方差？你应该增加正则化超参数α还是减小它呢？
训练误差和验证误差几乎相等且相当高，说明该模型欠拟合，是高偏差，应减小正则化超参数
10.为什么要使用：a.岭回归而不是简单的线性回归（即没有任何正则化）？b.Lasso而不是岭回归？c.弹性网络而不是Lasso？
- 具有某些正则化的模型通常比没有正则化的模型要好，因此优先选择岭回归而不是简单线性回归
- Lasso回归使用L1惩罚，这通常会将权重降低为0。这将导致稀疏矩阵，其中除了最重要的权重之外，其他权重均为0.这是一种自动进行特征选择的方法，如果实际上只有很少的特征重要，那选择Lasso，否则应选择岭回归
- Lasso确实增加了额外需要调整的超参数，但在某些情况（当几个特征强相关或当特征比训练实例更多时）可能产生异常，如果希望Lasso没有不稳定的行为，则可以仅使用L1_ratio接近1的弹性网络
11.假设你要将图片分类为室外/室内和白天/夜间。你应该实现两个逻辑回归分类器还是一个Softmax回归分类器？
两个逻辑回归分类器。（室内也有可能是白天）
https://www.cnblogs.com/zlslch/p/7481578.html
Original: https://blog.csdn.net/qq_42052864/article/details/116401448
Author: qq_42052864
Title: 机器学习—回归
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/635250/
转载文章受原作者版权保护。转载请注明原作者出处！