Einführung

Ich möchte Chainer verwenden. Aber ich bin mir nicht sicher. Ja, beginnen wir mit dem Erlernen von XOR mit einem mehrschichtigen Perceptron.

** * Dieser Artikel basiert auf der Annahme, dass die Umgebung vorhanden ist, in der Chainer verwendet werden kann. ** ** **

** In diesem Artikel verwendeter Code **

GitHub/ichiroex/xor-mlp-chainer

Umgebung

--python 2.7 Serie

chainer 1.6.2.1

Trainingsdaten

# 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)

Modelldefinition

Das diesmal verwendete Modell besteht aus 2 Eingängen und 1 Ausgang.

N = len(source) # train data size

in_units  = 2   #Anzahl der Einheiten in der Eingabeebene
n_units   = 2   #Anzahl der versteckten Ebeneneinheiten
out_units = 1   #Anzahl der Einheiten in der Ausgabeebene

#Modelldefinition
model = chainer.Chain(l1=L.Linear(in_units, n_units),
                      l2=L.Linear(n_units , out_units))

Vorwärtsausbreitung

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

Lernen

Wiederholen Sie diesen Vorgang, bis der Trainingsfehler kleiner als 0,00001 ist oder die Epoche größer oder gleich n_epoch ist.

# 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()       #Nullinitialisierung des Gradienten
    y    = forward(x, t)    #Vorwärtsausbreitung

    loss = F.mean_squared_error(y, t) #Durchschnittlicher quadratischer Fehler
    
    loss.backward()              #Fehler bei der Weitergabe
    optimizer.update()           #Optimierung
    
    #Zeigen Sie das Ergebnis unterwegs an
    if epoch % 1000 == 0:
        #Berechnen Sie den Fehler und die richtige Antwortrate
        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)) #Trainingsfehler,Richtige Antwortrate
        print ' - - - - - - - - - '
    
    # n_Es endet, wenn es Epoche oder mehr wird
    if epoch >= n_epoch:
        break

    epoch += 1

#Modell und Optimierer speichern
print 'save the model'
serializers.save_npz('xor_mlp.model', model)
print 'save the optimizer'
serializers.save_npz('xor_mlp.state', optimizer)

Ausführungsergebnis

Ich lerne als Regressionsproblem. Wenn Sie eine Vorhersage treffen, müssen Sie einen Schwellenwert wie 1 für 0,5 oder mehr und 0 für weniger als 0,5 festlegen.

$ 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]  #Ich möchte, dass du näher an 0 kommst
 [-0.85900736]  #Ich möchte, dass Sie näher an 1 kommen
 [-0.4117983 ]  #Ich möchte, dass Sie näher an 1 kommen
 [-0.62129647]] #Ich möchte, dass du näher an 0 kommst
train mean loss=1.55636525154  #Trainingsfehler(Ich möchte, dass du kleiner bist)
 - - - - - - - - -
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] #Annäherung 0
 [  9.99812365e-01] #Annäherung 1
 [  9.99832511e-01] #Annäherung 1
 [  2.56299973e-04]] #Annäherung 0
train mean loss=3.31361960093e-08
 - - - - - - - - -
save the model
save the optimizer

[PYTHON] [Chainer] Lernen von XOR mit mehrschichtigem Perzeptron