【机器学习】决策树（鸢尾花数据集c++）

最新推荐文章于 2024-04-25 16:54:27 发布
最新推荐文章于 2024-04-25 16:54:27 发布
阅读量481 收藏 4
点赞数 3
分类专栏： 机器学习 文章标签： 机器学习 决策树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73799537/article/details/131031294
版权

决策树处理鸢尾花数据集C++

预剪枝前

#include<iostream>
#include<fstream>
#include<istream>
#include<iomanip>
#include<sstream>
#include<stdio.h>
#include<vector>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<algorithm>
#include<time.h>
using namespace std;

/*
定义node结点类
定义决策树类
决策树类内包含生成决策树函数——treegenerate  递归函数中，有三个基类，停止递归
1、全属于同一种类别，标记为叶结点
2、当前属性集为空，标记为该数据集中最多的类
3、样本集合为空，标记为叶结点，类别是父结点最多的类
*/
//  start, finish;

class DataSet{
    public:
    vector<string> Attribute; //属性标签："花萼长度","花萼宽度","花萼长度","花瓣长度"
    vector<vector<string>> Data; // 属性值：5.1 3.5 1.4 0.2
    map<string,vector<string>> AttributeValue; //映射类型，整个表的数据：{"类别":{...},"花萼长度":{5.1,4.9,5.7....},"..":{...}}
    
    DataSet(); //初始构造函数
    DataSet(vector<vector<string>> data, vector<string> attribute); //过程的构造函数
    void Connect(); //关联属性标签与属性值
};
DataSet::DataSet(){
    Attribute={"花萼长度","花萼宽度","花瓣长度","花瓣宽度"};
}
DataSet::DataSet(vector<vector<string>> data, vector<string> attribute){
    Data=data;
    Attribute=attribute;
    Connect();
}
void DataSet::Connect(){
    if(Data.empty()) return;

    vector<vector<string>> attribute; //存储属性值的转置
    vector<string> TempAttribute = Attribute; //存储属性标签
    TempAttribute.push_back("类别"); //5
    attribute.resize(TempAttribute.size()); //5

    // Data 150行x5列
    for(int i=0;i<Data[0].size();i++){  //i 0-4
        for(int j=0;j<Data.size();j++){ //j 0-149
            attribute[i].push_back(Data[j][i]);
        }
        
        AttributeValue[TempAttribute[i]]=attribute[i];
    }
    
}
void Read_csv(DataSet &dataSet,string fname){
    // 读取文件
    ifstream csv_data(fname, ios::in);
    if (!csv_data.is_open()){
        cout << "Error: opening file fail" << endl;
        exit(1);
    }
    else{
        string line;
        vector<string> words;
	    string word;

        // 读取数据
	    getline(csv_data, line);// 读取标题行
        istringstream sin;
	    // 按行读取数据
        while (getline(csv_data, line))
        {
            word.clear();
            words.clear();
            sin.clear();
            sin.str(line);
            while (getline(sin, word, ',')){
                words.push_back(word);  //将每一格中的数据逐个push
            }
            dataSet.Data.push_back(words);
        }
        csv_data.close();
        dataSet.Data.pop_back();
    }
    dataSet.Connect();
}

class Node{
    public:
    Node(){
        isLeaf=false;
        isRoot=false;
    }
    
    vector<double> MidValue;
    bool isLeaf;
    bool isRoot;
    string node_Attribute;
    //判断标准
    double Mid;
    string Attribute;
    vector<Node*> ChildrenNode;
};

class DecisionTree{
    public:
    void TreeGenerate(DataSet &dataSet,Node* Father); //生成决策树，返回根结点的指针
    double CalcEntropy(DataSet &dataSet); //计算一个数据集的信息熵
    double CalcInfoGain(double midValue,DataSet& dataSet,string Value); //计算一个属性的信息增益

