树回归_机器学习

最新推荐文章于 2024-05-25 15:04:23 发布
最新推荐文章于 2024-05-25 15:04:23 发布
阅读量144 收藏
点赞数
分类专栏： 人工智能
4AM_明朝百晓生
本文链接：https://blog.csdn.net/chengxf2/article/details/103490980
版权

前言：

 

目录：

  1.    CART
  2.    模型树
  3.    树剪枝
  4.    GUI 使用

一 CART 

      流程：

      CreateTree

       寻找最佳的切分特征：

                      如果该节点不能再分，将该节点存为叶节点

                      执行二元切分

                      右子树调用 CreateTree() 方法

                       左子树调用CreateTree()方法

      最佳的切分特征：

                       遍历每个特征值

                               将数据切分为两份

                                计算切分的误差

                                 如果当前的误差小于当前的最小误差，那将当前切分设定为最佳切分并更新最小误差

                           返回最佳的特征和阀值

                           预剪枝：提前终止条件也是方法之一

     树剪枝（后剪枝）

                          基于已有的树切分测试数据

                                      如果存在任一子集是一棵树，则在该子集递归剪枝过程

                                      计算将当前两个叶结点合并后的误差

                                      计算不合并后的误差

                                     如果合并后的误差会降低误差，则叶合并

# -*- coding: utf-8 -*-
"""
Created on Mon Dec  9 14:27:46 2019

@author: chengxf2
"""

import numpy as np
from time import sleep
import os
import matplotlib.pyplot as plt

class treeNone():
      
      def __init__(self, feat, val, right, left):
          
          self.feature = feat
          self.value = val
          self.rightBranch = right
          self.leftBranch = left
          

def LoadDataSet(fileName):
    
    dataMat = []
    
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        floatLine = list(map(float, curLine))
        
        dataMat.append(floatLine)
    #print("\n dataMat \n ",dataMat)
    return np.mat(dataMat)

def BinSplitDataSet(dataSet, feature, value):
  

    index = np.nonzero(dataSet[:,feature]>value)[0]
    index1 = np.nonzero(dataSet[:,feature]<=value)[0]
    matL = dataSet[index,:]
    matR = dataSet[index1,:]
    

    return matL,matR

"""
当前的均值
Args
    dataSet: 当前的样本集
return 
    均值
"""
def RegLeaf(dataSet):
    
    y = np.mean(dataSet[:,-1])
    return y

"""
当前的方差
Args
  dataSet: 样本集
return 
  方差
"""
def RegErr(dataSet):
    m,n = np.shape(dataSet)
    q = np.var(dataSet[:,-1])
    
    return q*m

"""
选择最优特征去切分
Args
  dataSet: 数据集
  leafType: 当前均值
  errType: 方差

return
   最优属性
"""
def chooseBestSplit(dataSet, leafType=RegLeaf, errType = RegErr, ops=(1,4)):
    minDiff = ops[0]; minNum = ops[1]
    
    #print("\n dataSet ",dataSet)
    
    n = len(set(dataSet[:,-1].T.tolist()[0]))
    print("\n  ****chooseBestSplit**** \n ",n)
    if n == 1: ##只有一类
        return None, leafType(dataSet)
    
    m,n = np.shape(dataSet)
    S = errType(dataSet)
    bestS = np.inf ; bestIndex = -1; bestValue = -1
    
    for featIndex in range(n-1): ##最后一列是y
        
        for val in set(dataSet[:,featIndex].T.tolist()[0]):
            # print("\n val ",val)
             matL, matR =  BinSplitDataSet(dataSet, featIndex, val)
             
             m1,n1 = np.shape(matL)
             m2,n2 = np.shape(matR)
             
             if m1<minNum or m2<minNum:
                 continue
             
             newS = errType(matL)+errType(matR)
             
             if newS<bestS:
                 bestS = newS
                 bestIndex = featIndex
                 bestValue = val
                 
    
    if (S-bestS)<minDiff:##以前无法划分了
        
        return None,leafType(dataSet)
    
   #############有个预剪枝操作#############3
    m1,n1 = np.shape(matL)
    m2,n2 = np.shape(matR)
    if m1<minNum or m2<minNum:
        print("\n *********m1    ****************")
        return None,leafType(dataSet)
    return bestIndex, bestValue
        
        
    


