def test_handle_errors(self): data, target = datasets.make_classification(300, n_features=4, n_classes=2) x_train, x_test, y_train, y_test = model_selection.train_test_split( data, target, test_size=0.3) with self.assertRaises(ValueError): # First network has two output layers and the second # just one. algorithms.DynamicallyAveragedNetwork([ algorithms.RPROP((4, 10, 2), step=0.1), algorithms.GradientDescent((4, 10, 1), step=0.1) ]) with self.assertRaises(ValueError): # Use ensemble with less than one network algorithms.DynamicallyAveragedNetwork( [algorithms.GradientDescent((4, 10, 1), step=0.1)]) with self.assertRaises(ValueError): # Output greater than 1 dan = algorithms.DynamicallyAveragedNetwork([ algorithms.GradientDescent([ Input(4), Sigmoid(10), Relu(1, weight=init.Uniform(), bias=init.Uniform()), ], step=0.01), algorithms.RPROP((4, 10, 1), step=0.01), ]) dan.train(x_train, y_train, epochs=10) dan.predict(x_test)
def test_handle_errors(self): data, target = datasets.make_classification(300, n_features=4, n_classes=2) x_train, x_test, y_train, y_test = cross_validation.train_test_split( data, target, train_size=0.7 ) with self.assertRaises(ValueError): # First network has two output layers and the second # just one. ensemble.DynamicallyAveragedNetwork([ algorithms.RPROP((4, 10, 2), step=0.1), algorithms.Backpropagation((4, 10, 1), step=0.1) ]) with self.assertRaises(ValueError): # Use ensemble with less than one network ensemble.DynamicallyAveragedNetwork([ algorithms.Backpropagation((4, 10, 1), step=0.1) ]) with self.assertRaises(ValueError): # Output between -1 and 1 dan = ensemble.DynamicallyAveragedNetwork([ algorithms.Backpropagation( SigmoidLayer(4) > TanhLayer(10) > OutputLayer(1), step=0.01 ), algorithms.RPROP((4, 10, 1), step=0.1) ]) dan.train(x_train, y_train, epochs=10) dan.predict(x_test)
def test_irpropplus(self): options = dict(minstep=0.001, maxstep=1, increase_factor=1.1, decrease_factor=0.1, step=1, verbose=False) uniform = init.Uniform() params1 = dict( weight=uniform.sample((3, 10), return_array=True), bias=uniform.sample((10, ), return_array=True), ) params2 = dict( weight=uniform.sample((10, 2), return_array=True), bias=uniform.sample((2, ), return_array=True), ) network = layers.join( Input(3), Sigmoid(10, **params1), Sigmoid(2, **params2), ) nw = algorithms.IRPROPPlus(copy.deepcopy(network), **options) nw.train(simple_x_train, simple_y_train, epochs=100) irprop_plus_error = nw.errors.train[-1] self.assertGreater(1e-4, nw.errors.train[-1]) nw = algorithms.RPROP(copy.deepcopy(network), **options) nw.train(simple_x_train, simple_y_train, epochs=100) rprop_error = nw.errors.train[-1] self.assertGreater(rprop_error, irprop_plus_error)
def test_rprop(self): nw = algorithms.RPROP(self.network, minstep=0.001, maxstep=1, increase_factor=1.1, decrease_factor=0.1, step=1, verbose=False) nw.train(simple_x_train, simple_y_train, epochs=100) self.assertGreater(1e-4, nw.errors.train[-1])
def test_rprop(self): nw = algorithms.RPROP(self.connection, minstep=0.001, maxstep=1, increase_factor=1.1, decrease_factor=0.1, step=1, verbose=False) nw.train(simple_input_train, simple_target_train, epochs=100) self.assertGreater(1e-4, nw.errors.last())
def test_rprop(self): nw = algorithms.RPROP(self.connection, minimum_step=0.001, maximum_step=1, increase_factor=1.1, decrease_factor=0.1, step=1, use_raw_predict_at_error=True, verbose=False) nw.train(simple_input_train, simple_target_train, epochs=100) self.assertGreater(1e-4, nw.last_error_in())
def test_handle_errors(self): data, target = datasets.make_classification(300, n_features=4, n_classes=2) x_train, x_test, y_train, y_test = cross_validation.train_test_split( data, target, train_size=0.7 ) with self.assertRaises(ValueError): # First network has two output layers and the second # just one. algorithms.DynamicallyAveragedNetwork([ algorithms.RPROP((4, 10, 2), step=0.1), algorithms.GradientDescent((4, 10, 1), step=0.1) ]) with self.assertRaises(ValueError): # Use ensemble with less than one network algorithms.DynamicallyAveragedNetwork([ algorithms.GradientDescent((4, 10, 1), step=0.1) ]) with self.assertRaises(ValueError): # Output greater than 1 dan = algorithms.DynamicallyAveragedNetwork([ algorithms.GradientDescent( [ Sigmoid(4), Relu(10, init_method='bounded', bounds=(0, 1)), Output(1), ], step=0.01 ), algorithms.RPROP((4, 10, 1), step=0.01), ]) dan.train(x_train, y_train, epochs=10) dan.predict(x_test)
def test_dan(self): data, target = datasets.make_classification(300, n_features=4, n_classes=2) x_train, x_test, y_train, y_test = cross_validation.train_test_split( data, target, train_size=0.7 ) dan = algorithms.DynamicallyAveragedNetwork([ algorithms.RPROP((4, 10, 1), step=0.1, maxstep=1), algorithms.GradientDescent((4, 5, 1), step=0.1), algorithms.ConjugateGradient((4, 5, 1), step=0.01), ]) dan.train(x_train, y_train, epochs=500) result = dan.predict(x_test) ensemble_result = metrics.accuracy_score(y_test, result) self.assertAlmostEqual(0.9222, ensemble_result, places=4)
def test_irpropplus(self): options = dict(minimum_step=0.001, maximum_step=1, increase_factor=1.1, decrease_factor=0.1, step=1, verbose=False) nw = algorithms.IRPROPPlus(copy.deepcopy(self.connection), **options) nw.train(simple_input_train, simple_target_train, epochs=100) irprop_plus_error = nw.last_error_in() self.assertGreater(1e-4, nw.last_error_in()) nw = algorithms.RPROP(copy.deepcopy(self.connection), **options) nw.train(simple_input_train, simple_target_train, epochs=100) rprop_error = nw.last_error_in() self.assertGreater(rprop_error, irprop_plus_error)
def select_algorithm(self, algorithm, options=None): try: self.network = algorithms.LevenbergMarquardt(self.layers) opt = options print(opt[1]) print("Wybrano optymalizator: " + str(algorithm)) except RecursionError: print("Problem rekursji") return None if algorithm == 'GradientDescent': self.network = algorithms.GradientDescent(self.layers) if algorithm == 'LevenbergMarquardt': self.network = algorithms.LevenbergMarquardt(connection=self.layers, mu=opt[0], mu_update_factor=opt[1]) if algorithm == 'Adam': self.network = algorithms.Adam(self.layers) if algorithm == 'QuasiNewton': self.network = algorithms.QuasiNewton(self.layers) if algorithm == 'Quickprop': self.network = algorithms.Quickprop(self.layers) if algorithm == 'MinibatchGradientDescent': self.network = algorithms.MinibatchGradientDescent(self.layers) if algorithm == 'ConjugateGradient': self.network = algorithms.ConjugateGradient(self.layers) if algorithm == 'Hessian': self.network = algorithms.Hessian(self.layers) if algorithm == 'HessianDiagonal': self.network = algorithms.HessianDiagonal(self.layers) if algorithm == 'Momentum': self.network = algorithms.Momentum(self.layers) if algorithm == 'RPROP': self.network = algorithms.RPROP(self.layers) if algorithm == 'IRPROPPlus': self.network = algorithms.IRPROPPlus(self.layers) if algorithm == 'Adadelta': self.network = algorithms.Adadelta(self.layers) if algorithm == 'Adagrad': self.network = algorithms.Adagrad(self.layers) if algorithm == 'RMSProp': self.network = algorithms.RMSProp(self.layers) if algorithm == 'Adamax': self.network = algorithms.Adamax(self.layers)
def test_irpropplus(self): options = dict(minstep=0.001, maxstep=1, increase_factor=1.1, decrease_factor=0.1, step=1, verbose=False) connection = [ Input(3), Sigmoid(10, init_method='bounded', bounds=(0, 1)), Sigmoid(2, init_method='bounded', bounds=(0, 1)), ] nw = algorithms.IRPROPPlus(copy.deepcopy(connection), **options) nw.train(simple_input_train, simple_target_train, epochs=100) irprop_plus_error = nw.errors.last() self.assertGreater(1e-4, nw.errors.last()) nw = algorithms.RPROP(copy.deepcopy(connection), **options) nw.train(simple_input_train, simple_target_train, epochs=100) rprop_error = nw.errors.last() self.assertGreater(rprop_error, irprop_plus_error)
def test_ensemble(self): data, target = datasets.make_classification(300, n_features=4, n_classes=2) x_train, x_test, y_train, y_test = train_test_split(data, target, train_size=0.7) dan = algorithms.DynamicallyAveragedNetwork([ algorithms.RPROP((4, 5, 1), step=0.1, maxstep=1), algorithms.GradientDescent((4, 5, 1), step=0.1), algorithms.ConjugateGradient((4, 5, 1), step=0.01), ]) pipeline = Pipeline([ ('min_max_scaler', preprocessing.StandardScaler()), ('dan', dan), ]) pipeline.fit(x_train, y_train, dan__epochs=100) result = pipeline.predict(x_test) ensemble_result = metrics.accuracy_score(y_test, result) self.assertAlmostEqual(0.9222, ensemble_result, places=4)
logger.info("Loading word embedding NN") word2vec = WordEmbeddingNN.load(WORD_EMBEDDING_NN) prepare_data_pipeline = Pipeline([ ('tokenize_texts', TokenizeText(ignore_stopwords=False)), ('ignore_unknown_words', IgnoreUnknownWords(dictionary=word2vec.vocab)), ('word_embedding', word2vec), ]) classifier = algorithms.RPROP( [ layers.Relu(100), layers.Relu(200), layers.Sigmoid(50), layers.RoundedOutput(1), ], error='binary_crossentropy', verbose=True, shuffle_data=True, maxstep=1, minstep=1e-7, ) logger.info("Preparing train data") train_data = data[data.type == 'train'] texts = train_data.text.values x_train = prepare_data_pipeline.transform(texts) y_train = (train_data.sentiment.values == 'pos') logger.info("Preparing test data") test_data = data[data.type == 'test']
# los primero 3067 de los 4601 datos serviran para el entrenmiento x_train = X[0:3067] y_train = Y[0:3067] # el resto de los datos serviran para la validacion (1534) x_test = X[3067:] y_test = Y[3067:] #se crea la red neuronal con la arquitectura 57 -7 -1 rpropnet = algorithms.RPROP( [ layers.Input(57), layers.Sigmoid(7), layers.Sigmoid(1), ], error='mse', verbose=True, shuffle_data=True, maxstep=1, minstep=1e-7, ) #se realiza el entrenamiento de la red rpropnet.train(input_train=x_train,target_train=y_train,epochs=200) #se muestra un grafico de los errores cometidos en el entrenamiento plots.error_plot(rpropnet) y_train_predicted = rpropnet.predict(x_train).round() y_test_predicted = rpropnet.predict(x_test).round()