从零开始数据科学与机器学习算法-分类与决策树-06

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量110 收藏
点赞数
分类专栏： 数据科学与机器学习算法学习笔记 文章标签： 决策树 python 机器学习 算法 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37978800/article/details/114457874
版权

例：有没有心脏病？

-------1胸痛---------2血液循环良好-----------3.动脉阻塞-------------4心脏病(HD)

01.------No---------------No----------------------No------------------No
02.------Yes--------------Yes---------------------Yes-----------------Yes
03.------Yes--------------Yes---------------------No------------------No
…
…
每次选取一个可判断的条件，然后进行单一条件的决策树转化
1.Chest Pain：如是否有胸痛
------|--------|----
----HD-----HD-----
-----|--------|------
Yes|No—Yes|No------是否患有心脏病
105|39-----34|125–对应的人数
2.Good Blood Circulation
–|------|----
HD-----HD-----
|–|-----|–|------
Yes|No-Yes|No------
37 127 100 33

3.Blocked Arteries
–|------|----
HD-----HD-----
|–|-----|–|------
Yes|No-Yes|No------
92 31 45 129

我们把并非100%正确分类的要做"impure"的分类（着重关注点实在leaf node）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1.Chest Pain：如是否有胸痛
# ------|--------|----
# ----HD-----HD-----
# -----|--------|------
# Yes|No---Yes|No------是否患有心脏病
# 105|39-----34|125--对应的人数

# 概述：有胸痛/有心脏病的有105个  有胸痛/无心脏病的有的39个
#  无胸痛/有心脏病的有34个   无胸痛无心脏病的有125个

1-(105/(105+39))**2-(39/(105+39))**2

在这里插入图片描述

1-(34/(34+125))**2-(125/(34+125))**2

在这里插入图片描述

# 加权处理：
(144/(144+159))*0.395 +(159/(144+159))*0.336

在这里插入图片描述
以此类推， 1.Chest Pain = 0.364
2.Good Blood Circulation = 0.360
3.Blocked Arteries = 0.381

有上述得出Good Blood Circulation = 0.360 最小（最纯）

选定根节点之后
Good Blood Circulation
–|------|----
HD-----HD-----
|–|-----|–|------
Yes|No-Yes|No------
37 127 100 33

1.Chest Pain
–|------|----
HD-----HD-----
|–|-----|–|------
Yes|No-Yes|No------
13 98 24 29
这个时候可以算出在Chest Pain下面的Gini =0.3

2.Blocked Arteries
–|------|----
HD-----HD-----
|–|-----|–|------
Yes|No-Yes|No------
24 25 13 102
这个时候可以算出在Blocked Arteries下面的Gini =0.290

-----Good Blood Circulation-----
-------|-----------|--------------
------BA---------CP------------
----|-----|------|-----|----------
—CP-13/102–92/3–BA--------
-｜–｜-------------｜–｜------
17/3–7/22--------8/0—0/30—

思考： 1.如果你得到的是数值的数据如何计算Gini？(rank一遍，计算平均值，通过小于等于来分类，*没有必要将最大的一个数值包括，因为无法分类) 2.如果你得到的是程度数值（比如：按照喜欢程度1234）的数据如何计算Gini？(rank一遍，通过小于等于来分类，没有必要将最大的一个数值包括，因为无法分类) 3.如果你得到的是调查问卷的数据如何计算Gini？(通过排列组合来分类，*没有必要将包括所有的组合计算在内，因为无法分类)

基尼指数代码

def calculate_the_gini_index(groups, classes):
    # 计算有多少实例个数
    n_instances = float(sum([len(groups) for group in groups]))
    # 把每一个group里面的加权gini计算出来
    gini = 0.0
    for group in groups:
        size = float(len(groups))
        # *注意，这里不能除以0，所以我们要考虑到分母为0的情况
        if size == 0:
            continue
        score = 0.0
        for class_val in classes:
            p = [row[-1] for row in group].count(class_val) / size
            score += p * p
        # 这里做了一个加权处理
        gini += (1 - score) * (size / n_instances)

    return gini

# 两个类别的最坏情况
worst_case_for_two_classes = [[[1, 1], 
                               [1, 0]], 
                              [[1, 1], 
                               [1, 0]]]

print(calculate_the_gini_index(worst_case_for_two_classes, [0, 1]))
# 两个类别的最佳情况
best_case_for_two_classes = [[[1, 0], 
                              [1, 0]],
                             [[1, 1], 
                              [1, 1]]]

