[PYTHON] [PyTorch] Bildklassifizierung von CIFAR-10
In diesem Artikel werden wir Bilder von CIFAR-10 mit PyTorch klassifizieren. Folgen Sie dem Offiziellen Tutorial mit Kommentaren. Darüber hinaus sind Python und maschinelles Lernen Super-Anfänger.
Was ist CIFAR-10?
Ein Bilddatensatz mit 10 Etiketten, der im Bereich des maschinellen Lernens weit verbreitet ist. airplane、automobile、bird、cat、deer、dog、frog、horse、ship、truck Es stehen 10 Etiketten zur Verfügung.
Umgebung
- macOS Catalina
- Python 3.7.2
- pip 19.1.1
Installieren Sie PyTorch
Die offizielle Website gibt Installationsbefehle für jede Umgebung aus. Da ich ein MacOS bin, führen Sie zur Installation Folgendes aus.
pip install torch torchvision
Implementieren Sie CNN
Importieren Sie die erforderlichen Bibliotheken
#Importieren Sie NumPy, Matplotlib, PyTorch
import numpy as np
import matplotlib.pyplot as plt
import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
Laden Sie CIFAR-10 herunter
#ToTensor: Graustufenbild (RGB 0)~255 bis 0~Normalisieren auf den Bereich 1), Normalisieren: Z-Wert (RGB-Durchschnitt und Standardabweichung auf 0).Normalisieren mit 5)
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
#Trainingsdaten herunterladen
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)
#Testdaten herunterladen
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=True, num_workers=2)
Schauen Sie sich CIFAR-10 an
Überprüfen Sie die Daten
#Trainingsdatensatz: 50.000 RGB-Bilder mit 32 Pixel in Höhe und Breite
print(trainset.data.shape)
(50000, 32, 32, 3)
#Testdatensatz: 10000 RGB-Bilder mit 32 Pixel in Höhe und Breite
print(testset.data.shape)
(10000, 32, 32, 3)
#Überprüfen Sie die Klassenliste
print(trainset.classes)
['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
#Klassen werden oft verwendet, also bewahren Sie sie separat auf
classes = trainset.classes
Im offiziellen Dokument wurde ** Flugzeug als Flugzeug neu definiert ** und ** Automobil als Auto neu definiert **. Warum?
Bild anzeigen
#Versuchen Sie, das heruntergeladene Bild anzuzeigen
def imshow(img):
#Denormalisieren
img = img / 2 + 0.5
# torch.Vom Tensortyp bis zum Numpy.In ndarray-Typ konvertieren
print(type(img)) # <class 'torch.Tensor'>
npimg = img.numpy()
print(type(npimg))
#Form von (RGB, vertikal, horizontal) in (vertikal, horizontal, RGB) konvertieren
print(npimg.shape)
npimg = np.transpose(npimg, (1, 2, 0))
print(npimg.shape)
#Bild anzeigen
plt.imshow(npimg)
plt.show()
dataiter = iter(trainloader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
Implementieren Sie das Netzwerk
#Implementieren Sie CNN
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
Definieren Sie jede Ebene mit init und verbinden Sie sie mit forward.
Verlustfunktion / Optimierer definieren
#Gekreuzte Entropie
criterion = nn.CrossEntropyLoss()
#Probabilistische Gradientenabstiegsmethode
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
Trainieren
#Trainieren
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
#Fehler bei der Weitergabe
loss.backward()
optimizer.step()
train_loss = loss.item()
running_loss += loss.item()
if i % 2000 == 1999:
print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
[1, 2000] loss: 2.164
[1, 4000] loss: 1.863
[1, 6000] loss: 1.683
[1, 8000] loss: 1.603
[1, 10000] loss: 1.525
[1, 12000] loss: 1.470
[2, 2000] loss: 1.415
[2, 4000] loss: 1.369
[2, 6000] loss: 1.363
[2, 8000] loss: 1.333
[2, 10000] loss: 1.314
[2, 12000] loss: 1.317
Finished Training
Der durchschnittliche Verlustwert für jede 2000 Mini-Charge wird in das Protokoll ausgegeben.
Speichern Sie das Modell
#Speichern Sie das Modell
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)
Speichern Sie das Modell im aktuellen Verzeichnis mit der Erweiterung pth (PyTorch).
Versuchen Sie es mit dem Modell
#Laden Sie die Testdaten und zeigen Sie das Bild und das richtige Etikett an
dataiter = iter(testloader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
#Laden Sie das gespeicherte Modell und sagen Sie voraus
net = Net()
net.load_state_dict(torch.load(PATH))
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
GroundTruth: truck cat airplane ship
Predicted: truck horse airplane ship
Sie können sehen, dass die Vorhersagen bis auf Katze korrekt sind.
print(outputs)
value, predicted = torch.max(outputs, 1)
print(value)
print(predicted)
tensor([[ 0.7114, -2.2724, 0.1225, 0.9470, 2.1940, 1.8655, -2.6655, 4.1646,
-1.1001, -1.6991],
[-2.2453, -4.1017, 1.8291, 3.2079, 1.1242, 3.6712, 1.0010, 1.0489,
-3.2010, -1.9476],
[-3.0669, -3.8900, 0.9312, 3.5649, 2.7791, 1.5095, 2.1216, 1.5274,
-4.3077, -2.2234],
[-2.0948, -3.4640, 2.4833, 2.6210, 4.0590, 1.8350, 0.4924, 0.7212,
-3.5043, -2.4212]], grad_fn=<AddmmBackward>)
tensor([4.1646, 3.6712, 3.5649, 4.0590], grad_fn=<MaxBackward0>)
tensor([7, 5, 3, 4])
** torch.max ** gibt den Maximalwert der Ausgänge zurück.
Testen Sie das Modell
correct = 0
total = 0
#Berechnen ohne sich an den Gradienten zu erinnern (ohne zu lernen)
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
Accuracy of the network on the 10000 test images: 60 %
Sie können sehen, dass die korrekte Antwortrate für 10000 Testdaten 60% beträgt.
Unten finden Sie eine persönliche Anmerkung für Python-Anfänger. Nicht gut ** (vorhergesagt == Labels) .sum (). Item () ** Ich wusste nicht, wie ich das schreiben soll, also werde ich mich abmelden und es überprüfen.
print(type((predicted == labels)))
print((predicted == labels).dtype)
print(type((predicted == labels).sum()))
print((predicted == labels).sum())
print((predicted == labels).sum().item())
# <class 'torch.Tensor'>
# torch.bool
# <class 'torch.Tensor'>
# tensor(2)
# 2
Das war's. Vergleichen Sie jedes Element des Arrays und verwenden Sie sum (), das in torch.Tensor implementiert ist, um den Gesamtwert von true zu berechnen. Danach wird item (), das in torch.Tensor implementiert ist, verwendet, um den Gesamtwert zu einem numerischen Wert vom Typ int zu machen. Es war etwas einfacher zu verstehen, als ich es mit Numpy überprüfte.
#Versuchen Sie es mit Numpy
a = np.array([1, 2, 3, 4, 5])
b = np.array([1, 2, 0, 4, 5])
print(type((a == b)))
print((a == b))
print((a == b).sum())
print(type((a == b).sum()))
print((a == b).sum().item())
print(type((a == b).sum().item()))
# <class 'numpy.ndarray'>
# [ True True False True True]
# 4
# <class 'numpy.int64'>
# 4
# <class 'int'>
Unter Official können Sie fast dieselbe API wie ndarray verwenden, also ** sum () ** und ** item () ** Kann verwendet werden. Überzeugt.
Sehen wir uns die richtige Antwortrate für jedes Etikett an
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))
Accuracy of airplane : 72 %
Accuracy of automobile : 66 %
Accuracy of bird : 38 %
Accuracy of cat : 58 %
Accuracy of deer : 60 %
Accuracy of dog : 29 %
Accuracy of frog : 73 %
Accuracy of horse : 60 %
Accuracy of ship : 69 %
Accuracy of truck : 73 %
Ist es so in einem Tutorial?
Recommended Posts