【机器学习，填充数据后使用4种模型进行数据的处理】

于 2024-07-18 19:29:19 发布
阅读量70 收藏 1
点赞数 5
分类专栏： 机器学习 文章标签： 机器学习 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77444219/article/details/140507011
版权

文章目录

对数据进行处理之前首先导入必要的库：

import pandas as pd
from sklearn.model_selection import cross_val_score
import numpy as np
from sklearn import metrics
from sklearn.calibration import calibration_curve

然后进行数据的读取，读取的对象就是分别用删除数据行、平均值填充、中位数填充、众数填充四种方法填充数据后保存的excel文件：

'''数据提取'''
train_data = pd.read_excel(r'.//temp_data//训练数据集[删除空数据行].xlsx')
train_data_x = train_data.iloc[:,1:]    #训练数据集的特征
train_data_y = train_data.iloc[:,0]     #训练数据集的测试标签label

test_data = pd.read_excel(r'.//temp_data//测试数据集[删除空数据行].xlsx')
test_data_x = test_data.iloc[:,1:]    #测试数据集的特征
test_data_y = test_data.iloc[:,0]     #测试数据集的测试标签label

result_data = {}#用来保存后面6种算法的结果。

一、删除空数据行

'''#################逻辑回归LR算法实现代码#############################'''

from sklearn.linear_model import LogisticRegression
"""建立最优模型"""
LR_result= {}#用来保存训练之后的结果。
lr = LogisticRegression(C = 10, max_iter = 500,penalty='l2',solver='lbfgs')#逻辑回归的参数，是通过网格搜索算法来实现
lr.fit(train_data_x, train_data_y)


