（机器学习）线性回归-2

0三种梯度下降的方法

“Batch” Gradient Descent 批梯度下降
批梯度下降：指的是每下降一步，使用所有的训练集来计算梯度值

“Stochastic” Gradient Descent 随机梯度下降
随机梯度下降：指的是每下降一步，使用一条训练集来计算梯度值

“Mini-Batch” Gradient Descent “Mini-Batch”梯度下降
“Mini-Batch”梯度下降：指的是每下降一步，使用一部分的训练集来计算梯度值

1.随机梯度下降法

# -*- coding:utf-8 -*-
# @Time : 19-4-14 上午10:28
# @Author : flower
# @Filename : 1_stochatic_gradient.py
# @software : PyCharm

import numpy as np
import random

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]

# epoch 的意思是每一轮处理m个样本
n_epochs = 100
# 初始化学习率
a0 = 0.1
# 定义衰减率
decay_rate = 1

def learning_schedule(epoch_num):
    return (1.0/(decay_rate * epoch_num +1)) *a0

# 初始化theta值
theta = np.random.randn(2,1)

# 初始化随机值
num = [i for i in range(100)]
m = 100
"""
假设我们有m个样本，随机梯度下降一次迭代只用到一个样本
那么如果我们想把所有样本都用到，那就得作m次梯度下降，这个
过程就叫做一个epoch
"""

for epoch in range(n_epochs):
    # 生成100个不重复的随机数
    rand = random.sample(num,100)
    for i in range(m):
        """
        X = [[1],[2],[3]]
        Y = [[2],[4],[6]]
        第一次：X1 = [2],Y1=[4]
        第二次：X2 = [3],Y2=[6]
        第三次：X3 = [1],Y3=[2]
        我们要保证的是，每一个样本都被用到
        整个上面这个步骤，我们叫做一个epoch（一轮）
        """
        random_index = rand[i]
        x1 = X_b[random_index:random_index+1]
        y1 = y[random_index:random_index+1]
        gradients = x1.T.dot(x1.dot(theta)-y1)
        learning_rate = learning_schedule(epoch+1)
        theta = theta-learning_rate * gradients
print(theta)

输出：
[[4.04680324]
[2.7856735 ]]

2.‘Mini-batch’梯度下降
如果 mini-batch 大小 = m ： 那他就是批梯度下降
如果 mini-batch 大小 = 1 ： 那他就是随机梯度下降
如果 mini-batch 1 < 大小 < m ：那他就是‘Mini-batch’随机梯度下降

#encoding:utf-8
"""
mini-batch梯度下降
"""
import numpy as np
import random

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
num = [i for i in range(100)]

def learning_schedule(t):
    return float(t0) / (t + t1)

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

batch_num = 5
batch_size = m / 5

# epoch 是轮次的意思,意思是用m个样本做一轮迭代
for epoch in range(n_epochs):
    for i in range(batch_num):
        start = i*batch_size
        end = (i+1)*batch_size
        xi = X_b[start:end]
        yi = y[start:end]
        gradients = 1.0/batch_size * xi.T.dot(xi.dot(theta)-yi)
        learning_rate = learning_schedule(epoch*m + i)
        theta = theta - learning_rate * gradients

print(theta)

输出：
[[4.16177327]
[2.90515757]]

1归一化

特征缩放

特征缩放是为了确保特征在一个数量级上
1.除以最大值的方法

2.平方均值法

2学习率

当损失函数上升的时候，证明梯度下降方法没有正常工作，这时候可以使用小一点的学习率α
对于足够小的学习率α而言，损失函数应该每次都下降,但是如果学习率α太小，收敛的速度将会很慢.

3多项式回归

# -*- coding:utf-8 -*-
# @Time : 19-4-14 上午11:47
# @Author : flower
# @Filename : 3_ploynomial_多项式回归.py
# @software : PyCharm

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

m = 100
X = 6 * np.random.rand(m,1)-3
y = 0.5 * X ** 2 + X+2+np.random.randn(m,1)

# degree=2 x的平方-->2维
ploy_features = PolynomialFeatures(degree=2,include_bias=False)
# fit_transform=fit()+transform() 其中transform()就是用来作归一化的
X_ploy = ploy_features.fit_transform(X)

