Pytorch-回归实战-利用梯度下降方法求解numpy两组数据

'''
理论1.
回归学习：
理论：数据都是有噪声的.
模型：y=wx+b+ε  ，ε高斯噪声.
损失函数：loss=sqrt(wx+b-y)
动态图：由x,y,loss三个组成的立体空间图.
目的：输入x值，求得的y`值尽量接近于真实值y.
优化器：？？
'''
'''
理论2.
Linear Regression
a.Linear Regression (y=wx+b+ε)
b.Logistic Regression 对数据进行压缩，使得y值在[0,1].
c.Classification 手写字概率0-9? EPi=1（写10次）
'''
'''
实战-利用梯度下降方法求解numpy两组数据：
公式1：y=wx+b
公式2：loss=sqrt(wx+b-y)
问题描述：
输入x到公式生成的y`值与真实值的梯度下降方法计算最优参数w和b值.
运行：
Starting gradient descent at b = {0}, m = {1}, error = {2}
第一个compute_error_for_line_given_points()函数是计算参数值w,b为0的时候的差值.
更多的是寻找x与y最适合的参数值.
方法：
是通过求导公式2loss的w,b的极值，对函数loss求导求出它在值域里面的极小值，那也就是loss的最小值，小批量有100个数据值对w,b求导之和，
然后更新梯度w,b值.这为1/num_iterations.
对于num_iterations的次数，要看loss值.
After {0} iterations b = {1}, m = {2}, error = {3}
'''
import numpy as np

#y=wx+b
#计算误差函数
def compute_error_for_line_given_points(b, w, points):
    totalError = 0
    for i in range(0, len(points)): #一个代表列索引，一个代表列数据
        x = points[i, 0] #切片
        # print(x)
        y = points[i, 1] #切片
        # print(y)
        totalError += (y - (w * x + b)) ** 2
        # print(totalError)
    return totalError / float(len(points))

def step_gradient(b_current, w_current, points, learningRate):
    b_gradient = 0
    w_gradient = 0
    N = float(len(points)) #100
    for i in range(0, len(points)):
        x = points[i, 0]
        print("x:%d" % i)
        print(x)
        y = points[i, 1]
        print("y:%d" % i)
        print(y)
        b_gradient += -(2/N) * (y - ((w_current * x) + b_current))
        w_gradient += -(2/N) * x * (y - ((w_current * x) + b_current))
        print("b:%d"%i)
        print(b_gradient)
        print("w:%d"%i)
        print(w_gradient)
    new_b = b_current - (learningRate * b_gradient)
    new_m = w_current - (learningRate * w_gradient)
    return [new_b, new_m]

#梯度下降
def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
    b = starting_b
    m = starting_m
    for i in range(num_iterations):
        b, m = step_gradient(b, m, np.array(points), learning_rate) #更新b,w值，反复循环num_iterationsc次.
    return [b, m]

def run():
    points = np.genfromtxt("data.csv",delimiter=",") #将数据读取成列表形式
    # print(points)
    learning_rate = 0.0001
    initial_b = 0 # initial y-intercept guess
    initial_m = 0 # initial slope guess
    num_iterations = 1000 #迭代次数为1000
    #format:基本语法是通过 {} 和 : 来代替以前的 %
    print("Starting gradient descent at b = {0}, m = {1}, error = {2}"
          .format(initial_b, initial_m,
                  compute_error_for_line_given_points(initial_b, initial_m, points))
          )
    print("Running...")
    #将b,w更新为对函数最优的值，使用的方法叫做梯度下降法.
    [b,m] = gradient_descent_runner(points,initial_b,initial_m,learning_rate,num_iterations)  #(100,2),0,0,0.0001,1000
    print("After {0} iterations b = {1}, m = {2}, error = {3}".
          format(num_iterations, b, m,
                 compute_error_for_line_given_points(b, m, points))
          )
if __name__ == '__main__':
    run()

程序运行后的值，通过两次运行结果的error值，可以看出训练批次1000和10000差别不大：

批次为1000时训练后面的结果：

After 1000 iterations b = 0.08893651993741346, m = 1.4777440851894448, error = 112.61481011613473

批次为10000时训练后面的结果：

After 10000 iterations b = 0.6078985997054931, m = 1.4675440436333027, error = 112.31533427075733