Ideone.com

fork download

// ランダムフォレスト回帰（random forest regression）by 診断人
// データはhttp://c...content-available-to-author-only...e.com/mathematics/brase/understandable_statistics/7e/students/datasets/mlr/frames/frame.htmlのDenver Neighborhoodsを使用しています。
 
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
 
#define INCMSE (1)			// 重要度INCMSEを使用するか
#define INCNODEPURITY (1)	// 重要度INCNODEPURITYを使用するか
 
using namespace std;
#define SZ(a) ((int)(a).size())
 
 
// 乱数は、xorを使ってますが、メルセンヌツイスターの方がよいかも知れません。
class RandXor
{
public:
	RandXor()
	{
		init();
	}
 
	void init()
	{
		x=123456789;
		y=362436069;
		z=521288629;
		w= 88675123;
	}
 
	inline unsigned int random()
	{
		unsigned int t;
		t=(x^(x<<11));x=y;y=z;z=w; return( w=(w^(w>>19))^(t^(t>>8)) );
	}
private:
	unsigned int x;
	unsigned int y;
	unsigned int z;
	unsigned int w;
};
 
static RandXor	randxor;	// マルチスレッド対応にするなら、木ごとに乱数用オブジェクトを用意して、シードを変えましょう。
 
 
typedef double FeatureType;
typedef double AnswerType;
 
struct TreeNode {
	bool leaf;			// 葉（=子がない）ならtrue
	int level;			// ノードの深さ。ルートノードは0
	int featureID;		// 説明変数ID。x0, x1, x2... の0,1,2の部分
	FeatureType value;	// 分割する値
	AnswerType answer;	// ノード内（=領域内）の目的変数yの平均値
	vector <int> bags;	// ノード内（=領域内）に含まれるデータのID
	int left;			// 左側の子のノードID
	int right;			// 右側の子のノードID
#if INCNODEPURITY
	double nodePurity;	// ノードのPurity。平均2乗誤差が入る
#endif // INCNODEPURITY
 
 
	TreeNode() {
		leaf = false;
		level = -1;
		featureID = -1;
		value = 0;
		answer = 0;
		left = -1;
		right = -1;
#if INCNODEPURITY
		nodePurity = 0;
#endif // INCNODEPURITY
	}
};
 
class DecisionTree
{
public:
	DecisionTree() { }
 
