salut! C'est cool! !!
Cet article s'adresse aux débutants en apprentissage profond.
Cette fois, je vais vous expliquer la partie de base de Chainer, une bibliothèque d'apprentissage en profondeur pour python. J'écrirai sur la façon de construire un réseau neuronal entièrement connecté, une fonction d'activation, une fonction d'optimisation, etc.
L'environnement python utilise python 3.6.7-64bit. De plus, la bibliothèque utilise uniquement le chainer.
De plus, le code présenté dans cet article est exactement comme ça, je vous recommande donc d'essayer de le créer depuis le début tout en y faisant référence.
Vous trouverez ci-dessous le code pour créer un NN à l'aide de chainer.
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import training
class MyChain(chainer.Chain):
def __init__(self, n_input, n_node, n_output):
#Initialiser le poids avec une distribution gaussienne et déterminer l'échelle de l'écart type avec l'échelle
w = chainer.initializers.HeNormal(scale=1.0)
super(MyChain, self).__init__()
#Construire un NN à 4 couches
with self.init_scope():
self.l1 = L.Linear(n_input, n_node, initialW=w)
self.l2 = L.Linear(n_node, n_node, initialW=w)
self.l3 = L.Linear(n_node, n_node, initialW=w)
self.l4 = L.Linear(n_node, n_output, initialW=w)
def __call__(self, x):
#Utiliser la fonction relu pour la fonction d'activation
h = F.relu(self.l1(x))
h = F.relu(self.l2(h))
h = F.relu(self.l3(h))
return self.l4(h)
def create_model():
#Créer un NN avec 10 dimensions d'entrée, 200 nœuds et 10 dimensions de sortie
model = L.Classifier(MyChain(10, 200, 10), lossfun=F.softmax_cross_entropy)
#Adam est utilisé comme fonction d'optimisation, alpha(Taux d'apprentissage)0.025, ε 1e-Réglez sur 3.
optimizer = chainer.optimizers.Adam(alpha=0.025, eps=1e-3)
optimizer.setup(model)
return model, optimizer
Ce qui précède est le code pour créer le modèle NN.
La fonction d'activation est d'augmenter l'expressivité du modèle NN. En d'autres termes, il pourra gérer des problèmes de reconnaissance plus complexes.
En plus de relu, les fonctions d'activation incluent tanh, sigmoid et swish. Vous pouvez également voir d'autres fonctions d'activation à partir du lien dans la référence officielle du chainer ci-dessous (voir la colonne intitulée Fonctions d'activation). https://docs.chainer.org/en/stable/reference/functions.html
La fonction de perte est là pour calculer l'erreur. Habituellement, vous optimisez votre NN pour réduire les pertes. La fonction de perte est également appelée fonction objectif.
J'ai utilisé softmax_cross_entropy pour la fonction de perte (loss_fun), mais il existe d'autres fonctions de perte dans la section Fonctions de perte du lien ci-dessus.
La fonction d'optimisation est une fonction qui détermine comment mettre à jour le NN.
En plus d'Adam, il existe SGD, RMSprop, AdaGrad, etc. comme optimiseurs. Vous pouvez également voir d'autres fonctions d'activation à partir du lien de référence officiel du chainer ci-dessous. https://docs.chainer.org/en/stable/reference/optimizers.html (Les paramètres de la fonction d'optimisation sont fortement liés à la précision de l'apprentissage, il est donc bon d'essayer diverses combinaisons pour trouver la valeur optimale.)
Vous trouverez ci-dessous le code (modèle) pour commencer à apprendre. Copiez-le et collez-le dans le même fichier .py que le code de construction du modèle NN ci-dessus.
#Prendre les données de train et les données de test comme arguments
def learn(train, test):
#Propriété
epoch = 8
batchsize = 256
#Création de modèle NN
model, optimizer = create_model()
#Définition de l'itérateur
train_iter = chainer.iterators.SerialIterator(train, batchsize) #Pour apprendre
test_iter = chainer.iterators.SerialIterator(test, batchsize, repeat=False) #Pour évaluation
#Inscription du programme de mise à jour
updater = training.StandardUpdater(train_iter, optimizer)
#Inscription des formateurs
trainer = training.Trainer(updater, (epoch, 'epoch'))
#Afficher et enregistrer l'état d'apprentissage
trainer.extend(extensions.LogReport()) #Journal
trainer.extend(extensions.Evaluator(test_iter, model)) #Affichage du numéro d'époque
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time'] )) #Affichage de l'état du calcul
#Commencer à apprendre
trainer.run()
#sauvegarder
#chainer.serializers.save_npz("result/Agent" + str(episode) + ".model", model)
La fonction d'apprentissage définie ici reçoit les données de l'enseignant et les données de test comme arguments. (Créez des données d'enseignant et des données de test en fonction de ce que vous voulez entraîner.) Également, bouclez cette fonction en fonction du nombre d'épisodes.
Enfin, j'expliquerai le nombre d'époques et la taille du lot.
Le numéro d'époque est une valeur qui détermine combien de fois les mêmes données d'enseignant sont entraînées. Habituellement, peu de choses peuvent être apprises à la fois, alors laissez-les apprendre plusieurs fois. Cependant, si vous le définissez trop grand, cela entraînera un surapprentissage, alors ajustons-le en essayant différentes valeurs.
La taille du lot est une valeur qui détermine combien de pièces sont extraites des données de l'enseignant et formées. Normalement, plus le nombre de données est élevé, plus la valeur définie est élevée. Il existe également une valeur appelée le nombre d'itérations, mais une fois que la taille du lot et le nombre d'itérations sont déterminés, l'autre valeur est automatiquement déterminée.
Ce qui précède est le contenu de cette fois. Je viens de l'expliquer brièvement dans son ensemble, donc si vous voulez en savoir plus, veuillez vous référer à d'autres sites et articles.
J'espère que cet article sera un bon point d'entrée pour quiconque tente d'étudier l'apprentissage profond avec chainer.
Recommended Posts