【放假第2天】人工智能-梯度下降法-代码

几种回归的方法 和区别 基础知识可参考
https://www.jianshu.com/p/aadad14db00e
https://blog.csdn.net/mr_hhh/article/details/79567687

Lasso回归：压缩变量，起降维作用；模处理

Lasso回归等于线性回归 + L1范数（L1是拉普拉斯分布）

岭回归：消除共线性；模的平方处理

岭回归等于线性回归 + L2范数 （L2是高斯分布。）

弹性网络在很多特征互相联系的情况下是非常有用的。Lasso 很可能只随机考虑这些特征中的一个，而弹性网络更倾向于选择两个。

线性回归算法一般选择顺序：Ridge Regression(L2正则化)、ElasticNet(即包含L1又包含L2)、Lasso Regression(L1正则化)

超参数alpha在Rideg类中是L2正则的权重、在Lasso类中是L1正则的权重、在ElasticNet和SGDRegressor里面是损失函数里面的alpha

超参数l1_ration在ElasticNet和SGDRegressor中是损失函数的p

多项式回归：PolynomialFeatures（多项式特征）不是做拟合的算法是做预处理的方法，转换数据继续升维（维度的次幂，通过degree超参数在原有的维度基础上增加高阶次幂维度），是为了让线性模型去拟合非线性的数据，就是你是非线性数据，想用线性模型怎么办，把数据处理一下 所以他叫features
原来是 y^=x1 x2
变成
y^=x1 x2 x1 ^2 x2 ^2 x1*x2 升维

升维是增加多个影响Y结果的因素，这样考虑的更全面，最终目的是要增加准确率

如果数据是非线性的变化可以使用非线性的算法生成的模型进行拟合，也可以使用PolynomialFeatures将非线性的数据进行变化，变成类似线性的变化，然后使用线性的模型进行拟合

#线性回归简单代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名: linear_regression_1.py

import numpy as np
from sklearn.linear_model import LinearRegression

__author__ = 'yasaka'

X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

lin_reg = LinearRegression()
lin_reg.fit(X, y)
print(lin_reg.intercept_, lin_reg.coef_)

X_new = np.array([[0], [2]])
print(lin_reg.predict(X_new))

#linear_regression2

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名: linear_regression_0.py

import numpy as np
import matplotlib.pyplot as plt

__author__ = 'yasaka'

# 这里相当于是随机X维度X1，rand是随机均匀分布
X = 2 * np.random.rand(100, 1)
# 人为的设置真实的Y一列，np.random.randn(100, 1)是设置error，randn是标准正太分布
y = 4 + 3 * X + np.random.randn(100, 1)
# 整合X0和X1
X_b = np.c_[np.ones((100, 1)), X]
print(X_b)

# 常规等式求解theta
#只会抄代码。。。公式啊！https://blog.csdn.net/kaku812814843/article/details/89787638
#numpy.linalg.inv()矩阵的逆
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
print(theta_best)

# 创建测试集里面的X1
X_new = np.array([[0], [2]]) 
X_new_b = np.c_[(np.ones((2, 1))), X_new]
print(X_new_b)
y_predict = X_new_b.dot(theta_best)
print(y_predict)

plt.plot(X_new, y_predict, 'r-')
plt.plot(X, y, 'b.')
plt.axis([0, 2, 0, 15])
plt.show()

#弹性回归

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名: elastic_net.py

import numpy as np
from sklearn.linear_model import ElasticNet
from sklearn.linear_model import SGDRegressor

X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

elastic_net = ElasticNet(alpha=0.0001, l1_ratio=0.15)
elastic_net.fit(X, y)
print(elastic_net.predict(1.5))

sgd_reg = SGDRegressor(penalty='elasticnet', max_iter=1000)
sgd_reg.fit(X, y.ravel())
#https://blog.csdn.net/hqh131360239/article/details/79169188
print(sgd_reg.predict(1.5))