	// 学習。訓練データをいれて、決定木を作成する。
	// features 		  説明変数（特徴量）x0,x1,x2...
	// answers			  目的変数y
	// nodeSize			  ノード内に入るデータの数。これを下回れば計算は打ち切られ葉になる。Rの実装では、回帰のときは5、分類のときは1が使われている。
	// maxLevel 		  ノードの深さの最大値
	// numRandomFeatures  領域を分けるときに試す説明変数（グラフでは軸）の数。Rの実装ではmtryという引数で、回帰のときは(説明変数の数)/3、分類のときは(説明変数の数)^0.5が使われている。
	// numRandomPositions 領域を分けるときに試すデータ（グラフでは点）の数
	// rootBagSizeRatio   全訓練データの中から、どれだけの割合をルートに入れるか（ブートストラップサンプリング）
	DecisionTree(const vector <vector <FeatureType> >& features,
		const vector <AnswerType>& answers,
		int nodeSize,
		int maxLevel,
		int numRandomFeatures,
		int numRandomPositions,
		float rootBagSizeRatio)
	{
		const int numData = SZ(features);			// データの数
		const int numFeatures = SZ(features[0]);	// 説明変数の数
		assert(numData == SZ(answers));
		assert(numData>1);
 
#if INCNODEPURITY
		m_incNodePurity.clear();
		m_incNodePurity.resize(numFeatures);
#endif // INCNODEPURITY
 
		TreeNode root;	// ルートのノード
		root.level = 0;
 
		const int rootBagSize = static_cast<int>(numData * rootBagSizeRatio); // ルートに入るデータの数
		root.bags.resize(rootBagSize);
 
#if INCMSE
		vector <int> freq(numData); // データ番号別の、ルートに選ばれた個数
#endif // INCMSE
 
		// ブートストラップサンプリング
		for (int i = 0; i < rootBagSize; i++)
		{
			// ここで、同じIDが選ばれる可能性があるが、問題なし。
			int row = randxor.random() % numData;
			root.bags[i] = row;
#if INCMSE
			freq[row]++;
#endif // INCMSE
		}
 
#if INCMSE
		// 選ばれなかった
		m_oob.clear();
		for (int i = 0; i < SZ(freq); ++i)
		{
			if(freq[i]==0)
			{
				m_oob.emplace_back(i);
			}
		}
#endif // INCMSE
 
#if INCNODEPURITY
		double sumAll = 0; // ルートのyの総和
		for (int p : root.bags)
		{
			sumAll += answers[p];
		}
 
		const double meanAll = sumAll / SZ(root.bags); // ルートのyの平均
		// ルートの平均2乗誤差
		root.nodePurity = 0;
		for (int p : root.bags)
		{
			root.nodePurity += lossFunction(answers[p], meanAll);
		}
#endif // INCNODEPURITY
 
		// 決定木をつくる。m_nodesに子ノードがどんどん追加されていく幅優先探索。
		m_nodes.emplace_back(root);
		int curNode = 0; // 現在の決定木のノード番号
		while (curNode < SZ(m_nodes))
		{
			TreeNode &node = m_nodes[curNode];
 
			// 現在のノードに入っている目的変数が、すべて同じかどうかを調べる
			// （その場合は、ノードを分ける必要がなくなる）
			bool equal = true; // すべて同じならtrue
			for (int i = 1; i<SZ(node.bags); i++)
			{
				if (answers[node.bags[i]] != answers[node.bags[i - 1]])
				{
					equal = false;
					break;
				}
			}
 
			// 葉になる条件のチェック
			if (equal || SZ(node.bags) <= nodeSize || node.level >= maxLevel)
			{
				// 葉にして子ノードは増やさない。
				setLeaf(node, curNode, answers);
				continue;
			}
 
			// どこで分けるのがベストかを調べる
			int bestFeatureID = -1;
			int bestLeft = 0, bestRight = 0;
			FeatureType bestValue = 0;
			double bestMSE = 1e99;	// 平均2乗誤差（平均との差の２乗の和）
#if INCNODEPURITY
			double bestMSELeft = 1e99;	// splitValue未満の平均2乗誤差
			double bestMSERight = 1e99;	// splitValue以上の平均2乗誤差
#endif // INCNODEPURITY
 
			for (int i = 0; i<numRandomFeatures; i++)
			{
				// x0,x1,x2...の、どの軸で分けるかを決める
				int featureID = randxor.random() % numFeatures;
 
 
				for (int j = 0; j<numRandomPositions; j++)	 // どの位置で分けるか
				{
					const int positionID = randxor.random() % SZ(node.bags);
					const FeatureType splitValue = features[node.bags[positionID]][featureID];
					double sumLeft = 0;		// splitValue未満のyの総和
					double sumRight = 0;	// splitValue以上のyの総和
					int totalLeft = 0;		// splitValue未満の個数
					int totalRight = 0;		// splitValue以上の個数
					for (int p : node.bags)
					{
						if (features[p][featureID] < splitValue)
						{
							sumLeft += answers[p];
							totalLeft++;
						}
						else
						{
							sumRight += answers[p];
							totalRight++;
						}
					}
 
					// nodeBagのデータが"未満"か"以上"のどちらかに全部偏ってるので
					// 分け方として意味がないので、すぐやめる。
					if (totalLeft == 0 || totalRight == 0)
						continue;
 
					// 平均との差を使って、平均二乗誤差(MSE)を求める
					double meanLeft = totalLeft == 0 ? 0 : sumLeft / totalLeft;
					double meanRight = totalRight == 0 ? 0 : sumRight / totalRight;
 
					double mseLeft = 0;	// 平均二乗誤差(MSE)
					double mseRight = 0;	// 平均二乗誤差(MSE)
					for (int p : node.bags)
					{
						if (features[p][featureID] < splitValue)
						{
							mseLeft += lossFunction(answers[p], meanLeft);
						}
						else
						{
							mseRight += lossFunction(answers[p], meanRight);
						}
					}
 
					if (mseLeft + mseRight < bestMSE)
					{
						bestMSE = mseLeft + mseRight;
#if INCNODEPURITY
						bestMSELeft = mseLeft;
						bestMSERight = mseRight;
#endif // INCNODEPURITY
						bestValue = splitValue;
						bestFeatureID = featureID;
						bestLeft = totalLeft;
						bestRight = totalRight;
					}
				}
			}
 
			// 左か右にどちらかに偏るような分け方しかできなかった場合は、葉にする
			// （すべての分け方を試すわけではないので、こういうことは起こりえます）
			if (bestLeft == 0 || bestRight == 0)
			{
				setLeaf(node, curNode, answers);
				continue;
			}
 
			// うまく分けれたので、新しい子ノードを２つ追加する
			TreeNode left;
			TreeNode right;
 
			left.level = right.level = node.level + 1;
			node.featureID = bestFeatureID;
			node.value = bestValue;
			node.left = SZ(m_nodes);
			node.right = SZ(m_nodes) + 1;
 
			left.bags.resize(bestLeft);
			right.bags.resize(bestRight);
			for (int p : node.bags)
			{
				if (features[p][node.featureID] < node.value)
				{
					left.bags[--bestLeft] = p;
				}
				else
				{
					right.bags[--bestRight] = p;
				}
			}
 
#if INCNODEPURITY
			left.nodePurity = bestMSELeft;
			right.nodePurity = bestMSERight;
			m_incNodePurity[bestFeatureID] += node.nodePurity - left.nodePurity - right.nodePurity;
#endif // INCNODEPURITY
			m_nodes.emplace_back(left);
			m_nodes.emplace_back(right);
			curNode++;
		}
	}
 
	// 平均との差の2乗を求める
	// y 値
	// mean 平均
	// 返り値	平均との差の2乗
	double lossFunction(double y, double mean) const
	{
		return (y - mean)*(y - mean);
	}
 
	// 予測
	// features テスト用の説明変数x0,x1,x2のセット
	// 返り値	目的変数yの予測値
	AnswerType estimate(const vector <FeatureType>& features) const
	{
		// ルートからたどるだけ
		const TreeNode *pNode = &m_nodes[0];
		while (true)
		{
			if (pNode->leaf)
			{
				break;
			}
 
			const int nextNodeID = features[pNode->featureID] < pNode->value ? pNode->left : pNode->right;
			pNode = &m_nodes[nextNodeID];
		}
 
		return pNode->answer;
	}
 
	// bagsをクリアする。ランダムフォレストで一番メモリを使うのはbagsで、
	// 訓練してしまえばいらないので、メモリ不足のときはクリアしたほうがよい。
	void clearBags()
	{
		for (auto& node : m_nodes)
		{
			node.bags.clear();
			node.bags.shrink_to_fit();
		}
	}
 
	// OOBデータ
	const vector <int>& getOOB() const
	{
		return m_oob;
	}
 
#if INCNODEPURITY
	const vector < double >& getIncNodePurity() const
	{
		return m_incNodePurity;
	}
#endif // INCNODEPURITY
 
private:
 
	// nodeを葉にして、curNodeを次のノードへ進める
	void setLeaf(TreeNode& node, int& curNode, const vector<AnswerType>& answers) const
	{
		node.leaf = true;
 
		// 回帰の場合は、目的変数yの平均を求める
		for (int p : node.bags)
		{
			node.answer += answers[p];
		}
 
		assert(SZ(node.bags) > 0);
		if (SZ(node.bags))
		{
			node.answer /= SZ(node.bags);
		}
		curNode++;
	}
 
	vector < TreeNode > m_nodes;	// 決定木のノードたち。m_nodes[0]がルート
	vector < int > m_oob; // OOBデータ（OOB Examples。訓練データから外れたもの）
#if INCNODEPURITY
	vector < double > m_incNodePurity;
#endif // INCNODEPURITY
};
 