    vector<double> FindMidValue(DataSet &dataSet); //计算一个属性的划分点，构建循环计算一个属性的信息增益
    map<string,double> FindBestInfoGain(DataSet &dataSet); //找最大信息增益，返回最优属性以及最大增益的映射
    map<string,int> CountTimes(DataSet &dataSet); //计算各类别的样本数量
    void DestoryDecisionTree(Node* node);//删除决策树
    vector<string> Prediction(DataSet &dataSet,Node *node);
};
void DecisionTree::TreeGenerate(DataSet &dataSet,Node* Father){
    
    Node *newNode=new Node;
    Father->ChildrenNode.push_back(newNode);
    vector<double> newMid = FindMidValue(dataSet);//本次的各属性最优划分点
    newNode->MidValue = newMid;

    // 情况1：如果数据集中数据属于同一类别，将node标记为C类叶结点
    bool isSame=true;
    string curAttr=dataSet.AttributeValue["类别"][0];
    for(int i=0;i<dataSet.AttributeValue["类别"].size();i++){
        if(dataSet.AttributeValue["类别"][i]!=curAttr){
            isSame=false;
            break;
        }
    }
    if(isSame){
        newNode->isLeaf=true;
        newNode->node_Attribute=curAttr;
        return ;
    }

    // 情况2：属性集为空或数据集中样本在属性集上取值相同
    isSame = true;
    for (int i = 0; i < dataSet.Attribute.size(); i++) {
        string a = dataSet.AttributeValue[dataSet.Attribute[i]][0];
        if (stod(a) > Father->MidValue[i]) {//?
            for (int j = 1; j < dataSet.Data.size(); j++) {
                if (stod(dataSet.AttributeValue[dataSet.Attribute[i]][j]) <= Father->MidValue[i]) {
                    isSame = false;
                    break;
                }
            }
        }
        else {
            for (int j = 1; j < dataSet.Data.size(); j++) {
                if (stod(dataSet.AttributeValue[dataSet.Attribute[i]][j]) > Father->MidValue[i]) {
                    isSame = false;
                    break;
                }
            }
        }
        if(isSame==false) break;
    }
    if(dataSet.Attribute.empty()||isSame==true){
        newNode->isLeaf=true;
        map<string,int> mp=CountTimes(dataSet);
        int maxTimes=-1;
        string maxValue;
        for(auto i=mp.begin();i!=mp.end();i++){
            if(i->second>maxTimes){
                maxValue=i->first;
                maxTimes=i->second;
            }
        }
        newNode->node_Attribute=maxValue;
        return;
    }
   
    //情况3:从属性集中划分最优属性
    map<string,double> BestAttributeMap=FindBestInfoGain(dataSet);
    string BestAttribute=BestAttributeMap.begin()->first;
    newNode->Attribute = BestAttribute;

    //找出一个属性中的最优划分点
    vector<string> TempAttribute;
    TempAttribute.push_back(BestAttribute);
    vector<string> TempValue=dataSet.AttributeValue[BestAttribute];
    vector<string> TempAttr = dataSet.AttributeValue["类别"];
    vector<vector<string>> TempData(TempValue.size());
    for(int i=0;i<TempValue.size();i++){
        TempData[i].push_back(TempValue[i]);
        TempData[i].push_back(TempAttr[i]);
    }
    DataSet d(TempData,TempAttribute);
    vector<double> MidArray=FindMidValue(d);
    
    double bestmid = MidArray[0];//最优属性的最优划分点
    newNode->Mid = bestmid;
    vector<vector<vector<string>>> NextData(2);//下一次分类的数据
    for (int i = 0; i < dataSet.Data.size(); i++) {
        if (stod(dataSet.AttributeValue[BestAttribute][i]) < bestmid) {
            NextData[0].push_back(dataSet.Data[i]);
        }
        else {
            NextData[1].push_back(dataSet.Data[i]);
        }
    }
    for (int i = 0; i < NextData.size(); i++) {
        Node* newChild = new Node;
        if (NextData[i].empty()){
            newNode->ChildrenNode.push_back(newChild);
            newChild->isLeaf = true;
            map<string, int> mp = CountTimes(dataSet);
            int maxTimes = -1;
            string maxValue;
            for (auto i = mp.begin(); i != mp.end(); i++) {
                if (i->second > maxTimes) {
                    maxValue = i->first;
                    maxTimes = i->second;
                }
            }
            newChild->node_Attribute = maxValue;
            return ;
        }
        else {
            delete newChild;
            DataSet NewDataSet(NextData[i], dataSet.Attribute);
            TreeGenerate(NewDataSet, newNode);
        }
    }
}

vector<string> DecisionTree::Prediction(DataSet &dataSet,Node *node) {
    vector<string> ClassArray;
    if (node->isLeaf) {
        ClassArray.push_back(node->node_Attribute);
        return ClassArray;
    }
    else{
        for (int i = 0; i < dataSet.Data.size(); i++) {
            vector<string> oneClass;
            vector<vector<string>> tempData;
            tempData.push_back(dataSet.Data[i]);
            DataSet d(tempData, dataSet.Attribute);
            if (stod(dataSet.AttributeValue[node->Attribute][i]) < node->Mid || node->isRoot) {
                oneClass=Prediction(d, node->ChildrenNode[0]);
            }
            else{
                oneClass=Prediction(d, node->ChildrenNode[1]);
            }
            for(int j=0;j<oneClass.size();j++)
                ClassArray.push_back(oneClass[j]);
            
        }
    }
    return ClassArray;
}
//计算dataSet数据集中所有类别以及样本的出现次数
map<string,int>DecisionTree::CountTimes(DataSet &dataSet){
    map<string,int> ClassCount;
    vector<string> classList=dataSet.AttributeValue["类别"];
    for(int i=0;i<classList.size();i++){
        if(!ClassCount.count(classList[i])){
            ClassCount.insert({classList[i],0});
        }
        ClassCount[classList[i]]++;
    }
    return ClassCount;
}
void DecisionTree::DestoryDecisionTree(Node* node) {
    if (!node->isLeaf)
    {
        for (size_t i = 0; i < node->ChildrenNode.size(); i++)
        {
            DestoryDecisionTree(node->ChildrenNode[i]);
        }
    }
    delete node;	//释放节点
    node = nullptr;
}

