昆明理工大学天气决策树

昆明理工大学信息工程与自动化学院学生实验报告

（—学年第1学期）

一、上机目的及内容

1.上机内容

根据下列给定的14个数据,运用Information Gain构造一个天气决策树。

12多云中大有P

13多云热正常无P

14雨中大有N

2.上机目的

（1）学习用Information Gain构造决策树的方法；

（2）在给定的例子上，构造出正确的决策树；

（3）理解并掌握构造决策树的技术要点。

二、实验原理及基本技术路线图（方框原理图或程序流程图）

（1）设计并实现程序，构造出正确的决策树；

（2）对所设计的算法采用大O符号进行时间复杂性和空间复杂性分析；

实验考虑到几个属性：天况——晴、雨、多云；温度——热、中、冷；湿度——大、正常；风况——有、无；然后根据每个属性来算出信息增益，接下来我们根据信息增益最大的来进行划分。根据问题设计算法，建立数据结构，设计需要用的类，然后通过编程实现问题求解。了解和求解最大信息增益和最小熵选择平均熵最小的属性作为根节点，用同样的方法选择其他节点直至形成整个决策树。dataset 就是具体的划分过程，首先找到可用的划分项目，再第一次划分之后再相关的数据来计算熵。

Main函数流程图Dataset函数主要流程图Basefun函数流程图

Attributevalue函数流程图

Datapiont函数流程图

三、所用仪器、材料（设备名称、型号、规格等或使用软件）

1台PC及VISUAL C++6.0软件

四、实验方法、步骤（或：程序代码或操作过程）

源代码：

main函数：

#include

#include

#include

#include

#include

#include

#include "AttributeValue.h"

#include "DataPoint.h"

#include "DataSet.h"

DataPoint processLine(std::string const& sLine)

{

std::istringstream isLine(sLine, std::istringstream::in);

std::vector attributes;

// TODO: need to handle beginning and ending empty spaces.

while( isLine.good() )

{

std::string rawfield;

isLine >> rawfield;

attributes.push_back( AttributeValue( rawfield ) );

}

AttributeValue v = attributes.back();

attributes.pop_back();

bool type = v.GetType();

return DataPoint(attributes, type);

}

void main()

