def MLEM2_LERS(FILENAME, iter1, iter2) :
# rule induction
fullpath_filename = DIR_UCI+'/'+FILENAME+'/rules/'+'rules_'+str(iter1)+'-'+str(iter2)+'.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename): mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'-test'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[decision_table_test.columns[-1]].values.tolist()
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test, list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test, list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(decision_class, predictions)
#print('{FILENAME} : {iter1} {iter2}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2))
#logging.info('MLEM2_LERS,1,{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2,acc=accuracy))
savepath = DIR_UCI+'/'+FILENAME+'/MLEM2_LERS.csv'
with open(savepath, "a") as f :
f.writelines('MLEM2_LERS,1,{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2,acc=accuracy)+"\n")
return(accuracy)
def Apriori_LERS(FILENAME, iter1, iter2, minsup, minconf) :
# rule induction
fullpath_filename = '/data/uci/'+FILENAME+'/apriori/'+'rules_'+str(iter1)+'-'+str(iter2)+'-'+str(minsup)+'-'+str(minconf)+'.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(fullpath_filename) else apriori.getRulesByApriori(FILENAME, iter1, iter2, minsup, minconf)
# rule save
if not os.path.isfile(fullpath_filename): mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = '/data/uci/'+FILENAME+'/'+FILENAME+'-test'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[decision_table_test.columns[-1]].values.tolist()
filepath = '/data/uci/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test, list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test, list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(list(map(str,decision_class)), predictions)
#print('{FILENAME} : {iter1} {iter2}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2))
logging.basicConfig(filename=os.path.dirname(os.path.abspath("__file__"))+'/'+FILENAME+'.log',format='%(asctime)s,%(message)s',level=logging.DEBUG)
logging.info('Apriori_LERS,{FILENAME},{iter1},{iter2},{acc},{minsup},{minconf}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2,acc=accuracy,minsup=minsup,minconf=minconf))
return(accuracy)
def MLEM2_RuleClusteringByConsistentTimesSimExceptMRule_LERS(FILENAME, iter1, iter2, k, m) :
# rule induction
fullpath_filename = DIR_UCI+'/'+FILENAME+'/rules/'+'rules_'+str(iter1)+'-'+str(iter2)+'.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename): mlem2.savePickleRules(rules, fullpath_filename)
# rule clustering
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'-train'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table = mlem2.getDecisionTable(filepath)
colnames = mlem2.getColNames(decision_table)
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
fullpath_filename = DIR_UCI+'/'+FILENAME+'/rules_cluster_consistent_times_sim_except_mrule/'+'rules-'+str(k)+'_'+str(iter1)+'-'+str(iter2)+'.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(fullpath_filename) else clustering.getRuleClusteringByConsistentTimesSimilarityExceptMRule(rules, colnames, list_judgeNominal, k=k, m=m)
# rule save
if not os.path.isfile(fullpath_filename): mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'-test'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[decision_table_test.columns[-1]].values.tolist()
filepath = DIR_UCI+'/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test, list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test, list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(decision_class, predictions)
#print('{FILENAME} : {iter1} {iter2}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2))
#logging.info('MLEM2_RuleClusteringByConsistentSimExceptMRule_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,k=k,iter1=iter1,iter2=iter2,acc=accuracy))
savepath = DIR_UCI+'/'+FILENAME+'/MLEM2_RuleClusteringByConsistentTimesSimExceptMRule_LERS.csv'
with open(savepath, "a") as f :
f.writelines('MLEM2_RuleClusteringByConsistentTimesSimExceptMRule_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,k=k,iter1=iter1,iter2=iter2,acc=accuracy)+"\n")
return(accuracy)
def MLEM2_OnlyK_LERS(FILENAME, iter1, iter2, k):
print("START iter1 iter2 k : " + str(iter1) + "," + str(iter2) + "," +
str(k))
# rule induction
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules/' + 'rules_' + str(
iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# only-k rule filter
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules_onlyK/' + 'rules-' + str(
k) + '_' + str(iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else [r for r in rules if len(r.getSupport()) >= k]
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '-test' + str(
iter1) + '-' + str(iter2) + '.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[
decision_table_test.columns[-1]].values.tolist()
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test,
list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test,
list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(decision_class, predictions)
#print('{FILENAME} : {iter1} {iter2}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2))
#logging.info('MLEM2_OnlyK_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,k=k,iter1=iter1,iter2=iter2,acc=accuracy))
savepath = DIR_UCI + '/' + FILENAME + '/MLEM2_OnlyK_LERS.csv'
with open(savepath, "a") as f:
f.writelines(
'MLEM2_OnlyK_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'.format(
FILENAME=FILENAME, k=k, iter1=iter1, iter2=iter2, acc=accuracy)
+ "\n")
#print("END iter1 iter2 k : " + str(iter1) + "," + str(iter2) + "," + str(k))
return (accuracy)
def MLEM2_RuleClusteringByConsistentExceptMRule_STAT(FILENAME, iter1, iter2, k,
m):
# rule induction
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules/' + 'rules_' + str(
iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# rule clustering
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '-train' + str(
iter1) + '-' + str(iter2) + '.tsv'
decision_table = mlem2.getDecisionTable(filepath)
colnames = mlem2.getColNames(decision_table)
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules_cluster_consistent_except_mrule/' + 'rules-' + str(
k) + '_' + str(iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename
) else clustering.getRuleClusteringByConsistentExceptMRule(
rules, colnames, list_judgeNominal, k=k, m=m)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# rules の数を求める
num = len(rules)
# 平均の長さを求める
leng = mlem2.getMeanLength(rules)
# 平均支持度を求める
support = mlem2.getMeanSupport(rules)
# ファイルにsave
savepath = DIR_UCI + '/' + FILENAME + '/MLEM2_RuleClusteringByConsistentExceptMRule_STAT.csv'
with open(savepath, "a") as f:
f.writelines(
'MLEM2_RuleClusteringByConsistentExceptMRule_STAT,{k},{FILENAME},{iter1},{iter2},{num},{leng},{support}'
.format(FILENAME=FILENAME,
k=k,
iter1=iter1,
iter2=iter2,
num=num,
leng=leng,
support=support) + "\n")
return (0)
def MLEM2_RuleClusteringBySameCondition_LERS(FILENAME, iter1, iter2, k):
# rule induction
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules/' + 'rules_' + str(
iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# rule clustering
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules_cluster_same_condition/' + 'rules-' + str(
k) + '_' + str(iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else clustering.getRuleClusteringBySameCondition(
rules, k=k)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '-test' + str(
iter1) + '-' + str(iter2) + '.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[
decision_table_test.columns[-1]].values.tolist()
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test,
list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test,
list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(decision_class, predictions)
#logging.info('MLEM2_RuleClusteringBySameCondition_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'.format(FILENAME=FILENAME,k=k,iter1=iter1,iter2=iter2,acc=accuracy))
savepath = DIR_UCI + '/' + FILENAME + '/MLEM2_RuleClusteringBySameCondition_LERS.csv'
with open(savepath, "a") as f:
f.writelines(
'MLEM2_RuleClusteringBySameCondition_LERS,{k},{FILENAME},{iter1},{iter2},{acc}'
.format(
FILENAME=FILENAME, k=k, iter1=iter1, iter2=iter2,
acc=accuracy) + "\n")
return (accuracy)
def Apriori_LERS(FILENAME, iter1, iter2, minsup, minconf):
# rule induction
fullpath_filename = '/data/uci/' + FILENAME + '/apriori/' + 'rules_' + str(
iter1) + '-' + str(iter2) + '-' + str(minsup) + '-' + str(
minconf) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else apriori.getRulesByApriori(
FILENAME, iter1, iter2, minsup, minconf)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# test data setup
filepath = '/data/uci/' + FILENAME + '/' + FILENAME + '-test' + str(
iter1) + '-' + str(iter2) + '.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[
decision_table_test.columns[-1]].values.tolist()
filepath = '/data/uci/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test,
list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test,
list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(list(map(str, decision_class)), predictions)
#print('{FILENAME} : {iter1} {iter2}'.format(FILENAME=FILENAME,iter1=iter1,iter2=iter2))
logging.basicConfig(filename=os.path.dirname(os.path.abspath("__file__")) +
'/' + FILENAME + '.log',
format='%(asctime)s,%(message)s',
level=logging.DEBUG)
logging.info(
'Apriori_LERS,{FILENAME},{iter1},{iter2},{acc},{minsup},{minconf}'.
format(FILENAME=FILENAME,
iter1=iter1,
iter2=iter2,
acc=accuracy,
minsup=minsup,
minconf=minconf))
return (accuracy)
def MLEM2_RuleClusteringByConsistentSim_Identified(FILENAME, iter1, iter2, k,
p):
# rule induction
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules/' + 'rules_' + str(
iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename) else mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# rule clustering
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '-train' + str(
iter1) + '-' + str(iter2) + '.tsv'
decision_table = mlem2.getDecisionTable(filepath)
colnames = mlem2.getColNames(decision_table)
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
fullpath_filename = DIR_UCI + '/' + FILENAME + '/rules_cluster_consistent_sim/' + 'rules-' + str(
k) + '_' + str(iter1) + '-' + str(iter2) + '.pkl'
rules = mlem2.loadPickleRules(fullpath_filename) if os.path.isfile(
fullpath_filename
) else clustering.getRuleClusteringByConsistentSimilarity(
rules, colnames, list_judgeNominal, k=k)
# rule save
if not os.path.isfile(fullpath_filename):
mlem2.savePickleRules(rules, fullpath_filename)
# PerIdentifiedClass を求める
ans = mlem2.getPerIdentifiedClass(rules, p)
# save
savepath = DIR_UCI + '/' + FILENAME + '/Identify_MLEM2_RuleClusteringByConsistentSim.csv'
with open(savepath, "a") as f:
f.writelines(
'Identify_MLEM2_RuleClusteringByConsistentSim,{k},{p},{FILENAME},{iter1},{iter2},{ans}'
.format(
FILENAME=FILENAME, k=k, p=p, iter1=iter1, iter2=iter2,
ans=ans) + "\n")
return (ans)
# ========================================
if __name__ == "__main__":
FILENAME = 'hayes-roth'
iter1 = 5
iter2 = 4
rules = mlem2.getRulesByMLEM2(FILENAME, iter1, iter2)
filepath = '/mnt/data/uci/'+FILENAME+'/'+FILENAME+'-train'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table = mlem2.getDecisionTable(filepath)
colnames = mlem2.getColNames(decision_table)
filepath = '/mnt/data/uci/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
# ルールクラスタリング
#rules_new = getRuleClusteringBySimilarity(rules, colnames, list_judgeNominal, k=3)
#rules_new = getRuleClusteringByRandom(rules, k=3)
#rules_new = getRuleClusteringBySameCondition(rules, k=3)
#rules_new = getRuleClusteringByConsistentSimilarity(rules, colnames, list_judgeNominal, k=3)
#rules_new = getRuleClusteringByConsistentSimilarityExceptMRule(rules, colnames, list_judgeNominal, k=3, m=3)
#rules_new = getRuleClusteringByConsistentTimesSimilarityExceptMRule(rules, colnames, list_judgeNominal, k=3, m=3)
rules_new = getRuleClusteringBySimilarityExceptMRule(rules, colnames, list_judgeNominal, k=3, m=3)
rules_new = getRuleClusteringByConsistentExceptMRule(rules, colnames, list_judgeNominal, k=3, m=3)
# predict by LERS
filepath = '/mnt/data/uci/'+FILENAME+'/'+FILENAME+'-test'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
def main(DIR, FILENAME, CLASSES, ruleset, method, ITER):
ITER = str(ITER)
print(datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S') + ' ' +
FILENAME + ' ' + method + ' ' + ITER + " START")
# load rules
rules = loadRules(DIR, FILENAME, ruleset, method, ITER)
# load test and val data
filepath_test_A = DIR + '/' + FILENAME + '/MIXTURE/dataset/nobias2/' + ITER + '/test_A.tsv'
df_test_A = pd.read_csv(filepath_test_A, delimiter='\t')
filepath_val_A = DIR + '/' + FILENAME + '/MIXTURE/dataset/nobias2/' + ITER + '/val_A.tsv'
df_val_A = pd.read_csv(filepath_val_A, delimiter='\t')
decision_class_test = df_test_A[df_test_A.columns[-1]].values.tolist()
decision_class_val = df_val_A[df_val_A.columns[-1]].values.tolist()
filepath_nominal = DIR + '/' + FILENAME + '/dataset/' + FILENAME + '.nominal'
list_nominal = getNominalList(filepath_nominal)
list_judgeNominal = getJudgeNominal(df_test_A, list_nominal)
# predict by LERS
predict_test = predictByLERS(rules, df_test_A, list_judgeNominal)
predict_proba_test = predictProbaByLERS(rules,
df_test_A,
list_judgeNominal,
classes=CLASSES)
predict_proba_test = np.array(predict_proba_test)[:, 0]
predict_val = predictByLERS(rules, df_val_A, list_judgeNominal)
predict_proba_val = predictProbaByLERS(rules,
df_val_A,
list_judgeNominal,
classes=CLASSES)
predict_proba_val = np.array(predict_proba_val)[:, 0]
# 正答率を求める
result_acc_test = accuracy_score(decision_class_test, predict_test)
result_acc_val = accuracy_score(decision_class_val, predict_val)
# AUCを求める
fpr, tpr, thresholds = roc_curve(decision_class_test,
predict_proba_test,
pos_label=CLASSES[0])
result_auc_test = auc(fpr, tpr)
fpr, tpr, thresholds = roc_curve(decision_class_val,
predict_proba_val,
pos_label=CLASSES[0])
result_auc_val = auc(fpr, tpr)
# save
DIR_SAVE = DIR + '/' + FILENAME + '/MIXTURE/' + method + '/nobias2/' + ITER
if not os.path.isdir(DIR_SAVE): os.makedirs(DIR_SAVE, exist_ok=True)
fullpath_test = DIR_SAVE + '/result_test.tsv'
fullpath_val = DIR_SAVE + '/result_val.tsv'
df_result_test = pd.DataFrame({
'y_true': decision_class_test,
'y_predict': predict_test,
'y_predict_proba': predict_proba_test,
'acc': result_acc_test,
'auc': result_auc_test
})
df_result_val = pd.DataFrame({
'y_true': decision_class_val,
'y_predict': predict_val,
'y_predict_proba': predict_proba_val,
'acc': result_acc_val,
'auc': result_auc_val
})
pd.DataFrame.to_csv(df_result_test,
fullpath_test,
index=False,
sep='\t',
header=True)
pd.DataFrame.to_csv(df_result_val,
fullpath_val,
index=False,
sep='\t',
header=True)
print(datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S') + ' ' +
FILENAME + ' ' + method + ' ' + ITER + " END")
# ========================================
# main
# ========================================
if __name__ == "__main__":
FILENAME = 'hayes-roth'
iter1 = 4
iter2 = 5
minsup = 10
minconf = 1.0
rules = getRulesByApriori(FILENAME, iter1, iter2, minsup, minconf)
# test data setup
filepath = '/data/uci/'+FILENAME+'/'+FILENAME+'-test'+str(iter1)+'-'+str(iter2)+'.tsv'
decision_table_test = mlem2.getDecisionTable(filepath)
decision_table_test = decision_table_test.dropna()
decision_class = decision_table_test[decision_table_test.columns[-1]].values.tolist()
filepath = '/data/uci/'+FILENAME+'/'+FILENAME+'.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table_test, list_nominal)
# predict by LERS
predictions = LERS.predictByLERS(rules, decision_table_test, list_judgeNominal)
# 正答率を求める
accuracy = accuracy_score(list(map(str,decision_class)), predictions)
print(accuracy)
def getJudgeNominal(decision_table, FILENAME):
filepath = DIR_UCI + '/' + FILENAME + '/' + FILENAME + '.nominal'
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
return (list_judgeNominal)
def getJudgeNominal(decision_table, FILENAME):
filepath = DIR_UCI + "/" + FILENAME + "/" + FILENAME + ".nominal"
list_nominal = mlem2.getNominalList(filepath)
list_judgeNominal = mlem2.getJudgeNominal(decision_table, list_nominal)
return list_judgeNominal
