PyTorch 基础学习（2）- 张量 Tensors

news2024/11/15 19:30:12

PyTorch张量简介

张量是数学和计算机科学中的一个基本概念，用于表示多维数据，是AI世界中一切事物的表示和抽象。可以将张量视为一个扩展了标量、向量和矩阵的通用数据结构。以下是对张量的详细解释：

张量的定义

标量（0阶张量）：标量是一个单一的数值，例如 3 或 -1.5。
向量（1阶张量）：向量是一维数组，可以表示为一列或一行数值，例如 ([1, 2, 3])。
矩阵（2阶张量）：矩阵是一个二维数组，包含行和列，例如：

$[ \begin{bmatrix} 1 & 2 & 3 \ 4 & 5 & 6 \end{bmatrix} ]$
高阶张量：高阶张量是更高维度的数组。例如，三阶张量可以被视为一个矩阵的集合，每个矩阵位于一个"层"上，如下所示：

$[ \begin{bmatrix} \begin{bmatrix} 1 & 2 \ 3 & 4 \end{bmatrix}, \begin{bmatrix} 5 & 6 \ 7 & 8 \end{bmatrix} \end{bmatrix} ]$

张量的特点

维度（阶）：张量的维度指的是数据的方向数。例如，一个三阶张量可以用一个3D数组表示，其中每个维度称为一个轴。
形状：张量的形状由沿每个轴的元素数量定义。例如，形状为(3, 4, 5)的张量意味着它有3个“层”，每个“层”包含4行5列的数据。
数据类型：张量可以存储不同类型的数据，如整数、浮点数等。

张量在机器学习中的应用

在深度学习和机器学习中，张量是处理和操作数据的基础。以下是一些应用示例：

图像数据：图像通常表示为3阶张量，其中维度分别表示高度、宽度和颜色通道。
时间序列数据：时间序列数据可以表示为2阶张量，其中一个维度表示时间步，另一个维度表示特征。
神经网络权重：在神经网络中，权重和偏置通常存储为张量，以便进行高效的计算。

将图像转换成张量

from PIL import Image
from torchvision import transforms

# 第一步：加载图像
image_path = 'path_to_your_image.jpg'  # 替换为你的图像路径
image = Image.open(image_path)

# 第二步：定义转换
transform = transforms.Compose([
    transforms.ToTensor()  # 将图像转换为张量，并将像素值归一化到[0, 1]之间
])

# 第三步：应用转换
image_tensor = transform(image)

# 查看结果
print(f"张量形状: {image_tensor.shape}")  # 输出张量形状，通常为 (C, H, W)
print(f"数据类型: {image_tensor.dtype}")  # 输出张量的数据类型

输出：

张量形状: torch.Size([3, 1024, 1024])  //一幅三通道（RGB）的 1024x1024 像素图像。
数据类型: torch.float32 //张量的数据类型为32位浮点数

张量计算

PyTorch等深度学习框架利用张量作为基本数据结构，因为它们可以高效地在GPU上进行并行计算。张量支持多种数学运算，如加法、乘法、转置、索引和切片等，这使得它们非常适合处理复杂的数据计算任务。

总结来说，张量是一个灵活且高效的数据结构，广泛用于科学计算、图像处理、自然语言处理等领域。通过使用张量，我们可以在计算机中有效地表示和操作高维数据。

张量操作

张量检测
- torch.is_tensor(obj)：判断对象obj是否是一个PyTorch张量，返回True或False。

元素个数

torch.numel(input)：返回张量input中的元素个数。

import torch

a = torch.randn(1, 2, 3, 4, 5)
print(torch.numel(a))  # 输出: 120

设置默认张量类型
- torch.set_default_tensor_type(t)：设置默认的张量类型。
打印选项
- torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)：设置张量打印的选项，如精度、行宽等。

张量创建

