convn函数（conv函数是什么意思）



0 # 因为标量是一个单一的数值，没有维度

1 # 因为向量是一维的，只有一个轴，可以看作是一个行或者列向量

MATRIX = torch.tensor([[7, 8],
[9, 10]])
MATRIX.ndim # 返回张量的维度

2 # 因为矩阵是二维的，有两个轴：行和列

TENSOR = torch.tensor([[[1, 2, 3],
[3, 6, 9],
[2, 4, 5]]])
TENSOR.ndim # 返回张量的维度

3 # 三维张量有三个轴，可以看作是一个立方体的形状

注释解释：

• 第一步：创建一个标量张量 ，其中 创建了一个值为10的张量。
• 第二步：使用 NumPy 生成一个2x3的随机数组 ，然后将其转换为 PyTorch 张量 。注意，由于 NumPy 的默认数据类型是 float64，所以转换后的张量也是 。
• 第三步：使用包含列表的数据创建张量 。在这个例子中，列表中的数据都是浮点数，因此创建的张量的默认数据类型为 。

注释解释：

• 第一步：使用 创建一个2行3列的张量，默认数据类型为 。这种方式会初始化张量的值，但具体数值取决于内存中的初始状态，所以结果是随机的。
• 第二步：如果在 中传递一个单独的数值（如 ），则会创建一个包含该数值的张量。在这个例子中，生成的张量是 ，注意默认数据类型为 。
• 第三步：如果传递一个列表（如 ），则根据列表中的元素创建张量。生成的张量是 ，其中列表中的每个元素都成为张量中的一个值。同样，默认数据类型为 。

总结： 可以根据传递的参数不同来创建不同的张量。如果传递的是尺寸参数（如 ），则创建一个具有指定形状的张量，并且张量的值是未初始化的（随机值）。如果传递的是一个数值或者一个列表，将创建一个包含这些值的张量，并且默认数据类型为 。

torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量

tensor([2, 3], dtype=torch.int32)

data = torch.ShortTensor() # int16
data = torch.LongTensor() # int64
data = torch.FloatTensor() # float32
data = torch.DoubleTensor() # float64

● torch.arange 和 torch.linspace 创建线性张量
● torch.random.init_seed 和 torch.random.manual_seed 随机种子设置
● torch.randn 创建随机张量
●

注释解释：

• 第一步：使用 函数，在区间 中按照步长为 2 生成元素。生成的张量包含的元素为 。注意，结束位置 10 不包含在内，生成的数列从开始位置开始，每次增加步长，直到小于结束位置。
• 第二步：使用 函数，在区间 中按照指定的元素个数（10个元素）均匀生成数列。生成的张量为 。这里的步长是根据起始值、结束值和元素个数自动计算得出的，确保生成的数列是均匀分布的。

总结：

• 函数用于在指定区间内按照指定步长生成元素。
• 函数用于在指定区间内按照指定元素个数生成均匀分布的数列。
  张量的元素类型转换:
  ● torch.random.initial_seed()查看随机种子
  ● torch.random.manual_seed() 设置随机数种子
  ● torch.randn() 创建随机张量
  ●

print(‘随机数种子:’, torch.random.initial_seed())

随机数种子:

torch.random.manual_seed(100)
data = torch.randn(2, 3)
print(data)
print(‘随机数种子:’, torch.random.initial_seed())

tensor([[ 0.3607, -0.2859, -0.3938],
[ 0.2429, -1.3833, -2.3134]])
随机数种子: 100

张量的类型转换:
● torch.ones 和 torch.ones_like 创建全1张量
● torch.zeros 和 torch.zeros_like 创建全0张量
● torch.full 和 torch.full_like 创建全为指定值张量

注释解释：

• 第一步：使用 函数创建一个形状为 (2, 3) 的全0张量。生成的张量每个元素都是0，形状为二维的 2 行 3 列矩阵。
• 第二步：使用 函数根据已有张量 的形状创建一个新的全0张量。这里 是之前创建的形状为 (2, 3) 的张量，因此 将生成一个与 相同形状的全0张量。

总结：

• 可以根据指定的形状创建全0张量。
• 可以根据给定的张量 的形状创建一个形状相同的全0张量。
  import torch