// ランダムフォレスト回帰
class RandomForest {
public:
	RandomForest()
	{
		clear();
	}
 
	// 全部の決定木をクリア
	void clear()
	{
		m_trees.clear();
	}
 
	// 学習。訓練データをいれて、決定木を作成する。
	// 引数は、DecisionTreeにそのまま渡しているだけなので、そちらのコメントを参照してください。
	// numAdditionalTrees 追加する木の数
	void train(const vector <vector <FeatureType> >& features,
		const vector <AnswerType>& answers,
		int nodeSize,
		int maxLevel,
		int numRandomFeatures,
		int numRandomPositions,
		float rootBagSizeRatio,
		int numAdditionalTrees)
	{
		for (int i = 0; i < numAdditionalTrees; i++)
		{
			m_trees.emplace_back(DecisionTree(features, answers, nodeSize, maxLevel, numRandomFeatures, numRandomPositions, rootBagSizeRatio));
		}
	}
 
 
	// 予測
	// features テスト用の説明変数x0,x1,x2のセット
	// 返り値	目的変数yの予測値
	AnswerType estimateRegression(const vector <FeatureType> &testFeatures) const
	{
		if (SZ(m_trees) == 0)
		{
			return 0.0;
		}
 
		// すべての木から得られた結果の平均をとるだけ
		FeatureType sum = 0;
		for (int i = 0; i < SZ(m_trees); i++)
		{
			sum += m_trees[i].estimate(testFeatures);
		}
		return sum / SZ(m_trees);
	}
 
	// 決定木のbagsをクリア（メモリ節約用）
	// treeID 決定木のID
	void clearBags(int treeID)
	{
		m_trees[treeID].clearBags();
	}
 
 
#if INCMSE
 
	// OOBエラーを求める
	// trainingFeatures 	訓練データの説明変数（特徴量）x0,x1,x2...
	// trainingAnswers		訓練データの目的変数y
	// 返り値				OOBエラー
	double calculateOOBErr(const vector <vector <FeatureType> >& trainingFeatures, const vector < AnswerType >& trainingAnswers) const
	{
		const int numFeatures = SZ(trainingFeatures[0]);
		double averageOOBErr = 0.0;
 
		for (int i = 0; i < SZ(m_trees); i++)
		{
			const DecisionTree& tree = m_trees[i];
			double ooberr = 0.0;
 
			// OOBデータを使って、予測。2乗誤差の総和をooberrに入れる。
			const vector <int>& oob = tree.getOOB();
			for (int x = 0; x < SZ(oob); ++x)
			{
				const double myAnswer = tree.estimate(trainingFeatures[oob[x]]);
 
				ooberr += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
			}
 
			if(SZ(oob)>0)
			{
				ooberr /= SZ(oob);
			}
 
			averageOOBErr += ooberr;
		}
 
		averageOOBErr /= SZ(m_trees);
 
		return averageOOBErr;
	}
 
	// IncMSEを求める
	// trainingFeatures 	訓練データの説明変数（特徴量）x0,x1,x2...
	// trainingAnswers		訓練データの目的変数y
	// nPerm				特徴量1つあたりのシャッフル予測の回数
	// 返り値				特徴量ごとのIncMSE
	vector <double> calculateIncMSE(const vector <vector <FeatureType> >& trainingFeatures, const vector < AnswerType >& trainingAnswers, int nPerm) const
	{
		const int numFeatures = SZ(trainingFeatures[0]);
		vector <double> errimp(numFeatures);
 
		for (int i = 0; i < SZ(m_trees); i++)
		{
			const DecisionTree& tree = m_trees[i];
			double ooberr = 0.0;
 
			// OOBデータを使って、予測。2乗誤差の総和をooberrに入れる。
			const vector <int>& oob = tree.getOOB();
			for (int x = 0; x < SZ(oob); ++x)
			{
				const double myAnswer = tree.estimate(trainingFeatures[oob[x]]);
				ooberr += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
			}
 
			srand(i);
			for (int featureID = 0; featureID < numFeatures; ++featureID) // すべての特徴量featureIDでループ
			{
				double ooberrperm = 0.0;
 
				// OOBデータを、featureID番目の特徴量だけをシャッフル
				vector <FeatureType> swapped(SZ(oob));
				for (int x = 0; x < SZ(oob); ++x)
				{
					swapped[x] = trainingFeatures[oob[x]][featureID];
				}
 
				for (int nploop = 0; nploop < nPerm; ++nploop) // 何回シャッフルしたのを試すか。
				{
					random_shuffle(swapped.begin(), swapped.end());
 
					// すべてのOOBデータでシャッフルしたものを使う
					for (int x = 0; x < SZ(oob); ++x)
					{
						vector <FeatureType> vf(trainingFeatures[oob[x]]);
						vf[featureID] = swapped[x]; // featureID番目の要素だけ差し替え
 
						const double myAnswer = tree.estimate(vf);
						ooberrperm += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
					}
				}
 
				const double delta = (ooberrperm / nPerm - ooberr) / SZ(oob);
				errimp[featureID] += delta;
			}
		}
 
		for (int featureID = 0; featureID < numFeatures; ++featureID)
		{
			errimp[featureID] = errimp[featureID] / SZ(m_trees);   //　平均をとる
		}
 
		return errimp;
	}
#endif
 
#if INCNODEPURITY
	// IncNodePurityを求める
	// 返り値				特徴量ごとのIncMSE
	vector <double> calculateIncNodePurity() const
	{
		vector < double > retIncNodePurity;
 
		if (SZ(m_trees) > 0)
		{
			const int numFeatures = SZ(m_trees[0].getIncNodePurity());
			retIncNodePurity.resize(numFeatures);
			for (int i = 0; i < SZ(m_trees); i++)
			{
				const DecisionTree& tree = m_trees[i];
				const vector <double>& purity = tree.getIncNodePurity();
				for (int featureID = 0; featureID < numFeatures; ++featureID)
				{
					retIncNodePurity[featureID] += purity[featureID];
				}
			}
 
			for (int featureID = 0; featureID < numFeatures; ++featureID)
			{
				retIncNodePurity[featureID] /= SZ(m_trees);
			}
		}
 
		return retIncNodePurity;
	}
#endif // INCNODEPURITY
 
private:
	vector < DecisionTree > m_trees;	// たくさんの決定木
};
 
