pyTorch入门：numpy与Tensor_pytouch numpy tensor

python 深度学习，基于pytorch 的学习笔记，，

numpy 复习

1. 使用np.random 生成随机数组
   

• np.random.choice()

import numpy as np 
from numpy import random as nr 
a=np.arange(1,25,dtype=float) 
c1=nr.choice(a,size=(3,4)) #size指定输出数组形状 
c2=nr.choice(a,size=(3,4),replace=False) #replace缺省为True，即可重复抽取。 
#下式中参数p指定每个元素对应的抽取概率，不设置就是每个元素被抽取的概率相同。 
c3=nr.choice(a,size=(3,4),p=a / np.sum(a)) 
1
2
3
4
5
6
7

2. 构建数组
   

• np.savetxt( X=data, fname=’./test1.txt’) 保持数据到文本
• data = np.loadtxt(’./test.txt’)

3. 改变数组形状

arr =np.arange(6).reshape(2, -1)
print(arr)
print("按照列优先，展平") 
print(arr.ravel('F'))   
print("按照行优先，展平") 
print(arr.ravel()) 
输出结果： 
[[0 1 2] 
[3 4 5]] 
按照列优先，展平 
[0 3 1 4 2 5] 
按照行优先，展平 
[0 1 2 3 4 5]

# flatten 将矩阵转为向量，通常在卷积网络与全连接层之间
a =np.floor(10*np.random.random((3,4)))
print(a.flatten())

[[4. 0. 8. 5.] 
[1. 0. 4. 8.] 
[8. 2. 3. 7.]] 

[4. 0. 8. 5. 1. 0. 4. 8. 8. 2. 3. 7.]

# squeeze降维的
arr =np.arange(3).reshape(3, 1) 
print(arr.shape) #(3,1) 
print(arr.squeeze().shape) #(3,) 
arr1 =np.arange(6).reshape(3,1,2,1) 
print(arr1.shape) #(3, 1, 2, 1) 
print(arr1.squeeze().shape) #(3, 2)

# transpose 轴转换，深度学习中可以用来吧图片从 RGB -> GBR
arr2 = np.arange(24).reshape(2,3,4) 
print(arr2.shape) #(2, 3, 4) 
print(arr2.transpose(1,2,0).shape) #(3, 4, 2)
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
36

4. 数组合并
   

• append concatenate stack 都有一个 axis 参数，控制数组的合并方式是按行还是按列
• 合并是注意两者的形状要匹配。

a =np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

c = np.concatenate((a, b), axis=0)    # 跨行
print(c)
d = np.concatenate((a, b.T), axis=1)
print(d)

[[1 2]
 [3 4]
 [5 6]]
[[1 2 5]
 [3 4 6]]

a =np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(np.stack((a, b), axis=0))       # 这个是按指定轴堆叠数组或矩阵
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]   # 维数是不一样的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5. 批量处理

随机梯度下降法嘛，，SGD。分批次处理

#生成10000个形状为2X3的矩阵
data_train = np.random.randn(10000,2,3)
#这是一个3维矩阵，第一个维度为样本数，后两个是数据形状
print(data_train.shape)
#(10000,2,3)
#打乱这10000条数据
np.random.shuffle(data_train)
#定义批量大小
batch_size=100
#进行批处理
for i in range(0,len(data_train),batch_size):
    x_batch_sum=np.sum(data_train[i:i+batch_size])        # 批处理数据集
    print("第{}批次,该批次的数据之和:{}".format(i,x_batch_sum))
1
2
3
4
5
6
7
8
9
10
11
12
13

6. 通用函数
   

7. 广播机制

Tensor

与numpy 相似，可以是零维，多维数组，并共享内存，区别就是Tensor 可以放到GPU 中加速计算。

针对 Tensor 的操作，按照接口划分：

• torch.function，比如 torch.sum torch.add(x,y) ( 等价于 x.add(y))
• tensor.function 比如 tensor.view,tensor.add

针对修改方式：

• 不修改自身数据：x.add(y) x不变，返回一个新的Tensor
• 修改自身数据：x.add_(y) 修改x

x=torch.tensor([1,2])
y=torch.tensor([3,4])
z=x.add(y)
print(z)
print(x)
x.add_(y)
print(x)

tensor([4, 6])
tensor([1, 2])
tensor([4, 6])
1
2
3
4
5
6
7
8
9
10
11

1. 创建：

torch.Tensor([1,2,3,4,5,6])
torch.Tensor(2,3)
t=torch.Tensor([[1,2,3],[4,5,6]])
t.size(),t.shape                # shape 与 size 等价
>>> (torch.Size([2, 3]), torch.Size([2, 3]))

torch.Tensor(t.size())       # 根据已有形状创建
>>> 
tensor([[0., 0., 0.],
        [0., 0., 0.]])


# torch.Tensor and  torch.tensor 的区别

