왜이 간단한 신경 회로망이 XOR에 수렴하지 않습니까?

Question

아래의 네트워크 코드는 정상적으로 작동하지만 너무 느립니다. This site은 학습 속도가 0.2 인 100 에포크 이후 네트워크가 99 %의 정확도를 가져야한다는 것을 의미하지만 1900 년 이후에도 네트워크가 97 %를 넘지 않습니다.

Epoch 0, Inputs [0 0], Outputs [-0.83054376], Targets [0] 
Epoch 100, Inputs [0 1], Outputs [ 0.72563824], Targets [1] 
Epoch 200, Inputs [1 0], Outputs [ 0.87570863], Targets [1] 
Epoch 300, Inputs [0 1], Outputs [ 0.90996706], Targets [1] 
Epoch 400, Inputs [1 1], Outputs [ 0.00204791], Targets [0] 
Epoch 500, Inputs [0 1], Outputs [ 0.93396672], Targets [1] 
Epoch 600, Inputs [0 0], Outputs [ 0.00006375], Targets [0] 
Epoch 700, Inputs [0 1], Outputs [ 0.94778227], Targets [1] 
Epoch 800, Inputs [1 1], Outputs [-0.00149935], Targets [0] 
Epoch 900, Inputs [0 0], Outputs [-0.00122716], Targets [0] 
Epoch 1000, Inputs [0 0], Outputs [ 0.00457281], Targets [0] 
Epoch 1100, Inputs [0 1], Outputs [ 0.95921556], Targets [1] 
Epoch 1200, Inputs [0 1], Outputs [ 0.96001748], Targets [1] 
Epoch 1300, Inputs [1 0], Outputs [ 0.96071742], Targets [1] 
Epoch 1400, Inputs [1 1], Outputs [ 0.00110912], Targets [0] 
Epoch 1500, Inputs [0 0], Outputs [-0.00], Targets [0] 
Epoch 1600, Inputs [1 0], Outputs [ 0.9640324], Targets [1] 
Epoch 1700, Inputs [1 0], Outputs [ 0.96431516], Targets [1] 
Epoch 1800, Inputs [0 1], Outputs [ 0.97004973], Targets [1] 
Epoch 1900, Inputs [1 0], Outputs [ 0.96616225], Targets [1] 

내가 사용하고 데이터 집합은 다음과 같습니다

0 0 0 
1 0 1 
0 1 1 
1 1 1 

훈련 세트는 헬퍼 파일에서 함수를 사용하여 읽기,하지만 네트워크와 관련이 없습니다. 내가 predictions = self.forward_propagate(inputs[i])if에서 촬영하면

for epoch in range(epochs): 
    i = np.random.randint(0, len(inputs)) 
    if epoch % testfreq == 0: 
    predictions = self.forward_propagate(inputs[i]) 
    print('Epoch %s, Inputs %s, Outputs %s, Targets %s' % (epoch, inputs[i], predictions, targets[i])) 
    self.backpropagate_error(inputs[i], targets[i]) 
    self.adjust_weights(inputs[i], lrate) 

, 나는 훨씬 더 나은 결과를 빨리 얻을 :

import numpy as np 
import helper 

FILE_NAME = 'data.txt' 
EPOCHS = 2000 
TESTING_FREQ = 5 
LEARNING_RATE = 0.2 

INPUT_SIZE = 2 
HIDDEN_LAYERS = [5] 
OUTPUT_SIZE = 1 


class Classifier: 
    def __init__(self, layer_sizes): 
     np.set_printoptions(suppress=True) 

     self.activ = helper.tanh 
     self.dactiv = helper.dtanh 

     network = list() 
     for i in range(1, len(layer_sizes)): 
      layer = dict() 
      layer['weights'] = np.random.randn(layer_sizes[i], layer_sizes[i-1]) 
      layer['biases'] = np.random.randn(layer_sizes[i]) 
      network.append(layer) 

     self.network = network 

    def forward_propagate(self, x): 
     for i in range(0, len(self.network)): 
      self.network[i]['outputs'] = self.network[i]['weights'].dot(x) + self.network[i]['biases'] 
      if i != len(self.network)-1: 
       self.network[i]['outputs'] = x = self.activ(self.network[i]['outputs']) 
      else: 
       self.network[i]['outputs'] = self.activ(self.network[i]['outputs']) 
     return self.network[-1]['outputs'] 

    def backpropagate_error(self, x, targets): 
     self.forward_propagate(x) 
     self.network[-1]['deltas'] = (self.network[-1]['outputs'] - targets) * self.dactiv(self.network[-1]['outputs']) 
     for i in reversed(range(len(self.network)-1)): 
      self.network[i]['deltas'] = self.network[i+1]['deltas'].dot(self.network[i+1]['weights'] * self.dactiv(self.network[i]['outputs'])) 

    def adjust_weights(self, inputs, learning_rate): 
     self.network[0]['weights'] -= learning_rate * np.atleast_2d(self.network[0]['deltas']).T.dot(np.atleast_2d(inputs)) 
     self.network[0]['biases'] -= learning_rate * self.network[0]['deltas'] 
     for i in range(1, len(self.network)): 
      self.network[i]['weights'] -= learning_rate * np.atleast_2d(self.network[i]['deltas']).T.dot(np.atleast_2d(self.network[i-1]['outputs'])) 
      self.network[i]['biases'] -= learning_rate * self.network[i]['deltas'] 

    def train(self, inputs, targets, epochs, testfreq, lrate): 
     for epoch in range(epochs): 
      i = np.random.randint(0, len(inputs)) 
      if epoch % testfreq == 0: 
       predictions = self.forward_propagate(inputs[i]) 
       print('Epoch %s, Inputs %s, Outputs %s, Targets %s' % (epoch, inputs[i], predictions, targets[i])) 
      self.backpropagate_error(inputs[i], targets[i]) 
      self.adjust_weights(inputs[i], lrate) 


