c++版id3决策树实现

最新推荐文章于 2020-05-16 17:16:32 发布
最新推荐文章于 2020-05-16 17:16:32 发布
阅读量940 收藏 4
点赞数
分类专栏： 机器学习 文章标签： c++ 数据结构 机器学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_16233463/article/details/36379975
版权

上一篇文章实现了Python的决策树，借用上篇文章的算法思路实现了c++版的算法。数据结构是自己设计实现，肯定有很多不好的地方希望各位高手能给出些建议，这是我第一次使用c++来实现这样大的程序。程序中用到的数据是借用网上一哥们二的。

DataSet.h

#ifndef SAMPLE_H
#define SAMPLE_H
#include<vector>
#include<string>
#include<set>
using namespace std;
class DataSet
{
private:
	void ReadData(ifstream &in);//读取数据
	vector<string> SplitLine(const string &str);//处理从文件读入的每一行数据
	double Entropy(const vector<int> &v);

public:
	struct Sample
	{
		vector<string> attributes;
		string targetAttributes;
	};

	//存储数据的元素
	vector<string> attributesNames; //变量名称
	vector<Sample> dataSet; //数据集合

	DataSet();//无参数构造函数
	DataSet(const string &fileName);//从文件构造数据集
	~DataSet();
	void Print();//打印数据集，用于直观显示存储的数据。
	double Gain(const string &featureName);//计算信息增益

	DataSet SplitDataSet(const string&featureName, const string &featureValue);
	string BestSplitFeature();//最大信息增益的属性
	string CommomTargetValue();
	bool IsSameTarget();
	int GetAttributeIndex(const string &attributeName);

};

#endif

DataSet.cpp 

#include<vector>
#include<iostream>
#include<fstream>
#include<string>
#include<map>
#include<set>
#include<numeric>
#include"DataSet.h"

using namespace std;
//默认构造函数
DataSet::DataSet()
{
	
}
//从文件构建数据集
DataSet::DataSet(const string &fileName)
{
	ifstream in(fileName);
	if (!in)
	{
		cout << "文件打开失败";
	}
	else
	{
		ReadData(in);
	}
}
//析构函数
DataSet::~DataSet()
{
	if (!attributesNames.empty())
	{
		 dataSet.clear();
		 attributesNames.clear();
	}
}

//读取数据
void DataSet::ReadData(ifstream &in)
{
	string str;
	vector<string> tempV;
	getline(in, str);
	tempV= SplitLine(str);//调用splitLine;
	attributesNames.assign(tempV.begin() + 1, tempV.end() - 1);
	while (getline(in, str))
	{
		Sample s;
		tempV = SplitLine(str);
		s.attributes.assign(tempV.begin() + 1, tempV.end() - 1);
		s.targetAttributes = tempV[tempV.size() - 1];
		dataSet.push_back(s);
	}
}
//切分从文件读取的行
vector<string> DataSet::SplitLine(const string &str)
{
	vector<string> v;
	bool isFirstBlank = true;
	string::size_type pos=0;
	for (string::size_type i = 0; i != str.size(); ++i)
	{
		if (str[i] == '\t'&&isFirstBlank)
		{
			v.push_back(string(str,pos,i-pos));
			isFirstBlank = false;
		}
		if (str[i] != '\t' &&isFirstBlank == false)
		{
			isFirstBlank = true;
			pos = i;
		}
	}
	if (isFirstBlank)
	{
		v.push_back(string(str, pos, str.size() - pos));
	}
	return v;
}

//打印数据集
void DataSet::Print()
{
	if (attributesNames.size() == 0)
	{
		cout << "数据集为空" << endl;
		return;
	}

	for (vector<string>::iterator nIter = attributesNames.begin(); nIter != attributesNames.end();++nIter)
	{
		cout << *nIter<<"\t";
	}
	cout << endl;

	for (vector<Sample>::iterator sIter = dataSet.begin(); sIter != dataSet.end(); ++sIter)
	{
		for (vector<string>::iterator aIter = sIter->attributes.begin(); aIter != sIter->attributes.end(); ++aIter)
		{
			cout << *aIter << "\t";
		}
		cout << sIter->targetAttributes;
		cout << endl;
	}
}

