python torch基础用法

import torch
import numpy as np

print("PyTorch 版本:", torch.__version__)
print("CUDA 是否可用:", torch.cuda.is_available())

# 1.1 创建张量
print("\n=== 创建张量 ===")

# 从列表创建
x = torch.tensor([1, 2, 3, 4])
print("从列表创建:", x)

# 创建全零张量
zeros = torch.zeros(2, 3)
print("全零张量:\n", zeros)

# 创建全一张量
ones = torch.ones(2, 3)
print("全一张量:\n", ones)

# 创建随机张量
rand_tensor = torch.rand(2, 3)
print("随机张量:\n", rand_tensor)

# 创建范围张量
arange = torch.arange(0, 10, 2)
print("范围张量:", arange)

# 1.2 张量属性
print("\n=== 张量属性 ===")
tensor = torch.rand(3, 4)
print("张量形状:", tensor.shape)
print("张量维度:", tensor.dim())
print("张量数据类型:", tensor.dtype)
print("张量设备:", tensor.device)

# 2.1 基本运算
print("\n=== 张量运算 ===")

a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])

print("a =", a)
print("b =", b)
print("a + b =", a + b)
print("a - b =", a - b)
print("a * b =", a * b)  # 逐元素乘法
print("a / b =", a / b)
print("a ** 2 =", a ** 2)

# 矩阵乘法
matrix_a = torch.rand(2, 3)
matrix_b = torch.rand(3, 2)
matrix_product = torch.matmul(matrix_a, matrix_b)
print(f"矩阵乘法: {matrix_a.shape} @ {matrix_b.shape} = {matrix_product.shape}")

# 2.2 张量变形
print("\n=== 张量变形 ===")

tensor = torch.arange(12)
print("原始张量:", tensor, "形状:", tensor.shape)

# reshape
reshaped = tensor.reshape(3, 4)
print("reshape(3, 4):\n", reshaped)

# view
viewed = tensor.view(3, 4)
print("view(3, 4):\n", viewed)

# 转置
transposed = reshaped.T
print("转置:\n", transposed)

# 2.3 张量索引和切片
print("\n=== 张量索引和切片 ===")

tensor = torch.arange(24).reshape(4, 6)
print("原始张量:\n", tensor)
print("第一行:", tensor[0])
print("第一列:", tensor[:, 0])
print("子矩阵:\n", tensor[1:3, 2:4])

print("\n=== 自动求导 ===")

# 3.1 基本自动求导
x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x + 1
y.backward()
print(f"x = {x}, y = {y}")
print(f"dy/dx = {x.grad}")

# 3.2 多变量求导
x1 = torch.tensor(1.0, requires_grad=True)
x2 = torch.tensor(2.0, requires_grad=True)
z = x1 ** 2 + x1 * x2 + x2 ** 2
z.backward()
print(f"\n多变量函数: z = x1² + x1*x2 + x2²")
print(f"∂z/∂x1 = {x1.grad}")
print(f"∂z/∂x2 = {x2.grad}")

# 3.3 梯度清零
x1.grad.zero_()
x2.grad.zero_()
print("\n梯度清零后:")
print(f"x1.grad = {x1.grad}")
print(f"x2.grad = {x2.grad}")

import torch.nn as nn
import torch.nn.functional as F

print("\n=== 神经网络基础 ===")

# 4.1 定义简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(10, 5)  # 输入10维，输出5维
        self.fc2 = nn.Linear(5, 2)   # 输入5维，输出2维
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建网络实例
model = SimpleNet()
print("网络结构:")
print(model)

# 4.2 查看参数
print("\n网络参数:")
for name, param in model.named_parameters():
    print(f"{name}: {param.shape}")

# 4.3 前向传播
input_data = torch.randn(1, 10)  # batch_size=1, input_size=10
output = model(input_data)
print(f"\n输入形状: {input_data.shape}")
print(f"输出形状: {output.shape}")
print(f"输出: {output}")

print("\n=== 损失函数和优化器 ===")

# 5.1 损失函数
criterion = nn.CrossEntropyLoss()

# 5.2 优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 5.3 模拟训练步骤
print("模拟训练过程:")

# 模拟数据
inputs = torch.randn(4, 10)  # batch_size=4, input_size=10
labels = torch.tensor([0, 1, 0, 1])  # 4个样本的标签

# 前向传播
outputs = model(inputs)
loss = criterion(outputs, labels)

print(f"初始损失: {loss.item():.4f}")

# 反向传播
optimizer.zero_grad()  # 梯度清零
loss.backward()        # 反向传播
optimizer.step()       # 更新参数

# 再次前向传播查看损失变化
outputs_after = model(inputs)
loss_after = criterion(outputs_after, labels)
print(f"一次更新后损失: {loss_after.item():.4f}")

from torch.utils.data import Dataset, DataLoader

print("\n=== 数据集和数据加载器 ===")

# 6.1 自定义数据集
class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

