def test_sofm_step_reduction(self): X = 4 * np.ones((1, 2)) default_params = dict(n_inputs=2, n_outputs=1, step=0.1, weight=np.ones((2, 1))) sofm_1 = algorithms.SOFM(reduce_step_after=1, **default_params) sofm_1.train(X, epochs=4) dist_1 = np.linalg.norm(sofm_1.weight.T - X) sofm_2 = algorithms.SOFM(reduce_step_after=10, **default_params) sofm_2.train(X, epochs=4) dist_2 = np.linalg.norm(sofm_2.weight.T - X) # SOFM-2 suppose to be closer, becase learning rate decreases # slower with bigger reduction factor self.assertLess(dist_2, dist_1) sofm_3 = algorithms.SOFM(reduce_step_after=None, **default_params) sofm_3.train(X, epochs=4) dist_3 = np.linalg.norm(sofm_3.weight.T - X) # SOFM-3 doesn't have any step reduction, so it # converges even faster than SOFM-2 self.assertLess(dist_3, dist_2)
def runSOFM(self, outputRows, outputCols, learningRadius, weightInit, gridType): if weightInit == "default": sofm = algorithms.SOFM(n_inputs=self.n_inputs, features_grid=(outputRows, outputCols), verbose=False, step=0.5, learning_radius=learningRadius, grid_type=gridType) else: sofm = algorithms.SOFM(n_inputs=self.n_inputs, features_grid=(outputRows, outputCols), verbose=False, step=0.5, learning_radius=learningRadius, grid_type=gridType, weight=weightInit) # try: trainingStart = time() sofm.train(self.X, epochs=300) trainingTime = time() - trainingStart predictionResults, error, errorPercent = self.dataObject.verifyPrediction( sofm.predict(self.X)) if error < self.lowestError: self.lowestError = error with open(self.bestSOFMfile, 'wb') as f: pickle.dump(sofm, f) self.logRow(outputRows, outputCols, learningRadius, weightInit, gridType, error, errorPercent)
def test_sofm_learning_radius_reduction(self): input_data = 4 * np.ones((1, 2)) default_params = dict(n_inputs=2, n_outputs=3, weight=np.ones((2, 3)), learning_radius=1) sofm_1 = algorithms.SOFM(reduce_radius_after=1, **default_params) sofm_1.train(input_data, epochs=4) dist_1 = np.linalg.norm(sofm_1.weight.T - input_data) sofm_2 = algorithms.SOFM(reduce_radius_after=3, **default_params) sofm_2.train(input_data, epochs=4) dist_2 = np.linalg.norm(sofm_2.weight.T - input_data) # SOFM-2 suppose to be closer, becase learning radius # decreases slower with bigger reduction factor self.assertLess(dist_2, dist_1) sofm_3 = algorithms.SOFM(reduce_radius_after=None, **default_params) sofm_3.train(input_data, epochs=4) dist_3 = np.linalg.norm(sofm_3.weight.T - input_data) # SOFM-3 doesn't have any learning radius reduction, so it # converges even faster than SOFM-2 self.assertLess(dist_3, dist_2)
def test_sofm_hexagon_grid(self): data = make_circle(max_samples=100) sofm = algorithms.SOFM( n_inputs=2, n_outputs=9, learning_radius=1, reduce_radius_after=4, features_grid=(3, 3), verbose=False, grid_type='hexagon', ) sofm.train(data, epochs=10) grid = sofm.weight.reshape((2, 3, 3)) center = grid[:, 1, 1] top_left = grid[:, 0, 0] top_right = grid[:, 0, 2] distance_top_left = np.linalg.norm(center - top_left) distance_top_right = np.linalg.norm(center - top_right) self.assertLess(distance_top_right, distance_top_left) bottom_left = grid[:, 2, 0] bottom_right = grid[:, 2, 2] distance_bottom_left = np.linalg.norm(center - bottom_left) distance_bottom_right = np.linalg.norm(center - bottom_right) self.assertLess(distance_bottom_right, distance_bottom_left)
def test_sofm_weight_init_exceptions(self): msg = "Cannot apply PCA" with self.assertRaisesRegexp(WeightInitializationError, msg): algorithms.SOFM(n_inputs=4, n_outputs=7, weight='init_pca', grid_type='hexagon')
def test_sofm_euclide_norm_distance(self): weight = np.array([ [1.41700099, 0.52680476], [-0.60938464, 1.56545643], [-0.30243644, 0.13994967], [-0.07456091, 0.54797268], [-1.12894803, 0.32702141], [0.92084690, 0.02683249], ]).T sn = algorithms.SOFM(n_inputs=2, n_outputs=6, weight=weight, distance='euclid', learning_radius=1, features_grid=(3, 2), verbose=False) sn.train(input_data, epochs=10) answers = np.array([ [0., 0., 0., 1., 0., 0.], [0., 0., 0., 1., 0., 0.], [1., 0., 0., 0., 0., 0.], [1., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 1., 0.], [0., 0., 0., 0., 1., 0.], ]) np.testing.assert_array_almost_equal(sn.predict(input_data), answers)
def test_sofm_euclide_norm_distance(self): weight = np.array([ [1.41700099, 0.52680476], [-0.60938464, 1.56545643], [-0.30243644, 0.13994967], [-0.07456091, 0.54797268], [-1.12894803, 0.32702141], [0.92084690, 0.02683249], ]).T input_layer = EuclideDistanceLayer(2, weight=weight) output_layer = CompetitiveOutputLayer(6) sn = algorithms.SOFM(input_layer > output_layer, learning_radius=1, features_grid=(3, 2), verbose=False) sn.train(input_data, epochs=10) answers = np.array([ [0., 0., 0., 1., 0., 0.], [0., 0., 0., 1., 0., 0.], [1., 0., 0., 0., 0., 0.], [1., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 1., 0.], [0., 0., 0., 0., 1., 0.], ]) for data, answer in zip(input_data, answers): network_output = sn.predict(np.reshape(data, (2, 1)).T) correct_result = np.reshape(answer, (6, 1)).T self.assertTrue(np.all(network_output == correct_result))
def test_linear_weight_init_in_sofm(self): sofm = algorithms.SOFM( n_inputs=4, features_grid=(3, 3), weight='init_pca', ) input_data = np.random.random((100, 4)) self.assertTrue(callable(sofm.weight)) sofm.train(input_data, epochs=0) self.assertFalse(callable(sofm.weight)) self.assertEqual(sofm.weight.shape, (4, 9)) for row in (0, 3, 6): left = sofm.weight[:, row] center = sofm.weight[:, row + 1] right = sofm.weight[:, row + 2] self.assertLess(np.linalg.norm((left - center)**2), np.linalg.norm((left - right)**2)) for i in range(3): top = sofm.weight[:, i] center = sofm.weight[:, i + 3] bottom = sofm.weight[:, i + 6] self.assertLess(np.linalg.norm((top - center)**2), np.linalg.norm((top - bottom)**2))
def test_invalid_attrs(self): with self.assertRaises(ValueError): algorithms.SOFM(LinearLayer(2) > OutputLayer(3), learning_radius=-1, verbose=False) with self.assertRaises(ValueError): algorithms.SOFM(LinearLayer(2) > OutputLayer(2), learning_radius=1, verbose=False) with self.assertRaises(ValueError): algorithms.SOFM(LinearLayer(2) > CompetitiveOutputLayer(4), learning_radius=-1, features_grid=(2, 3), verbose=False)
def test_predict_different_inputs(self): input_layer = LinearLayer(1) output_layer = CompetitiveOutputLayer(2) sofmnet = algorithms.SOFM(input_layer > output_layer, verbose=False) target = np.array([ [1, 0], [1, 0], [0, 1], [1, 0], [1, 0], [1, 0], [1, 0], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], ]) sofmnet.train(input_data.ravel()) self.assertInvalidVectorPred(sofmnet, input_data.ravel(), target, decimal=2)
def test_train_different_inputs(self): input_layer = LinearLayer(1) output_layer = CompetitiveOutputLayer(1) self.assertInvalidVectorTrain( algorithms.SOFM(input_layer > output_layer, verbose=False), input_data.ravel())
def test_sofm_angle_distance(self): sn = algorithms.SOFM( n_inputs=2, n_outputs=3, transform='cos', learning_radius=1, features_grid=(3, 1), verbose=False ) sn.train(input_data, epochs=6) answers = np.array([ [1., 0., 0.], [1., 0., 0.], [0., 1., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 1.], ]) np.testing.assert_array_almost_equal( sn.predict(input_data), answers )
def test_sofm_custom_parameter_reduction(self): input_data = 4 * np.ones((1, 2)) default_params = dict( n_inputs=2, n_outputs=3, weight=np.ones((2, 3)), std=1, step=0.1, learning_radius=1, reduce_radius_after=None, reduce_step_after=None, reduce_std_after=None) sofm_1 = algorithms.SOFM(**default_params) sofm_1.train(input_data, epochs=4) dist_1 = np.linalg.norm(sofm_1.weight.T - input_data) def on_epoch_end_update_radius(network): if network.last_epoch % 2 == 0: network.learning_radius = 0 else: network.learning_radius = 1 def on_epoch_end_update_step(network): network.step = 0.1 / network.last_epoch def on_epoch_end_update_std(network): network.std = 1. / network.last_epoch testcases = { 'learning_radius': on_epoch_end_update_radius, 'step': on_epoch_end_update_step, 'std': on_epoch_end_update_std, } for testcase_name, on_epoch_end in testcases.items(): sofm_2 = algorithms.SOFM( epoch_end_signal=on_epoch_end, **default_params ) sofm_2.train(input_data, epochs=4) dist_2 = np.linalg.norm(sofm_2.weight.T - input_data) self.assertLess(dist_1, dist_2, msg="Test case name: {}".format(testcase_name))
def test_sofm_1d_vector_input(self): sofm = algorithms.SOFM( n_inputs=2, n_outputs=3, weight=self.weight, ) output = sofm.predict(input_data[0]) self.assertEqual(output.shape, (1, 3))
def test_invalid_attrs(self): with self.assertRaises(ValueError): # Invalid feature grid shape algorithms.SOFM(n_inputs=2, n_outputs=4, learning_radius=0, features_grid=(2, 3), verbose=False)
def test_invalid_attrs(self): with self.assertRaisesRegexp(ValueError, "Feature grid"): # Invalid feature grid shape algorithms.SOFM(n_inputs=2, n_outputs=4, features_grid=(2, 3)) with self.assertRaisesRegexp(ValueError, "n_outputs, features_grid"): algorithms.SOFM(n_inputs=2) with self.assertRaisesRegexp(ValueError, "more than 2 dimensions"): sofm = algorithms.SOFM(n_inputs=2, n_outputs=3, weight=self.weight) sofm.train(np.zeros((10, 2, 1))) with self.assertRaisesRegexp(ValueError, "more than 2 dimensions"): sofm = algorithms.SOFM(n_inputs=2, n_outputs=3, weight=self.weight) sofm.predict(np.zeros((10, 2, 1))) with self.assertRaisesRegexp(ValueError, "Input data expected"): sofm = algorithms.SOFM(n_inputs=2, n_outputs=3, weight=self.weight) sofm.train(np.zeros((10, 10))) with self.assertRaisesRegexp(ValueError, "Input data expected"): sofm = algorithms.SOFM(n_inputs=2, n_outputs=3, weight=self.weight) sofm.predict(np.zeros((10, 10))) with self.assertRaisesRegexp(ValueError, "one or two dimensional"): algorithms.SOFM(n_inputs=2, features_grid=(3, 1, 1), grid_type='hexagon')
def test_sofm_double_initialization_exception(self): sofm = algorithms.SOFM(n_inputs=2, n_outputs=3, verbose=False, weight='sample_from_data') sofm.init_weights(X) with self.assertRaises(WeightInitializationError): sofm.init_weights(X)
def test_sofm_std_parameter(self): default_params = dict(n_inputs=2, n_outputs=3, learning_radius=1, weight=self.weight) sofm_1 = algorithms.SOFM(std=1, **default_params) sofm_1.train(input_data[:1], epochs=1) dist_1 = np.linalg.norm(sofm_1.weight[0, :] - sofm_1.weight[1, :]) sofm_0 = algorithms.SOFM(std=0.1, **default_params) sofm_0.train(input_data[:1], epochs=1) dist_0 = np.linalg.norm(sofm_0.weight[0, :] - sofm_0.weight[1, :]) # Since SOFM-1 has bigger std than SOFM-0, two updated # neurons should be closer to each other for SOFM-1 than # for SOFM-0 self.assertLess(dist_1, dist_0)
def test_sofm(self): sn = algorithms.SOFM(n_inputs=2, n_outputs=3, weight=self.weight, learning_radius=0, features_grid=(3, 1), verbose=False) sn.train(input_data, epochs=100) np.testing.assert_array_almost_equal(sn.predict(input_data), answers)
def init_sofm(self, lr=0.5): self.sofm = algorithms.SOFM(n_inputs=128, n_outputs=300, step=lr, learning_radius=0, weight='init_pca', shuffle_data=True, verbose=True) with open('sofm_iam.pkl', 'wb') as output: pickle.dump(self.sofm, output, pickle.HIGHEST_PROTOCOL)
def test_sofm_weight_norm_before_training(self): sofm = algorithms.SOFM( n_inputs=2, n_outputs=3, verbose=False, distance='cos', ) actual_norms = np.linalg.norm(sofm.weight, axis=0) expected_norms = np.array([1, 1, 1]) np.testing.assert_array_almost_equal(expected_norms, actual_norms)
def test_sofm_init_during_the_training(self): sofm = algorithms.SOFM( n_inputs=4, n_outputs=7, weight='sample_from_data', ) X = np.random.random((10, 4)) self.assertTrue(callable(sofm.weight)) sofm.train(X, epochs=1) self.assertFalse(callable(sofm.weight))
def combina_colonne(lista): vett = np.asarray(lista) #print("vett:",vett) comb = [] for i in range(len(vett[0])): temp = [] for a in range(len(vett)): temp.append(vett[a][i]) comb.append(temp) data = np.asarray(comb) #print("data:",data) #print("len_data:",len(data)) #som con 20 neuroni GRID_HEIGHT = 1 GRID_WIDTH = 20 sofm = algorithms.SOFM( n_inputs=len(data[0]), features_grid=(GRID_HEIGHT, GRID_WIDTH), # Learning radius defines area within which we find # winning neuron neighbours. The higher the value # the more values we will be updated after each iteration. learning_radius=5, # Every 20 epochs learning radius will be reduced by 1. reduce_radius_after=50, step=0.4, std=1, #show_epoch=5 shuffle_data=True, verbose=True, ) sofm.train(data, epochs=500) clusters = sofm.predict(data).argmax(axis=1) #print("cluster:",clusters) #print("len_clusters:",len(clusters)) ''' colonna=[] for i in range(0,len(lista[0])): #sum=0 for a in range(0,len(lista)): sum+=(2**a)*int(lista[a][i]) colonna.append(str(sum)) print("colonna:",colonna) exit(1) ''' return clusters, sofm
def test_sample_data_weight_init_in_sofm(self): sofm = algorithms.SOFM( n_inputs=4, n_outputs=7, weight='sample_from_data', ) input_data = np.random.random((10, 4)) self.assertTrue(callable(sofm.weight)) sofm.train(input_data, epochs=0) self.assertFalse(callable(sofm.weight)) self.assertEqual(sofm.weight.shape, (4, 7))
def test_sofm(self): input_layer = LinearLayer(2, weight=self.weight) output_layer = CompetitiveOutputLayer(3) sn = algorithms.SOFM(input_layer > output_layer, learning_radius=0, features_grid=(3, 1), verbose=False) sn.train(input_data, epochs=100) for data, answer in zip(input_data, answers): network_output = sn.predict(np.reshape(data, (2, 1)).T) correct_result = np.reshape(answer, (3, 1)).T self.assertTrue(np.all(network_output == correct_result))
def test_sofm_storage(self): input_data = np.random.random((100, 10)) sofm = algorithms.SOFM(n_inputs=10, features_grid=(10, 10), std=1, step=0.5, learning_radius=2, weight=np.random.random((10, 100))) sofm.train(input_data, epochs=10) self.assertPickledNetwork(sofm, input_data) parameters = sofm.get_params() self.assertIn('weight', parameters) self.assertIsInstance(parameters['weight'], np.ndarray)
def test_sofm_training_with_4d_grid(self): sofm = algorithms.SOFM( n_inputs=4, n_outputs=8, features_grid=(2, 2, 2), verbose=False, ) data = np.concatenate([input_data, input_data], axis=1) sofm.train(data, epochs=1) error_after_first_epoch = sofm.errors.last() sofm.train(data, epochs=9) self.assertLess(sofm.errors.last(), error_after_first_epoch)
def main(): preprocess() #normalise() alldata=[] # with open (path+'normalised', 'rb') as fp: with open (path+'outfile.1', 'rb') as fp: alldata = pickle.load(fp) for data in alldata: plt.scatter(data[0], data[1], color='silver', alpha=0.1) sofmnet = algorithms.SOFM( n_inputs=2, n_outputs=5, step=0.01, std=0.1, reduce_step_after=200, reduce_radius_after=2, reduce_std_after=20, show_epoch=10, shuffle_data=True, verbose=True, learning_radius=2, distance='euclid', features_grid=(5, 1), ) sofmnet.train(alldata, epochs=10) plt.scatter(sofmnet.weight[0:1,:], sofmnet.weight[1:2,:], color='red') with open (path+'test_output.1', 'rb') as fp: testdata = pickle.load(fp) for data in testdata: plt.scatter(data[0], data[1], color='green') test(sofmnet) plt.savefig('graph_with_test.png') plt.show()
def test_sofm(self): sn = algorithms.SOFM( n_inputs=2, n_outputs=3, weight=input_data[(2, 0, 4), :].T, learning_radius=0, features_grid=(3, ), shuffle_data=True, verbose=False, reduce_radius_after=None, reduce_step_after=None, reduce_std_after=None, ) sn.train(input_data, epochs=100) np.testing.assert_array_almost_equal(sn.predict(input_data), answers)
def codebook_generation(num_batches,sofm,epoch): if(sofm is None): sofm = algorithms.SOFM(n_inputs = 128, n_outputs = 300 , step = 0.5, learning_radius = 0, signals=on_epoch_end ) with h5py.File('Datasets/SDpoints0.h5', 'r') as hf: data = hf['keypoints-batch'][:] for x in range(1,int(num_batches)+1): with h5py.File('Datasets/SDpoints0.h5', 'r') as hf: data = np.append(data,hf['keypoints-batch'][:],axis=0) sofm.train(data,epochs=int(epoch))