tensor([[0., 0., 0.],
[0., 0., 0.]])
注释解释：
● 第一步：使用 torch.zeros(2, 3) 函数创建一个形状为 (2, 3) 的全0张量。生成的张量每个元素都是0，形状为二维的 2 行 3 列矩阵。
● 第二步：使用 torch.zeros_like(data) 函数根据已有张量 data 的形状创建一个新的全0张量。这里 data 是之前创建的形状为 (2, 3) 的张量，因此 torch.zeros_like(data) 将生成一个与 data 相同形状的全0张量。
总结：
● torch.zeros(shape) 可以根据指定的形状创建全0张量。
● torch.zeros_like(tensor) 可以根据给定的张量 tensor 的形状创建一个形状相同的全0张量。

torch.zeros()、torch.zeros_like() 创建全0张量

torch.full()、torch.full_like() 创建全为指定值张量

张量元素类型转换
● data.type(torch.DoubleTensor)
● data.double()

torch.int64

torch.float64

data.double()
data = torch.full([2, 3], 10)
print(data.dtype)

torch.int64

torch.float64

上面转换总结:
创建张量的方式
● torch.tensor() 根据指定数据创建张量
● torch.Tensor() 根据形状创建张量, 其也可用来创建指定数据的张量
● torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量
<2> 创建线性和随机张量
● torch.arrange() 和 torch.linspace() 创建线性张量
● torch.random.initial_seed() 和 torch.random.manual_seed() 随机种子设置
● torch.randn() 创建随机张量
<3> 创建01张量
● torch.ones() 和 torch.ones_like() 创建全1张量
● torch.zeros() 和 torch.zeros_like() 创建全0张量
● torch.full() 和 torch.full_like() 创建全为指定值张量
<4> 张量元素类型转换
● data.type(torch.DoubleTensor)
● data.double()

data_tensor = torch.tensor([2, 3, 4])

<class ‘torch.Tensor’>

print(type(data_numpy))

<class ‘numpy.ndarray’>

tensor([100, 3, 4])

print(data_numpy)

[100 3 4]

data_tensor = torch.tensor([2, 3, 4])

<class ‘torch.Tensor’>

print(type(data_numpy))

<class ‘numpy.ndarray’>

tensor([2, 3, 4])

print(data_numpy)

[100 3 4]

data_numpy = np.array([2, 3, 4])

data_tensor = torch.from_numpy(data_numpy)

tensor([100, 3, 4], dtype=torch.int32)

print(data_numpy)

[100 3 4]

● 使用 torch.tensor 可以将 ndarray 数组转换为 Tensor，默认不共享内存。
data_numpy = np.array([2, 3, 4])
data_tensor = torch.tensor(data_numpy)

tensor([100, 3, 4], dtype=torch.int32)

print(data_numpy)

[2 3 4]

30

30

总结

1. 张量转换为 numpy 数组
   ● data_tensor.numpy()
   ● data_tensor.numpy().copy()
2. numpy 转换为张量
   ● torch.from_numpy(data_numpy)
   ● torch.tensor(data_numpy)
3. 标量张量和数字转换
   ● data.item()

张量的运算:
张量基本运算
● 加减乘除取负号：
● add、sub、mul、div、neg
● add_、sub_、mul_、div_、neg_（其中带下划线的版本会修改原数据）
data = torch.randint(0, 10, [2, 3])
print(data)

print(data.sub(100))

print(data.mul(100))

print(data.div(100))

print(data.neg())

注释解释：

• 方式一：使用 运算符进行张量的点积运算。在 PyTorch 中， 运算符与 函数等效，用于执行张量的矩阵乘法操作。
• 方式二：使用 函数进行点积运算，同样可以得到与 运算符相同的结果。

总结：

• 在 PyTorch 中，可以使用 运算符或 函数进行张量的矩阵乘法（点积）运算。
• 这两种方式都适用于执行矩阵乘法，计算结果相同。
  点乘（Element-wise Multiplication）：
  ● 点乘是指两个矩阵或向量中对应位置元素相乘的操作，
  点积结果是两个向量对应元素相乘后的和
  总结
  <1> 张量基本运算函数
  ● add、sub、mul、div、neg等函数
  ● add_、sub_、mul_、div_、neg_等函数
  <2> 张量的点乘运算
  ● mul 和运算符 *
  <3> 点积运算
  ● 运算符@用于进行两个矩阵的点乘运算
  ● torch.matmul 对进行点乘运算的两矩阵形状没有限定，对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则
  张量的函数计算:

import torch

print(data.mean())