# 创建模拟数据
data = torch.randn(100, 10)  # 100个样本，每个10维
labels = torch.randint(0, 2, (100,))  # 100个二分类标签

dataset = CustomDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=8, shuffle=True)

print(f"数据集大小: {len(dataset)}")
print(f"数据加载器批次数: {len(dataloader)}")

# 6.2 遍历数据加载器
print("\n遍历前3个批次:")
for i, (batch_data, batch_labels) in enumerate(dataloader):
    print(f"批次 {i+1}: 数据形状 {batch_data.shape}, 标签形状 {batch_labels.shape}")
    if i == 2:  # 只显示前3个批次
        break

print("\n=== GPU 使用 ===")

# 7.1 检查设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {device}")

# 7.2 将模型和数据移动到GPU
model = SimpleNet().to(device)

# 创建一些数据并移动到设备
if torch.cuda.is_available():
    data_gpu = torch.randn(4, 10).to(device)
    labels_gpu = torch.tensor([0, 1, 0, 1]).to(device)
    
    output_gpu = model(data_gpu)
    print(f"GPU计算结果形状: {output_gpu.shape}")
    print(f"GPU计算结果设备: {output_gpu.device}")

print("\n=== 完整训练示例 ===")

# 8.1 准备数据
def generate_data(n_samples=1000):
    """生成简单的二分类数据"""
    X = torch.randn(n_samples, 2)
    # 根据到原点的距离创建标签
    y = (X[:, 0]**2 + X[:, 1]**2 > 1).long()
    return X, y

X, y = generate_data(1000)

# 分割训练集和测试集
train_size = int(0.8 * len(X))
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

print(f"训练集: {X_train.shape}, 测试集: {X_test.shape}")

# 8.2 定义模型
class Classifier(nn.Module):
    def __init__(self):
        super(Classifier, self).__init__()
        self.fc1 = nn.Linear(2, 10)
        self.fc2 = nn.Linear(10, 5)
        self.fc3 = nn.Linear(5, 2)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = Classifier()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 8.3 训练循环
def train_model(model, X_train, y_train, epochs=100):
    model.train()
    losses = []
    
    for epoch in range(epochs):
        # 前向传播
        outputs = model(X_train)
        loss = criterion(outputs, y_train)
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        losses.append(loss.item())
        
        if epoch % 20 == 0:
            print(f'Epoch [{epoch}/{epochs}], Loss: {loss.item():.4f}')
    
    return losses

print("开始训练...")
losses = train_model(model, X_train, y_train, epochs=100)

# 8.4 评估模型
def evaluate_model(model, X_test, y_test):
    model.eval()
    with torch.no_grad():
        outputs = model(X_test)
        _, predicted = torch.max(outputs, 1)
        accuracy = (predicted == y_test).float().mean()
    return accuracy.item()

accuracy = evaluate_model(model, X_test, y_test)
print(f"测试集准确率: {accuracy:.4f}")

print("\n=== 模型保存和加载 ===")

# 9.1 保存模型
torch.save(model.state_dict(), 'model.pth')
print("模型已保存为 'model.pth'")

# 9.2 加载模型
new_model = Classifier()
new_model.load_state_dict(torch.load('model.pth'))
new_model.eval()
print("模型加载成功")

# 测试加载的模型
accuracy_loaded = evaluate_model(new_model, X_test, y_test)
print(f"加载模型的测试准确率: {accuracy_loaded:.4f}")

print("\n=== 常用工具函数 ===")

# 10.1 设置随机种子
torch.manual_seed(42)
print("设置随机种子为 42")

# 10.2 张量与NumPy数组转换
# 张量转NumPy
tensor = torch.tensor([1, 2, 3])
numpy_array = tensor.numpy()
print(f"张量: {tensor} -> NumPy: {numpy_array}")

# NumPy转张量
numpy_array = np.array([4, 5, 6])
tensor_from_numpy = torch.from_numpy(numpy_array)
print(f"NumPy: {numpy_array} -> 张量: {tensor_from_numpy}")

# 10.3 梯度计算控制
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 在不需要梯度时关闭
with torch.no_grad():
    y = x * 2
    print(f"无梯度计算: {y}")

# 或者使用 detach()
z = (x * 2).detach()
print(f"分离梯度: {z}")

PyTorch 版本: 2.0.1
CUDA 是否可用: True

=== 创建张量 ===
从列表创建: tensor([1, 2, 3, 4])
全零张量:
 tensor([[0., 0., 0.],
        [0., 0., 0.]])
全一张量:
 tensor([[1., 1., 1.],
        [1., 1., 1.]])

=== 自动求导 ===
x = 2.0, y = 11.0
dy/dx = 7.0

=== 完整训练示例 ===
开始训练...
Epoch [0/100], Loss: 0.7234
Epoch [20/100], Loss: 0.5321
Epoch [40/100], Loss: 0.4215
Epoch [60/100], Loss: 0.3521
Epoch [80/100], Loss: 0.3012
测试集准确率: 0.8950