Python决策树实现 适用分类变量、连续变量、缺失值

最新推荐文章于 2024-05-04 03:12:00 发布
最新推荐文章于 2024-05-04 03:12:00 发布
阅读量7.6k 收藏 19
点赞数 2
分类专栏： 机器学习 文章标签： 决策树 缺失值 分类变量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38204423/article/details/81903925
版权

按照周老师书上讲的用权重处理缺失值，发现问题很多。每当决策树选择包含缺失值的属性作为分割条件时，该属性包含缺失值的实例将被同时分配到每个子节点，这无疑将增加运算量。同时，各项退出条件的设置也不能再依据实例个数而应该是权重。总的来说，按照书上写的实现一遍，很多以前不懂的都一下子明白了。对sk learn中的决策树也有了更好的理解

CART算法对分类变量也是用的二叉树，这样不仅能提升运算速度，感觉这样能通过将分类变量进行组合，获得更好的泛化性能。

min_samples_split应该是不如min_samples_leaf的，但min_samples_leaf是先生成树，再剪枝叶节点样本小于某个值的，会耗费更多的运算，但min_samples_split太粗糙。比如min_samples_split=10时，会出现上一个节点12，划分后不同属性值都只有3、4个的情况。而用min_samples_leaf就会剪掉。我只实现了min_samples_split

没有写根据泛化性能剪枝的步骤。

 

 

这是不能处理缺失值的

import numpy as np
import pandas as pd
from pandas import DataFrame,Series

def Cal_entropy(frame,labelPosition):
    val_count = frame.loc[:, labelPosition].value_counts()
    pct_val = val_count / val_count.sum()
    log_pct = pct_val.map(np.log2)
    shannon_ent = -(pct_val * log_pct).sum()
    return shannon_ent


def BestFeatureToSplit(frame,infoFunction,labelPosition,featureClass):
    leastChaos = np.inf
    separatePoint = -1
    classColumnName = 'bestColumnName'
    for column in featureClass.index:
        if featureClass[column] == 0:
            valueCounts = frame[column].value_counts()
            if len(valueCounts) == 1:
                continue
            Chaos = (frame.groupby(column).\
            apply(infoFunction,labelPosition=labelPosition)*\
            (valueCounts/frame.shape[0])).sum()
            if Chaos < leastChaos:
                leastChaos = Chaos
                classColumnName = column            
        else:
            sortList = frame[column].drop_duplicates().sort_values()
            if len(sortList) == 1:
                continue
            sortList.index = np.arange(len(sortList))
            separatePointList = (round((sortList[i]+sortList[i+1])/2,4) 
                             for i in range(len(sortList)-1))
            for i in separatePointList:
                Compare = lambda x:'>%s'%i if x>i else '<=%s'%i
                classBy = frame[column].map(Compare)
                Chaos = (frame.groupby(classBy).\
                        apply(infoFunction,labelPosition=labelPosition)*\
                        (classBy.value_counts()/frame.shape[0])).sum()
                if Chaos<leastChaos:
                    leastChaos = Chaos
                    separatePoint = i
                    classColumnName = column
    return classColumnName,separatePoint


def ValueUnderCategory(frame,featureClass):
    valueUnderCategory = {}
    for column in featureClass.index:
        if featureClass[column] == 0:
            valueUnderCategory[column] = frame[column].unique()
    return valueUnderCategory
    
    
