深度学习--基础语法

目录

pytorch的tensor与numpy

关系

tensor与numpy的转换:

区别:

创建tensor

一 numpy数组,list列表转换为tensor

二 未初始化创建tensor

创建空的 PyTorch 张量 e:

使用 torch.Tensor() 创建指定大小的张量 f:

三 随机生成tensor

1. 使用 torch.rand() 创建随机初始化的张量 g:

2. 使用 torch.randn() 创建从标准正态分布中采样的张量 h:

3. 使用 torch.randn_like() 根据现有张量 g 的形状创建新的张量 i:

四 序列生成tensor

1. 使用 torch.arange() 生成等差序列:

2. 使用 torch.arange() 指定步长生成等差序列:

3. 使用 torch.linspace() 生成等间隔序列:

五 全一全零单位生成tensor

1. 创建全一张量(torch.ones()):

2. 创建全零张量(torch.zeros())

3. 创建单位矩阵(torch.eye()):

3.1 创建指定大小的单位矩阵:

3.2 创建默认大小(2x2)的单位矩阵:

补充

补充函数

torch.full()

torch.randperm()

解释浮点数

tensor的属性

介绍

代码演示

tensor的变形

1. reshape() 方法

2. view() 方法

3. flatten() 方法

4. squeeze() 方法

5. unsqueeze() 方法

代码演示

tensor的索引与切片

1. 索引单个元素

2. 切片操作

 3. 使用索引和切片修改张量的部分元素

4. 使用布尔索引

代码演示 

tensor的连接和拆分

tensor的连接

torch.cat

torch.stack

代码演示

tensor的拆分

torch.split

torch.chunk

补充

代码演示

tensor的换位与置换

1    T与torch.t()

2   .transpose()

3   .permute()

代码演示

tensor的运算


pytorch的tensor与numpy

关系

PyTorch 的 Tensor 和 NumPy 的 ndarray 在很多方面非常相似,它们都是用来存储和操作多维数据的数据结构,但它们也有一些重要的区别。
相似性:
数据类型支持:PyTorch 的 Tensor 和 NumPy 的 ndarray 都支持多种数据类型,如浮点数、整数等,并且可以通过指定 dtype 来指定数据类型。
多维数组:两者都支持多维数组操作,可以通过索引访问元素,并支持切片操作。
数学操作:PyTorch 的 Tensor 和 NumPy 的 ndarray 都支持广播(broadcasting)和各种数学操作,如加法、乘法、矩阵乘法等。
与 CPU/GPU 的兼容性:两者都能够在 CPU 和 GPU 上进行计算,且切换方式类似。
区别:
自动求导:PyTorch 的 Tensor 支持自动求导(Autograd),这意味着可以在计算中记录操作,并自动计算梯度。NumPy 的 ndarray 不支持自动求导功能。
计算性能:PyTorch 的 Tensor 针对深度学习任务进行了优化,特别是在 GPU 上的计算性能通常比 NumPy 的 ndarray 更高效。
库生态系统:PyTorch 作为一个深度学习库,有着丰富的深度学习函数和模型库,能够进行神经网络的构建、训练和部署。NumPy 则更为通用,适合于广泛的科学计算任务。

NumPy 示例

import numpy as np# 创建一个 NumPy 数组
a = np.array([[1, 2, 3], [4, 5, 6]])# 访问元素
print(a[0, 1])  # 输出: 2# 数学操作
b = np.array([[7, 8, 9], [10, 11, 12]])
c = a + b
print(c)  # 输出: [[ 8 10 12]#       [14 16 18]]

PyTorch 示例

import torch# 创建一个 PyTorch Tensor
d = torch.tensor([[1, 2, 3], [4, 5, 6]])# 访问元素
print(d[0, 1])  # 输出: tensor(2)# 数学操作
e = torch.tensor([[7, 8, 9], [10, 11, 12]])
f = d + e
print(f)  # 输出: tensor([[ 8, 10, 12],#              [14, 16, 18]])

tensor与numpy的转换:

import torch
import numpy as npprint(torch.__version__)a=np.array([[1,2],[3,4]])#numpy数组
print(type(a))
print(a)
print()b=torch.tensor([[1,2,3],[4,5,6]])#torch张量
print(type(b))
print(b)
print()c = b.numpy()                #torch张量转换numpy数组
print(type(c))
print(c)
print()结果
1.9.1
<class 'numpy.ndarray'>
[[1 2][3 4]]<class 'torch.Tensor'>
tensor([[1, 2, 3],[4, 5, 6]])<class 'numpy.ndarray'>
[[1 2 3][4 5 6]]<class 'torch.Tensor'>
tensor([[1, 2, 3],[4, 5, 6]])

