Pytorch学习笔记（三）－－linear regression andgradient descend（线性回归和梯度下降）

最新推荐文章于 2022-03-21 20:32:13 发布

屋顶数☆☆

最新推荐文章于 2022-03-21 20:32:13 发布

阅读量498

点赞数 1

分类专栏： pytorch

本文链接：https://blog.csdn.net/qq_42655135/article/details/91127160

版权

pytorch 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前请提要
Pytorch学习笔记（一）－－Tensor和Variable
Pytorch学习笔记（二）－－autograd and dynamic-graph

一．一元线性回归

线性模型简单通俗的讲就是已知很多个点，需要找到一个函数来拟合，使之误差最小
一元线性模型
假设我们有变量 xi 和目标 yi ，每个 i 对应于一个数据点，希望建立一个模型
yi’=wxi+b
yi’ 是我们预测的结果，希望通过yi’ 来拟合目标 yi，通俗来讲就是找到这个函数拟合 yi 使得误差最小，即最小化
１/n ∑1/n*(yi’−yi)^2

二．梯度下降法

梯度是一个函数变化最快的方向．对于函数 f(x, y)，在点 (x0,y0) 处，沿着梯度 ∇f(x0, y0) 的方向，函数增加最快，也就是说沿着梯度的方向，我们能够更快地找到函数的极大值点，或者反过来沿着梯度的反方向，我们能够更快地找到函数的最小值点。
不断改变 w 和 b 的值，最终找到一组最好的 w 和 b 使得误差最小。在更新的时候，我们需要决定每次更新的幅度，这个称为学习率，用 η 表示
w:　=　w　−　η＊∂f(w, b)/∂w
b:　=　b　−　η＊∂f(w, b)/∂b
例子以及代码如下
3.1画出散点

import torch
import numpy as np
from torch.autograd import Variable
import matplotlib.pyplot as plt

torch.manual_seed(2017)

# 读入数据 x 和 y
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                    [9.779], [6.182], [7.59], [2.167], [7.042],
                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
                    [3.366], [2.596], [2.53], [1.221], [2.827],
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

plt.plot(x_train, y_train, 'bo')

plt.show()

画出散点

3.2构建线性模型，画出更新前的点

#转换成tensor
x_train = torch.from_numpy(x_train)
y_train = torch.from_numpy(y_train)

#定义参数w和b  w随机初始化　b使用0初始化
w = Variable(torch.randn(1),requires_grad=True)
b = Variable(torch.zeros(1),requires_grad=True)

#构建线性回归模型
x_train = Variable(x_train)
y_train = Variable(y_train)

def linear_model(x):
    return x * w + b

y_ = linear_model(x_train)

#更新参数前模型的输出
plt.plot(x_train.data.numpy(),y_train.data.numpy(),'bo',label='raal')
plt.plot(x_train.data.numpy(),y_.data.numpy(),'ro',label='estimated')
plt.legend()  #图例

plt.show()

关于torch.mean()
https://www.cnblogs.com/kk17/p/10252238.html
在这里插入图片描述

3.3构建线性模型，参数更新一次

#计算误差
def get_loss(y_,y):
    return torch.mean((y_ - y_train) ** 2)

loss = get_loss(y_,y_train)

#自动求导
loss.backward()

#更新一次参数
w.data = w.data - 1e-2 * w.grad.data
b.data = b.data - 1e-2 * b.grad.data

#更新一次参数后模型的输出
y_ = linear_model(x_train)
plt.plot(x_train.data.numpy(),y_train.data.numpy(),'bo',label='raal')
plt.plot(x_train.data.numpy(),y_.data.numpy(),'ro',label='estimated')
plt.legend()

plt.show()

构建的模型开始拟合，但是还有上面的点离散
在这里插入图片描述
3.4构建线性模型，参数多次

for e in range(10):
    y_ = linear_model(x_train)
    loss = get_loss(y_,y_train)

    #归零梯度
    w.grad.zero_()
    b.grad.zero_()
    loss.backward()

    #更新参数
    w.data = w.data - 1e-2 * w.grad.data
    b.data = b.data - 1e-2 * b.grad.data
    print('epoch: {},loss: {}'.format(e,loss.data))

