Простая нейронная сеть с нуля с использованием NumPy

Question

Я добавил скорость обучения и импульс для реализации нейронной сети с нуля, которую я нашел по адресу: https://towardsdatascience.com/how-to-build-your-own-neural-network-from-scratch-in-python-68998a08e4f6

Однако у меня было несколько вопросов о моей реализации:

• Этоправильный?Какие-либо предлагаемые улучшения?Похоже, что он дает адекватные результаты в целом, но внешний совет очень ценится.

• При скорости обучения <0,5 или импульсе> 0,9 сеть имеет тенденцию застрять в локальном оптимуме, где потери = ~ 1.Я предполагаю, что это потому, что размер шага не достаточно велик, чтобы избежать этого, но есть ли способ преодолеть это?Или это присуще характеру решаемых данных и неизбежно.

  import numpy as np
  import matplotlib.pyplot as plt
  
  
  def sigmoid(x):
      return 1 / (1 + np.exp(-x))
  
  
  def sigmoid_derivative(x):
      sig = 1 / (1 + np.exp(-x))
      return sig * (1 - sig)
  
  
  class NeuralNetwork:
      def __init__(self, x, y):
          self.input      = x
          self.weights1   = np.random.rand(self.input.shape[1], 4)
          self.weights2   = np.random.rand(4, 1)
          self.y          = y
          self.output     = np.zeros(self.y.shape)
          self.v_dw1      = 0
          self.v_dw2      = 0
          self.alpha      = 0.5
          self.beta       = 0.5
  
      def feedforward(self):
          self.layer1 = sigmoid(np.dot(self.input, self.weights1))
          self.output = sigmoid(np.dot(self.layer1, self.weights2))
  
      def backprop(self, alpha, beta):
          # application of the chain rule to find derivative of the loss function with respect to weights2 and weights1
          d_weights2 = np.dot(self.layer1.T, (2*(self.y - self.output) * sigmoid_derivative(self.output)))
          d_weights1 = np.dot(self.input.T,  (np.dot(2*(self.y - self.output) *
                                              sigmoid_derivative(self.output), self.weights2.T) *
                                              sigmoid_derivative(self.layer1)))
          # adding effect of momentum
          self.v_dw1 = (beta * self.v_dw1) + ((1 - beta) * d_weights1)
          self.v_dw2 = (beta * self.v_dw2) + ((1 - beta) * d_weights2)
          # update the weights with the derivative (slope) of the loss function
          self.weights1 = self.weights1 + (self.v_dw1 * alpha)
          self.weights2 = self.weights2 + (self.v_dw2 * alpha)
  
  
  if __name__ == "__main__":
      X = np.array([[0, 0, 1],
                    [0, 1, 1],
                    [1, 0, 1],
                    [1, 1, 1]])
      y = np.array([[0], [1], [1], [0]])
      nn = NeuralNetwork(X, y)
  
      total_loss = []
      for i in range(10000):
          nn.feedforward()
          nn.backprop(nn.alpha, nn.beta)
          total_loss.append(sum((nn.y-nn.output)**2))
  
      iteration_num = list(range(10000))
      plt.plot(iteration_num, total_loss)
      plt.show()
      print(nn.output)
  

Answer 1

Во-первых, в вашем "sigmoid_derivative (x)" вход в эту функцию уже является выходом сигмоида, но вы снова получаете сигмоиду и затем вычисляете производную, то есть одну проблему, это должно быть:

return x * (1 - x)

вторая проблема, вы не используете предвзятость, откуда вы знаете, что граница вашего решения пересечет источник в пространстве гипотез задачи?так что вам нужно добавить термин смещения.

И последнее, что я думаю, что ваши производные не верны, вы можете обратиться к Эндрю Нг курс глубокого обучения 1, неделя 2 на coursera.org, чтобы получить список общих формулдля вычисления обратного распространения в нейронных сетях, чтобы убедиться, что вы делаете все правильно.