区别:

tensor与numpy在输出时tensor会显示tensor的标志

<class 'numpy.ndarray'>
[[1 2 3][4 5 6]]<class 'torch.Tensor'>
tensor([[1, 2, 3],[4, 5, 6]])

创建tensor

一 numpy数组,list列表转换为tensor

a=np.array([[1,2],[3,4]])#numpy二维数组
print(a)
print()b=torch.from_numpy(a)#numpy数组转换为tensor张量
print(b)
print()c=torch.tensor([2,1.2])#list转换为tensor张量
print(c)d=torch.tensor([[1,2],[3,4]])
print(d)[[1 2][3 4]]tensor([[1, 2],[3, 4]], dtype=torch.int32)tensor([2.0000, 1.2000])
tensor([[1, 2],[3, 4]])

二 未初始化创建tensor

torch.empty(1) 创建了一个包含一个元素的未初始化张量,输出可能接近于 0,但确切的值取决于内存状态。
torch.Tensor(2, 3) 创建了一个 2x3 的张量,并且初始化了其值为 [0, 1) 内的随机数。

创建空的 PyTorch 张量 e:

e=torch.empty(1)
print(e)
tensor([2.0000])

这段代码创建了一个大小为 (1,) 的空张量 e。torch.empty() 函数会创建一个未初始化的张量,其值取决于内存的状态。这意味着张量的内容可以是任意值,而不是零或其他特定值。

使用 torch.Tensor() 创建指定大小的张量 f:

f=torch.Tensor(2,3)
print(f)
tensor([[0., 0., 0.],[0., 0., 0.]])

这里使用了 torch.Tensor() 函数创建了一个 2x3 的张量 f。与 torch.empty() 不同,torch.Tensor() 会创建一个具有指定形状的张量,并初始化其值。默认情况下,这些值是在区间 [0, 1) 内的随机数。

三 随机生成tensor

torch.rand() 用于创建从 [0, 1) 均匀分布中采样的张量。
torch.randn() 用于创建从标准正态分布中采样的张量。
torch.randn_like() 用于根据输入张量的形状创建新的张量,并从标准正态分布中采样值。

1. 使用 torch.rand() 创建随机初始化的张量 g:

g=torch.rand(3,3)
print(g)
tensor([[0.0023, 0.5854, 0.4163],[0.4341, 0.5436, 0.8461],[0.8126, 0.6083, 0.6263]])

这段代码创建了一个形状为 (3, 3) 的张量 g,其中的元素是从 [0, 1) 的均匀分布中随机采样的值。

2. 使用 torch.randn() 创建从标准正态分布中采样的张量 h:

h=torch.randn(3,3)
print(h)
tensor([[-0.5487,  1.3024,  1.4909],[-0.1682,  0.8304, -1.1007],[ 0.3323,  1.3830,  2.4619]])

这段代码创建了一个形状为 (3, 3) 的张量 h,其中的元素是从标准正态分布(均值为 0,标准差为 1)中随机采样的值。

与 torch.rand() 不同,torch.randn() 生成的值更接近于正态分布的中心

3. 使用 torch.randn_like() 根据现有张量 g 的形状创建新的张量 i:

i = torch.randn_like(g)
print(i)
tensor([[-0.3863,  1.3241,  0.7400],[-0.1386,  0.7476, -0.2747],[ 0.1088,  0.7457, -0.3099]])

这段代码创建了一个与张量 g 具有相同形状 (3, 3) 的新张量 i,其中的元素也是从标准正态分布中随机采样的值。

与 torch.randn() 不同的是,torch.randn_like() 使用了 g 的形状信息来创建新的张量,但采样的方式仍然是从标准正态分布中。

四 序列生成tensor

1. 使用 torch.arange() 生成等差序列:

print(torch.arange(0,10))
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

这段代码生成一个从 0 到 9 的序列,步长为 1(默认步长)。

2. 使用 torch.arange() 指定步长生成等差序列:

print(torch.arange(0,10,2))
tensor([0, 2, 4, 6, 8])

这段代码生成一个从 0 到 9 的序列,步长为 2。

3. 使用 torch.linspace() 生成等间隔序列:

print(torch.linspace(0,10,3))
tensor([ 0.,  5., 10.])