# 到此，就相当与把一个高阶的方程,转化成了一个一阶方程（多元线性回归）
lin_reg = LinearRegression()
lin_reg.fit(X_ploy,y)
# coef是参数  intercept 是截距
print(lin_reg.coef_)
print(lin_reg.intercept_)

输出：
[[1.03245376 0.52101617]]
[1.87842386]

把多项式回归画出来便于观察：
1.首先看一下样本点

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
m = 100
X = 6* np.random.rand(m,1) -3
y = 0.5 * X **2 +X + 2 +np.random.randn(m,1)

plt.plot(X,y,'b.')
plt.show()

2.回归：阶数对回归的影响

# -*- coding:utf-8 -*-
# @Time : 19-4-14 下午1:54
# @Author : flower
# @Filename : 4_多项式回归画图polynomialfeatures.py
# @software : PyCharm

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
m = 100
X = 6* np.random.rand(m,1) -3
y = 0.5 * X **2 +X + 2 +np.random.randn(m,1)

plt.plot(X,y,'b.')
# plt.show()

# 表示阶数
d = {1:'g-',2:'r+',10:'y*'}

for i in d:
    poly_features = PolynomialFeatures(degree=i,include_bias=False)
    X_ploy = poly_features.fit_transform(X)

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

    y_predict = lin_reg.predict(X_ploy)
    plt.plot(X_ploy[:,0],y_predict,d[i],label='order=%d' %i)
#     [:,0] 所有行的第一列
plt.legend(loc='upper left')
plt.show()

图中，我们可以看出阶数为2时拟合的最好

4保险数据去处理保险金的问题

下载：链接: https://pan.baidu.com/s/1oE680x7lK2MgtN8TEpULEQ 提取码: 1149
1.查看数据

# 查看数据
data  = pd.read_csv('data/insurance.csv')
# print(data)
print(data.head())
# print(data.corr())
# print(data.describe())

输出：

   age  sex     bmi  children  smoker  region      charges
0   19    1  27.900         0       0       1  16884.92400
1   18    0  33.770         1       1       0   1725.55230
2   28    0  33.000         3       1       0   4449.46200
3   33    0  22.705         0       1       2  21984.47061
4   32    0  28.880         0       1       2   3866.85520

print(data.corr())
"""
pearson皮尔逊相关系数
正相关 +1 
不相关 0
负相关 -1
正相关 ：x维度在增大的时候，y也在增大
不相关 ：x维度在增加的时候，y在减小
负相关 ：无论x增大或者减小，y没有明显的变化

作用：为了降维

(1)如果两个维度正相关性比较高，那么我们就保留一个维度
(2)如果两个维度没有相关性，但是都和y的相关性比较高，那么我们保留两个维度
(3)如果两个维度有负相关性，我们可以保留两个维度

余弦定理：利用余弦计算来确定相关性
"""

2.清洗数据

'''清洗数据'''
reg =LinearRegression()

x = data[['age','sex','bmi','children','smoker','region']]
y = data['charges']
# print(x)
# 把数据中的文字转换成数字
x = x.apply(pd.to_numeric,errors = 'coerce')
y = y.apply(pd.to_numeric,errors = 'coerce')

# 把数据中的na值填成0
x.fillna(0,inplace=True)
y.fillna(0,inplace=True)

print(x)
print(y)

3.模型

# 阶数可以改变 从图上看出效果
poly_feature = PolynomialFeatures(degree=5,include_bias=False)
x_poly = poly_feature.fit_transform(x)
# print('x',x)
print('x_poly',x_poly)
print('x1',x_poly[:,0])

# 用线性回归拟合
reg =LinearRegression()
reg.fit(x_poly,y)
# print(reg.coef_,reg.intercept_)

y_predict = reg.predict(x_poly)
# 真实的y  ,x取age那一列
plt.plot(x['age'],y,'b.',label='real')
# 预测的y,x_poly保证和真实的数据一样多
plt.plot(x_poly[:,0],y_predict,'r.',label='pre')
plt.legend(loc='upper left')
plt.show()

蓝色与红色越重和准确度越高