class NeuronDecider(BaseDecider): """ The class is responsible for learning to recognize certain group of objects. Attributes ----------- hiden_neurons : int Number of hiden neurons. OUTPUT_NEURONS : int Number of output neurons. input_neurons : int Number of input neurons. X_train : numpy array of array of floats Each item of the array contains specific "coordinates" of the train object in array. X_test : numpy array of array of floats Each item of the array contains specific "coordinates" of the test object in array. y_train : numpy array of ints Each item of the array contains a number of the group which the train object belongs. Position in the array corresponds to item in X_train. y_test : numpy array of ints Each item of the array contains a number of the group which the test object belongs. Position in the array corresponds to item in X_test. maxErr : float Maximal error which would satisfy trainer maxEpochs : int Maximum number of epochs for training """ OUTPUT_NEURONS = 1 def __init__(self, treshold=0.5, hidden_neurons=2, maxErr=None, maxEpochs=20000): """ Parameters ----------- hidden_neurons: int Number of hidden neurons maxErr : NoneType, float Maximal error which would satisfy the trainer. In case of None trainUntilConvergence methods is used maxEpochs : int Maximum number of epochs for training Note ----- Attributes with None values will be updated by setTrainer and train methods """ self.hiden_neurons = hidden_neurons self.input_neurons = None self.X = None self.y = None self.treshold = treshold self.maxEpochs = maxEpochs self.maxErr = maxErr self.net = None def learn(self, searched, others): """ This method loads lists of specific values of searched objects and others. Then the sample will be divided into train and test samples according to user. Parameters ----------- searched : iterable List of searched objects values (their "coordinates") others : iterable List of other objects values (their "coordinates") Returns ------- NoneType None """ if not len(searched) or not len(others): raise QueryInputError( "Decider can't be learned on an empty sample") # Resolve number of input neurons self.input_neurons = len(searched[0]) # Input is accepted as a numpy array or as a list if type(searched) != list: try: X = searched.tolist() + others.tolist() except AttributeError as err: raise AttributeError("Wrong coordinates input: %s" % err) elif type(searched) == list: X = np.array(searched + others) # Note searched objects as 1 and others as 0 self.y = np.array([1 for i in range(len(searched))] + [0 for i in range(len(others))]) self.X = X self.train() def train(self): """Train neuron grid by training sample""" self.net = FeedForwardNetwork() inLayer = LinearLayer(self.input_neurons) hiddenLayer = SigmoidLayer(self.hiden_neurons) outLayer = LinearLayer(self.OUTPUT_NEURONS) self.net.addInputModule(inLayer) self.net.addModule(hiddenLayer) self.net.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) self.net.addConnection(in_to_hidden) self.net.addConnection(hidden_to_out) self.net.sortModules() ds = ClassificationDataSet(self.input_neurons, self.OUTPUT_NEURONS, nb_classes=3) for i, coord in enumerate(self.X): ds.addSample(coord, (self.y[i], )) trainer = BackpropTrainer(self.net, dataset=ds, momentum=0.1, verbose=True, weightdecay=0.01) if self.maxErr: for i in range(self.maxEpochs): if trainer.train() < self.maxErr: print "Desired error reached" break else: trainer.trainUntilConvergence(maxEpochs=self.maxEpochs) print "Successfully finished" def evaluate(self, coords): """ Find if inspected parameter-space coordinates belongs to searched object Parameter --------- coords : list of lists Parameter-space coordinates of inspected objects Returns ------ numpy.array Probabilities of membership to searched group objects """ pred = [] for coord in coords: p = self.net.activate(coord)[0] if p < 0: p = 0 elif p > 1: p = 1 pred.append(p) return np.array(pred)
ds = SupervisedDataSet(len(inputs_training), len(target_training)) ds.setField('input', inputs_training) ds.setField('target', target_training) trainer = BackpropTrainer(n, ds) trainer.trainUntilConvergence(verbose=True, validationProportion=0.15, maxEpochs=100, continueEpochs=10) for i in range(700): mse = trainer.train() rmse = np.sqrt(mse) print "training RSME, epoch {}: {}".format(i+1, rmse) #============================================================================== # trainer = BackpropTrainer(n, ds, learningrate=0.01, momentum=0.1) # # for epoch in range(1, 100000000): # if epoch % 10000000 == 0: # error = trainer.train() # print 'Epoch: ', epoch # print 'Error: ', error #============================================================================== predict = np.array([n.activate(x) for x in inputs_validation]) plt.plot(predict, color='blue', label='predict') plt.plot(target_validation, color='red', label='target') plt.legend(loc='best') print 'True'
ds.setField('target', target_training) trainer = BackpropTrainer(n, ds) trainer.trainUntilConvergence(verbose=True, validationProportion=0.15, maxEpochs=100, continueEpochs=10) for i in range(700): mse = trainer.train() rmse = np.sqrt(mse) print "training RSME, epoch {}: {}".format(i + 1, rmse) #============================================================================== # trainer = BackpropTrainer(n, ds, learningrate=0.01, momentum=0.1) # # for epoch in range(1, 100000000): # if epoch % 10000000 == 0: # error = trainer.train() # print 'Epoch: ', epoch # print 'Error: ', error #============================================================================== predict = np.array([n.activate(x) for x in inputs_validation]) plt.plot(predict, color='blue', label='predict') plt.plot(target_validation, color='red', label='target') plt.legend(loc='best') print 'True'