from scipy.spatial import distance, distance_matrix
from sklearn import svm
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import KNNImputer
import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, recall_score, f1_score, roc_auc_score, make_scorer
from sklearn.model_selection import StratifiedShuffleSplit, train_test_split, KFold, GridSearchCV, RandomizedSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.utils import class_weight, shuffle, resample
from stability_selection import StabilitySelection, plot_stability_path
train_original = pd.read_csv("DataUsed/method23_real2.csv")
test_original = pd.read_csv("DataUsed/method23_real2_valid.csv")
df = train_original
# df.insert(3, "num2", num2)
targetIndex = -1
# df = df.iloc[pd.isna(df.iloc[:, targetIndex]).values == False, :]
# df = df.drop(columns=["Num1"])
vars = df.columns[range(len(df.columns) - 1)]
df = df.values
X = df[:, range(0, df.shape[1] - 1)]
Y = df[:, targetIndex]
base_estimator = Pipeline([
('scaler', StandardScaler()),
('model', LogisticRegression(penalty='l2'))
])
selector = StabilitySelection(base_estimator=base_estimator, lambda_name='model__C',
lambda_grid=np.logspace(-5, -1, 50)).fit(X, Y)
fig, ax = plot_stability_path(selector)
fig.show()
selected_variables = selector.get_support(indices=True)
selected_scores = selector.stability_scores_.mean(axis=1)
selectedFeatures = pd.DataFrame({"selectedVars": vars[selected_variables], "score": selected_scores[selected_variables]},index=vars[selected_variables])
selectedFeatures.plot(kind='barh')
selectedFeatures.to_excel("stabilityFeatureSelection.xlsx")
# print(selector.get_support(indices=True))
# X = X[:, selected_variables]
class1Data = X[Y == 1, :]
class2Data = X[Y == 0, :]
class1Target = Y[Y == 1]
class2Target = Y[Y == 0]
pipelines = []
res = []
split = 3
kf = KFold(n_splits=split)
fold = 1
trainIndexC1 = []
trainIndexC2 = []
testIndexC1 = []
testIndexC2 = []
targetTrainIndexC1 = []
targetTrainIndexC2 = []
targetTestIndexC1 = []
targetTestIndexC2 = []
for train_index, test_index in kf.split(class1Data):
trainIndexC1.append(train_index)
testIndexC1.append(test_index)
for train_index, test_index in kf.split(class2Data):
trainIndexC2.append(train_index)
testIndexC2.append(test_index)
for train_index, test_index in kf.split(class1Target):
targetTrainIndexC1.append(train_index)
targetTestIndexC1.append(test_index)
for train_index, test_index in kf.split(class2Target):
targetTrainIndexC2.append(train_index)
targetTestIndexC2.append(test_index)
def spScore(y_true, y_pred):
aucValue = roc_auc_score(y_true, y_pred)
rec = recall_score(y_true, y_pred)
return 100 * (2 * aucValue - rec)
for index in range(len(targetTestIndexC2)):
c1DataTrain, c1DataTest = class1Data[trainIndexC1[index], :], class1Data[testIndexC1[index], :]
c2DataTrain, c2DataTest = class2Data[trainIndexC2[index], :], class2Data[testIndexC2[index], :]
c1TargetTrain, c1TargetTest = class1Target[targetTrainIndexC1[index]], class1Target[targetTestIndexC1[index]]
c2TargetTrain, c2TargetTest = class2Target[targetTrainIndexC2[index]], class2Target[targetTestIndexC2[index]]
minorClassSize = c2DataTrain.shape[0]
for i in range(int(c1DataTrain.shape[0] / minorClassSize)):
X = np.append(class2Data, c1DataTrain[range(i * minorClassSize, (i + 1) * minorClassSize), :], axis=0)
X = np.append(X, c2DataTrain, axis=0)
CMS = np.append(class2Target, c1TargetTrain[range(i * minorClassSize, (i + 1) * minorClassSize)], axis=0)
CMS = np.append(CMS, c2TargetTrain, axis=0)
X_train, X_test, y_train, y_test = train_test_split(X, CMS, test_size=0.05, stratify=CMS)
# smt = SMOTETomek()
# tree_param = {'bootstrap': [True, False],
# 'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, None],
# 'max_features': ['auto', 'sqrt'],
# 'min_samples_leaf': [1, 2, 4],
# 'min_samples_split': [2, 5, 10],
# 'n_estimators': [200, 400, 600, 800, 1000, 1200, 1400, 1600]}
# grid = RandomizedSearchCV(estimator=RandomForestClassifier(), param_distributions=tree_param, n_iter=10, verbose=2, n_jobs=-1, scoring=make_scorer(roc_auc_score))
tree_param = {'criterion': ['gini', 'entropy'], 'max_depth': [5, 9, 20, 30, 40, 50, 70, 90, 120, 150]}
grid = GridSearchCV(DecisionTreeClassifier(), param_grid=tree_param, scoring=make_scorer(f1_score))
pipeline = pl.make_pipeline(grid)
class_weights = class_weight.compute_class_weight('balanced',
np.unique(CMS),
CMS)
accuracy = []
recall = []
fscore = []
auc = []
# sss = StratifiedShuffleSplit(n_splits=5, test_size=0.5, random_state=0)
# for train_index, test_index in sss.split(X, CMS):
# df_ = resample(X_all, n_samples=500, replace=False, stratify=y_train)
# y_ = np.round(df_[:, -1])
# df = df.select_dtypes(include=['float32', 'float64', 'int'])
# X_ = df_[:, 0:df_.shape[1] - 1:1]
# X_, y_ = ros.fit_sample(X_train, y_train)
# X_, y_ = rus.fit_sample(X_, y_)
X_, y_ = X_train, y_train
# X_, y_ = smt.fit_resample(X_train, y_train)
# X_, y_ = resample(X_, y_,stratify=y_,n_samples=1000)
# weights = np.zeros([1, len(y_)])
# weights[0, y_ == 0] = class_weights[0]
# weights[0, y_ == 1] = class_weights[1]
pipeline.fit(X_, y_)
pipelines.append(pipeline)
y_pred = pipeline.predict(X_test)
# acc = accuracy_score(y_pred, y_test)
# rec = recall_score(y_pred, y_test)
# f1Score = f1_score(y_pred, y_test)
# aucValue = roc_auc_score(y_pred, y_test)
# accuracy.append(acc)
# recall.append(rec)
# fscore.append(f1Score)
# auc.append(aucValue)
#
# print("Acc: {}".format(acc))
# print("recal: {}".format(rec))
# print("f1Score:{}".format(f1Score))
# print("AUC : {}".format(aucValue))
Xtrain = np.append(c2DataTrain, c1DataTrain, axis=0)
CMSTrain = np.append(c2TargetTrain, c1TargetTrain, axis=0)
X = np.append(c2DataTest, c1DataTest, axis=0)
CMS = np.append(c2TargetTest, c1TargetTest, axis=0)
y_pred_train_all = np.zeros([CMSTrain.shape[0], len(pipelines)])
y_pred_test_all = np.zeros([CMS.shape[0], len(pipelines)])
for i, pipelineItem in enumerate(pipelines):
y_pred_train_all[:, i] = pipelineItem.predict(Xtrain)
y_pred_test_all[:, i] = pipelineItem.predict(X)
class_weights = class_weight.compute_class_weight('balanced',
np.unique(CMSTrain),
CMSTrain)
weights = np.zeros([1, len(CMSTrain)])
weights[0, CMSTrain == 0] = class_weights[0]
weights[0, CMSTrain == 1] = class_weights[1]
# param_grid = dict(scale_pos_weight=[1, 10, 25, 50, 75, 99, 100, 1000, 10000])
tree_param = {'criterion': ['gini', 'entropy'], 'max_depth': [4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 20, 30, 40, 50, 70, 90, 120, 150]}
# tree_param = {'bootstrap': [True, False],
# 'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, None],
# 'max_features': ['auto', 'sqrt'],
# 'min_samples_leaf': [1, 2, 4],
# 'min_samples_split': [2, 5, 10],
# 'n_estimators': [200, 400, 600, 800, 1000, 1200, 1400, 1600]}
# grid = RandomizedSearchCV(estimator=RandomForestClassifier(), param_distributions=tree_param, n_iter=20, verbose=2, n_jobs=-1, scoring=make_scorer(roc_auc_score))
grid = GridSearchCV(DecisionTreeClassifier(), param_grid=tree_param, scoring=make_scorer(f1_score))
# grid = GridSearchCV(estimator=XGBClassifier(), param_grid=param_grid, n_jobs=-1, scoring=make_scorer(roc_auc_score))
grid.fit(np.append(y_pred_train_all, Xtrain, axis=1), CMSTrain)
y_pred_test = grid.predict(np.append(y_pred_test_all, X, axis=1))
# y_pred_test = y_pred_test_all[:,0]
acc = accuracy_score(y_pred_test, CMS)
rec = recall_score(y_pred_test, CMS)
f1Score = f1_score(y_pred_test, CMS)
aucValue = roc_auc_score(y_pred_test, CMS)
# accuracy.append(acc)
# recall.append(rec)
# fscore.append(f1Score)
# auc.append(aucValue)
res.append(pd.DataFrame({"target": CMS, "prediction": y_pred_test}))
if fold == split:
with pd.ExcelWriter('resultFolds.xlsx') as writer:
for kk in range(len(res)):
res[kk].to_excel(writer, sheet_name='Fold{}'.format(kk))
fold = fold + 1
print("Test ==============================")
print("Test Acc: {}".format(acc))
print("Test recal: {}".format(rec))
print("Test f1Score:{}".format(f1Score))
print("Test AUC : {}".format(aucValue))
print("************************************************")
continue
Datasets
Models
