Repository navigation
Expand file tree
/
Copy pathclassfication.py
More file actions
105 lines (94 loc) · 3.54 KB
/
Copy pathclassfication.py
File metadata and controls
105 lines (94 loc) · 3.54 KB
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
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor,Lambda,Compose
import matplotlib.pyplot as plt
training_data = datasets.FashionMNIST(
root = "data",
train = True,
download = True,
transform = ToTensor(),
#这里并没有使用transforms.Compose说明我们这里并不需要进行多个图片操作。
)
test_data = datasets.FashionMNIST(
root = "data",
train = False,
download = True,
transform = ToTensor(),
)
batch_size = 64
#将Dataset传入DataLoader中。
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)
#z注意如果是自己的数据需要封装，那么要先写一个类，该类继承Dataset，然后在该类中要
#重写__len__,__getitem__项。并且在该类的__init__方法中，除了self，还有文件的路径。
#由torchvision中获得的数据已经是Dataset格式，不需要经过Dataset,直接传入DataLoader中。
for X, y in test_dataloader:
print("shape of X [N, C, H, W]:", X.shape)
print("Shape of y:", y.shape, y.dtype)
break
#这里循环中加了break,所以只需要打印一批的数据的信息。
#Creating Models
device = "cuda" if torch.cuda.is_available() else "cpu"
print('using {} device'.format(device))
#define model
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork,self).__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),
nn.ReLU()
)
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()#你可以这样理解，nn.xx，是一个类，torch.nn.functional.xx是函数。
optimizer = torch.optim.SGD(model.parameters(),lr=1e-3)
#w为了训练我们的模型，我们需要损失函数和优化器
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
for batch, (X,y) in enumerate(dataloader):
X, y = X.to(device), y.to(device)
pred = model(X)
loss = loss_fn(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if batch % 100 == 0:
loss, current = loss.item(), batch*len(X)
print(f"loss:{loss:>7f} [{current:>5d}/{size:>5d}]")
def test(dataloader, model, loss_fn):
model.eval()
size = len(dataloader.dataset)
num_batches = len(dataloader)
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()
#pred.argmax(1)在指定维度上求最大值。
#指定类型改变。
test_loss /= num_batches
correct /= size
print(f"Test Error: /n Accuracy:{(100*correct):>0.1f}%,Avg loss:{test_loss:>8f}\n")
#训练过程是在好几次迭代情况下实施的。
if __name__ == "__main__":
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!!")