def test_lvq_initialization_exceptions(self): with self.assertRaises(ValueError): # n_sublcasses < n_classes algorithms.LVQ(n_inputs=2, n_subclasses=2, n_classes=3) with self.assertRaises(ValueError): # sum(prototypes_per_class) != n_subclasses algorithms.LVQ(n_inputs=2, n_subclasses=10, n_classes=3, prototypes_per_class=[5, 3, 3]) with self.assertRaises(ValueError): # len(prototypes_per_class) != n_classes algorithms.LVQ(n_inputs=2, n_subclasses=10, n_classes=3, prototypes_per_class=[5, 5])
def test_lvq_with_odd_number_of_subclasses(self): lvqnet = algorithms.LVQ( n_inputs=2, n_subclasses=3, n_classes=2, ) self.assertIn(lvqnet.prototypes_per_class, ([2, 1], [1, 2]))
def test_lvq_weight_initialization_state(self): lvqnet = algorithms.LVQ(n_inputs=2, n_classes=2) self.assertFalse(lvqnet.initialized) lvqnet.train(np.random.random((10, 2)), np.random.random(10).round(), epochs=1) self.assertTrue(lvqnet.initialized) lvqnet = algorithms.LVQ(n_inputs=2, n_classes=3, weight=np.random.random((2, 3))) self.assertTrue(lvqnet.initialized) lvqnet = algorithms.LVQ(n_inputs=2, n_classes=3, weight=init.Normal()) self.assertTrue(lvqnet.initialized) self.assertEqual(lvqnet.weight.shape, (2, 3))
def test_lvq_with_custom_set_of_prototypes(self): lvqnet = algorithms.LVQ( n_inputs=2, n_subclasses=4, n_classes=2, prototypes_per_class=[3, 1], ) lvqnet.train(self.data, self.target, epochs=3) self.assertGreater(lvqnet.errors.last(), 0) lvqnet.train(self.data, self.target, epochs=30) self.assertEqual(lvqnet.errors.last(), 0)
def test_simple_lvq(self): lvqnet = algorithms.LVQ( n_inputs=2, n_subclasses=4, n_classes=2, shuffle_data=True, ) lvqnet.train(self.data, self.target, epochs=100) predicted_target = lvqnet.predict(self.data) self.assertEqual(lvqnet.errors.last(), 0) np.testing.assert_array_equal(predicted_target, self.target[:, 0])
def test_lvq_with_disabled_step_reduction(self): lvqnet = algorithms.LVQ( n_inputs=2, n_subclasses=4, n_classes=2, n_updates_to_stepdrop=None, ) n_expected_updates = 0 for i in range(10): n_expected_updates += len(self.data) lvqnet.train(self.data, self.target, epochs=1) self.assertAlmostEqual(lvqnet.training_step, lvqnet.step) self.assertEqual(n_expected_updates, lvqnet.n_updates)
def test_lvq_step_reduction(self): lvqnet = algorithms.LVQ( n_inputs=2, n_subclasses=4, n_classes=2, minstep=0.1, step=1.1, n_updates_to_stepdrop=200, ) n_expected_updates = 0 for i in range(10): n_expected_updates += len(self.data) lvqnet.train(self.data, self.target, epochs=1) expected_step = 1.1 - (i + 1) * 0.1 self.assertAlmostEqual(lvqnet.training_step, expected_step) self.assertEqual(n_expected_updates, lvqnet.n_updates) self.assertEqual(lvqnet.training_step, lvqnet.minstep)
def test_compare_lvq_and_lvq21(self): dataset = datasets.load_iris() data, target = dataset.data, dataset.target # Prepare the same weights for the fair comparison lvq = algorithms.LVQ(n_inputs=4, n_subclasses=3, n_classes=3) lvq.train(data, target, epochs=1) prepared_lvq_weights = lvq.weight compare_networks( algorithms.LVQ, partial(algorithms.LVQ21, epsilon=0.1), data=[data, target], epochs=10, show_comparison_plot=False, n_inputs=4, n_subclasses=3, n_classes=3, weight=prepared_lvq_weights, )
def test_lvq_training_exceptions(self): lvqnet = algorithms.LVQ(n_inputs=2, n_subclasses=4, n_classes=2) with self.assertRaises(NotTrained): lvqnet.predict(np.array([1, 2])) with self.assertRaises(ValueError): input_train = np.array([ [1, 2], [3, 4], [4, 5], ]) target_train = np.array([0, 1, 0]) # len(input_train) <= n_subclasses lvqnet.train(input_train, target_train) with self.assertRaises(ValueError): input_train = np.array([ [1, 2], [3, 4], [5, 6], [7, 8], [9, 10], ]) target_train = np.array([0, 0, 0, 0, 1]) # there are should be 3 or more samples for # class 1, got only 1 lvqnet.train(input_train, target_train) with self.assertRaises(ValueError): input_train = np.array([ [1, 2], [3, 4], [4, 5], [5, 6], [67, 8], ]) target_train = np.array([0, 1, 0, 1, 2]) # 3 unique classes instead of 2 expected lvqnet.train(input_train, target_train)
def test_compare_lvq_and_lvq3(self): dataset = datasets.load_iris() data, target = dataset.data, dataset.target # Prepare the same weights for the fair comparison lvq = algorithms.LVQ(n_inputs=4, n_subclasses=6, n_classes=3) lvq.train(data, target, epochs=1) prepared_lvq_weights = lvq.weight compare_networks( algorithms.LVQ, partial(algorithms.LVQ3, epsilon=0.4), data=[data, target], epochs=100, show_comparison_plot=False, n_inputs=4, n_subclasses=6, n_classes=3, prototypes_per_class=[4, 1, 1], step=0.001, weight=prepared_lvq_weights, )
""" Created on Thu Nov 7 23:40:37 2019 @author: abhishek """ import numpy as np import pandas as pd from neupy import algorithms import matplotlib.pyplot as plt from sklearn import preprocessing import pickle from sklearn import datasets import numpy as np classifier = algorithms.LVQ(n_inputs=4, n_classes=3) iris = datasets.load_iris() x = iris.data y = iris.target.reshape(-1, 1) print(x[:5]) print(y[:5]) print(x.shape) # print(y.head()) print(y.shape) colors = (0, 0, 0) data = pd.DataFrame(iris.data) plt.scatter(data[0], y, c="red", alpha=0.5)
data1.columns = [ 'sample_code_number', 'clump_thickness', 'uniformity_of_cell_size', 'uniformity_of_cell_shape', 'marginal_adhesion', 'single_epithelial_cell_size', 'bare_nuclei', 'bland_chromatin', 'normal_nucleoli', 'mitoses', 'class' ] feature_columns1 = [ 'clump_thickness', 'uniformity_of_cell_size', 'uniformity_of_cell_shape', 'marginal_adhesion', 'single_epithelial_cell_size', 'bare_nuclei', 'bland_chromatin', 'normal_nucleoli', 'mitoses' ] missingRemovedData1 = data1[data1['bare_nuclei'] != '?'] # remove rows with missing data X1 = missingRemovedData1[feature_columns1] y1 = missingRemovedData1['class'] # split X and y into training and teting sets X1_train, X1_test, y1_train, y1_test = train_test_split(X1, y1, test_size=0.35) lvqnet = algorithms.LVQ(n_inputs=9, n_classes=2) lvqnet.train(X1_train, y1_train, epochs=100) y1_pred = lvqnet.predict(X1_test) from sklearn import metrics print("Accuracy: %.2f%%", metrics.accuracy_score(y1_test, y1_pred) * 100.0) # In[ ]: