Exemplo n.º 1
0
 def loadDataSet(self,save_path):
     '''
     input_data
     output_data
     
     
     '''
     import os
     if os.path.exists(save_path):
         file=open(save_path,'r')
         output=[]
         num=0
         for line in file:
             inputString=line[line.find("["):line.find("\n")]
             output.append(inputString)
             num+=1
             #print line
         #print output
         input_data=[]
         output_data=[]
         for i in range(num/2):
             input_data.append(convertStringListToList(output[2*i]))
             output_data.append(convertStringListToList(output[2*i+1]))
         input_num=len(input_data[0])
         output_num=len(output_data[0])
         data=DataSet(input_num,output_num)
         for i in range(len(input_data)):
             data.addItem(input_data[i], output_data[i])
         return data
     else:
         print(save_path+"does not exist")
Exemplo n.º 2
0
 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
Exemplo n.º 3
0
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
trainer=DeltaTrainer(net)
trainer.setMaxError(0.001)
trainer.DeltaTrain()
#trainer.plotFigure()
net.setInputToInputLayer([1,1])