机器学习：多种算法处理填充后的数据

最新推荐文章于 2024-10-10 23:18:01 发布
最新推荐文章于 2024-10-10 23:18:01 发布
阅读量2.3k 收藏 22
点赞数 41
文章标签： 机器学习 算法 人工智能 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mohanyelong/article/details/142031684
版权

在机器学习中，填充数据（即处理缺失值）后，选择合适的算法并优化模型以提高召回率是一个常见的任务。召回率是指模型正确识别的正例占所有实际正例的比例。

代码思路：

  1. 数据预处理：

    • 导入填充后的数据                                                                                                              
      import pandas as pd
import numpy as np
train_data=pd.read_excel('训练数据集[随机森林填充].xlsx')

test_data=pd.read_excel('测试数据集[随机森林填充].xlsx')

  2. 特征与标签提取

    • 从数据集中提取特征和标签。                                                                                            
      train_data_x=train_data.drop('矿物类型',axis=1)
train_data_y=train_data['矿物类型']

test_data_x=test_data.drop('矿物类型',axis=1)
test_data_y=test_data['矿物类型']

#初始化存储所有算法的召回率字典
result_data={}

  3. 网格搜索(寻找最优参数可能时间花费较长)

    • 用于超参数优化的方法，它系统地遍历多种超参数的组合，通过交叉验证来确定最佳的超参数设置。

    • 步骤

      • 定义参数网格：

        • 确定需要优化的超参数及其可能的值。例如，学习率、正则化参数、树的深度等。

      • 设置交叉验证：

        • 选择交叉验证的折数（如5折或10折），这将影响模型评估的稳健性。

      • 初始化模型：

        • 选择一个基线模型，如逻辑回归、支持向量机、随机森林等。

      • 配置网格搜索：

        • 使用网格搜索算法，输入模型、参数网格和交叉验证设置。

      • 训练和评估：

        • 网格搜索算法将遍历所有参数组合，对每一组参数使用交叉验证来评估模型性能。

      • 选择最佳参数：

        • 根据交叉验证的结果，选择表现最好的参数组合。

      • 最终模型训练：

        • 使用最佳参数在完整的训练数据集上重新训练模型。                                      
          from sklearn.model_selection import GridSearchCV
param_grid={
    'penalty':['l1','l2','elasticnet','none'],
    'C':[0.001,0.01,0.1,1,10,100],
    'solver':['newton_cg','lbfgs','linear','sag','sage'],
    'max_iter':[100,200,500],
    'multi_class':['auto','ovr','multionmial']
}
from sklearn.linear_model import LogisticRegression
lohreg=LogisticRegression()
grid_search=GridSearchCV(lohreg,param_grid,cv=5)
grid_search.fit(train_data_x,train_data_y)
print('最佳参数')
print(grid_search.best_params_)

  4. 模型训练：

    • 使用训练数据集来训练模型。
    • 使用交叉验证来评估模型的稳定性和性能。

  5. 性能评估：

    • 使用测试数据集来评估模型的性能。
    • 重点观察召回率，但也要考虑精确度、F1分数等其他指标。

  6. 模型优化：

    • 调整模型的超参数，如树的深度、学习率、正则化参数等。
    • 使用网格搜索（Grid Search）或随机搜索（Random Search）来找到最优的超参数组合。

  7. 模型选择：

    • 比较不同模型的性能，选择召回率最高的模型。
    • 考虑模型的复杂度和训练时间，选择一个平衡性能和效率的模型。

  8. 选择算法：

    • 线性回归                                                                                                                           

      # 初始化逻辑回归模型
lr = LogisticRegression(C=10, max_iter=500, penalty='l2', solver='lbfgs')

# 训练模型
lr.fit(train_data_x, train_data_y)