double DecisionTree::CalcEntropy(DataSet &dataSet){
    int sum=dataSet.Data.size();//总数据数
    map<string,int> ClassCount=CountTimes(dataSet);
    
    vector<string> classList=dataSet.AttributeValue["类别"];
    double entropy=0;//信息熵
    
    for(auto item = ClassCount.begin();item!=ClassCount.end();item++){
        double p=(double)item->second/sum;
        if(p==0) entropy-=0;
        else entropy-=p*log(p)/log(2);
    }
    return entropy;
}


vector<double> DecisionTree::FindMidValue(DataSet &dataSet){//找出属性中最优划分点
    vector<double> bestMid;
    
    for(int i=0;i<dataSet.Attribute.size();i++){
        vector<string> valueString=dataSet.AttributeValue[dataSet.Attribute[i]];

        //将属性值从string类型转为double类型
        vector<double> valueDouble;
        for(int j=0;j<valueString.size();j++){
            valueDouble.push_back(stod(valueString[j]));
        }

        //排序double类型
        sort(valueDouble.begin(),valueDouble.end());

        vector<double> midArray;
        for(int j=0;j<valueDouble.size()-1;j++){
            midArray.push_back((valueDouble[j]+valueDouble[j+1])/2);
        }

        double bestmid;
        if(midArray.empty()) bestmid=valueDouble[0];
        else bestmid=midArray[0]; //初始化中间点
        double maxmidEntrophy=0; //划分点最大的信息熵

        for(int j=0;j<midArray.size();j++){
            double gain=CalcInfoGain(midArray[j],dataSet,dataSet.Attribute[i]);
            if(gain>=maxmidEntrophy){
                maxmidEntrophy=gain;
                bestmid=midArray[j];
            }
        }
        bestMid.push_back(bestmid); //将最优划分点放入vector容器
    }
    return bestMid;
}

double DecisionTree::CalcInfoGain(double midValue,DataSet& dataSet,string Value){ //计算一个属性的信息增益
    vector<vector<string>> leftData;
    vector<vector<string>> rightData;
    int leftCount=0;
    int sum=dataSet.Data.size();//样本数量
    double mid=midValue;

    for(int i=0;i<dataSet.Data.size();i++){
        if(stod(dataSet.AttributeValue[Value][i])<=mid){
            leftCount++;
            leftData.push_back(dataSet.Data[i]);
        }else{
            rightData.push_back(dataSet.Data[i]);
        }
    }
    DataSet d1(leftData,dataSet.Attribute);
    DataSet d2(rightData,dataSet.Attribute);
    double gain=CalcEntropy(dataSet)-leftCount*CalcEntropy(d1)/sum-(sum-leftCount)*CalcEntropy(d2)/sum;
    
    return gain;
}

map<string,double> DecisionTree::FindBestInfoGain(DataSet &dataSet){
    double maxgain=0;//属性的最大信息增益
    string bestAttri;
    vector<double> middle=FindMidValue(dataSet);
    for(int i=0;i<dataSet.Attribute.size();i++){
        double mid=middle[i];
        double gain=CalcInfoGain(mid,dataSet,dataSet.Attribute[i]);
        if(gain>maxgain){
            maxgain=gain;
            bestAttri=dataSet.Attribute[i];
        }
    }
    map<string,double> mp;
    mp[bestAttri]=maxgain;
    // cout<<"FindBestInforGain Over!"<<endl;
    return mp;
}



