pytorch Tensor的操作和Numpy之间的转化（三）

tensor中的比较

比较函数中有一些是逐元素比较，操作类似于逐元素操作，还有一些则类似于归并操作。常用比较函数如表3-6所示。

常用比较函数

函数	功能
gt/lt/ge/le/eq/ne	大于/小于/大于等于/小于等于/等于/不等
topk	最大的k个数
sort	排序
max/min	比较两个tensor最大最小值

表中第一行的比较操作已经实现了运算符重载，因此可以使用a>=b、a>b、a!=b、a==b，其返回结果是一个ByteTensor，可用来选取元素。max/min这两个操作比较特殊，以max来说，它有以下三种使用情况：

t.max(tensor)：返回tensor中最大的一个数
t.max(tensor,dim)：指定维上最大的数，返回tensor和下标
t.max(tensor1, tensor2): 比较两个tensor相比较大的元素

至于比较一个tensor和一个数，可以使用clamp函数。下面举例说明。

import pytorch as t
a = t.linspace(0, 15, 6).view(2, 3)
a

tensor([[  0.,   3.,   6.],
        [  9.,  12.,  15.]])

b = t.linspace(15, 0, 6).view(2, 3)
b

tensor([[ 15.,  12.,   9.],
        [  6.,   3.,   0.]])

a>b

tensor([[ 0,  0,  0],
        [ 1,  1,  1]], dtype=torch.uint8)

a[a>b] # a中大于b的元素

tensor([  9.,  12.,  15.])

t.max(a)

tensor(15.)

t.max(b, dim=1) 
# 第一个返回值的15和6分别表示第0行和第1行最大的元素
# 第二个返回值的0和0表示上述最大的数是该行第0个元素

(tensor([ 15.,   6.]), tensor([ 0,  0]))

t.max(a,b)

tensor([[ 15.,  12.,   9.],
        [  9.,  12.,  15.]])

# 比较a和10较大的元素
t.clamp(a, min=10)

tensor([[ 10.,  10.,  10.],
        [ 10.,  12.,  15.]])

Tensor和Numpy

Tensor和Numpy数组之间具有很高的相似性，彼此之间的互操作也非常简单高效。需要注意的是，Numpy和Tensor共享内存。由于Numpy历史悠久，支持丰富的操作，所以当遇到Tensor不支持的操作时，可先转成Numpy数组，处理后再转回tensor，其转换开销很小。

import numpy as np
a = np.ones([2, 3],dtype=np.float32)
a

array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)

b = t.from_numpy(a)
b

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

b = t.Tensor(a) # 也可以直接将numpy对象传入Tensor
b

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

a[0, 1]=100
b

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

c = b.numpy() # a, b, c三个对象共享内存
c

array([[  1., 100.,   1.],
       [  1.,   1.,   1.]], dtype=float32)

注意：当numpy的数据类型和Tensor的类型不一样的时候，数据会被复制，不会共享内存。

a = np.ones([2, 3])
# 注意和上面的a的区别（dtype不是float32）
a.dtype

dtype('float64')

b = t.Tensor(a) # 此处进行拷贝，不共享内存
b.dtype

torch.float32

c = t.from_numpy(a) # 注意c的类型（DoubleTensor）
c

tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.]], dtype=torch.float64)

a[0, 1] = 100
b # b与a不共享内存，所以即使a改变了，b也不变

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

c # c与a共享内存

tensor([[   1.,  100.,    1.],
        [   1.,    1.,    1.]], dtype=torch.float64)

注意： 不论输入的类型是什么，t.tensor都会进行数据拷贝，不会共享内存

tensor = t.tensor(a)

tensor[0,0]=0
a

array([[  1., 100.,   1.],
       [  1.,   1.,   1.]])

广播法则(broadcast)是科学运算中经常使用的一个技巧，它在快速执行向量化的同时不会占用额外的内存/显存。
Numpy的广播法则定义如下：

让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分通过在前面加1补齐
两个数组要么在某一个维度的长度一致，要么其中一个为1，否则不能计算
当输入数组的某个维度的长度为1时，计算时沿此维度复制扩充成一样的形状

