得墨忒耳定律——需要内部表示吗？

Question

假设我们有一个“神经网络”类

• 每个神经网络都由层组成
• 每一层都由神经元组成

• 每个神经元由权重、偏差和激活函数组成

  class Neuron:
      def __init__(self,weights,bias,activation):
          self._weights = weights
          self._bias = bias
          self._activation = activation
  
      def activate(self,input):
          return self._activation.compute(self._weights.dot(input)+self._bias)
  
  
  class Layer:
      def __init__(self,neurons):
          self._neurons = neurons
  
      def compute(self,input):
          output = []
          for neuron in self._neurons:
              output.append(neuron.activate(input))
          return output
  
  
  class NeuralNetwork:
      def __init__(self,layers):
          self._layers = layers
  
      def compute(self,input):
          output = input
          for layer in self._layers:
              output = layer.compute(output)
          return output
  
      def train(self,dataset):
          # do some training
          # changes the neurons inside the layers
  

NeuralNetwork 有一个方法 train() 可以改变其内部表示。 但这意味着可以访问 Layer 对象的内部。它需要访问单个神经元，这违反了得墨忒耳定律。 例如

layers[0].getNeuron(0).compute(input)

layer[0].getNeuron(0).changeBias(2)

我能想到的唯一解决方案是在“层”中提供额外的方法并将其委托给神经元。这也将允许我使用 Layer 接口的不同实现。一种更灵活，一种性能更好。

但这似乎很麻烦。没有更好的方法来建模吗？

Answer 1

第一个可能的解决方案是添加一些委托的方法。

从 Amr Mostafa 的 cmets 中提取的第二种解决方案是通过 Layer 对象向神经元发送一个事件。

这两种解决方案都允许我们使用不同的 Layer 对象，该对象由多维数组组成，而不是神经元对象（性能考虑）。