int main()
{
	int numAll; 		// 全データ数
	int numTrainings;	// 訓練データ数
	int numTests;		// テストデータ数
	int numFeatures;	// 説明変数の数
 
	// y = f(x0,x1,x2,...)
	// x0,x1,x2は説明変数です。コード上ではfeatureと命名してます。
	// yは目的変数です。コード上ではanswerという命名をしてます。
 
 
	cin >> numAll >> numTrainings >> numTests >> numFeatures;
	assert(numTrainings+numTests<=numAll);
 
	// 全データ
	vector < vector <FeatureType> > allFeatures(numAll, vector <FeatureType> (numFeatures));
	vector < AnswerType >		allAnswers(numAll);
 
	for(int i = 0 ; i < numAll; ++i)
	{
		for (int k = 0; k < numFeatures; ++k)
		{
			cin >> allFeatures[i][k];
		}
		cin >> allAnswers[i];
	}
 
	// シャッフル用
	vector < int > shuffleTable;
	for (int i = 0; i < numTrainings+numTests; ++i)
	{
		shuffleTable.emplace_back(i);
	}
	random_shuffle(shuffleTable.begin(), shuffleTable.end());
 
	// 訓練データ
	vector < vector <FeatureType> > trainingFeatures(numTrainings, vector <FeatureType>(numFeatures));
	vector < AnswerType >		trainingAnswers(numTrainings);
	for (int i = 0; i < numTrainings; ++i)
	{
		trainingFeatures[i] = allFeatures[shuffleTable[i]];
		trainingAnswers[i]	= allAnswers[shuffleTable[i]];
	}
 
	// テストデータ
	vector < vector <FeatureType> > testFeatures(numTests, vector <FeatureType>(numFeatures));
	vector < AnswerType >		testAnswers(numTests);
	for (int i = 0; i < numTests; ++i)
	{
		testFeatures[i] = allFeatures[shuffleTable[numTrainings+i]];
		testAnswers[i]	= allAnswers[shuffleTable[numTrainings+i]];
	}
 
	// ランダムフォレストを使って予測
	RandomForest* rf = new RandomForest();
 
	// 学習
	const int numTrees = 100;
	rf->train(trainingFeatures, trainingAnswers, 5, 999, 2, 5, 0.66f, numTrees);
 
	// 予測と結果表示
	printf("-----\n");
 
#if INCMSE
	{
		vector <double> vd = rf->calculateIncMSE(trainingFeatures, trainingAnswers, 5);
		for (int i = 0; i < SZ(vd); ++i)
		{
			printf("IncMSE        x%d=%8.2f\n",i,vd[i]);
		}
	}
#endif // INCMSE
 
#if INCNODEPURITY
	{
		vector <double> vd = rf->calculateIncNodePurity();
		for (int i = 0; i < SZ(vd); ++i)
		{
			printf("IncNodePurity x%d=%8.2f\n",i,vd[i]);
		}
	}
#endif // INCNODEPURITY
 
	double totalError = 0.0;
	for (int i = 0; i < numTests; ++i)
	{
		const double myAnswer = rf->estimateRegression(testFeatures[i]);
		const double diff = myAnswer-testAnswers[i];
		totalError += abs(diff);
		printf("Test%3d myAnswer=%8.2f testAnswer=%8.2f diff=%8.2f\n", i, myAnswer, testAnswers[i], diff);
	}
	printf("totalError=%8.2f\n",totalError);
 
 
	delete rf;
 
	return 0;
}

// ランダムフォレスト回帰（random forest regression）by 診断人
// データはhttp://c...content-available-to-author-only...e.com/mathematics/brase/understandable_statistics/7e/students/datasets/mlr/frames/frame.htmlのDenver Neighborhoodsを使用しています。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>

#define INCMSE (1)			// 重要度INCMSEを使用するか
#define INCNODEPURITY (1)	// 重要度INCNODEPURITYを使用するか

using namespace std;
#define SZ(a) ((int)(a).size())


// 乱数は、xorを使ってますが、メルセンヌツイスターの方がよいかも知れません。
class RandXor
{
public:
	RandXor()
	{
		init();
	}

	void init()
	{
		x=123456789;
		y=362436069;
		z=521288629;
		w= 88675123;
	}

	inline unsigned int random()
	{
		unsigned int t;
		t=(x^(x<<11));x=y;y=z;z=w; return( w=(w^(w>>19))^(t^(t>>8)) );
	}
private:
	unsigned int x;
	unsigned int y;
	unsigned int z;
	unsigned int w;
};

static RandXor	randxor;	// マルチスレッド対応にするなら、木ごとに乱数用オブジェクトを用意して、シードを変えましょう。


typedef double FeatureType;
typedef double AnswerType;

struct TreeNode {
	bool leaf;			// 葉（=子がない）ならtrue
	int level;			// ノードの深さ。ルートノードは0
	int featureID;		// 説明変数ID。x0, x1, x2... の0,1,2の部分
	FeatureType value;	// 分割する値
	AnswerType answer;	// ノード内（=領域内）の目的変数yの平均値
	vector <int> bags;	// ノード内（=領域内）に含まれるデータのID
	int left;			// 左側の子のノードID
	int right;			// 右側の子のノードID
#if INCNODEPURITY
	double nodePurity;	// ノードのPurity。平均2乗誤差が入る
#endif // INCNODEPURITY


	TreeNode() {
		leaf = false;
		level = -1;
		featureID = -1;
		value = 0;
		answer = 0;
		left = -1;
		right = -1;
#if INCNODEPURITY
		nodePurity = 0;
#endif // INCNODEPURITY
	}
};

class DecisionTree
{
public:
	DecisionTree() { }