def CreateTree(frame, labelPosition,featureClass, infoFunction, valueUnderCategory):
    if len(frame.loc[:, labelPosition].unique()) == 1:
        return frame[labelPosition].iloc[0]
    if len(frame) <=5 :
        return frame[labelPosition].value_counts().index[0]
    classColumnName, separatePoint = BestFeatureToSplit(frame,
                                                 infoFunction, labelPosition, featureClass)    
    if classColumnName == 'bestColumnName':
        return frame[labelPosition].value_counts().index[0]  #从逻辑上说，应该先判断所有退出条件，再执行最佳路径选择函数    
    mytree = {classColumnName: {}}                           #但这样会增加运算量，而路径选择函数里也需要调用类似的部分
    if featureClass[classColumnName] == 0:                   #所以把这个退出条件写成了根据路径选择结果判断
        #del (featureClass[classColumnName])
        for value in valueUnderCategory[classColumnName]:
            subfeatureClass = featureClass.drop(index=classColumnName)
            subframe = frame[frame.loc[:, classColumnName] == value]
            if len(subframe) == 0:
                mytree[classColumnName][value] = frame[labelPosition].value_counts().index[0]
            else:
                mytree[classColumnName][value] = CreateTree(subframe, 
                  labelPosition, subfeatureClass, infoFunction, valueUnderCategory)
    else:
        subframeUnder = frame[frame.loc[:, classColumnName]<=separatePoint]
        subframeAbove = frame[frame.loc[:, classColumnName]>separatePoint]
        mytree[classColumnName]['<=%s'%separatePoint] = CreateTree(subframeUnder, 
                  labelPosition, featureClass, infoFunction, valueUnderCategory)
        mytree[classColumnName]['>%s'%separatePoint] = CreateTree(subframeAbove, 
                  labelPosition, featureClass, infoFunction, valueUnderCategory)
    return mytree

能处理缺失值的

import numpy as np
import pandas as pd
from pandas import DataFrame,Series

def DataPrepare(frame):
    frameCut = frame.loc[:,['Pclass','Age','SibSp','Parch','Fare','Embarked',
                 'Sex','Survived']]
    fun_fix_Cabin = lambda x: 'Z' if x is np.nan else x[0]
    frameCut['W'] = 1
    frameCut['Cabin'] = frame['Cabin'].map(fun_fix_Cabin)
    return frameCut
    
def Cal_entropy(frame,labelPosition):
    val_count = frame.groupby(labelPosition)['W'].sum()
    pct_val = val_count / val_count.sum()
    log_pct = pct_val.map(np.log2)
    shannon_ent = -(pct_val * log_pct).sum()
    return shannon_ent

def BestFeatureToSplit(frame,infoFunction,labelPosition,featureClass):
    maxGain = -1
    separatePoint = -1
    classColumnName = 'bestColumnName'
    weightListFinal = Series([])
    for column in featureClass.index:
        if featureClass[column] == 0:
            valueWeight = frame.groupby(column)['W'].sum()
            sumOfWeight = valueWeight.sum()
            weightList = valueWeight/sumOfWeight            
            nullRatio = frame[frame[column].notnull()]['W'].sum() / \
                        frame['W'].sum()
            
            gain = (Cal_entropy(frame,labelPosition)-(frame.groupby(column).\
            apply(infoFunction,labelPosition=labelPosition)*\
            weightList).sum())*nullRatio
            if gain > maxGain:
                maxGain = gain
                classColumnName = column  
                weightListFinal = weightList
        else:
            sortList = frame[column].drop_duplicates().dropna().sort_values()
            if len(sortList) in (1,0):
                continue
            sortList.index = np.arange(len(sortList))
            separatePointList = (round((sortList[i]+sortList[i+1])/2,4) 
                             for i in range(len(sortList)-1))
            frameNotNull = frame[frame[column].notnull()]
            nullRatio = frameNotNull['W'].sum() / frame['W'].sum()                        
            sumOfWeight = frameNotNull['W'].sum()
            for i in separatePointList:
                Compare = lambda x:'>%s'%i if x>i else '<%s'%i
                classBy = frameNotNull[column].map(Compare)
                valueWeight = frameNotNull.groupby(classBy)['W'].sum()
                weightList = valueWeight / sumOfWeight
                gain = (Cal_entropy(frame,labelPosition)-(frameNotNull.groupby(classBy).\
                        apply(infoFunction,labelPosition=labelPosition)*\
                        weightList).sum())*nullRatio
                if gain > maxGain:                   
                    maxGain = gain
                    separatePoint = i
                    classColumnName = column
                    weightListFinal = weightList
    return classColumnName,separatePoint,weightListFinal


