深度学习框架PyTorch笔记（二）PyTorch张量（Tensor）小结

深度学习框架PyTorch笔记（二）

PyTorch张量（Tensor）

​ 张量（Tensor）是一个多维数组，可以是标量、向量、矩阵或更高维度的数据结构。在PyTorch中，张量（Tensor）是数据的核心表示形式，类似于NumPy的多维数组，但具有更强大的功能，例如支持GPU加速和自动梯度计算。张量支持多种数据类型（整型、浮点型、布尔型等）。张量可以存储在CPU或GPU中，GPU张量可显著加速计算。其不同维度张量说明如下：

• 1D Tensor/Vector （一维张量或向量）： 最基本的张量形式，可以看作是一个数组，图中的例子是一个包含10个元素的向量。

• 2D Tensor/Matrix （二维张量或矩阵）： 二维数组，通常用于表示矩阵，图中的例子是一个\(4\times5\)的矩阵，包含了20个元素。

• 3D Tensor/Cube （三维张量或标量立方体）：三维数组，可以看作是由多个矩阵堆叠而成立方体，图中的例子中展示了一个\(3\times4\times5\), 其中每个\(4\times5\) 的矩阵代表立方体的一个“层”。

• 4D Tensor/ Vector of Cubes （四维张量/立方体向量）：四维数组，可以看作是由多个立方体组成的向量中的例子没有具体数值，但是可以理解为一个包含了多个3D张量的集合。

• 5D Tensor/Matrix of Cubes （五维张量/立方体矩阵）： 五维数组，可以看作是由多个4D张量的组成的矩阵，图中的例子同样没有具体数值，但可以理解为一个包含了多个4D张量的集合。

（一）张量的基本概念与属性

​ 张量是Pytorch深度学习框架中的存储和变换数据的主要工具，其核心特性与构成如下：

• 张量的定义：张量是一个包含同一种数据类型元素的多维矩阵，可以表示标量（0维）、向量（1维）、矩阵（2维）或者更高维度的数据。

• 与NumPy数组的关系：PyTorch张量Tensor与NumPy的ndarray非常相似，两者可以无缝转换，这为数据的预处理和科学计算提供了极大的便利。

• 张量核心属性： 每个张量都包含了几个关键的属性，用于描述其状态。

  • 张量的形状(Shape of tensor): 一个元组，表示张量在每个维度上的大小，可通过\(.shape\)或\(.size()\) 获取。
  • 数据类型(dtype)：定义张量中元素的类型，如torch.float32、torch.int64,torch.bool等，可以通过 .dtype 查看。
  • 设备(device)：指示张量存储在于CPU内存还是GPU显存中，这是实现GPU加速计算的关键，可通过 .device查看。

  其总结如下：

  属性	说明	示例
  .shape	获取张量的形状	tensor.shape
  .size()	获取张量的形状	tensor.size()
  .dtype	获取张量的数据类型	tensor.dtype
  .device	查看张量所在的设备 (CPU/GPU)	tensor.device
  .dim()	获取张量的维度数	tensor.dim()
  .requires_grad	是否启用梯度计算	tensor.requires_grad
  .numel()	获取张量中的元素总数	tensor.numel()
  .is_cuda	检查张量是否在 GPU 上	tensor.is_cuda
  .T	获取张量的转置（适用于 2D 张量）	tensor.T
  .item()	获取单元素张量的值	tensor.item()
  .is_contiguous()	检查张量是否连续存储	tensor.is_contiguous()

（二）张量的创建

张量创建的方式可以总结如下表：