	// 学習。訓練データをいれて、決定木を作成する。
	// features 		  説明変数（特徴量）x0,x1,x2...
	// answers			  目的変数y
	// nodeSize			  ノード内に入るデータの数。これを下回れば計算は打ち切られ葉になる。Rの実装では、回帰のときは5、分類のときは1が使われている。
	// maxLevel 		  ノードの深さの最大値
	// numRandomFeatures  領域を分けるときに試す説明変数（グラフでは軸）の数。Rの実装ではmtryという引数で、回帰のときは(説明変数の数)/3、分類のときは(説明変数の数)^0.5が使われている。
	// numRandomPositions 領域を分けるときに試すデータ（グラフでは点）の数
	// rootBagSizeRatio   全訓練データの中から、どれだけの割合をルートに入れるか（ブートストラップサンプリング）
	DecisionTree(const vector <vector <FeatureType> >& features,
		const vector <AnswerType>& answers,
		int nodeSize,
		int maxLevel,
		int numRandomFeatures,
		int numRandomPositions,
		float rootBagSizeRatio)
	{
		const int numData = SZ(features);			// データの数
		const int numFeatures = SZ(features[0]);	// 説明変数の数
		assert(numData == SZ(answers));
		assert(numData>1);

#if INCNODEPURITY
		m_incNodePurity.clear();
		m_incNodePurity.resize(numFeatures);
#endif // INCNODEPURITY

		TreeNode root;	// ルートのノード
		root.level = 0;

		const int rootBagSize = static_cast<int>(numData * rootBagSizeRatio); // ルートに入るデータの数
		root.bags.resize(rootBagSize);

#if INCMSE
		vector <int> freq(numData); // データ番号別の、ルートに選ばれた個数
#endif // INCMSE

		// ブートストラップサンプリング
		for (int i = 0; i < rootBagSize; i++)
		{
			// ここで、同じIDが選ばれる可能性があるが、問題なし。
			int row = randxor.random() % numData;
			root.bags[i] = row;
#if INCMSE
			freq[row]++;
#endif // INCMSE
		}

#if INCMSE
		// 選ばれなかった
		m_oob.clear();
		for (int i = 0; i < SZ(freq); ++i)
		{
			if(freq[i]==0)
			{
				m_oob.emplace_back(i);
			}
		}
#endif // INCMSE

#if INCNODEPURITY
		double sumAll = 0; // ルートのyの総和
		for (int p : root.bags)
		{
			sumAll += answers[p];
		}

		const double meanAll = sumAll / SZ(root.bags); // ルートのyの平均
		// ルートの平均2乗誤差
		root.nodePurity = 0;
		for (int p : root.bags)
		{
			root.nodePurity += lossFunction(answers[p], meanAll);
		}
#endif // INCNODEPURITY

		// 決定木をつくる。m_nodesに子ノードがどんどん追加されていく幅優先探索。
		m_nodes.emplace_back(root);
		int curNode = 0; // 現在の決定木のノード番号
		while (curNode < SZ(m_nodes))
		{
			TreeNode &node = m_nodes[curNode];

			// 現在のノードに入っている目的変数が、すべて同じかどうかを調べる
			// （その場合は、ノードを分ける必要がなくなる）
			bool equal = true; // すべて同じならtrue
			for (int i = 1; i<SZ(node.bags); i++)
			{
				if (answers[node.bags[i]] != answers[node.bags[i - 1]])
				{
					equal = false;
					break;
				}
			}

			// 葉になる条件のチェック
			if (equal || SZ(node.bags) <= nodeSize || node.level >= maxLevel)
			{
				// 葉にして子ノードは増やさない。
				setLeaf(node, curNode, answers);
				continue;
			}

			// どこで分けるのがベストかを調べる
			int bestFeatureID = -1;
			int bestLeft = 0, bestRight = 0;
			FeatureType bestValue = 0;
			double bestMSE = 1e99;	// 平均2乗誤差（平均との差の２乗の和）
#if INCNODEPURITY
			double bestMSELeft = 1e99;	// splitValue未満の平均2乗誤差
			double bestMSERight = 1e99;	// splitValue以上の平均2乗誤差
#endif // INCNODEPURITY

			for (int i = 0; i<numRandomFeatures; i++)
			{
				// x0,x1,x2...の、どの軸で分けるかを決める
				int featureID = randxor.random() % numFeatures;


				for (int j = 0; j<numRandomPositions; j++)	 // どの位置で分けるか
				{
					const int positionID = randxor.random() % SZ(node.bags);
					const FeatureType splitValue = features[node.bags[positionID]][featureID];
					double sumLeft = 0;		// splitValue未満のyの総和
					double sumRight = 0;	// splitValue以上のyの総和
					int totalLeft = 0;		// splitValue未満の個数
					int totalRight = 0;		// splitValue以上の個数
					for (int p : node.bags)
					{
						if (features[p][featureID] < splitValue)
						{
							sumLeft += answers[p];
							totalLeft++;
						}
						else
						{
							sumRight += answers[p];
							totalRight++;
						}
					}

					// nodeBagのデータが"未満"か"以上"のどちらかに全部偏ってるので
					// 分け方として意味がないので、すぐやめる。
					if (totalLeft == 0 || totalRight == 0)
						continue;

					// 平均との差を使って、平均二乗誤差(MSE)を求める
					double meanLeft = totalLeft == 0 ? 0 : sumLeft / totalLeft;
					double meanRight = totalRight == 0 ? 0 : sumRight / totalRight;

					double mseLeft = 0;	// 平均二乗誤差(MSE)
					double mseRight = 0;	// 平均二乗誤差(MSE)
					for (int p : node.bags)
					{
						if (features[p][featureID] < splitValue)
						{
							mseLeft += lossFunction(answers[p], meanLeft);
						}
						else
						{
							mseRight += lossFunction(answers[p], meanRight);
						}
					}

					if (mseLeft + mseRight < bestMSE)
					{
						bestMSE = mseLeft + mseRight;
#if INCNODEPURITY
						bestMSELeft = mseLeft;
						bestMSERight = mseRight;
#endif // INCNODEPURITY
						bestValue = splitValue;
						bestFeatureID = featureID;
						bestLeft = totalLeft;
						bestRight = totalRight;
					}
				}
			}

			// 左か右にどちらかに偏るような分け方しかできなかった場合は、葉にする
			// （すべての分け方を試すわけではないので、こういうことは起こりえます）
			if (bestLeft == 0 || bestRight == 0)
			{
				setLeaf(node, curNode, answers);
				continue;
			}

			// うまく分けれたので、新しい子ノードを２つ追加する
			TreeNode left;
			TreeNode right;

			left.level = right.level = node.level + 1;
			node.featureID = bestFeatureID;
			node.value = bestValue;
			node.left = SZ(m_nodes);
			node.right = SZ(m_nodes) + 1;

			left.bags.resize(bestLeft);
			right.bags.resize(bestRight);
			for (int p : node.bags)
			{
				if (features[p][node.featureID] < node.value)
				{
					left.bags[--bestLeft] = p;
				}
				else
				{
					right.bags[--bestRight] = p;
				}
			}

#if INCNODEPURITY
			left.nodePurity = bestMSELeft;
			right.nodePurity = bestMSERight;
			m_incNodePurity[bestFeatureID] += node.nodePurity - left.nodePurity - right.nodePurity;
#endif // INCNODEPURITY
			m_nodes.emplace_back(left);
			m_nodes.emplace_back(right);
			curNode++;
		}
	}