# 预测训练集
train_pred = lr.predict(train_data_x)
# 打印训练集的分类报告
print('LR的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = lr.predict(test_data_x)
# 打印测试集的分类报告
print('LR的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
LR_result = {}

# 提取召回率和准确率
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['accuracy'] = float(b[25])  # 添加准确率

# 将逻辑回归的结果添加到总体结果字典中
result_data = {'LR': LR_result}

# 打印结束信息
print('LR结束')

    • 支持向量机（SVM）                                                                                                       

      # 初始化SVM分类器
svm_model = svm.SVC(
    C=1, 
    coef0=0.1, 
    degree=4, 
    gamma=1, 
    kernel='poly', 
    probability=True, 
    random_state=100
)

# 训练模型
svm_model.fit(train_data_x, train_data_y)

# 预测训练集
train_pred = svm_model.predict(train_data_x)
# 打印训练集的分类报告
print('SVM的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = svm_model.predict(test_data_x)
# 打印测试集的分类报告
print('SVM的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
svm_result = {}

# 提取召回率和准确率
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['accuracy'] = float(b[25])  # 添加准确率

# 将SVM的结果添加到总体结果字典中
result_data = {'svm': svm_result}

# 打印结束信息
print('SVM结束')
                                            

    • 随机森林                                                                                                                           

      # 初始化随机森林分类器
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_pred = rf.predict(train_data_x)
# 打印训练集的分类报告
print('RF的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = rf.predict(test_data_x)
# 打印测试集的分类报告
print('RF的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
rf_result = {}

# 提取召回率和准确率
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['accuracy'] = float(b[25])  # 添加准确率

# 将随机森林的结果添加到总体结果字典中
result_data = {'rf': rf_result}

# 打印结束信息
print('RF结束')

    • AdaBoost                                                                                                       

      # 初始化AdaBoost分类器
abc = AdaBoostClassifier(
    algorithm='SAMME.R',  # 使用SAMME.R算法
    base_estimator=DecisionTreeClassifier(max_depth=2),  # 使用决策树作为基学习器
    n_estimators=200,  # 弱学习器的数量
    learning_rate=1.0,  # 学习率
    random_state=0  # 随机数种子
)

# 训练模型
abc.fit(train_data_x, train_data_y)

# 预测训练集
train_pred = abc.predict(train_data_x)
# 打印训练集的分类报告
print('AdaBoost的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = abc.predict(test_data_x)
# 打印测试集的分类报告
print('AdaBoost的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
abc_result = {}

# 提取召回率和准确率
abc_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
abc_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
abc_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
abc_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
abc_result['accuracy'] = float(b[25])  # 添加准确率

# 将AdaBoost的结果添加到总体结果字典中
result_data = {'abc': abc_result}

# 打印结束信息
print('AdaBoost结束')

    • XGBoost                                                                                                                           

      # 初始化XGBoost分类器
xgb = xgbs.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  # 随机数种子
)

# 训练模型
xgb.fit(train_data_x, train_data_y)

# 预测训练集
train_pred = xgb.predict(train_data_x)
# 打印训练集的分类报告
print('XGB的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = xgb.predict(test_data_x)
# 打印测试集的分类报告
print('XGB的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
xgb_result = {}

# 提取召回率和准确率
xgb_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
xgb_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
xgb_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
xgb_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
xgb_result['recall_4'] = float(b[26])  # 添加类别为4的召回率
xgb_result['accuracy'] = float(b[31])  # 添加准确率

# 将XGBoost的结果添加到总体结果字典中
result_data = {'xgb': xgb_result}

# 打印结束信息
print('XGB结束')

    • 高斯朴素贝叶斯(GaussianNB)                                                                                          

      # 初始化高斯朴素贝叶斯分类器
mb = GaussianNB()

# 训练模型
mb.fit(train_data_x, train_data_y)

# 预测训练集
train_pred = mb.predict(train_data_x)
# 打印训练集的分类报告
print('MNB的train:\n', metrics.classification_report(train_data_y, train_pred))

# 预测测试集
test_pred = mb.predict(test_data_x)
# 打印测试集的分类报告
print('MNB的test:\n', metrics.classification_report(test_data_y, test_pred))

# 获取分类报告的字符串表示，并分割成单独的部分
a = metrics.classification_report(test_data_y, test_pred, digits=6)
b = a.split()

# 初始化结果字典
mb_result = {}

# 提取召回率和准确率
mb_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
mb_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
mb_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
# 修正召回率的键名 'recall 3' 为 'recall_3'
mb_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
mb_result['accuracy'] = float(b[25])  # 添加准确率

# 将朴素贝叶斯的结果添加到总体结果字典中
result_data = {'mb': mb_result}

# 打印结束信息
print('MNB结束')

代码结果

完整代码

import pandas as pd
import numpy as np
train_data=pd.read_excel('训练数据集[随机森林填充].xlsx')
train_data_x=train_data.drop('矿物类型',axis=1)
train_data_y=train_data['矿物类型']

test_data=pd.read_excel('测试数据集[随机森林填充].xlsx')
test_data_x=test_data.drop('矿物类型',axis=1)
test_data_y=test_data['矿物类型']

result_data={}
# from sklearn.model_selection import GridSearchCV
# param_grid={
#     'penalty':['l1','l2','elasticnet','none'],
#     'C':[0.001,0.01,0.1,1,10,100],
#     'solver':['newton_cg','lbfgs','linear','sag','sage'],
#     'max_iter':[100,200,500],
#     'multi_class':['auto','ovr','multionmial']
# }
from sklearn.linear_model import LogisticRegression
# lohreg=LogisticRegression()
# grid_search=GridSearchCV(lohreg,param_grid,cv=5)
# grid_search.fit(train_data_x,train_data_y)
# print('最佳参数')
# print(grid_search.best_params_)

LR_result={}
lr=LogisticRegression(C=10,max_iter=500,penalty='l2',solver='lbfgs')
lr.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=lr.predict(train_data_x)
print('LR的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=lr.predict(test_data_x)
print('LR的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
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结束')



import xgboost as xgbs
xgb_result={}
xgb=xgbs.XGBClassifier(learning_rate=0.05,
n_estimators=200,
num_class = 5,
max_depth=7,
min_child_weight=1, # 叶子节点中最小的样本权重
qamma=0,#节点分裂所需的最小损失函数下降值
subsample=0.6,#训练样本的子样本比例
colsample_bytree=0.8,#每棵树随机采样的列数的占比
objective='multi:softmax',#损失函数类型(对于二分类问题)
seed=0 #随机数种子
)# 创建XGBoost分类器
xgb.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=xgb.predict(train_data_x)
print('xgb的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=xgb.predict(test_data_x)
print('xgb的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()


xgb_result['recall_0']= float(b[6])  # 添加类别为0的召回导
xgb_result['recall_1']= float(b[11])     # 添加类别为1的召回字
xgb_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
xgb_result['recall 3']= float(b[21])     # 添加类别为3的召回率
xgb_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['xgb']= xgb_result    # result_data是总体的结果,
print('xgb结束')

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
abc_result={}
abc = AdaBoostClassifier(algorithm='SAMME.R',  # 修正算法名称
                          base_estimator=DecisionTreeClassifier(max_depth=2),  # 修正类名
                          n_estimators=200,
                          learning_rate=1.0,  # 修正参数名称
                          random_state=0)
# abc=AdaBoostClassifier(algorithm='SAMME',base_estimator=DecisionTreeClassifier(max_depth=2),n_estimators=200,Learning_rate= 1.0,random_state=0)
abc.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=abc.predict(train_data_x)
print('abc的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=abc.predict(test_data_x)
print('abc的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()


abc_result['recall_0']= float(b[6])  # 添加类别为0的召回导
abc_result['recall_1']= float(b[11])     # 添加类别为1的召回字
abc_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
abc_result['recall 3']= float(b[21])     # 添加类别为3的召回率
abc_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['abc']= abc_result    # result_data是总体的结果,
print('AdaBoost结束')

from sklearn import svm
svm_result={}
svm=svm.SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#
svm.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=svm.predict(train_data_x)
print('svm的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=svm.predict(test_data_x)
print('svm的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()


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    # result_data是总体的结果,
print('svm结束')


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)
from sklearn import metrics
train_pred=rf.predict(train_data_x)
print('rf的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=rf.predict(test_data_x)
print('rf的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.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    # result_data是总体的结果,
print('rf结束')

from sklearn.naive_bayes import GaussianNB
mb_result={}
mb=GaussianNB()
mb.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=mb.predict(train_data_x)
print('mb的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=mb.predict(test_data_x)
print('mb的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()


mb_result['recall_0']= float(b[6])  # 添加类别为0的召回导
mb_result['recall_1']= float(b[11])     # 添加类别为1的召回字
mb_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
mb_result['recall 3']= float(b[21])     # 添加类别为3的召回率
mb_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['mb']= mb_result    # result_data是总体的结果,
print('mb结束')

import json
result={}
with open('随机森林填充.json','w') as f1:
    json.dump(result_data,f1,ensure_ascii=False)

夜清寒风
关注
机器学习之数据均衡算法种类大全+Python代码一文详解
master_hunter的博客
06-05 5624
对于整个数据建模来看，数据均衡算法属于数据预处理一环。当整个数据集从调出数据库到拿到手的时候，对于分类数据集来说类别一般都是不均衡的，整个数据集合也是较为离散的。因此不可能一拿到数据集就可进行建模，类别的不均衡会极大影响建模判断准确率。其中我们希望整个数据集合的类别数目都是相似的，这样其特征数据权重能够更好的计算出来，便于分类。对于预测模型也是如此。数据均衡是整个数学建模以及研究最重要不得不重视的一环，下面我将详细介绍数据均衡的方法以及运用的不同场景。一、为什么要做数据均衡？首先在进行实验之前我们要了解数据
【计算机科学基础】机器学习
付费专栏已不再维护，请勿购买
09-26 3011
本文分享机器学习的相关内容
44. 在应用机器学习算法之前纠正和清洗数据的步骤是什么1
08-03
1.将数据导入 2.看数据：重点看元数据，即对字段解释、数据来源等信息 3.缺失值清洗 4.数据格式清洗：统一数据的时间、日期、全半角等显示格式 5.逻辑错误的
【Algorithm】种子填充算法
liudongdong_jlu
06-13 1万+
转载：https://www.cnblogs.com/icmzn/p/5065306.html 【平面区域填充算法】是计算机图形学领域的一个很重要的算法，区域填充即给出一个区域的边界 （也可以是没有边界，只是给出指定颜色），要求将边界范围内的所有象素单元都修改成指定的颜色（也可能是图案填充）。区域填充中最常用的是多边形填色，本文讨论种子填充算法（Seed Filling）如果要填充的区域是以图像...
数据预处理 第3篇：数据预处理（使用插补法处理缺失值）
wuyy0224的博客
10-05 1万+
插补法可以在一定程度上减少偏差，常用的插补法是热卡插补、拟合插补和多重插补。拟合插补，要求变量间存在强的相关性；多重插补（MCMC法），是在高缺失率下的首选插补方法，优点是考虑了缺失值的不确定性。热卡填充（Hot deck imputation）也叫就近补齐，对于一个包含空值的对象，热卡填充法在完整数据中找到一个与它最相似的对象，然后用这个相似对象的值来进行填充。通常会找到超出一个的相似对象，在所有匹配对象中没有最好的，而是从中随机的挑选一个作为填充值。这个问题关键是不同的问题可能会选用不同的标准来对相似进
机器学习之数据预处理——缺失值填充
zxxxlh123的博客
10-19 7015
机器学习之数据预处理——缺失值 上一节给大家回顾了Pandas进行数据预处理会用到哪些方法，学习缺失值简单的填充方法（0、unknown、均值等），这节课学习线性回归法填补缺失值和拉格朗日插值法。 1.线性回归法填补缺失值 #随机生成一个线性回归数据 from sklearn.datasets import make_regression X,Y=make_regression(n_samples=100, n_features=1,n_targets=1,noise=10.5,random_state
机器学习实战25-用多种机器学习算法实现各种数据分析与预测
weixin_42878111的博客
09-23 1791
在当今信息爆炸的时代，数据已成为企业和组织的核心资产之一，它如同新时代的石油，潜藏着巨大的价值和洞察力。随着大数据技术的发展，数据的收集、存储和处理能力大幅提升，但如何从这些海量数据中提取出有价值的信息，以支持决策制定、优化业务流程、提升用户体验，乃至开拓新的商业模式，成为了各行业面临的重要挑战。这正是机器学习算法应用于数据分析项目的根本动机和时代背景。K-means算法的核心思想是通过迭代的方式将数据分配到K个聚类中，使得每个数据点到其所属聚类中心的距离平方和最小。初始化。
机器学习特征工程：处理缺失值填充的5大技巧
Python数据挖掘
12-10 1854
大家好，本文分享Pandas中的5大技巧：填充具体数值，通常是0填充某个统计值，比如均值、中位数、众数等填充前后项的值基于SimpleImputer类的填充基于KNN算法的填充。
机器学习的概念、步骤、分类和实践
热门推荐
用文字记录下每一个瞬间的感动和每一次思考的火花
03-30 9万+
机器学习是人工智能（AI）的一个分支，它使计算机能够从数据中学习并做出决策或预测的技术，而无需对每个问题进行明确的程序编写。这种学习和决策制定过程是通过对数据的分析和模式的识别来实现的。机器学习的核心在于开发算法，这些算法可以自动提取信息并使用这些信息来改进自身的性能。
机器学习流程—数据预处理 清洗
03-05 3万+
这里我们需要说明一下，虽然这里我们讲的是数据预处理，但是我们这里为了更加充分的理解我们后面的数据预处理，这里我们说明一下我们要解决什么样的问题，也就是定义问题。itanic数据集作为kaggle比赛中的经典数据集，今天我们使用的数据也是这个数据集，这个数据集描述的主要是泰坦尼克号邮轮上乘客的数据，我们要做的事情就是根据乘客的数据预测乘客在泰坦尼克号沉没的时候时候可以活下来。
机器学习基础：数学理论+算法模型+数据处理+应用实践 通过掌握统计概率、优化理论，精通分类、聚类算法，运用特征提取与清洗技术，赋
03-20
通过以上对机器学习基础知识的详细介绍，我们可以看出，机器学习不仅仅是一系列算法的应用，更是建立在深厚数学理论基础上的科学。掌握这些理论知识和技术，能够让我们更加深刻地理解机器学习的工作原理，并在实践中...
手把手教你使用Python实现机器学习算法.pdf
06-16
首先，我们关注的库是`scikit-learn`（简称sklearn），这是一个强大的机器学习库，提供了各种预处理、模型选择和评估工具，以及多种经典的机器学习算法。例如，K-Nearest Neighbors (KNN) 是一种基于实例的学习方法...
机器学习-基于决策树开发的分西瓜算法（西瓜书数据集）
04-27
这个数据集主要用于教学和实践，帮助学习者理解并应用机器学习算法，尤其是决策树。以下我们将详细介绍决策树的基本原理以及如何利用它解决分西瓜的问题。 1. **决策树的基本概念**： - 决策树是一种非参数的分类...
数据挖掘与机器学习：数据挖掘算法原理与实践：数据预处理
Shining0596_Limcy
11-22 4371
第一关本关任务：利用sklearn对数据进行标准化。为了完成本关任务，你需要掌握：1.为什么要进行标准化，2.Z-score标准化，3.Min-max标准化，4.MaxAbs标准化。第二关本关任务：利用sklearn对数据进行非线性转换。为了完成本关任务，你需要掌握：1.为什么要非线性转换，2.映射到均匀分布，3.映射到高斯分布。第三关本关任务：利用sklearn对数据进行归一化。第四关、本关任务：利用sklearn对标签进行OneHot编码。第五关、第六关。
《机器学习》周志华-CH10（降维与度量学习）
一名混沌的大学生
10-07 708
仅是得到了训练样本在低维空间的坐标，对于新样本，将高维空间坐标作为输入，低维空间坐标作为输出，训练一个回归学习器来对新样本的低维空间坐标进行预测。利用流形在局部上与欧氏距离同胚这个性质，计算两点之间测地线距离的问题，就转变为计算近邻连接图上两点之间最短路径问题。在高维情形下出现的数据样本稀疏、距离计算困难等问题，是所有机器学习方法共同面临的困难，称为“若直接使用线性降维方法对三维空间观察到的样本进行降维，则将丢失原本的低维结构。对正交属性空间中的样本点，如何用一个超平面对所有样本进行表达？
TY1801 内置GaN电源芯片（18w-65w)
最新发布
QQ_2169636881的博客
10-10 621
TY1801 是一款内置氮化镓18W-65W开关电源芯片，用于离线交流/直流转换应用，包括手机充电器和适配器等。TY1801A 18W；TY1801B 20W；TY1801C 25W；TY1801D 30W；TY1801DH 30W；TY1801E 35W；TY1801F 40W；TY1801G 45W；TY1801H 65W；
机器学习-树模型算法
weixin_47102187的博客
10-04 371
仅个人笔记使用，感谢点赞关注，希望可以帮到你！
Machine Learning Specialization 学习笔记（5）
qq_41136689的博客
10-08 1045
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV1Bq421A74G。
机器学习基础：模型、数据处理与过拟合
"这篇资源是关于机器学习的总结，涵盖了机器学习的基本概念、主要任务、数据处理、模型评估以及过拟合和欠拟合的处理方法。" 在机器学习领域，核心目标是让计算机通过数据自动学习规律，形成模型，以解决实际问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值