目标识别：SSD pytorch代码学习笔记 （4）——函数篇

相关函数

product()

product 用于求多个可迭代对象的笛卡尔积(Cartesian Product)，它跟嵌套的 for 循环等价.即:
product(A, B) 和 ((x,y) for x in A for y in B)一样.
它的一般使用形式如下：

itertools.product(*iterables, repeat=1)

iterables是可迭代对象,repeat指定iterable重复几次。

class product(object):
    """
    product(*iterables, repeat=1) --> product object
    输入迭代的笛卡尔积。等价于嵌套的for循环。
    例如product(A, B)相当于((x,y) for x in A for y in B)。
    注意A在外层循环，B在内层循环。（当然参数还可以大于2个）
    如果要单独计算A的循环，还可以定义repeat，例如
    product(A, repeat=4) 等价于 product(A, A, A, A).
	具体例子：
    product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)
    product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...
    """

我们再尝试一下类似于PriorBox代码中的输入：

>>>from itertools import product
>>>for i, j in product(range(3), repeat=2):
>>>    print(i,j)
>>>	0 0
	0 1
	0 2
	1 0
	1 1
	1 2
	2 0
	2 1
	2 2

squeeze()/unsqueeze()

torch.squeeze() 这个函数主要对数据的维度进行压缩，去掉维数为1的的维度，默认是将a中所有为1的维度删掉。也可以通过dim指定位置，删掉指定位置的维数为1的维度。

1. 首先得到一个维度为（1，2，3）的tensor（张量）
   
   2.下面使用squeeze()函数将第一维去掉
   
   可见，维度已经变为（2，3）
   3.另外
   
   可以看出维度并没有变化，仍然为（1，2，3），这是因为只有维度为1时才会去掉。

torch.unsqueeze() 这个函数主要是对数据维度进行扩充。需要通过dim指定位置，给指定位置加上维数为1的维度。

1. 首先初始化一个a
   
2. 在第二维增加一个维度，使其维度变为（2，1，3）
   
   可以看出a的维度已经变为（2，1，3）了，同样如果需要在倒数第二个维度上增加一个维度，那么使用b.unsqueeze(-2)

expand()/expand_as()

tensor.expend()函数

>>> import torch
>>> a=torch.tensor([[2],[3],[4]])
>>> print(a.size())
torch.Size([3, 1])
>>> a.expand(3,2)
tensor([[2, 2],
        [3, 3],
        [4, 4]])
>>> a
tensor([[2],
        [3],
        [4]])

可以看出expand()函数括号里面为变形后的size大小，而且原来的tensor和tensor.expand()是不共享内存的。

tensor.expand_as()函数

>>> b=torch.tensor([[2,2],[3,3],[5,5]])
>>> print(b.size())
torch.Size([3, 2])
>>> a.expand_as(b)
tensor([[2, 2],
        [3, 3],
        [4, 4]])
>>> a
tensor([[2],
        [3],
        [4]])

可以看出，b和a.expand_as(b)的size是一样大的。且是不共享内存的。

view()

当于numpy中resize（）的功能，但是用法可能不太一样。

我的理解是：

把原先tensor中的数据按照行优先的顺序排成一个一维的数据（这里应该是因为要求地址是连续存储的），然后按照参数组合成其他维度的tensor。比如说是不管你原先的数据是[[[1,2,3],[4,5,6]]]还是[1,2,3,4,5,6]，因为它们排成一维向量都是6个元素，所以只要view后面的参数一致，得到的结果都是一样的。比如，

a=torch.Tensor([[[1,2,3],[4,5,6]]])
b=torch.Tensor([1,2,3,4,5,6])

print(a.view(1,6))
print(b.view(1,6))

得到的结果都是tensor([[1., 2., 3., 4., 5., 6.]])

再看一个例子：

a=torch.Tensor([[[1,2,3],[4,5,6]]])
print(a.view(3,2))

将会得到：

tensor([[1., 2.],
        [3., 4.],
        [5., 6.]])

相当于就是从1，2，3，4，5，6顺序的拿数组来填充需要的形状。但是如果您想得到如下的结果：

tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])

就需要使用另一个函数了：permute（）。

permute()

具体详见此博客

gt()

函数作用
torch.gt(a,b)函数比较a中元素大于（这里是严格大于）b中对应元素，大于则为1，不大于则为0，这里a为Tensor，b可以为与a的size相同的Tensor或常数。

>>> import torch
>>> a=torch.randn(2,4)
>>> a
tensor([[-0.5466,  0.9203, -1.3220, -0.7948],
        [ 2.0300,  1.3090, -0.5527, -0.1326]])
>>> b=torch.randn(2,4)
>>> b
tensor([[-0.0160, -0.3129, -1.0287,  0.5962],
        [ 0.3191,  0.7988,  1.4888, -0.3341]])
>>> torch.gt(a,b)            #得到a中比b中元素大的位置
tensor([[0, 1, 0, 0],
        [1, 1, 0, 1]], dtype=torch.uint8)
>>> torch.gt(b,a)           #b中比a中大
tensor([[1, 0, 1, 1],
        [0, 0, 1, 0]], dtype=torch.uint8)
>>> torch.gt(a,1)
tensor([[0, 0, 0, 0],
        [1, 1, 0, 0]], dtype=torch.uint8)
>>> c=torch.Tensor([[1,2,3],[4,5,6]])
>>> d=torch.Tensor([[1,1,3],[5,5,5]])
>>> torch.gt(c,d)                   #必须是严格大于才为1
tensor([[0, 1, 0],
        [0, 0, 1]], dtype=torch.uint8)

mask索引

import torch 

a = torch.randn(3, 4)
print(a) 

# 生成a这个Tensor中大于0.5的元素的掩码
mask = a.ge(0.5)
print(mask) 

# 取出a这个Tensor中大于0.5的元素
val = torch.masked_select(a, mask)
print(val)
print(val.shape)

输出结果：

tensor([[ 0.2055, -0.7070,  1.1201,  1.3325],

        [-1.6459,  0.9635, -0.2741,  0.0765],

        [ 0.2943,  0.1206,  1.6662,  1.5721]])

tensor([[0, 0, 1, 1],

        [0, 1, 0, 0],

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

tensor([1.1201, 1.3325, 0.9635, 1.6662, 1.5721])

torch.Size([5])

注意：最后取出的 大于0.5的Tensor的shape已经被打平。