tensor(4.1667, dtype=torch.float64)

print(data.mean(dim=0)) # 按列计算均值

tensor([5.0000, 1.5000, 6.0000], dtype=torch.float64)

print(data.mean(dim=1)) # 按行计算均值

tensor([3.6667, 4.6667], dtype=torch.float64)

print(data.sum())

tensor(25., dtype=torch.float64)

print(data.sum(dim=0))

tensor([10., 3., 12.], dtype=torch.float64)

print(data.sum(dim=1))

tensor([11., 14.], dtype=torch.float64)

print(torch.pow(data，2))

print(data.sqrt())

print(data.exp())

print(data.log()) # 以 e 为底

print(data.log2())

print(data.log10())

张量的索引操作:
. 张量的索引操作
● 在操作张量时，经常要去获取某些元素进行处理或者修改操作，在这里需要了解torch中的索引操作。
import torch

tensor([[0, 7, 6, 5, 9],
[6, 8, 3, 1, 0],
[6, 3, 8, 7, 3],
[4, 9, 5, 3, 1]])

print(data[0])

tensor([0, 7, 6, 5, 9])

print(data[:, 0])

tensor([0, 6, 6, 4])

注释解释：

• 第一个示例： 使用两个索引列表来获取张量中指定位置的元素。具体来说，它返回的是索引为 和 的两个元素。在这里， 返回的是第一行第二列的元素 ， 返回的是第二行第三列的元素 。
• 第二个示例： 使用两个索引列表来获取多行多列的元素。其中， 表示选择第 0 行和第 1 行， 表示选择第 1 列和第 2 列。这个操作返回的是一个形状为 (2, 2) 的张量，其中包含了选择的行和列的元素：
  • 第一个 行选择了第 0 行的第 1 列和第 2 列，即 。
  • 第二个 行选择了第 1 行的第 1 列和第 2 列，即 。

总结：

• 在 PyTorch 中，可以使用索引列表来同时选择张量中的多个元素或者多行多列的元素。
• 索引列表的长度和形状需要匹配张量的维度要求。
  范围索引的使用

注释解释：

• 第一个示例： 选择了张量 的前三行和前两列的数据。具体操作为：
  • 表示选择索引从 0 到 2 的行（前三行）。
  • 表示选择索引从 0 到 1 的列（前两列）。
  • 因此，返回的张量包含了 的前三行和前两列的数据，即：

• 第二个示例： 选择了张量 的从第二行开始到最后一行，并且选择了前两列的数据。具体操作为：
  • 表示选择从索引 2 开始到最后一行的数据。
  • 表示选择索引从 0 到 1 的列（前两列）。
  • 因此，返回的张量包含了 的第二行到最后一行的数据，并且只选择了前两列，即：

总结：

• 在 PyTorch 中，可以使用切片操作来选择张量中的部分数据。
• 切片操作的形式为 ，其中 表示起始索引（默认为 0）， 表示结束索引（不包含在内，默认为末尾）， 表示步长（默认为 1）。

布尔索引的使用:

注释解释：

• 第一个示例： 选择了张量 中第三列元素大于 5 的行数据。具体操作为：
  • 表示选择 的第三列（索引为 2）。
  • 返回一个布尔张量，指示哪些行的第三列元素大于 5。
  • 使用布尔索引选择满足条件的行，即第三列元素大于 5 的行数据。返回的张量为：

• 第二个示例： 选择了张量 中第二行元素大于 5 的列数据。具体操作为：
  • 返回一个布尔张量，指示哪些列的第二行元素大于 5。
  • 使用布尔索引选择满足条件的列，即第二行元素大于 5 的列数据。返回的张量为：

总结：

• 在 PyTorch 中，可以使用布尔索引来根据条件选择张量中的元素或者行列。
• 布尔索引的结果张量形状与原张量形状相同，但仅包含满足条件的部分数据。
  多维索引的使用:

注释解释：

• 是一个形状为 [3, 4, 5] 的三维张量，包含了随机生成的整数数据。
• 获取0轴上的第一个数据： 选择了在第0个轴（最外层维度）上的第一个子张量。这相当于选择了 中索引为 0 的子张量，其形状为 [4, 5]。
• 获取1轴上的第一个数据： 选择了在第1个轴上每个子张量的第一个行。这相当于选择了 中每个子张量的索引为 0 的行，形状为 [3, 5]。
• 获取2轴上的第一个数据： 选择了在第2个轴上每个子张量的第一个列。这相当于选择了 中每个子张量的索引为 0 的列，形状为 [3, 4]。