//信息增益计算
double DataSet::Gain(const string &featureName)
{
	vector<string>::iterator findIter = find(attributesNames.begin(), attributesNames.end(), featureName);
	if (findIter == attributesNames.end()) throw "参数错误";
	
	vector<string>::size_type index;//数据集的列标签
	for (index = 0; index != attributesNames.size(); ++index)
	{
		if (attributesNames[index] == featureName){
			break;
		}
	}

	map<string, int> targetMap;//统计各个属性的样本数
	map<string,map<string, int> > featureMap;//键为
	for (vector<Sample>::iterator sIter = dataSet.begin(); sIter != dataSet.end(); ++sIter)
	{
		++targetMap[sIter->targetAttributes];
		++featureMap[sIter->attributes[index]][sIter->targetAttributes];
	}

	vector<int> targetCount;//统计目标变量
	
	for (map<string, int>::iterator tarIter = targetMap.begin(); tarIter != targetMap.end(); ++tarIter)
	{
		targetCount.push_back(tarIter->second);
	}
	double gain = Entropy(targetCount);//总的熵
	
	int sTotal = dataSet.size();//总的样本数
	for (map<string, map<string, int> >::iterator featIter = featureMap.begin(); featIter != featureMap.end(); ++featIter)
	{
		vector<int> featureCout;
		for (map<string, int>::iterator featIter2 = featIter->second.begin(); featIter2 != featIter->second.end(); ++featIter2)
		{
			featureCout.push_back(featIter2->second);
		}
		int s = accumulate(featureCout.begin(), featureCout.end(),0);//特征出现的总次数
		
		gain -= 1.0 * s / sTotal*Entropy(featureCout);

	}
	return gain;
}

//计算信息熵
double DataSet::Entropy(const vector<int> &v)
{
	double entropy=0.0;
	int totalNum = accumulate(v.begin(),v.end(),0);
	for (vector<int>::size_type i = 0; i != v.size(); ++i)
	{
		int temp = v[i];
		double p =1.0* temp/totalNum;  //注意类型转化
		entropy -= p*log2(p);
	}
	return entropy;
}

//根据属性和属性的值为featureValue的子集
DataSet DataSet::SplitDataSet(const string &featureName, const string &featureValue)
{
	vector<string>::iterator fIter = find(attributesNames.begin(), attributesNames.end(), featureName);
	if (attributesNames.size() == 0|| fIter==attributesNames.end()) throw "参数错误";

	DataSet children;              //数据集的子集
	vector<string>::size_type index;
	for (index = 0; index != attributesNames.size(); ++index)//找到属性标签的序号
	{
		if (attributesNames[index] == featureName)
		{
			break;
		}
	}

	vector<Sample>::iterator dIter;
	for (dIter = dataSet.begin(); dIter != dataSet.end(); ++dIter)
	{
		
		if (dIter->attributes[index] == featureValue)
		{
			children.dataSet.push_back(*dIter);//把满足条件的样本放入childrenSet
		}
	}
	children.attributesNames = this->attributesNames;
	
	//去除childrenSet已经使用过的属性
	vector<string>::iterator eNiter = find(children.attributesNames.begin(), children.attributesNames.end(), featureName);
	if (eNiter!=children.attributesNames.end())
	{
		children.attributesNames.erase(eNiter);
	}
	vector<Sample>::iterator chilDataIter = children.dataSet.begin();
	for (; chilDataIter != children.dataSet.end(); ++chilDataIter)
	{
		vector<string>::iterator eFiter = find(chilDataIter->attributes.begin(), chilDataIter->attributes.end(), featureValue);
		if (eFiter != chilDataIter->attributes.end())
		{
			chilDataIter->attributes.erase(eFiter);
		}
	}
	return children;
}

//选择子集
string DataSet::BestSplitFeature()
{
	double maxGain = 0.0;//最大信息增益
	string bestSplit;    //具有最大信息增益的属性
	vector<string>::iterator tIter = attributesNames.begin();
	for (; tIter != attributesNames.end(); ++tIter)
	{
		if (maxGain < Gain(*tIter))
		{
			maxGain = Gain(*tIter);
			bestSplit = *tIter;
		}
	}
	return bestSplit;
}

