Cela a beaucoup changé depuis que le chainer est devenu 1.11.0, donc je vais écrire ma propre compréhension. Autant que possible, je le rendrai compréhensible à ceux qui sont nouveaux dans Python et Chainer.
Le code est ici Il s'agit d'un fichier appelé train_mnist.py dans l'exemple.
MNIST mnist est un ensemble de données d'images avec des nombres de taille 28x28. Il est souvent utilisé comme introduction à l'apprentissage automatique.
class MLP(chainer.Chain):
def __init__(self, n_in, n_units, n_out):
super(MLP, self).__init__(
l1=L.Linear(n_in, n_units),
l2=L.Linear(n_units, n_units),
l3=L.Linear(n_units, n_out),
)
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
Dans la définition du réseau, \ _ \ _ init \ _ \ _ définit la couche à utiliser. Cette fois,
\ _ \ _ Call \ _ \ _ décrit un réseau spécifique. Cette fois, nous utilisons une fonction d'activation appelée relu pour la sortie de l1 et l2.
Parser Pour le moment, parser
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--unit', '-u', type=int, default=1000,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
parser est un outil pratique qui facilite la définition des paramètres lors de l'exécution de python avec des commandes. Par exemple, si vous exécutez ce qui suit dans le terminal
> $ python train_mnist.py -g 0 -u 100
GPU: 0
# unit: 100
# Minibatch-size: 100
# epoch: 20
Il sera affiché. Si epoch n'est pas spécifié, ce sera la valeur initialisée par default. Si vous souhaitez l'ajouter vous-même
add_argument('Nom à appeler plus tard', '-Comment spécifier dans le terminal',S'il s'agit d'un nombre, saisissez=int,Valeur par défaut si non spécifiée)
Il peut être utilisé sous la forme de.
Dans le chainer, les données de train et les données de test sont préparées.
train, test = chainer.datasets.get_mnist()
Il récupère simplement les données utilisées par mnist et les met en train et teste. Le type de forme à l'intérieur est sur une seule ligne (train [0]) [[.234809284, .324039284, .34809382 …. .04843098], 3] Ainsi, la valeur d'entrée à gauche et la réponse (valeur d'étiquette) à droite sont incluses comme un ensemble. De plus, avec le chainer, vous apprendrez avec le train, essayez avec le test et verrez le taux de réponse correct.
Dans le passé, je me préparais à moi-même et je le tournais plusieurs fois pour apprendre, mais à partir de la version 1.11.0, j'ai dit que je vais utiliser cela en mettant des données comme train ci-dessus. Vous n'avez pas besoin d'écrire pendant des minutes.
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
Il semble que tout va bien. Il y a un sentiment de magie
Trainer Un formateur a été ajouté, et il semble qu'il fera diverses choses presque arbitrairement. Veuillez donner à votre enfant une série de questions et réponses au tuteur. Typique L'image de laisser l'enseignement des études à un tuteur (je ne sais pas si ça va)
Tout d'abord, définissez le formateur.
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'),
En utilisant ce train_iter (collection de problèmes), faites l'optimiser par cet optimizer (méthode d'étude), Tournez-le _epoch _ (combien de tours).
Certains des éléments suivants ne sont pas toujours nécessaires:
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
#C'est. tester_J'utilise iter pour évaluer chaque époque (je pense)
trainer.extend(extensions.dump_graph('main/loss'))
#Enregistrez la forme du réseau au format point afin qu'elle puisse être affichée sous forme de graphique.
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
#Enregistrez les informations du formateur pour chaque époque. Vous pouvez le lire et recommencer à partir du milieu. Cela a-t-il rendu les choses beaucoup plus rapides?
trainer.extend(extensions.LogReport())
#Journal de sortie pour chaque époque
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy']))
#Spécifiez les informations à sortir par journal.
trainer.extend(extensions.ProgressBar())
#Il vous dira jusqu'où vous allez maintenant et pour chaque époque.
trainer.run()
#Après avoir configuré divers entraîneurs, faites-le et exécutez-le. C'est obligatoire
main / loss est la taille de la différence par rapport à la réponse. mian / exactitude est le taux de réponse correct. Je ne sais pas à quoi se réfère validation / main / précision. (Si quelqu'un peut commenter ...)
Je pense que je vais l'expliquer ici et ne pas l'expliquer là-bas, mais c'est parce que je ne le comprends pas encore.
Je prévois toujours de détailler comment j'ai réellement joué avec.