This time I will use the scikit-learn module to bulid the classifiers,and I will use the randomforest’s importance to choose the explanatory variables.

Part1. Import the data and R’S randomforest importance

import pandas as pd
import numpy as np

df = pd.read_csv('C:/Users/User/OneDrive - student.nsysu.edu.tw/Educations/NSYSU/fu_chung/bacterial/123.csv')

impor = pd.read_csv('C:/Users/User/OneDrive - student.nsysu.edu.tw/Educations/NSYSU/fu_chung/bacterial - PCA/A.csv')
impo = np.array(impor['names'])
impo

array(['V994', 'V1428', 'V1426', ..., 'V1469', 'V1470', 'V1471'],
      dtype=object)

Part2. Classifiers Building

Contain methods:
svm,randomforest,navie bayes,knn,lda,qda,adaboost,logistic regression.

Those function will return the: “Methods Name”,
“All True amount”,
“Whole Accuracy”,
“True CRE amount”,
“True non-CRE amount”,
“CRE Accuracy”,
“non-CRE Accuracy”.

from sklearn import ensemble
from sklearn import metrics
from sklearn import svm 
#SVM
def svmloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        clf = svm.SVC(kernel = 'linear') #SVM模組，svc,線性核函式 
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "SupportVectorMachine",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#RF
def rfloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        clf = ensemble.RandomForestClassifier(n_estimators = 10)
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "RandomForest",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#NB
def nbloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.naive_bayes import GaussianNB
        clf = GaussianNB()
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "NaiveBayes",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#KNN
def knnloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.neighbors import KNeighborsClassifier 
        clf = KNeighborsClassifier(n_neighbors=3)
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "KNN",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#LDA
def ldaloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
        clf = LinearDiscriminantAnalysis(solver='lsqr', shrinkage=None, priors=None)
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "LDA",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#QDA
def qdaloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
        clf = QuadraticDiscriminantAnalysis()
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "QDA",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#ADABOOST
def adaloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.ensemble import AdaBoostClassifier
        clf = AdaBoostClassifier(n_estimators=100)
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "adaboost",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49
#logistic 
def glmloocv(ldf):
    ldf = ldf.reset_index(drop=True)
    cv = []
    for i in range(len(ldf)):
        dtrain = ldf.drop([i])
        dtest = ldf.iloc[i:i+1,:]
        train_X = dtrain.iloc[:,0:ldf.shape[1]-1]
        test_X = dtest.iloc[:,0:ldf.shape[1]-1]
        train_y = dtrain["CRE"]
        test_y = dtest["CRE"]
        from sklearn.linear_model import LogisticRegression
        clf = LogisticRegression(C=1000, random_state=0)
        clf_fit = clf.fit(train_X, train_y)
        test_y_predicted = clf.predict(test_X)
        accuracy_rf = metrics.accuracy_score(test_y, test_y_predicted)
        cv += [accuracy_rf]
    loocv = np.mean(cv)
    return "LogisticRegression",sum(cv),loocv,sum(cv[0:46]),sum(cv[46:95]),sum(cv[0:46])/46,sum(cv[46:95])/49

Function Testing

ldf = df.loc[:,impo[0:3]]
ldf['CRE'] = df['CRE']
knnloocv(ldf)

('KNN',
 50.0,
 0.5263157894736842,
 45.0,
 5.0,
 0.9782608695652174,
 0.10204081632653061)

Part 3. Processing

import time
import sys

lsvm = []
for i in range (20):  
    ldf = df.loc[:,impo[0:30+i]]
    ldf['CRE'] = df['CRE']
    lsvm += [svmloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(20-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lada = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lada += [adaloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
llda = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    llda += [ldaloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lqda = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lqda += [qdaloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lrf = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lrf += [rfloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lnb = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lnb += [nbloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lglm = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lglm += [glmloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)
lknn = []
for i in range (50):  
    ldf = df.loc[:,impo[0:1+i]]
    ldf['CRE'] = df['CRE']
    lknn += [knnloocv(ldf)]
    sys.stdout.write('\r')
    sys.stdout.write("[%-50s] %d%%" % ('='*i, (100/(50-1))*i))
    sys.stdout.flush()
    time.sleep(0.00000000000001)

[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%
[================================================= ] 100%

data = pd.concat([pd.DataFrame(lsvm),pd.DataFrame(lada),pd.DataFrame(lrf),pd.DataFrame(lnb),pd.DataFrame(llda),pd.DataFrame(lqda),pd.DataFrame(lknn),pd.DataFrame(lglm)], axis=1)
#Write the csv
data.to_csv("locv.csv",index=False,sep=',')

pd.read_csv('C:/Users/User/OneDrive - student.nsysu.edu.tw/Educations/NSYSU/fu_chung/CRE features selection/locv1.csv')

All of the above results, the best accuracy is adaboost in the interval between 67~166. Its accuracy in 0.989473684. Only miss one prediction.