def stacking(self):
train_data, test_data = self.Extract_feature.extract_count()
from sklearn.svm import SVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import RobustScaler, MinMaxScaler
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
import lightgbm as lgb
from lightgbm import LGBMClassifier
import xgboost as xgb
from mlxtend.classifier import StackingClassifier
import scipy as sc
from sklearn import model_selection
lasso = make_pipeline(SVC(C=2.1, gamma=0.005))
rforest = make_pipeline(
RandomForestClassifier(random_state=0, n_estimators=6))
Gboost = GradientBoostingClassifier(n_estimators=500,
learning_rate=0.01,
max_depth=12,
max_features="sqrt",
min_samples_leaf=15,
min_samples_split=97,
random_state=200)
model_xgb = xgb.XGBClassifier(colsample_bytree=0.4603,
gamma=10,
learning_rate=0.01,
max_depth=11,
n_estimators=500,
reg_alpha=0.01,
reg_lambda=5,
subsample=0.5213,
seed=1024,
nthread=-1)
lr = LogisticRegression()
classifiers = [rforest, lasso, Gboost, model_xgb, lr]
stregr = StackingClassifier(classifiers=classifiers,
meta_classifier=lr)
stregr.fit(train_data, self.train_label)
prediction = stregr.predict(test_data)
classification = classification_report(y_true=self.test_label,
y_pred=prediction)
print("classification:{}".format(classification))
print("测试集的score:{}".format(stregr.score(test_data, self.test_label)))
for clf, label in zip(
[rforest, lasso, Gboost, lr, model_xgb, stregr],
['rf', 'svr', 'gboost', 'lr', 'xgb', 'stackingclassifier']):
scores = model_selection.cross_val_score(clf,
train_data,
self.train_label,
cv=3,
scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]" %
(scores.mean(), scores.std(), label))
def test_fit_base_estimators_false():
np.random.seed(123)
meta = LogisticRegression(solver='liblinear', multi_class='ovr')
clf1 = RandomForestClassifier(n_estimators=10)
clf2 = GaussianNB()
clf1.fit(X, y)
clf2.fit(X, y)
sclf = StackingClassifier(classifiers=[clf1, clf2],
meta_classifier=meta,
fit_base_estimators=False)
sclf.fit(X, y)
assert round(sclf.score(X, y), 2) == 0.98
lr = LogisticRegression() slf = StackingClassifier(classifiers=[clf1, clf2, clf3], meta_classifier=lr) slf.fit(X_train, y_train) #交叉验证 scores = cross_validation.cross_val_score(gbm, X, y, cv=5) #得分 dtc_score = dtc.score(X_test, y_test) rfc_score = rfc.score(X_test, y_test) #gbc_score = cross_val_score(gbc,X,y,cv=10) gbc_score = gbc.score(X_test, y_test) gbm_score = gbm.score(X_test, y_test) knn_score = knn.score(X_test, y_test) slf_score = slf.score(X_test, y_test) #输出结果 print(np.mean(scores)) #print (dtc_score) print(rfc_score) print(gbc_score) print(gbm_score) #result1 = (418-np.sum(abs(gbc_predict-data_gender)))/418 #result2 = (418-np.sum(abs(xgb_predict-data_gender)))/418 #print(result1) #print(result2) #prin0t(gbc_predict.shape) #print(data_gender.shape) #data_train.info() #print(data_gender.shape) #可视化图形
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=54,
shuffle=True)
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from mlxtend.classifier import StackingClassifier
'''
from sklearn.ensemble import IsolationForest
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
import sklearn.ensemble.GradientBoostingClassifier
import xgboost as xgb
gb=GradientBoostingClassifier(n_estimators=682)
bg=BaggingClassifier(n_estimators=682)
xg=xgb.XGBClassifier(n_estimators=682)
iso=IsolationForest(n_estimators=682)
ada=AdaBoostClassifier(xg,n_estimators=682,algorithm='SAMME.R')
'''
ext = ExtraTreesClassifier(n_estimators=682,
min_samples_split=2,
random_state=8)
rf = RandomForestClassifier(n_estimators=682,
max_depth=None,
min_samples_split=2,
random_state=8)
clf = StackingClassifier(classifiers=[ext], meta_classifier=rf)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
label = ['stacking']
sclf.fit(X_train_standar, y_train)
score_stacking = cross_val_score(sclf,
X_train_standar,
y_train,
scoring='accuracy')
cross_val_score(sclf, X_train_standar, y_train, scoring='f1')
score_mean_sclf = score_stacking.mean()
print('stacking final score\'s mean is % .2f' % score_mean_sclf)
print('accuracy: %.2f (+/- %.2f) [%s]' %
(score_stacking.mean(), score_stacking.std(), label))
result_stacking = sclf.predict(X_test_stander)
result_stacking_proba = sclf.predict_proba(X_test_stander)
clf_stacking_test_score = sclf.score(X_test_stander, y_test)
precision, recall, thresholds = precision_recall_curve(y_test,
sclf.predict(X_test))
report = result_stacking_proba[:, 1] >= 0.8
print(classification_report(y_test, report, target_names=['0', '1']))
# ==============================================================================
# 模型持久化
# os.chdir(u'D:\【01】行健金融\【01】数据中心\【05】数据分析项目\【03】2018\May\规则引擎_分期商城_风控+授信')
# joblib.dump(sclf, 'stackingpkl.pkl')
# joblib.dump(scaler, 'scaler.pkl')
# ==============================================================================
time2 = time.time()
print("Accuracy: %.2f (+/- %.2f) [%s]" %
(scores.mean(), scores.std(), label))
clf_cv_mean.append(scores.mean())
clf_cv_std.append(scores.std())
clf.fit(X, y)
#plot classifier accuracy
(_, caps, _) = plt.errorbar(range(3),
clf_cv_mean,
yerr=clf_cv_std,
c='blue',
fmt='-o',
capsize=5)
for cap in caps:
cap.set_markeredgewidth(1)
plt.xticks(range(3), ['SVM', 'RF', 'Stacking'])
plt.ylabel('Accuracy')
plt.xlabel('Classifier')
plt.title('Stacking Ensemble')
plt.show()
import pickle
pickle.dump(sclf, open('stack_model_identify.sav', 'wb'))
pred = sclf.predict(X_test)
print(pred)
scores = sclf.score(X_test, y_test)
print("Test score: {0:.2f} %".format(100 * scores))
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
clfs = [
LogisticRegression(C=0.5, max_iter=100),
xgb.XGBClassifier(max_depth=6, n_estimators=100, num_round=5),
RandomForestClassifier(n_estimators=100, max_depth=6, oob_score=True),
GradientBoostingClassifier(learning_rate=0.3,
max_depth=6,
n_estimators=100)
]
clf2 = LogisticRegression(C=0.5, max_iter=100)
#============================================================================#
from mlxtend.classifier import StackingClassifier, StackingCVClassifier
sclf = StackingClassifier(classifiers=clfs, meta_classifier=clf2)
sclf.fit(X_train, Y_train)
print(sclf.score(X_train, Y_train))
sclf_pre = sclf.predict(X_test)
sclf_sub = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": sclf_pre
})
sclf_sub.to_csv("../data/sclf_sub.csv", index=False)
#===============================================================================#
sclf2 = StackingCVClassifier(classifiers=clfs, meta_classifier=clf2, cv=5)
x = np.array(X_train)
y = np.array(Y_train).flatten()
sclf2.fit(x, y)
print(sclf2.score(x, y))
sclf2_pre = sclf2.predict(np.array(X_test))
sclf2_sub = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
class Classifier(object):
"""
LR Bayes SVM XGB decisian tree random forest ...
"""
def __init__(self, model_name):
self.model_name = model_name
self.model = None
def save_model(self):
with open('./model/' + self.model_name + '.pkl', 'wb') as fw:
pickle.dump(self.model, fw)
def load_model(self):
with open('./model/' + self.model_name + '.pkl', 'rb') as fr:
self.model = pickle.load(self.model, fr)
def eval_prob(self, X_test):
return self.model.predict_proba(X_test)
def cls(self, X_train, X_test, y_train, y_test):
if self.model_name == 'lr':
self.model = LogisticRegression()
elif self.model_name == 'xgb':
self.model = XGBClassifier()
elif self.model_name == 'svm':
self.model = SVC(kernel='linear')
elif self.model_name == 'bayes':
# self.model = GaussianNB()
self.model = BernoulliNB() # 最好
# self.model = MultinomialNB()
elif self.model_name == 'rf':
""" 在bagging 的基础上,引入特征抽样，即随机抽取若干特征"""
self.model = RandomForestClassifier()
elif self.model_name == 'dt':
self.model = DecisionTreeClassifier()
elif self.model_name == 'et':
self.model = ExtraTreesClassifier()
elif self.model_name == 'ensemble':
model1 = LogisticRegression()
model2 = BernoulliNB()
model3 = RandomForestClassifier()
model4 = DecisionTreeClassifier()
model5 = ExtraTreesClassifier()
model6 = GradientBoostingClassifier()
# self.model = VotingClassifier(estimators=[('lr', model1), ('dt', model4)])
# self.model = BaggingClassifier(model4, n_estimators=100, max_samples=0.3) # dt 进行bag == rf
self.model = StackingClassifier(classifiers=[model3, model4, model5, model6],
use_probas=True,
average_probas=False,
meta_classifier=model1)
# self.model = GradientBoostingClassifier()
# 采用网格搜索参数
# params = {'lr__C': [1.0, 100.0], 'rf__n_estimators': [20, 200]}
# self.model = GridSearchCV(estimator=model_ensemble, param_grid=params, cv=5)
X_train = np.array(X_train)
y_train = np.array(y_train)
self.model.fit(X_train, y_train)
print(self.model.score(X_test, y_test))
print(classification_report(self.model.predict(X_test), y_test))
stacking_dic[flag]=tmp
out[flag]=(tmp,id)
print(stacking_dic)
print(out)
def correspond(flag):
if flag=='lr':
return LogisticRegression(random_state=1113)
elif flag=='svm':
return svm.SVC(random_state=1113)
elif flag=='rf':
return RandomForestClassifier(random_state=1113)
elif flag=='extra':
return ExtraTreesClassifier(random_state=1113)
elif flag=='gbdt':
return GradientBoostingClassifier(random_state=1113)
elif flag=='adaboost':
return GradientBoostingClassifier(random_state=1113,loss='exponential')
pipe=[]
i=1
for item in stacking_dic.keys():
locals()['pipe'+str(i)] = make_pipeline(ColumnSelector(cols=[j for j in range(stacking_dic[item])]),
correspond(item))
pipe.append(locals()['pipe'+str(i)])
i+=1
sclf = StackingClassifier(classifiers=pipe,
meta_classifier=LogisticRegression())
joblib.dump(sclf,'sclf.model')
sclf.fit(data, mark)
print('准确率:',sclf.score(data, mark))
'''== 0.732394366197'''
print("\n Gradient Boosting: ", classifier6.score(x, y))
from sklearn.tree import DecisionTreeClassifier
classifier7 = DecisionTreeClassifier(criterion='entropy')
classifier7.fit(x, y)
y_pred7 = classifier7.predict(x_test)
print("\n Decision Tree: ", classifier7.score(x, y))
from mlxtend.classifier import StackingClassifier
classifier8 = StackingClassifier(classifiers=[
classifier1, classifier3, classifier4, classifier5, classifier6,
classifier7
],
meta_classifier=classifier2)
classifier8.fit(x, y)
print("\n Ensemble Vote Classifier: ", classifier8.score(x, y))
y_pred8 = classifier8.predict(x_test)
'''
from sklearn import model_selection
for clf, label in zip([classifier1,classifier3,classifier4,
classifier5,classifier6, classifier7,
classifier8],
['SVC',
'KNN',
'Naive Bayes',
'Random Forests',
'Gradient Boosting',
'Decision Tree',
'Stacking Vote Classifier'
]):
class Danny_ML_CLF:
def __init__(self):
self.X = ''
self.y = ''
self.svm = ''
self.tree = ''
self.bayes = ''
self.knn = ''
self.xgb = ''
self.stacking = ''
self.voting = ''
self.bagging = ''
self.rf = '' # random forest
self.adaboost = ''
self.svm_pred = ''
self.tree_pred = ''
self.bayes_pred = ''
self.knn_pred = ''
self.xgb_pred = ''
self.stacking_pred = ''
self.voting_pred = ''
self.bagging_pred = ''
self.rf_pred = ''
self.adaboost_pred = ''
self.svm_report = ''
self.tree_report = ''
self.bayes_report = ''
self.knn_report = ''
self.xgb_report = ''
self.stacking_report = ''
self.voting_report = ''
self.bagging_report = ''
self.rf_report = ''
self.adaboost_report = ''
self.svm_cm = ''
self.tree_cm = ''
self.bayes_cm = ''
self.knn_cm = ''
self.xgb_cm = ''
self.stacking_cm = ''
self.voting_cm = ''
self.bagging_cm = ''
self.rf_cm = ''
self.adaboost_cm = ''
self.svm_score = ''
self.tree_score = ''
self.bayes_score = ''
self.knn_score = ''
self.xgb_score = ''
self.stacking_score = ''
self.voting_score = ''
self.bagging_score = ''
self.rf_score = ''
self.adaboost_score = ''
def Fit_value(self, x, y):
self.X = x
self.y = y
def Split_data(self, raw_X, raw_y, test_size, Standard=True):
train_X, test_X, train_y, test_y = train_test_split(
raw_X, raw_y, test_size=test_size, shuffle=True)
if Standard:
sc = StandardScaler()
sc.fit(train_X)
train_X = sc.transform(train_X)
test_X = sc.transform(test_X)
self.X = train_X
self.y = train_y
return train_X, test_X, train_y, test_y
def SVM(self, C=1, kernel='rbf'):
self.svm = SVC(C=C, kernel=kernel, degree=5, probability=True)
self.svm.fit(self.X, self.y)
def SVM_predict(self, pred_x):
self.svm_pred = self.svm.predict(pred_x)
return self.svm_pred
def Tree(self, criterion='gini', max_depth=5):
self.tree = DecisionTreeClassifier(criterion=criterion,
max_depth=max_depth)
self.tree.fit(self.X, self.y)
def Tree_predict(self, pred_x):
self.tree_pred = self.tree.predict(pred_x)
return self.tree_pred
def Bayes(self):
self.bayes = GaussianNB()
self.bayes.fit(self.X, self.y)
def Bayes_predict(self, pred_x):
self.bayes_pred = self.bayes.predict(pred_x)
return self.bayes_pred
def KNN(self, n_neighbors=3, weights='distance'):
self.knn = KNeighborsClassifier(n_neighbors=n_neighbors,
weights=weights)
self.knn.fit(self.X, self.y)
def KNN_predict(self, pred_x):
self.knn_pred = self.knn.predict(pred_x)
return self.knn_pred
def XGB(self):
self.xgb = xgb.XGBClassifier()
self.xgb.fit(self.X, self.y)
def XGB_prediction(self, pred_x):
self.xgb_pred = self.xgb.predict(pred_x)
return self.xgb_pred
def Stacking(self):
meta_clf = LogisticRegression()
self.stacking = StackingClassifier(
classifiers=[self.svm, self.tree, self.bayes, self.knn, self.xgb],
meta_classifier=meta_clf)
self.stacking.fit(self.X, self.y)
def Stacking_prediction(self, pred_x):
self.stacking_pred = self.stacking.predict(pred_x)
return self.stacking_pred
def Voting(self):
self.voting = VotingClassifier(estimators=[('svm', self.svm),
('tree', self.tree),
('bayes', self.bayes),
('knn', self.knn),
('xgb', self.xgb)],
voting='soft',
weights=[1, 1, 1, 1, 1])
self.voting.fit(self.X, self.y)
def Voting_prediction(self, pred_x):
self.voting_pred = self.voting.predict(pred_x)
return self.voting_pred
def Bagging(self, n_estimators=100, oob_score=False):
self.bagging = BaggingClassifier(n_estimators=n_estimators,
oob_score=oob_score)
self.bagging.fit(self.X, self.y)
def Bagging_prediction(self, pred_x):
self.bagging_pred = self.bagging.predict(pred_x)
return self.bagging_pred
def RF(self,
n_estimators=200,
criterion='gini',
max_features='auto',
oob_score=False):
self.rf = RandomForestClassifier(n_estimators=n_estimators,
criterion=criterion,
max_features=max_features,
oob_score=oob_score)
self.rf.fit(self.X, self.y)
def RF_prediction(self, pred_x):
self.rf_pred = self.rf.predict(pred_x)
return self.rf_pred
def Adaboost(self, n_estimators=100):
self.adaboost = AdaBoostClassifier(n_estimators=n_estimators)
self.adaboost.fit(self.X, self.y)
def Adaboost_prediction(self, pred_x):
self.adaboost_pred = self.adaboost.predict(pred_x)
return self.adaboost_pred
def Train(self):
self.SVM()
self.Tree()
self.Bayes()
self.KNN()
self.XGB()
self.Stacking()
self.Voting()
self.Bagging()
self.RF()
self.Adaboost()
def Report(self, test_X, test_y, labels, show_cm=True):
self.SVM_predict(test_X)
self.Tree_predict(test_X)
self.Bayes_predict(test_X)
self.KNN_predict(test_X)
self.XGB_prediction(test_X)
self.Stacking_prediction(test_X)
self.Voting_prediction(test_X)
self.Bagging_prediction(test_X)
self.RF_prediction(test_X)
self.Adaboost_prediction(test_X)
self.svm_score = self.svm.score(test_X, test_y)
self.tree_score = self.tree.score(test_X, test_y)
self.bayes_score = self.bayes.score(test_X, test_y)
self.knn_score = self.knn.score(test_X, test_y)
self.xgb_score = self.xgb.score(test_X, test_y)
self.stacking_score = self.stacking.score(test_X, test_y)
self.voting_score = self.voting.score(test_X, test_y)
self.bagging_score = self.bagging.score(test_X, test_y)
self.rf_score = self.rf.score(test_X, test_y)
self.adaboost_score = self.adaboost.score(test_X, test_y)
self.svm_report = metrics.classification_report(test_y, self.svm_pred)
self.tree_report = metrics.classification_report(
test_y, self.tree_pred)
self.bayes_report = metrics.classification_report(
test_y, self.bayes_pred)
self.knn_report = metrics.classification_report(test_y, self.knn_pred)
self.xgb_report = metrics.classification_report(test_y, self.xgb_pred)
self.voting_report = metrics.classification_report(
test_y, self.voting_pred)
self.stacking_report = metrics.classification_report(
test_y, self.stacking_pred)
self.bagging_report = metrics.classification_report(
test_y, self.bagging_pred)
self.rf_report = metrics.classification_report(test_y, self.rf_pred)
self.adaboost_report = metrics.classification_report(
test_y, self.adaboost_pred)
self.svm_cm = metrics.confusion_matrix(test_y,
self.svm_pred,
labels=labels)
self.tree_cm = metrics.confusion_matrix(test_y,
self.tree_pred,
labels=labels)
self.bayes_cm = metrics.confusion_matrix(test_y,
self.bayes_pred,
labels=labels)
self.knn_cm = metrics.confusion_matrix(test_y,
self.knn_pred,
labels=labels)
self.xgb_cm = metrics.confusion_matrix(test_y,
self.xgb_pred,
labels=labels)
self.stacking_cm = metrics.confusion_matrix(test_y,
self.stacking_pred,
labels=labels)
self.voting_cm = metrics.confusion_matrix(test_y,
self.voting_pred,
labels=labels)
self.bagging_cm = metrics.confusion_matrix(test_y,
self.bagging_pred,
labels=labels)
self.rf_cm = metrics.confusion_matrix(test_y,
self.rf_pred,
labels=labels)
self.adaboost_cm = metrics.confusion_matrix(test_y,
self.adaboost_pred,
labels=labels)
if show_cm:
self.plot_confusion_matrix(self.svm_cm,
classes=labels,
title='SVM')
self.plot_confusion_matrix(self.tree_cm,
classes=labels,
title='Tree')
self.plot_confusion_matrix(self.bayes_cm,
classes=labels,
title='Bayes')
self.plot_confusion_matrix(self.knn_cm,
classes=labels,
title='KNN')
self.plot_confusion_matrix(self.xgb_cm,
classes=labels,
title='XGB')
self.plot_confusion_matrix(self.stacking_cm,
classes=labels,
title='Stacking')
self.plot_confusion_matrix(self.voting_cm,
classes=labels,
title='Voting')
self.plot_confusion_matrix(self.bagging_cm,
classes=labels,
title='Bagging')
self.plot_confusion_matrix(self.rf_cm, classes=labels, title='RF')
self.plot_confusion_matrix(self.adaboost_cm,
classes=labels,
title='Adaboost')
def History(self):
print('******************\nSVM : ', self.svm_report)
print('******************\nTree : ', self.tree_report)
print('******************\nBayes : ', self.bayes_report)
print('******************\nKNN : ', self.knn_report)
print('******************\nXGB : ', self.xgb_report)
print('******************\nStacking : ', self.stacking_report)
print('******************\nVoting : ', self.voting_report)
print('******************\nBagging : ', self.bagging_report)
print('******************\nRF : ', self.rf_report)
print('******************\nAdaboost : ', self.adaboost_report)
def Score(self):
print('SVM Score : ', self.svm_score)
print('Tree Score : ', self.tree_score)
print('Bayes Score : ', self.bayes_score)
print('KNN Score : ', self.knn_score)
print('XGB Score : ', self.xgb_score)
print('Stacking Score : ', self.stacking_score)
print('Voting Score : ', self.voting_score)
print('Bagging Score : ', self.bagging_score)
print('RF Score : ', self.rf_score)
print('Adaboost Score : ', self.adaboost_score)
def Report2txt(self, filename):
f = open(filename, 'w')
f.write('SVM Score : ' + str(self.svm_score) + '\n')
f.write('Tree Score : ' + str(self.tree_score) + '\n')
f.write('Bayes Score : ' + str(self.bayes_score) + '\n')
f.write('KNN Score : ' + str(self.knn_score) + '\n')
f.write('XGB Score : ' + str(self.xgb_score) + '\n')
f.write('Stacking Score : ' + str(self.stacking_score) + '\n')
f.write('Voting Score : ' + str(self.voting_score) + '\n')
f.write('Bagging Score : ' + str(self.bagging_score) + '\n')
f.write('RF Score : ' + str(self.rf_score) + '\n')
f.write('Adaboost Score : ' + str(self.adaboost_score) + '\n')
f.write('Adaboost Score : ' + str(self.adaboost_score) + '\n')
f.write('XXXX\n')
f.write('******************\nSVM : ' + str(self.svm_report) + '\n')
f.write('******************\nTree : ' + str(self.tree_report) + '\n')
f.write('******************\nBayes : ' + str(self.bayes_report) + '\n')
f.write('******************\nKNN : ' + str(self.knn_report) + '\n')
f.write('******************\nXGB : ' + str(self.xgb_report) + '\n')
f.write('******************\nStacking : ' + str(self.stacking_report) +
'\n')
f.write('******************\nVoting : ' + str(self.voting_report) +
'\n')
f.write('******************\nBagging : ' + str(self.bagging_report) +
'\n')
f.write('******************\nRF : ' + str(self.rf_report) + '\n')
f.write('******************\nAdaboost : ' + str(self.adaboost_report) +
'\n')
f.close()
def plot_confusion_matrix(self,
cm,
classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.figure()
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print(title, ' Confusion matrix, without normalization')
print(cm)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j,
i,
cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()
from sklearn.naive_bayes import GaussianNB
import mlxtend
from mlxtend.classifier import StackingClassifier
lr = LogisticRegression()
knn = KNeighborsClassifier()
svm = SVC(probability=True)
NB = GaussianNB()
DT = DecisionTreeClassifier()
sclf = StackingClassifier(classifiers=[svm, lr, knn, DT, rand_GSOpt],
use_probas=True,
meta_classifier=rand_GSOpt)
sclf.fit(x_train, y_train)
sclf_y_pred = sclf.predict(x_test)
print('Accuracy of ensembeled stacking model classifier on test set: {:.2f}'.
format(sclf.score(x_test, y_test)))
print('sclf_F1 Score =',
sklearn.metrics.f1_score(y_test, sclf_y_pred, average="macro"))
print('sclf_Precision =',
sklearn.metrics.precision_score(y_test, sclf_y_pred, average="macro"))
print('sclf_Recall =',
sklearn.metrics.recall_score(y_test, sclf_y_pred, average="macro"))
import xgboost
from xgboost import XGBClassifier
XGBoost = XGBClassifier(learning_rate=0.2, max_depth=2, n_estimators=43)
XGBoost.fit(x_train, y_train)
XGBoost_y_pred = XGBoost.predict(x_test)
print('Accuracy of XGBoost on test set: {:.2f}'.format(
from sklearn.datasets import load_iris
from mlxtend.classifier import StackingClassifier
from mlxtend.feature_selection import ColumnSelector
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
iris = load_iris()
X = iris.data
y = iris.target
pipe1 = make_pipeline(ColumnSelector(cols=(0, 2)),
LogisticRegression())
pipe2 = make_pipeline(ColumnSelector(cols=(1, 2, 3)),
LogisticRegression())
sclf = StackingClassifier(classifiers=[pipe1, pipe2],
meta_classifier=LogisticRegression())
sclf.fit(X, y)
print(sclf.score(X,y))