def ValueUnderCategory(frame,featureClass):
    valueUnderCategory = {}
    for column in featureClass.index:
        if featureClass[column] == 0:
            valueUnderCategory[column] = frame[column].unique()
    return valueUnderCategory
    
    
def CreateTree(frame, labelPosition,featureClass, infoFunction, valueUnderCategory):
    weightLabelList = frame.groupby(labelPosition)['W'].sum()
    if weightLabelList.max()/weightLabelList.sum() > 0.95:
        return weightLabelList.idxmax()                    
    if frame['W'].sum() <8 :
        return frame[labelPosition].value_counts().index[0]     
    classColumnName, separatePoint, weightListFinal = BestFeatureToSplit(frame,
                                                 infoFunction, labelPosition, featureClass)

    if classColumnName == 'bestColumnName':
        return frame[labelPosition].value_counts().index[0]
    #print(classColumnName,separatePoint,weightListFinal)      
    mytree = {classColumnName: {}}  
    #print(classColumnName)                                   
    if featureClass[classColumnName] == 0:                   
        #del (featureClass[classColumnName])
        for value in valueUnderCategory[classColumnName]:
            subfeatureClass = featureClass.drop(index=classColumnName)
            subframe_1 = frame[frame.loc[:, classColumnName] == value]           
            if len(subframe_1) == 0:                               
                mytree[classColumnName][value] = frame[labelPosition].value_counts().index[0]
            else:                
                subframe_2 = frame.loc[frame[classColumnName].isnull()]
                subframe_2['W'] = subframe_2['W']*weightListFinal[value]
                subframe = pd.concat([subframe_1,subframe_2])
                mytree[classColumnName][value] = CreateTree(subframe, 
                  labelPosition, subfeatureClass, infoFunction, valueUnderCategory)
    else:
        #print(separatePoint)
        subframeUnder_1 = frame[frame[classColumnName]<separatePoint]
        subframeAbove_1 = frame[frame[classColumnName]>separatePoint]
        subframeUnder_2 = frame.loc[frame[classColumnName].isnull()]
        subframeUnder_2['W']=subframeUnder_2['W']*weightListFinal['<%s'%separatePoint]
        subframeAbove_2 = frame.loc[frame[classColumnName].isnull()]
        subframeAbove_2['W']=subframeAbove_2['W']*weightListFinal['>%s'%separatePoint]
        subframeUnder = pd.concat([subframeUnder_1, subframeUnder_2])
        subframeAbove = pd.concat([subframeAbove_1, subframeAbove_2])
        mytree[classColumnName]['<%s'%separatePoint] = CreateTree(subframeUnder, 
                  labelPosition, featureClass, infoFunction, valueUnderCategory)
        mytree[classColumnName]['>%s'%separatePoint] = CreateTree(subframeAbove, 
                  labelPosition, featureClass, infoFunction, valueUnderCategory)
    return mytree

调用和结果