print(calculate_the_gini_index(best_case_for_two_classes, [0, 1]))

在这里插入图片描述

def test_split(index, value, dataset): # 左右切分函数
    left, right = list(), list()
    for row in dataset:
        if row[index] < value:
            left.append(row)
        else:
            right.append(row)
    return left, right

# index,value,groups数据较多，所以选用dict
def get_split(dataset):
    class_values = list(set(row[-1] for row in dataset))
    posi_index, posi_value, posi_score, posi_groups = 888, 888, 888, None
    for index in range(len(dataset[0]) - 1):
        for row in dataset:
            groups = test_split(index, row[index], dataset)
            gini = calculate_the_gini_index(groups, class_values)
            if gini < posi_score:
                posi_index, posi_value, posi_score, posi_groups = index, row[index], gini, groups
    return {'The Best Index is': posi_index, 'The Best Value is': posi_value, 'The Best Groups is': posi_groups}


# 测试
dataset = [[2.1, 1.1, 0],
           [3.4, 2.5, 0],
           [1.3, 5.8, 0],
           [1.9, 8.6, 0],
           [3.7, 6.2, 0],
           [8.8, 1.1, 1],
           [9.6, 3.4, 1],
           [10.2, 7.4, 1],
           [7.7, 8.8, 1],
           [9.7, 6.9, 1]]

split = get_split(dataset)
print(split)

在这里插入图片描述

最好的分割

def test_split(index, value, dataset):
    left, right = list(), list()
    for row in dataset:
        if row[index] < value:
            left.append(row)
        else:
            right.append(row)
    return left, right


def calculate_the_gini_index(groups, classes):
    # 计算有多少实例
    n_instances = float(sum([len(group) for group in groups]))
    # 把每一个group里面的加权gini计算出来
    gini = 0.0
    for group in groups:
        size = float(len(group))
        # *注意，这里不能除以0，所以我们要考虑到分母为0的情况
        if size == 0:
            continue
        score = 0.0
        for class_val in classes:
            p = [row[-1] for row in group].count(class_val) / size
            score += p * p
        # 这个做了一个加权处理
        gini += (1 - score) * (size / n_instances)

    return gini


def get_split(dataset):
    class_values = list(set(row[-1] for row in dataset))
    posi_index, posi_value, posi_score, posi_groups = 888, 888, 888, None
    for index in range(len(dataset[0]) - 1):
        for row in dataset:
            groups = test_split(index, row[index], dataset)
            gini = calculate_the_gini_index(groups, class_values)
            print("X%d < %.3f Gini=%.3f" % ((index + 1), row[index], gini))
            if gini < posi_score:
                posi_index, posi_value, posi_score, posi_groups = index, row[index], gini, groups
    return {'index': posi_index, 'value': posi_value, 'groups': posi_groups}


dataset = [[2.1, 1.1, 0],
           [3.4, 2.5, 0],
           [1.3, 5.8, 0],
           [1.9, 8.6, 0],
           [3.7, 6.2, 0],
           [8.8, 1.1, 1],
           [9.6, 3.4, 1],
           [10.2, 7.4, 1],
           [7.7, 8.8, 1],
           [9.7, 6.9, 1]]

split = get_split(dataset)
print('Split:[X%d < %.3f]' % ((split['index'] + 1), split['value']))

在这里插入图片描述

建立回归树

# 1.root node
# 2.recursive split
# 3.terminal node (为了解决over-fitting的问题，减少整个tree的深度/高度，以及必须规定最小切分单位)
# 4.finish building the tree

def test_split(index, value, dataset):
    left, right = list(), list()
    for row in dataset:
        if row[index] < value:
            left.append(row)
        else:
            right.append(row)
    return left, right


def calculate_the_gini_index(groups, classes):
    # 计算有多少实例
    n_instances = float(sum([len(group) for group in groups]))
    # 把每一个group里面的加权gini计算出来
    gini = 0.0
    for group in groups:
        size = float(len(group))
        # *注意，这里不能除以0，所以我们要考虑到分母为0的情况
        if size == 0:
            continue
        score = 0.0
        for class_val in classes:
            p = [row[-1] for row in group].count(class_val) / size
            score += p * p
        # 这个做了一个加权处理
        gini += (1 - score) * (size / n_instances)

    return gini