这段代码生成一个从 0 到 10 的等间隔序列,总共包含 3 个数。

在 torch.linspace() 中,第一个参数是起始值,第二个参数是结束值,第三个参数是生成序列的长度(包含起始值和结束值),生成的序列是均匀间隔的。

五 全一全零单位生成tensor

1. 创建全一张量(torch.ones()):

print(torch.ones(3,3))
tensor([[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]])

这将创建一个形状为 (3, 3) 的张量,所有元素的值都为 1。

2. 创建全零张量(torch.zeros())

print(torch.zeros(2, 3))
tensor([[0., 0., 0.],[0., 0., 0.]])

这将创建一个形状为 (2, 3) 的张量,所有元素的值都为 0。

3. 创建单位矩阵(torch.eye()):

3.1 创建指定大小的单位矩阵:
print(torch.eye(4, 4))
tensor([[1., 0., 0., 0.],[0., 1., 0., 0.],[0., 0., 1., 0.],[0., 0., 0., 1.]])

这将创建一个 4x4 的单位矩阵,即主对角线上的元素为 1,其余元素为 0。

3.2 创建默认大小(2x2)的单位矩阵:
print(torch.eye(2))
tensor([[1., 0.],[0., 1.]])

补充

补充函数

torch.full()
l = torch.full((2, 3), 5)
print(l)

这将创建一个形状为 (2, 3) 的张量,所有元素初始化为指定的值 5。

torch.randperm()
n = torch.randperm(5)
print(n)
tensor([4, 2, 3, 0, 1])

这将创建一个随机排列的 0 到 4 的整数序列,类似于 [2, 1, 4, 3, 0]。

解释浮点数

在PyTorch中,torch.linspace()函数生成的张量包含了从起始值到结束值(包括)之间的等间隔的数列。让我们解释一下为什么输出是浮点数:

关于输出的解释:

1. 数据类型推断:
   - 当使用torch.linspace(0, 10, 3) 时,PyTorch会默认生成浮点数张量,即使起始值和结束值是整数。
   - 这是因为在机器学习和科学计算中,通常需要高精度的数值计算,所以生成的默认类型是浮点数(float32或 float64)。

2. 张量中元素类型:

   - 在示例中,生成的张量是 torch.Tensor类型,其中包含浮点数值。
   - 在PyTorch中,默认的张量类型是 torch.float32(32位浮点数),但具体类型可能会根据环境和硬件配置而有所不同。

总结:
在科学计算和机器学习中,使用浮点数类型是常见的,因为它们提供了足够的精度来处理各种数值计算任务。因此,torch.linspace() 默认生成的张量包含浮点数元素,即使起始值和结束值可以是整数。

tensor的属性

介绍

dtype返回张量中元素的数据类型。
shape 和 sizetensor.shape 或 tensor.size():返回张量的形状,可以使用两者互换使用。
tensor.size(dim):返回张量在指定维度上的大小。
dim返回张量的维度数
gradtensor.grad:返回张量的梯度。如果张量是一个叶子节点并且未执行反向传播,则 tensor.grad 通常为 None。
 
device返回张量当前所在的设备
requires_gradis_leaftensor.requires_grad:返回一个布尔值,指示张量是否需要计算梯度。
tensor.is_leaf:返回一个布尔值,指示张量是否是计算图中的叶子节点。
Ttensor.T 或 tensor.transpose(dim0, dim1):返回张量的转置(仅限于二维张量)或指定维度的转置。

代码演示

import torch
a=torch.tensor([[1,2,3],[2,3,4]],dtype=torch.float)
print(a.dtype)
print(a.shape)
print(a.size())
print(a.size(0))
print(a.size(1))
print(a.dim())
print(a.grad)
print(a.device)
torch.float32
torch.Size([2, 3])
torch.Size([2, 3])
2
3
2
None
cpu

tensor的变形

这些函数在处理张量时提供了灵活性和便利性,使得可以根据具体需要进行形状和维度的变换,是深度学习中常用的操作之一。选择合适的函数取决于需求和操作的具体特性,如内存共享、维度压缩等。

1. reshape() 方法

c = b.reshape(2, 3)

作用:将张量 b 变形为指定的形状 (2, 3),并返回新的张量 c。
注意:返回的新张量和原张量共享内存,即它们指向相同的数据,但形状不同。

2. view() 方法

d = b.view(1, 6)

