sklearn_分类预测(KNN,GNB,...)示例(疾病简单二分类)

文章目录

• code
• code (initial version)
• 预测分类(二分类0/1)
• • data_train.csv:
  • data_test.csv:

数据即和最新源代码link

code

from typing import Tuple
import numpy as np
from numpy.lib.function_base import average
import pandas as pd
import random
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from openpyxl import Workbook
from openpyxl.utils.dataframe import dataframe_to_rows
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
 
""" the exp6 """
 
 
def output_file(result_list, result_file, method):
    ''' 输出预测结果 '''
    with open(result_file, "w") as fos:
        result = ""
        # print(str(result_list))
        for char in result_list:
            result = result+(str(char)+'\n')
        # print(result)
        result.strip()
        # fos.write(method+str(result_list))
        fos.write(result)
 
 
data_train = 'data-train.csv'
data_test = 'data-test.csv'
# gnb predicion:
clf_GNB = GaussianNB()
clf_KNN = KNeighborsClassifier()
clf_LR = LogisticRegression()
clf_MLP = MLPClassifier(max_iter=10000)  # max_iter=1000最高迭代1000次
clf_RF = RandomForestClassifier()
clf_GB = GradientBoostingClassifier()
df_train_df = pd.read_csv(data_train, encoding='utf-8')
# 取得本征数据集条目
x_arrays_train = np.array(df_train_df.iloc[:, :-1])
# 取得对应的标签集
y_array_train = np.array(df_train_df.iloc[:, -1])
 
 
def generate_random_bools(x_array: np.ndarray, estimate_scale: float = 90):
    """ 通过随机化手段(将产生一系列的随机索引,方便对多组执行同样的随机选择(保持配套),
    这种做法相较于直接再数据容器(比如ndarray上直接抽取子集要来的灵活方便:引入第三方中介)) """
    size = len(x_array)
    estimate_scale_int = int(size/100*estimate_scale)
    real_scale = size-estimate_scale_int
    true_list = [True for index in range(estimate_scale_int)]
    false_list = [False for index in range(real_scale)]
    bools = true_list+false_list
    random.shuffle(bools)
    return bools
 
 
def estimate_accuracy(bools: list[bool], x_array: np.ndarray, y_array: np.ndarray, clf=clf_GNB):
 
    # 读取原始数据，指定UTF-8编码（需要用文本编辑器将数据装换为UTF-8编码）
    # print(bools)
 
    estimate_accuracy_x_train: np.ndarray = x_array[bools]
    estimate_accuracy_y_train: np.ndarray = y_array[bools]
    # fit the modle(classifier)
    clf.fit(estimate_accuracy_x_train, estimate_accuracy_y_train)
    # get the data set to be predict(estimate)
    bools_reverse = [not bool_ for bool_ in bools]
    estimate_accuracy_x_test = x_array[bools_reverse]
    real_result = y_array[bools_reverse]
 
    estimate_predict_result = clf.predict(estimate_accuracy_x_test)
    # calculate the accuracy:
    length = len(estimate_predict_result)
    count = 0
    for label1, label2 in zip(estimate_predict_result, real_result):
        if label1 == label2:
            count += 1
        else:
            ...
    # print the len to certain the result is calculate the proper case:
    accuracy = count/length
 
    # print(accuracy)
    # print(length, "elements were predicted with model:", clf)
    return accuracy
 
 
def estimate_by_k_fold(index_tuple:Tuple, x_arrays_train: np.ndarray = x_arrays_train,
                       y_array_train: np.ndarray = y_array_train, clf=clf_GNB):
    estimate_accuracy_x_train: np.ndarray = x_arrays_train[index_tuple[1]]
    estimate_accuracy_y_train: np.ndarray = y_array_train[index_tuple[1]]
    clf.fit(estimate_accuracy_x_train, estimate_accuracy_y_train)
    real_result = y_array_train[index_tuple[0]]
    estimate_accuracy_x_test = x_arrays_train[index_tuple[0]]
    estimate_predict_result = clf.predict(estimate_accuracy_x_test)
    # calculate the accuracy:
    length = len(estimate_predict_result)
    count = 0
    for label1, label2 in zip(estimate_predict_result, real_result):
        if label1 == label2:
            count += 1
        else:
            ...
    # print the len to certain the result is calculate the proper case:
    accuracy = count/length
 
    # print(accuracy)
    # print(length, "elements were predicted with model:", clf)
    return accuracy
 
 
def estimate_by_k_fold_times(index_tuples, clf=clf_GNB):
    count_probiblity=0
    for index_tuple in index_tuples:
        result = estimate_by_k_fold(index_tuple, clf=clf)
        count_probiblity+=result
        # print(result)
        # 返回平均值
    return count_probiblity/len(index_tuples)
    
 
 
# defind  series of k_fold related method:
""" 产生原问题的训练数据集x_array_train元素的索引构成的随机化序列,这些索引值构成一个索引序列列表index_list
k等分索引序列,得到k各区间,分别收集索引列表各区间的起始索引start_index和终止索引end_index;
range(start_index,end_index)产生的序列可以取得的index_list中的连续的若干个元素,按照这些元素可以取得x_array_train中的对应的一系列元素
这些元素将作为测试集;同时,range(0,start_index)和range(end_index,)
然而,更好的描述是:对于分组start_index,end_index,对于index_list的切片[start_index,end_index],[:start_index]和[end_index:]
两个切片之和作为对应的训练集(中元素的索引)
 
 """
 
 
