关系拟合（回归）
建立数据集
创建一些假数据来模拟真实的情况. 比如一个一元二次函数: y = a * x^2 + b, 将 y 数据加上一点噪声来更加真实的展示它.
#关系拟合（回归）
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
#fake data
x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
#unsqueeze将一维变成二维
y=x.pow(2)+0.2*torch.rand(x.size())
# 二次方+噪点的影响
plt.scatter(x.data.numpy(),y.data.numpy())
#散点图
plt.show()建立神经网络
建立一个神经网络可以直接运用 torch 中的体系. 先定义所有的层属性(init()), 然后再一层层搭建(forward(x))层于层的关系链接.建立关系的时候, 会用到激励函数,
#关系拟合（回归）
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
class Net(torch.nn.Module):#module是net主模块
#搭建torch所需要的两个功能
def __init__(self,n_feature,n_hidden,n_output):#搭建net所需要的信息
super(Net,self).__init__()#继承net到Module模块并输出init功能
#下面为层信息，层信息都是属性
self.hidden=torch.nn.Linear(n_feature,n_hidden)#多少输入多少输出
self.predict = torch.nn.Linear(n_hidden,n_output)
def forward(self,x):#前向传递的过程，正向传播输入值, 神经网络分析出输出值
x=F.relu(self.hidden(x))#x经过hidden输出n_hidden，再用relu激活函数嵌套
x=self.predict(x)#将上述x放入predict中 输出层输出x
#输出层不用激励函数，因为在大多数回归问题当中
#预测值在大多数回归问题中它的分布从正无穷到负无穷，
#用激励函数会将值截断了一点，predict不喜欢截断的结果
return x
#定义net
#！！！！不要打在class里
net=Net(n_feature=1,n_hidden=10,n_output=1)#x值1个，隐藏层（神经元10），y1
print(net)
plt.ion() #实时 画图
plt.show()
#优化网络
optimizer=torch.optim.SGD(net.parameters(),lr=0.2)#越高越快
#用optim优化器优化神经网络的参数,学习效率0.2
loss_func=torch.nn.MSELoss()#优化误差的手段 MSELoss()均方差
#开始训练
for t in range(100):#100步
prediction=net(x)#输入信息预测值
loss=loss_func(prediction,y)#预测prediction和y的误差
optimizer.zero_grad()#所有参数梯度降为0
loss.backward()#反向传递，给每个神经网络节点计算出梯度
optimizer.step()#优化梯度
if t % 5 == 0:
# plot and show learning process
plt.cla()
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
plt.text(0.2, 0, 'Loss=%.4f' % loss.data, fontdict={'size': 20, 'color': 'red'})
plt.pause(0.1)
plt.ioff()
plt.show()
区分类型 (分类)
创建一些假数据来模拟真实的情况. 比如两个二次分布的数据, 不过他们的均值都不一样.建立一个神经网络可以直接运用 torch 中的体系. 先定义所有的层属性(init()), 然后再一层层搭建(forward(x))层于层的关系链接.
这个和前面 regression 的时候的神经网络基本没差.建立关系的时候, 会用到激励函数,
import torch
import matplotlib.pyplot as plt
import torch.nn.functional as F
# 假数据
n_data = torch.ones(100, 2) # 数据的基本形态 x包含横纵坐标 y为类型
x0 = torch.normal(2*n_data, 1) # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100) # 标签为0
x1 = torch.normal(-2*n_data, 1) # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(100) # 标签为1
# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) #数据一定要为FloatTensor = 32-bit floating
#x合并在一起做数据
y = torch.cat((y0, y1), ).type(torch.LongTensor) # 标签一定要为LongTensor = 64-bit integer
# y合并在一起做标签0.
# plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
# plt.show()
class Net(torch.nn.Module): # 继承 torch 的 Module
def __init__(self, n_feature, n_hidden, n_output):
super(Net, self).__init__() # 继承 __init__ 功能
self.hidden = torch.nn.Linear(n_feature, n_hidden) # 隐藏层线性输出
self.out = torch.nn.Linear(n_hidden, n_output) # 输出层线性输出
def forward(self, x):
# 正向传播输入值, 神经网络分析出输出值
x = F.relu(self.hidden(x)) # 激励函数(隐藏层的线性值)
x = self.out(x) # 输出值, 但是这个不是预测值, 预测值还需要再另外计算
return x
net = Net(n_feature=2, n_hidden=10, n_output=2) # 几个类别就几个 output
#x输入为2个特征（x，y坐标） 输出2个特征（0和你）
print(net) # net 的结构
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02) # 传入 net 的所有参数, 学习率
loss_func = torch.nn.CrossEntropyLoss()
#CrossEntropyLoss()作用 标签值:【0,0,1】 预测值：【0.1,0.3,0.6】两者误差
plt.ion() # 画图
plt.show()
for t in range(100):
out = net(x) # 喂给 net 训练数据 x, 输出分析值
loss = loss_func(out, y) # 计算两者的误差
optimizer.zero_grad() # 清空上一步的残余更新参数值
loss.backward() # 误差反向传播, 计算参数更新值
optimizer.step() # 将参数更新值施加到 net 的 parameters 上
if t % 2 == 0:
plt.cla()
prediction = torch.max(out, 1)[1]
#最大值的位置就是索引为1的地方
pred_y = prediction.data.numpy().squeeze()
target_y = y.data.numpy()
plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn')
accuracy = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'})
plt.pause(0.1)
plt.ioff() # 停止画图
plt.show()快速搭建
在回归里用的方法，用 class 继承了一个 torch 中的神经网络结构, 然后对其进行了修改, 快速搭建更快, 用一句话就概括了上面所有的内容!
class Net(torch.nn.Module):
def __init__(self, n_feature, n_hidden, n_output):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden)
self.predict = torch.nn.Linear(n_hidden, n_output)
def forward(self, x):
x = F.relu(self.hidden(x))
x = self.predict(x)
return x
net1 = Net(1, 10, 1) # 这是我们用这种方式搭建的 net1快速搭建
net2 = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)
print(net1)
"""
Net (
(hidden): Linear (1 -> 10)
(predict): Linear (10 -> 1)
)
"""
print(net2)
"""
Sequential (
(0): Linear (1 -> 10)
(1): ReLU ()
(2): Linear (10 -> 1)
)
"""net2把激励函数也一同纳入进去了, 但是 net1 中, 激励函数实际上是在 forward() 功能中才被调用的.
这也就说明了, 相比 net2, net1 的好处就是, 可以根据个人需要更加个性化你自己的前向传播过程, 比如(RNN).
不过如果不需要七七八八的过程, net2 更适合.
保存提取
训练好了一个模型, 我们想要保存它, 留到下次要用的时候直接提取直接用, 这里用回归的神经网络举例实现保存提取.
一种保存整个神经网络 torch.save(net1,‘net.pkl’)
一种保存神经网络的参数torch.save(net1.state_dict(),‘net_params.pkl’)
import torch
import matplotlib.pyplot as plt
#fake data
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
#unsqueeze将一维变成二维
y = x.pow(2) + 0.2*torch.rand(x.size())
# 二次方+噪点的影响
#保存数据
def save():
#建网络
net1=torch.nn.Sequential(
torch.nn.Linear(1,10),
torch.nn.ReLU(),
torch.nn.Linear(10,1)
)
#优化网络
optimizer=torch.optim.SGD(net1.parameters(),lr=0.2)
loss_func=torch.nn.MSELoss()
# 开始训练
for t in range(100): # 100步
prediction =net1(x) # 输入信息预测值
loss = loss_func(prediction, y) # 预测prediction和y的误差
optimizer.zero_grad() # 所有参数梯loss = loss_func(prediction, y)度降为0
loss.backward() # 反向传递，给每个神经网络节点计算出梯度
optimizer.step() # 优化梯度
# 出图
plt.figure(1, figsize=(10, 3))
plt.subplot(131)
plt.title('Net1')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
torch.save(net1,'net.pkl')#保存整个神经网络
#保存的名字
torch.save(net1.state_dict(),'net_params.pkl')#保存整个神经网络的参数
def restore_net():
net2=torch.load('net.pkl')
prediction=net2(x)
# 出图
plt.subplot(132)
plt.title('Net2')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
def restore_parames():
#net3提取参数 首先要建立一个和net1一样的神经网络
#然后把net1的参数复制到net3中
net3 = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)#但里面的参数肯定不一样
net3.load_state_dict(torch.load('net_params.pkl'))
prediction=net3(x)
# 出图
plt.subplot(133)
plt.title('Net3')
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
plt.show()
save()
restore_net()
restore_parames()
批训练
DataLoader
DataLoader 是 torch 给你用来包装你的数据的工具. 所以要将自己的 (numpy array 或其他) 数据形式装换成 Tensor, 然后再放进这个包装器中.DataLoader帮你有效地迭代数据,
#批处理
import torch
import torch.utils.data as Data
BATCH_SIZE=5#一堆数据分为5个一组 5个 5个
x=torch.linspace(1,10,10)#从1到10分为10个点
y=torch.linspace(10,1,10)#从10到1。。
#定义一个数据库
torch_dataset=Data.TensorDataset(x,y)#x训练数据y目标数据
#使用loader将训练变成一小批一小批的
loader=Data.DataLoader(
dataset=torch_dataset,
batch_size=BATCH_SIZE,
shuffle=True,#要不要在训练的时候随机打乱数据再开始抽样 false为不打乱
)
for epoch in range(3):#把上述10个数据整体训练3次
for step,(batch_x,batch_y) in enumerate(loader):#总训练3次每次训练分为2部分
#loader定义要不要打乱数据 不打乱数据每次训练的形式是一样的先训练数据点1再训练数据点2.。
#enumerate在每次提取的时候都给他一个索引 第一个就是第一步
#training
print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
batch_x.numpy(), '| batch y: ', batch_y.numpy())
。。。
Epoch: 0 | Step: 0 | batch x: [3. 5. 1. 4. 8.] | batch y: [ 8. 6. 10. 7. 3.]
Epoch: 0 | Step: 1 | batch x: [ 2. 6. 10. 9. 7.] | batch y: [9. 5. 1. 2. 4.]
Epoch: 1 | Step: 0 | batch x: [ 4. 2. 6. 7. 10.] | batch y: [7. 9. 5. 4. 1.]
Epoch: 1 | Step: 1 | batch x: [9. 5. 8. 1. 3.] | batch y: [ 2. 6. 3. 10. 8.]
Epoch: 2 | Step: 0 | batch x: [4. 7. 6. 2. 8.] | batch y: [7. 4. 5. 9. 3.]
Epoch: 2 | Step: 1 | batch x: [10. 9. 1. 3. 5.] | batch y: [ 1. 2. 10. 8. 6.]若将BATCH_SIZE=5改为8输出
Epoch: 0 | Step: 0 | batch x: [2. 1. 5. 9. 7. 8. 4. 6.] | batch y: [ 9. 10. 6. 2. 4. 3. 7. 5.]
Epoch: 0 | Step: 1 | batch x: [10. 3.] | batch y: [1. 8.]
Epoch: 1 | Step: 0 | batch x: [4. 8. 6. 7. 1. 3. 2. 9.] | batch y: [ 7. 3. 5. 4. 10. 8. 9. 2.]
Epoch: 1 | Step: 1 | batch x: [ 5. 10.] | batch y: [6. 1.]
Epoch: 2 | Step: 0 | batch x: [ 3. 5. 9. 7. 10. 4. 6. 1.] | batch y: [ 8. 6. 2. 4. 1. 7. 5. 10.]
Epoch: 2 | Step: 1 | batch x: [2. 8.] | batch y: [9. 3.]在 step=1 就只给你返回这个 epoch 中剩下的数据
优化器 Optimizer
SGD 是最普通的优化器, 也可以说没有加速效果, 而 Momentum 是 SGD 的改良版, 它加入了动量原则.
后面的 RMSprop 又是 Momentum 的升级版. 而 Adam 又是 RMSprop 的升级版.
不过从这个结果中我们看到, Adam 的效果似乎比 RMSprop 要差一点. 所以说并不是越先进的优化器, 结果越佳.
我们在自己的试验中可以尝试不同的优化器, 找到那个最适合你数据/网络的优化器.
import torch
import torch.utils.data as Data
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
#超参数
LR=0.01
BATCH_SIZE=32
EPOCH=12
#回归的数据
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))
# plt.scatter(x.numpy(),y.numpy())
# plt.show()
#定义一个数据库
torch_dataset=Data.TensorDataset(x,y)
loader=Data.DataLoader(
dataset=torch_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2,#工作进程
)
#建立神经网络
class Net(torch.nn.Module):
def __init__(self):
super(Net,self).__init__()
self.hidden=torch.nn.Linear(1,20)#隐藏层
self.predict=torch.nn.Linear(20,1)#输出层
def forward(self,x):
x=F.relu(self.hidden(x))
x=self.predict(x)
return x
#四个不同的神经网络
if __name__ == '__main__':
net_SGD = Net()
net_Momentum= Net()
net_RMSprop= Net()
net_Adam= Net()
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]
opt_SGD= torch.optim.SGD(net_SGD.parameters(), lr=LR)
opt_Momentum= torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
opt_RMSprop= torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
opt_Adam= torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
optimizers=[opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
#开始训练
loss_func = torch.nn.MSELoss()#回归的误差计算公式
losses_his = [[], [], [], []] # 记录 training 时不同神经网络的 loss
for epoch in range(EPOCH):
print('Epoch: ', epoch)
for step, (b_x, b_y) in enumerate(loader):
#将不同的神经网络拿出来一个一个的训练
for net, opt, l_his in zip(nets, optimizers, losses_his):
output = net(b_x) # 输入信息预测值
loss = loss_func(output, b_y) # 预测prediction和y的误差
opt.zero_grad() # 所有参数梯度降为0
loss.backward() # 反向传递，给每个神经网络节点计算出梯度
opt.step() # 优化梯度
l_his.append(loss.data.numpy())#将误差放到记录里面
#打印
labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
for i, l_his in enumerate(losses_his):
plt.plot(l_his, label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0, 0.2))
plt.show()