作用:将张量 b 变形为指定的形状 (1, 6),并返回新的张量 d。
注意:与 reshape() 类似,但在处理不连续的张量时会有区别。也可以用来扩展或收缩维度,但不支持所有操作。

3. flatten() 方法

b = a.flatten()

作用:将高维张量拉平为一维张量,并返回新的张量 b。
注意:返回的张量是原张量在内存中连续存储的版本,因此可能与原张量不共享内存。

4. squeeze() 方法

e = torch.squeeze(d)

作用:去除张量 d 中所有维度为 1 的维度,并返回新的张量 e。
注意:如果 d 中没有维度为 1 的维度,则返回的张量与 d 是相同的。可以用来压缩维度。

5. unsqueeze() 方法

f = torch.unsqueeze(e, 0)

作用:在指定维度上增加一个维度,并返回新的张量 f。
注意:可以在任何维度上增加维度,以扩展张量的形状。

代码演示

import torch
a=torch.tensor([[1,2,3],[4,5,6]],dtype=torch.float)
print("a的值:",a)
print("a的形状:",a.shape)b=a.flatten()#拉平为一维
print("b的值:",b)
print("b的形状:",b.shape)c=b.reshape(2,3)
print("c的值:",c)
print("c的形状:",c.shape)d=b.view(1,6)
print("d的值:",d)
print("d的形状:",d.shape)e=torch.squeeze(d)
print("e的值:",e)
print("e的形状:",e.shape)f=torch.unsqueeze(e,0)
print("f的值:",f)
print("f的形状:",f.shape)f=torch.unsqueeze(e,1)
print("f的值:",f)
print("f的形状:",f.shape)
a的值: tensor([[1., 2., 3.],[4., 5., 6.]])
a的形状: torch.Size([2, 3])
b的值: tensor([1., 2., 3., 4., 5., 6.])
b的形状: torch.Size([6])
c的值: tensor([[1., 2., 3.],[4., 5., 6.]])
c的形状: torch.Size([2, 3])
d的值: tensor([[1., 2., 3., 4., 5., 6.]])
d的形状: torch.Size([1, 6])
e的值: tensor([1., 2., 3., 4., 5., 6.])
e的形状: torch.Size([6])
f的值: tensor([[1., 2., 3., 4., 5., 6.]])
f的形状: torch.Size([1, 6])
f的值: tensor([[1.],[2.],[3.],[4.],[5.],[6.]])
f的形状: torch.Size([6, 1])

tensor的索引与切片

张量的索引和切片操作非常类似于 Python 中列表的操作,但在多维情况下更加灵活和强大。使用这些操作可以高效地访问、修改和操作张量中的元素,是深度学习中数据处理的基础。

1. 索引单个元素

import torch# 创建一个张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])# 访问第一个元素(索引从0开始)
element = tensor[0, 0]
print(element)  # 输出:tensor(1)

作用:使用逗号分隔的索引来获取张量中特定位置的单个元素

2. 切片操作

# 切片获取第一行的所有元素
row = tensor[0, :]
print(row)  # 输出:tensor([1, 2, 3])# 切片获取第一列的所有元素
column = tensor[:, 0]
print(column)  # 输出:tensor([1, 4])# 切片获取部分子张量
sub_tensor = tensor[1:, 1:]
print(sub_tensor)
# 输出:
# tensor([[5, 6]])
  • 作用
    • : 表示取整个维度的所有元素。
    • start:end 表示从 start 索引到 end-1 索引的元素。
    • 省略 start 表示从该维度的起始位置开始,省略 end 表示取到该维度的末尾。

 3. 使用索引和切片修改张量的部分元素

# 修改元素
tensor[0, 0] = 10
print(tensor)
# 输出:
# tensor([[10,  2,  3],
#         [ 4,  5,  6]])# 修改子张量的元素
tensor[1:, 1:] = torch.tensor([[50, 60]])
print(tensor)
# 输出:
# tensor([[10,  2,  3],
#         [ 4, 50, 60]])

作用:可以通过索引和切片来修改张量中的特定元素或者部分区域的元素值

4. 使用布尔索引

mask = tensor > 5
print(mask)
# 输出:
# tensor([[ True, False, False],
#         [False,  True,  True]])# 使用布尔掩码获取满足条件的元素
filtered_tensor = tensor[mask]
print(filtered_tensor)
# 输出:
# tensor([10, 50, 60])
  • 作用:可以使用布尔张量作为索引,从而筛选出满足条件的元素。