pyTorch的方法	代码说明	示例代码
torch.tensor(data)	从Python列表或NumPy数组创建张量	x=torch.tensor([[1,2],[3,4]])
torch.zeros(size)	创建一个尺寸为size，元素全为0的张量	x=torch.zeros((2,3))
torch.ones(size)	创建一个尺寸为size，全为1的张量	x=torch.ones((2,3))
torch.empty(size)	创建一个尺寸为size，未初始化的张量	x=torch.empty((2,3))
torch.rand(size)	创建一个尺寸为size，服从均匀分布的随机张量，值在[0,1].	x=torch.rand((2,3))
torch.randn(size)	创建一个服从正态分布的随机张量，均值为0，标准差为1.	x=torch.randn((2,3))
torch.arange(start,end,step)	创建一个一维序列张量，类似于Python的range	x=torch.arange(0,10,2)
torch.linspace(start,end,nsteps)	创建一个在指定范围内等间隔的序列张量。	x=torch.linspace(0,1,5)
torch.eye(size)	创建一个单位矩阵（对角线为1，其他为0）	x=torch.eye(3)
torch.from_numpy(ndarray)	将NumPy数组转为张量。	x=torch.from_numpy(np.array([1,2,3]))

示例：

import torch

# 创建一个 2D 张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)

# 张量的属性
print("Tensor:\n", tensor)
print("Shape:", tensor.shape)  # 获取形状
print("Size:", tensor.size())  # 获取形状（另一种方法）
print("Data Type:", tensor.dtype)  # 数据类型
print("Device:", tensor.device)  # 设备
print("Dimensions:", tensor.dim())  # 维度数
print("Total Elements:", tensor.numel())  # 元素总数
print("Requires Grad:", tensor.requires_grad)  # 是否启用梯度
print("Is CUDA:", tensor.is_cuda)  # 是否在 GPU 上
print("Is Contiguous:", tensor.is_contiguous())  # 是否连续存储

# 获取单元素值
single_value = torch.tensor(42)
print("Single Element Value:", single_value.item())

# 转置张量
tensor_T = tensor.T
print("Transposed Tensor:\n", tensor_T)

输出结果：

Tensor:
 tensor([[1., 2., 3.],
         [4., 5., 6.]])
Shape: torch.Size([2, 3])
Size: torch.Size([2, 3])
Data Type: torch.float32
Device: cpu
Dimensions: 2
Total Elements: 6
Requires Grad: False
Is CUDA: False
Is Contiguous: True
Single Element Value: 42
Transposed Tensor:
 tensor([[1., 4.],
         [2., 5.],
         [3., 6.]])

（三）张量的操作

张量操作方法说明如下。张量基础操作：

操作	说明	示例代码
+, -, *, /	元素级加法、减法、乘法、除法。	z = x + y
torch.matmul(x, y)	矩阵乘法。	z = torch.matmul(x, y)
torch.dot(x, y)	向量点积（仅适用于 1D 张量）。	z = torch.dot(x, y)
torch.sum(x)	求和。	z = torch.sum(x)
torch.mean(x)	求均值。	z = torch.mean(x)
torch.max(x)	求最大值。	z = torch.max(x)
torch.min(x)	求最小值。	z = torch.min(x)
torch.argmax(x, dim)	返回最大值的索引（指定维度）。	z = torch.argmax(x, dim=1)
torch.softmax(x, dim)	计算 softmax（指定维度）。	z = torch.softmax(x, dim=1)

张量形状操作：

操作	说明	示例代码
x.view(shape)	改变张量的形状（不改变数据）。	z = x.view(3, 4)
x.reshape(shape)	类似于 view，但更灵活。	z = x.reshape(3, 4)
x.t()	转置矩阵。	z = x.t()
x.unsqueeze(dim)	在指定维度添加一个维度。	z = x.unsqueeze(0)
x.squeeze(dim)	去掉指定维度为 1 的维度。	z = x.squeeze(0)
torch.cat((x, y), dim)	按指定维度连接多个张量。	z = torch.cat((x, y), dim=1)

示例操作：

import torch

# 创建一个 2D 张量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
print("原始张量:\n", tensor)

# 1. **索引和切片操作**
print("\n【索引和切片】")
print("获取第一行:", tensor[0])  # 获取第一行
print("获取第一行第一列的元素:", tensor[0, 0])  # 获取特定元素
print("获取第二列的所有元素:", tensor[:, 1])  # 获取第二列所有元素

# 2. **形状变换操作**
print("\n【形状变换】")
reshaped = tensor.view(3, 2)  # 改变张量形状为 3x2
print("改变形状后的张量:\n", reshaped)
flattened = tensor.flatten()  # 将张量展平成一维
print("展平后的张量:\n", flattened)