path = 'E:/titanic/'
train = pd.read_csv(path + 'train.csv',index_col=[0])
test = pd.read_csv(path + 'test.csv',index_col=[0])
trainCut = DataPrepare(train)
featureClass = Series([0,1,1,1,1,0,0,0],index=['Pclass','Age','SibSp','Parch','Fare','Embarked','Sex','Cabin'])
valueUnderCategory = ValueUnderCategory(trainCut,featureClass)
BestFeatureToSplit(trainCut,Cal_entropy,'Survived',featureClass)
CreateTree(trainCut, 'Survived',featureClass, Cal_entropy, valueUnderCategory)
{'Sex': {'female': {'Pclass': {1: 1,
    2: {'Age': {'<56.0': {'Fare': {'<26.125': {'Fare': {'<12.825': 1,
          '>12.825': {'Age': {'<23.5': 1,
            '>23.5': {'Age': {'<27.5': 1,
              '>27.5': {'Age': {'<37.0': 1, '>37.0': 1}}}}}}}},
        '>26.125': 1}},
      '>56.0': 0}},
    3: {'Fare': {'<23.35': {'Embarked': {'C': {'Fare': {'<15.4938': {'Fare': {'<13.9354': 1,
            '>13.9354': 0}},
          '>15.4938': 1}},
        'Q': {'Parch': {'<0.5': {'Fare': {'<7.6812': 0,
            '>7.6812': {'Age': {'<20.0': {'Age': {'<15.5': 1, '>15.5': 1}},
              '>20.0': 1}}}},
          '>0.5': 0}},
        'S': {'Age': {'<36.5': {'Age': {'<32.0': {'Fare': {'<7.7625': 1,
              '>7.7625': {'Fare': {'<10.825': {'Fare': {'<10.1521': {'Parch': {'<0.5': {'Fare': {'<9.8396': {'Fare': {'<8.7666': {'Fare': {'<8.6729': {'Fare': {'<7.9875': {'Age': {'<18.5': 0,
                              '>18.5': 1}},
                            '>7.9875': 0}},
                          '>8.6729': 1}},
                        '>8.7666': 0}},
                      '>9.8396': 1}},
                    '>0.5': 1}},
                  '>10.1521': 0}},
                '>10.825': {'Fare': {'<17.25': {'SibSp': {'<0.5': 1,
                    '>0.5': 1}},
                  '>17.25': 0}}}}}},
            '>32.0': 1}},
          '>36.5': 0}},
        nan: 1}},
      '>23.35': {'Parch': {'<0.5': 1,
        '>0.5': {'Fare': {'<31.3312': 0, '>31.3312': 0}}}}}}}},
  'male': {'Cabin': {'A': {'Fare': {'<54.4646': {'Fare': {'<37.8125': 1,
        '>37.8125': 0}},
      '>54.4646': 1}},
    'B': {'Fare': {'<85.1396': {'Fare': {'<30.1': 0, '>30.1': 0}},
      '>85.1396': 1}},
    'C': {'Age': {'<17.5': 1,
      '>17.5': {'Fare': {'<98.2125': {'Age': {'<28.5': 1,
          '>28.5': {'Age': {'<47.5': {'Age': {'<37.5': 0, '>37.5': 0}},
            '>47.5': 1}}}},
        '>98.2125': 0}}}},
    'D': {'Fare': {'<77.0084': {'Fare': {'<58.2292': 0, '>58.2292': 1}},
      '>77.0084': 0}},
    'E': {'Age': {'<44.0': 1, '>44.0': 0}},
    'F': 0,
    'G': 0,
    'T': 0,
    'Z': {'Age': {'<9.5': {'SibSp': {'<2.5': {'Parch': {'<0.5': 0, '>0.5': 1}},
        '>2.5': {'Parch': {'<1.5': 0, '>1.5': 0}}}},
      '>9.5': {'Fare': {'<54.2479': {'Embarked': {'C': {'Fare': {'<27.1354': {'Fare': {'<15.1479': {'Age': {'<29.5': {'Fare': {'<14.1584': {'Fare': {'<9.9771': {'SibSp': {'<0.5': {'Fare': {'<5.6188': 0,
                        '>5.6188': {'Fare': {'<8.3042': {'Fare': {'<7.5625': {'Age': {'<22.75': 0,
                              '>22.75': 0}},
                            '>7.5625': 0}},
                          '>8.3042': 0}}}},
                      '>0.5': 0}},
                    '>9.9771': 1}},
                  '>14.1584': 0}},
                '>29.5': 0}},
              '>15.1479': 1}},
            '>27.1354': 0}},
          'Q': {'SibSp': {'<1.5': {'Fare': {'<7.7458': 0,
              '>7.7458': {'Age': {'<30.0': 0, '>30.0': 0}}}},
            '>1.5': 1}},
          'S': {'Parch': {'<0.5': {'Fare': {'<26.275': {'Fare': {'<13.25': {'Fare': {'<7.9104': {'Fare': {'<7.8646': {'Age': {'<32.5': {'Age': {'<23.5': 0,
                        '>23.5': {'Fare': {'<7.0104': 0,
                          '>7.0104': {'Age': {'<31.5': {'Age': {'<27.5': {'Age': {'<26.5': {'Fare': {'<7.0958': 0,
                                  '>7.0958': 0}},
                                '>26.5': 0}},
                              '>27.5': 0}},
                            '>31.5': 0}}}}}},
                      '>32.5': 0}},
                    '>7.8646': 0}},
                  '>7.9104': {'Fare': {'<7.9875': {'SibSp': {'<1.5': 0,
                      '>1.5': 0}},
                    '>7.9875': {'Age': {'<19.5': {'Fare': {'<8.1354': 0,
                        '>8.1354': {'Age': {'<18.5': 0, '>18.5': 0}}}},
                      '>19.5': {'Age': {'<26.5': 0,
                        '>26.5': {'Fare': {'<8.0812': 0,
                          '>8.0812': {'Age': {'<31.5': {'Pclass': {1: 0,
                              2: 0,
                              3: 0}},
                            '>31.5': {'Age': {'<40.5': 0,
                              '>40.5': 0}}}}}}}}}}}}}},
                '>13.25': 0}},
              '>26.275': 0}},
            '>0.5': 0}},
          nan: 0}},
        '>54.2479': {'Fare': {'<58.9375': 1,
          '>58.9375': {'Fare': {'<107.9104': 0, '>107.9104': 0}}}}}}}}}}}}

