def make_experiments_without_extract(X, y): svc_no_extract_scores = [] knn_no_extract_scores = [] gnb_no_extract_scores = [] dt_no_extract_scores = [] mlp_no_extract_scores = [] elm_no_extract_scores = [] for train_index, test_index in skf.split(X, y): X_train, X_test = X[train_index], X[test_index] y_train, y_test = y[train_index], y[test_index] svc_clf = SVC(random_state=444) knn_clf = KNeighborsClassifier() gnb_clf = GaussianNB() dt_clf = DecisionTreeClassifier(random_state=444) mlp_clf = MLPClassifier(random_state=444) elm_clf = ELM(X_train.shape[1], 1, 1000) svc_pred = svc_clf.fit(X_train, y_train).predict(X_test) knn_pred = knn_clf.fit(X_train, y_train).predict(X_test) gnb_pred = gnb_clf.fit(X_train, y_train).predict(X_test) dt_pred = dt_clf.fit(X_train, y_train).predict(X_test) mlp_pred = mlp_clf.fit(X_train, y_train).predict(X_test) elm_clf.train(X_train, y_train[:, np.newaxis]) elm_pred = elm_clf.predict(X_test) elm_pred = (elm_pred > 0.5).astype(int) svc_no_extract_scores.append(round(accuracy_score(svc_pred, y_test), 2)) knn_no_extract_scores.append(round(accuracy_score(knn_pred, y_test), 2)) gnb_no_extract_scores.append(round(accuracy_score(gnb_pred, y_test), 2)) dt_no_extract_scores.append(round(accuracy_score(dt_pred, y_test), 2)) mlp_no_extract_scores.append(round(accuracy_score(mlp_pred, y_test), 2)) elm_no_extract_scores.append(round(accuracy_score(elm_pred, y_test), 2)) return [ round(np.average(svc_no_extract_scores), 2), round(np.average(knn_no_extract_scores), 2), round(np.average(gnb_no_extract_scores), 2), round(np.average(dt_no_extract_scores), 2), round(np.average(mlp_no_extract_scores), 2), round(np.average(elm_no_extract_scores), 2) ]
def make_experiments_with_lda(X, y): for train_index, test_index in skf.split(X, y): X_train, X_test = X[train_index], X[test_index] y_train, y_test = y[train_index], y[test_index] lda = LinearDiscriminantAnalysis() X_lda = lda.fit_transform(X_train, y_train) X_test_lda = lda.transform(X_test) svc_clf = SVC(random_state=444) knn_clf = KNeighborsClassifier() gnb_clf = GaussianNB() dt_clf = DecisionTreeClassifier(random_state=444) mlp_clf = MLPClassifier(random_state=444) elm_clf = ELM(X_lda.shape[1], 1, 1000) svc_pred = svc_clf.fit(X_lda, y_train).predict(X_test_lda) knn_pred = knn_clf.fit(X_lda, y_train).predict(X_test_lda) gnb_pred = gnb_clf.fit(X_lda, y_train).predict(X_test_lda) dt_pred = dt_clf.fit(X_lda, y_train).predict(X_test_lda) mlp_pred = mlp_clf.fit(X_lda, y_train).predict(X_test_lda) elm_clf.train(X_lda, y_train[:, np.newaxis]) elm_pred = elm_clf.predict(X_test_lda) elm_pred = (elm_pred > 0.5).astype(int) svc_lda_scores.append(round(accuracy_score(svc_pred, y_test), 2)) knn_lda_scores.append(round(accuracy_score(knn_pred, y_test), 2)) gnb_lda_scores.append(round(accuracy_score(gnb_pred, y_test), 2)) dt_lda_scores.append(round(accuracy_score(dt_pred, y_test), 2)) mlp_lda_scores.append(round(accuracy_score(mlp_pred, y_test), 2)) elm_lda_scores.append(round(accuracy_score(elm_pred, y_test), 2)) return [ round(np.average(svc_lda_scores), 2), round(np.average(knn_lda_scores), 2), round(np.average(gnb_lda_scores), 2), round(np.average(dt_lda_scores), 2), round(np.average(mlp_lda_scores), 2), round(np.average(elm_lda_scores), 2) ]
np.zeros(dtype=np.int, shape=ith_total_test) + i, axis=0) return train_input, train_target, test_input, test_target # data preparation my_data = genfromtxt('iris.csv', delimiter=',') x_inp = my_data[:, 0:-1] t_inp = my_data[:, -1] train_input, train_target, test_input, test_target = split_data( x_inp, t_inp, 0.6, 0.4) e = ELM(50) e.train(train_input, train_target) e.test(test_input, test_target) print e.train_acc print e.test_acc """ # start for article on https://fennialesmana.com/extreme-learning-machine/ # 1. Prepare the input data (x) and target data (t) x = np.array([[-1, -5, 5, 5], [2, -4, 2, 3]]) t = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 1]]) # 2. Prepare the number of hidden nodes, input weight (w), and bias (b) randomly w = np.array([[0.5, 0.2], [0.7, -0.4], [-0.6, 0.3]]) b = np.array([[0.6], [0.7], [0.4]]) # 3. Calculate the output of hidden layer (H) H = np.dot(w, x) + b H = (1/(1+(numpy.matlib.exp(H*-1)))).transpose() # 4. Calculate the weight of hidden to output layer using zero error equation
hit_rates = [] no_of_attributes = dataset.shape[1] - 1 no_of_classes = len(dataset[0, no_of_attributes]) # insert bias no_rows = dataset.shape[0] dataset = np.c_[-1 * np.ones(no_rows), dataset] # perceptron = Perceptron(no_of_classes, no_of_attributes, 5, 'logistic') for j in range(0, 20): print("realization %d" % j) train_X, train_y, test_X, test_y = Classifier.train_test_split(dataset) train_X = np.array(train_X, dtype=float) test_X = np.array(test_X, dtype=float) hidden_units = ELM.model_training(no_of_classes, no_of_attributes, train_X, train_y) elm = ELM(no_of_classes, no_of_attributes, hidden_units) elm.train(train_X, train_y) predictions = elm.predict(test_X) hit_rates.append(elm.evaluate(test_y, predictions)) print(elm.confusion_matrix(test_y, predictions)) # Perceptron.plot_decision_boundaries(train_X, train_y, test_X, test_y, perceptron, hidden_neurons, j) print('hit rates: {}'.format(hit_rates)) print('accuracy: {}'.format(np.mean(hit_rates))) print('std: {}'.format(np.std(hit_rates))) # Perceptron.show_plot_decision_boundaries()
class ELMTest(unittest.TestCase): # We will test both FP and FN versions of the ELM def setUp(self): self.mockConnectionPool = Mock(spec=pycassa.pool.ConnectionPool) self.minimizationType = 'FP' self.numberNeurons = 100 def test_init(self): # Check that wrong input raises exception self.assertRaises(Exception, ELM, 'SomeString', self.mockConnectionPool, self.numberNeurons) self.assertRaises(Exception, ELM, self.minimizationType, 'NotAConnectionPool', self.numberNeurons) self.assertRaises(Exception, ELM, self.minimizationType, self.mockConnectionPool, 'NotANumber') @patch('elm.pycassa.columnfamily.ColumnFamily') def test_createTrainingData(self, mockFunction): returnedMock = Mock(spec=pycassa.ColumnFamily) returnedMock.get = mock_columnfamilyget returnedMock.get_range = mock_columnfamilyget_range returnedMock.batch = Mock() mockbatchinsert = Mock() mockbatchinsert.insert = mock_batchinsert mockbatch = Mock() mockbatch.__enter__ = Mock(return_value=mockbatchinsert) mockbatch.__exit__ = Mock(return_value=False) mockFunction.return_value = returnedMock returnedMock.batch.return_value = mockbatch self.myELM = ELM(self.minimizationType, self.mockConnectionPool, self.numberNeurons) self.myELM.createTrainingData() @patch('elm.pycassa.columnfamily.ColumnFamily') def test_storeTrainingDataToCassandra(self, mockFunction): returnedMock = Mock(spec=pycassa.ColumnFamily) returnedMock.get = mock_columnfamilyget returnedMock.get_range = mock_columnfamilyget_range returnedMock.batch = Mock() mockbatchinsert = Mock() mockbatchinsert.insert = mock_batchinsert mockbatch = Mock() mockbatch.__enter__ = Mock(return_value=mockbatchinsert) mockbatch.__exit__ = Mock(return_value=False) mockFunction.return_value = returnedMock returnedMock.batch.return_value = mockbatch self.myELM = ELM(self.minimizationType, self.mockConnectionPool, self.numberNeurons) self.myELM.createTrainingData() self.myELM.storeTrainingDataToCassandra() @patch('elm.pycassa.columnfamily.ColumnFamily') def test_train(self, mockFunction): returnedMock = Mock(spec=pycassa.ColumnFamily) returnedMock.get = mock_columnfamilyget returnedMock.batch = Mock() mockbatchinsert = Mock() mockbatchinsert.insert = mock_batchinsert mockbatch = Mock() mockbatch.__enter__ = Mock(return_value=mockbatchinsert) mockbatch.__exit__ = Mock(return_value=False) mockFunction.return_value = returnedMock returnedMock.batch.return_value = mockbatch self.myELM = ELM(self.minimizationType, self.mockConnectionPool, self.numberNeurons) self.myELM.train() @patch('elm.pycassa.columnfamily.ColumnFamily') def test_verdict(self, mockFunction): returnedMock = Mock(spec=pycassa.ColumnFamily) returnedMock.get = mock_columnfamilyget mockFunction.return_value = returnedMock self.myELM = ELM(self.minimizationType, self.mockConnectionPool, self.numberNeurons) self.myELM.train() inputTestData = np.loadtxt('./test_input_data_training_elm.txt').reshape((633, 9)) outputTestData = np.loadtxt('./test_output_data_training_elm.txt').reshape((633, 1)) ELMTestingData = ELMData(inputTestData, outputTestData, [], [])
h = Helper() h.get_dataset(datasets[3]) train, test = h.split_dataset() neural_network = ELM(input_size=13, output_layer_size=1) #neural_network.add_neuron(9, "linear") neural_network.add_neuron(100, "sigmoid") output_classes = [] print(len(train)) print(datetime.datetime.now()) for item in train.values: #item[:len(item)-1] neural_network.train(item[:len(item) - 1]) output_classes.append(item[len(item) - 1]) neural_network.update_beta(output_classes) #create output_weights print(datetime.datetime.now()) error_values = [] for item in h.test_dataset.values: predicted = neural_network.predict(item[:len(item) - 1]) print(predicted) actual_value = item[len(item) - 1] print(actual_value) error_values.append((actual_value - predicted)**2) #square the error print("MSE (Mean Squared Error): ", mean(error_values))