[Chainer] Apprentissage de XOR avec perceptron multicouche

introduction

Je veux utiliser Chainer. Mais je ne suis pas sur. Oui, commençons par apprendre XOR avec un Perceptron multicouche.

** * Cet article est écrit sur l'hypothèse que l'environnement dans lequel Chainer peut être utilisé est en place. ** **

** Code utilisé dans cet article **

environnement

Données d'entraînement

# Prepare dataset
source = [[0, 0], [1, 0], [0, 1], [1, 1]]
target = [[0], [1], [1], [0]]
dataset = {}
dataset['source'] = np.array(source, dtype=np.float32)
dataset['target'] = np.array(target, dtype=np.float32)

Définition du modèle

Le modèle utilisé cette fois est de 2 entrées et 1 sortie.

N = len(source) # train data size

in_units  = 2   #Nombre d'unités dans la couche d'entrée
n_units   = 2   #Nombre d'unités de calque masquées
out_units = 1   #Nombre d'unités dans la couche de sortie

#Définition du modèle
model = chainer.Chain(l1=L.Linear(in_units, n_units),
                      l2=L.Linear(n_units , out_units))

Propagation vers l'avant

def forward(x, t):
    h1 = F.sigmoid(model.l1(x))
    return model.l2(h1)

Apprentissage

Répétez jusqu'à ce que l'erreur d'apprentissage soit inférieure à 0,00001 ou que l'époque soit supérieure ou égale à n_epoch.

# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)

# Learning loop
loss_val = 100
epoch = 0
while loss_val > 1e-5:

    # training
    x = chainer.Variable(xp.asarray(dataset['source'])) #source
    t = chainer.Variable(xp.asarray(dataset['target'])) #target
    
    model.zerograds()       #Zéro initialisation du gradient
    y    = forward(x, t)    #Propagation vers l'avant

    loss = F.mean_squared_error(y, t) #Erreur quadratique moyenne
    
    loss.backward()              #Erreur de propagation de retour
    optimizer.update()           #optimisation
    
    #Afficher le résultat en chemin
    if epoch % 1000 == 0:
        #Calculer l'erreur et corriger le taux de réponse
        loss_val = loss.data

        print 'epoch:', epoch
        print 'x:\n', x.data
        print 't:\n', t.data
        print 'y:\n', y.data

        print('train mean loss={}'.format(loss_val)) #Erreur d'entraînement,Taux de réponse correct
        print ' - - - - - - - - - '
    
    # n_Il se termine quand il devient époque ou plus
    if epoch >= n_epoch:
        break

    epoch += 1

#Enregistrer le modèle et l'optimiseur
print 'save the model'
serializers.save_npz('xor_mlp.model', model)
print 'save the optimizer'
serializers.save_npz('xor_mlp.state', optimizer)

Résultat d'exécution

J'apprends comme un problème de régression. Lors d'une prédiction, il est nécessaire de définir un seuil tel que 1 pour 0,5 ou plus et 0 pour moins de 0,5.

$ python train_xor.py --gpu 1
epoch: 0
x:
[[ 0.  0.]
 [ 1.  0.]
 [ 0.  1.]
 [ 1.  1.]]
t:
[[ 0.]
 [ 1.]
 [ 1.]
 [ 0.]]
y:
[[-0.62479508]  #Je veux que tu te rapproche de 0
 [-0.85900736]  #Je veux que tu te rapproche de 1
 [-0.4117983 ]  #Je veux que tu te rapproche de 1
 [-0.62129647]] #Je veux que tu te rapproche de 0
train mean loss=1.55636525154  #Erreur d'entraînement(Je veux que tu sois plus petit)
 - - - - - - - - -
epoch: 1000
x:
[[ 0.  0.]
 [ 1.  0.]
 [ 0.  1.]
 [ 1.  1.]]
t:
[[ 0.]
 [ 1.]
 [ 1.]
 [ 0.]]
y:
[[ 0.39130747]
 [ 0.40636665]
 [ 0.50217605]
 [ 0.52426183]]
