python

系列
Python：实例讲解 Python 中的魔法函数（高级语法）

python 中的 main()只是起到提示作用无实质约束力，依旧从上向下依次读取
python 的 lambda 非需要下避免使用

pytorch

pytorch官方文档

squeeze和unsqueeze函数
momentum动量
contiguous
view

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
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")

model = NeuralNetwork().to(device)
model.load_state_dict(torch.load("model.pth"))

classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

model.eval()  # 切换到评估模式，关闭 dropout 和 batchnorm 的训练行为
x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():  # 关闭梯度计算，提高预测效率
    x = x.to(device)
    pred = model(x)  # 得到模型输出
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')

Tesorboard

可参考
Pytorch的TensorBoard
TensorFlow的TensorBoard
TensorBoard入门

TensorBoard 可以实时绘制训练损失、验证损失、准确率等多种曲线
计算图：TensorBoard 可以显示模型的计算图（graph），帮助你理解模型的架构和各层之间的关系。

层级结构：不仅可以看到层次结构，还能查看每一层的维度，帮助调试和优化模型。
TensorBoard 可以展示各层的权重、偏置等参数的分布，以及在训练过程中的变化，这有助于分析模型的训练状态。
TensorBoard 支持图像、音频和文本数据的可视化，可以直观展示训练过程中处理的数据样本。

为什么不用 plt 或者 ax2：
虽然 matplotlib（plt 或 ax2）也能绘制图表，但它的功能较为基础，无法直接支持 TensorFlow 的训练过程和模型结构的实时跟踪。TensorBoard 的优势在于它是专为深度学习训练过程设计的工具，能处理大量实时更新的数据，并提供对模型结构、参数和训练过程的深度分析。而 matplotlib 通常用于静态的图表绘制，不适合处理训练过程中的动态更新数据、模型结构和多实验对比。