def fit(self, X_train, y_train, X_test, y_test, model, feed, batch_size, n_epochs): K.set_session(self.sess) with self.graph.as_default(): json_file = open(str(model) + '.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) loaded_model.load_weights(str(model) + ".h5") model = loaded_model model.compile(optimizer=feed[0], loss=[feed[1]]) model.fit(X_train, y_train, batch_size, n_epochs) y_pred = model.predict(X_test) y_pred = [np.argmax(i) for i in y_pred] acc = acc_score(y_test, y_pred) return (acc, feed)
def main(tp, fp, fn, tn, exp, pred): try: mcc = round(mcc_score(exp, pred), 2) except ZeroDivisionError: mcc = 'NaN' try: acc = round(acc_score(exp, pred), 2) except ZeroDivisionError: acc = 'NaN' try: pre = round(pre_score(exp, pred), 2) except: pre = 'NaN' try: rec = round(rec_score(exp, pred), 2) except ZeroDivisionError: rec = 'NaN' try: spe = round((float(tn) / (tn + fp)), 2) except ZeroDivisionError: spe = 'NaN' try: f1m = round(f1m_score(exp, pred), 2) except ZeroDivisionError: f1m = 'NaN' try: if len(exp) != list(exp).count(0) and len(exp) != list(exp).count(0): auc = round(auc_score(exp, pred), 2) else: auc = '-' except ZeroDivisionError: auc = 'NaN' return mcc, acc, pre, rec, spe, f1m, auc
def start(workers): imports() preprocess(int(workers)) global topics, parameters, connections with open("out", 'a') as standardout: print("Starting processing\n", file=standardout) topics = ['m2w' + str(i) for i in range(int(workers))] connections = [ pika.BlockingConnection(parameters) for i in range(int(workers)) ] with open("out", 'a') as standardout: print("Topics", topics, file=standardout) model = Sequential(n_users=int(workers), steps=1) model.add(Dense(input_dim=784, units=256, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=10, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) a = time.time() #pr = cProfile.Profile() #pr.enable() model.fit(batch_size=10, epochs=10) #pr.disable() y_pred = model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] acc = acc_score(y_test, y_pred) with open("out", 'a') as stout: print("Accuracy", acc, file=stout) print("TIME", time.time() - a, file=stout) cons_channel.queue_delete(queue='w2m') cons_channel1.queue_delete(queue='w2m1') cons_channel.close() cons_channel1.close() cons_connection.close() cons_connection1.close() for usr in model.users: usr.channel.queue_delete(queue=usr.topic) for conn in connections: conn.close() #with open("out",'a') as sys.stdout: # pr.print_stats() return flask.Response(status=200)
def accuracy_score(self): global X_test_flat, y_test K.set_session(self.sess) with self.graph.as_default(): y_pred = self.model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] accuracy = acc_score(y_test, y_pred) return accuracy
def test_acc(X_test, y_test): global model y_pred = model.predict(X_test) y_pred = [np.argmax(i) for i in y_pred] accuracy = acc_score(y_test, y_pred) return accuracy
def get_accuracy(): K.set_session(sess) with graph.as_default(): y_pred = model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] accuracy = acc_score(y_test, y_pred) return accuracy
def classifier(file_name): review_sparse_vect, rating_sparse_vect = bag_of_words(file_name) # support vector classifier one vs all clf = SVC(C=1, kernel='linear', gamma=1, verbose=False, probability=False, decision_function_shape='ovr') clf.fit(review_sparse_vect, rating_sparse_vect) # Model fitting completeion # print("Fitting completed") predicted = cv.cross_val_predict(clf, review_sparse_vect, rating_sparse_vect, cv=10) # calculation of metrics print("accuracy_score\t", acc_score(rating_sparse_vect, predicted)) print("precision_score\t", pre_score(rating_sparse_vect, predicted)) print("recall_score\t", rc_score(rating_sparse_vect, predicted)) print("\nclassification_report:\n\n", cr(rating_sparse_vect, predicted)) print("\nconfusion_matrix:\n", cm(rating_sparse_vect, predicted))
def start(workers): global s global iplist iplist = [s + str(i) + ':5000' for i in range(0, int(workers))] imports() with open("out", "a") as stout: print("Imports completed", file=stout) (X_train_flat, y_train_oh), (X_test_flat, y_test) = preprocess() model = CustSequential(n_users=int(workers), num_steps=2) model.add(Dense(input_dim=784, units=256, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=10, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) a = time.time() model.fit(X_train_flat, y_train_oh, X_test_flat, y_test, batch_size=10, epochs=20) y_pred = model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] acc = acc_score(y_test, y_pred) with open("out", 'a') as stout: print(acc, file=stout) print(time.time() - a, file=stout) return flask.Response(status=200)
def start(workers): imports() preprocess(int(workers)) global topics with open("out", 'a') as standardout: print("Starting processing\n", file=standardout) topics = ['m2w' + str(i) for i in range(int(workers))] with open("out", 'a') as standardout: print("Topics", topics, file=standardout) model = Sequential(n_users=int(workers), steps=5) model.add(Dense(input_dim=784, units=256, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=10, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) a = time.time() pr = cProfile.Profile() pr.enable() model.fit(batch_size=10, epochs=20) pr.disable() y_pred = model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] acc = acc_score(y_test, y_pred) with open("out", 'a') as stout: print("Accuracy", acc, file=stout) print("TIME", time.time() - a, file=stout) with open("out", 'a') as sys.stdout: pr.print_stats() return flask.Response(status=200)
def start(): (X_train, y_train), (X_test, y_test) = preprocess() model = Sequential(n_users=5, steps=5) model.add(Dense(input_dim=784, units=256, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=128, activation='sigmoid')) model.add(Dense(units=10, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) a = time.time() model.fit(X_train_flat, y_train_oh, X_test_flat, y_test, batch_size=10, epochs=20) y_pred = model.predict(X_test_flat) y_pred = [np.argmax(i) for i in y_pred] acc = acc_score(y_test, y_pred) print(acc) print(time.time() - a) return flask.Response(status=200)
import matplotlib.pyplot as plt import pandas as pd import os from sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score as acc_score dataset = np.loadtxt('cat1_test.csv', delimiter=',') #load into 2d numpy array, skip first row containing column labels if dataset.shape[1]==38: #for csvs containing 38 columns after fix X = np.concatenate((dataset[:,0:14],dataset[:,15:37]),axis=1) #all columns except class and predicted columns y = dataset[:,14] #class column else: #for csvs containing 31 cols X = np.concatenate((dataset[:,0:13],dataset[:,14:30]),axis=1) y = dataset[:, 13] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) sc_X = MinMaxScaler(feature_range=(0, 1)) #scale cols to similar ranges X_train = sc_X.fit_transform(X_train) X_test = sc_X.transform(X_test) #here I have to implement my own logic from sklearn.neighbors import KNeighborsClassifier classifier = KNeighborsClassifier(n_neighbors=6,weights='distance') classifier.fit(X_train, y_train) y_pred = classifier.predict(X_test) acc = acc_score(y_test, y_pred) print(acc * 100)
_LIB.LGBM_BoosterPredictForMat( model, X_test, ctypes.c_int(num_row), preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))) return preds if __name__ == "__main__": ''' 测试使用 出于精简考虑,我们使用train去获得model 使用predict获得预测 使用eval对比结果 ''' # 使用iris数据集简单测试,只保留一部分数据做个二分类 # 数据格式:float32 X_train, y_train, X_test, y_test = load_data() #params 使用默认 model = train('', x_train, y_train) #预测结果 y_predict = predict(model, X_test) #进行评估 acc = sm.acc_score(y_test, y_predict) print(acc) print('done')
y_pred = model.predict(x_test) my_model_end = time.time() sk_start = time.time() from sklearn.ensemble import RandomForestClassifier as RFC skmodel = RFC(max_depth=max_depth, min_samples_leaf=min_leaf, n_estimators=n_trees, random_state=random_state) skmodel.fit(x_train, y_train) y_pred2 = skmodel.predict(x_test) from sklearn.metrics import accuracy_score as acc_score my_model_acc.append(acc_score(y_test, y_pred)) sk_model_acc.append(acc_score(y_test, y_pred2)) endtime = time.time() print( f"Finished iteration {i} in {endtime-starttime:.2f} seconds. My model took {my_model_end-my_model:.2f} seconds. SKLearn took {endtime-sk_start:.2f} seconds." ) # # print("My model's accuracy", acc_score(y_test, y_pred)) # print("SKLearn's model's accuracy", acc_score(y_test, y_pred2)) print("Model accuracy over 100 seeds") print("My model's average accuracy - ", (sum(my_model_acc) / len(my_model_acc))) print("SKLearn's model's average accuracy - ", (sum(sk_model_acc) / len(sk_model_acc)))
def kernel_perceptron(self, initial_alpha=None, T=100, lr=1, gamma=1, coeff=0, degree=1, view=False, b=0): """ Training the kernel perceptron on the input data to prml class. p = prml(X_train,y_train) p.kernel_perceptron() trains the model for the X_train and y_train Parameters: T :- Max no of epochs (default = 100) lr :- learning rate (default = 1) b :- bias for perceptron decision function (default = 0) gamma :- Kernel parameter (default = 1.0) coeff :- Kernel parameter (default = 0.0) degree :- Degree for polynomial kernel (default = 1.0) view :- To view Accuracy vs Epochs for training (default = False) returns: dual coefficients of shape (no of samples,) no_of_mistakes while training the model bound - theoratical bound for perceptron algorithm rho - parameter to estimate bound w_norm - parameter to estimate bound r - parameter to estimate bound """ self.algo = 'kernel_perceptron' (self.gamma, self.coeff, self.degree, self.b) = (gamma, coeff, degree, b) if str(type(initial_alpha)) == "<class 'NoneType'>": self.alpha = np.zeros_like(self.y) else: self.alpha = initial_alpha y = 2 * self.y - 1 a_score = [] no_of_mistakes = 0 for i in range(T): for j in range(y.size): y_hat = np.sign(( (self.alpha * y).T @ self._hybrid_kernel(self.X, self.X[j, :])) + self.b) if y_hat != y[j]: self.alpha[j] += lr no_of_mistakes += 1 y_h = np.sign( (self._hybrid_kernel(self.X, self.X) @ (self.alpha * y)) + self.b) a_score.append(acc_score(y, y_h)) # Bound calculation K = self._hybrid_kernel(self.X, self.X) r = np.max(np.diag(K)) #r>0 always see report alpha_y = y * self.alpha w_norm = np.sqrt(alpha_y.T @ K @ alpha_y) if w_norm != 0: rho_choice = y * (alpha_y @ K) / w_norm rho = np.min([i for i in rho_choice if i > 0]) #To keep rho>0 v = np.ones(self.X.shape[1]) / np.sqrt( self.X.shape[1]) #Unit vector v d = rho - (y * (alpha_y @ K)) d = d[d > 0] delta = np.linalg.norm(d) bound = ((r + delta) / rho)**2 else: # When w_norm = 0 replacing w with v. (See FOML book) v = np.ones(self.X.shape[1]) / np.sqrt(self.X.shape[1]) rho_choice = (y * (self.X @ v)) rho = np.min([i for i in rho_choice if i > 0]) d = rho - (y * (self.X @ v)) d = d[d > 0] delta = np.linalg.norm(d) bound = ((r + delta) / rho)**2 # Visualizing convergence if view: plt.plot(np.arange(T), a_score, 'bo') plt.xlabel('Epoches') plt.ylabel('Classification Accuracy') plt.title('Classification Accuracy vs Epoches') return self.alpha, no_of_mistakes, bound, rho, w_norm, r
) #train test split with specified random seed to get same output every time sc_X = StandardScaler() #scale cols to similar ranges X_train = sc_X.fit_transform(X_train) X_test = sc_X.transform(X_test) model = Sequential() model.add( Dense(12, input_dim=(36 if dataset.shape[1] == 38 else 29), activation='relu') ) #add input layer of 36 or 29 nodes and hidden layer of 12 nodes, with relu activation func model.add(Dense(8, activation='relu')) #add second hidden layer with relu model.add(Dense(1, activation='sigmoid') ) #add output layer with sigmoid for clear output model.compile( loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'] ) #compile model with loss function as binary crossentropy (like squared error for linear reg) used for binary classification problems, optimiser as adam (adaptive moment estimation) (like gradient descent for linear reg model.fit( X_train, y_train, epochs=100, batch_size=10 ) #1 epoch is 1 run through whole dataset, batch size is number of training examples considered at a time for training, all training examples considered batch by batch for each epoch y_pred = model.predict_classes(X_test) #predict class for test x acc = acc_score( y_test, y_pred) #check accuracy by comparing predicted y and test y print('done', cnt - 1) #number of files left cnt -= 1 print(filename, acc * 100, file=results) #put into results file results.close()