Bonjour, c'est Kawashima! Je pense depuis longtemps à publier sur Qiita, et maintenant je peux le faire! (^^)
Aujourd'hui, je voudrais expliquer un programme qui entraîne des données numériques manuscrites du MNIST à l'aide d'un réseau neuronal avec PyTorch.
Le sujet lui-même n'est pas nouveau, Cependant, dans les articles jusqu'à présent, il n'y a pas beaucoup de choses qui expliquent soigneusement les détails.
Dans cet article, j'aimerais l'écrire avec le plus de détails possible.
Cela dit, la plupart des explications se trouvent dans les commentaires. Soyez patient et lisez les commentaires ligne par ligne!
Commençons par regarder le code source!
# -*- 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
Pour étudier, essayez d'exécuter le programme en changeant ici.
# -----------------------------------------------------------------------------
#Taille du lot du mini lot
BATCH_SIZE = 4
#Nombre maximum d'apprentissage
MAX_EPOCH = 2
#Nombre de lots pour la progression de la sortie
PROGRESS_SHOW_PER_BATCH_COUNT=1000
Ici, nous définissons un réseau de neurones à trois couches. Notez qu'il ne s'agit pas d'un réseau neuronal convolutif.
# -----------------------------------------------------------------------------
#Définition de la classe de perceptron multicouche
class MLP(nn.Module):
def __init__(self):
'''
Par exemple, la fonction d'activation définie pour chaque couche est le suivant.()Défini dans
'''
super().__init__()
#Couche d'entrée
self.layer1 = nn.Linear(28 * 28, 100)
#Couche intermédiaire (couche cachée)
self.layer2 = nn.Linear(100, 50)
#Couche de sortie
self.layer3 = nn.Linear(50, 10)
def forward(self, input_data):
'''
Définition du réseau (propagation directe) (connexion)
'''
# input_Convertir les données au format
# -1 convertit automatiquement
input_data = input_data.view(-1, 28 * 28)
#Entrée de la couche précédente_transmettre les données à layer1
input_data = self.layer1(input_data)
#Entrée de la couche précédente_transmettre les données à layer2
input_data = self.layer2(input_data)
#Entrée de la couche précédente_transmettre les données à layer3
input_data = self.layer3(input_data)
return input_data
#Générer une instance du modèle d'entraînement
model = MLP()
# -----------------------------------------------------------------------------
#Préparez les données d'entraînement
#
print('----------Préparation des données d'entraînement----------')
data_folder = '~/data'
transform = transforms.Compose([
#Convertir le type de données en Tensor
transforms.ToTensor()
])
#Données d'entraînement
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)
#Données de validation
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)
Spécifiez la fonction de perte, le taux d'apprentissage, etc. pour l'apprentissage. Dans ce domaine, il est fondé sur la compréhension de ce qu'est un réseau neuronal. Si vous souhaitez vérifier à nouveau les prérequis, veuillez vous référer à ma note.
https://note.com/kawashimaken/n/nfeebd2502b87?magazine_key=me13f2d6e0ab8
# -----------------------------------------------------------------------------
#Préparez-vous à apprendre
#La fonction de perte utilise la fonction d'erreur d'entropie croisée
lossResult = nn.CrossEntropyLoss()
# SGD
optimizer = optimizer.SGD(model.parameters(), lr=0.01)
print('----------Commencer à apprendre----------')
#Commencer à apprendre
for epoch in range(MAX_EPOCH):
#Réglage initial de l'erreur
total_loss = 0.0
#enumerate décompose les données d'index
for i, data in enumerate(train_data_loader):
#Extraire un lot de données d'objectif de formation et de données d'étiquette d'enseignant à partir de données
train_data, teacher_labels = data
#Torche d'entrée.autograd.Convertir en variable
train_data, teacher_labels = Variable(train_data), Variable(
teacher_labels)
#Supprimer (réinitialiser, effacer) les informations de gradient calculées
optimizer.zero_grad()
#Donnez des données d'entraînement au modèle et faites des prédictions
outputs = model(train_data)
#Différencier le calcul par perte et w
loss = lossResult(outputs, teacher_labels)
#Calculer le gradient
loss.backward()
#Effectue l'étape d'optimisation une fois (met à jour les paramètres, un processus courant pour de nombreux optimiseurs)
optimizer.step()
# loss.item()Convertit la perte en un nombre, accumule les erreurs
total_loss += loss.item()
# PROGRESS_SHOW_PER_BATCH_COUNT Affiche la progression de chaque mini-lot
if i % PROGRESS_SHOW_PER_BATCH_COUNT == PROGRESS_SHOW_PER_BATCH_COUNT-1:
print('i=',i)
print(
'Progression de l'apprentissage:[EPOCH:%d, %d lot x%d -> %d feuilles apprentissage terminé]Erreur d'apprentissage (perte): %.3f' % (epoch + 1, i + 1, BATCH_SIZE, (i + 1) * BATCH_SIZE,
total_loss / PROGRESS_SHOW_PER_BATCH_COUNT))
#Réinitialise l'erreur de calcul
total_loss = 0.0
print('Fin de l'apprentissage')
Une fois que vous avez formé et obtenu un modèle entraîné, l'étape suivante consiste à «utiliser» réellement le modèle entraîné et à le déduire pour voir à quel point ce modèle entraîné est précis.
C'est presque une étape essentielle.
# -----------------------------------------------------------------------------
#Vérification: calculez le taux de réponse correct pour toutes les données d'image de vérification
print('----------Calculez le taux de réponse correct pour toutes les données d'image de vérification----------')
#Nombre total de données (nombre de cibles de mesure)
total = 0
#Compteur de réponses correctes
count_when_correct = 0
#
for data in test_data_loader:
#Extraire les données du chargeur de données de validation et les décompresser
test_data, teacher_labels = data
#Après avoir converti les données de test, transmettez-les au modèle et faites-les juger
results = model(Variable(test_data))
#Obtenez les prévisions
print(torch.max(results, 1))
#résultat:
# 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)
#Extrayez la valeur maximale (étiquette la plus certaine) du tableau de résultats d'inférence une par une.
#Si vous ne l'utilisez pas, faites-en un underbar. (jetable)
#Ici, axe=Puisqu'il est 1, cela signifie récupérer la valeur maximale pour chaque ligne.
print('_', _)
#Résultat: contient la valeur maximale de chaque
# tensor([1.6123, 5.6203, 3.0886, 3.8317], grad_fn=<MaxBackward0>)
print('predicted', predicted)
#Résultat: "Quelle est la valeur maximale?"(index location)Est inclus
# tensor([3, 9, 1, 0])
#
# print('teacher_labels',teacher_labels)
#résultat:
# 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('Taux de réponse correct:%d / %d = %f' % (count_when_correct, total,
int(count_when_correct) / int(total)))
Comment c'est? Avez-vous une image de reconnaissance d'image utilisant un réseau de neurones avec PyTorch dans une certaine mesure? Presque tout est devenu "lire les commentaires", mais s'il y a beaucoup de j'aime, je posterai un article comme celui-ci. J'ai hâte de travailler avec vous.
https://github.com/kawashimaken/salon/blob/master/pytorch/mnist.py
De plus, nous pouvons mettre à jour les commentaires, de sorte que le dernier code sera géré sur GitHub, donc si vous le souhaitez, veuillez suivre, ajouter une étoile ou ajouter un signet. m (.) m
Recommended Posts