"""
创建树
Args
   dataMat 数据集
   leafType: 叶节点，均值
   errType: 方差
   ops() tuple[0] 终止条件1，当前切分后变化下限  tuple[1] 叶节点个数
   
"""
def createTree(dataMat, leafType = RegLeaf, errType = RegErr, ops=(1,4)):
    print("\n ********Enter******* \n ")
    feat, val = chooseBestSplit(dataMat, leafType, errType, ops)
    print("\n createTree feat ",feat, "\t val: ",val)
    if feat is None:
        print("\n None Feat")
        return val
    retTree ={}
    
    retTree['spInd'] = feat
    retTree['spVal'] = val
    lSet, rSet = BinSplitDataSet(dataMat, feat, val)
    retTree['left']= createTree(lSet, leafType,errType,ops)
    retTree['right']= createTree(rSet, leafType,errType,ops)
    
    return retTree

"""
判断是否是树
"""
def IsTree(obj):
    return type(obj).__name__=='dict'

"""
获得误差
Args
   tree: 树
"""
def GetMean(tree):
    if IsTree(tree['left']):
        tree['left']=GetMean(tree['left'])
    
    if IsTree(tree['right']):
        tree['right']=GetMean(tree['right'])
        
    return (tree['left']+tree['right'])/2.0

"""
后剪枝
Args
   tree: 已经用train 数据集生成的数据
   testData: 用测试集去后剪枝
"""   
def Prune(tree, testData):
    m,n = np.shape(testData)
    if m == 0: ##数据集为Null
        return GetMean(tree)
    
    if IsTree(tree['left']) or IsTree(tree['right']): ##分割数据
       lMat, rMat = BinSplitDataSet(testData, tree['spInd'], tree['spVal'])
       
    if IsTree(tree['left']):
        tree['left']= Prune(tree['left'],lMat)
    
    if IsTree(tree['right']):
        tree['right']= Prune(tree['right'],rMat)
        
    if not IsTree(tree['left']) and not IsTree(tree['right']):
        lMat, rMat =  BinSplitDataSet(testData, tree['spInd'], tree['spVal'])
        
        #print("\n tree['left']",tree['left'],"\t tree['right']",tree['right'])
        errorNoMerge = np.sum(np.power(lMat[:,-1]-tree['left'],2))+ np.sum(np.power(rMat[:,-1]-tree['right'],2))
        #print("\n errorM ::",errorNoMerge)
        
        treeMean = (tree['left']+tree['right'])/2.0
        errorMerge = np.sum(np.power(testData[:,-1]-treeMean,2))
        if errorMerge< errorNoMerge:
            print("\n Merget:  ", errorNoMerge-errorMerge)
            return treeMean
        else:
            return tree
    else: 
        return tree
 
"""
预测
Args
   data: 数据集
   tree: 模型
   modelEval : 预测树
"""
def TreeForeCast(tree, data):
     
    if not IsTree(tree): ##已经是叶节点
        y = float(tree)
        return y
    
    #print("\n tree['spVal']",tree['spInd'], "\t ",data)
    key = tree['spInd']; value =tree['spVal']
    if data[0,key]> value:  
        if IsTree(tree['left']):
            return TreeForeCast(tree['left'],data)
        else:
            return  float(tree['left'])
    
    else:
        if IsTree(tree['right']):
            return TreeForeCast(tree['right'],data)
        else:
            return float(tree['right'])
        
"""
预测
Args
   data: 数据集
   tree: 模型
   
"""
def ForeCast(tree, testData):
    m,n = np.shape(testData)
    
    yHat = np.mat(np.zeros((m,1)))
    X = np.arange(0,m)
    Y =[]
   
    for i in range(m):
        yHat[i,0]= TreeForeCast(tree, testData[i,0:n-1])
        print("\n 预测值  ",yHat[i,0],"\t 实际值: ", testData[i,-1])
        Y.append(yHat[i,0]-testData[i,-1])
    
    
    Y.sort()
    plt.scatter(X,Y,c='r')
   # plt.scatter(X,Y2,c='g')
    return yHat

    
def Test():
    
    path = os.path.abspath("ex2.txt")
    trainData = LoadDataSet(path)
    myTree = createTree(trainData,ops=(1,2))
    print("\n ***MyTree ******** \n ", myTree)
    
    
    path2 = os.path.abspath("ex2test.txt")
    testData = LoadDataSet(path2)
    newTree = Prune(myTree, testData)
    print("\n prune Tree: \n ",newTree)
    
    ForeCast(newTree, testData)