单位矩阵
- torch.eye(n, m=None, out=None)：返回一个2D单位矩阵。
```
print(torch.eye(3))
```
从Numpy数组创建张量
- torch.from_numpy(ndarray)：将Numpy数组转换为PyTorch张量。
```
import numpy as np

a = np.array([1, 2, 3])
t = torch.from_numpy(a)
```
线性间隔张量
- torch.linspace(start, end, steps=100, out=None)：创建一个1D张量，包含从start到end的等间隔数值。
```
print(torch.linspace(3, 10, steps=5))
```
对数间隔张量
- torch.logspace(start, end, steps=100, out=None)：在对数尺度上创建等间隔数值的1D张量。
```
print(torch.logspace(start=0.1, end=1.0, steps=5))
```
全1张量
- torch.ones(*sizes, out=None)：创建一个形状为sizes的全1张量。
```
print(torch.ones(2, 3))
```
随机张量
- torch.rand(*sizes, out=None)：创建一个形状为sizes的张量，包含均匀分布的随机数。
- torch.randn(*sizes, out=None)：创建一个形状为sizes的张量，包含标准正态分布的随机数。
排列张量
- torch.randperm(n, out=None)：生成从0到n-1的随机排列。
```
print(torch.randperm(4))
```

索引与切片

张量连接
- torch.cat(inputs, dimension=0)：在给定维度上连接张量序列。
```
x = torch.randn(2, 3)
print(torch.cat((x, x, x), 0))
```
张量分块
- torch.chunk(tensor, chunks, dim=0)：将张量分成指定数量的块。
选择性索引
- torch.index_select(input, dim, index, out=None)：在指定维度上选择特定的索引项。
```
x = torch.randn(3, 4)
indices = torch.LongTensor([0, 2])
print(torch.index_select(x, 0, indices))
```
非零元素索引
- torch.nonzero(input, out=None)：返回一个张量，包含非零元素的索引。
```
print(torch.nonzero(torch.Tensor([1, 1, 0, 0, 1])))
```
挤压与扩展
- torch.squeeze(input, dim=None, out=None)：移除形状中的1。
- torch.unsqueeze(input, dim, out=None)：在指定位置插入维度1。
```
x = torch.Tensor([1, 2, 3, 4])
print(torch.unsqueeze(x, 0))
```

随机抽样

设定随机数种子
- torch.manual_seed(seed)：设定随机数生成的种子。
伯努利分布
- torch.bernoulli(input, out=None)：从伯努利分布中抽取二元随机数。
```
a = torch.Tensor(3, 3).uniform_(0, 1)
print(torch.bernoulli(a))
```
多项分布抽样
- torch.multinomial(input, num_samples, replacement=False, out=None)：从多项分布中抽取样本。
正态分布
- torch.normal(means, std, out=None)：从正态分布中抽取样本。
```
print(torch.normal(means=torch.arange(1, 6)))
```

序列化

保存对象
- torch.save(obj, f)：保存对象到文件。
加载对象
- torch.load(f, map_location=None)：从文件加载对象。

并行化

获取和设置线程数
- torch.get_num_threads()：获取用于并行化CPU操作的线程数。
- torch.set_num_threads(int)：设置用于并行化CPU操作的线程数。

应用实例：线性回归模型

下面是一个简单的线性回归模型示例，展示了如何使用上述PyTorch操作实现基本的机器学习任务。

import torch
import torch.nn as nn
import torch.optim as optim

# 生成随机数据
x = torch.rand(100, 1) * 10  # 100个样本，每个样本有1个特征
y = 2 * x + 3 + torch.randn(100, 1)  # y = 2*x + 3 + 噪声

# 定义线性模型
model = nn.Linear(1, 1)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(1000):
    # 前向传播
    outputs = model(x)
    loss = criterion(outputs, y)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 100 == 0:
        print(f'Epoch [{epoch+1}/1000], Loss: {loss.item():.4f}')

# 打印模型参数
[w, b] = model.parameters()
print(f'Weight: {w.item()}, Bias: {b.item()}')

输出：

......
Epoch [800/1000], Loss: 1.1024
Epoch [900/1000], Loss: 1.1014
Epoch [1000/1000], Loss: 1.1011
Weight: 1.9926187992095947, Bias: 3.0762107372283936