PyTorch当前已经支持了自动广播法则，但是笔者还是建议读者通过以下两个函数的组合手动实现广播法则，这样更直观，更不易出错：

unsqueeze或者view，或者tensor[None],：为数据某一维的形状补1，实现法则1
expand或者expand_as，重复数组，实现法则3；该操作不会复制数组，所以不会占用额外的空间。

注意，repeat实现与expand相类似的功能，但是repeat会把相同数据复制多份，因此会占用额外的空间。

a = t.ones(3, 2)
b = t.zeros(2, 3,1)

# 自动广播法则
# 第一步：a是2维,b是3维，所以先在较小的a前面补1 ，
#               即：a.unsqueeze(0)，a的形状变成（1，3，2），b的形状是（2，3，1）,
# 第二步:   a和b在第一维和第三维形状不一样，其中一个为1 ，
#               可以利用广播法则扩展，两个形状都变成了（2，3，2）
a+b

tensor([[[ 1.,  1.],
         [ 1.,  1.],
         [ 1.,  1.]],

        [[ 1.,  1.],
         [ 1.,  1.],
         [ 1.,  1.]]])

# 手动广播法则
# 或者 a.view(1,3,2).expand(2,3,2)+b.expand(2,3,2)
a[None].expand(2, 3, 2) + b.expand(2,3,2)

tensor([[[ 1.,  1.],
         [ 1.,  1.],
         [ 1.,  1.]],

        [[ 1.,  1.],
         [ 1.,  1.],
         [ 1.,  1.]]])

# expand不会占用额外空间，只会在需要的时候才扩充，可极大节省内存
e = a.unsqueeze(0).expand(10000000000000, 3,2)

内部结构

tensor的数据结构如图所示。tensor分为头信息区(Tensor)和存储区(Storage)，信息区主要保存着tensor的形状（size）、步长（stride）、数据类型（type）等信息，而真正的数据则保存成连续数组。由于数据动辄成千上万，因此信息区元素占用内存较少，主要内存占用则取决于tensor中元素的数目，也即存储区的大小。

一般来说一个tensor有着与之相对应的storage, storage是在data之上封装的接口，便于使用，而不同tensor的头信息一般不同，但却可能使用相同的数据。下面看两个例子。

在这里插入图片描述

a = t.arange(0, 6)
a.storage()

 0.0
 1.0
 2.0
 3.0
 4.0
 5.0
[torch.FloatStorage of size 6]

b = a.view(2, 3)
b.storage()

 0.0
 1.0
 2.0
 3.0
 4.0
 5.0
[torch.FloatStorage of size 6]

# 一个对象的id值可以看作它在内存中的地址
# storage的内存地址一样，即是同一个storage
id(b.storage()) == id(a.storage())

True

# a改变，b也随之改变，因为他们共享storage
a[1] = 100
b

tensor([[   0.,  100.,    2.],
        [   3.,    4.,    5.]])

c = a[2:] 
c.storage()

 0.0
 100.0
 2.0
 3.0
 4.0
 5.0
[torch.FloatStorage of size 6]

c.data_ptr(), a.data_ptr() # data_ptr返回tensor首元素的内存地址
# 可以看出相差8，这是因为2*4=8--相差两个元素，每个元素占4个字节(float)

(93894489135160, 93894489135152)

c[0] = -100 # c[0]的内存地址对应a[2]的内存地址
a

tensor([   0.,  100., -100.,    3.,    4.,    5.])

d = t.Tensor(c.storage())
d[0] = 6666
b

tensor([[ 6666.,   100.,  -100.],
        [    3.,     4.,     5.]])

# 下面４个tensor共享storage
id(a.storage()) == id(b.storage()) == id(c.storage()) == id(d.storage())

True

a.storage_offset(), c.storage_offset(), d.storage_offset()

(0, 2, 0)

e = b[::2, ::2] # 隔2行/列取一个元素
id(e.storage()) == id(a.storage())

True

b.stride(), e.stride()

((3, 1), (6, 2))

e.is_contiguous()

False