'''测试结果【含训练数据集的测试 + 测试数据集的测试】'''
train_predicted = lr.predict(train_data_x) #训练数据集的预测结果
print('LR的train:\n',metrics.classification_report(train_data_y, train_predicted))
test_predicted = lr.predict(test_data_x) #训练数据集的预测结果
print('LR的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)#digits表示保留有效位数
b = a.split()

LR_result['recall_0'] = float(b[6])   #添加类别为0的召回率
LR_result['recall_1'] = float(b[11])  #添加类别为1的召回率
LR_result['recall_2'] = float(b[16])  #添加类别为2的召回率
LR_result['recall_3'] = float(b[21])  #添加类别为3的召回率
LR_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['LR'] = LR_result#result_data是总体的结果，
print('lr结束')


# '''#################RF算法实现代码#############################'''
from sklearn.ensemble import RandomForestClassifier
RF_result = {}
rf = RandomForestClassifier(bootstrap= False,
                            max_depth=20,
                            max_features='log2',
                            min_samples_leaf= 1,
                            min_samples_split= 2,
                            n_estimators=50,
                            random_state=487)

rf.fit(train_data_x, train_data_y)
train_predicted = rf.predict(train_data_x) #训练数据集的预测结果
test_predicted = rf.predict(test_data_x) #训练数据集的预测结果

print('RF的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果
print('RF的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
rf_test_report = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = rf_test_report.split()

RF_result['recall_0'] = float(b[6])   #添加类别为0的召回率
RF_result['recall_1'] = float(b[11])  #添加类别为1的召回率
RF_result['recall_2'] = float(b[16])  #添加类别为2的召回率
RF_result['recall_3'] = float(b[21])  #添加类别为3的召回率
RF_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['RF'] = RF_result




'''#################SVM算法实现代码#############################'''
from sklearn.svm import SVC
#下面的参数均已通过网格搜索算法调优
SVM_result = {}
svm = SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#c无穷大，则可软间隔为0。不容分错。尝试修改

svm.fit(train_data_x,train_data_y)
test_predicted = svm.predict(test_data_x) #训练数据集的预测结果

print('SVM的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a= metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
print(a)

SVM_result['recall_0'] = float(b[6])   #添加类别为0的召回率
SVM_result['recall_1'] = float(b[11])  #添加类别为1的召回率
SVM_result['recall_2'] = float(b[16])  #添加类别为2的召回率
SVM_result['recall_3'] = float(b[21])  #添加类别为3的召回率
SVM_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['SVM'] = SVM_result





'''#################AdaBoost算法实现代码#############################'''
#XGBoost使用的基学习器是决策树,而AdaBoost可以使用其他各种弱学习器。
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

AdaBoost_reslut = {}

# 创建一个决策树分类器作为基础分类器
base_classifier = DecisionTreeClassifier(max_depth=1)

abf = AdaBoostClassifier(algorithm= 'SAMME',
                         base_estimator= base_classifier,
                         n_estimators=200,
                         learning_rate= 1.0,
                         random_state=0)  # 创建AdaBoost分类器# 创建GridSearchCV对象

abf.fit(train_data_x,train_data_y)
train_predicted = abf.predict(train_data_x) #训练数据集的预测结果
print('AdaBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = abf.predict(test_data_x) #训练数据集的预测结果
print('AdaBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

AdaBoost_reslut['recall_0'] = float(b[6])   #添加类别为0的召回率
AdaBoost_reslut['recall_1'] = float(b[11])  #添加类别为1的召回率
AdaBoost_reslut['recall_2'] = float(b[16])  #添加类别为2的召回率
AdaBoost_reslut['recall_3'] = float(b[21])  #添加类别为3的召回率
AdaBoost_reslut['acc'] = float(b[25])*100  #添加accuracy的结果
result_data['AdaBoost'] = AdaBoost_reslut


'''#################GNB算法实现代码#############################'''
from sklearn.naive_bayes import GaussianNB

GNB_result = {}
gnb = GaussianNB() # 创建高斯朴素贝叶斯分类器
gnb.fit(train_data_x,train_data_y)
train_predicted = gnb.predict(train_data_x) #训练数据集的预测结果
print('GNB的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = gnb.predict(test_data_x) #训练数据集的预测结果
print('GNB的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

GNB_result['recall_0'] = float(b[6])   #添加类别为0的召回率
GNB_result['recall_1'] = float(b[11])  #添加类别为1的召回率
GNB_result['recall_2'] = float(b[16])  #添加类别为2的召回率
GNB_result['recall_3'] = float(b[21])  #添加类别为3的召回率
GNB_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['GNB'] = GNB_result



'''#################XGBoost算法实现代码#############################'''
import xgboost as xgb
XGBoost_result = {}
xgb_model = xgb.XGBClassifier(learning_rate=0.05,  # 学习率
    n_estimators=200,  # 决策树数量
    num_class = 5,
    max_depth=7,  # 树的最大深度
    min_child_weight=1,  # 叶子节点中最小的样本权重和
    gamma=0,  # 节点分裂所需的最小损失函数下降值
    subsample=0.6,  # 训练样本的子样本比例
    colsample_bytree=0.8,  # 每棵树随机采样的列数的占比
    objective='multi:softmax',  # 损失函数类型（对于二分类问题）
    seed=0  # 随机数种子
     ) # 创建XGBoost分类器

xgb_model.fit(train_data_x,train_data_y)
train_predicted = xgb_model.predict(train_data_x) #训练数据集的预测结果
print('XGBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = xgb_model.predict(test_data_x) #训练数据集的预测结果
print('XGBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
XGBoost_result['recall_0'] = float(b[6])  #添加类别为0的召回率
XGBoost_result['recall_1'] = float(b[11])  #添加类别为1的召回率
XGBoost_result['recall_2'] = float(b[16])  #添加类别为2的召回率
XGBoost_result['recall_3'] = float(b[21])  #添加类别为3的召回率
XGBoost_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['XGBoost'] = XGBoost_result

import json
# 使用 'w' 模式打开文件，确保如果文件已存在则会被覆盖
result = {}
result['cca fill'] = result_data
with open(r'temp_data/删除数据行result.json', 'w', encoding='utf-8') as file:
    # 使用 json.dump() 方法将字典转换为 JSON 格式并写入文件
    json.dump(result, file, ensure_ascii=False, indent=4)

代码执行结果

在这里插入图片描述

在这里插入图片描述

二、平均值填充

下面三种方法的代码是一样的，只是需要改变读取到的数据对象，以及最后保存的JSON文件的内容。

import pandas as pd
from sklearn.model_selection import cross_val_score
import numpy as np
from sklearn import metrics
from sklearn.calibration import calibration_curve

'''数据提取'''
train_data = pd.read_excel(r'.//temp_data//训练数据集[平均值填充].xlsx')
train_data_x = train_data.iloc[:,1:]    #训练数据集的特征
train_data_y = train_data.iloc[:,0]     #训练数据集的测试标签label

test_data = pd.read_excel(r'.//temp_data//测试数据集[平均值填充].xlsx')
test_data_x = test_data.iloc[:,1:]    #测试数据集的特征
test_data_y = test_data.iloc[:,0]     #测试数据集的测试标签label

result_data = {}#用来保存后面6种算法的结果。

from sklearn.linear_model import LogisticRegression
"""建立最优模型"""
LR_result= {}#用来保存训练之后的结果。
lr = LogisticRegression(C = 10, max_iter = 500,penalty='l2',solver='lbfgs')#逻辑回归的参数，是通过网格搜索算法来实现
lr.fit(train_data_x, train_data_y)


'''测试结果【含训练数据集的测试 + 测试数据集的测试】'''
train_predicted = lr.predict(train_data_x) #训练数据集的预测结果
print('LR的train:\n',metrics.classification_report(train_data_y, train_predicted))
test_predicted = lr.predict(test_data_x) #训练数据集的预测结果
print('LR的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)#digits表示保留有效位数
b = a.split()

LR_result['recall_0'] = float(b[6])   #添加类别为0的召回率
LR_result['recall_1'] = float(b[11])  #添加类别为1的召回率
LR_result['recall_2'] = float(b[16])  #添加类别为2的召回率
LR_result['recall_3'] = float(b[21])  #添加类别为3的召回率
LR_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['LR'] = LR_result#result_data是总体的结果，
print('lr结束')


# '''#################RF算法实现代码#############################'''
from sklearn.ensemble import RandomForestClassifier
RF_result = {}
rf = RandomForestClassifier(bootstrap= False,
                            max_depth=20,
                            max_features='log2',
                            min_samples_leaf= 1,
                            min_samples_split= 2,
                            n_estimators=50,
                            random_state=487)

rf.fit(train_data_x, train_data_y)
train_predicted = rf.predict(train_data_x) #训练数据集的预测结果
test_predicted = rf.predict(test_data_x) #训练数据集的预测结果

print('RF的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果
print('RF的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
rf_test_report = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = rf_test_report.split()

RF_result['recall_0'] = float(b[6])   #添加类别为0的召回率
RF_result['recall_1'] = float(b[11])  #添加类别为1的召回率
RF_result['recall_2'] = float(b[16])  #添加类别为2的召回率
RF_result['recall_3'] = float(b[21])  #添加类别为3的召回率
RF_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['RF'] = RF_result




'''#################SVM算法实现代码#############################'''
from sklearn.svm import SVC
#下面的参数均已通过网格搜索算法调优
SVM_result = {}
svm = SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#c无穷大，则可软间隔为0。不容分错。尝试修改

svm.fit(train_data_x,train_data_y)
test_predicted = svm.predict(test_data_x) #训练数据集的预测结果

print('SVM的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a= metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
print(a)

SVM_result['recall_0'] = float(b[6])   #添加类别为0的召回率
SVM_result['recall_1'] = float(b[11])  #添加类别为1的召回率
SVM_result['recall_2'] = float(b[16])  #添加类别为2的召回率
SVM_result['recall_3'] = float(b[21])  #添加类别为3的召回率
SVM_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['SVM'] = SVM_result





'''#################AdaBoost算法实现代码#############################'''
#XGBoost使用的基学习器是决策树,而AdaBoost可以使用其他各种弱学习器。
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

AdaBoost_reslut = {}

# 创建一个决策树分类器作为基础分类器
base_classifier = DecisionTreeClassifier(max_depth=1)

abf = AdaBoostClassifier(algorithm= 'SAMME',
                         base_estimator= base_classifier,
                         n_estimators=200,
                         learning_rate= 1.0,
                         random_state=0)  # 创建AdaBoost分类器# 创建GridSearchCV对象

abf.fit(train_data_x,train_data_y)
train_predicted = abf.predict(train_data_x) #训练数据集的预测结果
print('AdaBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = abf.predict(test_data_x) #训练数据集的预测结果
print('AdaBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

AdaBoost_reslut['recall_0'] = float(b[6])   #添加类别为0的召回率
AdaBoost_reslut['recall_1'] = float(b[11])  #添加类别为1的召回率
AdaBoost_reslut['recall_2'] = float(b[16])  #添加类别为2的召回率
AdaBoost_reslut['recall_3'] = float(b[21])  #添加类别为3的召回率
AdaBoost_reslut['acc'] = float(b[25])*100  #添加accuracy的结果
result_data['AdaBoost'] = AdaBoost_reslut


'''#################GNB算法实现代码#############################'''
from sklearn.naive_bayes import GaussianNB

GNB_result = {}
gnb = GaussianNB() # 创建高斯朴素贝叶斯分类器
gnb.fit(train_data_x,train_data_y)
train_predicted = gnb.predict(train_data_x) #训练数据集的预测结果
print('GNB的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = gnb.predict(test_data_x) #训练数据集的预测结果
print('GNB的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

GNB_result['recall_0'] = float(b[6])   #添加类别为0的召回率
GNB_result['recall_1'] = float(b[11])  #添加类别为1的召回率
GNB_result['recall_2'] = float(b[16])  #添加类别为2的召回率
GNB_result['recall_3'] = float(b[21])  #添加类别为3的召回率
GNB_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['GNB'] = GNB_result



'''#################XGBoost算法实现代码#############################'''
import xgboost as xgb
XGBoost_result = {}
xgb_model = xgb.XGBClassifier(learning_rate=0.05,  # 学习率
    n_estimators=200,  # 决策树数量
    num_class = 5,
    max_depth=7,  # 树的最大深度
    min_child_weight=1,  # 叶子节点中最小的样本权重和
    gamma=0,  # 节点分裂所需的最小损失函数下降值
    subsample=0.6,  # 训练样本的子样本比例
    colsample_bytree=0.8,  # 每棵树随机采样的列数的占比
    objective='multi:softmax',  # 损失函数类型（对于二分类问题）
    seed=0  # 随机数种子
     ) # 创建XGBoost分类器

xgb_model.fit(train_data_x,train_data_y)
train_predicted = xgb_model.predict(train_data_x) #训练数据集的预测结果
print('XGBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = xgb_model.predict(test_data_x) #训练数据集的预测结果
print('XGBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
XGBoost_result['recall_0'] = float(b[6])  #添加类别为0的召回率
XGBoost_result['recall_1'] = float(b[11])  #添加类别为1的召回率
XGBoost_result['recall_2'] = float(b[16])  #添加类别为2的召回率
XGBoost_result['recall_3'] = float(b[21])  #添加类别为3的召回率
XGBoost_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['XGBoost'] = XGBoost_result

import json
# 使用 'w' 模式打开文件，确保如果文件已存在则会被覆盖
result = {}
result['mean fill'] = result_data
with open(r'temp_data/平均值填充result.json', 'w', encoding='utf-8') as file:
    # 使用 json.dump() 方法将字典转换为 JSON 格式并写入文件
    json.dump(result, file, ensure_ascii=False, indent=4)

执行结果

在这里插入图片描述
在这里插入图片描述

三、中位数填充

import pandas as pd
from sklearn.model_selection import cross_val_score
import numpy as np
from sklearn import metrics
from sklearn.calibration import calibration_curve

'''数据提取'''
train_data = pd.read_excel(r'.//temp_data//训练数据集[中位数填充].xlsx')
train_data_x = train_data.iloc[:,1:]    #训练数据集的特征
train_data_y = train_data.iloc[:,0]     #训练数据集的测试标签label

test_data = pd.read_excel(r'.//temp_data//测试数据集[中位数填充].xlsx')
test_data_x = test_data.iloc[:,1:]    #测试数据集的特征
test_data_y = test_data.iloc[:,0]     #测试数据集的测试标签label

result_data = {}#用来保存后面6种算法的结果。

from sklearn.linear_model import LogisticRegression
"""建立最优模型"""
LR_result= {}#用来保存训练之后的结果。
lr = LogisticRegression(C = 10, max_iter = 500,penalty='l2',solver='lbfgs')#逻辑回归的参数，是通过网格搜索算法来实现
lr.fit(train_data_x, train_data_y)


'''测试结果【含训练数据集的测试 + 测试数据集的测试】'''
train_predicted = lr.predict(train_data_x) #训练数据集的预测结果
print('LR的train:\n',metrics.classification_report(train_data_y, train_predicted))
test_predicted = lr.predict(test_data_x) #训练数据集的预测结果
print('LR的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)#digits表示保留有效位数
b = a.split()

LR_result['recall_0'] = float(b[6])   #添加类别为0的召回率
LR_result['recall_1'] = float(b[11])  #添加类别为1的召回率
LR_result['recall_2'] = float(b[16])  #添加类别为2的召回率
LR_result['recall_3'] = float(b[21])  #添加类别为3的召回率
LR_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['LR'] = LR_result#result_data是总体的结果，
print('lr结束')


# '''#################RF算法实现代码#############################'''
from sklearn.ensemble import RandomForestClassifier
RF_result = {}
rf = RandomForestClassifier(bootstrap= False,
                            max_depth=20,
                            max_features='log2',
                            min_samples_leaf= 1,
                            min_samples_split= 2,
                            n_estimators=50,
                            random_state=487)

rf.fit(train_data_x, train_data_y)
train_predicted = rf.predict(train_data_x) #训练数据集的预测结果
test_predicted = rf.predict(test_data_x) #训练数据集的预测结果

print('RF的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果
print('RF的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
rf_test_report = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = rf_test_report.split()

RF_result['recall_0'] = float(b[6])   #添加类别为0的召回率
RF_result['recall_1'] = float(b[11])  #添加类别为1的召回率
RF_result['recall_2'] = float(b[16])  #添加类别为2的召回率
RF_result['recall_3'] = float(b[21])  #添加类别为3的召回率
RF_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['RF'] = RF_result




'''#################SVM算法实现代码#############################'''
from sklearn.svm import SVC
#下面的参数均已通过网格搜索算法调优
SVM_result = {}
svm = SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#c无穷大，则可软间隔为0。不容分错。尝试修改

svm.fit(train_data_x,train_data_y)
test_predicted = svm.predict(test_data_x) #训练数据集的预测结果

print('SVM的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a= metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
print(a)

SVM_result['recall_0'] = float(b[6])   #添加类别为0的召回率
SVM_result['recall_1'] = float(b[11])  #添加类别为1的召回率
SVM_result['recall_2'] = float(b[16])  #添加类别为2的召回率
SVM_result['recall_3'] = float(b[21])  #添加类别为3的召回率
SVM_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['SVM'] = SVM_result





'''#################AdaBoost算法实现代码#############################'''
#XGBoost使用的基学习器是决策树,而AdaBoost可以使用其他各种弱学习器。
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

AdaBoost_reslut = {}

# 创建一个决策树分类器作为基础分类器
base_classifier = DecisionTreeClassifier(max_depth=1)

abf = AdaBoostClassifier(algorithm= 'SAMME',
                         base_estimator= base_classifier,
                         n_estimators=200,
                         learning_rate= 1.0,
                         random_state=0)  # 创建AdaBoost分类器# 创建GridSearchCV对象

abf.fit(train_data_x,train_data_y)
train_predicted = abf.predict(train_data_x) #训练数据集的预测结果
print('AdaBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = abf.predict(test_data_x) #训练数据集的预测结果
print('AdaBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

AdaBoost_reslut['recall_0'] = float(b[6])   #添加类别为0的召回率
AdaBoost_reslut['recall_1'] = float(b[11])  #添加类别为1的召回率
AdaBoost_reslut['recall_2'] = float(b[16])  #添加类别为2的召回率
AdaBoost_reslut['recall_3'] = float(b[21])  #添加类别为3的召回率
AdaBoost_reslut['acc'] = float(b[25])*100  #添加accuracy的结果
result_data['AdaBoost'] = AdaBoost_reslut


'''#################GNB算法实现代码#############################'''
from sklearn.naive_bayes import GaussianNB

GNB_result = {}
gnb = GaussianNB() # 创建高斯朴素贝叶斯分类器
gnb.fit(train_data_x,train_data_y)
train_predicted = gnb.predict(train_data_x) #训练数据集的预测结果
print('GNB的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = gnb.predict(test_data_x) #训练数据集的预测结果
print('GNB的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

GNB_result['recall_0'] = float(b[6])   #添加类别为0的召回率
GNB_result['recall_1'] = float(b[11])  #添加类别为1的召回率
GNB_result['recall_2'] = float(b[16])  #添加类别为2的召回率
GNB_result['recall_3'] = float(b[21])  #添加类别为3的召回率
GNB_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['GNB'] = GNB_result



'''#################XGBoost算法实现代码#############################'''
import xgboost as xgb
XGBoost_result = {}
xgb_model = xgb.XGBClassifier(learning_rate=0.05,  # 学习率
    n_estimators=200,  # 决策树数量
    num_class = 5,
    max_depth=7,  # 树的最大深度
    min_child_weight=1,  # 叶子节点中最小的样本权重和
    gamma=0,  # 节点分裂所需的最小损失函数下降值
    subsample=0.6,  # 训练样本的子样本比例
    colsample_bytree=0.8,  # 每棵树随机采样的列数的占比
    objective='multi:softmax',  # 损失函数类型（对于二分类问题）
    seed=0  # 随机数种子
     ) # 创建XGBoost分类器

xgb_model.fit(train_data_x,train_data_y)
train_predicted = xgb_model.predict(train_data_x) #训练数据集的预测结果
print('XGBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = xgb_model.predict(test_data_x) #训练数据集的预测结果
print('XGBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
XGBoost_result['recall_0'] = float(b[6])  #添加类别为0的召回率
XGBoost_result['recall_1'] = float(b[11])  #添加类别为1的召回率
XGBoost_result['recall_2'] = float(b[16])  #添加类别为2的召回率
XGBoost_result['recall_3'] = float(b[21])  #添加类别为3的召回率
XGBoost_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['XGBoost'] = XGBoost_result

import json
# 使用 'w' 模式打开文件，确保如果文件已存在则会被覆盖
result = {}
result['median fill'] = result_data
with open(r'temp_data/中位数填充result.json', 'w', encoding='utf-8') as file:
    # 使用 json.dump() 方法将字典转换为 JSON 格式并写入文件
    json.dump(result, file, ensure_ascii=False, indent=4)

执行结果

在这里插入图片描述
在这里插入图片描述

四、众数填充

import pandas as pd
from sklearn.model_selection import cross_val_score
import numpy as np
from sklearn import metrics
from sklearn.calibration import calibration_curve

'''数据提取'''
train_data = pd.read_excel(r'.//temp_data//训练数据集[众数填充].xlsx')
train_data_x = train_data.iloc[:,1:]    #训练数据集的特征
train_data_y = train_data.iloc[:,0]     #训练数据集的测试标签label

test_data = pd.read_excel(r'.//temp_data//测试数据集[众数填充].xlsx')
test_data_x = test_data.iloc[:,1:]    #测试数据集的特征
test_data_y = test_data.iloc[:,0]     #测试数据集的测试标签label

result_data = {}#用来保存后面6种算法的结果。

from sklearn.linear_model import LogisticRegression
"""建立最优模型"""
LR_result= {}#用来保存训练之后的结果。
lr = LogisticRegression(C = 10, max_iter = 500,penalty='l2',solver='lbfgs')#逻辑回归的参数，是通过网格搜索算法来实现
lr.fit(train_data_x, train_data_y)


'''测试结果【含训练数据集的测试 + 测试数据集的测试】'''
train_predicted = lr.predict(train_data_x) #训练数据集的预测结果
print('LR的train:\n',metrics.classification_report(train_data_y, train_predicted))
test_predicted = lr.predict(test_data_x) #训练数据集的预测结果
print('LR的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)#digits表示保留有效位数
b = a.split()

LR_result['recall_0'] = float(b[6])   #添加类别为0的召回率
LR_result['recall_1'] = float(b[11])  #添加类别为1的召回率
LR_result['recall_2'] = float(b[16])  #添加类别为2的召回率
LR_result['recall_3'] = float(b[21])  #添加类别为3的召回率
LR_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['LR'] = LR_result#result_data是总体的结果，
print('lr结束')


# '''#################RF算法实现代码#############################'''
from sklearn.ensemble import RandomForestClassifier
RF_result = {}
rf = RandomForestClassifier(bootstrap= False,
                            max_depth=20,
                            max_features='log2',
                            min_samples_leaf= 1,
                            min_samples_split= 2,
                            n_estimators=50,
                            random_state=487)

rf.fit(train_data_x, train_data_y)
train_predicted = rf.predict(train_data_x) #训练数据集的预测结果
test_predicted = rf.predict(test_data_x) #训练数据集的预测结果

print('RF的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果
print('RF的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
rf_test_report = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = rf_test_report.split()

RF_result['recall_0'] = float(b[6])   #添加类别为0的召回率
RF_result['recall_1'] = float(b[11])  #添加类别为1的召回率
RF_result['recall_2'] = float(b[16])  #添加类别为2的召回率
RF_result['recall_3'] = float(b[21])  #添加类别为3的召回率
RF_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['RF'] = RF_result




'''#################SVM算法实现代码#############################'''
from sklearn.svm import SVC
#下面的参数均已通过网格搜索算法调优
SVM_result = {}
svm = SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#c无穷大，则可软间隔为0。不容分错。尝试修改

svm.fit(train_data_x,train_data_y)
test_predicted = svm.predict(test_data_x) #训练数据集的预测结果

print('SVM的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a= metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
print(a)

SVM_result['recall_0'] = float(b[6])   #添加类别为0的召回率
SVM_result['recall_1'] = float(b[11])  #添加类别为1的召回率
SVM_result['recall_2'] = float(b[16])  #添加类别为2的召回率
SVM_result['recall_3'] = float(b[21])  #添加类别为3的召回率
SVM_result['acc'] = float(b[25]) #添加accuracy的结果
result_data['SVM'] = SVM_result





'''#################AdaBoost算法实现代码#############################'''
#XGBoost使用的基学习器是决策树,而AdaBoost可以使用其他各种弱学习器。
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

AdaBoost_reslut = {}

# 创建一个决策树分类器作为基础分类器
base_classifier = DecisionTreeClassifier(max_depth=1)

abf = AdaBoostClassifier(algorithm= 'SAMME',
                         base_estimator= base_classifier,
                         n_estimators=200,
                         learning_rate= 1.0,
                         random_state=0)  # 创建AdaBoost分类器# 创建GridSearchCV对象

abf.fit(train_data_x,train_data_y)
train_predicted = abf.predict(train_data_x) #训练数据集的预测结果
print('AdaBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = abf.predict(test_data_x) #训练数据集的预测结果
print('AdaBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

AdaBoost_reslut['recall_0'] = float(b[6])   #添加类别为0的召回率
AdaBoost_reslut['recall_1'] = float(b[11])  #添加类别为1的召回率
AdaBoost_reslut['recall_2'] = float(b[16])  #添加类别为2的召回率
AdaBoost_reslut['recall_3'] = float(b[21])  #添加类别为3的召回率
AdaBoost_reslut['acc'] = float(b[25])*100  #添加accuracy的结果
result_data['AdaBoost'] = AdaBoost_reslut


'''#################GNB算法实现代码#############################'''
from sklearn.naive_bayes import GaussianNB

GNB_result = {}
gnb = GaussianNB() # 创建高斯朴素贝叶斯分类器
gnb.fit(train_data_x,train_data_y)
train_predicted = gnb.predict(train_data_x) #训练数据集的预测结果
print('GNB的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = gnb.predict(test_data_x) #训练数据集的预测结果
print('GNB的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()

GNB_result['recall_0'] = float(b[6])   #添加类别为0的召回率
GNB_result['recall_1'] = float(b[11])  #添加类别为1的召回率
GNB_result['recall_2'] = float(b[16])  #添加类别为2的召回率
GNB_result['recall_3'] = float(b[21])  #添加类别为3的召回率
GNB_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['GNB'] = GNB_result



'''#################XGBoost算法实现代码#############################'''
import xgboost as xgb
XGBoost_result = {}
xgb_model = xgb.XGBClassifier(learning_rate=0.05,  # 学习率
    n_estimators=200,  # 决策树数量
    num_class = 5,
    max_depth=7,  # 树的最大深度
    min_child_weight=1,  # 叶子节点中最小的样本权重和
    gamma=0,  # 节点分裂所需的最小损失函数下降值
    subsample=0.6,  # 训练样本的子样本比例
    colsample_bytree=0.8,  # 每棵树随机采样的列数的占比
    objective='multi:softmax',  # 损失函数类型（对于二分类问题）
    seed=0  # 随机数种子
     ) # 创建XGBoost分类器

xgb_model.fit(train_data_x,train_data_y)
train_predicted = xgb_model.predict(train_data_x) #训练数据集的预测结果
print('XGBoost的train:\n',metrics.classification_report(train_data_y, train_predicted)) #打印训练数据集的测试结果

test_predicted = xgb_model.predict(test_data_x) #训练数据集的预测结果
print('XGBoost的test:\n',metrics.classification_report(test_data_y, test_predicted)) #打印训练数据集的测试结果
a = metrics.classification_report(test_data_y, test_predicted,digits=6)
b = a.split()
XGBoost_result['recall_0'] = float(b[6])  #添加类别为0的召回率
XGBoost_result['recall_1'] = float(b[11])  #添加类别为1的召回率
XGBoost_result['recall_2'] = float(b[16])  #添加类别为2的召回率
XGBoost_result['recall_3'] = float(b[21])  #添加类别为3的召回率
XGBoost_result['acc'] = float(b[25])  #添加accuracy的结果
result_data['XGBoost'] = XGBoost_result

import json
# 使用 'w' 模式打开文件，确保如果文件已存在则会被覆盖
result = {}
result['mode fill'] = result_data
with open(r'temp_data/众数填充result.json', 'w', encoding='utf-8') as file:
    # 使用 json.dump() 方法将字典转换为 JSON 格式并写入文件
    json.dump(result, file, ensure_ascii=False, indent=4)

执行结果

在这里插入图片描述
在这里插入图片描述

01_6
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习流程—数据预处理 清洗
03-05 2万+
这里我们需要说明一下，虽然这里我们讲的是数据预处理，但是我们这里为了更加充分的理解我们后面的数据预处理，这里我们说明一下我们要解决什么样的问题，也就是定义问题。itanic数据集作为kaggle比赛中的经典数据集，今天我们使用的数据也是这个数据集，这个数据集描述的主要是泰坦尼克号邮轮上乘客的数据，我们要做的事情就是根据乘客的数据预测乘客在泰坦尼克号沉没的时候时候可以活下来。
机器学习-泰坦尼克号数据集
04-02
《机器学习：深入解析泰坦尼克号数据集》 在数据科学的世界里，经典的数据集总能引起学者和...通过这个案例，我们可以深入了解数据预处理、特征工程、模型选择与优化等核心概念，为今后的机器学习之旅打下坚实的基础。
基于机器学习算法的数据分析师薪资预测模型优化研究
m0_64336780的博客
12-26 1万+
目前大陆地区对数据分析师的需求主要集中在北京、上海、深圳地区；相应提供的薪资水平也是这三个地区居于前面，证实了经济较好的地区对该岗位的需求更好、待遇更好；因而，对于互联网等相关企业，北上广深依旧是广大求职者的目标地区；从数据统计情况来看，针对数据分析师在学历方面的要求，目前是学历越高，薪资待遇越好；但相反的是，学历越高，岗位需求并非越大；而针对数据分析师在经验上的要求，目前是经验在3年及以上的岗位缺口更大；
Python数据分析与机器学习在医疗诊断中的应用
屿小夏.的知识博客
06-14 3万+
在现代医疗领域，数据分析与机器学习的应用已经成为提升医疗诊断效率和准确性的关键手段。医疗诊断系统通过对大量患者数据进行分析，帮助医生预测疾病风险、制定个性化治疗方案，并且在疾病早期阶段提供预警。Python作为一种灵活且功能强大的编程语言，结合其丰富的数据分析和机器学习库，成为医疗诊断系统开发的首选工具。本文将探讨Python数据分析与机器学习在医疗诊断中的应用，详细介绍构建医疗诊断系统的步骤和技术。
【机器学习】机器学习之数据清洗
朝花夕拾
11-14 1万+
在实验中探索数据清洗的重要性以及清洗过程中的一些关键步骤，理解数据清洗是一个必要的预处理过程，用来帮助从原始数据中去除不准确、不完整或不适用于模型的记录，以确保所使用的数据是准确、可靠且适合用于模型训练，也可以帮助发现和纠正数据中的错误、缺失和不一致之处，以提高数据的质量和准确性。
Python数据分析与机器学习在金融风控中的应用
热门推荐
屿小夏.的知识博客
06-17 4万+
金融风控是金融机构确保其业务健康运行、减少损失的重要手段。随着大数据和人工智能技术的发展，利用Python进行数据分析和机器学习可以为金融风控提供强有力的支持。本文将探讨Python在金融风控中的应用，详细介绍如何利用Python进行数据收集、预处理、机器学习建模和评估，以提升金融风控的准确性和效率。
基于Python 机器学习进行医疗保险价格预测数据集
04-18
基于Python的机器学习进行医疗保险价格预测，是一个结合了数据科学、统计学和机器学习技术的复杂任务。在这个项目中，我们使用Python编程语言及其强大的机器学习库，如Scikit-learn、Pandas、Matplotlib等，来构建...
机器学习-决策树（以西瓜数据集为例）
03-30
决策树是一种广泛应用于机器学习领域的算法，它通过创建分层的决策模型来预测目标变量。在本案例中，我们将深入探讨如何使用决策树处理“西瓜数据集”。这个数据集是用于教学目的的理想选择，因为它包含了多个特征，...
《10种流行的机器学习算法进行泰坦尼克幸存者分析》脚本与数据
09-20
在本项目中，我们探索了如何使用《10种流行的机器学习算法进行泰坦尼克幸存者分析》。这个案例研究旨在教你如何运用多种机器学习技术来预测在泰坦尼克号灾难中乘客的生存情况。数据来源于一个经典的数据科学竞赛，它...
机器学习UCI数据集mat.txt,data形式
03-18
数据可能需要进一步预处理，例如分隔符处理、缺失值填充和异常值处理，才能被机器学习算法使用。 3. data文件：这种格式通常指的是结构化的数据文件，可能类似于txt文件，但具体格式可能因数据集而异。它可以是逗号...
【机器学习】Scoring Model Scores: 理解、设计与优化评分模型
2301_81771576的博客
07-18 229
最后，模型部署是将训练好的模型应用于新数据，生成评分，可能需要与现有业务系统集成[^1^]。AUC是评估二分类模型性能的重要指标，它衡量了ROC曲线下的面积，值范围在0到1之间，AUC越高，表明模型的性能越好。例如，金融机构使用评分模型来评估信贷申请人的违约风险，而电商网站则利用评分模型预测用户对产品的兴趣程度，提供个性化的商品推荐[^1^]。构建评分模型时应关注数据质量、特征选择、模型算法及评估指标，同时通过不断优化和更新，确保模型在实际应用中的准确性和可靠性。
支持向量机（SVM）
最新发布
2201_76139143的博客
07-18 754
支持向量机(Support Vector Machine：SVM)的目的是用训练数据集的间隔最大化找到一个最优分离超平面。这里面有两个概念间隔最大化和最优分离超平面。
AI算法16-贝叶斯线性回归算法Bayesian Linear Regression | BLR
yangguangjiujiu99的专栏
07-15 1100
线性回归的频率主义观点可能你已经学过了：该模型假定因变量（y）是权重乘以一组自变量（x）的线性组合。完整的公式还包含一个误差项以解释随机采样噪声。如有两个自变量时，方程为：模型中，y是因变量，β是权重（称为模型参数），x是自变量的值，ε是表示随机采样噪声的误差项或变量的影响。线性回归是一个简单的模型，它可以很容易解释：是截距项，其他权重β表示增加自变量对因变量的影响。例如，如果是1.2，那么对于中的每个单位增加，响应将增加1.2。我们可以使用矩阵方程将线性模型推广到任意数量的预测变量。
机器学习概述
2301_76828807的博客
07-15 371
机器学习概述
借助高能效GaN转换器，提高充电器和适配器设计的功率密度
Qingniu01的博客
07-16 660
在PD运行模式下，谐振电流和磁化电流之间的电流差经由变压器和整流器传递到二次侧，从而实现给负载供电. 除此之外，所有一个侧MOSFET均随ZVS谐振接通，从而完全回收存储在MOSFET寄生输出电容中的能量。能够实现更高功率密度的转换器拓扑 事实证明，得益于零电压开关（ZVS）和无缓冲损耗，诸如有源钳位反激式（ACF）、混合反激式（HFB）和LLC转换器等半桥（HB）拓扑，即使在很高开关频率下也能实现高能效。采用与LLC转换器相同的技术，在这种拓扑中，变压器漏感和磁化电感可与电容器发生谐振。
NumPy与线性代数：掌握机器学习中的矩阵操作艺术
eclipsercp的博客
07-15 734
通过本文，我们详细介绍了NumPy库在数据处理和线性代数运算中的应用。NumPy不仅提供了高效的多维数组对象，还内置了丰富的数学函数，特别是针对线性代数的操作。掌握NumPy的这些基础操作，将为我们后续的机器学习应用提供有力的支持。希望本文能帮助读者更好地理解NumPy与线性代数的关系，并在实践中灵活运用这些知识。随着学习的深入，你将能够解锁更多NumPy的高级特性和功能，进一步提升你的数据分析和科学计算能力。
十六、【机器学习】【监督学习】- 支持向量回归 (SVR)
技术分享、程序员趣事、行业趋势等内容！
07-18 682
在先前的文章系列中，我们深入探讨了机器学习的基础框架和算法分类，为读者构建了关于这一领域的坚实理论基础。本章节我们将焦点转向监督学习领域中的一个核心算法—— 神经网络回归，旨在详尽解析其内在逻辑、应用实践及重要参数调整策略。监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。
深入剖析 Scikit-learn 中的 LogisticRegression：参数调优指南
2402_85762143的博客
07-15 548
Logistic Regression 通过使用逻辑函数将线性回归的输出映射到 0 和 1 之间，从而进行二分类。它是一种概率分类器，可以给出每个类别的预测概率。
彻底改变时尚：使用 GAN 实现 AI 的未来
gongdiwudu的专栏
07-16 1065
​ 想象一下，在这个世界里，时装设计师永远不会用完新想法，我们穿的每一件衣服都是一件艺术品。听起来很有趣，对吧？好吧，我们可以在通用对抗网络 （GAN）的帮助下在现实中实现这一目标。GAN模糊了现实与想象之间的界限。它就像一个瓶子里的精灵，满足了我们所有的创造性愿望。我们甚至可以在GAN的帮助下在地球上创造一个太阳，这在现实生活中是不可能的。​

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值