代码演示 

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]], dtype=torch.float)
print(a)
print("a[1,2]的值:",a[1,2])
print("a[-1,-1]的值:",a[-1,-1])
print("a的第1行,第1列3行的值:",a[[1],[0,2]])
print("a的值大于4的索引:",a>4)
print("大于5输出a的值,否则输出b:\n",torch.where(a>5,a,b))
print(a)
print("a的第1列:",a[:,0])
print("a的第3列:",a[:,2])
print("a的第3列:",a[:,-1])
print("a的1到2列:",a[:,0:2])print("a的第1行:",a[0,:])
print("a的第2行:",a[1, :])
print("a的最后1行:",a[-1,:])
print("a的间隔行值",a[::2,::2])tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
a[1,2]的值: tensor(6.)
a[-1,-1]的值: tensor(9.)
a的第1行,第1列3行的值: tensor([4., 6.])
a的值大于4的索引: tensor([[False, False, False],[False,  True,  True],[ True,  True,  True]])
大于5输出a的值,否则输出b:tensor([[10., 10., 10.],[10., 10.,  6.],[ 7.,  8.,  9.]])
tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
a的第1列: tensor([1., 4., 7.])
a的第3列: tensor([3., 6., 9.])
a的第3列: tensor([3., 6., 9.])
a的1到3列: tensor([[1., 2.],[4., 5.],[7., 8.]])
a的第1行: tensor([1., 2., 3.])
a的第2行: tensor([4., 5., 6.])
a的最后1行: tensor([7., 8., 9.])
a的间隔行值 tensor([[1., 3.],[7., 9.]])

tensor的连接和拆分

张量的连接和拆分操作是在深度学习中常见的数据处理技术,可以帮助组织数据并进行复杂的模型构建。根据具体的需求,选择适当的函数来进行连接或拆分操作,可以有效地处理数据。

tensor的连接

torch.cat

import torch# 创建两个张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6]])# 在第一维度(行)上连接两个张量
concatenated_tensor = torch.cat((tensor1, tensor2), dim=0)
print(concatenated_tensor)
# 输出:
# tensor([[1, 2],
#         [3, 4],
#         [5, 6]])

作用:通过 torch.cat 可以沿指定的维度将多个张量连接起来。在上面的例子中,dim=0 表示在第一个维度(行)上进行连接,dim=1表示在第二维度(列)上进行连接。

torch.stack

# 创建两个张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6]])# 在新的维度上堆叠两个张量
stacked_tensor = torch.stack((tensor1, tensor2))
print(stacked_tensor)
# 输出:
# tensor([[[1, 2],
#          [3, 4]],
# 
#         [[5, 6]]])

作用:torch.stack 可以在一个新的维度上堆叠多个张量。在上面的例子中,会创建一个新的维度(第一维度),将 tensor1 和 tensor2 沿此维度堆叠。

代码演示

a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]], dtype=torch.float)
print(a)
print(b)
print("a,b按行拼接:\n",torch.cat((a,b),dim=0))
print("a,b按行拼接:\n",torch.cat((a,b),dim=0).shape)
print("a,b按列拼接:\n",torch.cat((a,b),dim=1))
print("a,b按列拼接:\n",torch.cat((a,b),dim=1).shape)print("a,b按行拼接:\n",torch.stack((a,b),dim=0))
print("a,b按行拼接:\n",torch.stack((a,b),dim=0).shape)
print("a,b按列拼接:\n",torch.stack((a,b),dim=1))
print("a,b按列拼接:\n",torch.stack((a,b),dim=1).shape)tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
tensor([[10., 10., 10.],[10., 10., 10.],[10., 10., 10.]])
a,b按行拼接:tensor([[ 1.,  2.,  3.],[ 4.,  5.,  6.],[ 7.,  8.,  9.],[10., 10., 10.],[10., 10., 10.],[10., 10., 10.]])
a,b按行拼接:torch.Size([6, 3])
a,b按列拼接:tensor([[ 1.,  2.,  3., 10., 10., 10.],[ 4.,  5.,  6., 10., 10., 10.],[ 7.,  8.,  9., 10., 10., 10.]])
a,b按列拼接:torch.Size([3, 6])
a,b按行拼接:tensor([[[ 1.,  2.,  3.],[ 4.,  5.,  6.],[ 7.,  8.,  9.]],[[10., 10., 10.],[10., 10., 10.],[10., 10., 10.]]])
a,b按行拼接:torch.Size([2, 3, 3])
a,b按列拼接:tensor([[[ 1.,  2.,  3.],[10., 10., 10.]],[[ 4.,  5.,  6.],[10., 10., 10.]],[[ 7.,  8.,  9.],[10., 10., 10.]]])
a,b按列拼接:torch.Size([3, 2, 3])

