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()