torch.randint(low, high, size, dtype=torch.int64, device='cpu', **kwargs)
low和high如上所述。size是一个元组，表示张量的形状。dtype是数据类型，默认为torch.int64，表示生成的整数是64位整数。device指定了生成张量所在的设备，可以是CPU或GPU等。
一般写成torch.randint(1, 10, (2, 3))，这将生成一个2行3列的张量，其中每个元素是1到9之间的随机整数。
认识张量维度：（即 以数组为一个层面， n为分割数组的逗号个数，张量的行数 = n+1；
张量的列数 就是每个数组中的列数。
tensor([[1, 2, 3],
[4, 5, 6]]) 这是2行3列的张量
tensor（[1,2,3])这是1行3列的张量
注意！这也可以说成是二维数组，但是一般不这么表示，一般还是说成张量。
张量和向量，矩阵的区别，可以参见：Transformer论文理解-CSDN博客
而数组是一个其他概念，应该是和元组，列表等并列的，一维数组可看成向量，二维数组可以看成矩阵，三维，四维，n维，可近似看成 n维张量。
函数语句解释：
torch.Tensor([2,4]).to(torch.int32)#创建一个包含2和4两个元素的张量(默认为float)，并转化成32位整数
src_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_src_words,(L,)), (0,max_src_seq_len-L)),0) for L in src_len])torch.randint(a, b, (L,))在a(包含)~b(不包含)的范围内，生成一个形状为L的张量
F.pad(...)是torch.nn.functional.pad 的别名，用于对张量进行填充。
F.pad(input,pad,[mode],[value])
input(tensor)：是要被扩充的元组
pad(tuple)：是指明对该tensor各方位扩充的元素个数（这个元组中的每个数字对应于输入张量的一个维度的填充大小），（pad_left, pad_right, pad_top, pad_bottom, ...）
import torch
input = torch.tensor([[[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]]])
padded_input = torch.nn.functional.pad(input, (1, 1, 1, 1), mode='constant', value=0)扩充后：形状变为（1，1，5，5）。
tensor([[[[0, 0, 0, 0, 0],
[0, 1, 2, 3, 0],
[0, 4, 5, 6, 0],
[0, 7, 8, 9, 0],
[0, 0, 0, 0, 0]]]])mode :默认为constant，即常数。可省略
value：指填充元素的数值，一般填充0.
-----------------
torch.unsqueeze（input,dim,[*]，[out=None]）用于对张量扩充一个维度。
一般只用前两个参数，Input：要被扩充的张量，
dim:是要被扩充维数的位置
Q1：dim指定的扩充维度的位置，那么torch.unsqueeze(tensor([1,2,3]), dim=0), 其中dim=0时，扩充出来是怎样的，dim=1时可以这么设置吗？
若tensor([1,2,3])则形状为(3,) ，dim = 0时，扩充后为tensor([[1,2,3]]), 形状为(1,3)
dim的数值，可以理解为tensor形状元组的索引位置。
Q2：扩充维度时，填从的元素是什么？
增加的维度大小为 1，但这个维度并不填充任何具体的值。它只是增加了一个维度，使得原始张量的维度增加一维。（相当于只是让容器大了一层，但并不一定装东西。）
其他例子：
import torch
# 示例 1: 原始张量形状为 (3,)
x = torch.tensor([1, 2, 3])
y = torch.unsqueeze(x, 0)
print(y) # 输出: tensor([[1, 2, 3]])
# 示例 2: 原始张量形状为 (3,)
x = torch.tensor([1, 2, 3])
y = torch.unsqueeze(x, 1)
print(y) # 输出: tensor([[1],
# [2],
# [3]])
# 示例 3: 原始张量形状为 (2, 3)
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.unsqueeze(x, 0)
print(y) # 输出: tensor([[[1, 2, 3],
# [4, 5, 6]]])
# 示例 4: 原始张量形状为 (2, 3)
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.unsqueeze(x, 1)
print(y) # 输出: tensor([[[1, 2, 3]],
# [[4, 5, 6]]])---------------------------------------
torch.cat([...]): 这个函数用于将多个张量沿着指定的维度进行拼接。在这里，它将所有通过列表推导式生成的张量拼接在一起
torch.cat(tensors, dim=0, *, out=None)
tensors(sequence of Tensors) - 要拼接的张量序列，这些张量必须在其他所有非拼接维度上具有相同的形状。（拼接维度直接相加）如：dim=1时(1,2,3)和(1,5,3)拼成(1,7,3)
而dim=0时，(1,2,3)和(1,5,3)就不能拼接
dim=0时，就是最外面那个框框相接，即tensor([[...]],[[...]])
dim = 1时，就是倒数第二个框框外相接（总之就是从外到内看）tensor([[...],[...]])
形状为(2,1,2)和(2,2,2)的张量当torch.cat()函数中dim = 1时,拼接
（tips：从内到外表示tensor）tensor([[a,b]],[[c,d]]) 和 tensor([[a,b],[c,d]],[[e,f],[g,h]])
拼接后为：tensor([ [a,b],
[a,b],
[c,d] ],
[ [c,d],
[e,f],
[g,h] ])
import torch
# 假设张量 A 和 B 已经定义，形状分别为 (2, 1, 2) 和 (2, 2, 2)
A = torch.tensor([[[1, 2]], [[3, 4]]])
B = torch.tensor([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
# 沿着第三维度拼接
result = torch.cat((A, B), dim=1)
print(result)
拓：
技巧：找逗号，判层数
tensor([1,2,3,4]) 在PyTorch中表示一个一维张量，具体来说是一个长度为4的向量。
- 行：1行
- 列：4列
这种张量的形状可以表示为 (4,)。在PyTorch中，张量的形状是一个元组，其中每个元素代表一个维度的大小。对于一维张量，形状通常只有一个元素，表示该维度的长度（这里就是4）。
辨析F.pad(...)于torch.unsqueeze（）用途区别：
pad是用于对张量进行填充。即可以使（1，2，3）变成（1，4，3）
表现为: 某一维度下增加了元素[1,2,3,4,0,0,0,0]
torch.unsqueeze 在张量的某维度下增加一个额外的维度。即可以使(1，2，3)变成（1，1，2，3）
表现为最外层增加个中括号。
判断一个tensor是的几维形状，则去数非并列的最右边的右括号有几个，有n个，就是n维
如：
tensor([[0],
[1],
[2],
[3]])则是两个右中括号，则为二维（1，4）。若是tensor([1,2,3,4])则是一维（4，）
扫一扫
1746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