决策树的使用还是有问题，看西瓜书决策树这一章，讲了在生成树时如何处理缺失数据，但没讲如何用这样生成的树去分类包含缺失值的实例。

这是不支持预测缺失值的

def Predict(ser,tree,featureClass):    
    for feature in tree:
        if featureClass[feature] == 0:            
            categoryValue = tree[feature][ser[feature]]   
            if not isinstance(categoryValue,dict):
                return categoryValue
            return Predict(ser, categoryValue, featureClass)
        classValue = float(list(tree[feature].keys())[0][1:])
        if ser[feature] < classValue:
            if not isinstance(tree[feature]['<%s'%classValue],dict):
                return tree[feature]['<%s'%classValue]
            return Predict(ser, tree[feature]['<%s'%classValue], featureClass)
        if not isinstance(tree[feature]['>%s'%classValue],dict):
            return tree[feature]['>%s'%classValue]
        return Predict(ser, tree[feature]['>%s'%classValue], featureClass)

def PredictMore(frame,tree,featureClass):
    result = Series(index=frame.index)
    for i in frame.index:
        ser = frame.loc[i]
        predictValue = Predict(ser,tree,featureClass)
        result[i] = predictValue
    return result

 

等风来ing
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
决策树 Decision Tree
shy19890510的博客
03-12 874
决策树是一个有监督的分类算法，在每次分裂中都找到最容易区分一个集合和另一个集合的特征。在寻找最优特征时，DT算法保证了局部最优，但整体上看不一定是全局最优。一、目标 target因为决策树是一个有监督的算法，所以样本已经有一个变量用来表征这个样本的target，可能是正例/反例，也可以是多个类别（比如高/中/低）二、模型输入 model input在实际应用中，无论是离散特征还是连续特征，其实都可...
Python手撸机器学习系列（十二）：连续特征决策树与缺失值决策树实现
qq_43601378的博客
04-08 4773
连续值与缺失值决策树 本节代码和理论主要参考自周志华《机器学习》 ID3、C4.5以及CART决策树和剪枝代码请参考我的上一篇博客https://blog.csdn.net/qq_43601378/article/details/121360503?spm=1001.2014.3001.5502 1. 连续值决策树 对于连续特征，不能再根据连续属性的可取值对节点进行划分，而是应该使用取值范围进行划分。最简单的策略是二分法，即先将所有样本的取值排序，然后去两个样本取值的中点作为一个切分点，如有n个样本，则共计
2024年Python最新python实现决策树算法_python决策树 generate_tree_code()，2024年最新腾讯nlp面经
最新发布
2401_84140060的博客
05-04 1117
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
python-机器学习-决策树-decision tree
Guoguounique的博客
08-18 548
以是否有房这个特征为例子，在有房子的人当中，不是所有的都是可选择的监护人，也不是所有没有房子的都不适合做监护人。我一开始做的时候个人主观觉得房子很重要，但是根据数据计算出来的gini系数，月薪是否过万这个特征变量才是最好的。比如 是否有房可以筛选出四个符合条件的监护人，是否有车可以是筛选出3个，月薪是否过万，可以选择出4个。对了，文章一开始作为例子贴的那张根节点的图是错误的，我们不应该选择是否有房作为根节点。根节点也就是最重要的特征，在选择监护人的例子里面，我们选择是否有房作为根节点。...
决策树分类
David_jiang
04-05 1万+
决策树（ Decision Tree ）又称为判定树，是运用于分类的一种树结构。其中的每个内部结点（ internal node ）代表对某个属性的一次测试，每条边代表一个测试结果，叶结点（ leaf ）代表某个类（ class ）或者类的分布（ class distribution ），最上面的结点是根结点。决策树分为分类树和回归树两种，分类树对离散变量做决策树，回归树对连续变量做决策树。
机器学习基础学习－－决策树
雪泪寒的博客
09-03 151
决策树是一种基本的分类与回归方法
机器学习 决策树篇——解决离散变量的分类问题
Cyrus_May的博客
05-19 4926
机器学习 决策树篇——解决离散变量的分类问题摘要熵增益和熵增益率计算熵增益和熵增益率运行结果离散变量的决策树模型决策树模型运行结果 摘要 本文通过python实现了熵增益和熵增益率的计算、实现了离散变量的决策树模型，并将代码进行了封装，方便读者调用。 熵增益和熵增益率计算 此对象用于计算离散变量的熵、条件熵、熵增益（互信息）和熵增益率 .cal_entropy()：计算熵的函数 .cal_conditional_entropy()：计算条件熵的函数 .cal_entropy_gain()：计算熵增益（互信息
用python实现决策树算法
12-17
在这个"用Python实现决策树算法"的资料包中，包含的是C4.5决策树和ID3决策树的Python实现，以及用于训练和测试的数据集。 首先，让我们深入理解这两个决策树算法： 1. ID3（Iterative Dichotomiser 3）：这是最早...
python实现决策树分类算法
07-23
下面是一个简单的Python决策树分类器实现： ```python from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier ...
决策树算法C5.0-in-Python-master
09-14
1. **数据预处理**：首先，需要对数据进行清洗，处理缺失值，可能还需要进行数据类型转换，比如将连续变量离散化，以便于决策树处理。 2. **导入库**：使用`pandas`读取数据，用`rpart`或`sklearn`库实现C5.0。`...
python数据分析之决策树实践
12-21
在Python中，可以使用scikit-learn库中的`DecisionTreeClassifier`进行分类决策树的实现。包括特征选择、训练、预测及调参等步骤。 7.2 回归决策树实践 同样，scikit-learn提供了`DecisionTreeRegressor`用于回归...
数据挖掘 | [有监督学习——分类] 决策树基本知识及python代码实现——利用sklearn
12-21
总的来说，决策树是一种直观且易于解释的分类算法，适用于处理离散型和连续型特征。`sklearn`库提供了丰富的功能，可以方便地实现决策树的构建、训练、预测以及可视化。在数据挖掘中，决策树常常与其他算法如关联...
分类情况下处理缺失值方法综述
THE_CS_UNIVERSE的博客
01-07 3934
1.删除含有缺失值实例 分为只要含有缺失值的即删除和关键值缺失的实例删除 2.基于统计学计算 1）使用均值填充 使用在该部分不缺失的实例的均值填充 使用同类在该部分不缺失的实例的均值填充 2）回归计算 线性回归计算和非线性回归计算 3）Hot and cold deck imputation Hot deck imputation 使用本数据集中在其他不缺失值方面最接近的实例在缺失特征上的值来替代 Cold deck imputation 使用其他数据集的数据，余同Hot deck imputation。
决策树缺失值python_决策树处理缺失值
weixin_39559804的博客
12-06 727
缺失值问题可以从三个方面来考虑1. 在选择分裂属性的时候，训练样本存在缺失值，如何处理？(计算分裂损失减少值时，忽略特征缺失的样本，最终计算的值乘以比例(实际参与计算的样本数除以总的样本数))假如你使用ID3算法，那么选择分类属性时，就要计算所有属性的熵增(信息增益，Gain)。假设10个样本，属性是a,b,c。在计算a属性熵时发现，第10个样本的a属性缺失，那么就把第10个样本去掉，前9个样本组...
使用R完成决策树分类
热门推荐
不是码农
04-06 4万+
关于决策树理论方面的介绍，李航的《统计机器学习》第五章有很好的讲解。 传统的ID3和C4.5一般用于分类问题，其中ID3使用信息增益进行特征选择，即递归的选择分类能力最强的特征对数据进行分割，C4.5唯一不同的是使用信息增益比进行特征选择。 特征A对训练数据D的信息增益g(D, A) = 集合D的经验熵H(D) - 特征A给定情况下D的经验条件熵H(D|A) 特征A对训练数据D的信息增益比r
用决策树实现分类（预测）实战（python）
t18438605018的博客
11-30 7341
1.决策树原理 决策树（decision tree）是一类常见的机器学子方法。具体的原理这里不做介绍，读者可以简单理解为：要用决策树做未知样本的分类（预测），一定要现根据已有样本，寻，训练、产生一颗泛化能力强，即能处理未知样本的决策树。 2.用决策树做分类的例子 a.数据集，名为getbed.csv 季节 时间已过八点 风力情况 要不要赖床 spring no breeze yes winter no no wind yes autumn yes breeze yes winter no no wind
数据结构 - 决策树(分类)
为了更好的未来_加油
05-21 9656
数据结构 - 决策树一决策树的介绍二决策树的构造使用决策树做预测需要以下过程：1.信息熵2.条件熵(Conditional Entropy)与[信息增益](https://so.csdn.net/so/search?q=信息增益&spm=1001.2101.3001.7020)（Information Gain）3.信息增益做特征选择的优缺点4.信息增益比(Infomation Gain Ratio)5.Gini系数 一决策树的介绍 决策树（decision tree）：是一种基本的分类与回归方法，
sklearn决策树（Decision Tree）多分类问题
Yvesx的博客
12-09 1万+
文章目录步骤建立模型特征选择预剪枝预处理训练测试+评价模型可视化不同的criterion和max_depth训练决策树结果 步骤 建立模型 class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, ran
数据预处理——4种缺失值处理方法
user_lib的博客
07-28 4万+
1.删除含有缺失值的个案 主要有简单删除法和权重法。简单删除法是对缺失值进行处理的最原始方法。它将存在缺失值的个案删除。如果数据缺失问题可以通过简单的删除小部分样本来达到目标，那么这个方法是最有效的。当缺失值的类型为非完全随机缺失的时候，可以通过对完整的数据加权来减小偏差。把数据不完全的个案标记后，将完整的数据个案赋予不同的权重，个案的权重可以通过logistic或probit回归求得。如果解释变量中存在对权重估计起决定行因素的变量，那么这种方法可以有效减小偏差。如果解释变量和权重并不相关，它并不能减小偏差
python决策树缺失值
08-24
在Python中，处理决策树中的缺失值有几种常见的方法： 1. 删除缺失值：最简单的方法是直接删除含有缺失值的样本或特征。这种方法适用于缺失值较少的情况，但可能会导致样本数量减少或信息损失。 2. 填充缺失值：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值