def predict_image(classifier, test_histogram_of_features):
'''
To predict the test image with classifier
Parameters
----------
classifier : object
Classifier object after being trained with normalized histogram
of features
test_histogram_of_features : ndarray
Array containing all histogram of features from test image
train_names : list
List containing the names of image classes available
Returns
-------
str
Image prediction result of the test image
'''
id = classifier.predict(test_histogram_of_features)
y = np.array([0, 2, 1, 0, 0, 1, 2, 0, 2, 1])
print(id)
print(y)
acc = ac(id, y) * 100
print('accuracy: ', acc, '%')
def SVMEvaluation(self, y_dev, X_dev):
# obtenemos precision, recall y f1 comparando el gold standard (y_dev) con las predicciones
predicted = self.model.predict(X_dev)
bPrecis, bRecall, bFscore, bSupport = pr(y_dev, predicted, average='macro')
# mostramos resultados
bAcuracy = ac(y_dev, predicted)
print(classification_report(y_dev, predicted))
print(bAcuracy,bPrecis,bRecall,bFscore)
def evaluate(pred_vals, true_vals, pred_prob):
precision, recall, thresholds = metrics.precision_recall_curve(
true_vals, pred_prob)
return [
mcc(true_vals, pred_vals),
metrics.f1_score(true_vals, pred_vals),
metrics.precision_score(true_vals, pred_vals),
ac(true_vals, pred_vals),
metrics.roc_auc_score(true_vals, pred_prob),
metrics.auc(recall, precision)
]
def dataTest(model_dir, test_generator, test_size, input_num, dims_num,
batch_size):
model = load_model(model_dir,
custom_objects={
'auc': auc,
'binary_PFA': binary_PFA,
'binary_PTA': binary_PTA
})
labels_pre = []
labels_true = []
batch_num = test_size // batch_size + 1
steps = 0
for batch, labels in test_generator:
if len(labels) == batch_size:
labels_pre.extend(model.predict_on_batch(batch))
else:
batch = np.concatenate(
(batch,
np.zeros((batch_size - len(labels), input_num, dims_num))))
labels_pre.extend(model.predict_on_batch(batch)[0:len(labels)])
labels_true.extend(labels)
steps += 1
print("%d/%d batch" % (steps, batch_num))
labels_pre = np.array(labels_pre).round()
def to_y(labels):
y = []
for i in range(len(labels)):
if labels[i][0] == 1:
y.append(0)
else:
y.append(1)
return y
y_true = to_y(labels_true)
y_pre = to_y(labels_pre)
precision = precision_score(y_true, y_pre)
recall = recall_score(y_true, y_pre)
accuracy = accuracy_score(y_true, y_pre)
f1 = f1_score(y_true, y_pre)
print("Precision score is :", precision)
print("Recall score is :", recall)
print("Accuracy score is : ", accuracy)
print("F1 score is : ", f1)
fpr, tpr, thresholds = roc_curve(y_true, y_pre)
roc_auc = ac(fpr, tpr)
print("FP rate is :", fpr)
print("TP rate is :", tpr)
print("Roc_AOC is :", roc_auc)
axs[1, 4].set_title('alcohol')
y = df["quality"]
df = df.drop(columns="quality")
x = df
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.15)
from sklearn import neighbors
from sklearn.metrics import accuracy_score as ac
from sklearn.metrics import confusion_matrix
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
lda = LDA(n_components=1)
x_train = lda.fit_transform(x_train, y_train)
x_test = lda.fit_transform(x_test, y_test)
temp, var = 0, 0
ans = []
from sklearn.ensemble import RandomForestClassifier as RFC
for i in range(1, 20):
cl = RFC(max_depth=i, random_state=0)
cl.fit(x_train, y_train)
y_pred = cl.predict(x_test)
if (temp < ac(y_pred, y_test)):
temp = ac(y_pred, y_test)
var = i
ans = y_pred
print(str(temp) + " " + str(var))
print(confusion_matrix(y_pred, y_test))
gaps = np.abs(result[:, 0] - tmp_y)
MEAN = mean_and_std.loc[data.columns[0], "Mean"]
STD = mean_and_std.loc[data.columns[0], "Std"]
N = attribute_N.loc[data.columns[0], "N"]
label = data.iloc[299: -1, 1].values
y_pred = [1 if gap > MEAN + N*STD else 0 for gap in gaps]
# 打印单维预测信息
aims[299:-1, read_file_list.index(file)] = y_pred
y_pred = filter(y_pred)
print("---------------------")
print(data.columns[0], " 调整之后的预测精度展示：")
print("N = ", N)
print("mean = ",MEAN)
print("std = ",STD)
print("Test acc score: {:.6f}".format(ac(label, y_pred)))
print("Test p score: {:.6f}".format(p(label, y_pred)))
print("Test r score: {:.6f}".format(r(label, y_pred)))
print("confusion matrix:")
print(confusion_matrix(label, y_pred))
# 计算并存储最后一个阈值
source_label = source_label
aims = np.sum(aims, axis=1)
f = open('./data/end_N.txt')
end_N = int(float(f.read()))
f.close()
# f1分数
end_N = 5
aim_label = [1 if aim > end_N else 0 for aim in aims]
print("训练集样本大小为：", train_x.shape[0])
print("训练集正常样本大小为：", train_x.shape[0] - np.sum(train_y))
print("训练集异常样本大小为：", np.sum(train_y))
print("测试集样本大小为：", test_x.shape[0])
print("测试集正常样本大小为：", test_x.shape[0] - np.sum(test_y))
print("测试集异常样本大小为：", np.sum(test_y))
# 训练并保存模型
k_means = KMeans(n_clusters=2)
k_means.fit(train_x, train_y)
joblib.dump(k_means, "kmeans_model.pkl")
# 预测
y_pred = k_means.predict(test_x)
print("--------------------")
print("预测结果为：")
print("Test acc score: {:.6f}".format(ac(test_y, y_pred)))
print("Test p score: {:.6f}".format(p(test_y, y_pred)))
print("Test r score: {:.6f}".format(r(test_y, y_pred)))
print("confusion matrix:")
print(confusion_matrix(test_y, y_pred))
'''
预测结果为：
Test acc score: 0.549053
Test p score: 0.023267
Test r score: 0.416620
confusion matrix:
[[76638 62088]
[ 2071 1479]]
'''
train_x, train_y = final_data(list_image_count, train_x, train_y)
for i in train_y:
if i==1:
x=np.array([0,1])
t.append(x)
if i==0:
x=np.array([1,0])
t.append(x)
train_y = np.array(temp)
model = Sequential()
model.add(Conv2D(32, strides=2, kernel_size=(3,3), activation='relu', input_shape=(210,160,5)))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(64, strides=2, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(2048, activation='relu'))
model.add(Dense(2, activation='softmax'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(final_train_data_x, final_train_data_y_ohe)
pred_y = model.predict(final_train_data_x)
pred_y=pred_y.astype(int)
accuracy = ac(final_train_data_y_ohe, pred_y)
print('Accuracy :', accuracy)
model.save('final_model')
#model = load_model('my_model.h5')
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test_cal, y_pred_lg)
# In[48]:
print('confusion_matrix')
print(cm)
# In[49]:
from sklearn.metrics import accuracy_score as ac
# In[50]:
accuracy_logistic_calibration = ac(y_test_cal, y_pred_lg)
# In[54]:
print('Accuracy')
print(accuracy_logistic_calibration)
# In[102]:
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)
knn.fit(X_train_calP, y_train_cal)
y_pred_knn = knn.predict(X_test_calP)
cm_knn = confusion_matrix(y_test_cal, y_pred_knn)
accuracy_knn = ac(y_test_cal, y_pred_knn)
# Saving the cosine similarities in an array
cos_dis = []
for i in range(0, 9000):
text1 = corpus[i][0]
text2 = corpus[i][1]
vector1 = text_to_vector(text1)
vector2 = text_to_vector(text2)
cosine = get_cosine(vector1, vector2)
cos_dis.append([cosine])
cos_dis = np.asarray(cos_dis)
Y = dataset.iloc[0:9000, 2:3]
df = pd.DataFrame(cos_dis)
df.to_csv('output.csv')
# Splitting the dataset in training and test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(cos_dis, Y, test_size=0.2)
# Using random forest classifer for classfication problem
from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=100, criterion='entropy')
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
# Calculating the accuracy
from sklearn.metrics import accuracy_score as ac
score = ac(y_test, y_pred)
temp = open(path4 + x, 'r')
temp = temp.read()
X_test.append(temp)
x_train = X_train
y_train = Y_train
x_test = X_test
y_test = Y_test
print("bow initiated")
vect = fe.text.CountVectorizer(max_features = 2000)
X_train_dtm = vect.fit_transform(x_train)
pd.DataFrame(X_train_dtm.toarray(), columns=vect.get_feature_names())
X_test_dtm = vect.transform(x_test)
pd.DataFrame(X_test_dtm.toarray(), columns=vect.get_feature_names())
# creating and training logistic regression model
print("training begins")
BNBC = BernoulliNB()
BNBC.fit(X_train_dtm, y_train)
print("test begins")
y_predicted = BNBC.predict(X_test_dtm)
print(ac(y_test, y_predicted))
import pandas as pd
from sklearn.tree import DecisionTreeClassifier as dc
from sklearn.model_selection import train_test_split as tts
from sklearn.metrics import accuracy_score as ac
from sklearn.externals import joblib
music_data = pd.read_csv('music.csv')
x = music_data.drop(columns=['genre'])
y = music_data['genre']
x_train, x_test, y_train, y_test = tts(x, y, test_size=0.2)
model = dc()
model.fit(x_train, y_train)
predictions = model.predict(x_test)
score = ac(y_test, predictions)
print(score)
joblib.dump(model, 'music-recommender.joblib')
model = joblib.load('music-recommender.joblib')
predictions = model.predict([[32, 1]])
predictions
#TODO: Test the dataset accuracy using train_test_split() in sklearn.
X = df.values[:, 0:12]
y = df.values[:, 12]
#TODO: Decision tree test part 1.
X_train, X_test, y_train, y_test = tts(X, y, test_size=0.3, random_state=100)
dt_classify_gini = dtc(criterion="gini",
random_state=100,
max_depth=5,
min_samples_leaf=5)
dt_classify_gini.fit(X_train, y_train)
y_predict_gini = dt_classify_gini.predict(X_test)
print("\nDesicion Tree using Gini Index [70:30]\nAccuracy is ",
ac(y_test, y_predict_gini) * 100)
#TODO: Decision tree test part 2.
X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2, random_state=100)
dt_classify_gini = dtc(criterion="gini",
random_state=100,
max_depth=5,
min_samples_leaf=5)
dt_classify_gini.fit(X_train, y_train)
y_predict_gini = dt_classify_gini.predict(X_test)
print("\nDesicion Tree using Gini Index [80:20]\nAccuracy is ",
ac(y_test, y_predict_gini) * 100)
#TODO: Decison tree test part 3.
X_train, X_test, y_train, y_test = tts(X, y, test_size=0.1, random_state=100)
#Cross validation
xtrain, xtest, ytrain, ytest = train_test_split(x,
y,
test_size=0.10,
random_state=0)
'''print(xtrain)
print(xtest)
print(ytrain)
print(ytest)'''
'''__init__(n_components=None, copy=True, iterated_power=3, whiten=False, random_state=None)'''
'''pca = RandomizedPCA(n_components=90)
pca.fit(xtrain)
train_res = pca.fit_transform(xtrain)
#xtest = (np.float32(xtest[:])/255.)
test_res = pca.transform(xtest)
classifier = svm.SVC(gamma = 0.01,C=3, kernel='rbf')
classifier.fit(train_res,ytrain)
expected=ytest
predicted=classifier.predict(test_res)
ac = accuracy_score(expected,predicted)
print ac'''
#SVM
model = svm.SVC(kernel='poly')
model.fit(xtrain, ytrain)
pred = model.predict(xtest)
print(" accuracy is", ac(pred, ytest) * 100)
# 得到测试数据的真实标签
sources = np.zeros((142276, 24))
for i in range(len(read_file_list)):
data = pd.read_csv(read_file_list[i], engine="python")["Class"]
sources[:, i] = data.values
sources = np.sum(sources, axis=1)
source_label = [1 if source > 0 else 0 for source in sources]
num_3 = np.load("num_3.txt.npy")
num_N = np.load("num_N.txt.npy")
one_3 = np.load("one_3.txt.npy")
one_N = np.load("one_N.txt.npy")
print("--------------------------------------------")
print("num_3")
print("Test acc score: {:.6f}".format(ac(source_label, num_3)))
print("Test p score: {:.6f}".format(p(source_label, num_3)))
print("Test r score: {:.6f}".format(r(source_label, num_3)))
data = pd.DataFrame()
data["y_true"] = source_label
data["y_pred"] = num_3
print("TP", data[(data["y_pred"] == 1) & (data["y_true"] == 1)].shape[0])
print("FP", data[(data["y_pred"] == 1) & (data["y_true"] == 0)].shape[0])
print("--------------------------------------------")
print("num_N")
print("Test acc score: {:.6f}".format(ac(source_label, num_N)))
print("Test p score: {:.6f}".format(p(source_label, num_N)))
print("Test r score: {:.6f}".format(r(source_label, num_N)))
data = pd.DataFrame()
data["y_true"] = source_label
def ml(request):
z = False
#data = Document1.objects.all()
#data = serializers.serialize( "python", Document1.objects.all())
d = os.getcwd()
file1 = [f for f in os.listdir(d) if f.endswith('.csv')]
try:
data = pd.read_csv(file1[0])
except:
return HttpResponse("<h2><center> Please upload the file </center> </h2>")
col = []
for i in data.columns:
col.append(i)
test = False
t1 = 'k'
if(request.method == 'POST'):
try:
t1 = request.POST['test']
#t1 = t1.encode('ascii')
except:
print("No value entered")
if(t1=='Y'):
test = True
Label = LabelName.objects.values_list('Label')[0]
#Label = Label[0].encode('ascii')
col.remove(Label)
return render(request, 'index.html', {'test2':test,'col':col})
elif(t1 == 'N'):
os.remove(file1[0])
os.remove('model.pkl')
test = True
LabelName.objects.all().delete()
return render(request, 'index.html', {'test4':test})
if(request.method == 'POST'):
Preprocess = request.POST['Preprocess']
Label = request.POST['Label Name']
#Label = Label.encode('ascii')
#u'label' -> label ascii
split = request.POST['split']
z = True
obj = LabelName(Preprocess = Preprocess,Label = Label, split = split)
obj.save()
if(z):
le = LabelEncoder()
sc = StandardScaler()
print("Printing label after decoding {}".format(Label))
if(data[Label].dtype == 'object'):
data[Label] = le.fit_transform(data[Label])
y = data[Label].values
#print(y)
for i in data.columns:
c1 = re.findall(r"unnamed",i.lower())
c2 = re.findall(r"id",i.lower())
if(len(c1)>0 or len(c2)>0):
data = data.drop(i,axis = 1)
if(Preprocess == 'Y'):
dop = []
for i in data.keys():
s = []
if(data[i].isna().sum()>0):
if(data[i].dtypes == 'int64' or data[i].dtypes == 'float64'):
data[i].fillna(data[i].mean(),inplace = True)
elif(data[i].dtypes == 'object'):
data[i].fillna(data[i].mode()[0],inplace = True)
if(data[i].dtype == 'object'):
for j in data[i]:
s.append(len(j))
else:
s.append(0)
if(max(s) > 30):
dop.append(i)
for z1 in dop:
print("Dropping the column : ", z1)
data = data.drop(z1,axis = 1)
for i in data.keys():
if(data[i].dtype == 'object'):
data[i] = le.fit_transform(data[i])
#data1 = data.astype('float64')
X = data.drop(Label,axis=1)
X = X.values
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = int(split))
X_train = sc.fit_transform(X_train)
X_test = sc.fit_transform(X_test)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(X_train,y_train)
y_pred = lr.predict(X_test)
from sklearn.metrics import accuracy_score as ac
ac1 = ac(y_test,y_pred)
#LabelName.objects.all().delete()
#os.remove(file1[0])
joblib.dump(lr, "model.pkl")
return render(request,'data.html',{'z':z,'label':Label,'ac1':ac1})
return render(request,'data.html',{'col':col})
from sklearn.neighbors import KNeighborsClassifier as kn
from sklearn.cross_validation import train_test_split
from sklearn.metrics import accuracy_score as ac
#plt.style.use('ggplot')
iris = datasets.load_iris()
type(iris)
print(iris.keys())
iris.data.shape
iris.target_names
# EDA
X = iris.data
y = iris.target
y = y.astype(float)
df = pd.DataFrame(X, columns=iris.feature_names)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=1 / 3,
random_state=6)
knn = kn(n_neighbors=6)
knn.fit(X_train, y_train)
pred = knn.predict(X_test)
#visualization
#plt.scatter(X_train,y_train,color='red')
#plt.plot(X_train,knn.predict(X_train),color= 'blue')
print("Accuracy using Knn AT N=6 is: ")
ac(y_test, pred)
#print(df.head())
#pd.scatter_matrix(df,c=y,figsize= [9,9],s= 150,marker= 'D')
temp2.pop(pair[0])
temp2.append(temp)
temp2 = np.array(temp2)
temp2=temp2.flatten()
temp2=temp2.astype(float)
temp2=list(temp2)
final_train_x.append(temp2)
final_train_y.append(temp_data_y[j+6])
return np.array(final_train_x), np.array(final_train_y)
train_x, train_y = final_data(list_image_count, train_x, train_y)
model = svm.SVC()
model.fit(train_x, train_y)
predicted_y = model.predict(test_x)
accuracy = ac(train_y, predicted_y)
print('Guassian Kernel :', accuracy)
model = svm.svm.LinearSVC()
model.fit(train_x, train_y)
predicted_y = model.predict(test_x)
accuracy = ac(train_y, predicted_y)
print('Linear Kernel :', accuracy)
model.save('final_model')
#model = load_model('my_model.h5')
clf.fit(X_final, y)
#Training regressor
train_regressor = pd.read_csv('polarity.csv').iloc[1400:1500,:]
y_regg = np.array(train_regressor['spam'])
X_regg = np.array(train_regressor['review'])
x_regg=X_regg
X_regg = tfidf.transform(X_regg)
polarity_regressor = sparse.csr_matrix(train_regressor['polarity'])
X_regg = sparse.hstack([X_regg,polarity_regressor.reshape(-1,1)], format='csr')
X_regg1=tfidf1.transform(x_regg)
val1=clf.predict(X_regg)
val2=clf1.predict(X_regg1)
val3=pd.concat([pd.DataFrame(val1),pd.DataFrame(val2)],axis=1).values
classifier = LinearRegression().fit(val3, y_regg)
#Testing the hybrid model together
final = pd.read_csv('polarity.csv').iloc[1500:,:]
y_test = np.array(final['spam'])
X_test = np.array(final['review'])
x_test=X_test
X_test = tfidf.transform(X_test)
polarity1 = sparse.csr_matrix(final['polarity'])
X_test = sparse.hstack([X_test,polarity1.reshape(-1,1)], format='csr')
X_test1=tfidf1.transform(x_test)
val1=clf.predict(X_test)
val2=clf1.predict(X_test1)
val3=pd.concat([pd.DataFrame(val1),pd.DataFrame(val2)],axis=1).values
predRF=classifier.predict(val3)
predRF=predRF>0.5
print('Accuracy score: {}'.format(ac(y_test, predRF)))
print('F1 score: {}'.format(f1(y_test, predRF)))
sorted_dict = {
k: v
for k, v in sorted(
dict_fit[key].items(), key=lambda item: item[1], reverse=True)
}
for i, key in enumerate(sorted_dict.keys()):
if (3 < i < 25):
print(features[int(key)], end=" ")
#indicators(dict_fit)
y_p = predict(dict_fit, df_test.values)
cm = cm(y_indexs_test, y_p)
print("Accuracy=", ac(y_indexs_test, y_p))
import matplotlib.pyplot as plt
import seaborn as sns
fig, ax = plt.subplots(figsize=(15, 10))
sns.heatmap(cm,
annot=True,
cmap="Set3",
fmt="d",
xticklabels=list(test.target_names),
yticklabels=list(test.target_names))
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
X_train_Scaler=ss.fit_transform(X_train)
X_test_Scaler =ss.fit_transform(X_test)
# first for regression
if(Which.lower()=="reg" or Which.lower()=="regression"):
# multiRegression
from sklearn.linear_model import LinearRegression
reg = LinearRegression()
reg.fit(X_train, y_train)
results.append(ac(y_test,reg.predict(X_test)))
# polyregression
from sklearn.preprocessing import PolynomialFeatures
pf = PolynomialFeatures(degree=4)
X_poly = pf.fit_transform(X_train)
reg_poly = LinearRegression()
reg_poly.fit(X_poly, y_train)
results.append(ac(y_test, reg_poly.predict(pf.fit_transform(X_test))))
# SVM
from sklearn.svm import SVR
model1.add(Dense(6, activation='relu', input_dim=11))
model1.add(Dense(6, activation='relu'))
model1.add(Dense(1, activation='sigmoid', input_dim=11))
model1.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model1.fit(X_train, y_train, batch_size=10, epochs=100)
y_pred = model1.predict(X_test)
y_pred = (y_pred > 0.5)
print('CM:', confusion_matrix(y_test, y_pred))
print('AC:', ac(y_test, y_pred))
print('F1 scores:', f1(y_test, y_pred))
print('PR:', prfs(y_test, y_pred))
#logistic Regression
from sklearn.linear_model import LogisticRegression as lr
model2 = lr().fit(X_train, y_train)
y_pred = model2.predict(X_test)
y_pred = (y_pred > 0.5)
print('CM:', confusion_matrix(y_test, y_pred))
print('AC:', ac(y_test, y_pred))
print('F1 scores:', f1(y_test, y_pred))
print('PR:', prfs(y_test, y_pred))
from sklearn.neighbors import KNeighborsClassifier as knn
X = processed_df.drop(['Survived'], axis=1) # Features dataset
y = processed_df['Survived'] # Target variable
#Train Test split
from sklearn.cross_validation import train_test_split as tt_split
X_train, X_test, y_train, y_test = tt_split(X,
y,
test_size=0.2,
random_state=100)
from sklearn.metrics import accuracy_score as ac
from sklearn.ensemble import RandomForestClassifier as RFC
RF_default = RFC(random_state=10)
RF_default.fit(X_train, y_train)
pred_dfault = RF_default.predict(X_test)
ac(y_test, pred_dfault)
RF_model1 = RFC(n_estimators=7,
criterion="entropy",
max_features=2,
max_depth=9,
random_state=999)
RF_model1.fit(X_train, y_train)
pred_model1 = RF_model1.predict(X_test)
pred_model1_train = RF_model1.predict(X_train)
ac(y_train, pred_model1_train)
ac(y_test, pred_model1)
from sklearn.model_selection import GridSearchCV
params = {
from sklearn.model_selection import train_test_split as tts
x_train1, x_test1, y_train1, y_test1 = tts(data_ml1, output)
from sklearn.neighbors import KNeighborsClassifier as knc
cla = knc()
cla.fit(x_train1, y_train1)
pred = cla.predict(x_test1)
from sklearn.metrics import accuracy_score as ac
acc = ac(y_test1, pred)
#%% Plotting hexbin for data 2 and patterns
day_section = []
for i in data2.hour:
if i >= 0 and i < 3:
day_section.append('night')
elif i >= 3 and i < 6:
day_section.append('deep night')
elif i >= 6 and i < 9:
day_section.append('earl morning')
elif i >= 9 and i < 12:
day_section.append('morning rush')
elif i >= 12 and i < 15:
acc.append(matthews_corrcoef(label, y_pred))
acc = np.array(acc)
index = np.where(acc == acc.max())
accuracies.append(acc.max())
best_threshold.loc[data.columns[0], "N"] = threshold[index[0][0]]
# 打印预测信息
N = threshold[index[0][0]]
y_pred = [1 if gap > MEAN + N * STD else 0 for gap in gaps]
# y_pred = filter(y_pred)
print("---------------------")
print(data.columns[0], " 调整之后的预测精度展示：")
print("N = ", N)
print("mean = ", MEAN)
print("std = ", STD)
print("Test acc score: {:.6f}".format(ac(label, y_pred)))
print("Test p score: {:.6f}".format(p(label, y_pred)))
print("Test r score: {:.6f}".format(r(label, y_pred)))
print("confusion matrix:")
print(confusion_matrix(label, y_pred))
# 绘图
plt.switch_backend('agg')
plt.subplot(2, 1, 1)
plt.plot(tmp_y, c="b")
plt.plot(result[:, 0], c="r")
plt.title(data.columns[0])
plt.subplot(2, 1, 2)
plt.plot(gaps, c="b")
plt.plot((MEAN + N * STD) * np.ones(len(gaps)))
plt.savefig("./single_result_picture/" + data.columns[0] + ".png")