int main()
{
    //开始计时
    clock_t start = clock();

    // 创建一个数据集对象
    DataSet dataSet;
    string fname = "iris.csv";
    Read_csv(dataSet,fname);

    DecisionTree dt;
    Node* RootNode = new Node;

    //初始化父结点
    map<string, double> BestAttributeMap = dt.FindBestInfoGain(dataSet);
    string BestAttribute = BestAttributeMap.begin()->first;
    RootNode->Attribute = BestAttribute;

    vector<string> TempAttribute;
    TempAttribute.push_back(BestAttribute);
    vector<string> TempValue = dataSet.AttributeValue[BestAttribute];
    vector<string> TempAttr = dataSet.AttributeValue["类别"];
    vector<vector<string>> TempData(TempValue.size());
    for (int i = 0; i < TempValue.size(); i++) {
        TempData[i].push_back(TempValue[i]);
        TempData[i].push_back(TempAttr[i]);
    }
    DataSet d(TempData, TempAttribute);
    vector<double> MidArray = dt.FindMidValue(d);
    vector<double> Midd = dt.FindMidValue(dataSet);

    RootNode->MidValue = Midd;
    double bestmid = MidArray[0];//最优属性的最优划分点
    RootNode->Mid = bestmid;
    RootNode->isRoot=true;

    // 生成决策树(训练)
    dt.TreeGenerate(dataSet, RootNode);

    DataSet dataSet_pre;
    string fname_pre;
    fname_pre = "iris_pre.csv";
    Read_csv(dataSet_pre, fname_pre);
    vector<string> pre;
    pre=dt.Prediction(dataSet_pre, RootNode);

    //计算正确率百分比
    double accuracy_score=0;
    int count_accuracy=0;
    for(int i=0;i<pre.size();i++){
        if(pre[i]==dataSet_pre.AttributeValue["类别"][i]) count_accuracy++;
    }
    accuracy_score=count_accuracy/pre.size();
    cout<<fixed<<setprecision(2)<<"decision_tree's accuracy_score:"<<accuracy_score*100<<"%"<<endl;

    
    // 释放内存
    dt.DestoryDecisionTree(RootNode);
    
    //运行时间
    clock_t finish = clock();
    cout<<"(Before)The time cost is:"<<double(finish - start) / CLOCKS_PER_SEC<<endl;

    return 0;
}

运行结果

在这里插入图片描述

预剪枝后

#include<iostream>

#include<fstream>
#include<istream>
#include<iomanip>
#include<sstream>
#include<stdio.h>

#include<vector>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<algorithm>
#include<time.h>
using namespace std;

/*
定义node结点类
定义决策树类
决策树类内包含生成决策树函数——treegenerate  递归函数中，有三个基类，停止递归
1、全属于同一种类别，标记为叶结点
2、当前属性集为空，标记为该数据集中最多的类
3、样本集合为空，标记为叶结点，类别是父结点最多的类
*/
//  start, finish;

class DataSet{
    public:
    vector<string> Attribute; //属性标签："花萼长度","花萼宽度","花萼长度","花瓣长度"
    vector<vector<string>> Data; // 属性值：5.1 3.5 1.4 0.2
    map<string,vector<string>> AttributeValue; //映射类型，整个表的数据：{"类别":{...},"花萼长度":{5.1,4.9,5.7....},"..":{...}}
    
    DataSet(); //初始构造函数
    DataSet(vector<vector<string>> data, vector<string> attribute); //过程的构造函数
    void Connect(); //关联属性标签与属性值
};
DataSet::DataSet(){
    Attribute={"花萼长度","花萼宽度","花瓣长度","花瓣宽度"};
}
DataSet::DataSet(vector<vector<string>> data, vector<string> attribute){
    Data=data;
    Attribute=attribute;
    Connect();
}
void DataSet::Connect(){
    if(Data.empty()) return;

    vector<vector<string>> attribute; //存储属性值的转置
    vector<string> TempAttribute = Attribute; //存储属性标签
    TempAttribute.push_back("类别"); //5
    attribute.resize(TempAttribute.size()); //5

    // Data 150行x5列
    for(int i=0;i<Data[0].size();i++){  //i 0-4
        for(int j=0;j<Data.size();j++){ //j 0-149
            attribute[i].push_back(Data[j][i]);
        }
        
        AttributeValue[TempAttribute[i]]=attribute[i];
    }
    
}
void Read_csv(DataSet &dataSet,string fname){
    // 读取文件
    ifstream csv_data(fname, ios::in);
    if (!csv_data.is_open()){
        cout << "Error: opening file fail" << endl;
        exit(1);
    }
    else{
        string line;
        vector<string> words;
	    string word;

        // 读取数据
	    getline(csv_data, line);// 读取标题行
        istringstream sin;
	    // 按行读取数据
        while (getline(csv_data, line))
        {
            word.clear();
            words.clear();
            sin.clear();
            sin.str(line);
            while (getline(sin, word, ',')){
                words.push_back(word);  //将每一格中的数据逐个push
            }
            dataSet.Data.push_back(words);
        }
        csv_data.close();
        dataSet.Data.pop_back();
    }
    dataSet.Connect();
}

class Node{
    public:
    Node(){
        isLeaf=false;
        isRoot=false;
        nodeAccuracy=0;
    }
    
    vector<double> MidValue;
    bool isLeaf;
    bool isRoot;
    string node_Attribute;
    //判断标准
    double Mid;
    string Attribute;
    vector<Node*> ChildrenNode;
    double nodeAccuracy;

};