tensor的拆分

torch.split

# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4], [5, 6]])# 在指定维度上拆分张量
split_tensors = torch.split(tensor, split_size_or_sections=2, dim=0)
print(split_tensors)
# 输出:(拆分成两个张量)
# (tensor([[1, 2],
#          [3, 4]]), tensor([[5, 6]]))

作用:torch.split 可以在指定维度上将一个张量拆分成多个张量。在上面的例子中,split_size_or_sections=2 表示在第一个维度(行)上每两行拆分成一个张量。

torch.chunk

# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4], [5, 6]])# 在指定维度上均匀拆分张量
chunks = torch.chunk(tensor, chunks=3, dim=0)
print(chunks)
# 输出:(拆分成三个张量)
# (tensor([[1, 2]]), tensor([[3, 4]]), tensor([[5, 6]]))

作用:torch.chunk 可以在指定维度上将一个张量均匀地拆分成多个张量。在上面的例子中,chunks=3 表示在第一个维度(行)上均匀拆分成三个张量。

补充

torch.split 和 torch.chunk 的返回值确实是元组形式。具体来说:
torch.split 返回一个元组,元组中包含拆分后的多个张量。每个张量的形状取决于拆分的方式和维度。
torch.chunk 同样返回一个元组,元组中包含均匀拆分后的多个张量。每个张量的形状取决于拆分的方式和维度。

代码演示

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
print(a)
print(torch.split(a,2,dim=0))
print(torch.split(a,1,dim=0))
print(torch.split(a,1,dim=1))print(torch.chunk(a,2,dim=0))
print(torch.chunk(a,2,dim=1))tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
(tensor([[1., 2., 3.],[4., 5., 6.]]), tensor([[7., 8., 9.]]))
(tensor([[1., 2., 3.]]), tensor([[4., 5., 6.]]), tensor([[7., 8., 9.]]))
(tensor([[1.],[4.],[7.]]), tensor([[2.],[5.],[8.]]), tensor([[3.],[6.],[9.]]))
(tensor([[1., 2., 3.],[4., 5., 6.]]), tensor([[7., 8., 9.]]))
(tensor([[1., 2.],[4., 5.],[7., 8.]]), tensor([[3.],[6.],[9.]]))

tensor的换位与置换

1    T与torch.t()

只接收二维数组

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
print(a)
print(a.T)#只接收二维
print(torch.t(a))#只接收二维tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])

将行和列进行交换

2   .transpose()

.transpose() 方法可以用来交换张量的两个维度的顺序。只接收二维数组

import torch# 创建一个张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])# 使用 transpose 方法交换维度
transposed_tensor = tensor.transpose(0, 1)  # 交换第0维和第1维
print(transposed_tensor)
# 输出:
# tensor([[1, 4],
#         [2, 5],
#         [3, 6]])

tensor.transpose(0, 1) 将第0维和第1维进行了交换,原来的行变成了列,列变成了行。

3   .permute()

.permute() 方法允许对张量的维度进行任意排列,可以不是二维

# 创建一个张量
tensor = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])# 使用 permute 方法对维度进行置换
permuted_tensor = tensor.permute(2, 0, 1)  # 将第2维放在第0维,第0维放在第1维,第1维放在第2维
print(permuted_tensor)
# 输出:
# tensor([[[1, 3],
#          [5, 7]],
# 
#         [[2, 4],
#          [6, 8]]])

tensor.permute(2, 0, 1) 将原始张量的第2维移动到第0维的位置,第0维移动到第1维的位置,第1维移动到第2维的位置,从而实现了张量维度的置换。

代码演示

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
print(a)
print(a.T)#只接收二维
print(torch.t(a))#只接收二维
print(torch.transpose(a,1,0))#只接收二维
print(a.permute(1,0))#不只接收二维c=torch.unsqueeze(a,0)
print(c)
print(c.shape)
print(c.permute(1,0,2).shape)tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])
tensor([[1., 4., 7.],[2., 5., 8.],[3., 6., 9.]])
tensor([[[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]]])
torch.Size([1, 3, 3])
torch.Size([3, 1, 3])

