Hallo, das ist Kawashima! Ich habe lange darüber nachgedacht, auf Qiita zu posten, und jetzt kann ich es schaffen! (^^)
Heute möchte ich ein Programm erklären, das handgeschriebene numerische MNIST-Daten mithilfe eines neuronalen Netzwerks mit PyTorch trainiert.
Das Thema selbst ist nicht neu, In den bisherigen Artikeln gibt es jedoch nur wenige Dinge, die die Details sorgfältig erklären.
In diesem Artikel möchte ich es so detailliert wie möglich schreiben.
Das heißt, der größte Teil der Erklärung ist in den Kommentaren. Seien Sie geduldig und lesen Sie die Kommentare Zeile für Zeile!
Beginnen wir mit dem Quellcode!
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
import torch
print(torch.__version__)
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torch.autograd import Variable
import torch.nn as nn
import torch.optim as optimizer
Versuchen Sie zum Lernen, das Programm auszuführen, während Sie hier wechseln.
# -----------------------------------------------------------------------------
#Chargengröße der Mini-Charge
BATCH_SIZE = 4
#Maximale Anzahl des Lernens
MAX_EPOCH = 2
#Anzahl der Stapel, um den Fortschritt auszugeben
PROGRESS_SHOW_PER_BATCH_COUNT=1000
Hier definieren wir ein dreischichtiges neuronales Netzwerk. Beachten Sie, dass dies kein Faltungsnetzwerk ist.
# -----------------------------------------------------------------------------
#Definition der mehrschichtigen Perzeptronklasse
class MLP(nn.Module):
def __init__(self):
'''
Beispielsweise ist die für jede Schicht definierte Aktivierungsfunktion die nächste Weiterleitung.()Definiert in
'''
super().__init__()
#Eingabeebene
self.layer1 = nn.Linear(28 * 28, 100)
#Zwischenschicht (versteckte Schicht)
self.layer2 = nn.Linear(100, 50)
#Ausgabeschicht
self.layer3 = nn.Linear(50, 10)
def forward(self, input_data):
'''
Definition des Netzwerks (Forward Propagation) (Verbindung)
'''
# input_Daten in Format konvertieren
# -1 konvertiert automatisch
input_data = input_data.view(-1, 28 * 28)
#Eingabe von der vorherigen Ebene_Daten an Layer1 übergeben
input_data = self.layer1(input_data)
#Eingabe von der vorherigen Ebene_Daten an Layer2 übergeben
input_data = self.layer2(input_data)
#Eingabe von der vorherigen Ebene_Daten an Layer3 übergeben
input_data = self.layer3(input_data)
return input_data
#Generieren Sie eine Instanz des Trainingsmodells
model = MLP()
# -----------------------------------------------------------------------------
#Bereiten Sie die Trainingsdaten vor
#
print('----------Vorbereitung der Trainingsdaten----------')
data_folder = '~/data'
transform = transforms.Compose([
#Konvertieren Sie den Datentyp in Tensor
transforms.ToTensor()
])
#Trainingsdaten
train_data_with_labels = MNIST(
data_folder, train=True, download=True, transform=transform)
train_data_loader = DataLoader(
train_data_with_labels, batch_size=BATCH_SIZE, shuffle=True)
#Validierungsdaten
test_data_with_labels = MNIST(
data_folder, train=False, download=True, transform=transform)
test_data_loader = DataLoader(
test_data_with_labels, batch_size=BATCH_SIZE, shuffle=True)
Geben Sie die Verlustfunktion, die Lernrate usw. für das Lernen an. In diesem Bereich wird vorausgesetzt, dass verstanden wird, was ein neuronales Netzwerk ist. Wenn Sie die Voraussetzungen noch einmal überprüfen möchten, lesen Sie bitte meinen Hinweis.
https://note.com/kawashimaken/n/nfeebd2502b87?magazine_key=me13f2d6e0ab8
# -----------------------------------------------------------------------------
#Mach dich bereit zum Lernen
#Die Verlustfunktion verwendet die Kreuzentropiefehlerfunktion
lossResult = nn.CrossEntropyLoss()
# SGD
optimizer = optimizer.SGD(model.parameters(), lr=0.01)
print('----------Fang an zu lernen----------')
#Fang an zu lernen
for epoch in range(MAX_EPOCH):
#Anfangseinstellung des Fehlers
total_loss = 0.0
#enumerate zerlegt die Indexdaten
for i, data in enumerate(train_data_loader):
#Extrahieren Sie einen Stapel von Trainingszieldaten und Lehreretikettendaten aus den Daten
train_data, teacher_labels = data
#Eingangsbrenner.autograd.In Variable konvertieren
train_data, teacher_labels = Variable(train_data), Variable(
teacher_labels)
#Löschen (Zurücksetzen, Löschen) der berechneten Gradienteninformationen
optimizer.zero_grad()
#Geben Sie dem Modell Trainingsdaten und machen Sie Vorhersagen
outputs = model(train_data)
#Differenzieren Sie die Berechnung nach Verlust und w
loss = lossResult(outputs, teacher_labels)
#Berechnen Sie den Gradienten
loss.backward()
#Führt den Optimierungsschritt einmal aus (aktualisiert die Parameter, ein für viele Optimierer üblicher Prozess)
optimizer.step()
# loss.item()Wandelt den Verlust in eine Zahl um und sammelt Fehler
total_loss += loss.item()
# PROGRESS_SHOW_PER_BATCH_COUNT Zeigt den Fortschritt für jeden Mini-Batch an
if i % PROGRESS_SHOW_PER_BATCH_COUNT == PROGRESS_SHOW_PER_BATCH_COUNT-1:
print('i=',i)
print(
'Lernfortschritt:[EPOCH:%d, %d Charge x%d -> %d Blätter lernen abgeschlossen]Lernfehler (Verlust): %.3f' % (epoch + 1, i + 1, BATCH_SIZE, (i + 1) * BATCH_SIZE,
total_loss / PROGRESS_SHOW_PER_BATCH_COUNT))
#Setzt den Berechnungsfehler zurück
total_loss = 0.0
print('Ende des Lernens')
Sobald Sie trainiert und ein trainiertes Modell erhalten haben, besteht der nächste Schritt darin, das trainierte Modell tatsächlich zu "verwenden" und daraus zu schließen, um zu sehen, wie genau dieses trainierte Modell ist.
Es ist fast ein wesentlicher Schritt.
# -----------------------------------------------------------------------------
#Überprüfung: Berechnen Sie die richtige Antwortrate für alle Überprüfungsbilddaten
print('----------Berechnen Sie die richtige Antwortrate für alle Verifizierungsbilddaten----------')
#Gesamtzahl der Daten (Anzahl der Messziele)
total = 0
#Richtiger Antwortzähler
count_when_correct = 0
#
for data in test_data_loader:
#Extrahieren Sie Daten aus dem Validierungsdatenlader und entpacken Sie sie
test_data, teacher_labels = data
#Übergeben Sie die Testdaten nach der Konvertierung an das Modell und lassen Sie sie beurteilen
results = model(Variable(test_data))
#Holen Sie sich die Prognose
print(torch.max(results, 1))
#Ergebnis:
# torch.return_types.max(
# values=tensor([1.2185, 5.8557, 2.8262, 4.7874], grad_fn=<MaxBackward0>),
# indices=tensor([2, 8, 8, 8]))
# torch.max(tensor, axis)
# values indices
# ↓ ↓
# _ predicted
_, predicted = torch.max(results.data, 1)
#Extrahieren Sie den Maximalwert (die sicherste Bezeichnung) des Inferenzergebnis-Arrays nacheinander.
#Wenn Sie es nicht verwenden, machen Sie es zu einer Unterleiste. (Einweg)
#Hier Achse=Da es 1 ist, bedeutet dies, den Maximalwert für jede Zeile abzurufen.
print('_', _)
#Ergebnis: Enthält jeweils den Maximalwert
# tensor([1.6123, 5.6203, 3.0886, 3.8317], grad_fn=<MaxBackward0>)
print('predicted', predicted)
#Ergebnis: "Was ist der Maximalwert?"(index location)Ist enthalten
# tensor([3, 9, 1, 0])
#
# print('teacher_labels',teacher_labels)
#Ergebnis:
# teacher_labels
# tensor([3, 5, 3, 8])
# teacher_labels
# tensor([3, 5, 1, 7])
# ...
# ...
#
# print('teacher_labels.size(0)',teacher_labels.size(0))
# teacher_labels.size(0) 4
total += teacher_labels.size(0)
count_when_correct += (predicted == teacher_labels).sum()
print('count_when_correct:%d' % (count_when_correct))
print('total:%d' % (total))
print('Richtige Antwortrate:%d / %d = %f' % (count_when_correct, total,
int(count_when_correct) / int(total)))
Wie ist das? Haben Sie ein Bild der Bilderkennung mithilfe eines neuronalen Netzwerks mit PyTorch? Fast alles ist zu "Kommentaren lesen" geworden, aber wenn es viele Likes gibt, werde ich einen Artikel wie diesen veröffentlichen. Ich freue mich darauf, mit Dir zu arbeiten.
https://github.com/kawashimaken/salon/blob/master/pytorch/mnist.py
Darüber hinaus können wir Kommentare aktualisieren, sodass der neueste Code auf GitHub verwaltet wird. Wenn Sie möchten, folgen Sie bitte, markieren Sie oder setzen Sie ein Lesezeichen. m (.) m
Recommended Posts