class DecisionTree{
    public:
    void TreeGenerate(DataSet &dataSet,Node* Father); //生成决策树，返回根结点的指针
    double CalcEntropy(DataSet &dataSet); //计算一个数据集的信息熵
    double CalcInfoGain(double midValue,DataSet& dataSet,string Value); //计算一个属性的信息增益

    double AccuracyRate(DataSet &dataSet, Node* node);
    vector<double> FindMidValue(DataSet &dataSet); //计算一个属性的划分点，构建循环计算一个属性的信息增益
    map<string,double> FindBestInfoGain(DataSet &dataSet); //找最大信息增益，返回最优属性以及最大增益的映射
    map<string,int> CountTimes(DataSet &dataSet); //计算各类别的样本数量
    void DestoryDecisionTree(Node* node);//删除决策树
    vector<string> Prediction(DataSet &dataSet,Node *node);
};
void DecisionTree::TreeGenerate(DataSet &dataSet,Node* Father){
    
    Node *newNode=new Node;
    Father->ChildrenNode.push_back(newNode);
    vector<double> newMid = FindMidValue(dataSet);//本次的各属性最优划分点
    newNode->MidValue = newMid;

    // 情况1：如果数据集中数据属于同一类别，将node标记为C类叶结点
    bool isSame=true;
    string curAttr=dataSet.AttributeValue["类别"][0];
    for(int i=0;i<dataSet.AttributeValue["类别"].size();i++){
        if(dataSet.AttributeValue["类别"][i]!=curAttr){
            isSame=false;
            break;
        }
    }
    if(isSame){
        newNode->isLeaf=true;
        newNode->node_Attribute=curAttr;
        return ;
    }

    // 情况2：属性集为空或数据集中样本在属性集上取值相同
    isSame = true;
    for (int i = 0; i < dataSet.Attribute.size(); i++) {
        string a = dataSet.AttributeValue[dataSet.Attribute[i]][0];
        if (stod(a) > Father->MidValue[i]) {//?
            for (int j = 1; j < dataSet.Data.size(); j++) {
                if (stod(dataSet.AttributeValue[dataSet.Attribute[i]][j]) <= Father->MidValue[i]) {
                    isSame = false;
                    break;
                }
            }
        }
        else {
            for (int j = 1; j < dataSet.Data.size(); j++) {
                if (stod(dataSet.AttributeValue[dataSet.Attribute[i]][j]) > Father->MidValue[i]) {
                    isSame = false;
                    break;
                }
            }
        }
        if(isSame==false) break;
    }
    if(dataSet.Attribute.empty()||isSame==true){
        newNode->isLeaf=true;
        map<string,int> mp=CountTimes(dataSet);
        int maxTimes=-1;
        string maxValue;
        for(auto i=mp.begin();i!=mp.end();i++){
            if(i->second>maxTimes){
                maxValue=i->first;
                maxTimes=i->second;
            }
        }
        newNode->node_Attribute=maxValue;
        return;
    }
   
    //情况3:从属性集中划分最优属性
    map<string,double> BestAttributeMap=FindBestInfoGain(dataSet);
    string BestAttribute=BestAttributeMap.begin()->first;
    newNode->Attribute = BestAttribute;

    //找出一个属性中的最优划分点
    vector<string> TempAttribute;
    TempAttribute.push_back(BestAttribute);
    vector<string> TempValue=dataSet.AttributeValue[BestAttribute];
    vector<string> TempAttr = dataSet.AttributeValue["类别"];
    vector<vector<string>> TempData(TempValue.size());
    for(int i=0;i<TempValue.size();i++){
        TempData[i].push_back(TempValue[i]);
        TempData[i].push_back(TempAttr[i]);
    }
    DataSet d(TempData,TempAttribute);
    vector<double> MidArray=FindMidValue(d);
    
    double bestmid = MidArray[0];//最优属性的最优划分点
    newNode->Mid = bestmid;
    vector<vector<vector<string>>> NextData(2);//下一次分类的数据
    for (int i = 0; i < dataSet.Data.size(); i++) {
        if (stod(dataSet.AttributeValue[BestAttribute][i]) < bestmid) {
            NextData[0].push_back(dataSet.Data[i]);
        }
        else {
            NextData[1].push_back(dataSet.Data[i]);
        }
    }
    

    for (int i = 0; i < NextData.size(); i++) {
        Node* newChild = new Node;
        
        if (NextData[i].empty()){
            newNode->ChildrenNode.push_back(newChild);
            newChild->isLeaf = true;
            map<string,int>mp = CountTimes(dataSet);
            int maxTimes = -1;
            string maxValue;
            for (auto i = mp.begin(); i != mp.end(); i++) {
                if (i->second > maxTimes) {
                    maxValue = i->first;
                    maxTimes = i->second;
                }
            }
            newChild->node_Attribute = maxValue;
            
            return ;
        }
        else {
            //情况4：需要预剪枝
            DataSet NewDataSet(NextData[i], dataSet.Attribute);

            //对newNode的属性初始化
            map<string,int> mp=CountTimes(dataSet);
            int maxTimes=-1;
            string maxValue;
            for(auto i=mp.begin();i!=mp.end();i++){
                if(i->second>maxTimes){
                    maxValue=i->first;
                    maxTimes=i->second;
                }
            }
            newNode->node_Attribute=maxValue;

            //对newChild初始化
            mp = CountTimes(NewDataSet); //先标记为该数据集中数量最多的类
            maxTimes = -1;
            maxValue="";
            for (auto i = mp.begin(); i != mp.end(); i++) {
                if (i->second > maxTimes) {
                    maxValue = i->first;
                    maxTimes = i->second;
                }
            }
            newChild->node_Attribute = maxValue;

            if(AccuracyRate(dataSet,newNode)>AccuracyRate(NewDataSet,newChild)){
                newNode->isLeaf=true;
                delete newChild;
                return;
            }
            delete newChild;
            TreeGenerate(NewDataSet, newNode);
        }
    }
}

