pytorch基础入门（二）：线性回归与非线性回归的实现

pytorch基础入门（二）：线性回归与非线性回归的实现

一、线性回归

import os

os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

import numpy as np

import matplotlib.pyplot as plt

from torch import nn,optim

from torch.autograd import Variable

import torch

x_data = np.random.rand(100)

noise = np.random.normal(0,0.01,x_data.shape)

y_data = x_data*0.1 + 0.2 + noise

plt.scatter(x_data,y_data)

plt.show()

# 将数据变成两维,reshape(-1,1)(-1表示自动匹配任意行，1表示1列)

x_data = x_data.reshape(-1,1)

y_data = y_data.reshape(-1,1)

# 把numpy数据转换为tensor数据

x_data = torch.FloatTensor(x_data)

y_data = torch.FloatTensor(y_data)

# 变成变量

inputs = Variable(x_data) # x_data看成模型的输入

target = Variable(y_data) # y_data看成数据的标签

# 构建神经网络模型

# 一般把网络中具有可学习参数的层放在__init__中

class LinearRegression(nn.Module): # 继承pytroch的类

# 定义网络结构

def __init__(self) -> None:

# 初始化nn.Modle

super(LinearRegression,self).__init__()

self.fc = nn.Linear(1,1) # fc全连接层（输入多少个值，输出多少个值）

# 定义网络计算 x表示网络的输入

def forward(self,x): # 前向计算。反向传播在pytorch中能自行计算

out = self.fc(x) # 网络接收到信号，就把数据传到全连接层进行计算，然后得到输出值out

return out

# 定义模型

model = LinearRegression() # 实例化

# 定义代价函数

mse_loss = nn.MSELoss() # mse是均方差（二次代价函数）

# 定义优化器

optimizer = optim.SGD(model.parameters(), lr = 0.1) # 优化器使用的是最简单的随机梯度下降法来优化网络参数，paramenters是模型的参数，lr是学习率

# 查看模型的参数 weight ： 权值 bias ： 偏置值

for name,paramenters in model.named_parameters():

print('name:{},param:{}'.format(name,paramenters))

name:fc.weight,param:Parameter containing:

tensor([[0.3600]], requires_grad=True)

name:fc.bias,param:Parameter containing:

tensor([-0.0594], requires_grad=True)

# 模型的训练

for i in range(1001):

out = model(inputs) # 数据传给模型，out是模型的预测值

# 计算loss

loss = mse_loss(out, target)

# 梯度清0

optimizer.zero_grad() # 在计算梯度前需要梯度清0，不然梯度会累加

# 计算梯度

loss.backward()

# 修改权值

optimizer.step()

# 每两百次打印一次

if i % 200 == 0:

print(i,loss.item())

0 9.744561248226091e-05

200 9.744561248226091e-05

400 9.744561248226091e-05

600 9.744561248226091e-05

800 9.744561248226091e-05

1000 9.744561248226091e-05

# 预测值

y_pred = model(inputs)

plt.scatter(x_data,y_data)

plt.plot(x_data,y_pred.data.numpy(),'r-',lw = 3) # 将y_pred转换为numpy数值

plt.show()

​

二、非线性回归

import os

os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

import numpy as np

import matplotlib.pyplot as plt

from torch import nn,optim

from torch.autograd import Variable

import torch

x_data = np.linspace(-2,2,200)[:,np.newaxis] # 生成-2到2之间均匀变大的200个数据, newawxis在列的位置加了一列

noise = np.random.normal(0,0.2,x_data.shape)

y_data = np.square(x_data) + noise #square求平方

plt.scatter(x_data,y_data)

plt.show()

​

# 将数据变成两维,reshape(-1,1)(-1表示自动匹配任意行，1表示1列)(由于上面使用了[:,np.newaxis]，两者选其一就行)

x_data = x_data.reshape(-1,1)

y_data = y_data.reshape(-1,1)

# 把numpy数据转换为tensor数据

x_data = torch.FloatTensor(x_data)

y_data = torch.FloatTensor(y_data)

# 变成变量

inputs = Variable(x_data) # x_data看成模型的输入

target = Variable(y_data) # y_data看成数据的标签

# 构建神经网络模型

# 一般把网络中具有可学习参数的层放在__init__中

class NonLinearRegression(nn.Module): # 继承pytroch的类

# 定义网络结构

def __init__(self) -> None:

# 初始化nn.Modle

super(NonLinearRegression,self).__init__()

#网络结构 1-10-1

self.fc1 = nn.Linear(1,10) # fc1为隐藏层（1个输入，10个输出）

self.tanh = nn.Tanh() # 双曲正切函数（激活函数）

self.fc2 = nn.Linear(10,1) # 全连接层（输出层）（10个输入，1个输出）

# 定义网络计算 x表示网络的输入

def forward(self,x): # 前向计算。反向传播在pytorch中能自行计算

x = self.fc1(x) # x表示数据传入，先经过隐藏层fc1

x = self.tanh(x) # 经过全连接层计算后，在传入双曲正切函数进行非线性变换

x = self.fc2(x) # 然后再传入全连接层fc2

return x

# 定义模型

model = NonLinearRegression() # 实例化

# 定义代价函数

mse_loss = nn.MSELoss() # mse是均方差（二次代价函数）

# 定义优化器

optimizer = optim.SGD(model.parameters(), lr = 0.3) # 优化器使用的是最简单的随机梯度下降法来优化网络参数，paramenters是模型的参数，lr是学习率

# 查看模型的参数 weight ： 权值 bias ： 偏置值

for name,paramenters in model.named_parameters():

print('name:{},param:{}'.format(name,paramenters))

name:fc1.weight,param:Parameter containing:

tensor([[-0.5068],

[-0.9891],

[-0.8892],

[-0.2340],

[-0.2264],

[ 0.4042],

[-0.2895],

[-0.8782],

[-0.4250],

[ 0.4728]], requires_grad=True)

name:fc1.bias,param:Parameter containing:

tensor([-0.6195, -0.7031, -0.3021, 0.2578, 0.5572, -0.1862, 0.9643, -0.9674,

0.9793, -0.6294], requires_grad=True)

name:fc2.weight,param:Parameter containing:

tensor([[ 0.0379, -0.1409, 0.0473, -0.3142, -0.0907, -0.1494, 0.2386, 0.2821,

-0.1539, 0.1841]], requires_grad=True)

name:fc2.bias,param:Parameter containing:

tensor([-0.2621], requires_grad=True)

# 模型的训练

for i in range(2001):

out = model(inputs) # 数据传给模型，out是模型的预测值

# 计算loss

loss = mse_loss(out, target)

# 梯度清0

optimizer.zero_grad() # 在计算梯度前需要梯度清0，不然梯度会累加

# 计算梯度

loss.backward()

# 修改权值

optimizer.step()

# 每四百次打印一次

if i % 400 == 0:

print(i,loss.item())

0 4.775318145751953

400 0.1682930439710617

800 0.0795355960726738

1200 0.08297023177146912

1600 0.0833432674407959

2000 0.08173517882823944

# 预测值

y_pred = model(inputs)

plt.scatter(x_data,y_data)

plt.plot(x_data,y_pred.data.numpy(),'r-',lw = 3) # 将y_pred转换为numpy数值

plt.show()

​

好文推荐

 您阅读本篇文章共花了：