t1 = torch.Tensor(1)
t2= torch.tensor(1)
print(t1,t1.type(),t2,t2.type())  # Tensor使用默认的dtype(FloatTensor) .tensor从数据中推断类型
>>> tensor([7.3447e-16]) torch.FloatTensor tensor(1) torch.LongTensor 
 # tensor(1)返回一个固定值1，而Tensor() 返回的是大小为 1 的随机张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 修改形状

x = torch.randn(2, 3)
x.size()   
>>> torch.Size([2, 3])

#查看x的维度
x.dim()    #结果为2
#把x变为3x2的矩阵
x.view(3,2)
#把x展平为1维向量
y=x.view(-1)  
y.shape   >>> torch.Size([6])
#添加一个维度
z=torch.unsqueeze(y,0)
#查看z的形状
z.size()   #结果为torch.Size([1, 6])
#计算Z的元素个数
z.numel()   #结果为6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

torch.view and torch.reshape 的区别：

• reshape（）可以由，torch.reshape() or torch.Tensor.reshape() 调用。但 view() 只能由 torch.Tensor.view() 调用。
• 对一个要被view 的 Tensor，新的size 必须与原来的 size与 stride 兼容，否则在之前调用contiguous 方法（）
• 只想重塑张量，使用torch.reshape ，如果还关注内存的使用并确保两个张量共享相同的数据，使用torch.view。

3. 索引操作

索引操作与numpy类似，一般来说 索引结果与源数据共享内存。索引还可以通过一些函数

torch.manual_seed(100)   # 一个随机种子
x = torch.randn(2,3)
x
>>> 
tensor([[ 0.3607, -0.2859, -0.3938],
        [ 0.2429, -1.3833, -2.3134]])


x[1,1:]  # >>> tensor([-1.3833, -2.3134])
x[:,-1] # >>> tensor([-0.3938, -2.3134])
mask=x>0      # 生成是否大于零的 Byter 张量
# tensor([[ True, False, False],   mask
#         [ True, False, False]])


torch.masked_select(x,mask)  # >>> tensor([0.3607, 0.2429]) 大于零的值
torch.nonzero(mask)  
# tensor([[0, 0],          # 非零下标，就是行，列的索引。
#         [1, 0]])

torch.index_select(x,1,torch.tensor([0,2]))     # 指定维度的跨行索引。。
>>>
tensor([[ 0.3607, -0.3938],
        [ 0.2429, -2.3134]])

#获取指定索引对应的值,输出根据以下规则得到
#out[i][j] = input[index[i][j]][j]  # if dim == 0  对行的操作
#out[i][j] = input[i][index[i][j]]  # if dim == 1  对列的操作,,啥玩意。。
index=torch.LongTensor([[0,1,1],[1,1,1]])
a=torch.gather(x,1,index)
a
>>>
tensor([[ 0.3607, -0.2859, -0.2859],
        [-1.3833, -1.3833, -1.3833]])

#把a的值返回到一个2x3的0矩阵中
z=torch.zeros(2,3)
torch.scatter(z,1,index,a)            # 顶层没有scratter_() 方法
z.scatter_(1,index,a)          
>>>
tensor([[ 0.3607, -0.2859,  0.0000],  # 对指定索引补充数据，，这又是啥。。
        [ 0.0000, -1.3833,  0.0000]])
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
36
37
38
39
40
41
42

torch.gather 脑补连接
语言处理中，给每个单词上一个标签，现在我们有四个句子（由单词标签构成的不同长度的句子）：

input = [
[2, 3, 4, 5],
[1, 4, 3],
[4, 2, 2, 5, 7],
[1]
]
进行填充，padding

input = [
[2, 3, 4, 5, 0, 0],
[1, 4, 3, 0, 0, 0],
[4, 2, 2, 5, 7, 0],
[1, 0, 0, 0, 0, 0]
]
现在要从填充后的input 中选出最后一个单词的标签。

input = [
    [2, 3, 4, 5, 0, 0],
    [1, 4, 3, 0, 0, 0],
    [4, 2, 2, 5, 7, 0],
    [1, 0, 0, 0, 0, 0]
]
input = torch.tensor(input)  # 在指定维度上选择数据，输出的形状与 Index(LongTensor类型） 一致。
#注意index的类型 ，
# 将input的第i维的大小更改为y，且要满足y>=1（除了第i维之外的其他维度，大小要和input保持一致）
length = torch.LongTensor([[3],[2],[4],[0]])       # 学废了吗
out = torch.gather(input, 1, length)
out
tensor([[5],
        [3],
        [7],
        [1]])

length = torch.LongTensor([[3,0],[2,0],[4,0],[0,0]])
out = torch.gather(input, 1, length)
out
tensor([[5, 2],
        [3, 1],
        [7, 4],
        [1, 1]])

length = torch.LongTensor([[2,3]])   # 前两行的第三个，第四个元素
out = torch.gather(input, 0, length)
out
tensor([[4, 0]])
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

torch.scatter 脑部链接

