pytorch——操作（完善中）

操作

手写更新操作

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()

1. can’t convert CUDA tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.
2. 对于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

随机数

1. 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]])

2. torch.randn()
   标准正态分布
   torch.randn(*sizes, out=None) → Tensor

返回一个张量，包含了从标准正态分布（均值为0，方差为1)

3. torch.normal(means, std, out=None) → → Tensor
   离散正态分布

   返回一个张量，包含了从指定均值means和标准差std的离散正态分布中抽取的一组随机数。

   标准差std是一个张量，包含每个输出元素相关的正态分布标准差。
   参数:

   1. means (float, optional) - 均值

   2. std (Tensor) - 标准差

   3. 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]
      

4. 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

记得加上torch！！！

thanks
thanks

技巧

1.在用random生成随机数进行训练时可以设置seed为相同，保证训练结果一样

2.对神经网络层参数进行初始化有时候可以使得训练效果跟优

nn.Linear(size).weight.data.normal_(0, 0.1)