train mean loss=0.257050335407
 - - - - - - - - -

...


 - - - - - - - - -
epoch: 8000
x:
[[ 0.  0.]
 [ 1.  0.]
 [ 0.  1.]
 [ 1.  1.]]
t:
[[ 0.]
 [ 1.]
 [ 1.]
 [ 0.]]
y:
[[ 0.00557911]
 [ 0.98262894]
 [ 0.98446763]
 [ 0.02371788]]
train mean loss=0.000284168170765
 - - - - - - - - -
epoch: 9000
x:
[[ 0.  0.]
 [ 1.  0.]
 [ 0.  1.]
 [ 1.  1.]]
t:
[[ 0.]
 [ 1.]
 [ 1.]
 [ 0.]]
y:
[[  5.99622726e-05] #Approché 0
 [  9.99812365e-01] #Approché 1
 [  9.99832511e-01] #Approché 1
 [  2.56299973e-04]] #Approché 0
train mean loss=3.31361960093e-08
 - - - - - - - - -
save the model
save the optimizer

chart.png

Article de référence

Recommended Posts

[Chainer] Apprentissage de XOR avec perceptron multicouche
Perceptron multicouche avec chaînette: ajustement fonctionnel
Expérience d'apprentissage Perceptron apprise avec Python
Essayez l'apprentissage de la représentation commune avec le chainer
Classez les visages d'anime avec l'apprentissage en profondeur avec Chainer
Essayez avec Chainer Deep Q Learning - Lancement
Faire un circuit logique avec Perceptron (Perceptron multicouche)
Seq2Seq (1) avec chainer
Classification d'image MNIST (numéro manuscrit) avec Perceptron multicouche
Prévision de stock avec TensorFlow (perceptron multicouche: MLP) ~ Prévision de stock 2 ~
Apprendre Python avec ChemTHEATER 03
Apprendre Python avec ChemTHEATER 05-1
Régression linéaire multiple, régression logistique, perceptron multicouche, encodeur automatique, Chainer Yo!
Apprendre Python avec ChemTHEATER 02
Apprendre Python avec ChemTHEATER 01
Utilisez l'ensemble de données d'entraînement scikit-learn avec chainer (pour l'entraînement / la prédiction)
Maintenant, essayons la reconnaissance faciale avec Chainer (phase d'apprentissage)
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
Déplaçons word2vec avec Chainer et voyons la progression de l'apprentissage
L'apprentissage automatique appris avec Pokemon
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez d'implémenter RBM avec chainer.
Renforcer l'apprentissage 6 First Chainer RL
Apprentissage amélioré à partir de Python
Essayez d'implémenter XOR avec PyTorch
Apprenez les orbites elliptiques avec Chainer
À propos de l'apprentissage avec Google Colab
Apprentissage automatique avec Python! Préparation
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Effectuer des opérations logiques à l'aide de Perceptron
Seq2Seq (3) ~ Edition CopyNet ~ avec chainer
Utilisation du chainer avec Jetson TK1
L'apprentissage le plus rapide sous Linux avec AWS
Réseau de neurones commençant par Chainer
Démineur d'apprentissage automatique avec PyTorch
Votre Perceptron multicouche est sale
Algorithme d'apprentissage automatique (perceptron simple)
Implémentation du GAN conditionnel avec chainer
Génération de légende d'image avec Chainer
Commencer avec l'apprentissage automatique Python
Traitement itératif Python appris avec ChemoInfomatics
Implémentation de SmoothGrad avec Chainer v2
Clustering embarqué profond avec Chainer 2.0
Un peu coincé dans le chainer
Essayez le machine learning à la légère avec Kaggle
Générez des Pokémon avec Deep Learning
Perceptron multi-couches pour le Deep Learning (Deep Learning avec Python; Série MPS Yokohama Deep Learning)
Introduction au Deep Learning (2) - Essayez votre propre régression non linéaire avec Chainer-