def get_split(dataset):
    class_values = list(set(row[-1] for row in dataset))
    posi_index, posi_value, posi_score, posi_groups = 888, 888, 888, None
    for index in range(len(dataset[0]) - 1):
        for row in dataset:
            groups = test_split(index, row[index], dataset)
            gini = calculate_the_gini_index(groups, class_values)
            print("X%d < %.3f Gini=%.3f" % ((index + 1), row[index], gini))
            if gini < posi_score:
                posi_index, posi_value, posi_score, posi_groups = index, row[index], gini, groups
    return {'index': posi_index, 'value': posi_value, 'groups': posi_groups}


def determine_the_terminal(group):
    outcomes = [row[-1] for row in group]
    return max(set(outcomes), key=outcomes.count)


# 1.把数据进行切分（分为左边与右边），原数据删除掉
# 2.检查非空以及满足我们的我们设置的条件（深度/最小切分单位/非空）
# 3.一直重复类似寻找root node的操作，一直到最末端


def split(node, max_depth, min_size, depth):
    # 做切分，并删除掉原数据
    left, right = node['groups']
    del (node['groups'])
    # 查看非空
    if not left or not right:
        node['left'] = node['right'] = determine_the_terminal(left + right)
        return

    # 检查最大深度是否超过
    if depth >= max_depth:
        node['left'], node['right'] = determine_the_terminal(left), determine_the_terminal(right)
        return
        # 最小分类判断与左侧继续向下分类
    if len(left) <= min_size:
        node['left'] = determine_the_terminal(left)
    else:
        node['left'] = get_split(left)
        split(node['left'], max_depth, min_size, depth + 1)
        # 最小分类判断与右侧继续向下分类
    if len(right) <= min_size:
        node['right'] = determine_the_terminal(right)
    else:
        node['right'] = get_split(right)
        split(node['right'], max_depth, min_size, depth + 1)


# 最终建立决策树

def build_the_regression_tree(train, max_depth, min_size):
    root = get_split(train)
    split(root, max_depth, min_size, 1)
    return root


# 通过CLI可视化的呈现类树状结构便于感性认知
def print_our_tree(node, depth=0):
    if isinstance(node, dict):
        print('%s[X%d < %.3f]' % ((depth * '-', (node['index'] + 1), node['value'])))
        print_our_tree(node['left'], depth + 1)
        print_our_tree(node['right'], depth + 1)
    else:
        print('%s[%s]' % ((depth * '-', node)))


def make_prediction(node, row):
    if row[node['index']] < node['value']:
        if isinstance(node['left'], dict):
            return make_prediction(node['left'], row)
        else:
            return node['left']
    else:
        if isinstance(node['right'], dict):
            return make_prediction(node['right'], row)
        else:
            return node['right']


dataset = [[2.1, 1.1, 0],
           [3.4, 2.5, 0],
           [1.3, 5.8, 0],
           [1.9, 8.6, 0],
           [3.7, 6.2, 0],
           [8.8, 1.1, 1],
           [9.6, 3.4, 1],
           [10.2, 7.4, 1],
           [7.7, 8.8, 1],
           [9.7, 6.9, 1]]

tree = build_the_regression_tree(dataset, 3, 1)
print_our_tree(tree)

decision_tree_stump = {'index': 0, 'right': 1, 'value': 9.3, 'left': 0}
for row in dataset:
    prediction = make_prediction(decision_tree_stump, row)
    print("What is expected data : %d , Your prediction is %d " % (row[-1], prediction))

在这里插入图片描述

