每日总结-pytorch的学习

所花时间：2小时

代码量：无

博客量：本学期截至目前82篇

了解到的知识点：pytorch的学习

PyTorch 是一个用于机器学习的开源深度学习框架，由 Facebook 开发并维护。它以 Python 语言为基础，旨在让用户能够更加轻松地构建和训练神经网络模型。

以下是 PyTorch 的一些特性和功能：

1. 动态图：PyTorch 使用动态图机制，这意味着每个计算图都是实时建立的。这种机制使得用户能够更加灵活地构建模型并进行调试。

2. 强大的 GPU 加速：PyTorch 支持 GPU 加速，这使得深度学习模型的训练速度能够大大加快。

3. 自动微分：PyTorch 能够自动计算梯度，这对于训练神经网络模型非常有用。

4. 多种神经网络层支持：PyTorch 支持许多种不同的神经网络层，包括全连接层、卷积层、循环神经网络层等。

5. 可视化工具：PyTorch 提供了可视化工具，以帮助用户更好地理解模型的训练过程和性能。

6. 模型保存：PyTorch 允许用户将训练好的模型保存为文件，以便在需要时可以方便地重复使用。

7. 支持 TorchScript：PyTorch 支持 TorchScript，这是一种用于序列化 PyTorch 模型的方式，使其可以在 Python 环境以外的环境中运行。

总的来说，PyTorch 是一个非常强大的深度学习框架。它的动态图机制和自动微分功能使得用户能够更加灵活地构建和调试模型，同时支持 GPU 加速也使得模型的训练速度更快。此外，可视化工具和模型保存等功能也使得用户能够更加方便地进行深度学习模型的开发和部署。

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
# Download training data from open datasets.
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
)

# Download test data from open datasets.
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
)
batch_size = 64

# Create data loaders.
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader:
    print(f"Shape of X [N, C, H, W]: {X.shape}")
    print(f"Shape of y: {y.shape} {y.dtype}")
    break# Get cpu, gpu or mps device for training.
device = (
    "cuda"
    if torch.cuda.is_available()
    else "mps"
    if torch.backends.mps.is_available()
    else "cpu"
)
print(f"Using {device} device")

# Define model
class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    model.train()
    for batch, (X, y) in enumerate(dataloader):
        X, y = X.to(device), y.to(device)

        # Compute prediction error
        pred = model(X)
        loss = loss_fn(pred, y)

        # Backpropagation
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

        if batch % 100 == 0:
            loss, current = loss.item(), (batch + 1) * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
epochs = 5
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model, loss_fn)
print("Done!")
torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")