Test()

       

二 模型树

   

      如上 所不同的，最优点切分使用回归算法。

      1： 叶节点是一个权值系数，不再是预测值

                 预测值为：    y=X^TW+b

   

    myTree = createTree(trainData, ModelLeaf, ModelErr, ops=(1,5))

 

  

# -*- coding: utf-8 -*-
"""
Created on Wed Dec 11 16:56:19 2019

@author: chengxf2
"""

import numpy as np
import os
import matplotlib.pyplot as plt

"""
加载数据集
"""
def LoadDataSet(fileName):
    
    dataMat = []
    
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        floatLine = list(map(float, curLine))
        
        dataMat.append(floatLine)
    #print("\n dataMat \n ",dataMat)
    return np.mat(dataMat)
"""
判断是否是树
"""
def IsTree(obj):
    return type(obj).__name__=='dict'


def BinSplitDataSet(dataSet, feature, value):
  

    index = np.nonzero(dataSet[:,feature]>value)[0]
    index1 = np.nonzero(dataSet[:,feature]<=value)[0]
    matL = dataSet[index,:]
    matR = dataSet[index1,:]
    

    return matL,matR
"""
线性模型
Args
    dataSet: 数据集
return
    ws: 权值系数
    X: 样本集
    Y: 标签集
"""    
def LinearSolve(dataSet):
    
    
    m,n = np.shape(dataSet)
    X = np.mat(np.ones((m,n))); Y = np.mat(np.ones((m,1)))  
    
    X[:,1:n]=dataSet[:,0:n-1]
    Y = dataSet[:,-1]
    
    A = X.T*X
    if np.linalg.det(A)==0: ##也可以通过岭回归解决 需要增加第个值，或者正规化
        raise NameError("\n ********非线性**************")
    W = np.linalg.inv(A)*(X.T*Y)
    return W,X,Y

"""
生成叶
Args
    dataSet: 数据集
"""
def ModelLeaf(dataSet):
    W, X,Y = LinearSolve(dataSet)
    print("\n ****** W **********\n",W)
    return W

"""
模型错误
Args
   dataSet: 数据集
return
   None
"""
def ModelErr(dataSet):
    W,X,Y = LinearSolve(dataSet)
    
    yHat = X*W## 预测值

    return np.sum(np.power(Y-yHat,2))


"""
选择最优特征去切分
Args
  dataSet: 数据集
  leafType: 当前均值
  errType: 方差

return
   最优属性
"""
def chooseBestSplit(dataSet, leafType=RegLeaf, errType = RegErr, ops=(1,4)):
    minDiff = ops[0]; minNum = ops[1]
    
    #print("\n dataSet ",dataSet)
    
    n = len(set(dataSet[:,-1].T.tolist()[0]))
    print("\n  ****chooseBestSplit**** \n ",n)
    if n == 1: ##只有一类
        return None, leafType(dataSet)
    
    m,n = np.shape(dataSet)
    S = errType(dataSet)
    bestS = np.inf ; bestIndex = -1; bestValue = -1
    
    for featIndex in range(n-1): ##最后一列是y
        
        for val in set(dataSet[:,featIndex].T.tolist()[0]):
            # print("\n val ",val)
             matL, matR =  BinSplitDataSet(dataSet, featIndex, val)
             
             m1,n1 = np.shape(matL)
             m2,n2 = np.shape(matR)
             
             if m1<minNum or m2<minNum:
                 continue
             
             newS = errType(matL)+errType(matR)
             
             if newS<bestS:
                 bestS = newS
                 bestIndex = featIndex
                 bestValue = val
                 
    
    if (S-bestS)<minDiff:##以前无法划分了
        
        return None,leafType(dataSet)
    """  把预剪枝部分删除
    m1,n1 = np.shape(matL)
    m2,n2 = np.shape(matR)
    if m1<minNum or m2<minNum:
        print("\n *********m1    ****************")
        return None,leafType(dataSet)
    """
    return bestIndex, bestValue


