pytorch中torch.cat() 和paddle中的paddle.concat()函数用法

Posted 2023-04-11 灰太狼家的小鸭子

在pytorch中：

torch.cat(x=[A,B],dim=n)函数：是将数据A,B沿着dim=n的方向进行拼接；x必须是list或者tuple类型的tensor.

例子：

import torch
x1 = torch.tensor([[1, 2, 3],
                    [4, 5, 6]])

x2 = torch.tensor([[11, 12, 13],
                    [14, 15, 16]])

x3 = torch.tensor([[21, 22],
                    [23, 24]])

out1=torch.cat([x1,x2,x3],dim=-1) #(dim=-1：横着拼接)
out2=torch.cat([x1,x2,x3],dim=1) #(dim=1：横着拼接)
out3=torch.cat([x1,x2],dim=0) #(dim=0：竖着拼接)


print(out1.shape)
print("out1:\\n",out1)
print("out2:\\n",out2)
print("out3:\\n",out3)


========================================
输出结果
torch.Size([2, 8])
out1:  #(dim=-1：横着拼接)
 tensor([[ 1,  2,  3, 11, 12, 13, 21, 22],
        [ 4,  5,  6, 14, 15, 16, 23, 24]])
out2:  #(dim=1：横着拼接)
 tensor([[ 1,  2,  3, 11, 12, 13, 21, 22],
        [ 4,  5,  6, 14, 15, 16, 23, 24]])
out3:  #(dim=0：竖着拼接)
 tensor([[ 1,  2,  3],
        [ 4,  5,  6],
        [11, 12, 13],
        [14, 15, 16]])

注意：竖着拼接的两个数据的维度需要相同；dim=-1 和dim=1的效果是相同的。

在paddle中：

paddle.concat(x, axis=0, name=None)：对输入沿参数 axis 轴进行拼接，返回一个新的 Tensor。

参数：x一般是list或者tuple类型的数据

• x (list|tuple) - 待联结的 Tensor list 或者 Tensor tuple，支持的数据类型为：bool、float16、float32、float64、int32、int64、uint8， x 中所有 Tensor 的数据类型应该一致。

• axis (int|Tensor，可选) - 指定对输入 x 进行运算的轴，可以是整数或者形状为[1]的 Tensor，数据类型为 int32 或者 int64。 axis 的有效范围是 [-R, R)，R 是输入 x 中 Tensor 的维度，axis 为负值时与 axis+R 等价。默认值为 0。

• name (str，可选) - 具体用法请参见 Name，一般无需设置，默认值为 None。

例子：

import paddle

x1 = paddle.to_tensor([[1, 2, 3],
                       [4, 5, 6]])
x2 = paddle.to_tensor([[11, 12, 13],
                       [14, 15, 16]])
x3 = paddle.to_tensor([[21, 22],
                       [23, 24]])
zero = paddle.full(shape=[1], dtype='int32', fill_value=0)


out1 = paddle.concat(x=[x1, x2, x3], axis=-1) #（-1：横着拼接） -1和 1都是横着拼接
out2 = paddle.concat(x=[x1, x2], axis=0) # (0 :竖着拼接：)
out3 = paddle.concat(x=[x1, x2], axis=zero)

# out1
# [[ 1  2  3 11 12 13 21 22]    #（-1：横着拼接）
#  [ 4  5  6 14 15 16 23 24]]   
# out2 out3     # (0 :竖着拼接：)
# [[ 1  2  3]
#  [ 4  5  6]
#  [11 12 13]
#  [14 15 16]]

pytorch-torch2:张量计算和连接

参考技术A torch.cat(seq,dim=0,out=None)->Tensor
在给定维度上对输入张量序列seq进行连接操作由这可以想到卷积神经网络
的全连接层
torch.cat() 可以看做 torch.split() 和 torch.chunk() 的逆运算

torch.chunk(tensor,chunks,dim)->>tensors
将张量沿给定维度分块

torch.gather(input,dim,index,out=None,sparse_grad=Flase,out=None)->Tensor

通俗点解释就是把指定索引dim的下标进行替换

torch.index_select(input,dim,index,out=None)->>Tensor

torch.masked_select(input,mask,out=None)->>Tensor
根据mask输出一个一维张量

torch.split(tensor,split_size,dim=0)->>tensor
如果可分,张量沿着指定维度指定大小进行分割,直到大小不足则停止

torch.t(input,out=None)->Tensor
张量转置相当于
torch.transpose(input,o,1)

torch.bernoulli(input,out=None)

从伯努利分布中抽取二元随机数(0或者1)这里的bernoulli概率p是随机的
输入张量值需是一个概率

torch.multinomial(input,num_samples,replacement=Flase,out=None)->>LongTensor
从输入张量中每行取num_samples个样本,可以设置replacement设置是否重复取值
返回取值的下标

torch.normal(means,std,out)->>tensor
按照指定均值和方差选取样本,均值个数决定样本个数
若均值和方差都为张量则两个张量元素个数必须相等

torch.abs(input,out)->tensor 输出张量元素绝对值

torch.acos(input,out) 求反余弦

torch.add(input,value,out) 对每个张量元素逐个加上value

torch.addcdiv(tensor,value=1,tensor1,tensor2) 张量(tensor1/tensor2)*value+tensor

torch.addmul 相乘相加

torch.ceil(input,out) 向上取整

torch.clamp(input,min,max,out=None)
将元素调整至[min,max]区间

torch.div(input,value) 除

torch.exp(tensor,out) 指数

torch.floor(input,out) 向下去整

torch.fmod(input,divisor,out) 取余数

torch.frac 取分数部分

torch.lerp(start, end, weight, out=None)
线性插值:out = start+weight*(end-start)

torch.log 取自然对数

torch.mul(input, value, out=None)

torch.mul(input, other, out=None) 哈达玛积

torch.neg 取复数

torch.pow(input, exponent, out=None) 求幂

torch.reciprocal(input, out=None) → Tensor 去倒数

torch.remainder(input, divisor, out=None) → Tensor 取余数

torch.rsqrt(input, out=None) → Tensor 平方根倒数

torch.sigmoid(input, out=None) → Tensor sigmoid值

torch.sigmoid(input, out=None) → Tensor 符号函数

torch.cumprod(input, dim, out=None) → Tensor 按指定维度累积

torch.cumsum(input, dim, out=None) → Tensor 指定维度累加

torch.dist(input, other, p=2, out=None) → Tensor 求P范数

torch.mean(input) → float 均值

torch.mean(input, dim, out=None) → Tensor 指定维度均值

torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor) 指定维度中位数

torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor) 众数

torch.norm(input, p, dim, out=None) → Tensor 指定维度p范数

torch.prod(input) → float 所有积

torch.prod(input, dim, out=None) → Tensor 指定维度积

torch.std(input, dim, out=None) → Tensor 标准差

torch.sum(input, dim, out=None) → Tensor 按维度求和

torch.sum(input) → float 所有元素和

var 按行方差，所有元素方差

torch.eq(input, other, out=None) → Tensor 相等比较操作 返回01

torch.equal(tensor1, tensor2) → bool 张量比较shape and value返回bool

torch.ge(input, other, out=None) → Tensor 大于

torch.gt(input, other, out=None) → Tensor 与equal类似返回不同

torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor) 取指定维度最小值

torch.le(input, other, out=None) → Tensor 小于等于

torch.lt(input, other, out=None) → Tensor 小于

torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor) 返回指定维度最大值和索引