{

std::ifstream ifs("tree.txt", std::ifstream::in);

DataSet initDataset;

while( ifs.good() )

{

// TODO: need to handle empty lines.

std::string sLine;

std::getline(ifs, sLine);

initDataset.addDataPoint( processLine(sLine) );

}

std::list processQ;

std::vector finishedDataSet;

processQ.push_back(initDataset);

while ( processQ.size() > 0 )

{

std::vector splittedDataSets;

DataSet dataset = processQ.front();

dataset.splitDataSet(splittedDataSets);

processQ.pop_front();

for (int i=0; i

{

float prob = splittedDataSets[i].getPositiveProb();

if (prob == 0.0 || prob == 1.0)

{

finishedDataSet.push_back(splittedDataSets[i]);

}

else

{

processQ.push_back(splittedDataSets[i]);

}

}

}

std::cout << "The dicision tree is:" << std::endl;

for (int i = 0; i < finishedDataSet.size(); ++i)

{

finishedDataSet[i].display();

}

}

DataSet函数：

#include

#include

#include "base.h"

#include "DataSet.h"

void SplitAttributeValue::display()

{

std::cout << "\tSplit attribute ID(" << m_attributeIndex << ")\t";

std::cout << "Split attribute value(" << m_v.getValue() << ")" << std::endl; }

void DataSet::addDataPoint(DataPoint const& datapoint)

{

m_data.push_back(datapoint);

}

float DataSet::getPositiveProb()

{

float nPositive = 0;

for(int i=0; i

{

if ( m_data[i].isPositive() )

{

nPositive++;

}

}

return nPositive / m_data.size();

}

struct Stat

{

int nPos;

int nNeg;

int id;

};

void DataSet::splitDataSet(std::vector& splittedSets)

{

// find all available splitting attributes

int nAttributes = m_data[0].getNAttributes();

int i, j;

std::vector splittingAttributeBV;

splittingAttributeBV.resize(nAttributes);

for (i=0; i

{

splittingAttributeBV[i] = true;

}

for (i=0; i

{

splittingAttributeBV[ m_splitAttributes[i].getAttributeIndex() ] = false;

}

std::vector splittingAttributeIds;

for (i=0; i

{

if (true == splittingAttributeBV[i])

{

splittingAttributeIds.push_back(i);

}

}

typedef std::map AttributeValueStat;

typedef std::map::iterator AttributeValueStat_iterator;

typedef std::map::const_iterator AttributeValueStat_const_iterator;

// go through data once, and collect needed statistics to calculate entropy

std::vector< AttributeValueStat > splittingStats;

splittingStats.resize( splittingAttributeIds.size() );

for (i=0; i

{

for (j=0; j

{

AttributeValue const& v = m_data[i].getAttribute(splittingAttributeIds[j]);

AttributeValueStat_iterator it = splittingStats[j].find(v);

if ( splittingStats[j].end() == it )

{

Stat stat;

if ( m_data[i].isPositive() )

{

stat.nPos = 1;

stat.nNeg = 0;

stat.id = 0;

}

else

{

stat.nPos = 0;

stat.nNeg = 1;

stat.id = 0;

}

splittingStats[j].insert(std::pair(v, stat));

}

else

{

if ( m_data[i].isPositive() )

{

it->second.nPos++;

}

else

{

it->second.nNeg++;

}

}

}

}

// display collected statistics

for (j=0; j

{

std::cout << "Attribute(" << splittingAttributeIds[j] << "):" << std::endl;

std::cout << "\tValue \t nPos \t nNeg" << std::endl;

for (AttributeValueStat_const_iterator it = splittingStats[j].begin();

it != splittingStats[j].end(); ++it)

{

std::cout << "\t" << it->first.getValue() << " \t " << it->second.nPos << " \t " << it->second.nNeg << std::endl;

}

}

// find splitting attribute

float minEntropy = 0.0;

int splitAttributeId = -1;

for (j=0; j

{

int n = m_data.size();

float entropy = 0.0;

for (AttributeValueStat_iterator it = splittingStats[j].begin();

it != splittingStats[j].end(); ++it)

{

int nSamples = it->second.nPos + it->second.nNeg;

float p = it->second.nPos;

p /= nSamples;

entropy += calEntropy(p) * nSamples / n;

}

if (entropy < minEntropy || -1 == splitAttributeId)

{

minEntropy = entropy;

splitAttributeId = j;

}

}

std::cout << "Split at attribute(" << splittingAttributeIds[splitAttributeId] << ")" << std::endl << std::endl;

// split

int attrId = splittingAttributeIds[splitAttributeId];

AttributeValueStat const& attVStat = splittingStats[splitAttributeId];

splittedSets.clear();

int k = 0;

for (AttributeValueStat_iterator it = splittingStats[splitAttributeId].begin();

it != splittingStats[splitAttributeId].end(); ++it)

{

it->second.id = k++;

}

splittedSets.resize( k);

for (i=0; i

{

for (j=0; j

{

splittedSets[i].m_splitAttributes.push_back( m_splitAttributes[j] );

}

}

for (AttributeValueStat_iterator itt = splittingStats[splitAttributeId].begin();

itt != splittingStats[splitAttributeId].end(); ++itt)

{

splittedSets[itt->second.id].m_splitAttributes.push_back(SplitAttributeValue(itt->first, attrId));

}

for (i=0; i

{

AttributeValue const& v = m_data[i].getAttribute(attrId);

AttributeValueStat_const_iterator it = attVStat.find(v);

if ( attVStat.end() != it )

{

splittedSets[it->second.id].addDataPoint(m_data[i]);

}

else

{

throw DataErrException();

}

}

}

void DataSet::display()

{

int i;

std::cout << "Dataset(" << this << ")" << std::endl;

for (i=0; i

{

m_splitAttributes[i].display();

}

std::cout << "Data:" << std::endl;

for (i=0; i

{

m_data[i].display();

}

std::cout << std::endl;

}

DataPoint函数：

#include

float log2 (float x)

{

return 1.0 / log10(2) * log10(x);

}

float calEntropy(float prob)

{

float sum=0;

if (prob == 0 || prob == 1)

{

return 0;

}

sum -= prob * log2(prob);

sum -= (1 - prob) * log2 ( 1 - prob );

return sum;

}

Basefun函数：

#include

float log2 (float x)

{

return 1.0 / log10(2) * log10(x);

}

float calEntropy(float prob)

{

float sum=0;

if (prob == 0 || prob == 1)

{

return 0;

}

sum -= prob * log2(prob);

sum -= (1 - prob) * log2 ( 1 - prob );

return sum;

}

AttributeValue函数：

#include "AttributeValue.h"

#include "base.h"

AttributeValue::AttributeValue(std::string const& instring) : m_value(instring)

{

}

bool AttributeValue::GetType()

{

if (m_value == "P")

{

return true;

}

else if (m_value == "N")

{

return false;

}

else

{

throw DataErrException();

}

}

AttributeValue头文件：

#ifndef ATTRIBUTE_VALUE_H_

#define ATTRIBUTE_VALUE_H_

#include

class AttributeValue

{

public:

AttributeValue(std::string const& instring);

bool GetType();

std::string const& getValue() const

{

return m_value;

}

private:

std::string m_value;

};

struct AttributeValueCmp

{

bool operator() (AttributeValue const& lhs, AttributeValue const& rhs) const {

return lhs.getValue() < rhs.getValue();

}

};

#endif

Base头文件：

class DataErrException : public std::exception

{

};

float calEntropy(float prob);

DataPoint头文件：

#ifndef DATA_POINT_H_

#define DATA_POINT_H_

#include

#include "AttributeValue.h"

class DataPoint

{

public:

DataPoint(std::vector const& attributes, bool type);

bool isPositive()

{

return m_type;

}

int getNAttributes()

{

return m_attributes.size();

}

AttributeValue const& getAttribute(int index)

{

return m_attributes[index];

}

void display();

private:

std::vector m_attributes;

bool m_type;

};

#endif

DataSet头文件：

#include

#include

#include "DataPoint.h"

class SplitAttributeValue

{

public:

SplitAttributeValue(AttributeValue v, int id)

: m_v(v)

, m_attributeIndex(id)

{

}

int getAttributeIndex()

{

return m_attributeIndex;

}

void display();

private:

int m_attributeIndex;

AttributeValue m_v;

};

class DataSet

{

public:

void addDataPoint(DataPoint const& datapoint);

float getPositiveProb();

void splitDataSet(std::vector& splittedSets);

void display();

private:

std::vector m_splitAttributes;

std::vector m_data;

};

五、实验过程原始记录( 测试数据、图表、计算等)

六、实验结果、分析和结论（误差分析与数据处理、成果总结等。其中，绘制曲线图时必须用计算纸或程序运行结果、改进、收获）

Attributevalue的作用是判断正反例，以便下面的的划分决策过程，basefun的作用则是计算熵，通过熵的比。dataset就是具体的划分过程，首先找到可用的划分项目，再第一次划分之后再手机相关的数据来计算熵。

通过该实验，我了解了如何采用Information Gain构建天气决策树，以及了解什么是熵，如何计算熵等等。同时也意识到自己基础知识的欠缺，今后的学习中会更加注重基础知识的掌握和巩固，争取熟练运用所学的知识。

注：教师必须按照上述各项内容严格要求，认真批改和评定学生成绩。