tensor的运算

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]], dtype=torch.float)
print(a)
print(b)
print(a+100)#点加
print(a + b)#点加
print(a.add(b))#点加print(a*b)#点乘
print(a@b)#矩阵相乘
print(a.matmul(b))#矩阵相乘
print(torch.mm(a,b))#矩阵相乘tensor([[1., 2., 3.],[4., 5., 6.],[7., 8., 9.]])
tensor([[10., 10., 10.],[10., 10., 10.],[10., 10., 10.]])
tensor([[101., 102., 103.],[104., 105., 106.],[107., 108., 109.]])
tensor([[11., 12., 13.],[14., 15., 16.],[17., 18., 19.]])
tensor([[11., 12., 13.],[14., 15., 16.],[17., 18., 19.]])
tensor([[10., 20., 30.],[40., 50., 60.],[70., 80., 90.]])
tensor([[ 60.,  60.,  60.],[150., 150., 150.],[240., 240., 240.]])
tensor([[ 60.,  60.,  60.],[150., 150., 150.],[240., 240., 240.]])
tensor([[ 60.,  60.,  60.],[150., 150., 150.],[240., 240., 240.]])

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/45035.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

HNU-2024操作系统实验-Lab9-Shell

一、 实验目的 理解Shell程序的原理、底层逻辑和Shell依赖的数据结构等 在操作系统内核MiniEuler上实现一个可用的Shell程序 能够根据相关原理编写一条可用的Shell指令 二、 实验过程 首先从底层出发&#xff0c;实现Shell程序 1.在src/include目录下新建prt_shell.h头文…

产线工控安全怎么做

随着工业自动化的推进&#xff0c;工控系统在现代生产线中的应用越来越广泛&#xff0c;但随着网络安全威胁的不断演变&#xff0c;产线工控系统的安全也面临着前所未有的挑战。面对这种情况&#xff0c;可以使用MCK主机加固&#xff08;深信达&#xff09;解决方案为产线工控安…

ROS基础学习-ROS运行管理

ROS运行管理 目录 1. ROS运行管理简述2. ROS元功能包2.1 概念2.2 作用2.3 实现 3. ROS-launch文件3.1. ROS节点管理launch文件3.1.1 概念3.1.2 作用3.1.3 使用 3.2 launch文件标签 1. ROS运行管理简述 ROS是多进程(节点)的分布式框架&#xff0c;一个完整的ROS系统实现&#x…

C++ 入门08:运算符重载

往期回顾&#xff1a; C 入门05&#xff1a;类和对象-CSDN博客 C 入门06&#xff1a;类的进阶&#xff08;构造函数的重载与拷贝构造函数&#xff09;-CSDN博客 C 入门07&#xff1a;静态成员和常量成员-CSDN博客 一、前言 在前面的文章学习中&#xff0c;我们学习了类和对象的…

在Spring Boot项目中集成分布式追踪系统

在Spring Boot项目中集成分布式追踪系统 大家好&#xff0c;我是微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01; 在复杂的分布式系统中&#xff0c;定位和解决问题是一项挑战。分布式追踪系统通过跟踪请求的调用链&#xf…

基于搭载 DJYOS 的 STM32H730 的低空无人驾驶无人机解决方案探究

摘要&#xff1a;本文详细阐述了一种基于搭载 DJYOS 的 STM32H730 开发的低空无人驾驶无人机解决方案。通过对其硬件配置、飞控系统、传感器应用、动力与续航以及操控方式等方面的深入分析&#xff0c;展现了该方案在低空无人驾驶领域的创新性和优势&#xff0c;为相关技术的发…

最新 Kubernetes 集群部署 + Contranerd容器运行时 + flannel 网络插件(保姆级教程,最新 K8S 1.28.2 版本)

资源列表 操作系统配置主机名IP所需插件CentOS 7.92C4Gk8s-master192.168.60.143flannel-cni-plugin、flannel、coredns、etcd、kube-apiserver、kube-controller-manager、kube-proxy、 kube-scheduler 、containerd、pause 、crictlCentOS 7.92C4Gk8s-node01192.168.60.144f…

VScode代码对齐快捷键

解决复制过来代码对齐格式问题。 左对齐&#xff1a;Ctrl[ 右对齐&#xff1a;Ctrl]

always块敏感列表的相关报错,

在综合的时候&#xff0c;报错如下 Synthesis synth_1 [Synth 8-91] ambiguous clock in event control ["E:/FPGA/FPGA_project/handwrite_fft/handwrite_fft.srcs/sources_1/new/reg_s2p.v":140] 猜测报错原因&#xff08;暂时没有时间寻找原因&#xff0c;后续在…

