今日对比不同梯度下降的代码

1.BGD大批量梯度下降(一元一次）

首先导入库

import numpy as np

import matplotlib.pyplot as plt

随机生成线性回归函数

X=np.random.rand(100,1)

w,b=np.random.randint(1,10,size=2)

#增加噪声，更像真实数据
#numoy广播机制
y= w*X+b+np.random.randn(100,1)
plt.scatter(X,y)

使用了 np.concatenate 来将一个全为1的列向量添加到 X 的左边，从而在数据集中包含截距项

# 将b作为偏置项，截距，对应的系数，理解为1
X=np.concatenate([X,np.full(shape = (100,1),fill_value=1)],axis=1)
X[:10]

大批量梯度下降函数

#循环次数
epoches = 10000

#学习率
eta =0.01
t0 = 5
t1 = 1000
#优化：学习率变化
#t 梯度下降的次数，逆时衰减，随着梯度下降次数增加学习率，变小
def learning_rate_shedule(t):
    return t0/(t + t1)
#要求解的系数
theta = np.random.randn(2,1)


#梯度下降的次数
t=0
for i in range(epoches):
    #批量梯度下降
    g = X.T.dot(X.dot(theta)-y)#根据公式计算梯度
    eta = learning_rate_shedule(t)#随着梯度下降增加，学习率下降
    theta = theta - eta*g
print('真实的斜率，截距是：',w,b)
print('BGD求解的斜率，截距是：',theta)#因为增加了噪声所以有差距

大批量（多元一次）

import numpy as np
import matplotlib.pyplot as plt

X=np.random.rand(100,8)

w=np.random.randint(1,10,size=(8,1))
b=np.random.randint(1,10,size=1)
#增加噪声，更像真实数据
#numoy广播机制
y= X.dot(w)+b+np.random.randn(100,1)

#截距当成偏执项
X =np.concatenate ([X,np.full(shape=(100,1),fill_value=1)],axis=1)

#循环次数
epoches = 10000

#学习率
eta =0.01
t0 = 5
t1 = 1000
#优化：学习率变化
#t 梯度下降的次数，逆时衰减，随着梯度下降次数增加学习率，变小
def learning_rate_shedule(t):
    return t0/(t + t1)
#要求解的系数
theta = np.random.randn(9,1)


#梯度下降的次数
t=0
for i in range(epoches):
    #批量梯度下降
    g = X.T.dot(X.dot(theta)-y)#根据公式计算梯度
    eta = learning_rate_shedule(t)#随着梯度下降增加，学习率下降
    theta = theta - eta*g
print('真实的斜率，截距是：',w,b)
print('BGD求解的斜率，截距是：',theta)#因为增加了噪声所以有差距

2.SGD随机梯度下降

导入库

import numpy as np
import matplotlib.pyplot as plt

X=np.random.rand(100,1)

w,b=np.random.randint(1,10,size=2)

#增加噪声，更像真实数据
#numoy广播机制
y= w * X + b + np.random.randn(100,1)
plt.scatter(X,y)

#编置，x也需要增加#full_like(用于创建一个与给定数组 a 形状和类型相同，但填充了指定值的新数组。)
X = np.concatenate([X,np.full_like(X,fill_value=1)],axis = 1)

#循环次数
epoches = 100

t0 = 5
t1 = 1000
#优化：学习率变化
#t 梯度下降的次数，逆时衰减，随着梯度下降次数增加学习率，变小
def learning_rate_shedule(t):
    return t0/(t + t1)
theta = np.random.randn(2,1)

count=0
for t in range(epoches):
    index = np.arange(100)
    np.random.shuffle(index)#洗牌，打乱
    
    #numpy花式索引
    X=X[index]
    y=y[index]
    for i in range(100):
        #随机抽样！！！抽了一个样本
        X_i=X[i]
        y_i=y[i]
    
        #根据这个样本，逆行计算梯度
        #单个样本依然是矩阵
        g = X_i.T.dot(X_i-theta* y_i)
        eta = learning_rate_shedule(t+count)
        count +=1
        theta -= eta*g
print('真实的斜率，截距是：',w,b)
print('SGD求解的斜率，截距是：',theta)

3.MGD小批量梯度下降

import numpy as np
import matplotlib.pyplot as plt

X=np.random.rand(100,1)

w,b=np.random.randint(1,10,size=2)

y= w * X + b + np.random.randn(100,1)

X = np.c_[X,np.ones((100,1))]

t0,t1=5,500
def learning_rate_shedule(t):
    return t0/(t + t1)

epoches = 100
n=100
batch_size = 16
num_batches = int(n/batch_size)


#5初始化 w0..wn,标准正态分布创建
o =np.random.randn(2,1)

#6 多次for循环实现梯度下降，最终结果收敛
for epoch in range(epoches):
    #在双层for循环之间，每个轮次开始分批次迭代之前打乱数据索引顺序
    index = np.arange(n)
    np.random.shuffle(index)#打乱
    X = X[index]
    y = y[index]
    for i in range(num_batches):
        #切片
        X_batch = X[i * batch_size:(i+1)*batch_size]
        y_batch = y[i * batch_size:(i+1)*batch_size]
        
        g = X_batch.T.dot(X_batch.dot(o) - y_batch)
        
        learning_rate = learning_rate_shedule(epoch*n+i)
        o = o-learning_rate*g
print('真实斜率和截距',w,b)
print('梯度下降计算斜率和截距',o)