很过数据是没有线性关系的==》非线性 =》多项式模拟非线性曲线  

添加的特征是原来特征的线性组合==》解决非线性问题=》数据集升维      (PCA降维)  有时升维有时降维

  =》x^2  x  虽然是同一特征 但我们把它x^2当做是另一个特征








Pipeline   创建多项式回归：  通过增加特征 依然使用使用线性回归




多项式回归拟合非线性：

一个二次曲线   ==》过拟合  100次太复杂了  训练集上好  在验证集  和  测试集不好  欠拟合 1次不够

学习狗的图片：

有眼睛的是狗：只学习一部分特征 欠拟合

四爪 眼睛 ... 斑点 :所有符合的基础上又加上了 斑点   斑点只是一部分狗才有  可过拟合学出了斑点特征      太细节的特征

 





泛化能力：由此及彼能力       根据训练得到的曲线         面对新的数据的能力

最终的模型最终能力不是拟合训练集 而是更好的拟合  测试集 新数据 =》


 



 







 








train valitation test

欠拟合：训练 测试上dou不好     过拟合 ：训练上低  测试上高

为了防止   验证集中有极端数据   防止关于验证集的过拟合  ==》交叉验证

评价模型准确度更加靠谱：

==》每次都要训练k个模型  才确定一组参数  比正常多耗时K倍





M个样本分为  m分  用其中一份作为验证集 其他用于训练

高偏差：模型太偏离原问题  ==》    一些数据可能原本就不是线性的    如果非要用线性拟合的话就容易高偏差  》特征取得不好 

                我们假设数据是符合某个模型的一旦不符合极易出现高偏差  degree越小越简单 degree越大形状越奇怪引入的方差越大

 

高方差：泛化能力差    KNN 多依赖于数据==》非参数学习      k越小模型越复杂 方差可能越大



偏差 和 方差是可以避免的         不可避免的误差如 数据中有噪音

偏差：

    1.用名字预测成绩  选取特征  离目标是高度不相关的  

     2.欠拟合 

方差：过拟合  学习的过度  分的太细

          1.降低模型复杂度

            2.过拟合可能学到的太多的噪音数据

            3.增加样本量   深度学习的条件是数据规模要足够的大  不然不如简单地模型

            4.使用验证集   防止模型针对测试数据集过拟合

            


 











 

假设数据来源可靠  特征明显    ==》机器学习算法 主要考虑方差



模型正则化   ：系数越大曲线越陡峭==》让theta平方和小  theta0不在其中  theta0是截距

 

阿尔法是一个新的超参数=》决定theta平方和（尽可能小） 占整的损失函数的多少 

 

阿尔法=0相当于没有加入正则化==》阿尔法无穷大 MS额E比重就比较小 此时的优化任务变为让每一个theta变小

我们要做的是要在预测准确度和让每个theta尽量小   两件事之间做一个平衡

方法：

       岭回归

        LASSO回归

         

 





 




岭回归过分 =》阿尔法取值过大就变成  是theta平方和最小 =》小到一定程度 为零 就成为了  线性函数 甚至平行于X轴

lasso回归：选择怎么表达theta最小上不一样  有降维作用  

      因为不想像回归逐渐的走 每个theta都是有数值的

      lasso  |x|导数  = x/|x|  非0即+-1  沿着某一个方向一直走    直到一个theta为零换方向   继续直到直到最小值点   

      最后theta有可能很多维度上 达到零 （下面图有走的过程）


 


lasso回归缺点：有可能错误的将有用的特征前参数为0  使有用特征降掉    极易将某些元素化为0     一般从计算准确度上来讲还是岭回归比较好

                优点：如果特征特别大 用多项回归degree要100  特征数非常多 此时使用lasso  也是非常好的  起到降维的作用  模型特征变小     

 

选择顺序  岭回归  》 弹性网  》  lasso回归


 

 



 









 



 


无论是岭回归还是LASSO回归   两种模型正则化   都是在原始的损失函数后面添加一项     为了减小学习到的theta   使得模型的泛化能力变强    使模型系数不那么大 函数图像不那么怪   


 



 

多项式回归和拟合、正则化
1 多项式回归
1.1 介绍
1.2 回归实现
2 拟合&正则化
2.1拟合问题
2.1.1 拟合出现的类型
2.2 解决拟合出现的问题
3 正则化
3.1 介绍
3.2 分类

1 多项式回归
1.1 介绍
在线性回归中，我们介绍了的是这种模型y = kX +b来拟合图形，但是也存在一些数据分析用线性拟合效果很差，或者说不适合用线性回归来拟合，如下图


相对而言，用多项式就比较合适。多项式就是如同

y = a + bx^2  + c这种， y = a + bx^2 +cx^3 + d 等等
也就是多项式的模型一般是这样子的：


1.2 回归实现
下面以这个数据做一个示例


import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from numpy import genfromtxt

# 加载数据
data = genfromtxt("job.csv", delimiter=",")

x_data = data[1:, 1]
y_data = data[1:, 2]
plt.scatter(x_data, y_data)
plt.show()
# print(x_data, y_data)