y_ = linear_model(x_train)
plt.plot(x_train.data.numpy(),y_train.data.numpy(),'bo',label='raal')
plt.plot(x_train.data.numpy(),y_.data.numpy(),'ro',label='estimated')
plt.legend()
plt.title("e=10")

plt.show()

format用法
https://www.runoob.com/python/att-string-format.html

epoch: 0,loss: 153.3519744873047
epoch: 1,loss: 3.135772228240967
epoch: 2,loss: 0.355089008808136
epoch: 3,loss: 0.30295446515083313
epoch: 4,loss: 0.30131959915161133
epoch: 5,loss: 0.3006228804588318
epoch: 6,loss: 0.2999469041824341
epoch: 7,loss: 0.299274742603302
epoch: 8,loss: 0.2986060082912445
epoch: 9,loss: 0.2979407012462616

在这里插入图片描述

三．多项式回归模型

y^=wx+b

这里是关于 x 的一个一次多项式，这个模型比较简单，没有办法拟合比较复杂的模型，所以我们可以使用更高次的模型，比如

y^=w0+w1x+w2x2+w3x3+⋯

1.画出样本图

#多项式回归模型
import torch
import numpy as np
from torch.autograd import Variable
import matplotlib.pyplot as plt

torch.manual_seed(2017)

#定义一改多变量的函数
w_target = np.array([0.5,3,2.4])
b_target = np.array([0.9])

#non-empty format string passed to object.__format__
#y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3
f_des = 'y = {:.2f} + {:.2f} * x + {:.2f} * x^2 + {:.2f} * x^3'.format(*b_target, *w_target)
print(f_des)

# 画出这个函数的曲线
x_sample = np.arange(-3, 3.1, 0.1)
y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3
plt.plot(x_sample,y_sample,label='real curve')
plt.legend()
plt.show()

y = 0.90 + 0.50 * x + 3.00 * x^ 2 + 2.40 * x^3

在这里插入图片描述

2.更新参数前的拟合

# 构建数据 x 和 y
# x 是一个如下矩阵 [x, x^2, x^3]
# y 是函数的结果 [y]
x_train = np.stack([x_sample ** i for i in range(1, 4)], axis=1)
x_train = torch.from_numpy(x_train).float()
y_train = torch.from_numpy(y_sample).float().unsqueeze(1)

# 定义参数和模型
w = Variable(torch.randn(3, 1), requires_grad=True)
b = Variable(torch.zeros(1), requires_grad=True)

# 将 x 和 y 转换成 Variable
x_train = Variable(x_train)
y_train = Variable(y_train)

def multi_linear(x):
    return torch.mm(x, w) + b

#画出更新之前的模型
y_pred = multi_linear(x_train)

plt.plot(x_train.data.numpy()[:, 0], -y_pred.data.numpy(), label='fitting curve', color='r')
plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')
plt.legend()

在这里插入图片描述

3.更新一次参数后拟合

#计算误差
def get_loss(y_,y):
    return torch.mean((y_ - y_train) ** 2)

loss = get_loss(-y_pred, y_train)

# 自动求导
loss.backward()

# 更新一下参数
w.data = w.data - 0.001 * w.grad.data
b.data = b.data - 0.001 * b.grad.data

# 画出更新一次之后的模型
y_pred = multi_linear(x_train)

plt.plot(x_train.data.numpy()[:, 0], -y_pred.data.numpy(), label='fitting curve', color='r')
plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')
plt.legend()

plt.show()

在这里插入图片描述
4.更新Ｎ多次参数

for e in range(440):
    y_pred = multi_linear(x_train)
    loss = get_loss(y_pred, y_train)

    # w.grad.data.zero_()
    # b.grad.data.zero_()
    loss.backward()

    # 更新参数
    w.data = w.data - 0.001 * w.grad.data
    b.data = b.data - 0.001 * b.grad.data
    if (e + 1) % 20 == 0:
        print('epoch {}, Loss: {:.5f}'.format(e + 1, loss.data))

y_pred = multi_linear(x_train)
plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')
plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')
plt.legend()
plt.show()