这些操作展示了如何通过索引在多维张量中选择特定的子集或者元素。
张量的形状操作:
这里是对每个函数的解释和带有注释的示例代码：

1.

• 功能：重塑张量 为指定的 ，如果形状兼容的话。
• 示例代码：

2.

• 功能：返回一个不同形状的张量视图，但与原始张量共享相同的数据。
• 示例代码：

3.

• 功能：确保张量在内存中是整块的，有时在操作非连续的张量时需要调用此方法。
• 示例代码（需要在具体场景中使用，这里不展示具体示例）。

4.

• 功能：沿着新的维度 连接多个张量序列，所有张量必须具有相同的大小。
• 示例代码：

5.

• 功能：挤压张量 中所有尺寸值为 1 的维度。
• 示例代码：

6.

• 功能：在张量 的 维度处添加维度值为 1 的新维度。
• 示例代码：

7.

• 功能：交换张量 的指定维度 和 。
• 示例代码：

8.

• 功能：返回原始张量 的视图，其尺寸被按照 指定的顺序重新排列。
• 示例代码：

这些函数提供了对张量进行重塑、维度操作和形状变换的多种功能，适用于各种深度学习任务中对数据结构的处理和准备。
堆叠解释:
在深度学习中，"堆叠（stack）"通常指的是沿着新的维度将多个张量连接起来，形成一个新的张量。这个新的维度被称为"堆叠维度（stack dimension）“或者"堆叠轴（stack axis）”。堆叠的意义在于可以将多个具有相同形状的张量按照特定方向进行组合，从而方便进行批处理、并行计算或者数据整合。

示例代码解释：

解释：

• x 是一个形状为 (7,) 的张量，包含了7个元素。
• torch.stack([x, x, x, x], dim=0) 表示将张量 x 在维度0上进行堆叠，即在行的方向上重复堆叠4次。
• 结果 x_stacked 是一个形状为 (4, 7) 的张量，其中4表示堆叠的次数，7表示原始张量 x 的维度。

意义：

• 批处理（Batching）：在深度学习中，通常需要对多个样本进行并行处理。堆叠可以将多个样本的输入数据组合成一个张量，从而一次性输入神经网络进行处理，提高计算效率。
• 并行计算（Parallel Computation）：某些情况下，可以同时处理多个堆叠的张量，例如在GPU上并行计算。
• 数据整合（Data Integration）：当需要将多个来源的数据按照一定规则整合成一个张量时，堆叠是一种常见的操作方式。

总之，堆叠是在深度学习中常用的数据处理手段，能够帮助提高计算效率和数据管理的便捷性。

总结
<1> reshape 函数可以在保证张量数据不变的前提下改变数据的维度
<2> squeeze 和 unsqueeze 函数可以用来增加或者减少维度
<3> transpose 函数可以实现交换张量形状的指定维度, permute 可以一次交换更多的维度
<4> view 函数也可以用于修改张量的形状, 但是它要求被转换的张量内存必须连续，所以一般配合 contiguous 函数使用
张量的拼接操作:
张量的拼接是现有维度,形状相同,然后拼接在一起
这段代码展示了如何使用PyTorch的函数沿不同维度拼接张量，并且输出了每次拼接后的张量形状。

1. 按0维度拼接 ()：
   • 在0维度上拼接意味着沿着第一个轴（通常是批次轴）堆叠张量。
   • 和 都是形状为 的张量。
   • 在0维度上拼接后，新的张量 的形状为 ，表示在批次维度上堆叠了两个张量。
2. 按1维度拼接 ()：
   • 在1维度上拼接意味着沿着第二个轴堆叠张量。
   • 和 在1维度上拼接后，形状为 ，表示在每个批次中堆叠了四个张量。
3. 按2维度拼接 ()：
   • 在2维度上拼接意味着沿着第三个轴堆叠张量。
   • 和 在2维度上拼接后，形状为 ，表示在每个批次的每行中堆叠了六个元素。

总结：

• 函数允许按指定的维度将多个张量连接起来。
• 拼接后的张量形状取决于拼接的维度和张量的形状。
  张量的堆叠是
  堆叠用法:
  import torch

到此这篇convn函数（conv函数是什么意思）的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

版权声明：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/haskellbc/50767.html