这里是pytorch学习笔记。

创建操作

torch.randn()

1
torch.randn(*size,out = None)
  • 输入：
    • size(int)：指定了输出张量的形状
  • 输出：输出结果为张量
  • 作用：返回一个张量，从标准正态分布中抽取一组随机数。形状由*size决定

张量维度操作

转置：transpose

1
torch.transpose(input,dim0,dim1)
  • 参数：
    • input: 输入张量，可以是二维及二维以上的张量
    • dim0,dim1: 要转置的两个维度。
  • 作用： 返回输入矩阵的转置。一次只能转置张量的两个维度。输出张量与输入张量共享内存，同步改变。
1
torch.t(tensor)

输入一个二维张量（矩阵），并转置0,1维。可以看做函数torch.transpose(input,0,1)的简写函数。
比较下transpose与view这两个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
>> a = torch.randn(2,3,5)
>> b = torch.transpose(a,1,2)
>> c = a.view(2,5,3)
>> print(a)
tensor([[[ 0.9926, -0.1669, -1.6571, -0.2730, -0.1313],
         [ 0.9811, -1.9854,  1.5519,  0.1383,  1.4571],
         [ 0.8221, -1.1283, -0.7675, -2.0497,  0.4748]],

        [[ 0.1594,  0.7166, -0.2603,  1.1027,  1.5283],
         [-0.7652, -1.4711,  0.5077,  0.6639,  0.0374],
         [ 1.8121, -1.4864, -2.9863, -0.5769, -0.2915]]]) 
>> print(b)
tensor([[[ 0.9926,  0.9811,  0.8221],
         [-0.1669, -1.9854, -1.1283],
         [-1.6571,  1.5519, -0.7675],
         [-0.2730,  0.1383, -2.0497],
         [-0.1313,  1.4571,  0.4748]],

        [[ 0.1594, -0.7652,  1.8121],
         [ 0.7166, -1.4711, -1.4864],
         [-0.2603,  0.5077, -2.9863],
         [ 1.1027,  0.6639, -0.5769],
         [ 1.5283,  0.0374, -0.2915]]]) 
>> print(c)
tensor([[[ 0.9926, -0.1669, -1.6571],
         [-0.2730, -0.1313,  0.9811],
         [-1.9854,  1.5519,  0.1383],
         [ 1.4571,  0.8221, -1.1283],
         [-0.7675, -2.0497,  0.4748]],

        [[ 0.1594,  0.7166, -0.2603],
         [ 1.1027,  1.5283, -0.7652],
         [-1.4711,  0.5077,  0.6639],
         [ 0.0374,  1.8121, -1.4864],
         [-2.9863, -0.5769, -0.2915]]])

可以看到:二者得到的结果并不相同。transpose是进行转置操作。view对张量整形时，张量中元素的顺序保持不变。相当于将这个三维张量按顺序

torch.Tensor

torch.manual_seed()

1
torch.manual_seed(seed)
  • 输入：
    • seed(int or long)：设定种子，为int类型或long类型
  • 作用：设定生成随机数的种子。种子相同，生成的随机数就是相同的，实验结果就可以复现。

参见：利用随机数种子来使pytorch中的结果可以复现

.view() 整形

1
tensor.view(*size)
  • 输入：
    • *size(int)：指定了输出张量的形状
  • 输出：输出结果为张量
  • 作用：整形，只改变原张量的形状，形状由*size指定。

例子：

1
2
3
4
5
6
7
8
9
>> x = torch.randn(5,4)
>> x.size()
torch.Size([5,4]
>> x.view(30)
>> x.size()
torch.Size([20])
>> x.view(1,1,-1) # -1表示该维度由其他的维度推断。
>> x.size()
torch.Size([1, 1, 20])

torch.cat() 连接

1
torch.cat(inputs,dimension = 0)
  • 输入：
    • inputs(sequence of Tensors)： 多个Tensor的python序列。 如[tensor1,tensor2…]或(Tensor1，tensor2)
    • dimension(int,optional): 沿着该维连接张量序列。默认为0。
  • 作用：在指定维度上，对输入张量序列进行连接操作。

举个例子：

1
2
3
4
5
6
7
8
9
10
>> impotr torch 
>> x = torch.randn(4,3)
>> x.size()
torch.Size([4, 3])
>> y = torch.cat((x,x,x),0)
>> y.size()
torch.Size([12, 3])
>> z = torch.cat((x,x,x),1)
>> z.size() 
torch.Size([4, 9])

torch.optim

class torch.optim.SGD(params,lr=,momentum=0,weight_decay=0)

  • 参数：
    • params： 待优化参数的iterable
    • lr(float): 学习率
    • momentum(float,可选)： 动量因子，默认为0
    • weight_decay(float,可选): 权重衰减，默认为0
  • 作用：实现随机梯度下降算法。

如何使用optimizer?

1
2
3
4
5
6
7
8
9
import torch.optim as optim 

optimizer = optim.SGD(model.parameters(),lr = 0.01) #构建一个optimizer,model.parameters()给出了所有要优化的参数
for input,target in dataset:
    optimizer.zero_grad() #清空所有被优化过的Variable的梯度
    output = model(input)
    loss = loss_fn(output,target)
    loss.backward()  #反向传播算法，计算好所有要优化Variable的梯度。
    optimizer.step() #单步优化，基于计算得到的梯度进行参数更新。