线性回归

# 一维变二维
x_data = x_data[:, np.newaxis]
y_data = y_data[:, np.newaxis]

# 创建并拟合模型
model = LinearRegression()
model.fit(x_data, y_data)

plt.scatter(x_data, y_data)
plt.plot(x_data, model.predict(x_data), 'r')
plt.show()



多项式回归

# 定义多项式回归, degree的值可以调节多项式的特征
poly_reg = PolynomialFeatures(degree=3)
# 特征处理
x_poly = poly_reg.fit_transform(x_data)

# 定义回归模型
reg = LinearRegression()
reg.fit(x_poly, y_data)

plt.plot(x_data, y_data, 'b.')
plt.plot(x_data, reg.predict(x_poly), 'r')
plt.show()


2 拟合&正则化
之前我们在模型那一块有讲过模型拟合会出现欠拟合、过拟合，今天我们来具体讲一下吧
2.1拟合问题
2.1.1 拟合出现的类型

过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

回归中出现的拟合问题：



分类拟合中出现的问题如下：


2.2 解决拟合出现的问题
（1）欠拟合原因以及解决办法

原因：学习到数据的特征过少

解决办法：

• 1）添加其他特征项，有时候我们模型出现欠拟合的时候是因为特征项不够导致的，可以添加其他特征项来很好地解决。例如，“组合”、“泛化”、“相关性”三类特征是特征添加的重要手段，无论在什么场景，都可以照葫芦画瓢，总会得到意想不到的效果。除上面的特征之外，“上下文特征”、“平台特征”等等，都可以作为特征添加的首选项。

• 2）添加多项式特征，这个在机器学习算法里面用的很普遍，例如将线性模型通过添加二次项或者三次项使模型泛化能力更强。
（2）过拟合原因以及解决办法

原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点

解决办法：

• 1）重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致的，如果出现了过拟合就需要我们重新清洗数据。

• 2）增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小。

• 3）正则化

• 4）减少特征维度，防止维灾难
3 正则化
3.1 介绍
在学习的时候，数据提供的特征有些影响模型复杂度或者这个特征的数据点异常较多，所以算法在学习的时候尽量减少这个特征的影响（甚至删除某个特征的影响），这就是正则化。如图示例


3.2 分类


L2正则化

1）作用：可以使得其中一些W（权重）的都很小，都接近于0，削弱某个特征的影响

2）优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象

3）Ridge回归

4）代价函数




L1正则化

1）作用：可以使得其中一些W的值直接为0，删除这个特征的影响

2）LASSO回归

3）代价函数

对于一般的线性回归模型，由于该函数拟合出来的是一条直线，所以精度欠佳，我们可以考虑多项式回归来拟合更多的模型。多项式回归，原理和线性回归是一样的，无非现在是高次多项式而非一次多项式。
比如说我们想要拟合方程：
我们可以先设置参数方程：
代码实现：
导入相关包，torch用来创建模型，matplotlib用来可视化。POLY_DEGREE指多项式的最高次数。
import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
from torch import nn

POLY_DEGREE = 3
预处理数据，把数据变成矩阵形式。
用torch.cat函数来实现Tensor的拼接。
def make_features(x):
    x = x.unsqueeze(1)
    return torch.cat([x ** i for i in range(1, POLY_DEGREE+1)], 1)
定义真实函数。
W_target = torch.FloatTensor([3,6,2]).unsqueeze(1)
b_target = torch.FloatTensor([8])

def f(x):
    return x.mm(W_target) + b_target.item()
在训练的时候我们需要采样一些点，可以随机生成一批数据来得到训练集。下面的函数可以让我们每次取batch_size这么多个数据，然后将其转化为矩阵形式，再把这个值通过函数之后的结果也返回作为真实的输出值。
def get_batch(batch_size=64):
    random = torch.randn(batch_size)
    x = make_features(random)
    y = f(x)  # + torch.rand(1)
    return Variable(x), Variable(y)

# # show an example of a batch
# x_axis = torch.randn(64)
# y_axis = f(make_features(x_axis)).squeeze()
# plt.title("Original Data Example")
# plt.scatter(x_axis.data.numpy(), y_axis.data.numpy())
# plt.show()
定义多项式模型，定义损失函数和优化器。
class poly_model(nn.Module):
    def __init__(self):
        super(poly_model,self).__init__()
        self.poly = nn.Linear(3,1)

    def forward(self, x):
        out = self.poly(x)
        return out


model = poly_model()
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
定义一个打印函数，方便在训练过程中和训练后打印拟合的多项式表达式。
def poly_desc(W, b):
    result = 'y = '
    for i, w in enumerate(W):
        result += '{:+.2f} x^{} '.format(w, len(W) - i)
    result += '{:+.2f}'.format(b[0])
    return result
开始训练。
epoch = 0
while True:
    batch_x, batch_y = get_batch()
    output = model(batch_x)
    loss = criterion(output, batch_y)
    print_loss = loss.data
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    # if epoch % 50 == 0:
    #     print('Loss: {:.6f} after {} batches'.format(loss, epoch))
    #     print('==> Learned function:t' + poly_desc(model.poly.weight.view(-1), model.poly.bias))
    epoch += 1
    if print_loss < 1e-3:
        print()
        print("==========End of Training==========")
        break