"""
创建树
Args
   dataMat 数据集
   leafType: 叶节点，均值
   errType: 方差
   ops() tuple[0] 终止条件1，当前切分后变化下限  tuple[1] 叶节点个数
   
"""
def createTree(dataMat, leafType = RegLeaf, errType = RegErr, ops=(1,4)):
    print("\n ********createTree******* \n ")
    feat, val = chooseBestSplit(dataMat, leafType, errType, ops)
    print("\n chooseBestSplit End feat ",feat, "\t val: ",val)
    if feat is None:
        print("\n Feat is None return val")
        return val
    retTree ={}
    
    retTree['spInd'] = feat
    retTree['spVal'] = val
    lSet, rSet = BinSplitDataSet(dataMat, feat, val)
    retTree['left']= createTree(lSet, leafType,errType,ops)
    retTree['right']= createTree(rSet, leafType,errType,ops)
    
    return retTree


"""
Cart的输出值
Args
   model: 叶节点的值
   
"""
def regTreeEval(model,data):
    
    return float(model)

"""
树回归的输出值
Args:
    dataMat: 数据集
    W: 权值系数
return:
    Y: 输出值=X*W+B
"""
def modelTreeEval(W, dataMat):
    
    m,n = np.shape(dataMat)
    
   
    X = np.mat(np.ones((1,n+1)))
    X[:,1:n+1]=dataMat
    return float(X*W)

"""
预测
Args
   data: 数据集
   tree: 模型
   modelEval : 预测树
"""
def TreeForeCast(tree, data, modelEval= modelTreeEval):
     
    if not IsTree(tree):
        y = modelEval(tree, data)
        return y
    
    #print("\n tree['spVal']",tree['spInd'], "\t ",data)
    key = tree['spInd']; value =tree['spVal']
    if data[0,key]> value:  
        if IsTree(tree['left']):
            return TreeForeCast(tree['left'],data, modelEval)
        else:
            return modelEval(tree['left'], data)
    else:
        if IsTree(tree['right']):
            return TreeForeCast(tree['right'],data, modelEval)
        else:
            return modelEval(tree['right'], data)
        
"""
预测
Args
   data: 数据集
   tree: 模型
   
"""
def CreateForeCast(tree, testData, modelEval = modelTreeEval):
    m,n = np.shape(testData)
    
    yHat = np.mat(np.zeros((m,1)))
    X = np.arange(0,m)
    Y1 =[]
    Y2 =[]
    for i in range(m):
        yHat[i,0]= TreeForeCast(tree, testData[i,0:n-1], modelEval)
        print("\n 预测值  ",yHat[i,0],"\t 实际值: ", testData[i,-1])
        Y1.append(yHat[i,0]-testData[i,-1])
        Y2.append(testData[i,-1])
    
    Y1.sort()
    plt.scatter(X,Y1,c='r')
   # plt.scatter(X,Y2,c='g')
    return yHat


def Test():
    
    path = os.path.abspath("Modeltrain.txt")
    trainData = LoadDataSet(path)
   # print("\n trainData ",trainData)
    myTree = createTree(trainData, ModelLeaf, ModelErr, ops=(1,20))
    
    print("\n myTree ",myTree)
    
    print("\n **********开始预测*******************\n")
    
    path2 = os.path.abspath("ModelTest.txt")
    testData = LoadDataSet(path2)
    CreateForeCast(myTree, testData, modelTreeEval)

Test()

参考文档：

   《机器学习实战》