// 预剪枝
double DecisionTree::AccuracyRate(DataSet &dataSet, Node* node){
    vector<string> ClassArray=dataSet.AttributeValue["类别"];
    string NodeAttr=node->node_Attribute;
    int count=0;
    for(int i=0;i<ClassArray.size();i++){
        if(NodeAttr==ClassArray[i]) count++;
    }
    return 1.0*count/ClassArray.size();
}

vector<string> DecisionTree::Prediction(DataSet &dataSet,Node *node) {
    vector<string> ClassArray;
    if (node->isLeaf) {
        ClassArray.push_back(node->node_Attribute);
        return ClassArray;
    }
    else{
        for (int i = 0; i < dataSet.Data.size(); i++) {
            vector<string> oneClass;
            vector<vector<string>> tempData;
            tempData.push_back(dataSet.Data[i]);
            DataSet d(tempData, dataSet.Attribute);
            if (stod(dataSet.AttributeValue[node->Attribute][i]) < node->Mid || node->isRoot) {
                oneClass=Prediction(d, node->ChildrenNode[0]);
            }
            else{
                oneClass=Prediction(d, node->ChildrenNode[1]);
            }
            for(int j=0;j<oneClass.size();j++)
                ClassArray.push_back(oneClass[j]);
            
        }
    }
    return ClassArray;
}
//计算dataSet数据集中所有类别以及样本的出现次数
map<string,int>DecisionTree::CountTimes(DataSet &dataSet){
    map<string,int> ClassCount;
    vector<string> classList=dataSet.AttributeValue["类别"];
    for(int i=0;i<classList.size();i++){
        if(!ClassCount.count(classList[i])){
            ClassCount.insert({classList[i],0});
        }
        ClassCount[classList[i]]++;
    }
    return ClassCount;
}
void DecisionTree::DestoryDecisionTree(Node* node) {
    if (!node->isLeaf)
    {
        for (size_t i = 0; i < node->ChildrenNode.size(); i++)
        {
            DestoryDecisionTree(node->ChildrenNode[i]);
        }
    }
    delete node;	//释放节点
    node = nullptr;
}

double DecisionTree::CalcEntropy(DataSet &dataSet){
    int sum=dataSet.Data.size();//总数据数
    map<string,int> ClassCount=CountTimes(dataSet);
    
    vector<string> classList=dataSet.AttributeValue["类别"];
    double entropy=0;//信息熵
    
    for(auto item = ClassCount.begin();item!=ClassCount.end();item++){
        double p=(double)item->second/sum;
        if(p==0) entropy-=0;
        else entropy-=p*log(p)/log(2);
    }
    return entropy;
}


vector<double> DecisionTree::FindMidValue(DataSet &dataSet){//找出属性中最优划分点
    vector<double> bestMid;
    
    for(int i=0;i<dataSet.Attribute.size();i++){
        vector<string> valueString=dataSet.AttributeValue[dataSet.Attribute[i]];

        //将属性值从string类型转为double类型
        vector<double> valueDouble;
        for(int j=0;j<valueString.size();j++){
            valueDouble.push_back(stod(valueString[j]));
        }

        //排序double类型
        sort(valueDouble.begin(),valueDouble.end());

        vector<double> midArray;
        for(int j=0;j<valueDouble.size()-1;j++){
            midArray.push_back((valueDouble[j]+valueDouble[j+1])/2);
        }

        double bestmid;
        if(midArray.empty()) bestmid=valueDouble[0];
        else bestmid=midArray[0]; //初始化中间点
        double maxmidEntrophy=0; //划分点最大的信息熵

        for(int j=0;j<midArray.size();j++){
            double gain=CalcInfoGain(midArray[j],dataSet,dataSet.Attribute[i]);
            if(gain>=maxmidEntrophy){
                maxmidEntrophy=gain;
                bestmid=midArray[j];
            }
        }
        bestMid.push_back(bestmid); //将最优划分点放入vector容器
    }
    return bestMid;
}