web自动化环境搭建[基于Chrome]+常用元素定位方式

下载chrome&#xff1a;可以使用电脑自带软件[HUES,360等]下载 下载chromedriver&#xff1a; 老版本地址:http://chromedriver.storage.googleapis.com/index.html,选择点击进去&#xff0c;有个notes.txt文件查看支持版本 最新版本:https://googlechromelabs.github.io/chro…

mac python

1. 默认在 /usr/bin/ 目录&#xff0c;安装目录在 /Users/wangjun/Library/Python/3.9/lib/python/site-packages 2. 安装自己的python。 无需理会上面的版本。 访问 Python Release Python 3.12.4 | Python.org 安装即可 使用 python3 pip3 /usr/local/bin

AI虚拟医生重塑医患关系

如今&#xff0c;越来越多的企业开始选择用AI虚拟数字人播报员替代真人出镜&#xff0c;这不仅有助于企业实现降本增效的目标&#xff0c;更能让广告传播趋向多样化和个性化。对于普通人而言&#xff0c;也摆脱了真人出镜的种种烦恼&#xff0c;让表达更加自由与便捷。AI虚拟数…

一个简单的基于Qt的MVC框架

如下是一个简单的基于Qt的MVC框架示例&#xff0c;其中模型&#xff08;Model&#xff09;中的操作会在子线程中处理。这个示例将包括一个基本的视图&#xff08;View&#xff09;、控制器&#xff08;Controller&#xff09;和模型&#xff08;Model&#xff09;。 1. 项目结…

5,智能合约(react+区块链实战)

5&#xff0c;智能合约&#xff08;react区块链实战&#xff09; 5-1 智能合约5-2 metamask安装及私有链搭建互相联动5-3 solidity数据类型-布尔-数字-地址&#xff08;owner区别&#xff09;5-4 solidity 数组和映射&#xff08;代币转账&#xff09;5-5 solidity结构体与枚举…

视频怎么压缩变小?最佳视频压缩器

即使在云存储和廉价硬盘空间时代&#xff0c;大视频文件使用起来仍然不方便。无论是存储、发送到电子邮件帐户还是刻录到 DVD&#xff0c;拥有最好的免费压缩软件可以确保您快速缩小文件大小&#xff0c;而不必担心视频质量下降。继续阅读以探索一些顶级最佳 免费视频压缩器选项…

排序(二)——快速排序(QuickSort)

欢迎来到繁星的CSDN&#xff0c;本期内容包括快速排序(QuickSort)的递归版本和非递归版本以及优化。 一、快速排序的来历 快速排序又称Hoare排序&#xff0c;由霍尔 (Sir Charles Antony Richard Hoare) &#xff0c;一位英国计算机科学家发明。霍尔本人是在发现冒泡排序不够快…

【操作系统】单例模式

目录 单例模式一. 什么是单例模式二. 饿汉模式三. 懒汉模式四. 多线程下的懒汉模式 单例模式 一. 什么是单例模式 在接下来的学习中我会依次为大家介绍以下几种设计模式&#xff1a; 单例模式工厂模式适配器模式门面模式代理模式 单例模式简单来说就是多次调用只有这一个对…

oracle 23ai新的后台进程bgnn介绍

前言 昨天发文研究了哪些oracle 后台不能杀 具体文章如下链接 oracle哪些后台进程不能杀&#xff1f;-CSDN博客 其中23ai中新增了一个后台进程bgnn 但是在oracle 23ai database reference中并没有找到该后台进程 有点不甘心就开了个SR&#xff0c;找oracle 官方来看看这个后…

构建工具webpackvite

1. webpack 使用步骤: 1.初始化项目yarn init -y&#xff08;也可以是npm其他包管理工具&#xff09; 2.安装依赖webpack webpack-cli&#xff1a;yarn add -D webpack webpack-cli&#xff08;-D是只用于开发时候加&#xff09; 3.在项目中创建src目录&#xff0c;然后编写代…

开发编码规范笔记

前言 &#xff08;1&#xff09;该博客仅用于个人笔记 格式转换 &#xff08;1&#xff09;查看是 LF 行尾还是CRLF 行尾。 # 单个文件&#xff0c;\n 表示 LF 行尾。\r\n 表示 CRLF 行尾。 hexdump -c <yourfile> # 单个文件&#xff0c;$ 表示 LF 行尾。^M$ 表示 CRLF …