精华内容
下载资源
问答
  • 2020-11-01 21:09:05


    前言

    在研究机器学习,发现了一些宝藏算法,写下来让自己记住,超有用!同时也想要分享给大家,如果喜欢可以支持一下,谢谢。

    一、使用决策树和随机森林对数据分类

    使用决策树算法和随机森林算法对income_classification.csv的收入水平进行分类。训练集和测试集的比例是7:3,选取适当的特征列,使得针对测试样本的分类准确率在80%以上,比较2种分类方法的准确率。

    数据说明:

    特征列

    age:年龄,整数

    workclass:工作性质,字符串

    education:教育程度,字符串

    education_num:受教育年限,整数

    maritial_status:婚姻状况,字符串

    occupation:职业,字符串

    relationship:亲戚关系,字符串

    race:种族,字符串

    sex:性别,字符串

    capital_gain:资本收益,浮点数

    capital_loss:资本损失,浮点数

    hours_per_week:每周工作小时数,浮点数

    native_country:原籍,字符串

    分类标签列:income

    imcome > 50K

    Imcome ≤ 50K

      读入数据并显示数据的维度和前5行数据
    

    import pandas as pd

    import numpy as np

    对连续变量年龄进行离散化,并显示前5行数据离散化后的结果

    age_bins = [20, 30,40, 50, 60, 70]

    对属性是字符串的任意特征进行数字编号处理,显示前5行编码后的结果,每个特定的字符串用一个整数来表示,整数序列从0开始增长。

    from sklearn.preprocessing import LabelEncoder

    enc = LabelEncoder()

    对预处理后的数据用决策树算法和随机森林算法分类

    代码思路:

    1. 选择合适的若干特征字段

    2. 按7:3划分训练集和样本集

    3. 使用训练集训练一个决策树分类器

    4. 使用测试集计算决策树分类器的分类准确率

    5. 使用训练集训练一个随机森林分类器

    6. 使用测试集计算随机森林分类器的分类准确率

    fromsklearn.ensemble import RandomForestClassifier

    from sklearn importtree

    fromsklearn.preprocessing import LabelEncoder

    fromsklearn.feature_extraction import DictVectorizer

    accuracy_random =clf_random.score(xTest, yTest)

    二、代码

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import tree

    print(‘1.载入数据…’)
    data = []
    labels = []
    with open(“income_classification.csv”) as ifile:
    for line in ifile:
    # data需要是字典形式,因为之后需要使用DictVectorizer()修改字符串数据类型,以便符合DecisionTreeClassifier()
    rowDict = {}
    tokens = line.strip().split(’,’)
    rowDict[‘age’] = tokens[0]
    rowDict[‘workclass’] = tokens[1]
    rowDict[‘education_num’] = tokens[2]
    rowDict[‘maritial_status’] = tokens[3]
    rowDict[‘occupation’] = tokens[4]
    rowDict[‘relationship’] = tokens[5]
    rowDict[‘race’] = tokens[6]
    rowDict[‘sex’] = tokens[7]
    rowDict[‘capital_gain’] = tokens[8]
    rowDict[‘capital_loss’] = tokens[9]
    rowDict[‘hours_per_week’] = tokens[10]
    rowDict[‘native_country’] = tokens[11]
    rowDict[‘income’] = tokens[12]
    data.append(rowDict)
    labels.append(tokens[-1])

    print(‘2. 构造数据和标签…’)
    x = np.array(data)
    labels = np.array(labels)
    y = np.zeros(labels.shape) # 初始label全为0

    y[labels == ‘<=50K’] = 0 # 当label等于这三种属性的话,设置为1。
    y[labels == ‘>50K’] = 1

    print(‘3.转换字符串数据类型…’)
    vec = DictVectorizer() # 转换字符串数据类型
    dx = vec.fit_transform(x).toarray()

    print(‘4.拆分训练数据和测试数据…’)
    print(‘训练集和验证集比例7:3’)

    拆分成训练数据和测试数据

    ratio = 0.7
    xTrain = []
    yTrain = []
    xTest = []
    yTest = []
    features = xTrain, xTest
    labels = yTrain, yTest
    for i in range(len(dx)):
    dataSetIndex = 0 if np.random.random() < ratio else 1
    features[dataSetIndex].append(dx[i])
    labels[dataSetIndex].append(y[i])

    CART决策树分类

    print(‘5.CART决策树分类…’)
    clf_cart = tree.DecisionTreeClassifier(criterion = ‘entropy’) # CART算法,使用entropy作为标准;默认是是用gini作为标准
    clf_cart.fit(xTrain, yTrain)

    检查准确率

    accuracy_cart = clf_cart.score(xTest, yTest)
    print(‘CART树分类准确率:’,accuracy_cart)

    print(‘6.随机森林分类…’)
    clf_random = RandomForestClassifier()
    clf_random.fit(xTrain, yTrain)

    检查准确率

    accuracy_random = clf_random.score(xTest, yTest)
    print(‘随机森林分类准确率:’, accuracy_random)


    以上代码全部复制进python环境即可运行,亲测有效

    三、总结

    python库很强大,短短几句话就完事了。
    但是如果你不知道有这几句话,你确实得找很久
    希望我能帮你省些时间,喜欢的可以支持一下,谢谢啦~

    更多相关内容
  • 决策树和随机森林的学习资料,通过介绍决策树的相关案例,给出两种模型的计算结果及其分析
  • 决策树和随机森林

    2019-01-06 19:38:24
    决策树和随机森林是机器学习中两种及其重要的算法,应当好好学习一下
  • 本项目使用了决策树和随机森林2种机器学习方法进行实验,完整代码在最下方,想要先看源码的同学可以移步本文最下方进行下载。 博主也参考过文本分类相关模型的文章,但大多是理论大于方法。很多同学肯定对原理不需要...
  • 本文实例讲述了Python决策树和随机森林算法。分享给大家供大家参考,具体如下: 决策树和随机森林都是常用的分类算法,它们的判断逻辑人的思维方式非常类似,人们常常在遇到多个条件组合问题的时候,也通常可以画...
  • 使用 SVM、决策树和随机森林进行手写数字识别 MNIST 数据集已经在 Datasets 文件夹下给出。 svmfile.py 直接在 mnist 数据集上使用 svm。 Decisiontreefile.py 与 mnist 数据集上的决策树一起使用。 ...
  • 决策树随机森林

    2021-02-25 01:47:53
    本文于cnblogs,介绍了决策树的生成,Bagging策略,python实现代码等。首先,在了解树模型之前,自然想到树模型线性模型有什么区别呢?其中最重要的是,树形模型是一个一个特征进行处理,之前线性模型是所有特征...
  • Bootstrapping、决策树和随机森林算法简介 在这里,我展示了随机森林算法的构建,重点是引导和决策树。 这是在知识共享会议上提出的。
  • 初始决策树随机森林 初始决策树随机森林 初始决策树随机森林
  • 决策树和随机森林实战Python代码
  • 机器学习 第四讲 决策树和随机森林

    万次阅读 2021-04-15 16:20:09
    决策树和随机森林 一、认识决策树 决策树思想的来源非常朴素,程序设计中的条件分支结构就是if-else结构,最早的决策树就是利用这类结构分割数据的一种分类学习方法。 比如:你母亲要给你介绍男朋友,是这么来对话...

    决策树和随机森林

    在这里插入图片描述

    一、认识决策树

    决策树思想的来源非常朴素,程序设计中的条件分支结构就是if-else结构,最早的决策树就是利用这类结构分割数据的一种分类学习方法。

    比如:你母亲要给你介绍男朋友,是这么来对话的: 女儿:多大年纪了? 母亲:26。 女儿:长的帅不帅? 母亲:挺帅的。 女儿:收入高不? 母亲:不算很高,中等情况。 女儿:是公务员不? 母亲:是,在税务局上班呢。 女儿:那好,我去见见。

    在这里插入图片描述

    二、信息论基础-银行贷款分析

    银行贷款数据
    在这里插入图片描述
    你如何去划分是否能得到贷款?
    在这里插入图片描述
    在这里插入图片描述
    决策树的实际划分
    在这里插入图片描述
    g(D,A) = H(D)-H(D|A)
    H(D) = -(9/15log9/15 + 6/15log6/15 ) = 0.2922
    g(D,年龄) = H(D)-H(D’|年龄) = 0.2922 - [(1/3H|青年) + (1/3H|中年) + (1/3H|老年)]
    H(青年) = - (2/5log2/5 + 3/5log3/5) = 0.2923

    三、决策树的生成

    信息的度量和作用

    在这里插入图片描述
    猜谁是冠军?假设有32支球队

    信息的度量和作用
    每猜一次给一块钱,告诉我是否猜对了,那么我需要掏多少钱才能知道谁是冠军?我可以
    把球编上号,从1到32,然后提问:冠 军在1-16号吗?依次询问,只需要五次,就可以知
    道结果

    信息论的创始人,香农是密歇根大学学士,麻省理工学院博士。
    1948年,香农发表了划时代的论文——通信的数学原理,奠定了
    现代信息论的基础
    信息的单位:比特
    在这里插入图片描述
    信息熵
    “谁是世界杯冠军”的信息量应该比5比特少。香农指出,它的准确信息量应该是:
    H = -(p1logp1 + p2logp2 + … + p32log32)
    H的专业术语称之为信息熵,单位为比特。
    公式:在这里插入图片描述
    当这32支球队夺冠的几率相同时,对应的信息熵等于5比特

    决策树的划分依据之-信息增益
    特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件
    下D的信息条件熵H(D|A)之差,即公式为:
    在这里插入图片描述
    信息增益的计算
    结合前面的贷款数据来看我们的公式:
    信息熵的计算:
    在这里插入图片描述
    条件熵的计算:在这里插入图片描述

    常见决策树使用的算法

    • ID3
      信息增益 最大的准则
    • C4.5
      信息增益比 最大的准则
    • CART
      回归树: 平方误差 最小
      分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的原则

    sklearn决策树API
    class sklearn.tree.DecisionTreeClassifier(criterion=‘gini’, max_depth=None,random_state=None)
    决策树分类器
    criterion:默认是’gini’系数,也可以选择信息增益的熵’entropy’
    max_depth:树的深度大小
    random_state:随机数种子
    method:
    decision_path:返回决策树的路径

    四、泰坦尼克号乘客生存分类

    1.泰坦尼克号案例

    在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。在泰坦尼克号的数
    据帧不包含从剧组信息,但它确实包含了乘客的一半的实际年龄。关于泰坦尼克号旅客的数据
    的主要来源是百科全书Titanica。这里使用的数据集是由各种研究人员开始的。其中包括许多
    研究人员创建的旅客名单,由Michael A. Findlay编辑。
    我们提取的数据集中的特征是票的类别,存活,乘坐班,年龄,登陆,home.dest,房间,票,
    船和性别。乘坐班是指乘客班(1,2,3),是社会经济阶层的代表。
    其中age数据存在缺失。
    数据:http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt

    2.泰坦尼克号乘客生存分类模型

    1、pd读取数据
    2、选择有影响的特征,处理缺失值
    3、进行特征工程,pd转换字典,特征抽取x_train.to_dict(orient=“records”)
    4、决策树估计器流程

    3.决策树的结构、本地保存

    1、sklearn.tree.export_graphviz() 该函数能够导出DOT格式
    tree.export_graphviz(estimator,out_file=‘tree.dot’,feature_names=[’’,’’])
    2、工具:(能够将dot文件转换为pdf、png)
    安装graphviz
    ubuntu:sudo apt-get install graphviz
    3、运行命令
    dot -Tpng tree.dot -o tree.png

    '''
    1、pd读取数据
    2、选择有影响的特征,处理缺失值
    3、进行特征工程,pd转换字典,特征抽取x_train.to_dict(orient="records")
    4、决策树估计器流程
    '''
    
    import pandas as pd
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.model_selection import train_test_split
    from sklearn.tree import DecisionTreeClassifier, export_graphviz
    
    
    def decision():
        """
        决策树对泰坦尼克号进行预测
        :return: None
        """
        # 获取数据
        titan = pd.read_csv('titanic.txt')
        # print(titan.head())
        '''
           row.names pclass  survived  ...      ticket   boat     sex
        0          1    1st         1  ...  24160 L221      2  female
        1          2    1st         0  ...         NaN    NaN  female
        2          3    1st         0  ...         NaN  (135)    male
        3          4    1st         0  ...         NaN    NaN  female
        4          5    1st         1  ...         NaN     11    male'''
        # print(titan.info())
        '''
        <class 'pandas.core.frame.DataFrame'>
        RangeIndex: 1313 entries, 0 to 1312
        Data columns (total 11 columns):
         #   Column     Non-Null Count  Dtype  
        ---  ------     --------------  -----  
         0   row.names  1313 non-null   int64  
         1   pclass     1313 non-null   object 
         2   survived   1313 non-null   int64  
         3   name       1313 non-null   object 
         4   age        633 non-null    float64
         5   embarked   821 non-null    object 
         6   home.dest  754 non-null    object 
         7   room       77 non-null     object 
         8   ticket     69 non-null     object 
         9   boat       347 non-null    object 
         10  sex        1313 non-null   object 
        dtypes: float64(1), int64(2), object(8)
        memory usage: 113.0+ KB
        None'''
        # 处理数据:找出特征值和目标值
        x = titan[['pclass', 'age', 'sex']]
        y = titan[['survived']]
        # print(x)
        '''
             pclass      age     sex
        0       1st  29.0000  female
        1       1st   2.0000  female
        2       1st  30.0000    male
        3       1st  25.0000  female
        4       1st   0.9167    male
        ...     ...      ...     ...
        1308    3rd      NaN    male
        1309    3rd      NaN    male
        1310    3rd      NaN    male
        1311    3rd      NaN  female
        1312    3rd      NaN    male
        
        [1313 rows x 3 columns]
        '''
        # print(y)
        '''
              survived
        0            1
        1            0
        2            0
        3            0
        4            1
        ...        ...
        1308         0
        1309         0
        1310         0
        1311         0
        1312         0
        
        [1313 rows x 1 columns]'''
        # 处理缺失值
        x['age'].fillna(x['age'].mean(), inplace=True)  # 给age的缺失值添加平均值,inplace=True修改它本身
        # print(x)
        '''
             pclass        age     sex
        0       1st  29.000000  female
        1       1st   2.000000  female
        2       1st  30.000000    male
        3       1st  25.000000  female
        4       1st   0.916700    male
        ...     ...        ...     ...
        1308    3rd  31.194181    male
        1309    3rd  31.194181    male
        1310    3rd  31.194181    male
        1311    3rd  31.194181  female
        1312    3rd  31.194181    male
        
        [1313 rows x 3 columns]
        '''
        # 分割数据 训练集  测试集
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
        # 特征工程处理  特征->类别 -> one_hot编码  0 1 2
        dic = DictVectorizer(sparse=False)
    
        x_train = dic.fit_transform(x_train.to_dict(orient='records'))
        x_test = dic.fit_transform(x_test.to_dict(orient='records'))
        # print(x_train)
        '''
            [[12.          0.          1.          0.          1.          0.        ]
         [31.19418104  0.          0.          1.          0.          1.        ]
         [31.19418104  0.          0.          1.          0.          1.        ]
         ...
         [31.19418104  1.          0.          0.          1.          0.        ]
         [ 9.          0.          0.          1.          0.          1.        ]
         [30.          0.          1.          0.          1.          0.        ]]
        '''
        # print(dic.get_feature_names())
        '''['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male']'''
        # 用决策树进行预测
        dec = DecisionTreeClassifier()
        dec.fit(x_train, y_train)
    
        print("预测的准确率", dec.score(x_test, y_test))
        '''预测的准确率 0.8206686930091185'''
        # 本地保存
        export_graphviz(dec, out_file='./tree.dot',feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male'])
    
        return None
    
    
    if __name__ == '__main__':
        decision()
    
    

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

    五、决策树的优缺点以及改进

    优点:
    > 简单的理解和解释,树木可视化。
    > 需要很少的数据准备,其他技术通常需要数据归一化,
    缺点:
    > 决策树学习者可以创建不能很好地推广数据的过于复杂的树,这被称为过拟合。
    > 决策树可能不稳定,因为数据的小变化可能会导致完全不同的树被生成
    改进:
    > 减枝cart算法
    > 随机森林

    六、集成学习方法-随机森林

    (1)、什么是随机森林
    (2)、随机森林的过程、优势
    (3)、泰坦尼克号乘客生存分类分析

    1.集成学习方法:

    集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型,各自独立地学习和作出预测。这些预测最后结合成单预测,因此优于任何一个单分类的做出预测。

    定义:在机器学习中,随机森林是一个包含多个决策树的分类器,并且其输出的类别是由个别树输出的类别的众数而定。

    例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终结果会是True.

    2.学习算法

    根据下列算法而建造每棵树:
    1.用N来表示训练用例(样本)的个数,M表示特征数目。
    2.输入特征数目m,用于确定决策树上一个节点的决策结果;其中m应远小于M。
    3.从N个训练用例(样本)中以有放回抽样的方式,取样N次,形成一个训练集(即bootstrap取样),并用未抽到的用例(样本)作预测,评估其误差。

    为什么要随机抽样训练集?
    如果不进行随机抽样,每棵树的训练集都一样,那么最终训练出的树分类结果也是完全一样的

    为什么要有放回地抽样?
    如果不是有放回的抽样,那么每棵树的训练样本都是不同的,都是没有交集的,这样每棵树都是“有偏的”,都是绝对“片面的”(当然这样说可能不对),也就是说每棵树训练出来都是有很大的差异的;而随机森林最后分类取决于多棵树(弱分类器)的投票表决。

    集成学习API
    sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion=‘gini’,max_depth=None, bootstrap=True,random_state=None)
    随机森林分类器
    n_estimators:integer,optional(default = 10) 森林里的树木数量
    criteria:string,可选(default =“gini”)分割特征的测量方法
    max_depth:integer或None,可选(默认=无)树的最大深度
    bootstrap:boolean,optional(default = True)是否在构建树时使用放回抽样

    '''
    1、pd读取数据
    2、选择有影响的特征,处理缺失值
    3、进行特征工程,pd转换字典,特征抽取x_train.to_dict(orient="records")
    4、决策树估计器流程
    '''
    
    import pandas as pd
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.tree import DecisionTreeClassifier
    
    def decision():
        """
        决策树对泰坦尼克号进行预测
        :return: None
        """
        # 获取数据
        titan = pd.read_csv('titanic.txt')
        # print(titan.head())
        '''
           row.names pclass  survived  ...      ticket   boat     sex
        0          1    1st         1  ...  24160 L221      2  female
        1          2    1st         0  ...         NaN    NaN  female
        2          3    1st         0  ...         NaN  (135)    male
        3          4    1st         0  ...         NaN    NaN  female
        4          5    1st         1  ...         NaN     11    male'''
        # print(titan.info())
        '''
        <class 'pandas.core.frame.DataFrame'>
        RangeIndex: 1313 entries, 0 to 1312
        Data columns (total 11 columns):
         #   Column     Non-Null Count  Dtype  
        ---  ------     --------------  -----  
         0   row.names  1313 non-null   int64  
         1   pclass     1313 non-null   object 
         2   survived   1313 non-null   int64  
         3   name       1313 non-null   object 
         4   age        633 non-null    float64
         5   embarked   821 non-null    object 
         6   home.dest  754 non-null    object 
         7   room       77 non-null     object 
         8   ticket     69 non-null     object 
         9   boat       347 non-null    object 
         10  sex        1313 non-null   object 
        dtypes: float64(1), int64(2), object(8)
        memory usage: 113.0+ KB
        None'''
        # 处理数据:找出特征值和目标值
        x = titan[['pclass', 'age', 'sex']]
        y = titan[['survived']]
        # print(x)
        '''
             pclass      age     sex
        0       1st  29.0000  female
        1       1st   2.0000  female
        2       1st  30.0000    male
        3       1st  25.0000  female
        4       1st   0.9167    male
        ...     ...      ...     ...
        1308    3rd      NaN    male
        1309    3rd      NaN    male
        1310    3rd      NaN    male
        1311    3rd      NaN  female
        1312    3rd      NaN    male
        
        [1313 rows x 3 columns]
        '''
        # print(y)
        '''
              survived
        0            1
        1            0
        2            0
        3            0
        4            1
        ...        ...
        1308         0
        1309         0
        1310         0
        1311         0
        1312         0
        
        [1313 rows x 1 columns]'''
        # 处理缺失值
        x['age'].fillna(x['age'].mean(), inplace=True)  # 给age的缺失值添加平均值,inplace=True修改它本身
        # print(x)
        '''
             pclass        age     sex
        0       1st  29.000000  female
        1       1st   2.000000  female
        2       1st  30.000000    male
        3       1st  25.000000  female
        4       1st   0.916700    male
        ...     ...        ...     ...
        1308    3rd  31.194181    male
        1309    3rd  31.194181    male
        1310    3rd  31.194181    male
        1311    3rd  31.194181  female
        1312    3rd  31.194181    male
        
        [1313 rows x 3 columns]
        '''
        # 分割数据 训练集  测试集
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
        # 特征工程处理  特征->类别 -> one_hot编码  0 1 2
        dic = DictVectorizer(sparse=False)
    
        x_train = dic.fit_transform(x_train.to_dict(orient='records'))
        x_test = dic.fit_transform(x_test.to_dict(orient='records'))
        # print(x_train)
        '''
            [[12.          0.          1.          0.          1.          0.        ]
         [31.19418104  0.          0.          1.          0.          1.        ]
         [31.19418104  0.          0.          1.          0.          1.        ]
         ...
         [31.19418104  1.          0.          0.          1.          0.        ]
         [ 9.          0.          0.          1.          0.          1.        ]
         [30.          0.          1.          0.          1.          0.        ]]
        '''
        # print(dic.get_feature_names())
        '''['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male']'''
        # # 用决策树进行预测
        # dec = DecisionTreeClassifier()
        # dec.fit(x_train, y_train)
        #
        # print("预测的准确率", dec.score(x_test, y_test))
        # '''预测的准确率 0.8206686930091185'''
        # export_graphviz(dec, out_file='./tree.dot',feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male'])
    
        # 用随机森林(超参数的调优)
        rf = RandomForestClassifier()
    
        param = {'n_estimators': [120, 200, 300, 500, 800, 1200], 'max_depth': [5, 8, 15, 25, 30]}
    
        gc = GridSearchCV(rf, param_grid=param, cv=2)
        gc.fit(x_train, y_train)
        print('准确率', gc.score(x_test, y_test))  # 准确率 0.8297872340425532
        print("选择的参数模型", gc.best_params_)  # 选择的参数模型 {'max_depth': 5, 'n_estimators': 200}
    
        return None
    
    
    if __name__ == '__main__':
        decision()
    
    

    3.随机森林的优点

    1.在当前所有算法中,具有极好的准确率
    2.能够有效地运行在大数据集上
    3.能够处理具有高维特征的输入样本,而且不需要降维
    4.能够评估各个特征在分类问题上的重要性
    5.对于缺省值问题也能够获得很好得结果

    在这里插入图片描述

    展开全文
  • 月亮数据预测(决策树和随机森林算法).zip
  • 机器学习一:使用决策树和随机森林对数据分类 首先导入数据:income_classification.csv 在python编辑器中导入所需要的库 import numpy as np import pandas as pd from sklearn import tree from sklearn.ensemble ...

    机器学习一:使用决策树和随机森林对数据分类

    首先导入数据:income_classification.csv
    在python编辑器中导入所需要的库

    import numpy as np
    import pandas as pd
    from sklearn import tree
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.preprocessing import LabelEncoder
    
    

    题目一:读入数据并显示数据的维度和前5行数据。

    #题目一:读入数据并显示数据的维度和前五行数据
    print('1.载入数据.....')
    data = pd.read_csv("income_classification.csv", header=0)
    print('数据的维度和前五行数据:', data.shape)
    print(data.head())
    
    

    题目二:对连续变量age进行离散化处理并显示前五行。

    print('对连续变量age进行离散化处理,等宽分成五类,显示前五行:')
    AGE_CUT = pd.cut(x=data['age'], bins=5, labels=range(0, 5))
    data['age'] = AGE_CUT
    print(data.head(5))
    

    题目三:对属性是字符串的任意特征进行数字编号处理,显示前5行编码后的结果,每个特定的字符串用一个整数来表示,整数序列从0开始增长

    class_le = LabelEncoder()
    data['workclass'] = pd.DataFrame(class_le.fit_transform(data['workclass']))
    data['marital-status'] = pd.DataFrame(class_le.fit_transform(data['marital-status']))
    data['occupation'] = pd.DataFrame(class_le.fit_transform(data['occupation']))
    data['education'] = pd.DataFrame(class_le.fit_transform(data['education']))
    data['native-country'] = pd.DataFrame(class_le.fit_transform(data['native-country']))
    data['relationship'] = pd.DataFrame(class_le.fit_transform(data['relationship']))
    data['race'] = pd.DataFrame(class_le.fit_transform(data['race']))
    data['sex'] = pd.DataFrame(class_le.fit_transform(data['sex']))
    print('显示前五行编码后的结果:')
    print(data.head(5))
    

    题目四:对预处理后的数据用决策树算法和随机森林算法分类。

    实验步骤

    1. 选择合适的若干特征字段
    2. 按7:3划分训练集和样本集
    3. 使用训练集训练一个决策树分类器
    4. 使用测试集计算决策树分类器的分类准确率
    5. 使用训练集训练一个随机森林分类器
    6. 使用测试集计算随机森林分类器的分类准确率
    data1 = []
    labels = []
    for index, row in data.iterrows():
        # data需要是字典形式,因为之后需要使用DictVectorizer()修改字符串数据类型,以便符合DecisionTreeClassifier()
        rowDict = {}
        row = list(row)
        rowDict['age'] = row[0]
        rowDict['workclass'] = row[1]
        rowDict['education'] = row[2]
        rowDict['education_num'] = row[3]
        rowDict['maritial_status'] = row[4]
        rowDict['occupation'] = row[5]
        rowDict['relationship'] = row[6]
        rowDict['race'] = row[7]
        rowDict['sex'] = row[8]
        rowDict['capital_gain'] = row[9]
        rowDict['capital_loss'] = row[10]
        rowDict['hours_per_week'] = row[11]
        rowDict['native_country'] = row[12]
        data1.append(rowDict)
        labels.append(row[-1])
    
    print('2. 构造数据和标签.....')
    x = np.array(data1)
    labels = np.array(labels)
    y = np.zeros(labels.shape)  # 初始label全为0
    y[labels == '<=50K'] = 0  # 当label等于这三种属性的话,设置为1。
    y[labels == '>50K'] = 1
    
    # 转换字符串数据类型
    print('3.转换字符串数据类型.....')
    vec = DictVectorizer()
    dx = vec.fit_transform(x).toarray()
    
    # 拆分成训练数据和测试数据
    print('4.拆分训练数据和测试数据.....')
    print('训练集和验证集比例7:3')
    ratio = 0.7
    xTrain = []
    yTrain = []
    xTest = []
    yTest = []
    features = xTrain, xTest
    labels = yTrain, yTest
    for i in range(len(dx)):
        dataSetIndex = 0 if np.random.random() < ratio else 1
        features[dataSetIndex].append(dx[i])
        labels[dataSetIndex].append(y[i])
    
    # CART决策树分类
    print('5.CART决策树分类.....')
    clf_cart = tree.DecisionTreeClassifier(criterion='entropy')  # CART算法,使用entropy作为标准;默认是是用gini作为标准
    clf_cart.fit(xTrain, yTrain)
    
    # 检查准确率
    accuracy_cart = clf_cart.score(xTest, yTest)
    print('CART树分类准确率:', accuracy_cart)
    
    print('6.随机森林分类.....')
    clf_random = RandomForestClassifier()
    clf_random.fit(xTrain, yTrain)
    
    # 检查准确率
    accuracy_random = clf_random.score(xTest, yTest)
    print('随机森林分类准确率:', accuracy_random)
    
    
    展开全文
  • 决策树和随机森林 垃圾邮件泰坦尼克号数据集的分类器。 只需从上到下运行提供的iPython Notebook,确保数据集位于同一目录中。 将CSV文件输出到当前目录。
  • 使用决策树和随机森林预测员工离职率 我们的任务是帮助人事部门门理解员工为何离职,预测- -个员工离职的可能性.数据来源: #引入工具包 import pandas as pd import numpy as np import matplotlib.pyplot as plt ...

    使用决策树和随机森林预测员工离职率

    • 我们的任务是帮助人事部门门理解员工为何离职,预测- -个员工离职的可能性.数据来源:
    #引入工具包
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib as matplot
    import seaborn as sns
    %matplotlib inline
    #读取数据
    df = pd.read_csv("./data/HR_comma_sep.csv",index_col = None)
    # 数据预处理
    #检查数据是否又缺失值
    df.isnull().any()
    df.head()
    #重命名
    df.rename(columns=({'satisfaction_level': 'satisfaction', 
                            'last_evaluation': 'evaluation',
                            'number_project': 'projectCount',
                            'average_montly_hours': 'averageMonthlyHours',
                            'time_spend_company': 'yearsAtCompany',
                            'Work_accident': 'workAccident',
                            'promotion_last_5years': 'promotion',
                            'sales' : 'department',
                            'left' : 'turnover'}),inplace=True)
    # 将预测标签放第一列
    font = df['turnover']
    df.drop(labels=['turnover'],axis=1,inplace=True)
    df.insert(0,'turnover',font)
    df.head()
    

    在这里插入图片描述

    分析数据

    • 14999 条数据,每一条数据包含10个特征
    • 总的离职率24%
    • 平均满意度0.61
    turnover_rate = df.turnover.value_counts()/len(df)
    turnover_rate
    #显示统计数据
    df.describe()
    

    在这里插入图片描述

    turnover_summary = df.groupby('turnover')
    turnover_summary.mean()
    

    在这里插入图片描述

    相关性分析


    正相关的特征:

    • projectCount VS evaluation: 0.349333
    • projectCount VS averageMonthlyHours: 0.417211
    • averageMonthlyHours VS evaluation: 0.339742

    负相关的特征:

    • satisfaction VS turnover: -0.388375

    思考:

    • 什么特征的影响最大?
    • 什么特征之间相关性最大?
    # 相关性矩阵
    corr = df.corr()
    sns.heatmap(corr,xticklabels=corr.columns.values,yticklabels=corr.columns.values)
    corr
    

    在这里插入图片描述

    # 比较离职和未离职员工的满意度
    emp_population = df['satisfaction'][df['turnover']==0].mean()
    emp_turnover_satisfaction = df[df['turnover']==1]['satisfaction'].mean()
    
    print('未离职员工满意度',emp_population)
    print('离职员工满意度',emp_turnover_satisfaction)
    

    在这里插入图片描述

    model

    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import  accuracy_score, classification_report, precision_score, recall_score, confusion_matrix, precision_recall_curve
    #将string型转换为整数型
    df['department'] = df['department'].astype('category').cat.codes
    df['salary'] = df['department'].astype('category').cat.codes
    
    #产生x,y
    target_name = 'turnover'
    # 产生x,y
    y = df['turnover']
    x = df.drop('turnover',axis=1)
    x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.15,random_state=123,stratify=y)
    df.head()
    

    在这里插入图片描述

    决策树

    from sklearn.metrics import roc_auc_score
    from sklearn.metrics import classification_report
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import tree
    from sklearn.tree import DecisionTreeClassifier
    
    #决策树
    dtree = tree.DecisionTreeClassifier(
        criterion='entropy',
        #max_depth=3, #定义树的深度,可以用来防止过拟合
        min_weight_fraction_leaf=0.01 #定义叶子节点最少需要包含多少个样本(使用百分比表达),防止过拟合
    )
    dtree = dtree.fit(x_train,y_train)
    print('\n\n---决策树---')
    dt_roc_auc = roc_auc_score(y_test,dtree.predict(x_test))
    print('决策树的roc_auc_score  ',dt_roc_auc)
    print(classification_report(y_test,dtree.predict(x_test)))
    

    在这里插入图片描述

    随机森林

    # 随机森林
    rf = RandomForestClassifier(
        criterion = 'entropy',
        n_estimators=1000,
        max_depth=None,  #定义树的深度,可以用来防止过拟合
        min_samples_split=10 # 定义至少多少个样本的情况下才继续分叉
       # min_weight_fraction_leaf=0.01 #定义叶子节点最少需要包含多少个样本(使用百分比表达),防止过拟合
    )
    rf.fit(x_train,y_train)
    print('\n\n--随机森林--')
    rt_roc_auc = roc_auc_score(y_test,rf.predict(x_test))
    print('\n\n--随机森林auc--',rt_roc_auc)
    print(classification_report(y_test,rf.predict(x_test)))
    

    在这里插入图片描述

    roc图

    from sklearn.metrics import roc_curve
    rf_fpr, rf_tpr, rf_thresholds = roc_curve(y_test, rf.predict_proba(x_test)[:,1])
    dt_fpr, dt_tpr, dt_thresholds = roc_curve(y_test, dtree.predict_proba(x_test)[:,1])
    
    plt.figure()
    
    # 随机森林 ROC
    plt.plot(rf_fpr, rf_tpr, label='Random Forest (area = %0.2f)' % rt_roc_auc)
    
    # 决策树 ROC
    plt.plot(dt_fpr, dt_tpr, label='Decision Tree (area = %0.2f)' % dt_roc_auc)
    
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.05])
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.title('ROC Graph')
    plt.legend(loc="lower right")
    plt.show()
    

    在这里插入图片描述

    通过决策树分析不同的特征的重要性

    ## 画出决策树特征的重要性 ##
    importances = rf.feature_importances_
    feat_names = df.drop(['turnover'],axis=1).columns
    indices = np.argsort(importances)[::1]
    plt.figure(figsize=(12,6))
    plt.title("Feature importances by Decis ionTreeClassifier")
    plt.bar(range(len(indices)),importances[indices],color='lightblue',align='center')
    plt.step(range(len(indices)),np.cumsum(importances[indices]),where='mid',label='Cumulative')
    plt.xticks(range(len(indices)),feat_names[indices],rotation='vertical',fontsize=14)
    plt.xlim([-1,len(indices)])
    plt.show()
    

    在这里插入图片描述

    ## 画出决策树的特征的重要性 ##
    importances = rf.feature_importances_
    feat_names = df.drop(['turnover'],axis=1).columns
    
    
    indices = np.argsort(importances)[::-1]
    plt.figure(figsize=(12,6))
    plt.title("Feature importances by Decision Tree")
    plt.bar(range(len(indices)), importances[indices], color='lightblue',  align="center")
    plt.step(range(len(indices)), np.cumsum(importances[indices]), where='mid', label='Cumulative')
    plt.xticks(range(len(indices)), feat_names[indices], rotation='vertical',fontsize=14)
    plt.xlim([-1, len(indices)])
    plt.show()
    
    

    在这里插入图片描述

    展开全文
  • 最新决策树和随机森林的Python实现代码,适合新手小白
  • dec-tree-random-forest-泰坦尼克号 使用决策树和随机森林模型预测泰坦尼克号乘客的存活率。 使用熊猫 scikit-learn。 数据及比赛详情:
  • 2.1.决策树和随机森林

    千次阅读 2021-05-27 21:21:21
    2.1.决策树和随机森林 决策树(Decision Tree)是在已知各种情况发生概率的基础上,通过构成决策树来求取净现值的期望值大于等于零的概率,评价项目风险,判断其可行性的决策分析方法,是直观运用概率分析的一种图解法...
  • 1.决策树 import pandas as pd import numpy as np from sklearn.datasets import load_iris from sklearn.tree import DecisionTreeClassifier from sklearn.tree import export_graphviz from sklearn.tree import...
  • y_train, y_test = train_test_split( X, y, test_size=0.15, random_state=123, stratify=y) # 显示前5行数据 df.head() 决策树和随机森林Decision Tree V.S. Random Forest from sklearn.metrics import roc_auc_...
  • 决策树和随机森林是机器学习的一个重要内容。今天主要来说说决策树决策树分为传统的决策树和条件决策树,传统决策树(rpart包实现)主要是基于:基尼不纯度(Gini Impurity)或信息增益(Information Gain)等标准...
  • 使用决策树和随机森林分析预测糖尿病

    千次阅读 多人点赞 2020-06-07 20:36:13
    输出决策树和随机森林的性能报告;画出ROC图;分析不同特征的重要性 (作笔记使用,如有错误,欢迎指正!) 导入数据: import pandas as pd data = pd.read_csv('./datasets.csv') data.head() 标题解释:...
  • dsa14hw4 数据结构与算法作业4 ... 在数据heart.train上运行具有 30 棵树的随机森林。 make predict_tree PNAME=heart.test : 通过决策树模型对数据heart.test进行预测。 make predict_forest P
  • 决策树和随机森林-邹伟的ppt,适用于机器学习爱好者。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,390
精华内容 14,156
关键字:

决策树和随机森林