# 3. **数学运算操作**
print("\n【数学运算】")
tensor_add = tensor + 10  # 张量加法
print("张量加 10:\n", tensor_add)
tensor_mul = tensor * 2  # 张量乘法
print("张量乘 2:\n", tensor_mul)
tensor_sum = tensor.sum()  # 计算所有元素的和
print("张量元素的和:", tensor_sum.item())

# 4. **与其他张量的操作**
print("\n【与其他张量操作】")
tensor2 = torch.tensor([[1, 1, 1], [1, 1, 1]], dtype=torch.float32)
print("另一个张量:\n", tensor2)
tensor_dot = torch.matmul(tensor, tensor2.T)  # 张量矩阵乘法
print("矩阵乘法结果:\n", tensor_dot)

# 5. **条件判断和筛选**
print("\n【条件判断和筛选】")
mask = tensor > 3  # 创建一个布尔掩码
print("大于 3 的元素的布尔掩码:\n", mask)
filtered_tensor = tensor[tensor > 3]  # 筛选出符合条件的元素
print("大于 3 的元素:\n", filtered_tensor)

输出结果：

原始张量:
 tensor([[1., 2., 3.],
         [4., 5., 6.]])

【索引和切片】
获取第一行: tensor([1., 2., 3.])
获取第一行第一列的元素: tensor(1.)
获取第二列的所有元素: tensor([2., 5.])

【形状变换】
改变形状后的张量:
 tensor([[1., 2.],
         [3., 4.],
         [5., 6.]])
展平后的张量:
 tensor([1., 2., 3., 4., 5., 6.])

【数学运算】
张量加 10:
 tensor([[11., 12., 13.],
         [14., 15., 16.]])
张量乘 2:
 tensor([[ 2.,  4.,  6.],
         [ 8., 10., 12.]])
张量元素的和: 21.0

【与其他张量操作】
另一个张量:
 tensor([[1., 1., 1.],
         [1., 1., 1.]])
矩阵乘法结果:
 tensor([[ 6.,  6.],
         [15., 15.]])

【条件判断和筛选】
大于 3 的元素的布尔掩码:
 tensor([[False, False, False],
         [ True,  True,  True]])
大于 3 的元素:
 tensor([4., 5., 6.])

（四）张量的GPU加速

​ 在使用PyTorch进行深度学习开发时，将张量(Tensor)移动到GPU上可以显著提高计算速度和效率。以下是一些基本的步骤和示例，帮助你将PyTorch张量转移到GPU上并利用GPU加速。

4.1 检查CUDA支持

首先，确保你的PyTorch按照是否支持CUDA，并且你的系统中有NVIDIA GPU和对应的CUDA驱动。

import torch

#检查CUDA是否可用
if torch.cuda.is_available():
  print("CUDA is available.GPU is ready!");
else:
  print("CUDA is not available.GPU acceleration is not possible.");

4.2 将张量移动到GPU端

​ 使用 .to(device)方法，其中 device可以是cuda(默认使用当前活动的GPU)或“cuda:0”（指定使用第二个GPU），等等。

# 创建一个张量
x=torch.randn(3,3)

#将张量移动到GPU
device=torch.device("cuda" if torch.cuda.is_available()else "cpu")
x=x.to(device)

#查看张量现在在哪个设备上
print(x)

4.3 使用GPU进行计算

一旦张量在GPU上，你可以在GPU上执行所有的计算操作。PyTorch会自动将计算转移到GPU上执行。

y=torch.randn(3,3).to(device)
z=x+y  #这将在GPU上执行
prin(z)

4.4 模型和数据转移到GPU

如果你正在使用神经网络模型，确保整个模型和数据都转移到GPU上。

# 定义一个简单的模型
model=torch.nn.Sequential(
			torch.nn.Linear(3,3),
      troch.nn.ReLU(),
  		torch.nn.Linear(3,2)
)
# 将模型和数据移动到GPU
model.to(device)
x=x.to(device)