	// 平均との差の2乗を求める
	// y 値
	// mean 平均
	// 返り値	平均との差の2乗
	double lossFunction(double y, double mean) const
	{
		return (y - mean)*(y - mean);
	}

	// 予測
	// features テスト用の説明変数x0,x1,x2のセット
	// 返り値	目的変数yの予測値
	AnswerType estimate(const vector <FeatureType>& features) const
	{
		// ルートからたどるだけ
		const TreeNode *pNode = &m_nodes[0];
		while (true)
		{
			if (pNode->leaf)
			{
				break;
			}

			const int nextNodeID = features[pNode->featureID] < pNode->value ? pNode->left : pNode->right;
			pNode = &m_nodes[nextNodeID];
		}

		return pNode->answer;
	}

	// bagsをクリアする。ランダムフォレストで一番メモリを使うのはbagsで、
	// 訓練してしまえばいらないので、メモリ不足のときはクリアしたほうがよい。
	void clearBags()
	{
		for (auto& node : m_nodes)
		{
			node.bags.clear();
			node.bags.shrink_to_fit();
		}
	}

	// OOBデータ
	const vector <int>& getOOB() const
	{
		return m_oob;
	}

#if INCNODEPURITY
	const vector < double >& getIncNodePurity() const
	{
		return m_incNodePurity;
	}
#endif // INCNODEPURITY

private:

	// nodeを葉にして、curNodeを次のノードへ進める
	void setLeaf(TreeNode& node, int& curNode, const vector<AnswerType>& answers) const
	{
		node.leaf = true;

		// 回帰の場合は、目的変数yの平均を求める
		for (int p : node.bags)
		{
			node.answer += answers[p];
		}

		assert(SZ(node.bags) > 0);
		if (SZ(node.bags))
		{
			node.answer /= SZ(node.bags);
		}
		curNode++;
	}

	vector < TreeNode > m_nodes;	// 決定木のノードたち。m_nodes[0]がルート
	vector < int > m_oob; // OOBデータ（OOB Examples。訓練データから外れたもの）
#if INCNODEPURITY
	vector < double > m_incNodePurity;
#endif // INCNODEPURITY
};

// ランダムフォレスト回帰
class RandomForest {
public:
	RandomForest()
	{
		clear();
	}

	// 全部の決定木をクリア
	void clear()
	{
		m_trees.clear();
	}

	// 学習。訓練データをいれて、決定木を作成する。
	// 引数は、DecisionTreeにそのまま渡しているだけなので、そちらのコメントを参照してください。
	// numAdditionalTrees 追加する木の数
	void train(const vector <vector <FeatureType> >& features,
		const vector <AnswerType>& answers,
		int nodeSize,
		int maxLevel,
		int numRandomFeatures,
		int numRandomPositions,
		float rootBagSizeRatio,
		int numAdditionalTrees)
	{
		for (int i = 0; i < numAdditionalTrees; i++)
		{
			m_trees.emplace_back(DecisionTree(features, answers, nodeSize, maxLevel, numRandomFeatures, numRandomPositions, rootBagSizeRatio));
		}
	}


	// 予測
	// features テスト用の説明変数x0,x1,x2のセット
	// 返り値	目的変数yの予測値
	AnswerType estimateRegression(const vector <FeatureType> &testFeatures) const
	{
		if (SZ(m_trees) == 0)
		{
			return 0.0;
		}

		// すべての木から得られた結果の平均をとるだけ
		FeatureType sum = 0;
		for (int i = 0; i < SZ(m_trees); i++)
		{
			sum += m_trees[i].estimate(testFeatures);
		}
		return sum / SZ(m_trees);
	}

	// 決定木のbagsをクリア（メモリ節約用）
	// treeID 決定木のID
	void clearBags(int treeID)
	{
		m_trees[treeID].clearBags();
	}


#if INCMSE

	// OOBエラーを求める
	// trainingFeatures 	訓練データの説明変数（特徴量）x0,x1,x2...
	// trainingAnswers		訓練データの目的変数y
	// 返り値				OOBエラー
	double calculateOOBErr(const vector <vector <FeatureType> >& trainingFeatures, const vector < AnswerType >& trainingAnswers) const
	{
		const int numFeatures = SZ(trainingFeatures[0]);
		double averageOOBErr = 0.0;

		for (int i = 0; i < SZ(m_trees); i++)
		{
			const DecisionTree& tree = m_trees[i];
			double ooberr = 0.0;

			// OOBデータを使って、予測。2乗誤差の総和をooberrに入れる。
			const vector <int>& oob = tree.getOOB();
			for (int x = 0; x < SZ(oob); ++x)
			{
				const double myAnswer = tree.estimate(trainingFeatures[oob[x]]);

				ooberr += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
			}

			if(SZ(oob)>0)
			{
				ooberr /= SZ(oob);
			}

			averageOOBErr += ooberr;
		}

		averageOOBErr /= SZ(m_trees);

		return averageOOBErr;
	}

