Question

我正在尝试编写自己的神经网络框架作为练习。为了简单起见，我将展示一个神经元的玩具示例。

我们有一个神经元课

class Neuron:
   def __init__(self,representation,trainer):
      # initialize   

   def compute(self,input):
      # compute output

   def train(self,dataset):
      self.representation = self.trainer(self.representation,dataset)

   def getRepresentation(self):
      return self.representation

neuronRepresentation类是一个简单的包装器数据对象

class NeuronRepresentation:
   def __init__(self,weights,bias,activation):
      #initialize

但是火车方法漫长而复杂，我们希望能够使用不同的培训师（策略）。

 class SomeNeuronTrainer:
    def _init__(self):
       #initialize

    def train(self,representation,dataset)
       #train and return representation

所以基本上通过使用依赖注入，我们按照以下方式创建模型

representation = NeuronRepresentation([1,1,1],1,SigmoidActivation()) 
trainer = SomeNeuronTrainer()
model = Neuron(representation,trainer)

model.compute(someinput)
model.train(somedataset)
model.compute(someinput)

如您所见，培训师的培训方法有2个输入

一个可能的解决方案是在训练器的构造函数中注入表示，以便Neuron类委托，然后请求结果。

class Neuron
   ...
   def train(self,dataset)
      self.trainer.train(dataset)
      self.representation = self.trainer.getRepresentation()  
   ...

trainer = SomeNeuronTrainer(representation)
model = Neuron(representation,trainer)

然而，这对我来说似乎不对，并且是违反直觉的。当我们想在运行时交换训练器时，我们需要这样做

model.changeTrainer(SomeOtherTrainer(model.getRepresentation))

而不是

model.changeTrainer(SomeOtherTrainer())

编辑：我们也可以让训练师有一些方法setRepresentation（表示），让神经元将它设置在自己的初始化或我们改变训练器时。但这也意味着在初始化之后，只有在设置了表示并且我的信念禁止我创建这样的对象之后，才能容易地使用Trainer对象。为了解决这个问题，我们需要做一些更愚蠢的事情并注入一个建设者。

def changeTrainer(self,trainerBuilder)
   self.trainer = trainerBuilder.build(representation)

model.changeTrainer(SomeTrainerBuilder())

所有这一切只是为了删除一个参数。所以是的，这是可能的，但我的问题是它是否有可能以一种看似自然的方式。

这种二元方法能否自然地重构为monadic方法

0 个答案: