目录
1.pytorch基本知识
1、tensor的定义
2、tensor与numpy的相互转换
3、tensor使用cuda加速
4、Variable的使用
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 8 16:40:47 2019
pytorch快速入门教程
参考书籍:《深度学习框架pytorch:入门与实践》
@author: xiaoxiaoke
"""
import torch as t
import numpy as np
#####################1Tensor的基础使用###########
#1.1、构建5*3的矩阵,未分配空间进行初始化
x1=t.Tensor(5,3)
print(x1)
#1.2、使用[0 1]的均匀分布随机初始化二维数组
x2=t.rand(5,3)
print(x2)
#1.3、查看矩阵的形状
print(x2.shape)
print(x2.size())#等价写法
#1.4、tensor 的加法
y=t.rand(5,3)
z=y+x1
print(z)
y2=t.add(y,x1)#加法的等价写法
print(y2)
y2.add_(100)
print(y2)
#注释:add_与add的不同
# add_ 以_进行结尾,函数会修改对象本身的值
# add的语法则是等式形式
########################2、Tensor与numpy的结合###########################
#tensor不支持的操作可以先转为numpy,操作之后在转为tensor进行操作
#2.1、tensor转换为numpy
a_tensor=t.ones(5)
print(a_tensor)
b_np=a_tensor.numpy()#tensor—>numpy
print(b_np)
#2.2、将numpy转换为tensor
c_np=np.ones(5)
print(c_np)
d_tensor=t.from_numpy(c_np)#numpy->tensor
print(d_tensor)
#注意:tensor与numpy之间的转换,对象共享内存!!
# 内存共享意味着二者之间的转换会很快,
# 但是同时意味着一方的值改变之后,另外一方的值也会随之更改。
#验证如下:
a_tensor.add_(1000)
print("内存共享:",a_tensor)
print("内存共享:",b_np)
##################3、tensor可以使用CUDA加速######################
if t.cuda.is_available():
y=y.cuda()
y2=y2.cuda()
print(x+y2)
#####################4、Autograd:自动微分#######################
#autograd.Veribale是Autograd中的核心类,封装了tensor之后,可以调用backward实现自动计算反向梯度
from torch.autograd import Variable
x_var=Variable(t.ones(2,2),requires_grad=True)
print(x_var)
y_var=x_var.sum()
print(y_var)
print(y_var.grad_fn)
y_var.backward()
print("第一次反向传播",x_var.grad)
y_var.backward()
print("第二次反向传播",x_var.grad)
# 注意:grad在反向传播的过程中是累加的,深度学习是多层神经网络,在每次反向传播结束之后会累加上次的结果。
# 基于上述原因,训练过程中会在首次反向传播之前将梯度置为零。
#将梯度置为零
x_var.grad.data.zero_()
print(x_var.grad)
y_var.backward()
print("置零之后反向传播",x_var.grad)
2.回归模型
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import time
import numpy as np
# =============================================================================
# 利用三层神经网络对带有噪声的正弦信号进行回归拟合
# =============================================================================
#准备数据(unsqueeze 一维转成二维)
start=time.time()
X = torch.unsqueeze(torch.linspace(-2.5, 2.5, 200), dim=1) # x (tensor)(200, 1)
y = X.sin() + 0.2*torch.rand(X.size()) # y (tensor)(200, 1)
#定义三层神经网络模型
class Net(torch.nn.Module):
def __init__(self,n_input,n_hidden,n_output):
super(Net,self).__init__()#继承
self.hidden=torch.nn.Linear(n_input,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
#设置网络节点数,损失函数和优化方法
net=Net(n_input=1,n_hidden=10,n_output=1)
loss_func=torch.nn.MSELoss()
optimizer=torch.optim.SGD(net.parameters(),lr=0.2)
loss_List=[]
for t in range(150):
prediction=net(X)
loss=loss_func(prediction,y)
loss_List.append(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
#训练过程和损失函数的可视化
if t % 1 == 0:
plt.figure(1)
plt.subplot(211)
plt.cla()
plt.scatter(X.data.numpy(), y.data.numpy())
plt.text(-2.1, 1.2,'time:%d' % t, fontdict={'size':20, 'color':'green'})
plt.plot(X.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
plt.text(-0.9, 1.2,'Loss=%.4f' %loss.data.numpy(),fontdict={'size':20, 'color':'red'})
plt.xlim((-2.5,2.5))
plt.ylim((-1.9,1.9))
plt.pause(0.1)
plt.title('data')
plt.subplot(212)
plt.cla()
plt.plot(range(0,t+1), loss_List,'b-')
plt.title('loss')
plt.xlabel('epoch')
plt.ylabel('MSELoss')
end=time.time()
print("共用时%.2fs"%(end-start))
3.分类模型
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt
import time
import numpy as np
# =============================================================================
# 利用三层神经网络对带有噪声的正弦信号进行回归拟合
# =============================================================================
# 数据
n_data = torch.ones(500, 2) # 数据的基本形态
x0 = torch.normal(2*n_data, 1) # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(500) # 类型0 y data (tensor), shape=(100, )
x1 = torch.normal(-2*n_data, 1) # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(500) # 类型1 y data (tensor), shape=(100, )
# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1)).type(torch.FloatTensor) # FloatTensor = 32-bit floating
y = torch.cat((y0, y1)).type(torch.LongTensor) # LongTensor = 64-bit integer
# 画图
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
print(net)
# optimizer 训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02) # 传入 net 的所有参数, 学习率
loss_func = torch.nn.CrossEntropyLoss()
for t in range(50):
out = net(x) # 喂给 net 训练数据 x, 输出分析值
loss = loss_func(out, y) # 计算两者的误差
optimizer.zero_grad() # 清空上一步的残余更新参数值
loss.backward() # 误差反向传播, 计算参数更新值
optimizer.step() # 将参数更新值施加到 net 的 parameters 上
# 画图
plt.ion()
plt.show()
if t % 2 == 0:
plt.cla()
prediction = torch.max(F.softmax(out), 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 = sum(pred_y == target_y)/1000. # 预测中有多少和真实值一样
plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'})
plt.pause(0.1)
plt.ioff() # 停止画图
plt.show()
4.快速搭建法
net = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)
5.参考资料
1.莫烦python:https://morvanzhou.github.io/tutorials/machine-learning/torch/3-02-classification/