print('Loss: {:.6f} after {} batches'.format(loss, epoch))
print('==> Learned function:t' + poly_desc(model.poly.weight.view(-1), model.poly.bias))
print('==> Actual function:t' + poly_desc(W_target.view(-1), b_target))
当64个数的均方误差小于1e-3，训练结束。
参考链接：
https://www.zhihu.com/pub/reader/119606991/chapter/1102563393726173184

之前我们曾经学习了简单线性回归模型的推导、sklearn实战，并尝试从零搭建了一个简单线性回归的模型工具。
但是我们遇到的数据并不总是线性的，这时如果我们还拿线性模型去拟合，我们模型的效果就会大打折扣。不过不用担心，我们仍然可以使用线性回归的方法来拟合非线性的数据，只不过我们要先对输入数据做一些处理。
一、快速理解多项式回归原理
我们先来回顾一下简单线性回归的假设：
$\hat{y}=\alpha + \beta x$
假如我们通过散点图发现变量y与x之间的关系大致符合二次分布，那么上述的假设就不太合适了，我们可以假设：
$\hat{y}=\alpha + \beta_1 x + \beta_2 x^2$
我们的残差依然是:
$error = y - \hat{y}$
与简单线性回归相同，我们的目标是最小化残差平方和：
$RSS(SSE) = \sum_{i=1}^{n}{(y_i-\hat{y_i})^2} = \sum_{i=1}^{n}{[y_i-(\alpha + \beta_1 x_i + \beta_2 x_i^2)]^2}$
然后我们分别对α、β1和β2求偏导，使其为0，我们可以得到三个等式，求解即可。
这部分推理与简单线性回归的推理部分极为相似，感兴趣的可以直接阅读我的《三步教你从零掌握简单线性回归》一文。
二、scikit-learn实战
那么接下来，我们就直接来看scikit-learn实战部分了。先放代码和输出，然后我们再详解一下：
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()

X_train = [[6], [8], [10], [14], [18]]
y_train = [[7], [9], [13], [17.5], [18]]
X_test = [[6], [8], [11], [16]]
y_test = [[8], [12], [15], [18]]

# 简单线性回归
model = LinearRegression()
model.fit(X_train, y_train)
xx = np.linspace(0, 26, 100)
yy = model.predict(xx.reshape(xx.shape[0], 1))
plt.scatter(x=X_train, y=y_train, color='k')
plt.plot(xx, yy, '-g')

# 多项式回归
quadratic_featurizer = PolynomialFeatures(degree=2)
X_train_quadratic = quadratic_featurizer.fit_transform(X_train)
X_test_quadratic = quadratic_featurizer.fit_transform(X_test)
model2 = LinearRegression()
model2.fit(X_train_quadratic, y_train)
xx2 = quadratic_featurizer.transform(xx[:, np.newaxis])
yy2 = model2.predict(xx2)
plt.plot(xx, yy2, '-r')

print('X_train:\n', X_train)
print('X_train_quadratic:\n', X_train_quadratic)
print('X_test:\n', X_test)
print('X_test_quadratic:\n', X_test_quadratic)
print('简单线性回归R2：', model.score(X_test, y_test))
print('二次回归R2：', model2.score(X_test_quadratic, y_test));

输出为：
X_train:
 [[6], [8], [10], [14], [18]]
X_train_quadratic:
 [[  1.   6.  36.]
 [  1.   8.  64.]
 [  1.  10. 100.]
 [  1.  14. 196.]
 [  1.  18. 324.]]
X_test:
 [[6], [8], [11], [16]]
X_test_quadratic:
 [[  1.   6.  36.]
 [  1.   8.  64.]
 [  1.  11. 121.]
 [  1.  16. 256.]]
简单线性回归R2： 0.809726797707665
二次回归R2： 0.8675443656345073


三、步骤详解
我们来看看在每一步我们都做了什么。
第一步，我们导入了必要的库。
第二步，我们创建了训练集和测试集。
第三步，我们拟合了简单线性回归，并且绘制了预测的直线。
第四步，我们使用sklearn.preprocessing.PolynomialFeatures方法，将我们的原始特征集生成了n*3的数据集，其中第一列对应常数项α，相当于x的零次方，因此这一列都是1；第二列对应一次项，因此这一列与我们的原始数据是一致的；第三列对应二次项，因此这一列是我们原始数据的平方。
第四步，我们拿前边用PolynomialFeatures处理的数据集做一个多元线性回归，然后用训练好的模型预测一条曲线，并将其绘制出来。
第五步，输出数据方便理解；输出模型分数用于对比效果。
看到这里你可能已经明白了，多项式回归虽然拟合了多项式曲线，但其本质仍然是线性回归，只不过我们将输入的特征做了些调整，增加了它们的多次项数据作为新特征。其实除了多项式回归，我们还可以使用这种方法拟合更多的曲线，我们只需要对原始特征作出不同的处理即可。
你学会了吗？