def fit(self, train_ops, data_dir='lfe/data', save_dir='lfe'):
'''
:param train_ops: list for train_ops
:param data_dir: directory for training data
:param save_dir: directory to save models
:return:
'''
if not os.path.exists(save_dir):
os.mkdir(save_dir)
train_x, train_y = self.load_training_data(data_dir)
for train_op in train_ops:
save_path = "lfe_" + self.name_prefix + "_" + train_op
save_path = os.path.join(save_dir, save_path)
if train_op == 'log':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'sqrt':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'square':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'freq':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'round':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'tanh':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'sigmoid':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'isoreg':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'zscore':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
elif train_op == 'norm':
clf = MLP(hidden_layer_sizes=(500, ),
max_iter=3000,
verbose=1,
n_iter_no_change=20,
tol=1e-5)
else:
raise ValueError("Unexpected operation %s" % train_op)
clf.fit(train_x, train_y[train_op])
from sklearn.metrics import accuracy_score
print(accuracy_score(clf.predict(train_x), train_y[train_op]))
with open(save_path, 'wb') as f:
pkl.dump(clf, f)
# printing class distribution of test dataset
print(f'Classes: {np.unique(y_test)}')
print(f'Class distribution for test data: {np.bincount(y_test)}')
# MLP is sensitive to feature scaling, hence performing scaling
# Options: MinmaxScaler and Standardscaler
# from sklearn.preprocessing import MinMaxScaler
# scaler = MinMaxScaler()
from sklearn.preprocessing import StandardScaler as SS
X_train_stdsc = SS().fit_transform(X_train)
X_test_stdsc = SS().fit_transform(X_test)
# Setting of hyperparameters of the network
from sklearn.neural_network import MLPClassifier as MLP
mlp = MLP(hidden_layer_sizes=(10, ), learning_rate_init=0.001, max_iter=5000)
# Calculating Training Time : more neurons, more time
from time import time
start = time()
# Train the model using the scaled training sets
mlp.fit(X_train_stdsc, y_train)
end = time()
print(f'Training Time: {(end-start)*1000:.3f}ms')
# Predict the response for test dataset
y_pred = mlp.predict(X_test_stdsc) # scaled
# Import scikit-learn metrics module for evaluating model performance
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
criterion='gini',
)
from neupy import algorithms
modeloPNN = algorithms.PNN(
std=5,
verbose=False,
)
from sklearn.neural_network import MLPClassifier as MLP
modeloMLP = MLP(hidden_layer_sizes=(
175,
100,
50,
25,
),
max_iter=500,
random_state=1)
from sklearn import svm
modeloSVM = svm.LinearSVC()
modelos = {
'LDA': modeloLDA,
'QDA': modeloQDA,
'KNN': modeloKNN,
'FOREST': modelFOREST,
'SVM': modeloSVM,
'PNN': modeloPNN,
if x!=103:
pca = decomposition.PCA(n_components = x)
train_X = pca.fit_transform(Train_X)
test_X = pca.transform(Test_X)
else:
train_X = Train_X
test_X = Test_X
print(test_X.shape)
print(train_X.shape)
##print(n_classes)
mlp = MLP(hidden_layer_sizes = (128,64),batch_size = 128,learning_rate_init=0.001,epsilon = 1e-08,max_iter=100)
mlp.fit(train_X,train_Y)
pred = mlp.predict(test_X)
pred = pred.argmax(axis=1)
c_matrix = confusion_matrix(test_Y,pred)
print(c_matrix)
accuracy = accuracy_score(test_Y,pred)
print('Accuracy : ',accuracy)
a.append(accuracy)
#precision = true positive / total predicted positive(True positive + False positive)
#recall = true positive / total actual positive(True positive + False Negative)
print(classification_report(test_Y,pred))
print(a)
def simpleAlgorithm(trainData):
trainx=trainData[[ 'Pclass', 'Sex', 'Age', 'Fare', 'Embarked', 'familySize']]
trainy=trainData['Survived'].values.ravel()
tr_tr_x,tr_te_x,tr_tr_y,tr_te_y=train_test_split(trainx,trainy,test_size=0.3,random_state=0)
clf_svms=[]
clf_KNNs = []
clf_LRs = []
clf_MNBs = []
clf_MLPs = []
clf_rfcs = []
clf_XGBs = []
clf_ADAs = []
# C=np.arange(0.1,2,0.1)
# gamma=np.arange(0.01,0.2,0.01)
# for p1 in C:
# for p2 in gamma:
# clf_svm = SVC(C=p1, gamma=p2, kernel='rbf', random_state=1)
# clf_svms.append(clf_svm)
# tols=[1.0,0.01,0.001,0.0001,0.00001,0.000001]
# for ele in tols:
# clf_svm=SVC(C=4.7,gamma=0.07,kernel='rbf',random_state=0,tol=ele)
# clf_svms.append(clf_svm)
# for p2 in coef0s:
# clf_svm = SVC(C=0.9, gamma=0.0999999999, kernel='rbf', random_state=0,probability=True,coef0=p2)
# clf_svms.append(clf_svm)
# parameters={
# 'C':[0.01,0.1,1,2,5],
# 'kernel':['rbf','linear','poly']
# }
# clf=SVC()
# gsearch=GridSearchCV(clf,param_grid=parameters,scoring='roc_auc',cv=5)
# gsearch.fit(trainx,trainy)
# print(gsearch.best_params_,gsearch.best_score_)
clf_svm = SVC(C=0.5, gamma=0.19, kernel='rbf', random_state=0,probability=True)
clf_svms.append(clf_svm)
# clf = SVC(C=2,kernel='poly')
# cv=ShuffleSplit(n_splits=100,test_size=0.2,random_state=1)
# plot_learning_curve(clf,tr_tr_x,tr_tr_y,ylim=(0.7,0.95),cv=cv)
# n_neighbors=range(1,20)
# for n_neighbor in n_neighbors:
# clf_KNN = KNN(n_neighbors=n_neighbor)
# clf_KNNs.append(clf_KNN)
# sizes=range(20,100,10)
# for size in sizes:
# clf_KNN = KNN(n_neighbors=4,leaf_size=size)
# clf_KNNs.append(clf_KNN)
clf_KNN = KNN(n_neighbors=4,leaf_size=80)
clf_KNNs.append(clf_KNN)
C=np.arange(0.018,0.021,0.001)
for c in C:
clf_LR = LR(tol=0.0001, random_state=0, solver='lbfgs', penalty='l2', C=c)
clf_LRs.append(clf_LR)
clf_MNB=MNB()
clf_MNBs.append(clf_MNB)
hidden_layer_sizes=[]
# for i in range(6,15,6):
# tuple=(i,)
# hidden_layer_sizes.append(tuple)
# for i in range(3,8,1):
# for j in range(3, 8, 1):
# for k in range(3,8,1):
# tuple = (i,j,k)
# hidden_layer_sizes.append(tuple)
# for i in range(7,15,1):
# tuple = (i,i,i)
# hidden_layer_sizes.append(tuple)
# hidden_layer_sizes=[(6,6),(7, 3),(6,6,6),(7,3,7),(7,7,7),(70,70,70)]
hidden_layer_sizes = [(12,12,12)]
for hidden_layer_size in hidden_layer_sizes:
clf_MLP = MLP(hidden_layer_sizes=hidden_layer_size, max_iter=10000,tol=0.00001,solver='lbfgs')
clf_MLPs.append(clf_MLP)
# n_estimators=range(10,50)
# max_depths=range(3,5)
# max_features=range(1,7)
# min_samples_splits=range(2,23,1)
# min_samples_leafs=range(1,101,10)
n_estimators = np.arange(17,18,1)
for n_estimator in n_estimators:
clf_rfc = rfc(n_estimators=n_estimator, max_depth=4, random_state=0,max_features=2,oob_score=False,min_samples_split=18)
clf_rfcs.append(clf_rfc)
# for depth in max_depths:
# clf_rfc=rfc(n_estimators=n_estimator,max_depth=depth,random_state=0)
# for min_samples_leaf in min_samples_leafs:
# clf_rfc = rfc(n_estimators=30, max_depth=4, random_state=0,max_features=1,oob_score=True,min_samples_split=18)
# clf_rfcs.append(clf_rfc)
# min_samples_leafs=np.arange(0.1,0.6,0.1)
# min_samples_leafs.append(1)
# for leaf in min_samples_leafs:
clf_rfc = rfc(n_estimators=26, max_depth=4, random_state=0,max_features=2,oob_score=False,min_samples_split=18)
clf_rfcs.append(clf_rfc)
# n_estimators=range(62,63,1)
# max_depths=range(3,4)
# for n_estimator in n_estimators:
# for depth in max_depths:
# clf_XGB=XGB(n_estimators=n_estimator,max_depth=depth)
# clf_XGBs.append(clf_XGB)
# min_child_weights=range(1,101,20)
# subsamples=np.arange(0.5,1.0,0.2)
# gammas=np.arange(0,1.0,0.2)
# for min_child_weight in min_child_weights:
# for subsample in subsamples:
# for gamma in gammas:
# clf_XGB = XGB(n_estimators=62, max_depth=3,min_child_weight=min_child_weight,subsample=subsample,gamma=gamma)
# clf_XGBs.append(clf_XGB)
# n_estimators=np.arange(60,80,1)
# for n_estimator in n_estimators:
# clf_XGB = XGB(random_state=0,n_estimators=n_estimator, max_depth=3, min_child_weight=1, subsample=0.9, gamma=0.2,reg_alpha=0.2,learning_rate=0.30000000000000004,reg_lambda=0.5)
# clf_XGBs.append(clf_XGB)
clf_XGB = XGB(random_state=0, n_estimators=67, max_depth=3, min_child_weight=1, subsample=0.9, gamma=0.2,
reg_alpha=0.2, learning_rate=0.30000000000000004, reg_lambda=0.5)
clf_XGBs.append(clf_XGB)
# n_estimators=range(1,20,1)
# learning_rates=np.arange(0.8,1.0,0.01)
# for learning_rate in learning_rates:
# for n_estimator in n_estimators:
# clf_ada = ADA(n_estimators=n_estimator,learning_rate=learning_rate)
# clf_ADAs.append(clf_ada)
# n_estimators=np.arange(1,13,1)
# for n_estimator in n_estimators:
# clf_ada = ADA(n_estimators=n_estimator, learning_rate=0.9800000000000002,random_state=0)
# clf_ADAs.append(clf_ada)
clf_ada = ADA(n_estimators=9, learning_rate=0.9800000000000002, random_state=0)
clf_ADAs.append(clf_ada)
clfs=[clf_svms,clf_KNNs,clf_LRs,clf_MNBs,clf_MLPs,clf_rfcs,clf_XGBs,clf_ADAs]
Algorithms = ['svm', 'KNN', 'LR', 'MNB', 'MLP', 'rfc', 'XGB','ADA']
savemodels = []
savemodelpaths=[]
for clf,Algorithm in zip(clfs,Algorithms):
bigges_tr_score = 0
best_tr_clf = ''
bigges_te_score = 0
best_te_clf = ''
corr_te_score=0
corr_tr_score=0
for ele in clf:
if Algorithm!='MNB':
tr_x_scale=scale(tr_tr_x)
tr_te_x_scale=scale(tr_te_x)
tr_score,te_score,tr_mean_score = trainModel(ele, Algorithm, tr_x_scale,tr_tr_y,tr_te_x_scale,tr_te_y)
else:
tr_score,te_score,tr_mean_score = trainModel(ele, Algorithm, tr_tr_x,tr_tr_y,tr_te_x,tr_te_y)
if tr_score>bigges_tr_score:
bigges_tr_score=tr_score
corr_te_score=te_score
best_tr_clf=ele
if te_score > bigges_te_score:
bigges_te_score = te_score
corr_tr_score=tr_score
best_te_clf = ele
print('训练集切分训练数据最佳得分：%s score is:%.4f 对应的测试数据：%s score is:%.4f'%(Algorithm,bigges_tr_score,Algorithm,corr_te_score))
print('训练集切分测试数据最佳得分：%s score is:%.4f 对应的训练数据：%s score is:%.4f' % (Algorithm, bigges_te_score,Algorithm,corr_tr_score))
print('best Algorithm is:',best_tr_clf)
print('best Algorithm is:', best_te_clf)
# cv=ShuffleSplit(n_splits=10,test_size=0.2,random_state=1)
# plot_learning_curve(best_te_clf,Algorithm,trainx,trainy,ylim=(0.7,0.95),cv=cv)
savemodels.append(best_te_clf)
for Algorithm in Algorithms:
str='../models/'+Algorithm+'_model.m'
savemodelpaths.append(str)
return savemodels,savemodelpaths
labelsTrain = pickle.load(open("labelsTrain.pkl","rb"))
labelsVal = pickle.load(open("labelsVal.pkl","rb"))
"""
# Determine optimal number of hidden nodes
print(1)
runs = 10
nodes = 14
lowestAvgMAE = float('inf')
runPoints = []
avgPoints = []
for i in range(2, nodes + 2):
errorSum = []
for j in range(runs):
ANN = MLP(hidden_layer_sizes=(i, ),
max_iter=200,
activation='logistic',
solver='lbfgs')
ANN.fit(featTrain, labelsTrain)
N = ANN.predict(featVal)
k = len(labelsVal)
labelDeg = np.rad2deg(np.arctan2(labelsVal[:, 0], labelsVal[:, 1]))
NDeg = np.rad2deg(np.arctan2(N[:, 0], N[:, 1]))
labelDeg[labelDeg < 0] = labelDeg[labelDeg < 0] + 360
NDeg[NDeg < 0] = NDeg[NDeg < 0] + 360
AE = np.abs(labelDeg - NDeg)
AE[AE > 180] = 360 - AE[AE > 180]
MAE = np.mean(AE)
runPoints.append([i, MAE])
errorSum.append(MAE)
avgMAE = np.mean(errorSum)
avgPoints.append([i, avgMAE])
if __name__ == "__main__":
# desabilita mensagens de warning
warnings.filterwarnings("ignore")
# classificadores lineares
linear = {
"LDA": LDA(solver="svd", n_components=1),
"Logit": LogisticClassifier(solver="liblinear")
}
# classificadores não-lineares
nonlinear = {
"MLP":
MLP(hidden_layer_sizes=(400, ),
solver="sgd",
learning_rate="constant",
max_iter=1000,
power_t=0.4),
"QDA":
QDA(reg_param=1),
"SVM":
SVM(kernel="rbf", C=1.41),
"KNN":
KNN(metric="manhattan", n_neighbors=24)
}
# carregando dados (conjunto original)
training = pd.read_csv("data/training.csv")
testing = pd.read_csv("data/testing.csv")
X_train = training.drop(["Class"], axis=1)
y_train = training["Class"]
# pickle.dump(new_data, open('bertheads.pkl' , 'wb'))
for data in ["original", "heads", "shortened"]:
print("**************" + data + "*****************")
if data == "shortened":
data = shortened
elif data == "original":
data = original
else:
data = head
train, test = train_test_split(data,
shuffle=True,
random_state=1,
train_size=int(len(data) * 0.9))
x_train = [i[1].squeeze() for i in train]
y_train = [i[0] for i in train]
x_test = [i[1].squeeze() for i in test]
y_test = [i[0] for i in test]
clf = MLP()
clf.fit(x_train, y_train)
y_pred = clf.predict(x_test)
print(classification_report(y_test, y_pred, output_dict=True))
y_pred = clf.predict(x_train)
print(classification_report(y_train, y_pred, output_dict=True))
ytest = M.item().get('y_test')
#%%
# This is for capturing the best value
start_time = time()
param_grid = {
'hidden_layer_sizes': [(50, 50, 50), (50, 100, 50), (8, 8, 8), (8, 10, 8)],
'activation': ['tanh', 'relu'],
'solver': ['sgd', 'adam'],
'alpha': [0.0001, 0.05],
'learning_rate': ['constant', 'adaptive'],
}
clf = GridSearchCV(MLP(max_iter=1000,
early_stopping=True,
validation_fraction=1.0 / 6),
param_grid,
cv=10,
verbose=1,
n_jobs=-1)
clf.fit(Xtrain, ytrain)
elapsed_time = time() - start_time
print("Time final: {}".format(elapsed_time))
dump(clf, 'archivo_grey.joblib')
#%%
nn_acc = clf.score(Xtest, ytest)
print(f"NN: El accuracy encontrado fue {nn_acc * 100.0}%")
#MAEValidAngle = []
numNodes = []
node = []
avgMAEs = []
bestMAE = float('inf')
history = np.array([float('inf')] * 10)
itr = -1
priorValidAngles = []
for k in range(4, 12, 2):
#ANN = MLP(hidden_layer_sizes = (k,),max_iter=30,activation='logistic',solver='lbfgs',warm_start=True)
MAECurrent = []
MAETrainCurrent = []
for l in range(10):
ANN = MLP(hidden_layer_sizes=(k, ),
max_iter=30,
activation='logistic',
solver='lbfgs',
warm_start=True)
#ANNs.append(ANN.fit(scaleTrainFeat,trainLabel))
condition = True
#set almost all lists to be empty here
MAETrain = []
MAEValid = []
MAETrainAngle = []
MAEValidAngle = []
epoch = []
loop = -1
#itr = -1
while (condition):
itr += 1
X_train = np.random.rand(2, 2)
y_train = np.random.rand(2, )
my_hidden_layer_sizes = (4, 4)
XOR_MLP = MLP(activation='tanh',
alpha=0.99,
batch_size='auto',
beta_1=0.9,
beta_2=0.999,
early_stopping=False,
epsilon=1e-08,
hidden_layer_sizes=my_hidden_layer_sizes,
learning_rate='constant',
learning_rate_init=0.1,
max_iter=5000,
momentum=0.5,
nesterovs_momentum=True,
power_t=0.5,
random_state=0,
shuffle=True,
solver='sgd',
tol=0.0001,
validation_fraction=0.1,
verbose=False,
warm_start=False)
XOR_MLP.fit(X_train, y_train)
# Read layer weights and bias weights together
weights = XOR_MLP.coefs_
biases_weights = XOR_MLP.intercepts_
centered_train_features = train_features.copy()
ncols = features.shape[1]
train_col_means = centered_train_features.mean(axis=0)
for i in range(ncols):
centered_train_features[:,
i] = centered_train_features[:,
i] - train_col_means[i]
centered_test_features = test_features.copy()
test_col_means = centered_test_features.mean(axis=0)
for i in range(ncols):
centered_test_features[:,
i] = centered_test_features[:,
i] - test_col_means[i]
mlp = MLP(hidden_layer_sizes=(2 * len(centered_train_features)))
mlp.fit(centered_train_features, train_outcome)
predicted_outcome = mlp.predict(
centered_test_features) #don't forget to center the test features
score = accuracy_score(test_outcome, predicted_outcome)
print(score)
# about 82 % accuracy
pca = PCA(train_features.shape[1])
transformed_train_features = pca.fit_transform(train_features)
transformed_test_features = pca.transform(test_features)
mlp = MLP(hidden_layer_sizes=(2 * len(transformed_train_features)))
mlp.fit(transformed_train_features, train_outcome)
predicted_outcome = mlp.predict(transformed_test_features)
score = accuracy_score(test_outcome, predicted_outcome)
for train_index, test_index in folds:
m = SVC(kernel='linear', class_weight='balanced')
m.fit(np.concatenate((X1[train_index], X2[train_index]), axis=-1),
Y[train_index])
yp = m.predict(np.concatenate((X1[test_index], X2[test_index]), axis=-1))
rst = precision_recall_fscore_support(Y[test_index], yp)
print(rst)
results.append(rst)
print('Linear SVM\n', file=fp)
print(np.mean(results, axis=0), file=fp)
print('\n\n', file=fp)
results = []
for train_index, test_index in folds:
m = MLP(class_weight='balanced')
m.fit(np.concatenate((X1[train_index], X2[train_index]), axis=-1),
Yl[train_index])
yp = m.predict(np.concatenate((X1[test_index], X2[test_index]), axis=-1))
rst = precision_recall_fscore_support(Y[test_index], yp)
print(rst)
results.append(rst)
print('MLP\n', file=fp)
print(np.mean(results, axis=0), file=fp)
print('\n\n', file=fp)
results = []
for train_index, test_index in folds:
m = LR(class_weight='balanced')
m.fit(X1[train_index] - X2[train_index], Y[train_index])
def main(argv):
del argv # Unused.
# -- Load data
# ---- Embedding
logging.info('Loading embeddings')
emb0 = Embedding(join(FLAGS.data_root, FLAGS.lang0_emb_file))
emb1 = Embedding(join(FLAGS.data_root, FLAGS.lang1_emb_file))
emb = MultiLanguageEmbedding(emb0, emb1)
logging.info('Loadding desc - word pairs')
# ---- desc, word pairs
dw_pair_train_01 = DescCorpus.build_dw_pair_from_file(join(
FLAGS.data_root, FLAGS.lang01_desc_file),
emb,
src_lan_id=0,
tgt_lan_id=1)
dw_pair_train_10 = DescCorpus.build_dw_pair_from_file(join(
FLAGS.data_root, FLAGS.lang10_desc_file),
emb,
src_lan_id=1,
tgt_lan_id=0)
dw_pair_test_01 = DescCorpus.build_dw_pair_from_file(join(
FLAGS.data_root, FLAGS.lang01_desc_test_file),
emb,
src_lan_id=0,
tgt_lan_id=1)
dw_pair_test_10 = DescCorpus.build_dw_pair_from_file(join(
FLAGS.data_root, FLAGS.lang10_desc_test_file),
emb,
src_lan_id=1,
tgt_lan_id=0)
# ---- build candidate set
lang0_candidate_set = [] # lang# is the lang_id of *target*
for dw_pair in chain(dw_pair_train_10, dw_pair_test_10):
d, w = dw_pair
lang0_candidate_set.append(w)
lang0_candidate_set = set(lang0_candidate_set)
lang1_candidate_set = [] # lang# is the lang_id of *target*
for dw_pair in chain(dw_pair_train_01, dw_pair_test_01):
d, w = dw_pair
lang1_candidate_set.append(w)
lang1_candidate_set = set(lang1_candidate_set)
# -- Load model(s)
logging.info('Loading models.')
tag = ''
word2vec_model_infer = keras.models.load_model(
join(FLAGS.model_root, tag + 'word2vec_model_infer'))
encoder_model_infer = keras.models.load_model(
join(FLAGS.model_root, tag + 'encoder_model_infer'))
# encoder_model_infer.compile(optimizer=Adam(amsgrad=True), loss='mse')
logging.info("Models are not compiled, but that's fine.")
# -- Predicting
logging.info("predicting...")
# ---- Get embedding matrix
emb_matrix = word2vec_model_infer.predict(
np.arange(0, len(emb)), batch_size=FLAGS.word2vec_batch_size)
logging.info('emb_matrix.shape = %s', emb_matrix.shape)
# -- Test Task 1
def run_test_task_1(dw_pair, lang_target_candidate_set):
desc_iter = DescIterator(
DescCorpus(dw_pair),
desc_length=FLAGS.encoder_desc_length,
batch_size=FLAGS.encoder_batch_size,
shuffle=False,
epochs=1,
)
desc_embedded = []
for batch in desc_iter.iter(is_inference=True):
r = encoder_model_infer.predict_on_batch(batch)
desc_embedded.append(r)
desc_embedded = np.concatenate(desc_embedded)
desc_target = [_[1] for _ in dw_pair]
def get_knn(embedded, emb_matrix, candidate_set):
r = []
for id_ in candidate_set:
dist = np.linalg.norm(embedded - emb_matrix[id_])
r.append((dist, id_))
r.sort()
return [_[1] for _ in r]
def get_rank(target, candidates):
rank = 0
while candidates[rank] != target and rank + 1 < len(candidates):
rank += 1
assert candidates[rank] == target
return rank + 1 # starting from 1
hits_key = [1, 10, 100]
hits_counter = defaultdict(int)
total = 0
mrr = []
for embedeed, target in tqdm(zip(desc_embedded, desc_target),
desc='test sents'):
total += 1
assert target in lang_target_candidate_set
plist = get_knn(
embedeed,
emb_matrix,
lang_target_candidate_set,
)
for hits in hits_key:
hits_counter[hits] += int(target in plist[:hits])
mrr.append(1.0 / get_rank(target, plist))
hits_ratio = [1.0 * hits_counter[hits] / total for hits in hits_key]
return hits_counter, hits_ratio, np.mean(mrr)
lang_01_result = run_test_task_1(dw_pair_test_01, lang1_candidate_set)
lang_10_result = run_test_task_1(dw_pair_test_10, lang0_candidate_set)
print('TASK 1:')
fout = open(join(FLAGS.model_root, 'test_task_1.txt'), 'w')
def dual_print(*args):
print(*args)
print(*args, file=fout)
dual_print('LANG 0 sent -> LANG 1 word')
dual_print(lang_01_result[0])
dual_print(lang_01_result[1])
dual_print(lang_01_result[2])
dual_print('LANG 1 sent -> LANG 0 word')
dual_print(lang_10_result[0])
dual_print(lang_10_result[1])
dual_print(lang_10_result[2])
fout.close()
# -- Run test task 2 (paraphrasing)
def desc_to_ids(desc, lang_id):
r = emb.encode(
[_.lower() for _ in desc.split()],
lang_id=lang_id,
)
r = [_ for _ in r if _ != -1]
return r
def load_suite(filepath):
lang0_d, lang1_d, target, n = [], [], [], 0
for line in tqdm(
csv.reader(
open(filepath, newline=''),
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL,
),
desc=('Loading paraphrase from %s' % filepath),
):
lang0_d.append(desc_to_ids(line[0], lang_id=0))
lang1_d.append(desc_to_ids(line[1], lang_id=1))
target.append(float(line[2]))
n += 1
desc_length = FLAGS.encoder_desc_length
def get_embedded_sent(d):
sent = np.zeros(shape=(n, desc_length), dtype=np.int32)
mask = np.zeros(shape=(n, desc_length), dtype=np.float32)
for i in range(n):
this_d = d[i][:desc_length]
lth = len(this_d)
sent[i, :lth] = this_d
mask[i, :lth] = 1.0
embedded = encoder_model_infer.predict(
[sent, mask], batch_size=FLAGS.encoder_batch_size)
return embedded
lang0_embedded = get_embedded_sent(lang0_d)
lang1_embedded = get_embedded_sent(lang1_d)
result_d, result_w, result_w1d = [], [], []
for i in range(n):
result_d.append([lang0_embedded[i], lang1_embedded[i]])
result_w.append([target[i], 1 - target[i]])
result_w1d.append(target[i])
result_d = np.array(result_d)
result_w = np.array(result_w)
result_w1d = np.array(result_w1d, dtype='int32')
# import pdb
# pdb.set_trace()
return result_d, result_w, result_w1d
train_d, train_w, train_w1d = load_suite(
join(FLAGS.data_root, FLAGS.lang01_paraphrase_train_file))
test_d, _, test_w = load_suite(
join(FLAGS.data_root, FLAGS.lang01_paraphrase_test_file))
'''
print('train_d.shape', train_d.shape)
print('train_w.shape', train_w.shape)
print('train_w1d.shape', train_w1d.shape)
print('test_d.shape', test_d.shape)
print('test_w.shape', test_w.shape)
'''
encode_train1 = train_d[:, 0]
encode_train2 = train_d[:, 1]
assert (len(encode_train1) == len(train_w))
diff_train = np.array([
encode_train1[i] - encode_train2[i] for i in range(len(encode_train1))
])
dist_train = np.array([[np.linalg.norm(x)] for x in diff_train])
encode_test1 = test_d[:, 0]
encode_test2 = test_d[:, 1]
diff_test = np.array(
[encode_test1[i] - encode_test2[i] for i in range(len(encode_test1))])
dist_test = np.array([[np.linalg.norm(x)] for x in diff_test])
def match(pred, t):
#if (len(pred.shape)) > 1:
#pred = pred[0]
if (pred > 0.5 and t < 0.5) or (pred < 0.5 and t > 0.5):
return 0.
return 1.
logging.info('Fitting LR')
logreg = LR()
logreg.fit(dist_train, train_w1d)
lr_rst = logreg.predict(dist_test)
lr_accuracy = 0.
for i in range(len(lr_rst)):
lr_accuracy += match(lr_rst[i], test_w[i])
lr_accuracy /= len(lr_rst)
logging.info('fitting MLP')
mlp = MLP(hidden_layer_sizes=[25, 13])
mlp.fit(diff_train, train_w1d)
mlp_rst = mlp.predict(diff_test)
mlp_accuracy = 0.
for i in range(len(mlp_rst)):
mlp_accuracy += match(mlp_rst[i], test_w[i])
mlp_accuracy /= len(mlp_rst)
print('TASK 2:')
fout = open(join(FLAGS.model_root, 'test_task_2.txt'), 'w')
def dual_print(*args):
print(*args)
print(*args, file=fout)
dual_print('LR accuracy', lr_accuracy)
dual_print('MLP accuracy', mlp_accuracy)
fout.close()
file = open('../data/pima-indians-diabetes-database/diabetes.csv')
all_data = list(csv.reader(file))
data_size = len(all_data) - 1
max_dim = 8 #max number of dimensions plus 1
train_frac = 0.6
val_frac = 0.2
test_frac = 0.2
(x_train, y_train), (x_val, y_val), (x_test,
y_test) = process(all_data, train_frac,
val_frac, test_frac)
nn = MLP()
print(x_train.shape)
print(y_train.shape)
nn.fit(x_train, y_train)
real_train_acc = accuracy_score(nn.predict(x_train), y_train)
real_test_acc = accuracy_score(nn.predict(x_test), y_test)
train_acc = []
test_acc = []
for dim in range(1, max_dim):
pca = PCA(n_components=dim)
pca.fit(x_train)
reduced_x_train = np.array(pca.transform(x_train))
reduced_x_test = np.array(pca.transform(x_test))
nn = MLP()
nn.fit(reduced_x_train, y_train)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend(loc="lower right")
plt.show()
report_with_auc = class_report(y_true=Y_test, y_pred=preds)
print("Report", report_with_auc)
print("KNN accuracy", accknn)
mlp = MLP(hidden_layer_sizes=(100),
activation='logistic',
solver='adam',
random_state=42,
verbose=True,
max_iter=200)
mlp.fit(X_train, Y_train)
preds = mlp.predict(X_test)
accmlp = accuracy_score(preds, Y_test)
for i in Y_test:
fpr, tpr, _ = roc_curve(Y_test, preds)
roc_auc = auc(fpr, tpr)
fig = plt.figure()
lw = 2
plt.plot(fpr,
tpr,
color='darkorange',
lw=lw,
winner = (calendar[ii], calendar[ii].winner)
loser = (calendar[ii], calendar[ii].loser)
pre_predict = [calendar[ii].lrank - calendar[ii].wrank, calendar[ii].welo-calendar[ii].lelo, calendar[ii].welosur-calendar[ii].lelosur, surf_into_num[calendar[ii].surface], \
round(wins_percent(*winner) - wins_percent(*loser), 3), round(wins_per_surface(*winner) - wins_per_surface(*loser), 3), \
round(av_first_serve(*winner) - av_first_serve(*loser), 3), round(av_first_serve_surface(*winner) - av_first_serve_surface(*loser), 3), \
round(av_second_serve(*winner) - av_second_serve(*loser), 3), round(av_second_serve_surface(*winner) - av_second_serve_surface(*loser), 3), \
round(av_first_return(*winner) - av_first_return(*loser), 3), round(av_first_return_surface(*winner) - av_first_return_surface(*loser), 3), \
round(av_second_return(*winner) - av_second_return(*loser), 3), round(av_second_return_surface(*winner) - av_second_return_surface(*loser), 3), \
round(av_aces(*winner) - av_aces(*loser), 3), round(av_aces_surface(*winner) - av_aces_surface(*loser), 3), \
round(av_dfs(*winner) - av_dfs(*loser), 3), round(av_dfs_surface(*winner) - av_dfs_surface(*loser), 3), \
round(av_bps(*winner) - av_bps(*loser), 3), round(av_bps_surface(*winner) - av_bps_surface(*loser), 3)]
to_predict = scaler.transform([pre_predict])
clf = MLP(random_state=7,
solver='lbfgs',
hidden_layer_sizes=(12, ),
activation='logistic',
alpha=1e-3)
clf.fit(X, Y)
#print(round(clf.score(X_test, y_test), 3))
#predictions = []
#probas = []
#for match in X_test:
# predictions.append(clf.predict([match])[0])
# probas.append(clf.predict_proba([match])[0])
#predictions = np.array(predictions)
#probas = np.array(probas)
#print("roi1: {}%".format(int(round(100*roi_1(predictions), 0))))
cur_char = np.array([float(x) for x in list_vals[start:end]])
data.append(cur_char)
if len(data) >= num_data:
break
# In[ ]:
data_r=(np.array(data).reshape(50,128))
labels_r=np.array(labels).reshape(50,num_orig_labels)
labels_r[0].shape
data_train=data_r[:num_train]
data_test=data_r[num_train:]
labels_train=labels_r[:num_train]
labels_test=labels_r[num_train:]
# In[130]:
from sklearn.neural_network import MLPClassifier as MLP
nn=MLP(hidden_layer_sizes=(128,16,num_orig_labels),max_iter=20000,tol=0.01)
nn=nn.fit(data_train,labels_train)
nn.score(data_test,labels_test)
def supervised_stratified(x_tr, y_tr, x_ts, y_ts, lea):
acc = []
f1 = []
for i in range(0, len(y_ts)):
lea.fit(x_tr[i], y_tr[i])
prec, rec, ff1, sup = precision_recall_fscore_support(y_ts[i], lea.predict(x_ts[i]), average='weighted')
acc.append(lea.score(x_ts[i] ,y_ts[i]) * 100)
f1.append(ff1 * 100)
#print acc
return np.mean(acc) , np.std(acc), np.mean(f1) , np.std(f1)
rf_super = RandomForestClassifier(n_estimators = 100, class_weight = 'balanced', random_state = 23) #'balanced_subsample')
ext_super = EXT(n_estimators=100, class_weight = 'balanced', random_state = 23)
nb_super = NB()
knn_super = KNN()
mlp_super = MLP(random_state = 23)
rf_upper_bound = np.mean(cross_val_score( rf_super, X, y, cv = 3)) * 100
nb_upper_bound = np.mean(cross_val_score( nb_super, X, y, cv = 3)) * 100
knn_upper_bound = np.mean(cross_val_score( knn_super, X, y, cv = 3)) * 100
ext_upper_bound = np.mean(cross_val_score( ext_super, X, y, cv = 3)) * 100
mlp_upper_bound = np.mean(cross_val_score( ext_super, X, y, cv = 3)) * 100
sss = StratifiedShuffleSplit(n_splits = 3, test_size = 0.1, random_state = 23)
x_tr, y_tr, x_ts, y_ts = [], [], [], []
for train_index, test_index in sss.split(X, y):
X_train, X_test = X.loc[train_index], X.loc[test_index]
y_train, y_test = y.loc[train_index], y.loc[test_index]
x_tr.append(X_train)
y_tr.append(y_train)
for x in n_features:
if x != 103:
pca = decomposition.PCA(n_components=x)
train_X = pca.fit_transform(Train_X)
test_X = pca.transform(Test_X)
else:
train_X = Train_X
test_X = Test_X
print(test_X.shape)
print(train_X.shape)
##print(n_classes)
mlp = MLP(hidden_layer_sizes=(128, 64),
batch_size=64,
alpha=0.001,
learning_rate_init=0.001,
epsilon=1e-05,
max_iter=500)
mlp.fit(train_X, train_Y)
pred = mlp.predict(test_X)
pred = pred.argmax(axis=1)
c_matrix = confusion_matrix(test_Y, pred)
print(c_matrix)
accuracy = accuracy_score(test_Y, pred)
print('Accuracy : ', accuracy)
a.append(accuracy)
#precision = true positive / total predicted positive(True positive + False positive)
#recall = true positive / total actual positive(True positive + False Negative)
print(classification_report(test_Y, pred))
x = int(input())
scores = ['average_precision', 'recall', 'f1', 'accuracy']
for score in scores:
print("# Tuning hyper-parameters for %s" % score)
print()
if (x == 1):
clf = GridSearchCV(DTC(),
DTC_tuned_parameter,
cv=5,
scoring='%s' % score)
elif (x == 2):
clf = GridSearchCV(MLP(),
MLP_tunned_parameter,
cv=5,
scoring='%s' % score)
elif (x == 3):
clf = GridSearchCV(SVC(),
SVC_tuned_parameters,
cv=5,
scoring='%s' % score)
elif (x == 4):
clf = GridSearchCV(NB(),
NB_tuned_parameter,
cv=7,
scoring='%s' % score)
elif (x == 5):
clf = GridSearchCV(LR(),
y = npXy[:, -1]
# Normalize data
X = ((X - np.min(X, 0)) / (np.max(X, 0) - np.min(X, 0) + .0001))
shuffleX, shuffley = shuffle_data(X, y)
trainX = shuffleX[:int(.8 * len(X)), :]
trainy = shuffley[:int(.8 * len(y))]
#validX = trainX[:int(.15 * len(X)), :]
#validy = trainy[:int(.15 * len(y))]
testX = shuffleX[int(.8 * len(X)):, :]
testy = shuffley[int(.8 * len(y)):]
mMadness = MLP(random_state=0, hidden_layer_sizes=(15, 15), activation='identity',
alpha=.0001, learning_rate_init=.2, max_iter=30).fit(trainX, trainy)
lossCurve = mMadness.loss_curve_
predictions = mMadness.predict(testX)
MSE = sum([(int(predictions[i]) - testy[i]) ** 2 for i in range(len(predictions))]) / len(predictions)
score = mMadness.score(testX, testy)
MSEs.append(MSE)
scores.append(score)
print(f)
print("MSE: " + str(MSE))
print("Score: " + str(score))
print()
plt.plot(range(len(lossCurve)), lossCurve, label=str(n + 2000))
avgMSE = sum(MSEs)/len(MSEs)
def __init__(self, link, position):
super().__init__(link, position, MLP())
def main():
# for i in range(100):
overall_time = time.time()
# Prepare the labels for TRAF videos.
# 0 # impatient
# 1 # threatening
# 2 # reckless
# 3 # careful
# 4 # timid
# 5 # cautious
dataset = 'argo'
nbrs = 4
if not os.path.exists('laps_and_embs/lap.npy') or not os.path.exists(
'laps_and_embs/argo_lap.npy'):
# convert TRAF file into list of dicts. Indexing of the list corresponds to the frames, ...
# and each dict consits of key:value pairs where keys refers to the IDs in the frame, ...
# and the values for each ID is the X-Y position
video = []
video_list_output = []
if dataset == 'traf':
data_path = 'data/behavior_data/'
labels_list = generate_labels(data_path)
np.save('labels', labels_list)
video_list = [
'TRAF53_1', 'TRAF53_2', 'TRAF53_5', 'TRAF53_6', 'TRAF53_7',
'TRAF53_8', 'TRAF53_9', 'TRAF29'
]
for i in range(len(video_list)):
video_path = 'data/behavior_data_gt/' + video_list[
i] + '_gt.txt'
video = []
with open(video_path) as file:
lines = file.readlines()
for line in lines:
toks = line.split(',')
dict_item = {}
for i in range(int(toks[1])):
dict_item[int(toks[5 * i + 6])] = [
int(toks[5 * i + 2]),
int(toks[5 * i + 3])
]
video.append(dict_item)
video_list_output.append(video)
# List of adjacency matrices corresponding to each TRAF video
Adjacency_Matrices = computeA(video_list_output, labels_list, nbrs,
dataset)
# List of lists: Each element of the list corresponds to a list of [L_1,L_2,...,L_T] for each TRAF video
Laplacian_Matrices = extractLi(Adjacency_Matrices)
np.save('laps_and_embs/lap', Laplacian_Matrices)
elif dataset == 'argo':
video_list = ['ARGO1', 'ARGO2']
data_argo = np.load('data/argo/argo_data.npy', allow_pickle=True)
labels_argo = np.load('data/argo/argo_labels.npy',
allow_pickle=True)
# List of adjacency matrices corresponding to each TRAF video
Adjacency_Matrices = computeA(data_argo, labels_argo, nbrs,
dataset)
# List of lists: Each element of the list corresponds to a list of [L_1,L_2,...,L_T] for each TRAF video
Laplacian_Matrices = extractLi(Adjacency_Matrices)
np.save('laps_and_embs/argo_lap', Laplacian_Matrices)
# ===================================MAIN ALGORITHM==================================================
if not os.path.exists('laps_and_embs/emb.npy') or not os.path.exists(
'laps_and_embs/argo_emb.npy'):
# time_start_all = time.time ()
Laplacian_Matrices = np.load(
'laps_and_embs/lap.npy',
allow_pickle=True) if dataset == 'traf' else np.load(
'laps_and_embs/argo_lap.npy', allow_pickle=True)
U_Matrices = []
from scipy import linalg as LA
for Lis_for_each_video in Laplacian_Matrices:
time_start_all = time.time()
# ListofUs = []
for L_index, L in enumerate(Lis_for_each_video):
if first_laplacian(L_index):
Lambda_prev, U_prev = la.eig(L) # need top k eigenvectors
Lambda_prev = np.diag(np.real(Lambda_prev))
# Lambda_prev = Lambda_prev[0:10,0:10]
U_prev = np.real(U_prev)
else:
U_curr, Lambda = GraphRQI(U_prev, Lis_for_each_video,
L_index, Lambda_prev)
Lambda_prev = Lambda
# ListofUs.append(U_curr)
U_prev = U_curr[-1]
# Daeig , Va , X = LA.svd ( L , lapack_driver='gesvd' )
print("time for computing spectrum for one video: ",
(time.time() - time_start_all))
U_Matrices.append(U_curr[0])
# embedding = np.hstack ( U_Matrices )
# embedding = embedding.T
np.save('laps_and_embs/emb',
U_Matrices) if dataset == 'traf' else np.save(
'laps_and_embs/argo_emb', U_Matrices)
# =========================================ML==================================================
all_embedding = np.load(
'laps_and_embs/emb.npy',
allow_pickle=True) if dataset == 'traf' else np.load(
'laps_and_embs/argo_emb.npy', allow_pickle=True)
# embedding = pad(all_embedding)
# sheets_label = ['c1.xlsx','c2.xlsx','c8.xlsx','r5.xlsx','r6.xlsx','r7.xlsx','u8.xlsx','u9.xlsx']
# video_list = [ 'TRAF53_1' , 'TRAF53_2' , 'TRAF53_5' , 'TRAF53_6' , 'TRAF53_7' , 'TRAF53_8' , 'TRAF53_9' , 'TRAF29' ]
labels_list = np.load('laps_and_embs/labels.npy',
allow_pickle=True) if dataset == 'traf' else np.load(
'data/argo/argo_labels.npy', allow_pickle=True)
labels = []
index = 0
# for index in [0,1,2,3,4,5,7]:
if dataset == 'traf':
for j in range(len(labels_list[index])):
labels.append(list(labels_list[index][j].values())[0])
else:
for j in range(len(labels_list[index])):
labels.append(labels_list[index][j][1])
# for i,sheet_label in enumerate(sheets_label):
# spath = 'data/behavior_data/'+sheet_label
# df = pd.read_excel ( spath )
# behavior_gt = df.as_matrix ()
# prev_labels = list ( behavior_gt[ : , 2 ] )
# # labels= labels + [''] * (max_ID - len(labels))
# [ prev_labels.append ( 0 ) for i in range ( max_ID-1 - len ( prev_labels ) ) ]
# if i == 0:
# curr_labels = np.array ( prev_labels )
# else:
# curr_labels = np.vstack((curr_labels,np.array(prev_labels)))
# print(Counter(labels))
# embedding = preprocessing.scale ( embedding )
embedding = all_embedding[index]
[labels.append(0) for i in range(embedding.shape[0] - len(labels))]
Xtrain, Xtest = train_test_split(embedding, test_size=0.1)
ytrain, ytest = train_test_split(labels, test_size=0.1)
# Xtrain = embedding[0:800,:]
# ytrain = labels[:,0:800].T
# Xtest = embedding[800:,:]
# ytest = labels[:,800:].T
lr = LogisticRegression(max_iter=1)
mlp = MLP(hidden_layer_sizes=(10, 50), max_iter=4000)
clf = svm.SVC(max_iter=100)
#
iters = 1
score = 0
for _ in range(iters):
#
# lr.fit(Xtrain, ytrain)
# y_pred = lr.predict(Xtest)
# score += lr.score(Xtest, ytest)
mlp.fit(Xtrain, ytrain)
y_pred = mlp.predict(Xtest)
score += mlp.score(Xtest, ytest)
# clf.fit ( Xtrain , ytrain )
# y_pred = clf.predict ( Xtest )
# score += clf.score ( Xtest , ytest )
print(time.time() - overall_time)
print(score / iters)
from sklearn.metrics import multilabel_confusion_matrix
# cm = confusion_matrix ( ytest , y_pred )
cm = multilabel_confusion_matrix(ytest, y_pred, labels=[0, 1, 2, 3, 4, 5])
# print ( cm )
f = []
e = embedding[:, 70]
e = e.tolist()
for i, el in enumerate(e):
if i < 3 or i > 14:
f.append(0)
else:
f.append(e[i])
plt.plot(e, linewidth=16, alpha=0.8)
plt.plot(range(3, 14), f[3:14], c='black', linewidth=8)
# plt.plot ( range ( 64 , 70 ) , e[ 64:70 ] , c='black' , linewidth=8 )
gca().set_xticklabels([''] * len(e))
gca().set_yticklabels([''] * len(e))
#Import required modules from sklearn.datasets import load_boston from sklearn.neural_network import MLPRegressor as MLP from sklearn.metrics import mean_absolute_error,mean_squared_error import matplotlib.pyplot as plt #Load Dataset data=load_boston() X=data.data y=data.target #Configure Multilayer Perceptron,Train,Predict mlp=MLP(solver='lbfgs',hidden_layer_sizes=(800),activation='tanh',max_iter=2000,verbose=True) mlp.fit(X,y) p=mlp.predict(X) #Result print "\n Mean Squared Error : ",mean_squared_error(p,y) print "\n Mean Absolute Error : ",mean_absolute_error(p,y) plt.scatter(y,p) plt.show()
def train(self, X, Y):
clf = MLP(hidden_layer_sizes=(100, 50),
solver='adam',
alpha=1e-5,
learning_rate_init=0.01)
return clf.fit(X, Y)
def Find_Optimal_Features(ML_DATA):
# Creates all combinations of features
lst = list(itertools.product([0, 1], repeat=8))
lst.remove((0, 0, 0, 0, 0, 0, 0, 0))
for i in range(len(lst)):
lst[i] = list(lst[i])
outs = []
for i in range(8):
outs.append([])
# Clasifiers put into array for easier access and expandability
clfs = [
DTC(),
KNN(),
BC(ETC()),
LSVC(max_iter=10_000),
RFC(),
SVC(),
SGDC(),
MLP(max_iter=10_000)
]
tot = len(lst)
y = []
# Trains all models on all feature sets and gets scores
for i, item in enumerate(lst[:15]):
X_train, ys_train, ya_train, X_test, ys_test, ya_test = ML_DATA.Make_Set(
item, 0.25)
for item in clfs:
item.fit(X_train, ys_train)
scores = []
for j, item in enumerate(clfs):
scores.append(item.score(X_test, ys_test))
outs[j].append(scores[j])
PBR(i + 1, tot, name="Test Set", end="\r")
y = ys_test
print()
temp = Counter(y)
total = len(y)
rand_ratio = 0
for item in temp.values():
rand_ratio += item / total
rand_ratio = (rand_ratio / 8) * 100
print("Random Choice :", rand_ratio)
final = np.zeros(8)
final_top = np.zeros(8)
final_btop = np.zeros(8)
names = [
"Decision Tree", "KNN", "Bag Extra Tree", "Linear SVC",
"Random Forest", "SVC", "SGDC", "MLP"
]
# Prints all results
for k, name in enumerate(names):
o = RAS(outs[k], 10)
final_top += np.asarray(lst[o[0]])
f = np.zeros(8)
count = 0
best = outs[k][0]
print(name + ":")
for i, item in enumerate(o):
if i == 0:
best = outs[k][item]
print("\t\t{:2}) {:7.4f}% {}".format(i, outs[k][item] * 100,
lst[item]))
if outs[k][item] == best:
count += 1
f += np.asarray(lst[item])
final += np.asarray(lst[item])
final_btop += f / count
print()
print(final)
print(final_top)
print(final_btop)
interval = [0.1,0.5,1,5,10,30]
pred_results = []
for i in range(6):
num = int(interval[i]*10)
X = np.array(data[['best_ask_size','best_bid_size','ask_total_size','bid_total_size','ask_weighted_average_price',
'bid_weighted_average_price','best_ask_price','best_bid_price']])
Y = np.array(data['output_%s'%interval[i]])
sample = len(X)
train_num = int(sample*0.7)
X = X[:-num]
Y = Y[:-num]
X_train = X[:train_num]
Y_train = Y[:train_num]
X_test = X[train_num:]
Y_test = Y[train_num:]
XOR_MLP = MLP(activation='relu', alpha=1e-05, batch_size='auto', early_stopping=False,
epsilon=1e-08, hidden_layer_sizes=(12,8,), learning_rate='constant',
learning_rate_init=0.001, max_iter=200, momentum=0.9,
nesterovs_momentum=True, power_t=0.5, random_state=1, shuffle=True,
solver='adam', tol=0.0001, validation_fraction=0.1, verbose=False,
warm_start=False)
XOR_MLP.fit(X_train,Y_train)
Y_pred = XOR_MLP.predict(X_test)
pred_results.append(Y_pred)
print(pred_results)
predictions = pd.DataFrame(pred_results).T
predictions.columns = ['output%s'%i for i in interval]
predictions.to_csv('predictions1.csv', encoding='utf-8', index=False)
def build_classifiers(exclude, scale, feature_selection, nCols):
'''
Input:
- exclude: list of names of classifiers to exclude from the analysis
- scale: True or False. Scale data before fitting classifier
- feature_selection: True or False. Run feature selection before
fitting classifier
- nCols: Number of columns in input dataset to classifiers
Output:
Dictionary with classifier name as keys.
- 'clf': Classifier object
- 'parameters': Dictionary with parameters of 'clf' as keys
'''
classifiers = collections.OrderedDict()
if 'Multilayer Perceptron' not in exclude:
classifiers['Multilayer Perceptron'] = {
'clf': MLP(),
'parameters': {
'hidden_layer_sizes': [(100, 50), (50, 25)],
'max_iter': [500]
}
}
if 'Nearest Neighbors' not in exclude:
classifiers['Nearest Neighbors'] = {
'clf': KNeighborsClassifier(),
'parameters': {
'n_neighbors': [1, 5, 10, 20]
}
}
if 'SVM' not in exclude:
classifiers['SVM'] = {
'clf':
SVC(C=1,
probability=True,
cache_size=10000,
class_weight='balanced'),
'parameters': {
'kernel': ['rbf', 'poly'],
'C': [0.01, 0.1, 1]
}
}
if 'Linear SVM' not in exclude:
classifiers['Linear SVM'] = {
'clf': LinearSVC(dual=False, class_weight='balanced'),
'parameters': {
'C': [0.01, 0.1, 1],
'penalty': ['l1', 'l2']
}
}
if 'Decision Tree' not in exclude:
classifiers['Decision Tree'] = {
'clf': DecisionTreeClassifier(max_depth=None, max_features='auto'),
'parameters': {}
}
if 'Random Forest' not in exclude:
classifiers['Random Forest'] = {
'clf':
RandomForestClassifier(max_depth=None,
n_estimators=10,
max_features='auto'),
'parameters': {
'n_estimators': list(range(5, 20))
}
}
if 'Logistic Regression' not in exclude:
classifiers['Logistic Regression'] = {
'clf':
LogisticRegression(fit_intercept=True,
solver='lbfgs',
penalty='l2'),
'parameters': {
'C': [0.001, 0.1, 1]
}
}
if 'Naive Bayes' not in exclude:
classifiers['Naive Bayes'] = {'clf': GaussianNB(), 'parameters': {}}
# classifiers['Voting'] = {}
def name(x):
"""
:param x: The name of the classifier
:return: The class of the final estimator in lower case form
"""
return x['clf']._final_estimator.__class__.__name__.lower()
for key, val in classifiers.items():
if not scale and not feature_selection:
break
steps = []
if scale:
steps.append(StandardScaler())
if feature_selection:
steps.append(SelectKBest(f_regression, k='all'))
steps.append(classifiers[key]['clf'])
classifiers[key]['clf'] = make_pipeline(*steps)
# Reorganize paramenter list for grid search
new_dict = {}
for keyp in classifiers[key]['parameters']:
new_dict[name(classifiers[key]) + '__' +
keyp] = classifiers[key]['parameters'][keyp]
classifiers[key]['parameters'] = new_dict
if nCols > 5 and feature_selection:
classifiers[key]['parameters']['selectkbest__k'] = np.linspace(
np.round(nCols / 5), nCols, 5).astype('int').tolist()
return classifiers
all_data = list(csv.reader(file))
data_size = len(all_data) - 1
train_frac = 0.6
val_frac = 0.2
test_frac = 0.2
(x_train, y_train), (x_val, y_val), (x_test, y_test) = process(all_data, train_frac, val_frac, test_frac)
n_samples = 200
maxc = 20 #maximum number of clusters plus 1
y_train = y_train.flatten()
print(y_train.shape)
nn = MLP()
nn.fit(x_train, y_train)
real_train_acc = accuracy_score(nn.predict(x_train), y_train)
real_test_acc = accuracy_score(nn.predict(x_test), y_test)
print("GMM")
# print(y_train[0])
# gmm = GaussianMixture(n_components=3)
# gmm.fit(x_train)
# gmm_x_train = gmm.predict_proba(x_train)
# gmm_x_val = gmm.predict_proba(x_val)
# gmm_x_test = gmm.predict_proba(x_test)
# print(gmm_x_train)
# print(y_train)