//判断目标属性是否唯一
bool DataSet::IsSameTarget()
{
	set<string> targetContine;
	vector<Sample>::iterator sIter = dataSet.begin();
	for (; sIter != dataSet.end(); ++sIter)
	{
		targetContine.insert(sIter->targetAttributes);
	}
	if (targetContine.size() == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//返回最长出现的属性
string DataSet::CommomTargetValue()
{
	map<string, int> targetValue;
	vector<Sample>::iterator dIter = dataSet.begin();
	for (; dIter != dataSet.end(); ++dIter)
	{
		++targetValue[dIter->targetAttributes];
	}

	map<string, int>::iterator mIter = targetValue.begin();
	string commomTarget;
	int maxValue = 0;
	for (; mIter != targetValue.end(); ++mIter)
	{
		if (maxValue < mIter->second)
		{
			maxValue = mIter->second;
			commomTarget = mIter->first;
		}
	}
	return commomTarget;
}

int DataSet::GetAttributeIndex(const string &attributeName)
{
	vector<string>::size_type index;
	for (index = 0; index != attributesNames.size(); ++index)
	{
		if (attributesNames[index] == attributeName)
		{
			return index;
		}
	}

	if (index == attributesNames.size())
	{
		throw "属性不存在";
	}
}

DesctionTree.h 

#ifndef DESCITION_H
#define DESCITION_H
#include<string>
#include<vector>
#include<map>
#include"DataSet.h"
using  std::string;
using std::vector;
class DesctionTree
{
private:
	struct Node
	{
		string value;
		map<string, Node* > children;
	};

	Node *root;

	Node* CreateNode(DataSet &trainSet);
	void ShowNode(Node *rNode,int level);
	

	string ClassOneSample(Node* rNode,vector<string> &v,vector<string> &attributeNames);
public:
	DesctionTree();
	//~DesctionTree();
	void CreateTree(DataSet &trainSet);
	vector<string> ClassTest(DataSet &examples);
	void ShowTree();
	void ClearTree(Node* rNode);
	

};


#endif

Desction.cpp 

#include<vector>
#include<string>
#include<iostream>
#include"DesctionTree.h"

using namespace std;

DesctionTree::DesctionTree()
{
	root = NULL;
}


void DesctionTree::CreateTree(DataSet &trainSet)
{
	root = new Node;
	root = CreateNode(trainSet);
}

void DesctionTree::ShowTree()
{
	if (root != NULL)
	{
		ShowNode(root,1);
	}
	
}

DesctionTree::Node* DesctionTree::CreateNode(DataSet &trainSet)
{
	if (trainSet.dataSet.size() == 0)
	{
		cout << "数据为空" << endl;
		return NULL;
	}

	Node* rootNode= new Node;
	if (trainSet.attributesNames.size() == 0)
	{
		rootNode->value = trainSet.CommomTargetValue();
		return rootNode;
	}

	if (trainSet.IsSameTarget())
	{
		vector<DataSet::Sample>::iterator sIter = trainSet.dataSet.begin();
		rootNode->value = sIter->targetAttributes;
		return rootNode;
	}

	string bestSplitAttributes = trainSet.BestSplitFeature();
	rootNode->value = bestSplitAttributes;
	vector<string>::size_type index;
	for (index = 0; index != trainSet.attributesNames.size();++index)
	{
		if (trainSet.attributesNames[index] == bestSplitAttributes)
		{
			break;
		}
	}

	set<string> valueSet;
	vector<DataSet::Sample>::iterator sIter2 = trainSet.dataSet.begin();
	for (; sIter2 != trainSet.dataSet.end(); ++sIter2)
	{
		valueSet.insert(sIter2->attributes[index]);
	}

	set<string>::iterator setIter = valueSet.begin();
	for (; setIter != valueSet.end(); ++setIter)
	{
		
		DataSet childSet = trainSet.SplitDataSet(bestSplitAttributes,*setIter);
		
		rootNode->children[*setIter] = CreateNode(childSet);
	}
	return rootNode;
}

void DesctionTree::ShowNode(Node *rNode,int level)
{
	cout << rNode->value << '\n';
	if (rNode->children.size() == 0)
	{
		return;
	}
	map<string, Node*>::iterator mIter = rNode->children.begin();

	for (; mIter != rNode->children.end(); ++mIter)
	{
		for (int j = 0; j < level; ++j)
		{
			cout << '\t';
		}
		cout << mIter->first << "->";
		ShowNode(mIter->second,level+1);
	}
}

vector<string> DesctionTree::ClassTest(DataSet &examples)
{
	vector<string> retDesction;//决策属性
	vector<DataSet::Sample>::iterator sIter=examples.dataSet.begin();

	for (; sIter != examples.dataSet.end(); ++sIter)
	{
		
		retDesction.push_back(ClassOneSample(root, sIter->attributes, examples.attributesNames));
	}
	return retDesction;
}


string DesctionTree::ClassOneSample(Node* rNode,vector<string> &v, vector<string> &attributeNames)
{
	
	vector<string>::size_type index;
	if (rNode->children.size() == 0)
	{
		
		return rNode->value;
	}

	vector<string>::iterator result = find(attributeNames.begin(), attributeNames.end(), rNode->value);
	if (result == attributeNames.end())
	{
		return " ";
	}
	index = result - attributeNames.begin();
	
	map<string, Node*>::iterator mIter = rNode->children.begin();
	for (; mIter != rNode->children.end(); ++mIter)
	{
		if (mIter->first == v[index])
		{
			vector<string> tempV(v);
			vector<string> tempAttributeNames(attributeNames);
			tempV.erase(tempV.begin()+index);
			tempAttributeNames.erase(tempAttributeNames.begin() + index);
				
			
			return ClassOneSample(mIter->second, tempV, tempAttributeNames);
			
		}
	}
	
}

/*
void DesctionTree::ClearTree(Node *rNode)
{
	if (rNode->children.empty())
	{
		delete rNode;
		rNode = NULL;
	}

	for (map<string, Node*>::iterator mIter = rNode->children.begin(); mIter != rNode->children.end(); ++mIter)
	{
		ClearTree(mIter->second);
	}
}
*/

main.cpp 

/**********************************
** id3决策树
** @author:郑午
** @time:2014-06-19
**
*********************************/

#include<iostream>
#include<vector>
#include<set>
#include<iterator>
#include"DataSet.h"
#include"DesctionTree.h"
using namespace std;

int main()
{
	//训练
	DataSet dataMat("data.txt");
	DesctionTree id3Tree;
	id3Tree.CreateTree(dataMat);
	cout << "树结构:"<<endl;
	id3Tree.ShowTree();

	//测试
	DataSet testSet("test.txt");
	vector<string> result=id3Tree.ClassTest(testSet);
	cout << "测试结果:" << endl<<endl;
	copy(result.begin(), result.end(), ostream_iterator<string>(cout, " "));
	cout << endl<<endl;
	system("pause");
}



数据文件

Day OutlookTemperate HumidityWind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No


测试数据是训练数据的一个子集。

运行结果：


rocky_zheng
关注
专栏目录
c语言实现id3算法决策树,决策树学习与ID3算法C++实现
weixin_29386469的博客
05-25 1385
决策树学习是以实例为基础的归纳学习，它从一类无序、无规则的事物(也就是概念)中推理出决策树表示的分类规则。决策树所谓决策树就是一棵表示“怎么做决定”的树。比如你现在考虑是否要去跑步，那么你也许会以这样的顺序来考虑：天气怎么样？如果下雨我就不去了；不下的话，我再考虑考虑。我状态怎么样？如果良好就出发吧，不然就算了吧。如果将上面这个考虑(做决定)过程转化为一棵决策树，它会是下面这个样子的：Decisi...
C++实现西瓜书决策树
01-31
在这个"C++实现西瓜书决策树"的项目中，我们将探讨如何用C++编程语言来实现这个算法，以及相关的理论知识。 1. **决策树的基本概念** - **ID3算法**：这是最早的决策树算法，基于信息熵和信息增益来选择最优特征...
决策树机器学习ID3C++源码实现
06-18
主要利用了网上的决策树ID3算法，添加了调用决策树的模块，输出决策树调用最终产生的结果
数据挖掘—决策树ID3分类算法的C++实现
Coding for Dreams
03-05 1236
数据挖掘课上面老师介绍了下决策树ID3算法，我抽空余时间把这个算法用C++实现了一遍。 决策树算法是非常常用的分类算法，是逼近离散目标函数的方法，学习得到的函数以决策树的形式表示。其基本思路是不断选取产生信息增益最大的属性来划分样例集和，构造决策树。信息增益定义为结点与其子结点的信息熵之差。信息熵是香农提出的，用于描述信息不纯度(不稳定性)，其计算公式是 Pi为子集合中不同性(而二元分类即...
ID3算法 决策树 C++实现
weixin_34067102的博客
06-16 392
人工智能课的实验。 数据结构：多叉树 这个实验我写了好久，开始的时候从数据的读入和表示入手，写到递归建树的部分时遇到了瓶颈，更新样例集和属性集的办法过于繁琐； 于是参考网上的代码后重新写，建立决策树类，把属性集、样例集作为数据成员加入类中，并设立访问数组，这样每次更新属性集、样例集时只是标记访问数组的对应元素即可，不必实际拷贝。 主函数： 1 #in...
AI 决策树ID3 代码(c++)
帐前卒 专栏
02-03 4743
源代码工程文件（vs2005）http://d.download.csdn.net/down/1018461/cctt_1过去在网上找了段代码，发现写的代码要改些地方，而且也想顺便练习下自己的c++编码。首先我要建立一个真正的树形结构。于是使用了自己过去的GeneralTree.h(当然这里还是改动些GeneralTree的代码例如增添了些函数，另外把有些私有函数变成了公有函数)。训练
[源码和文档分享]基于C++实现的ID3算法
qq_38474647的博客
04-09 190
1、算法描述 ID3算法是以信息熵下降速度作为选取测试属性的标准的，决策树生成算法。 信息熵的下降速度用信息增益度来衡量其定义是： 定义1：若存在n个相同概率的消息，则每个消息的概率p是1/n，一个消息传递的信息量为Log2(1/n) 定义2：若有n个消息，其给定概率分布为P=(p1,p2…pn)，则由该分布传递的信息量...
基于C++的决策树实现
11-19
在这个基于C++的决策树实现中，开发者参考了《统计学习方法》（俗称“西瓜书”）中的ID3算法。 ID3（Iterative Dichotomiser 3）是决策树算法的一个早期版本，由Ross Quinlan提出。该算法基于信息熵和信息增益来...
模糊决策树算法ID3的c++实现
05-24
9. **代码结构**：`ID3.cpp`包含了ID3算法的实现，可能包括了数据读取、决策树构建和测试等主要功能；`ID3.h`是头文件，定义了相关的类和函数；`train_data.txt`和`test_data.txt`则是输入数据。 10. **运行与测试*...
C++ ID3决策树
dayuhaitang1的博客
05-16 2066
因为自己对决策树的机制非常的好奇，所以就研究了一下决策树的ID3算法，在这也做一篇笔记记录一下过程。 文章目录一、什么是决策树？二、信息增益2.1信息熵2.1.1定义2.1.2演变2.2信息增益三、ID3算法实现四、小结 一、什么是决策树？ 这个问题是我从一开始就有的疑问，什么是决策树？在看了一些资料之后，因为没有看到书上给出具体定义，所以按照我自己的理解决策树就是通过一个个“决策”而构建的一种树状结构，而且决策树的整个处理机制非常类似于我们人类在面临决策问题时的处理机制，这也可能就是其名字的由来。 决
决策树C++实现
03-15
操作系统决策树 ComputeMapFrom2DVector(); root = BulidDecisionTreeDFS(root,remain_state,remain_attribute); cout<<"the decision tree is :"<<endl; PrintTree(root,0);
决策树算法的C++实现
05-08
本工程基于c++实现了决策树算法，输入的经验数据放在工程文件下的Tree1文件夹下
id3算法实现--c++实现
11-07
使用c++实现的决策树，数据库中有多个数据集，可以测试。表中第一列为分类类别。
决策树C4.5算法的c++实现
11-14
本程序为VS2010编写，其中源程序中包含测试数据。
C++实现决策树
GaoJieVery6
09-08 1589
依托的理论依据是信息增益，注释在代码里，代码很好懂的，文章最后有两个样例。 这是运行结果 （ ）内是特征，[ ] 内是具体的特征值，比如(身高)下面有(高)(矮)(中等)。 代码在这里~ #include &lt;iostream&gt; #include &lt;cctype&gt; #include &lt;cstring&gt; #include &lt;string&gt; ...
C++ 实现决策树 ID3 算法
iTom's blog
11-21 2870
C++ 实现 ID3 决策树
决策树的C++实现(CART)
网络资源是无限的
10-13 6524
关于决策树的介绍可以参考： https://blog.csdn.net/fengbingchun/article/details/78880934 CART算法的决策树的Python实现可以参考： https://blog.csdn.net/fengbingchun/article/details/78881143 这里参考 https://machinelearningmastery.com...
决策树分类器（ID3算法）C语言
09-29
决策树分类器（ID3算法）C语言，可直接运行
通过C++编程实现决策树算法id3
最新发布
10-11
在C++编程中实现ID3（Iterative Dichotomiser 3）决策树算法，通常需要以下几个步骤： 1. **数据预处理**： - 导入数据集，包括特征列和目标列。 - 对数值型特征进行离散化处理，例如将连续值划分为几个区间。 2...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值