就是把input数组中的数据进行重新分配。index中表示了要把原数组中的数据分配到output数组中的位置，如果未指定，则填充0。就是index 中的是index 中元素在 output 中的位置。

不一定所有的input数据都会分到output中，output也不是所有位置都有对应的input，当output中没有对应的input时，自动填充0。

一般scatter用于生成onehot向量，

index = torch.tensor([[1], [2], [0], [3]])
onehot = torch.zeros(4, 4)
onehot.scatter_(1, index, 1)
print(onehot)
1
2
3
4
5

tensor([[0., 1., 0., 0.],
[0., 0., 1., 0.],
[1., 0., 0., 0.],
[0., 0., 0., 1.]])

4. 广播机制

A = np.arange(0, 40,10).reshape(4, 1)
B = np.arange(0, 3)
#把ndarray转换为Tensor
A1=torch.from_numpy(A)  #形状为4x1
B1=torch.from_numpy(B)  #形状为3
print(A1.shape,B1.size())
#Tensor自动实现广播
C=A1+B1     # torch.Size([4, 1]) torch.Size([3]) -> 4,3
print(C)

#我们可以根据广播机制，手工进行配置
#根据规则1，B1需要向A1看齐，把B变为（1,3）
B2=B1.unsqueeze(0)  #B2的形状为1x3
#使用expand函数重复数组，分别的4x3的矩阵
A2=A1.expand(4,3)
B3=B2.expand(4,3)
#然后进行相加,C1与C结果一致
C1=A2+B3
print(C1)

>>>
torch.Size([4, 1]) torch.Size([3])
tensor([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32]], dtype=torch.int32)
tensor([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32]], dtype=torch.int32)
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

5. 逐元素操作

大多逐元素操作与numpy 类似，如果需要就地操作，可以在后面加个下划线 add_()

感受到了np 之处。。

t = torch.randn(1, 3)
t1 = torch.randn(3, 1)
t2 = torch.randn(1, 3)
#t+0.1*(t1/t2)
torch.addcdiv(t, 0.1, t1, t2)
#计算sigmoid
torch.sigmoid(t)
#将t限制在[0,1]之间
torch.clamp(t,0,1)
#t+2进行就地运算
t.add_(2)
1
2
3
4
5
6
7
8
9
10
11

6. 归并操作

对输入进行归并或合计等操作。。归并操作可以针对整个 Tensor or 针对某一个 axis

各种范数

归并操作一般有一个 dim 参数，指定在那个维度进行归并，keepdim 决定是否要保留维度1.默认不保留

a=torch.linspace(0,10,6)
a=a.view((2,3))
#沿y轴方向累加，即dim=0
b=a.sum(dim=0)   #b的形状为[3]  ,等于  a.sum(axis=0) 对列操作
>>> tensor([ 6., 10., 14.])
#沿y轴方向累加，即dim=0,并保留含1的维度
b=a.sum(dim=0,keepdim=True) #b的形状为[1,3]
>>>tensor([[ 6., 10., 14.]])
1
2
3
4
5
6
7
8

7. 比较操作

一般是逐元素比较，有些是按指定方向比较

x=torch.linspace(0,10,6).view(2,3)
#求所有元素的最大值
torch.max(x)   #结果为10
#求y轴方向的最大值
torch.max(x,dim=0)  #结果为[6,8,10]
>>>
torch.return_types.max(
values=tensor([ 6.,  8., 10.]),     # 专业
indices=tensor([1, 1, 1]))

#求最大的2个元素
torch.topk(x,2,dim=0)  
>>>
torch.return_types.topk(
values=tensor([[ 6.,  8., 10.],
               [ 0.,  2.,  4.]]),
indices=tensor([[1, 1, 1],
                [0, 0, 0]]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8. 矩阵操作

• Torch的 dot 是对两个 一维的点积运算，mm 才是2D 的矩阵的点积运算，bmm 3D点积。numpy中的dot 没有限制

a=torch.tensor([2, 3])
b=torch.tensor([3, 4])
torch.dot(a,b) 
tensor(18)

x=torch.randint(10,(2,3))
y=torch.randint(6,(3,4))
torch.mm(x,y)
tensor([[36, 77, 81, 41],
        [45, 63, 69, 42]])

x=torch.randint(10,(2,2,3))
y=torch.randint(6,(2,3,4))
torch.bmm(x,y)
(tensor([[[1, 8, 9],
          [0, 0, 6]],
 
         [[2, 4, 8],
          [0, 4, 3]]]),
 tensor([[[0, 2, 2, 0],
          [0, 1, 1, 5],
          [1, 5, 5, 0]],
 
         [[4, 2, 0, 1],
          [4, 5, 3, 3],
          [4, 0, 5, 1]]]))

tensor([[[ 9, 55, 55, 40],
         [ 6, 30, 30,  0]],     # 就是两个二维矩阵的点乘。。然后stack 堆叠起来

        [[56, 24, 52, 22],
         [28, 20, 27, 15]]])
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