gemoumou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5分钟了解二叉树之LeetCode里的二叉树
qq_14932463的博客
03-26 1028
二叉树是面试常考的数据结构，在数据结构中占据了重要的地位，本文给大家梳理了LeetCode有关二叉树的题型和一些二叉树的基本概念，方便大家复习和了解。
※数据结构※→☆非线性结构（tree）☆============树结点 顺序存储结构（tree node sequence）（十四）
热门推荐
潇汀
09-23 5万+
结点：         包括一个数据元素及若干个指向其它子树的分支；例如，A，B，C，D等。 在数据结构的图形表示中，对于数据集合中的每一个数据元素用中间标有元素值的方框表示，一般称之为数据结点，简称结点。         在C语言中，链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据；二为下一个结点的地址，即指针域和数据域。
Tree （中序+后序还愿树，并求根到哪个叶的和最小）
自渡的博客
08-25 315
You are to determine the value of the leaf node in a given binary tree that is the terminal node of a path of least value from the root of the binary tree to any leaf. The value of a path is the sum o...
《机器学习核心技术》分类算法 - 决策树
wangyuxiang946的博客
08-28 1万+
决策树是一种「二叉树形式」的预测模型，每个「节点」对应一个「判断条件」，「满足」上一个条件才能「进入下一个」判断条件。 就比如找对象，第一个条件肯定是长得帅，长得帅的才考虑下一个条件；长得不帅就直接pass，不往下考虑了。
从零开始的机器学习生活---决策树
dh_nwu的博客
11-15 887
从零开始的机器学习生活—决策树的实现 决策树（decision tree）是一种常见的机器学习方法，往往不需要很深奥的背景知识就能掌握，所以选择决策树作为入门机器学习的第一款算法的你，已经成功迈出了成为机器学习大神的第一步。学习决策树树之前，需要掌握数据结构的知识，还需要有一定的python基础。
从零开始的机器学习——ID3决策树 （2018-6-23）.zip
04-16
从上述所列举的应用可知，机器学习正在成为各行各业都会经常使用到的分析工具，尤其是在各领域数据量爆炸的今天，各行业都希望通过数据处理与分析手段，得到数据中有价值的信息，以便明确客户的需求和指引企业的发展...
python机器学习教程-从零开始掌握Python机器学习：十四步教程.pdf
06-12
在开始机器学习之旅之前，首先需要掌握Python的基础编程技能。这包括理解变量、数据类型、控制结构（如if-else，for，while循环）、函数、类和对象等概念。对于初学者，可以通过"Learn Python the Hard Way"这样的...
从零开始手写主流机器学习算法.zip
04-12
机器学习算法在各个领域都有广泛的应用，包括医疗保健、金融、零售和电子商务、智能交通、生产制造等。例如，在医疗领域，机器学习技术可以帮助医生识别医疗影像，辅助诊断疾病，预测病情发展趋势，并为患者提供个性...
Python与机器学习教程 机器学习算法课程-HTML网页版教程课件 可直接在浏览器运行 从入门到进阶.rar
05-03
课程分为三天的内容，即day01、day02和day03，包含了数十个章节，旨在帮助用户从零开始掌握机器学习的基本概念和常用算法。 Python是一种高级编程语言，以其简洁的语法和丰富的库资源受到广大开发者喜爱。在机器...
决策树回归（Decision Tree Regression）
qq_44133607的博客
07-18 412
决策树回归是一种非参数监督学习方法，用于回归问题。它通过将数据集划分成较小的子集来建立模型，并在这些子集上构建简单的预测模型（通常是恒定值）。
决策树：简单而强大的机器学习算法
UnityBoy的博客
07-21 399
在机器学习的众多算法中，决策树（Decision Tree）以其直观易懂和易于实现的特点，成为了许多初学者的首选。决策树不仅在分类和回归问题中表现出色，还能提供易于解释的模型，帮助我们理解数据中的模式。
基于遗传算法和决策树的特征选择
博客简介
07-17 277
使用遗传算法进行特征选择，并使用决策树算法评估每个特征选择方案的分类性能。通过这种方式，可以找到最优的特征子集，从而提高分类模型的性能。遗传算法通过模拟生物进化过程，逐步优化特征选择方案，而决策树算法则提供了快速评估特征选择方案的手段。
什么是决策树？
qq_40698086的博客
07-17 489
决策树（Decision Tree）是一种常用的机器学习算法，用于解决分类和回归问题。它通过构建树结构来表示决策过程，分支节点表示特征选择，叶节点表示类别或回归值。
使用Python的Turtle库绘制动态风车
爱写代码的小朋友
07-20 327
python绘制风车
Java-Lambda
最新发布
lizhiwei21的博客
07-21 202
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 621
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 409
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
IPython 日志秘籍：%logstate 命令全解析
2401_85812026的博客
07-17 593
logstate命令是 IPython 日志系统的重要组成部分，它帮助我们掌控日志记录的状态。通过本文的介绍，你应该对如何在 IPython 中使用%logstate查看日志状态有了更深入的理解。记住，合理利用日志系统，可以让你的数据探索过程更加透明和可追溯。本文详细介绍了 IPython 的%logstate命令，包括其基本概念、基本用法、输出解析以及实战示例。希望本文能够帮助读者更好地利用 IPython 的日志系统，优化数据探索和科学计算的工作流。记住，掌握%logstate。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 399
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
从零开始的机器学习：Scikit-Learn与TensorFlow实战
Learn and TensorFlow》由Aurélien Géron撰写，这本书是面向机器学习初学者的实践指南，旨在帮助读者从零基础开始理解机器学习的基本概念、直觉，并掌握使用Scikit-Learn和TensorFlow实现学习算法的工具。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值