pytorch 中 repeat 和 expend 的功能和区别

功能

均是用于扩展张量的维度

区别

tensor.expand(*sizes)

将张量中单维度（singleton dimensions，即张量在某个维度上为1的维度，exp(1,2,3)，其中在第一个维度上就是单维度）扩展到指定的size大小(size为扩展后的张量在单维度处的维度)，而张量中其他的非单维度的位置，可以填写原始维度的大小或者-1，exp: tensor.expand(size,2,3)，或者tensor.expand(size,-1,-1)。注意，expand只作用于张量的单维度上。--> 类似于数据的复制，在batch维度上的扩展。

同时，expand不会为扩展维度后的整个张量重新分配内存，而仅仅是原始张量上的一个视图（view）

exp:（采用CSDN博客的例子）

import torch
a = torch.tensor([1, 0, 2])
b = a.expand(2, -1)   # 第一个维度为升维，第二个维度保持
# b为   tensor([[1, 0, 2],  [1, 0, 2]])

a = torch.tensor([[1], [0], [2]])
b = a.expand(-1, 2)   # 保持第一个维度，第二个维度只有一个元素，可扩展
# b为  tensor([[1, 1],
#              [0, 0],
#              [2, 2]])

此外，tensor.expand_as(tensor) 函数可以将tensor作为一种size传入，并进行指定的扩展。

exp:（采用CSDN博客的例子）

import torch
a = torch.tensor([1, 0, 2])
b = torch.zeros(2, 3)
c = a.expand_as(b)  # a照着b的维度大小进行拓展
		# c为 tensor([[1, 0, 2],[1, 0, 2]])

tensor.repeat(*sizes)

可以对于张量的非单维度进行扩展。size为原始的张量在各个维度上的复制次数。且其复制有先后顺序之分，按照原始张量的各个维度依次进行size指定大小的复制。与expand不同的是不需要复制的维度的地方用1表示，而不是-1或者原维度。

其复制后返回的张量会重新拥有一个独立存储区。

exp:

import torch
x = torch.tensor([1, 2, 3])
print(x)
y = x.repeat(2, 2)				# 先在行的维度扩展2倍 再在列的维度扩展2倍
print(y)
z = x.repeat(1, 2)				# 先在行的维度扩展2倍 再在列的维度扩展2倍
print(z)
>> tensor([1, 2, 3])
>> tensor([[1, 2, 3, 1, 2, 3],
	  [1, 2, 3, 1, 2, 3]])
>> tensor([1, 2, 3, 1, 2, 3])

此外 torch.repeat_interleave(tensor, repeats, dim=None) 可以只对指定维度进行复制, 不是把整个待复制张量当作一个整体，而是按张量元素进行操作。

tensor: 传入的数据为tensor

repeats: 复制的份数。可以是单个数，或者一个tensor形式的数组（必须为一维数组，且数组的长度要和dim对应的维度的大小相同）。

dim: 要复制的维度，可设定为0/1/2....., 若不指定dim参数，则dim默认为None ，即将输入tensor扁平化。也就是将把给定的输入张量展平（flatten）为向量，然后将每个元素重复repeats次，并返回重复后的张量（此时的repeats只能是个数而不能是数组）。

exp:

import torch
a=torch.arange(10).view(2,5)
## 常规 ##
b=torch.repeat_interleave(a,3,dim=0)
c=torch.repeat_interleave(a,3,dim=1)
## 不指定dim，默认为None ##
d=torch.repeat_interleave(a,2)
## repeats 为tensor数组 dim对应的维度大小和数组大小匹配 ##
e=torch.repeat_interleave(a,torch.tensor([2,3]),dim=0)
## repeats 为tensor数组 dim对应的维度大小和数组大小不匹配 ##
f=torch.repeat_interleave(a,torch.tensor([2,3]),dim=1)
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
>>
# 原数组 --> a
tensor([[0, 1, 2, 3, 4],
        [5, 6, 7, 8, 9]])
# 沿第一维度重复后的数组 --> b  -> 按元素操作，对应维度的元素都复制repeats后，再进行后面维度的元素的复制
tensor([[0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [5, 6, 7, 8, 9],
        [5, 6, 7, 8, 9],
        [5, 6, 7, 8, 9]])
# 沿第二维度重复后的数组 --> c
tensor([[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4],
        [5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]])
>>
# 不指定dim时,扁平化且重复两次 --> d
tensor([0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9])
>>
# 第一行重复两次，第二行重复三次 --> e
tensor([[0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [5, 6, 7, 8, 9],
        [5, 6, 7, 8, 9],
        [5, 6, 7, 8, 9]])
>>
# dim=1的原tensor的维度的大小为5，而repeats数组大小为2，不匹配，报错
RuntimeError: repeats must have the same size as input along dim

TIPS：矩阵的维度的判断

从最外层的[ ] 依次向里的[ ] 进行分析，其中 在一个[ ] 的元素是位于同一行，行里面有几个元素一共就会有几列（在不存在空行的情况下）

或者说 从外往里进行计数，比如np.array([[[1,1,1],[1,2,1]]]) ，其去除最外面的 [ ] 后 为[[1,1,1],[1,2,1]]，此时只有一个最大的 [ ]，再去除一层 [ ]后为[1,1,1],[1,2,1]，此时有两个 [ ] 元素， 在对于其中一个[ ]元素 再去除 一层 [ ] 后为 1,1,1，此时还剩3个最内层的元素。所有其shape为 (1, 2, 3)

下面是一些实际的计算的例子：

import numpy as np
c = np.array([1,1,1])
print(c.shape)
c = np.array([[1],[1],[1]])
print(c.shape)
c = np.array([[1,1,1],[1,2,1]])
print(c.shape)
c = np.array([[[1,1,1],[1,2,1]]])
print(c.shape)
c = np.array([[1,1,1],[],[1,2,1]])
print(c.shape)
>> (3,)
>> (3, 1)
>> (2, 3)
>> (1, 2, 3)
>> (3,)