编辑2:
新建训练集。。。在
输入:
[
[0.0, 0.0],
[0.0, 1.0],
[0.0, 2.0],
[0.0, 3.0],
[0.0, 4.0],
[1.0, 0.0],
[1.0, 1.0],
[1.0, 2.0],
[1.0, 3.0],
[1.0, 4.0],
[2.0, 0.0],
[2.0, 1.0],
[2.0, 2.0],
[2.0, 3.0],
[2.0, 4.0],
[3.0, 0.0],
[3.0, 1.0],
[3.0, 2.0],
[3.0, 3.0],
[3.0, 4.0],
[4.0, 0.0],
[4.0, 1.0],
[4.0, 2.0],
[4.0, 3.0],
[4.0, 4.0]
]
输出:
^{pr2}$编辑1:
我已经用我最新的代码更新了这个问题。我修复了一些小问题,但我仍然得到相同的输出,所有的输入组合后,网络学习。在
下面是backprop算法的解释:Backprop algorithm
是的,这是一个家庭作业,一开始就把它弄清楚。在
我要在一个简单的神经网络上实现一个简单的反向传播算法。在
我选择了Python作为这项任务的语言,我选择了一个类似这样的神经网络:
3层:1个输入层,1个隐藏层,1个输出层:
O O
O
O O
输入神经元都是整数,输出神经元是1或0。在
这是我的整个实现(有点长)。在下面,我将选择较短的相关片段,我认为错误可能位于:
import os
import math
import Image
import random
from random import sample
#------------------------------ class definitions
class Weight:
def __init__(self, fromNeuron, toNeuron):
self.value = random.uniform(-0.5, 0.5)
self.fromNeuron = fromNeuron
self.toNeuron = toNeuron
fromNeuron.outputWeights.append(self)
toNeuron.inputWeights.append(self)
self.delta = 0.0 # delta value, this will accumulate and after each training cycle used to adjust the weight value
def calculateDelta(self, network):
self.delta += self.fromNeuron.value * self.toNeuron.error
class Neuron:
def __init__(self):
self.value = 0.0 # the output
self.idealValue = 0.0 # the ideal output
self.error = 0.0 # error between output and ideal output
self.inputWeights = []
self.outputWeights = []
def activate(self, network):
x = 0.0;
for weight in self.inputWeights:
x += weight.value * weight.fromNeuron.value
# sigmoid function
if x < -320:
self.value = 0
elif x > 320:
self.value = 1
else:
self.value = 1 / (1 + math.exp(-x))
class Layer:
def __init__(self, neurons):
self.neurons = neurons
def activate(self, network):
for neuron in self.neurons:
neuron.activate(network)
class Network:
def __init__(self, layers, learningRate):
self.layers = layers
self.learningRate = learningRate # the rate at which the network learns
self.weights = []
for hiddenNeuron in self.layers[1].neurons:
for inputNeuron in self.layers[0].neurons:
self.weights.append(Weight(inputNeuron, hiddenNeuron))
for outputNeuron in self.layers[2].neurons:
self.weights.append(Weight(hiddenNeuron, outputNeuron))
def setInputs(self, inputs):
self.layers[0].neurons[0].value = float(inputs[0])
self.layers[0].neurons[1].value = float(inputs[1])
def setExpectedOutputs(self, expectedOutputs):
self.layers[2].neurons[0].idealValue = expectedOutputs[0]
def calculateOutputs(self, expectedOutputs):
self.setExpectedOutputs(expectedOutputs)
self.layers[1].activate(self) # activation function for hidden layer
self.layers[2].activate(self) # activation function for output layer
def calculateOutputErrors(self):
for neuron in self.layers[2].neurons:
neuron.error = (neuron.idealValue - neuron.value) * neuron.value * (1 - neuron.value)
def calculateHiddenErrors(self):
for neuron in self.layers[1].neurons:
error = 0.0
for weight in neuron.outputWeights:
error += weight.toNeuron.error * weight.value
neuron.error = error * neuron.value * (1 - neuron.value)
def calculateDeltas(self):
for weight in self.weights:
weight.calculateDelta(self)
def train(self, inputs, expectedOutputs):
self.setInputs(inputs)
self.calculateOutputs(expectedOutputs)
self.calculateOutputErrors()
self.calculateHiddenErrors()
self.calculateDeltas()
def learn(self):
for weight in self.weights:
weight.value += self.learningRate * weight.delta
def calculateSingleOutput(self, inputs):
self.setInputs(inputs)
self.layers[1].activate(self)
self.layers[2].activate(self)
#return round(self.layers[2].neurons[0].value, 0)
return self.layers[2].neurons[0].value
#------------------------------ initialize objects etc
inputLayer = Layer([Neuron() for n in range(2)])
hiddenLayer = Layer([Neuron() for n in range(100)])
outputLayer = Layer([Neuron() for n in range(1)])
learningRate = 0.5
network = Network([inputLayer, hiddenLayer, outputLayer], learningRate)
# just for debugging, the real training set is much larger
trainingInputs = [
[0.0, 0.0],
[1.0, 0.0],
[2.0, 0.0],
[0.0, 1.0],
[1.0, 1.0],
[2.0, 1.0],
[0.0, 2.0],
[1.0, 2.0],
[2.0, 2.0]
]
trainingOutputs = [
[0.0],
[1.0],
[1.0],
[0.0],
[1.0],
[0.0],
[0.0],
[0.0],
[1.0]
]
#------------------------------ let's train
for i in range(500):
for j in range(len(trainingOutputs)):
network.train(trainingInputs[j], trainingOutputs[j])
network.learn()
#------------------------------ let's check
for pattern in trainingInputs:
print network.calculateSingleOutput(pattern)
现在,问题是,在学习之后,网络似乎返回一个非常接近0.0的浮点数,对于所有的输入组合,甚至那些应该接近1.0的组合也是如此。在
我以100个周期训练网络,每个周期我都会:
对于训练集中的每一组输入:
然后根据学习率和累积的增量调整权重。在
这是我对神经元的激活函数:
def activationFunction(self, network):
"""
Calculate an activation function of a neuron which is a sum of all input weights * neurons where those weights start
"""
x = 0.0;
for weight in self.inputWeights:
x += weight.value * weight.getFromNeuron(network).value
# sigmoid function
self.value = 1 / (1 + math.exp(-x))
我是这样计算三角洲的:
def calculateDelta(self, network):
self.delta += self.getFromNeuron(network).value * self.getToNeuron(network).error
这是我的算法的一般流程:
for i in range(numberOfIterations):
for k,expectedOutput in trainingSet.iteritems():
coordinates = k.split(",")
network.setInputs((float(coordinates[0]), float(coordinates[1])))
network.calculateOutputs([float(expectedOutput)])
network.calculateOutputErrors()
network.calculateHiddenErrors()
network.calculateDeltas()
oldWeights = network.weights
network.adjustWeights()
network.resetDeltas()
print "Iteration ", i
j = 0
for weight in network.weights:
print "Weight W", weight.i, weight.j, ": ", oldWeights[j].value, " ............ Adjusted value : ", weight.value
j += j
输出的最后两行是:
0.552785449458 # this should be close to 1
0.552785449458 # this should be close to 0
它实际上返回所有输入组合的输出编号。在
我错过什么了吗?在
看起来你得到的几乎是神经元的初始状态(几乎是
self.idealValue
)。也许你不应该在提供实际数据之前初始化这个神经元?在编辑:好的,我在代码中看得更深一点,并简化了一点(下面将发布简化版本)。基本上你的代码有两个小错误(看起来像是你刚刚忽略的),但是这会导致一个网络绝对无法工作。在
显然,这两个问题中的任何一个都会导致网络的不和谐。在
一旦更正,它就可以工作了(好吧,在我的简化版代码中就可以了)。在
这些错误不容易发现,因为最初的代码太复杂了。在引入新类或新方法之前,您应该三思而后行。没有创建足够的方法或类会使代码难以阅读和维护,但是创建太多的方法或类可能会使代码更难阅读和维护。你必须找到正确的平衡。我个人找到这种平衡的方法是遵循code smells和重构技术,无论它们引导我到哪里。有时添加方法或创建类,有时删除它们。这当然不是完美的,但这是我的工作。在
下面是一些重构应用后我的代码版本。我花了大约一个小时修改了你的代码,但总是保持功能上的等价性。我认为这是一个很好的重构练习,因为最初的代码读起来非常糟糕。重构之后,只花了5分钟就发现了问题。在
顺便说一下,还有第三个问题我没有纠正(但很容易纠正)。如果x太大或太小(>;320或<;-320)
math.exp()
将引发异常。如果您申请训练迭代,比如几千次,就会发生这种情况。我看到的最简单的纠正方法是检查x的值,如果它太大或太小,根据情况将神经元的值设置为0或1,这是极限值。在相关问题 更多 >
编程相关推荐