1 Tensor 基本操作
-
Tensor与Numpy很相似，常用的操作如下
-
随机生产一个指定行列的矩阵,每个值都会介于0-1之间
import torch
x = torch.randn(5,3)
print(x)
- 生成一个指定行列的全零0/1矩阵
x = torch.ones(4,4)
y = torch.zeros(4,4)
print(x)
print(y)
- 生成与另一个矩阵有相同行数和列数的矩阵
z = torch.rand_like(x)
print(z)
- 生成与另一个矩阵有相同行数和列数的全1矩阵
z = torch.ones_like(x)
print(z)
- Tensor的运算
x = torch.ones(4,4,dtype=torch.long) #使得每一个值都为整数型
print(x.dtype)
x = torch.rand(5,3)
y = torch.randn_like(x)
z = x+y
print(z)
y.add(x)
print(y)
y.add_(x) #使用下划线之后y的值会变
print(y)
- Tensor与numpy相互转换
x = torch.ones(2,2)
y = x.numpy()
import numpy as np
a = np.ones((2,2))
b = torch.from_numpy(a)
2 torch构建神经网络
- 使用torch进行简单的两层神经网络构建
N, D_in,H,D_out = 64,1000,100,10 # N：样本数、D_in：样本维度、
# H：hidden layer的维度、D_out：输出的维度
x =torch.randn(N,D_in,requires_grad = True) #随机初始化样本
y = torch.randn(N,D_out,requires_grad= True) #随机初始化标签值
w1 = torch.randn(D_in,H,requires_grad =True) #初始化第一层权重矩阵
w2 = torch.randn(H,D_out,requires_grad = True) #初始化第二层权重矩阵
learning_rate = 1e-6
for t in range(500):
h = x@w1 #计算hidden layer的各个神经元
h_relu = h.clamp(min=0) #clamp:activation function夹在最大值和最小值之间
y_pred = h_relu@w2 #计算预测值
loss = (y_pred-y).pow(2).sum() #平方损失函数
print(t,loss.item()) # .item()是获取数值
loss.backward() #获取loss的所有梯度
with torch.no_grad():#可以减缓内存压力
w1 -= learning_rate*w1.grad
w2 -= learning_rate*w2.grad
w1.grad.zero_() #每次求完要清零，不然会接着上次的继续计算梯度
w2.grad.zero_()
- 使用torch,nn建立同样的神经网络
import torch.nn
N, D_in,H,D_out = 64,1000,100,10 # N：样本数、D_in：样本维度、
# H：hidden layer的维度、D_out：输出的维度
x =torch.randn(N,D_in,requires_grad = True) #随机初始化样本
y = torch.randn(N,D_out,requires_grad= True) #随机初始化标签值
model = torch.nn.Sequential(torch.nn.Linear(D_in,H),torch.nn.ReLU()
,torch.nn.Linear(H,D_out)) #第一层参数、激活函数、第二层参数
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-4
for t in range(500):
y_pred = model(x)
loss = loss_fn(y_pred,y)
print(t,loss.item())
loss.backward()
model.zero_grad() #清空梯度
with torch.no_grad():
for param in model.parameters():
param -= learning_rate*param #更新每一个参数
- torch提供的梯度下降函数
N,D_in,H,D_out = 64,1000,100,10
x = torch.rand(N,D_in,requires_grad=True)
y = torch.rand(N,D_out,requires_grad=True)
model = torch.nn.Sequential(torch.nn.Linear(D_in,H),torch.nn.ReLU()
,torch.nn.Linear(H,D_out))
optimizer = torch.optim.Adam(model.parameters(),lr = 1e-4)
loss_fn = nn.MESLoss(reduction='sum') #Mean Square Error
for t in range(500):
y_pred = model(X)
loss = loss_fn(y_pred,y)
print(t,loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step()
- 自己设置框架
import torch
import torch.nn as nn
#1.构建一个模型
class TwoLayerNet(torch.nn.Module):
#在__init__当中将每一个有导数的层都放在这里，也就是框架设置好
def __init__(self,D_in,H,D_out):
super(TwoLayerNet,self).__init__()
self.linear1 = torch.nn.Linear(D_in,H)
self.linear2 = torch.nn.Linear(H,D_out)
#前向传播的模型
def forward(self,x):
y_pred = self.linear2(self.linear1(x).clamp(min=0))
return y_pred
model = TwoLayerNet(D_in,H,D_out)
#2.定义一个lost function
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-4
#3.交给optim，找个优化方法
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
#4.进行训练，优化参数
for t in range(500):
y_pred =model(x)
loss = loss_fn(y_pred,y)
print(t,loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step() #一步到位
总结：
- Pytorch构建一个简单神经网络的流程如下：
- 首先准备好输入和输出
- 定义一个框架
class TwoLayerNet(torch.nn.Module):
#在__init__当中将每一个有导数的层都放在这里，也就是框架设置好
def __init__(self,D_in,H,D_out):
super(TwoLayerNet,self).__init__()
self.linear1 = torch.nn.Linear(D_in,H)
self.linear2 = torch.nn.Linear(H,D_out)
#前向传播的模型
def forward(self,x):
y_pred = self.linear2(self.linear1(x).clamp(min=0))
return y_pred
model = TwoLayerNet(D_in,H,D_out)
- 定义一个损失函数
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-4
- 定义一个优化方法
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
- 进行训练（获取一个y_pred -> 计算损失 -> 获得所有梯度 -> 优化 ->清除当前梯度）
for t in range(500):
y_pred =model(x)
loss = loss_fn(y_pred,y)
print(t,loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step() #一步到位