class Backpropagation(object):
def __init__(self,input_layer_list,hidden_layer_list,output_layer_list,learning_rate=0.2,max_error=0.01,max_epoch=-1):
'''
Constructor
'''
self.net=NeuronBuilder(input_layer_list,hidden_layer_list,output_layer_list)
self.net.setLayerFunction('out', 'purelin')
for i in range(len(self.net.hidden_layers)):
self.net.setLayerFunction('hid'+str(i),'logsig')
self.net.connectTwoLayers('in', 'hid0')
if len(self.net.hidden_layers)!=1:
for i in range(len(self.net.hidden_layers)-1):
self.net.connectTwoLayers('hid'+str(i), 'hid'+str(i+1))
self.net.connectTwoLayers('hid'+str(len(self.net.hidden_layers)-1), 'out')
self.learning_rate=learning_rate
self.max_error=max_error
self.max_epoch=max_epoch
def activate(self,input_list):
self.net.setInputToInputLayer(input_list)
output=self.net.getOutputFromLayer('out')
return output
def setDataSet(self,data_set):
self.data_set=data_set
[self.net.input_data,self.net.output_data]=data_set.returnDataSet()
def train(self):
if self.data_set==None:
print("Please set data sets")
else:
self.trainer=DeltaTrainer(self.net)
self.trainer.setLearningRate(self.learning_rate)
self.trainer.setMaxError(self.max_error)
self.trainer.setMaxEpoch(self.max_epoch)
self.trainer.DeltaTrain()
#[weight,bias]=self.trainer.returnTrainedLayerToLayerWeightAndBias()
[self.net.layer_to_layer_weight,self.net.bias_to_layer]=self.trainer.returnTrainedLayerToLayerWeightAndBias()
# print self.net.neuron_to_neuron_weight
self.net.updateNeuronToNeuronWeightByLayerToLayerWeight()
self.net.updateBiasToNeuronByBiasToLayer()
# print self.net.neuron_to_neuron_weight
def plotFigure(self):
self.trainer.plotFigure()
def setLearningRate(self,learning_rate):
self.learning_rate=learning_rate
def setMaxError(self,max_error):
self.max_error=max_error
def setMaxEpoch(self,max_epoch):
self.max_epoch=max_epoch
def showNetworkSimulation(self):
self.net.showNetworkSimulation()
class InstarNetwork(object):
def __init__(self, input_num, output_num, unconditioned_input_num, function_name="hardlim", learning_rate=0.2):
self.function_name = function_name
self.input_num = input_num
self.output_num = output_num
self.learning_rate = learning_rate
self.net = NeuronBuilder([self.input_num], [0], [self.output_num])
self.net.connectTwoLayers("in", "out")
self.net.setLayerFunction("out", self.function_name)
self.net.setUnconditionedNeuronNum(unconditioned_input_num)
def activate(self, input_list):
self.net.setInputToInputLayer(input_list)
output = self.net.getOutputFromLayer("out")
return output
def train(self, input_list):
self.trainer = InstarTrainer(self.net, self.learning_rate)
self.trainer.InstarTrainForOnce(input_list)
def setLearningRate(self, learning_rate):
self.learning_rate = learning_rate
def returnNeuronBuilder(self):
return self.net
def setNeuronBuilder(self, net):
self.net = net
def showNetworkSimulation(self):
self.net.showNetworkSimulation()
class OutstarNetwork(object):
def __init__(self,input_num,unconditioned_input_num,function_name='satlins',learning_rate=0.2):
self.function_name=function_name
self.input_num=input_num
self.output_num=unconditioned_input_num
self.learning_rate=learning_rate
self.net=NeuronBuilder([self.input_num],[0],[self.output_num],has_bias=False)
for i in range(unconditioned_input_num):
self.net.connectTwoNeurons('in'+str(i), 'out'+str(i))
for i in range(input_num-unconditioned_input_num):
for neuron in self.net.neuron_in_layer['out']:
self.net.connectTwoNeurons('in'+str(i+unconditioned_input_num),neuron)
# print self.net.neuron_to_neuron_weight
# print self.net.layer_to_layer_weight
self.net.setLayerFunction('out', self.function_name)
self.net.setUnconditionedNeuronNum(unconditioned_input_num)
def activate(self,input_list):
self.net.setInputToInputLayer(input_list)
output=self.net.getOutputFromLayer('out')
return output
def train(self,input_list):
self.trainer=OutstarTrainer(self.net,self.learning_rate)
self.trainer.OutstarTrainForOnce(input_list)
def setLearningRate(self,learning_rate):
self.learning_rate=learning_rate
def returnNeuronBuilder(self):
return self.net
def setNeuronBuilder(self,net):
self.net=net
def showNetworkSimulation(self):
self.net.showNetworkSimulation()
class SimpleAssociativeNetwork(object):
def __init__(self,input_num,output_num,unconditioned_input_num,function_name='hardlim',learning_rate=0.2,decay_rate=0.1):
self.function_name=function_name
self.input_num=input_num
self.output_num=output_num
self.learning_rate=learning_rate
self.decay_rate=decay_rate
self.net=NeuronBuilder([self.input_num],[0],[self.output_num])
self.net.connectTwoLayers('in', 'out')
self.net.setLayerFunction('out', self.function_name)
self.net.setUnconditionedNeuronNum(unconditioned_input_num)
def activate(self,input_list):
self.net.setInputToInputLayer(input_list)
output=self.net.getOutputFromLayer('out')
return output
def train(self,input_list):
self.trainer=HebbUnsupervisedTrainer(self.net,self.learning_rate,self.decay_rate)
self.trainer.HebbTrainForOnce(input_list)
def setLearningRate(self,learning_rate):
self.learning_rate=learning_rate
def setDecayRate(self,decay_rate):
self.decay_rate=decay_rate
def returnNeuronBuilder(self):
return self.net
def setNeuronBuilder(self,net):
self.net=net
def showNetworkSimulation(self):
self.net.showNetworkSimulation()
class TwoLayersNeuralNetwork(object):
def __init__(
self,
input_num,
output_num,
function_name="hardlim",
weight=None,
bias=None,
data_set=None,
learning_rate=0.2,
max_error=0,
max_epoch=-1,
):
self.function_name = function_name
self.input_num = input_num
self.output_num = output_num
self.learning_rate = learning_rate
self.max_error = max_error
self.max_epoch = max_epoch
self.net = NeuronBuilder([self.input_num], [0], [self.output_num])
self.net.connectTwoLayers("in", "out")
self.net.setLayerFunction("out", self.function_name)
if data_set != None:
self.net.setDataSet(data_set)
self.net.connectTwoLayers("in", "out")
if weight != None:
self.net.setLayerToLayerWeight("in", "out", weight)
if bias != None:
self.net.setBiasToLayer("out", bias)
def activate(self, input_list):
self.net.setInputToInputLayer(input_list)
output = self.net.getOutputFromLayer("out")
return output
def setDataSet(self, data_set):
self.net.input_data = None
self.net.output_data = None
self.net.setDataSet(data_set)
def train(self):
if self.net.data_set == None:
print("Please set data sets")
else:
self.trainer = LMSTrainer(self.net, self.learning_rate, self.max_error, self.max_epoch)
# self.trainer.setDefaultLearningRate()
self.trainer.LMSTrain()
[
self.net.layer_to_layer_weight,
self.net.bias_to_layer,
] = self.trainer.returnTrainedLayerToLayerWeightAndBias()
self.net.updateNeuronToNeuronWeightByLayerToLayerWeight()
self.net.updateBiasToNeuronByBiasToLayer()
def plotFigure(self):
self.trainer.plotFigure()
def setLearningRate(self, learning_rate):
self.learning_rate = learning_rate
def setMaxError(self, max_error):
self.max_error = max_error
def setMaxEpoch(self, max_epoch):
self.max_epoch = max_epoch
def returnNeuronBuilder(self):
return self.net
def setNeuronBuilder(self, net):
self.net = net
def showNetworkSimulation(self):
self.net.showNetworkSimulation()
'''
from neuron_build.neuron_build import NeuronBuilder
net=NeuronBuilder([2],[3],[2],has_bias=True)
net.connectTwoLayers('in', 'hid0')
net.connectTwoLayers('hid0','out')
from data.DataSet import DataSet
data=DataSet(2,2)
data.addItem([1,1], [-1,-1])
data.addItem([1,-1],[-1,1])
data.addItem([-1,1],[1,-1])
data.addItem([-1,-1],[1,1])
net.setDataSet(data)
net.setLayerFunction('hid0', 'logsig')
net.setLayerFunction('out','purelin')
net.setInputToInputLayer([1,1])
print net.getOutputFromLayer('out')
print net.neuron_function
from trainer.DeltaTrainer import DeltaTrainer
trainer=DeltaTrainer(net)
trainer.setMaxError(0.001)
trainer.DeltaTrain()
#trainer.plotFigure()
net.setInputToInputLayer([1,1])
print net.getOutputFromLayer('out')
print net.activate([1,-1])
print net.activate([1,1,1])
print net.getOutputFromLayer('out')
'''
from pyneuron.neuron_type.backpropagation_neural_network import Backpropagation
from pyneuron.data.DataSet import DataSet