明朝百晓生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习经典算法8-树回归
moodytong的专栏
08-19 2万+
1.简单介绍         线性回归方法可以有效的拟合所有样本点（局部加权线性回归除外）。当数据拥有众多特征并且特征之间关系十分复杂时，构建全局模型的想法一个是困难一个是笨拙。此外，实际中很多问题为非线性的，例如常见到的分段函数，不可能用全局线性模型来进行拟合。 树回归将数据集切分成多份易建模的数据，然后利用线性回归进行建模和拟合。这里介绍较为经典的树回归CART(classificatio
【机器学习实战】第9章 树回归
片刻 - ApacheCN
10-09 1185
第9章 树回归 http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default">> 树回归 概述 我们本章介绍 CART(Classification And Regression Trees， 分类回归树) 的树构建算法。该算法既可以用于分类还可以用于回归。 树回归 场景 我们在第 8 章
超简单白话文机器学习 - 回归树&树剪枝（含算法介绍，公式，源代码实现以及调包实现）
最新发布
qq_51222843的博客
05-25 1601
我们一般使用CART回归树，CART(Classification and Regression Trees)回归树是一种用于连续值预测的树模型。它通过递归地分裂数据集，以最小化预测误差为目标，最终生成一棵树结构的模型。
树回归-CART
weixin_30421525的博客
01-03 176
1、树回归的提出背景 线性回归需要拟合所有的样本（除了局部加权性回归），实际生活中大部分的问题是非线性的。所以需要将数据集进行切分成很多份容易建模的数据，然后利用线性回归的方法进行建模。但是一般一两次的切分仍然不能满足要求，所以就提出了树回归的方法 2、CART(classification and regression trees) 分类回归树 该算法不仅...
机器学习实战笔记-树回归
fighting!
11-17 543
9.1 复杂数据的局部性建模第3章使用决策树来进行分类。决策树不断将数据切分成小数据集，直到所有目标变量完全相 同 ，或者数据不能再切分为止。决策树是一种贪心算法，它要在给定时间内做出最佳选择，但并不关心能否达到全局最优。 树回归 优点：可以对复杂和非线性的数据建模。 缺点：结果不易理解。 适用数据类型：数值型和标称型数据。第3章使用
树回归
R.KING
04-13 370
为什么会引入树回归？因为现实生活中很多问题是非线性的，单纯的用线性回归得不到满意的结果。树回归的核心思想是数据集切分：既然全体数据集太复杂不好建模，就把它切分成很多份，每份方便建模就行了呗。至于怎么切分，切出来之后怎么建模就是树回归研究的问题。
树回归_树回归_
10-03
树回归是一种在机器学习领域广泛使用的预测模型，它结合了多个决策树的预测结果来得到一个更准确的输出。在本主题中，我们将深入探讨树回归的核心概念，以及如何使用Python实现这一算法，特别是通过AdaBoost算法。 ...
ex2-logistic regression_逻辑回归_机器学习_
10-02
在机器学习领域，逻辑回归是一种基础且重要的监督学习方法。 **工作原理** 逻辑回归的核心在于将线性回归的结果通过一个非线性的函数——sigmoid函数（S型曲线）转换，从而得到一个介于0到1之间的概率值。这个概率...
逻辑回归_逻辑回归_python机器学习_
10-01
逻辑回归是一种广泛应用的统计分析方法，它在机器学习领域中主要用作二分类模型，尽管在某些情况下也可以扩展到多分类任务。这个模型的名字虽然含有“回归”一词，但实际上，逻辑回归主要用于处理离散型的目标变量，...
tree_机器学习_决策树_
10-03
决策树是一种广泛应用于机器学习领域的算法，它以其直观易懂和高效的特点深受数据科学家和机器学习工程师的喜爱。本文将深入探讨决策树的基本概念、工作原理、优缺点以及在实际问题中的应用。 一、决策树简介 决策...
机器学习实战——树回归
uilotus
09-19 1180
一、 CART算法 二、
第9章 树回归
Slashyouth的博客
06-02 380
树回归 概述 我们本章介绍 CART(Classification And Regression Trees， 分类回归树) 的树构建算法。该算法既可以用于分类还可以用于回归。 树回归 场景 我们在第 8 章中介绍了线性回归的一些强大的方法，但这些方法创建的模型需要拟合所有的样本点（局部加权线性回归除外）。当数据拥有众多特征并且特征之间关系十分复杂时，构建全局模型的想法就显得太难了，也略显笨拙。而且，实际生活中很多问题都是非线性的，不可能使用全局线性模型来拟合任何数据。 一种可行的方法是将数据集切分成很多份
树回归预测
爱哭的猫的专栏
03-13 969
两种树已经创建完毕，现在我们就进行预测：train.txt (提取码：405c) test.txt (提取码：72d9) def regTreeEval(model, inDat): return float(model) def modelTreeEval(model, inDat): n = shape(inDat)[1] X = mat(ones((1,n+1)
机器学习-树回归
pcb931126的博客
01-14 205
基于CART形成的回归树以及树的预剪枝和后剪枝，代码如下： """ 机器学习-树回归（CART） 姓名:pcb 日期：2019.01.10 """ from numpy import * class treeNode(): def __init__(self,feat,val,right,left): featureToSplitOn=feat valu...
回归与决策树详解：机器学习实战课程关键
本资源是一份关于机器学习中的回归与决策树课程的PPT，内容涵盖了回归分析的多个方面，包括线性回归、多元线性回归以及它们在实际问题中的应用。在讲解回归部分，首先介绍了线性回归的基本概念，如线性模型的一般...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值