AI学习(3): PyTorch-初识张量
1.介绍
PyTorch中的张量（tensor）是其核心数据结构，表示任意维度的数组。张量可以用于存储和处理数据，是PyTorch中的基本构建模块。
在PyTorch中，张量是torch.Tensor类的实例，它提供了丰富的方法和功能，用于进行数值计算和深度学习模型的构建与训练。
1.1 创建函数
在PyTorch中，有多种方法可以创建张量，如:torch.tensor()、torch.as_tensor()、torch.from_numpy()等。这些方法在处理不同类型的数据和内存共享方面有所不同，开发者可以根据具体需求选择合适的方法来创建张量;
torch.tensor() 是 PyTorch 中常用于创建张量的函数之一。该函数可以从其他 Python 可迭代对象（如列表、元组）或 NumPy 数组中创建张量。下面是 torch.tensor() 函数的主要参数和它们的含义：
torch.tensor(data, dtype=None, device=None, requires_grad=False)
参数说明：
-
data(必填): 要转换为张量的数据。可以是Python列表(list)、元组(tuple)、NumPy数组等可迭代对象。 -
dtype(可选): 指定张量的数据类型。如果不提供，PyTorch将尝试推断数据类型。 -
device(可选): 指定张量存储的设备，可以是CPU或GPU。如果不提供，将使用默认设备。 -
requires_grad(可选): 是否启用自动求导机制，以便追踪对张量的操作并计算梯度，默认False。
@注意:使用
as_tensor()创建张量，将共享底层数据，对张量的修改会影响原始数据。
1.2 重要属性
张量(tensor)有很多重要的属性。以下是一些常用的 torch.Tensor 属性：
import numpy as np
import torch
if __name__ == "__main__":
# 张量创建
# 从numpy中创建张量
numpyArray = np.array([
[1, 2, 3],
[4, 5, 6]
])
numpyTensor = torch.tensor(numpyArray)
print("numpyTensor: ", numpyTensor)
print("形状: ", numpyTensor.shape)
print("数据类型: ", numpyTensor.dtype)
print("放置设备(GPU|CPU): ", numpyTensor.device)
print("自动求导属性: ", numpyTensor.requires_grad)
print("梯度信息: ", numpyTensor.grad)
print("梯度函数: ", numpyTensor.grad_fn)
"""
numpyTensor: tensor([[1, 2, 3],
[4, 5, 6]])
形状: torch.Size([2, 3])
数据类型: torch.int64
放置设备(GPU|CPU): cpu
自动求导属性: False
梯度信息: None
梯度函数: None
"""
1.3 数据类型
在使用torch.tensor()函数创建张量时，可以使用参数dtype指定张量的元素类型，如:
# 指定张量类型为:torch.float32
torch.tensor([1, 2, 3], dtype=torch.float32)
以下是 torch.Tensor 支持的常见数据类型列表：
| 数据类型 | 描述 |
|---|---|
torch.int8 |
8位有符号整数 |
torch.int16 |
16位有符号整数 |
torch.int32 |
32位有符号整数 |
torch.int64 |
64位有符号整数 |
torch.uint8 |
8位无符号整数 |
torch.float16 |
16位浮点数 |
torch.float32 |
32位浮点数 |
torch.float64 |
64位浮点数 |
torch.complex64 |
64位复数（32位实部和虚部） |
torch.complex128 |
128位复数（64位实部和虚部） |
torch.bool |
布尔类型（True 或 False） |
2.张量创建
2.1 基于列表创建
import numpy as np
import torch
# 从list中创建张量
listTensor = torch.tensor([1, 2, 3])
2.2 基于numpy创建
import numpy as np
import torch
if __name__ == "__main__":
# 从numpy中创建张量
numpyArray = np.array([
[1, 2, 3],
[4, 5, 6]
])
# 使用函数:from_numpy
numpyTensorA = torch.from_numpy(numpyArray)
print("numpyTensorA: ", numpyTensorA)
# 使用函数: torch.tensor
numpyTensorB = torch.tensor(numpyArray)
print("numpyTensorB: ", numpyTensorB)
2.3 更多函数使用
PyTorch除了上面常用的torch.tensor创建张量函数外,还提供了很多便捷函数类创建张量，常用函数使用如下:
import torch
# -------------------- 特殊张量 --------------------
# 创建指定形状的全零张量
zeroTensor = torch.zeros((2, 3))
# 创建指定形状的全一张量
oneTensor = torch.ones((2, 3))
# 创建指定形状的单位矩阵
eyeTensor = torch.eye(3)
# 创建未初始化的张量
uninitializedTensor = torch.empty((2, 3))
# -------------------- END --------------------
# -------------------- 数学张量 --------------------
# 创建等差数列张量
arithmeticTensor = torch.arange(1, 10, 2)
# 创建随机张量（均匀分布）
randTensor = torch.rand((2, 3))
# 创建正态分布张量
randnTensor = torch.randn((2, 3))
# 创建指定范围内的均匀分布张量
linspaceTensor = torch.linspace(0, 1, 5)
# -------------------- END --------------------
# -------------------- 模仿创建 --------------------
# 原始张量
originalTensor = torch.tensor([[1, 2], [3, 4]])
# 创建与原始张量，形状一致，值都是0的张量
zerosLikeTensor = torch.zeros_like(originalTensor)
# 创建与原始张量，形状一致，值都是1的张量
onesLikeTensor = torch.ones_like(originalTensor)
# -------------------- END --------------------
3.张量访问
在 PyTorch 中，张量的常见访问方式包括索引、切片、以及一些常用的方法。以下是部分的代码示例：
3.1 使用索引
import numpy as np
import torch
if __name__ == "__main__":
# 基于numpy创建多维张量
npArray = np.arange(12).reshape(3, 4)
npTensor = torch.tensor(npArray)
print("多维张量:\n", npTensor)
# 使用索引访问
print("访问索引=0:", npTensor[0])
print("访问索引=1:", npTensor[1])
# 访问单个元素
print("访问单个元素[0,2]:", npTensor[0, 2])
print("访问单个元素[1,2]:", npTensor[1, 2])
print("访问单个元素[2,2]:", npTensor[2, 2])
"""
多维张量:
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
访问索引=0: tensor([0, 1, 2, 3])
访问索引=1: tensor([4, 5, 6, 7])
访问单个元素[0,2]: tensor(2)
访问单个元素[1,2]: tensor(6)
访问单个元素[2,2]: tensor(10)
"""
3.2 使用切片
import numpy as np
import torch
if __name__ == "__main__":
# 基于numpy创建多维张量
npArray = np.arange(15).reshape(5, 3)
npTensor = torch.tensor(npArray)
print("多维张量:\n", npTensor)
# 根据范围访问行数
print("访问 npTensor[:2]: \n", npTensor[:2])
print("访问 npTensor[1:3] \n", npTensor[1:3])
# 访问具体行
print("访问第一行: ", npTensor[0, :])
# 访问具体列
print("访问第二列: ", npTensor[:, 1])
# 获取部分张量，从第二行开始（索引为1），取每行的前两列（索引为:2）
print("获取部分张量: \n", npTensor[1:, :2])
# 使用步长获取数据
print("访问偶数列: \n", npTensor[::2])
"""
多维张量:
tensor([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14]])
访问 npTensor[:2]:
tensor([[0, 1, 2],
[3, 4, 5]])
访问 npTensor[1:3]
tensor([[3, 4, 5],
[6, 7, 8]])
访问第一行: tensor([0, 1, 2])
访问第二列: tensor([ 1, 4, 7, 10, 13])
获取部分张量:
tensor([[ 3, 4],
[ 6, 7],
[ 9, 10],
[12, 13]])
访问偶数列:
tensor([[ 0, 1, 2],
[ 6, 7, 8],
[12, 13, 14]])
"""
4.张量运算
4.1 基本运算
import torch
if __name__ == "__main__":
# 创建两个张量
tensorA = torch.tensor([[1, 2], [3, 4]])
tensorB = torch.tensor([[5, 6], [7, 8]])
# 加法
sumResult = tensorA + tensorB
print("加法:\n", sumResult)
# 减法
subtraction_result = tensorA - tensorB
print("减法:\n", subtraction_result)
# 乘法（逐元素相乘）
multiplyResult = tensorA * tensorB
print("乘法: \n", multiplyResult)
# 除法（逐元素相除）
divideResult = tensorA / tensorB
print("除法: \n", divideResult)
"""
加法:
tensor([[ 6, 8],
[10, 12]])
减法:
tensor([[-4, -4],
[-4, -4]])
乘法:
tensor([[ 5, 12],
[21, 32]])
除法:
tensor([[0.2000, 0.3333],
[0.4286, 0.5000]])
"""
4.2 统计运算
import torch
import numpy as np
if __name__ == "__main__":
# 创建张量
numpyArray = np.arange(12).reshape((3, 4))
tensorData = torch.tensor(numpyArray)
print("原始数据:\n", tensorData)
# 求和
sumTensor = torch.sum(tensorData)
print("求和:", sumTensor)
# 平均值
meanTensor = torch.mean(tensorData.float())
print("平均值:", meanTensor)
# 转换为浮点数类型
# 标准差和方差仅支持浮点数和复数类型的张量，不支持整数类型的张量。在进行这两个操作之前，需要将张量的数据类型转换为浮点数或复数类型。
tensorFloat = tensorData.float()
# 标准差
stdTensor = torch.std(tensorFloat)
print("标准差:", stdTensor.item())
# 方差
varianceTensor = torch.var(tensorFloat)
print("方差:", varianceTensor.item())
# 最大值
maxTensor = torch.max(tensorData)
print("最大值:", maxTensor.item())
# 最小值
minTensor = torch.min(tensorData)
print("最小值:", minTensor.item())
# 按维度进行统计运算
dimSumTensor = torch.sum(tensorData, dim=0)
print("计算每列(dim=0)的和: \n", dimSumTensor)
dimMeanTensor = torch.mean(tensorFloat, dim=0)
print("计算每列(dim=0)的平均值: \n", dimMeanTensor)
"""
原始数据:
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
求和: tensor(66)
平均值: tensor(5.5000)
标准差: 3.605551242828369
方差: 13.0
最大值: 11
最小值: 0
计算每列(dim=0)的和:
tensor([12, 15, 18, 21])
计算每列(dim=0)的平均值:
tensor([4., 5., 6., 7.])
"""
4.3 矩阵运算
import torch
if __name__ == "__main__":
# 创建一个二维张量（矩阵）
matrix_a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 转置
transposed_matrix_a = matrix_a.T
print("转置:\n", transposed_matrix_a)
# 矩阵乘法
matrix_b = torch.tensor([[2, 0, 1], [1, 2, 3], [4, 5, 6]])
matrix_multiply_result = torch.matmul(matrix_a, matrix_b)
print("矩阵乘法:\n", matrix_multiply_result)
"""
转置:
tensor([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])
矩阵乘法:
tensor([[16, 19, 25],
[37, 40, 55],
[58, 61, 85]])
"""
本文由 mdnice 多平台发布