def get_random_indexes(x_arrays_train=x_arrays_train) -> list:
    size = len(x_arrays_train)
    indexes = [i for i in range(size)]
    random.shuffle(indexes)
    # print(np.ndarray(indexes))
    return indexes
 
 
def get_k_fold_test_indexes(random_indexes:list[int], k=5) -> list:
    test_index_tuples: list = []
    size=len(random_indexes)
    array_size = size//k
    for i in range(k):
        array_start = i*array_size
        array_end = array_start+array_size
        # 左闭右开
        # test_index_tuples.append(indexs[array_start:array_end])
        # test_index_tuples.append((array_start,array_end))
        test_index_tuples.append(
            (random_indexes[array_start: array_end], random_indexes[:array_start]+random_indexes[array_end:]))
    return test_index_tuples
 
 
# def get_k_fold_train_indexes(test_index_tuples, length, k=10) -> list:
#     for tuple in test_index_tuples:
# def k_fold_estimate(x_array_train, k=10):
 
 
def random_reservation():
    classifiers: list = [clf_GNB, clf_KNN, clf_RF, clf_GB, clf_MLP]
    sort_list = []
    times = 10
    count_prob = [0.0 for i in range(len(classifiers))]
    for index in range(times):
        bools = generate_random_bools(x_arrays_train, 90)
        clf_index = 0
        for clf_i in classifiers:
            count_prob[clf_index] += estimate_accuracy(
                bools, x_arrays_train, y_array_train, clf=clf_i)
            clf_index += 1
            
    average_probs: np.ndarray = np.array(count_prob)/times
 
    # clf_index=0
    for clf_perform in zip(classifiers, average_probs):
        print("in average result with:", clf_perform[0], clf_perform[1])
        sort_list.append(clf_perform)
    # print(sort_list)
    sort_list.sort(key=lambda tuple: tuple[1], reverse=True)
    for item in sort_list:
        print(item)
 
def k_fold():
    classifiers: list = [clf_GNB, clf_KNN, clf_RF, clf_GB, clf_MLP]
    sort_list = []
    times = 10
    count_prob = [0.0 for i in range(len(classifiers))]
    for index in range(times):
        index_tuples = get_k_fold_test_indexes(get_random_indexes(x_arrays_train))
        clf_index = 0
        for clf_i in classifiers:
            
            count_prob[clf_index] += estimate_by_k_fold_times(
                index_tuples, clf=clf_i)
            clf_index += 1
            
    average_probs: np.ndarray = np.array(count_prob)/times
 
    # clf_index=0
    for clf_perform in zip(classifiers, average_probs):
        print("in average result with:", clf_perform[0], clf_perform[1])
        sort_list.append(clf_perform)
    # print(sort_list)
    sort_list.sort(key=lambda tuple: tuple[1], reverse=True)
    for item in sort_list:
        print(item)
 
if "__main__" == __name__:
    k_fold()
 

code (initial version)

def exp6():
    from re import T
    from openpyxl import Workbook
    from openpyxl.utils.dataframe import dataframe_to_rows
    import pandas as pd
    import numpy as np
    prefix = "./exp6/"
    data_train = 'data-train.csv'  # 
    data_test = 'data-test.csv'
 
    data_train = prefix+data_train
    data_test = prefix+data_test
    prediction_result = prefix+'prediction.txt'  # 
 
    # 读取原始数据，指定UTF-8编码（需要用文本编辑器将数据装换为UTF-8编码）
    """   # print(data_table)
        # print(data_table.loc[0:3])
        # print("\n"*3)
        # list=np.array(data_table.iloc[:,:]).tolist()
        # print(list[0])
        # lists=np.array(data_table.iloc[:,:-1]).tolist()
        # print(lists[0])
        # print(list[0]) """
    df_train = pd.read_csv(data_train, encoding='utf-8')
    x_arrays = np.array(df_train.iloc[:, :-1])
    y_array = np.array(df_train['target'])
    
    # print(x_arrays,"\n",y_array)
   
    
    df_test = pd.read_csv(data_test, encoding='utf-8')
    newx = np.array(df_test.iloc[:, :-1])
 
    KNN_exp6(x_arrays,y_array,newx,prediction_result)
    # GNB_exp6(x_arrays,y_array,newx,prediction_result)
 
    
    # print("predict_GNB:",clf.predict((newx)))
    # print("probability_GNB:",clf.predict_proba(newx))
 
def KNN_exp6(x,y,newx,prediction_result):
    # the default n_neightbors=5
    clf=KNeighborsClassifier(n_neighbors=7)
    clf.fit(x,y)
    result_list=clf.predict(newx)
    output_file(result_list, prediction_result,"KNN")
def GNB_exp6(x,y,newx,prediction_result):
    clf= clf = GaussianNB()
    clf.fit(x, y)
    result_list=clf.predict(newx)
    output_file(result_list, prediction_result,"GNB")
    
exp6()

预测分类(二分类0/1)

data_train.csv:

data_test.csv: