여러 객체는 어떻게 든 서로

Question

가능한 중복 방해 :
Multiple objects somehow interfering with each other [original version]

(참고 : 나는 그렇게 몇 시간 전에 비슷한 질문을 게시 있지만 가난하게 표현되고 설명 더 명확한 재 제출 임)

안녕하세요,

단일 데이터 세트에 적용 할 때 완벽하게 작동하는 신경망 (NN)이 있습니다. 그러나 예를 들어 한 세트의 데이터에서 NN을 실행 한 다음 다른 데이터 세트 (또는 동일한 세트)에서 실행되도록 NN의 새 인스턴스를 작성하면 새 인스턴스가 완전히 잘못된 예측을 생성합니다 .

예를 들어, XOR 패턴에 대한 교육 :

test=[[0,0],[0,1],[1,0],[1,1]] 
    data = [[[0,0], [0]],[[0,1], [0]],[[1,0], [0]],[[1,1], [1]]] 

    n = NN(2, 3, 1) # Create a neural network with 2 input, 3 hidden and 1 output nodes 
    n.train(data,500,0.5,0) # Train it for 500 iterations with learning rate 0.5 and momentum 0 

    prediction = np.zeros((len(test))) 
    for row in range(len(test)): 
     prediction[row] = n.runNetwork(test[row])[0] 

    print prediction 

    # 
    # Now do the same thing again but with a new instance and new version of the data. 
    # 

    test2=[[0,0],[0,1],[1,0],[1,1]] 
    data2 = [[[0,0], [0]],[[0,1], [0]],[[1,0], [0]],[[1,1], [1]]] 

    p = NN(2, 3, 1) 
    p.train(data2,500,0.5,0) 

    prediction2 = np.zeros((len(test2))) 
    for row in range(len(test2)): 
     prediction2[row] = p.runNetwork(test2[row])[0] 

    print prediction2 

출력 :

[-0.01 -0. -0.06 0.97] 
    [ 0. 0. 1. 1.] 

공지 사항 첫 번째 예측은 두 번째는 완전히 잘못된 곳으로 아주 좋은, 그리고 내가 할 수있는 것을 ' 수업에 문제가없는 것을 확인하십시오 :

import math 
    import random 
    import itertools 
    import numpy as np 

    random.seed(0) 

    def rand(a, b): 
     return (b-a)*random.random() + a 

    def sigmoid(x): 
     return math.tanh(x) 

    def dsigmoid(y): 
     return 1.0 - y**2 

    class NN: 
     def __init__(self, ni, nh, no): 
      # number of input, hidden, and output nodes 
      self.ni = ni + 1 # +1 for bias node 
      self.nh = nh + 1 
      self.no = no 

      # activations for nodes 
      self.ai = [1.0]*self.ni 
      self.ah = [1.0]*self.nh 
      self.ao = [1.0]*self.no 

      # create weights (rows=number of features, columns=number of processing nodes) 
      self.wi = np.zeros((self.ni, self.nh)) 
      self.wo = np.zeros((self.nh, self.no)) 
      # set them to random vaules 
      for i in range(self.ni): 
       for j in range(self.nh): 
        self.wi[i][j] = rand(-5, 5) 
      for j in range(self.nh): 
       for k in range(self.no): 
        self.wo[j][k] = rand(-5, 5) 

      # last change in weights for momentum 
      self.ci = np.zeros((self.ni, self.nh)) 
      self.co = np.zeros((self.nh, self.no)) 


     def runNetwork(self, inputs): 
      if len(inputs) != self.ni-1: 
       raise ValueError('wrong number of inputs') 

      # input activations 
      for i in range(self.ni-1): 
       #self.ai[i] = sigmoid(inputs[i]) 
       self.ai[i] = inputs[i] 

      # hidden activations 
      for j in range(self.nh-1): 
       sum = 0.0 
       for i in range(self.ni): 
        sum = sum + self.ai[i] * self.wi[i][j] 
       self.ah[j] = sigmoid(sum) 

      # output activations 
      for k in range(self.no): 
       sum = 0.0 
       for j in range(self.nh): 
        sum = sum + self.ah[j] * self.wo[j][k] 
       self.ao[k] = sigmoid(sum) 

      ao_simplified = [round(a,2) for a in self.ao[:]] 
      return ao_simplified 


     def backPropagate(self, targets, N, M): 
      if len(targets) != self.no: 
       raise ValueError('wrong number of target values') 

      # calculate error terms for output 
      output_deltas = [0.0] * self.no 
      for k in range(self.no): 
       error = targets[k]-self.ao[k] 
       output_deltas[k] = dsigmoid(self.ao[k]) * error 

      # calculate error terms for hidden 
      hidden_deltas = [0.0] * self.nh 
      for j in range(self.nh): 
       error = 0.0 
       for k in range(self.no): 
        error = error + output_deltas[k]*self.wo[j][k] 
       hidden_deltas[j] = dsigmoid(self.ah[j]) * error 

      # update output weights 
      for j in range(self.nh): 
       for k in range(self.no): 
        change = output_deltas[k]*self.ah[j] 
        self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k] 
        self.co[j][k] = change 
        #print N*change, M*self.co[j][k] 

      # update input weights 
      for i in range(self.ni): 
       for j in range(self.nh): 
        change = hidden_deltas[j]*self.ai[i] 
        self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j] 
        self.ci[i][j] = change 

      # calculate error 
      error = 0.0 
      for k in range(len(targets)): 
       error = error + 0.5*(targets[k]-self.ao[k])**2 
      return error 

     def train(self, patterns, iterations=1000, N=0.5, M=0.1): 
      # N: learning rate 
      # M: momentum factor 
      for i in range(iterations): 
       error = 0.0 
       for p in patterns: 
        inputs = p[0] 
        targets = p[1] 
        self.runNetwork(inputs) 
        error = error + self.backPropagate(targets, N, M) 
       if i % 100 == 0: # Prints error every 100 iterations 
        print('error %-.5f' % error) 

어떤 도움을 주시면 감사하겠습니다!

Answer 1

명확하게 볼 수있는 한 가지는 0에 012 임의로 시드를 부여한다는 것입니다. 나는 그 문제에 대해 충분히 알고 있지 않습니다. 그 의도가 무엇인지 알고 계십시오. 그러나이 작업을 수행하면 항상 동일한 일련의 숫자가 산출됩니다. , 하나씩. 숫자는 의사 랜덤입니다.

동일한 클래스의 두 번째 인스턴스를 사용할 때 임의 시드는 모듈 코드에 있으므로 일련 번호는 재설정되지 않으며 같은 번호가 아닌 일련의 pseuo- 난수가 연속되어 실행됩니다 . 두 번째 실행에서 다른 결과가 나타날 수 있습니다 Google 알고리즘이 실제로 임의의 숫자와 작동하지 않지만 사용 가능한 특정 시리즈에 따라 다를 경우 b random.seed (0)

그 외의 경우 코드가 보이지 않습니다. 인스턴스 오브젝트에서 상태를 유지하여 설명하는 문제점을 초래할 수 있습니다.

시간에 - 귀하의 일이 실제로 난수와 함께 작동해야한다면 모듈 수준에서 random.seed 문을 버리십시오. 알고리즘은 정확하고 random.seed (0) 후 산출 순서에 의존하는 경우

그렇지 않으면, 당신은 전에이 문을 다시 발행 네트워크