随机梯度下降

# -*- coding: UTF-8 -*-
# 文件名: batch_gradient_descent.py
#批处理数据下降  参数是 batch  size  每次处理一百张照片  stotastic 是随机梯度下降用的更多sgd
import numpy as np

__author__ = 'yasaka'

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]
# print(X_b)

learning_rate = 0.1
n_iterations = 10000
m = 100
#一般不会等它达到多大值，因为很浪费时间，一般选写次数
# 1，初始化theta，w0...wn
theta = np.random.randn(2, 1)
#有n是标准正态分布，初始化数值，形状是2行一列的矩阵，里面放w0和w1
count = 0

# 4，不会设置阈值，之间设置超参数，迭代次数，迭代次数到了，我们就认为收敛了
for iteration in range(n_iterations):
    count += 1
    # 2，接着求梯度gradient
    gradients = 1/m * X_b.T.dot(X_b.dot(theta)-y)
    #公式 https://blog.csdn.net/csefrfvdv/article/details/100038207
    #x_b是  x矩阵里的x1和x2  .T是转置  .dot点基theta    就是把x转置然后乘以另外一部分，最后得到数值
    #这里是gradients 包含了g0和g1  1/m是使得它变成均值，不然数据增多，损失函数增大
    # 3，应用公式调整theta值，theta_t + 1 = theta_t - grad * learning_rate
    theta = theta - learning_rate * gradients

print(count)
print(theta)

# stotastic_gradient_descent
知识补充：
np.c_ https://blog.csdn.net/weixin_41797117/article/details/80048688

#stotastic_gradient_descent
#越接近时候步伐越小  他可以认为和学习次数相关

import numpy as np
import random

_author_='lalala'
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]
print(x_b)

n_epochs=500
t0,t1=5,50   #超参数


m=100
def learning_shedule(t):
    ruturn t0/(t+t1)
#随着时间增加，迭代次数增加，他是在逐渐减小的  避免在山谷低下来回震荡

theta=np.random.randn(2,1)

for epoch in range(n_epochs):
    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)
        learning_rate=learning_shedule(epoch*m+i)
        theta=theta-learning_rate*gradienrs
        
print(theta)
        

岭回归
防止过拟合 ，岭回归加入惩罚项
https://blog.csdn.net/xgxyxs/article/details/79436195

#参数的意义参考
https://www.jianshu.com/p/4880d476d40e

构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。

正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名: ridge_regression.py

import numpy as np
from sklearn.linear_model import Ridge
from sklearn.linear_model import SGDRegressor

__author__ = 'yasaka'

X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
"""
ridge_reg = Ridge(alpha=1, solver='sag')
#ridge_reg=Ridge(alpha=1,solver='auto')
ridge_reg.fit(X, y)
print(ridge_reg.predict(1.5))
#带入1.5看最终的预测值是多少
print(ridge_reg.intercept_)
print(ridge_reg.coef_)
"""
#下面是不用redge 等价方法 l2正则就是radge的关系
sgd_reg = SGDRegressor(penalty='l2', n_iter=1000)
sgd_reg.fit(X, y.ravel())
#y是API封装时候这么规定的，把列向量变成行向量传进来
print(sgd_reg.predict(1.5))
print("W0=", sgd_reg.intercept_)
print("W1=", sgd_reg.coef_)

#lasso

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名: lasso_regression.py

import numpy as np
from sklearn.linear_model import Lasso
from sklearn.linear_model import SGDRegressor

__author__ = 'yasaka'

X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

lasso_reg = Lasso(alpha=0.15)
lasso_reg.fit(X, y)
print(lasso_reg.predict(1.5))
print(lasso_reg.coef_)

sgd_reg = SGDRegressor(penalty='l1', max_iter=1000)
sgd_reg.fit(X, y.ravel())
print(sgd_reg.predict(1.5))
print(sgd_reg.coef_)