	// IncMSEを求める
	// trainingFeatures 	訓練データの説明変数（特徴量）x0,x1,x2...
	// trainingAnswers		訓練データの目的変数y
	// nPerm				特徴量1つあたりのシャッフル予測の回数
	// 返り値				特徴量ごとのIncMSE
	vector <double> calculateIncMSE(const vector <vector <FeatureType> >& trainingFeatures, const vector < AnswerType >& trainingAnswers, int nPerm) const
	{
		const int numFeatures = SZ(trainingFeatures[0]);
		vector <double> errimp(numFeatures);

		for (int i = 0; i < SZ(m_trees); i++)
		{
			const DecisionTree& tree = m_trees[i];
			double ooberr = 0.0;

			// OOBデータを使って、予測。2乗誤差の総和をooberrに入れる。
			const vector <int>& oob = tree.getOOB();
			for (int x = 0; x < SZ(oob); ++x)
			{
				const double myAnswer = tree.estimate(trainingFeatures[oob[x]]);
				ooberr += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
			}

			srand(i);
			for (int featureID = 0; featureID < numFeatures; ++featureID) // すべての特徴量featureIDでループ
			{
				double ooberrperm = 0.0;

				// OOBデータを、featureID番目の特徴量だけをシャッフル
				vector <FeatureType> swapped(SZ(oob));
				for (int x = 0; x < SZ(oob); ++x)
				{
					swapped[x] = trainingFeatures[oob[x]][featureID];
				}

				for (int nploop = 0; nploop < nPerm; ++nploop) // 何回シャッフルしたのを試すか。
				{
					random_shuffle(swapped.begin(), swapped.end());

					// すべてのOOBデータでシャッフルしたものを使う
					for (int x = 0; x < SZ(oob); ++x)
					{
						vector <FeatureType> vf(trainingFeatures[oob[x]]);
						vf[featureID] = swapped[x]; // featureID番目の要素だけ差し替え

						const double myAnswer = tree.estimate(vf);
						ooberrperm += (trainingAnswers[oob[x]] - myAnswer)*(trainingAnswers[oob[x]] - myAnswer);
					}
				}

				const double delta = (ooberrperm / nPerm - ooberr) / SZ(oob);
				errimp[featureID] += delta;
			}
		}

		for (int featureID = 0; featureID < numFeatures; ++featureID)
		{
			errimp[featureID] = errimp[featureID] / SZ(m_trees);   //　平均をとる
		}

		return errimp;
	}
#endif

#if INCNODEPURITY
	// IncNodePurityを求める
	// 返り値				特徴量ごとのIncMSE
	vector <double> calculateIncNodePurity() const
	{
		vector < double > retIncNodePurity;

		if (SZ(m_trees) > 0)
		{
			const int numFeatures = SZ(m_trees[0].getIncNodePurity());
			retIncNodePurity.resize(numFeatures);
			for (int i = 0; i < SZ(m_trees); i++)
			{
				const DecisionTree& tree = m_trees[i];
				const vector <double>& purity = tree.getIncNodePurity();
				for (int featureID = 0; featureID < numFeatures; ++featureID)
				{
					retIncNodePurity[featureID] += purity[featureID];
				}
			}

			for (int featureID = 0; featureID < numFeatures; ++featureID)
			{
				retIncNodePurity[featureID] /= SZ(m_trees);
			}
		}

		return retIncNodePurity;
	}
#endif // INCNODEPURITY

private:
	vector < DecisionTree > m_trees;	// たくさんの決定木
};

int main()
{
	int numAll; 		// 全データ数
	int numTrainings;	// 訓練データ数
	int numTests;		// テストデータ数
	int numFeatures;	// 説明変数の数

	// y = f(x0,x1,x2,...)
	// x0,x1,x2は説明変数です。コード上ではfeatureと命名してます。
	// yは目的変数です。コード上ではanswerという命名をしてます。


	cin >> numAll >> numTrainings >> numTests >> numFeatures;
	assert(numTrainings+numTests<=numAll);

	// 全データ
	vector < vector <FeatureType> > allFeatures(numAll, vector <FeatureType> (numFeatures));
	vector < AnswerType >		allAnswers(numAll);

	for(int i = 0 ; i < numAll; ++i)
	{
		for (int k = 0; k < numFeatures; ++k)
		{
			cin >> allFeatures[i][k];
		}
		cin >> allAnswers[i];
	}

	// シャッフル用
	vector < int > shuffleTable;
	for (int i = 0; i < numTrainings+numTests; ++i)
	{
		shuffleTable.emplace_back(i);
	}
	random_shuffle(shuffleTable.begin(), shuffleTable.end());

	// 訓練データ
	vector < vector <FeatureType> > trainingFeatures(numTrainings, vector <FeatureType>(numFeatures));
	vector < AnswerType >		trainingAnswers(numTrainings);
	for (int i = 0; i < numTrainings; ++i)
	{
		trainingFeatures[i] = allFeatures[shuffleTable[i]];
		trainingAnswers[i]	= allAnswers[shuffleTable[i]];
	}

	// テストデータ
	vector < vector <FeatureType> > testFeatures(numTests, vector <FeatureType>(numFeatures));
	vector < AnswerType >		testAnswers(numTests);
	for (int i = 0; i < numTests; ++i)
	{
		testFeatures[i] = allFeatures[shuffleTable[numTrainings+i]];
		testAnswers[i]	= allAnswers[shuffleTable[numTrainings+i]];
	}

	// ランダムフォレストを使って予測
	RandomForest* rf = new RandomForest();

	// 学習
	const int numTrees = 100;
	rf->train(trainingFeatures, trainingAnswers, 5, 999, 2, 5, 0.66f, numTrees);

	// 予測と結果表示
	printf("-----\n");

#if INCMSE
	{
		vector <double> vd = rf->calculateIncMSE(trainingFeatures, trainingAnswers, 5);
		for (int i = 0; i < SZ(vd); ++i)
		{
			printf("IncMSE        x%d=%8.2f\n",i,vd[i]);
		}
	}
#endif // INCMSE

#if INCNODEPURITY
	{
		vector <double> vd = rf->calculateIncNodePurity();
		for (int i = 0; i < SZ(vd); ++i)
		{
			printf("IncNodePurity x%d=%8.2f\n",i,vd[i]);
		}
	}
#endif // INCNODEPURITY

	double totalError = 0.0;
	for (int i = 0; i < numTests; ++i)
	{
		const double myAnswer = rf->estimateRegression(testFeatures[i]);
		const double diff = myAnswer-testAnswers[i];
		totalError += abs(diff);
		printf("Test%3d myAnswer=%8.2f testAnswer=%8.2f diff=%8.2f\n", i, myAnswer, testAnswers[i], diff);
	}
	printf("totalError=%8.2f\n",totalError);
	

	delete rf;

	return 0;
}



