操作
手写更新操作
for i in range(step):
Y_hat = conv2d(X)
l = ((Y_hat - Y) ** 2).sum()
l.backward() #只要参数都可求导那么都可以 backward
# 梯度下降
conv2d.weight.data -= lr * conv2d.weight.grad #nn.parameter.data 返回的是tensor
conv2d.bias.data -= lr * conv2d.bias.grad
# 梯度清0
conv2d.weight.grad.fill_(0)
conv2d.bias.grad.fill_(0)
if (i + 1) % 5 == 0:
print('Step %d, loss %.3f' % (i + 1, l.item())) #通过loss item返回python 数据类型
高维矩阵转置 Transpose 和 Permute
1.通过调用tensor.permute(对应维数)可以对任意高维矩阵进行转置.
2.transpose只能操作2D矩阵的转置,有两种调用方式:
torch.transpose(Tensor, 1, 0) tensor.transpose(q,0)
3.改变形状
torch.randn(10000,3,28,28)
x = torch.view(10000,2,784)
torch.text
可以生成处理text的数据集
检查GPU
torch.cuda.is_available
防止梯度爆炸
GRAD_CLIP为截断值 可以设置为 1.0
torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
保存和加载模型
# 保存和加载整个模型
torch.save(model_object, 'model.pkl')
model = torch.load('model.pkl')
# 仅保存和加载模型参数(推荐使用)
torch.save(model_object.state_dict(), 'params.pkl')
model_object.load_state_dict(torch.load('params.pkl'))
pytorch:torch.clamp()
添加链接描述
dropout防止过拟合
torch.nn.Dropout(0.5)
在测试的时候记得转化一下去掉dropout
net_overfitting.eval()
net_dropped.eval()
最后再变回来
net_overfitting.train()
net_dropped.train()
与numpy转化
x_torch = torch.from_numpy(x_numpy), x_torch.numpy()
- can’t convert CUDA tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.
- 对于require_grad = True的tensor
tensor.cpu().detach().numpy()
打印param
params = model.parameters()
for param in params:
print(param)
调节模型精度
Amp允许用户轻松地尝试不同的纯模式和混合精度模式。通过选择“优化级”或opt_level选择常用的默认模式;每个opt_level建立一组属性来管理Amp实现的纯或混合精度训练。通过将特定属性的值直接传递给amp.initialize,可以实现对给定opt_level行为方式的细粒度控制。这些手动指定的值覆盖opt_level建立的默认值。
from apex import amp
# Declare model and optimizer as usual, with default (FP32) precision
model = torch.nn.Linear(10, 100).cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
# Allow Amp to perform casts as required by the opt_level
model, optimizer = amp.initialize(model, optimizer, opt_level="O1")
...
# loss.backward() becomes:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
...
onehot实现
scatter(dim, index, src) 的参数有 3 个
dim:沿着哪个维度进行索引
index:用来 scatter 的元素索引
src:用来 scatter 的源元素,可以是一个标量或一个张量
def one_hot(x, n_class, dtype=torch.float32):
# X shape: (batch), output shape: (batch, n_class)
x = x.long()
res = torch.zeros(x.shape[0], n_class, dtype=dtype, device=x.device)
res.scatter_(1, x.view(-1, 1), 1)
return res
实例表示: 首先创建一个batch * n_class 的全零矩阵,之后在按行,将x指向的坐标填充为1
dataloader() shuffle=True 的作用
shuffle 是将数据全部打乱之后再划分batch的,不是划分好batch再打乱
nn.LSTM与nn.LSTMcell
nn.LSTM相当于将nn.LSTMcell进行了封装
nn.LSTMcell比较灵活相当于的nn.LSTM一个unit 需要自行不断迭代输入上一步的h与c
import torch
from torch import nn
# 一层的LSTM计算单元,输入的feature_len=100,隐藏单元和记忆单元hidden_len=20
cell = nn.LSTMCell(input_size=100, hidden_size=20)
# 初始化隐藏单元h和记忆单元C,取batch=3
h = torch.zeros(3, 20)
C = torch.zeros(3, 20)
# 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]
xs = [torch.randn(3, 100) for _ in range(10)]
# 对每个时刻,传入输入x_t和上个时刻的h_{t-1}和C_{t-1}
for xt in xs:
h, C = cell(xt, (h, C))
print(h.shape) # torch.Size([3, 20])
print(C.shape) # torch.Size([3, 20])
LSTM padding packed实现
def rnn_for(rnn,input,seq_length)
batch_first = rnn.batch_first
seq_lengths = seq_lengths[:,0]
packed_inputs = nn.utils.rnn.pack_padded_sequence(inputs,seq_lengths,batch_first=batch_first,enforce_sorted=True)
out,_ = rnn(packed_inputs)
unpacked, index = nn.utils.rnn.pad_packed_sequence(out,batch_first=True)
if rnn.bidirectional:
unpacked = unpacked[:,:,:rnn.hidden_size]+unpacked[:,:,rnn.hidden_size:]
index2 = index - torch.tensor([1]) #选取操作
index1 = torch.tensor(list(range(len(index2)))) #生成第一维度
return unpacked[index1,index2,:]
pytorch 随机数与 dtype
随机数
- torch.rand()
返回一个张量,包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义
torch.rand((4,5),dtype=torch.float)
tensor([[0.9346, 0.0891, 0.4820, 0.6237, 0.9688],
[0.7095, 0.9463, 0.9259, 0.9960, 0.3302],
[0.7502, 0.3764, 0.3279, 0.4506, 0.1402],
[0.1254, 0.4322, 0.1356, 0.4112, 0.8832]])
- torch.randn()
标准正态分布
torch.randn(*sizes, out=None) → Tensor
返回一个张量,包含了从标准正态分布(均值为0,方差为1)
-
torch.normal(means, std, out=None) → → Tensor
离散正态分布返回一个张量,包含了从指定均值means和标准差std的离散正态分布中抽取的一组随机数。
标准差std是一个张量,包含每个输出元素相关的正态分布标准差。
参数:-
means (float, optional) - 均值
-
std (Tensor) - 标准差
-
out (Tensor) - 输出张量
torch.normal(mean=0.5, std=torch.arange(1, 6)) -0.1505 -1.2949 -4.4880 -0.5697 -0.8996 [torch.FloatTensor of size 5]
-
-
torch.linspace(start, end, steps=100, out=None) → Tensor
线性间距向量
返回一个1维张量,包含在区间start和end上均匀间隔的step个点。
输出张量的长度由steps决定。
参数:
start (float) - 区间的起始点
end (float) - 区间的终点
steps (int) - 在start和end间生成的样本数
out (Tensor, optional) - 结果张量例子:
torch.linspace(3, 10, steps=5)
3.0000
4.7500
6.5000
8.2500
10.0000
[torch.FloatTensor of size 5]
dtype
技巧
1.在用random生成随机数进行训练时可以设置seed为相同,保证训练结果一样
2.对神经网络层参数进行初始化有时候可以使得训练效果跟优
nn.Linear(size).weight.data.normal_(0, 0.1)