double DecisionTree::CalcInfoGain(double midValue,DataSet& dataSet,string Value){ //计算一个属性的信息增益
    vector<vector<string>> leftData;
    vector<vector<string>> rightData;
    int leftCount=0;
    int sum=dataSet.Data.size();//样本数量
    double mid=midValue;

    for(int i=0;i<dataSet.Data.size();i++){
        if(stod(dataSet.AttributeValue[Value][i])<=mid){
            leftCount++;
            leftData.push_back(dataSet.Data[i]);
        }else{
            rightData.push_back(dataSet.Data[i]);
        }
    }
    DataSet d1(leftData,dataSet.Attribute);
    DataSet d2(rightData,dataSet.Attribute);
    double gain=CalcEntropy(dataSet)-leftCount*CalcEntropy(d1)/sum-(sum-leftCount)*CalcEntropy(d2)/sum;
    
    return gain;
}

map<string,double> DecisionTree::FindBestInfoGain(DataSet &dataSet){
    double maxgain=0;//属性的最大信息增益
    string bestAttri;
    vector<double> middle=FindMidValue(dataSet);
    for(int i=0;i<dataSet.Attribute.size();i++){
        double mid=middle[i];
        double gain=CalcInfoGain(mid,dataSet,dataSet.Attribute[i]);
        if(gain>maxgain){
            maxgain=gain;
            bestAttri=dataSet.Attribute[i];
        }
    }
    map<string,double> mp;
    mp[bestAttri]=maxgain;
    // cout<<"FindBestInforGain Over!"<<endl;
    return mp;
}



int main()
{
    //开始计时
    clock_t start = clock();

    // 创建一个数据集对象
    DataSet dataSet;
    string fname = "iris.csv";
    Read_csv(dataSet,fname);

    DecisionTree dt;
    Node* RootNode = new Node;

    //初始化父结点
    map<string, double> BestAttributeMap = dt.FindBestInfoGain(dataSet);
    string BestAttribute = BestAttributeMap.begin()->first;
    RootNode->Attribute = BestAttribute;

    vector<string> TempAttribute;
    TempAttribute.push_back(BestAttribute);
    vector<string> TempValue = dataSet.AttributeValue[BestAttribute];
    vector<string> TempAttr = dataSet.AttributeValue["类别"];
    vector<vector<string>> TempData(TempValue.size());
    for (int i = 0; i < TempValue.size(); i++) {
        TempData[i].push_back(TempValue[i]);
        TempData[i].push_back(TempAttr[i]);
    }
    DataSet d(TempData, TempAttribute);
    vector<double> MidArray = dt.FindMidValue(d);
    vector<double> Midd = dt.FindMidValue(dataSet);

    RootNode->MidValue = Midd;
    double bestmid = MidArray[0];//最优属性的最优划分点
    RootNode->Mid = bestmid;
    RootNode->isRoot=true;

    // 生成决策树(训练)
    dt.TreeGenerate(dataSet, RootNode);

    DataSet dataSet_pre;
    string fname_pre;
    fname_pre = "iris_pre.csv";
    Read_csv(dataSet_pre, fname_pre);
    vector<string> pre;
    pre=dt.Prediction(dataSet_pre, RootNode);

    //计算正确率百分比
    double accuracy_score=0;
    int count_accuracy=0;
    for(int i=0;i<pre.size();i++){
        if(pre[i]==dataSet_pre.AttributeValue["类别"][i]) count_accuracy++;
    }
    accuracy_score=count_accuracy/pre.size();
    cout<<fixed<<setprecision(2)<<"decision_tree's accuracy_score:"<<accuracy_score*100<<"%"<<endl;

    
    // 释放内存
    dt.DestoryDecisionTree(RootNode);
    
    //运行时间
    clock_t finish = clock();
    cout<<"(After)The time cost is:"<<double(finish - start) / CLOCKS_PER_SEC<<endl;

    return 0;
}

运行结果

在这里插入图片描述

