Abschnitt 1 Pytorch
1. Klassifizierungsaufgabe für neuronale Netze
1. Mnist-Klassifizierungsaufgabe:
Grundlegende Netzwerkaufbau- und Trainingsmethoden, Analyse häufig verwendeter Funktionen
Torch.nn.Funktionsmodul
nn.Module-Modul
1) Überprüfen Sie die Pytorch-Version
import torch
print(torch.__version__)`
2) Lesen Sie den Mnist-Datensatz
Der Download erfolgt automatisch. 784 ist die Anzahl der Pixel in jeder Stichprobe des mnist-Datensatzes.
from pathlib import Path
import requests
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"
PATH.mkdir(parents=True, exist_ok=True)
URL = "http://deeplearning.net/data/mnist/"
FILENAME = "mnist.pkl.gz"
if not (PATH / FILENAME).exists():
content = requests.get(URL + FILENAME).content
(PATH / FILENAME).open("wb").write(content)
import pickle
import gzip
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")
[Die Übertragung des externen Link-Bildes ist fehlgeschlagen. Die Quellseite verfügt möglicherweise über einen Anti-Leeching-Mechanismus. Es wird empfohlen, das Bild zu speichern und direkt hochzuladen (img-3Iw4CBNL-1670769748412) (C:\Users\Administrator\Desktop\4.png )]
[Die Übertragung des externen Link-Bildes ist fehlgeschlagen. Die Quellseite verfügt möglicherweise über einen Anti-Leeching-Mechanismus. Es wird empfohlen, das Bild zu speichern und direkt hochzuladen (img-JEr8Ubf7-1670769748414) (C:\Users\Administrator\Desktop\5.png )]
Beachten Sie, dass die Daten in einen Tensor umgewandelt werden müssen, um am nachfolgenden Modellierungstraining teilnehmen zu können.
import torch
#map是python内置函数，会根据提供的函数对指定的序列做映射。
x_train, y_train, x_valid, y_valid = map(
torch.tensor, (x_train, y_train, x_valid, y_valid)
)
n, c = x_train.shape
x_train, x_train.shape, y_train.min(), y_train.max()
print(x_train, y_train)
print(x_train.shape)
print(y_train.min(), y_train.max())
import torch.nn.functional as F
loss_func = F.cross_entropy
def model(xb):
return xb.mm(weights) + bias
bs = 64
xb = x_train[0:bs] # a mini-batch from x
yb = y_train[0:bs]
weights = torch.randn([784, 10], dtype = torch.float, requires_grad = True)
bs = 64
bias = torch.zeros(10, requires_grad=True)
print(loss_func(model(xb), yb))
Torch.nn.function Hier sind viele Ebenen und Funktionen zu sehen
In Torch.nn.Functional gibt es viele Funktionen, die in Zukunft häufig verwendet werden. Wann also nn.Module und wann nn.Functional verwenden? Wenn das Modell über lernbare Parameter verfügt, ist es im Allgemeinen am besten, nn.Module zu verwenden. In anderen Fällen ist nn.Functional relativ einfacher.
3) Erstellen Sie ein Modell, um den Code zu vereinfachen
- Muss nn.Module erben und den Konstruktor von nn.Module in seinem Konstruktor aufrufen
- Es ist nicht erforderlich, eine Backpropagation-Funktion zu schreiben. nn.Module kann Autograd verwenden, um die Backpropagation automatisch zu implementieren
- Lernbare Parameter im Modul können Iteratoren über „named_parameters()“ oder „parameters()“ zurückgeben.
from torch import nn
class Mnist_NN(nn.Module):
def __init__(self): #构造函数
super().__init__()
self.hidden1 = nn.Linear(784, 128)
self.hidden2 = nn.Linear(128, 256)
self.out = nn.Linear(256, 10)
self.dropout = nn.Dropout(0.5)
def forward(self, x): #前向传播
x = F.relu(self.hidden1(x))
x = F.relu(self.hidden2(x))
x = self.out(x)
return x
net = Mnist_NN()
print(net)
4) Drucken Sie die Gewichtungen und Bias-Elemente unter den definierten Namen aus
for name, parameter in net.named_parameters():
print(name, parameter,parameter.size())
Verwenden Sie zur Vereinfachung TensorDataset und DataLoader
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
train_ds = TensorDataset(x_train, y_train)
train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)
valid_ds = TensorDataset(x_valid, y_valid)
valid_dl = DataLoader(valid_ds, batch_size=bs * 2)
def get_data(train_ds, valid_ds, bs):
return (
DataLoader(train_ds, batch_size=bs, shuffle=True), #shuffle:数据是否打乱 训练的时候需要打乱，验证一般不做shuffle
DataLoader(valid_ds, batch_size=bs * 2),
)
- Im Allgemeinen wird model.train() beim Training des Modells hinzugefügt, sodass Batch-Normalisierung und Dropout normal verwendet werden.
- Wählen Sie beim Testen im Allgemeinen model.eval (), damit Batch-Normalisierung und Dropout nicht verwendet werden.
import numpy as np
#step迭代次数 opt：优化器
def fit(steps, model, loss_func, opt, train_dl, valid_dl):
for step in range(steps): #epoch
model.train() #更新每一层的权重和偏置
for xb, yb in train_dl: #batch
loss_batch(model, loss_func, xb, yb, opt)
model.eval() #验证不需要更新参数
with torch.no_grad():
losses, nums = zip(
*[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
)
#zip:配对
val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)
print('当前step:'+str(step), '验证集损失：'+str(val_loss))
#zip的用法
a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b) #配对
print(list(zipped))
a2,b2 = zip(*zip(a,b)) #解包
print(a2)
print(b2)
from torch import optim
def get_model():
model = Mnist_NN()
return model, optim.Adam(model.parameters(), lr=0.001)
def loss_batch(model, loss_func, xb, yb, opt=None):
loss = loss_func(model(xb), yb)
if opt is not None:
loss.backward()
opt.step()
opt.zero_grad() # torch默认梯度累加，所以执行完梯度后需要清零
return loss.item(), len(xb)
train_dl, valid_dl = get_data(train_ds, valid_ds, bs)
model, opt = get_model()
fit(25, model, loss_func, opt, train_dl, valid_dl)
correct = 0
total = 0
for xb,yb in valid_dl:
outputs = model(xb)
_,predicted = torch.max(outputs.data, 1) # 1 沿着1这个维度 返回最大值和最大值的位置
total += yb.size(0)
correct += (predicted == yb).sum().item()
print('Accuracy of the network on the 10000 test images:%d %%' %(100* correct/ total))
返回最大值和最大值的位置
total += yb.size(0)
korrekt += (vorhergesagt == yb).sum().item()
print('Accuracy of the network on the 10000 test images:%d %%' %(100* correct/ total))