pytorch常用函数

tensor.item()

item()用法是：一个元素张量可以用x.item()得到元素值

zero_()、zeros()、zeros_like()

zero_()：将矩阵中的元素全部变为0

>>> import torch
>>> torch.manual_seed(seed=20200910)
<torch._C.Generator object at 0x000002BCFF2CD330>
>>>
>>> a = torch.randn(3,4)
>>> b = a
>>> b
tensor([[ 0.2824, -0.3715,  0.9088, -1.7601],
        [-0.1806,  2.0937,  1.0406, -1.7651],
        [ 1.1216,  0.8440,  0.1783,  0.6859]])
>>> a
tensor([[ 0.2824, -0.3715,  0.9088, -1.7601],
        [-0.1806,  2.0937,  1.0406, -1.7651],
        [ 1.1216,  0.8440,  0.1783,  0.6859]])
>>>
>>> a.zero_()
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
>>> a
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
>>> b
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
>>>
>>>
>>>
>>>

zeros()：生成全零矩阵

# Importing the PyTorch library 
import torch 
  
  
# Applying the zeros function and 
# storing the resulting tensor in 't' 
a = torch.zeros([3, 4]) 
print("a = ", a) 

输出

a =  tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])

zeros_like()：生成一个与输入矩阵大小维度一致的全零矩阵，不改变输入矩阵的元素

import torch

if __name__ == "__main__":
    a = torch.arange(12).view((3,4))
    print("zeros_like",torch.zeros_like(a))
    print("a:",a)

选择计算设备

.to(device) 可以指定CPU 或者GPU

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # 单GPU或者CPU
model.to(device)
#如果是多GPU
if torch.cuda.device_count() > 1:
  model = nn.DataParallel(model，device_ids=[0,1,2])
model.to(device)

.cuda() 只能指定GPU

#指定某个GPU
os.environ['CUDA_VISIBLE_DEVICE']='1'
model.cuda()
#如果是多GPU
os.environment['CUDA_VISIBLE_DEVICES'] = '0,1,2,3'
device_ids = [0,1,2,3]
net  = torch.nn.Dataparallel(net, device_ids =device_ids)
net  = torch.nn.Dataparallel(net) # 默认使用所有的device_ids 
net = net.cuda()

torch.max()

torch.max(a,1)返回每一行中最大值的那个元素，且返回其索引（返回最大元素在这一行的列索引）

a = torch.randn(3,3)
>>
0.2252 -0.0901  0.5663
-0.4694  0.8073  1.3596
 0.1073 -0.7757 -0.8649
 
torch.max(a,1)
>>
(
 0.5663
 1.3596
 0.1073
[torch.FloatTensor of size 3]
, 
 2
 2
 0
[torch.LongTensor of size 3]
)

tensor.detach()

返回一个新的tensor，从当前计算图中分离下来的，但是仍指向原变量的存放位置,不同之处只是requires_grad为false，得到的这个tensor永远不需要计算其梯度，不具有grad。

即使之后重新将它的requires_grad置为true,它也不会具有梯度grad
这样我们就会继续使用这个新的tensor进行计算，后面当我们进行反向传播时，到该调用detach()的tensor就会停止，不能再继续向前进行传播

注意：

使用detach返回的tensor和原始的tensor共同一个内存，即一个修改另一个也会跟着改变。

Variable()

它封装了Tensor，并整合了反向传播的相关实现。tensor变成variable之后才能进行反向传播求梯度。
参考博文

nllloss

参考博文

torch.no_grad()

在使用pytorch时，并不是所有的操作都需要进行计算图的生成（计算过程的构建，以便梯度反向传播等操作）。而对于tensor的计算操作，默认是要进行计算图的构建的，在这种情况下，可以使用 with torch.no_grad():，强制之后的内容不进行计算图构建。

使用with torch.no_grad():

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))        
print(outputs)

不使用with torch.no_grad()时，此时计算结果有grad_fn=属性，表示，计算的结果在一计算图当中，可以进行梯度反传等操作。但是，两者计算的结果实际上是没有区别的。