Success #stdin #stdout 0.01s 3296KB

stdin

44 30 14 6
6.9	1.8	30.2	58.3	27.3	84.9	-14.2
8.4	28.5	38.8	87.5	39.8	172.6	-34.1
5.7	7.8	31.7	83.5	26	154.2	-15.8
7.4	2.3	24.2	14.2	29.4	35.2	-13.9
8.5	-0.7	28.1	46.7	26.6	69.2	-13.9
13.8	7.2	10.4	57.9	26.2	111	-22.6
1.7	32.2	7.5	73.8	50.5	704.1	-40.9
3.6	7.4	30	61.3	26.4	69.9	4
8.2	10.2	12.1	41	11.7	65.4	-32.5
5	10.5	13.6	17.4	14.7	132.1	-8.1
2.1	0.3	18.3	34.4	24.2	179.9	12.3
4.2	8.1	21.3	64.9	21.7	139.9	-35
3.9	2	33.1	82	26.3	108.7	-2
4.1	10.8	38.3	83.3	32.6	123.2	-2.2
4.2	1.9	36.9	61.8	21.6	104.7	-14.2
9.4	-1.5	22.4	22.2	33.5	61.5	-32.7
3.6	-0.3	19.6	8.6	27	68.2	-13.4
7.6	5.5	29.1	62.8	32.2	96.9	-8.7
8.5	4.8	32.8	86.2	16	258	0.5
7.5	2.3	26.5	18.7	23.7	32	-0.6
4.1	17.3	41.5	78.6	23.5	127	-12.5
4.6	68.6	39	14.6	38.2	27.1	45.4
7.2	3	20.2	41.4	27.6	70.7	-38.2
13.4	7.1	20.4	13.9	22.5	38.3	-33.6
10.3	1.4	29.8	43.7	29.4	54	-10
9.4	4.6	36	78.2	29.9	101.5	-14.6
2.5	-3.3	37.6	88.5	27.5	185.9	-7.6
10.3	-0.5	31.8	57.2	27.2	61.2	-17.6
7.5	22.3	28.6	5.7	31.3	38.6	27.2
18.7	6.2	39.7	55.8	28.7	52.6	-2.9
5.1	-2	23.8	29	29.3	62.6	-10.3
3.7	19.6	12.3	77.3	32	207.7	-45.6
10.3	3	31.1	51.7	26.2	42.4	-31.9
7.3	19.2	32.9	68.1	25.2	105.2	-35.7
4.2	7	22.1	41.2	21.4	68.6	-8.8
2.1	5.4	27.1	60	23.5	157.3	6.2
2.5	2.8	20.3	29.8	24.1	58.5	-27.5
8.1	8.5	30	66.4	26	63.1	-37.4
10.3	-1.9	15.9	39.9	38.5	86.4	-13.5
10.5	2.8	36.4	72.3	26	77.5	-21.6
5.8	2	24.2	19.5	28.3	63.5	2.2
6.9	2.9	20.7	6.6	25.8	68.9	-2.4
9.3	4.9	34.9	82.4	18.4	102.8	-12
11.4	2.6	38.7	78.2	18.4	86.6	-12.8

stdout

-----
IncMSE        x0=   -6.46
IncMSE        x1=    5.80
IncMSE        x2=  -12.16
IncMSE        x3=   66.87
IncMSE        x4=  -15.22
IncMSE        x5=    0.69
IncNodePurity x0=  599.36
IncNodePurity x1=  958.41
IncNodePurity x2=  890.15
IncNodePurity x3= 1276.43
IncNodePurity x4=  805.89
IncNodePurity x5= 1258.49
Test  0 myAnswer=  -11.36 testAnswer=  -10.30 diff=   -1.06
Test  1 myAnswer=  -15.27 testAnswer=  -13.50 diff=   -1.77
Test  2 myAnswer=  -14.47 testAnswer=   -2.20 diff=  -12.27
Test  3 myAnswer=  -15.27 testAnswer=  -37.40 diff=   22.13
Test  4 myAnswer=    0.57 testAnswer=  -13.90 diff=   14.47
Test  5 myAnswer=   -5.69 testAnswer=  -13.40 diff=    7.71
Test  6 myAnswer=   -6.41 testAnswer=   -2.90 diff=   -3.51
Test  7 myAnswer=  -14.62 testAnswer=  -12.80 diff=   -1.82
Test  8 myAnswer=   -8.04 testAnswer=   -8.10 diff=    0.06
Test  9 myAnswer=  -11.27 testAnswer=  -38.20 diff=   26.93
Test 10 myAnswer=  -14.22 testAnswer=  -32.50 diff=   18.28
Test 11 myAnswer=   -4.54 testAnswer=  -33.60 diff=   29.06
Test 12 myAnswer=   -9.10 testAnswer=  -12.50 diff=    3.40
Test 13 myAnswer=  -11.43 testAnswer=   -8.80 diff=   -2.63
totalError=  145.10

https://ideone.com/RYF0Bn

language:

C++14 (gcc 8.3)

created:

visibility:

public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!

Discover > Sphere Engine API

Discover > IDE Widget

Choose your language