YESHUOYUE
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
使用决策树对鸢尾花进行分类python
qq_44425179的博客
04-26 3242
鸢尾花数据集介绍。
Python决策树鸢尾花类别分类(1)
2401_83703797的博客
04-12 346
(2).如果是浮点数(0到1之间)，则每次分裂节点的时候只考虑int(max_features * n_features)个特征。如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。如果为浮点数(0到1之间)，每个叶子节点包含的最少样本数为ceil(min_samples_leaf * n_samples)N_t_R是分裂后右子节点的样本数。其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，
决策树之鸢尾花卉实例解析
rongrongyaofeiqi的博客
10-20 9619
以sklearn数据集中的鸢尾花卉Iris数据集为例，解析决策树。
基于机器学习的鸢尾花数据集的三分类算法的实现 C++
智能码农的博客
07-07 762
基于机器学习的鸢尾花数据集的三分类算法的实现
python代码实现决策树对鸢尾花的分类
最新发布
weixin_40623018的博客
04-25 1174
python代码实现决策树对鸢尾花的分类
决策树分类——附数据下载
ryo007gnnu的博客
10-06 5224
又在网络上搜罗了几个，凑了几个决策树的例子，原理的部分直接略去，说白了就是
【机器学习】监督学习算法 2.3.5 决策树
heroybc的博客
11-01 1172
全文代码如下 需要在github上下载相关数据集，下载整个包，在data中找到ram_prices.csv即可 点这下载 #决策树 import mglearn import numpy as np import matplotlib.pyplot as plt import pandas as pd from sklearn.tree import DecisionTreeClassifier...
决策树实现iris鸢尾花分类-C++
04-28
在本文中，我们将介绍如何在C++中使用决策树算法来解决鸢尾花分类问题。 首先，我们需要准备鸢尾花数据集。可以从网上下载或使用机器学习库中的内置数据集，如scikit-learn。然后，我们需要对数据集进行预处理，包括...
机器学习之鸢尾花-决策树
03-21
其他机器学习模型通常需要数据规范化，比如构建虚拟变量和移除缺失值,不过请注意，这种模型不支持缺失值。 由于训练决策树的数据点的数量导致了决策树的使用开销呈指数分布(训练树模型的时间复杂度是参与训练数据点...
鸢尾花分类实验-决策树_鸢尾花实验_鸢尾花分类实验-决策树_
10-04
在C++中实现决策树，首先需要导入包含鸢尾花数据集的文件，这个数据集通常包括花瓣长度、花瓣宽度、萼片长度和萼片宽度四个特征，以及对应的类别标签（Setosa、Versicolour、Virginica）。数据预处理是关键步骤，...
c++写的决策树分类算法
08-17
c++编写的决策树分类算法，能够对文本进行决策树分类，算法中包括了决策树算法的全部步骤，是决策树学习的不错例子，下载后用VS2008打开就可以执行
蘑菇数据集
11-13
此数据集非常适合用来做决策树，可以用来练习决策树建模。以及其他的分类模型的构建。
决策树C++代码示例
05-22
提供一个关于决策树的C++代码，示例为一个利用决策树对将样本进行训练以及对对象进行分类的算法
决策树C语言代码
07-13
决策树C语言实现代码，建立决策树，建立决策树链接
决策树算法的C++实现
06-04
决策树算法的C++实现
C++机器学习笔记.md
08-24
此外，文章还提供了两个示例，分别展示了如何使用实现的机器学习算法进行预测，其中一个是线性回归预测房价，另一个是决策树分类预测鸢尾花种类。 适合人群： 本文适合对机器学习算法和C++编程有基本了解的读者。 ...
鸢尾花数据集分类-决策树
weixin_42567027的博客
07-21 8124
决策树 决策树（Decision Tree）是一种基本的分类与回归方法，当决策树用于分类时称为分类树，用于回归时称为回归树。主要介绍分类树。 决策树由结点和有向边组成。结点有两种类型：内部结点和叶结点，其中内部结点表示一个特征或属性，叶结点表示一个类。 决策树学算法通常是一个递归地选择最优特征，并根据该特征对训练数据进行分割，使得对各个子数据集有一个最好的分类的过程。根据信息增益准则的特征选择方法：对于训练数据集（或子集），计算其每个特征的信息增益，并比较它们的大小，选择信息增益最大的特征。 数据集 代码
机器学习-决策树概述及对鸢尾花数据分类python实现利用graphviz模块画出决策树
KIDaptx4869的博客
07-15 3299
决策树（decisiontree）是一种基本的分类与回归方法，在分类问题中，表示基于特征对实例进行分类的过程。学习时，利用训练数据，根据损失函数最小化的原则建立决策树模型；预测时，对新的数据，利用决策树模型进行分类。决策树的学习通常包括3个步骤特征选择、决策树的生成和决策树的修剪。决策树算法的基本思想递归地选择最优特征，并根据该特征对训练数据进行分割，使得各个子数据集有一个最好的分类的过程。这个过程就是特征空间的划分，也是决策树的构建。......
机器学习鸢尾花数据集
10-10
鸢尾花数据集是一个常用的机器学习数据集，其中包含了三个不同种类的鸢尾花：山鸢尾（setosa）、变色鸢尾（versicolor）和维吉尼亚鸢尾（virginica）。每个样本都有四个特征：萼片长度、萼片宽度、花瓣长度和花瓣...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值