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 __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 __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 __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 __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
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()
def loadNeuronBuilder(self,save_path):
'''
input_layer=self.net.input_layer
hidden_layers=self.net.hidden_layers
output_layer=self.net.output_layer
has_bias=self.net.has_bias
layer_to_layer_weight=self.net.layer_to_layer_weight
bias_to_layer=self.net.bias_to_neuron
neuron_function=self.net.neuron_function
neuron_dict=self.net.neuron_dict
name_dict=self.net.name_dict
input_data=self.net.input_data
output_data=self.net.output_data
'''
import os
if save_path.find('.')==-1:
save_path+='.nnet'
if os.path.exists(save_path):
file=open(save_path,'r')
output=[]
for lines in file:
output.append(lines)
#print output
dic={}
for line in output:
# print line
dic[line[0:line.find(':')]]=line[line.find(':')+1:line.find('\\')]
#print dic
file.close()
input_layer=convertStringListToList(dic['input_layer'])
for i in range(len(input_layer)):
input_layer[i]=int(input_layer[i])
hidden_layers=convertStringListToList(dic['hidden_layers'])
for i in range(len(hidden_layers)):
hidden_layers[i]=int(hidden_layers[i])
output_layer=convertStringListToList(dic['output_layer'])
for i in range(len(output_layer)):
output_layer[i]=int(output_layer[i])
has_bias=dic['has_bias']
if has_bias=='True':
has_bias=True
elif has_bias=='False':
has_bias=False
else:
print("Mistake occurred when load has_bias:"+has_bias)
layer_to_layer_weight=convertStringDictToDict(dic['layer_to_layer_weight'])
print dic['layer_to_layer_weight']
print layer_to_layer_weight
for key in layer_to_layer_weight.keys():
layer_to_layer_weight[key]=convertStringListToList(layer_to_layer_weight[key])
bias_to_layer=convertStringDictToDict(dic['bias_to_layer'])
print dic['bias_to_layer']
print bias_to_layer
for key in bias_to_layer:
bias_to_layer[key]=convertStringListToList(bias_to_layer[key])
neuron_function=convertStringDictToDict(dic['neuron_function'])
neuron_dict=convertStringDictToDict(dic['neuron_dict'])
name_dict=convertStringDictToDict(dic['name_dict'])
input_data=convertStringListToList(dic['input_data'])
output_data=convertStringListToList(dic['output_data'])
net=NeuronBuilder(input_layer,hidden_layers,output_layer,has_bias)
net.layer_to_layer_weight=layer_to_layer_weight
net.updateNeuronToNeuronWeightByLayerToLayerWeight()
net.bias_to_layer=bias_to_layer
net.updateBiasToNeuronByBiasToLayer()
net.neuron_function=neuron_function
net.neuron_dict=neuron_dict
net.name_dict=name_dict
data=DataSet(len(input_data[0]),len(output_data[0]))
for i in range(len(input_data)):
data.addItem(input_data[i], output_data[i])
net.setDataSet(data)
#print neural_network_type
#print input_num
#print output_num
#print weight
#print bias
#print function_name
return net
else:
print(save_path+"does not exist")
return None
print net.neuron_to_neuron_weight
print net.bias_to_neuron
net.setLayerFunction('hid0', 'logsig')
net.setLayerFunction('hid1', 'logsig')
net.setLayerFunction('out', 'purelin')
net.setNeuronFunction('hid0_2', 'hardlim')
print net.neuron_function
net.setInputToInputLayer([1,0.6])
print net.getOutputFromLayer('hid1')
print net.getOutputFromLayer('out')
print net.getOutputFromOneNeuron('out0')
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
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 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()