inputs, outputs = helper.readInput(FILE_NAME, INPUT_SIZE, OUTPUT_SIZE) 
print('Input data: {0}'.format(inputs)) 
print('Output targets: {0}\n'.format(outputs)) 
np.random.seed(1) 

nn = Classifier([INPUT_SIZE] + HIDDEN_LAYERS + [OUTPUT_SIZE]) 

nn.train(inputs, outputs, EPOCHS, TESTING_FREQ, LEARNING_RATE) 

Answer 1

주요 버그 epoch % testfreq == 0이 때, 즉 전진 패스 시간의 20 %를하고있는 것입니다 : 또한

Epoch 100, Inputs [0 1], Outputs [ 0.80317447], Targets 1 
Epoch 105, Inputs [1 1], Outputs [ 0.96340466], Targets 1 
Epoch 110, Inputs [1 1], Outputs [ 0.96057278], Targets 1 
Epoch 115, Inputs [1 0], Outputs [ 0.87960599], Targets 1 
Epoch 120, Inputs [1 1], Outputs [ 0.97725825], Targets 1 
Epoch 125, Inputs [1 0], Outputs [ 0.89433666], Targets 1 
Epoch 130, Inputs [0 0], Outputs [ 0.03539024], Targets 0 
Epoch 135, Inputs [0 1], Outputs [ 0.92888141], Targets 1 

라는 용어 시대 보통의 단일 실행을 의미 있습니다 귀하의 경우 4의 훈련 데이터의 모든은, 그래서, 사실, 당신은 4 배 적은 신 (新) 시대를하고 있습니다.

나는 결과로, 세부 사항에주의를 지불하지 않았다

업데이트, 놓친 몇 가지 미묘한 아직 중요한 참고 :

• 훈련 데이터 문제는 또는하지 나타냅니다 XOR, 내 결과가 위의 또는 작업을 학습 그래서;
• 뒤로 패스 전달뿐만 아니라 앞으로 실행한다 (그래서 버그 아니라 놀라운 구현 세부 사항이 아니다). 이 문제를 알고
는

, 나는 데이터를 업데이트하고 다시 한 번 스크립트를 확인했습니다. 이 수로 모델 이 학습, 단순히 너무 빨리하지 그래서 10000 반복에 대한 교육을 실행하면, ~ 0.001 평균 오차했다.

(매립 정규화기구)없이 간단한 신경망은 초기화 및 학습 속도와 같은 특정 하이퍼 파라미터에 아주 민감하다.

# slightly bigger learning rate 
LEARNING_RATE = 0.3 
... 
# slightly bigger init variation of weights 
layer['weights'] = np.random.randn(layer_sizes[i], layer_sizes[i-1]) * 2.0 

이 다음과 같은 성능을 제공합니다 : I 수동으로 여기에 내가있어 무엇 다양한 값을 시도

... 
Epoch 960, Inputs [1 1], Outputs [ 0.01392014], Targets 0 
Epoch 970, Inputs [0 0], Outputs [ 0.04342895], Targets 0 
Epoch 980, Inputs [1 0], Outputs [ 0.96471654], Targets 1 
Epoch 990, Inputs [1 1], Outputs [ 0.00084511], Targets 0 
Epoch 1000, Inputs [0 0], Outputs [ 0.01585915], Targets 0 
Epoch 1010, Inputs [1 1], Outputs [-0.004097], Targets 0 
Epoch 1020, Inputs [1 1], Outputs [ 0.01898956], Targets 0 
Epoch 1030, Inputs [0 0], Outputs [ 0.01254217], Targets 0 
Epoch 1040, Inputs [1 1], Outputs [ 0.01429213], Targets 0 
Epoch 1050, Inputs [0 1], Outputs [ 0.98293925], Targets 1 
... 
Epoch 1920, Inputs [1 1], Outputs [-0.00043072], Targets 0 
Epoch 1930, Inputs [0 1], Outputs [ 0.98544288], Targets 1 
Epoch 1940, Inputs [1 0], Outputs [ 0.97682002], Targets 1 
Epoch 1950, Inputs [1 0], Outputs [ 0.97684186], Targets 1 
Epoch 1960, Inputs [0 0], Outputs [-0.00141565], Targets 0 
Epoch 1970, Inputs [0 0], Outputs [-0.00097559], Targets 0 
Epoch 1980, Inputs [0 1], Outputs [ 0.98548381], Targets 1 
Epoch 1990, Inputs [1 0], Outputs [ 0.97721286], Targets 1 

평균 정확도 1000 반복 후 98.5 %와 99.1 % 이후에 가깝습니다 2000 회 반복. 약속보다 약간 느리지 만 충분히 좋습니다. 나는 그것이 더 조정될 수 있다고 확신하지만이 장난감 운동의 목표는 아닙니다. 결국, tanh is not 최상의 활성화 기능 및 분류 문제는 L2 엔트로피 손실 (L2 손실이 아닌)으로 더 잘 해결되어야합니다.따라서이 특정 네트워크의 성능에 대해 너무 걱정하지 않고 로지스틱 회귀 분석을 계속 진행할 것입니다. 그것은 학습 속도 측면에서 확실히 더 나을 것입니다.