C++ TimerPtr::elapsed方法代码示例

	void Bagger::buildTree(){
		int treeId;
		
		// Choose tree id
		m_chooseTree->lock();
		treeId = m_treeId++;
		m_chooseTree->unlock();

		// sorting is performed inside this constructor
		DataCachePtr myData = DataCachePtr(new DataCache(m_data,m_evaluation,m_seed));

		// create the in-bag dataset (and be sure to remember what's in bag)
		// for computing the out-of-bag error later
		DataCachePtr bagData = myData->resample(m_bagSize);
		/*bagData.reusableRandomGenerator = bagData.getRandomNumberGenerator(
				random.nextInt());*/
		m_inBag[treeId] = bagData->inBag;

		// build the classifier
		RandomTreePtr aTree = m_trees[treeId];
		aTree->data = bagData;
		TimerPtr timer = TimerPtr(new boost::timer);
		aTree->build();
		double time = timer->elapsed();

		m_chooseTree->lock();
		m_buildTime += time;
		m_totalNumNodes += aTree->getNumNodes();
		m_chooseTree->unlock();
	}

	void GPUERT::deviceHandler(){
		m_devId = m_gfxMgr->createDeviceContext(m_devId);
		calculateMaxNodes(m_devId);
		initResources();

		m_constantsBagging.cb_baggingActivated = false;
		TimerPtr timerKernel = TimerPtr(new boost::timer);

		TimerPtr timer = TimerPtr(new boost::timer);
		TimerPtr timerTotal = TimerPtr(new boost::timer);

		m_internalNodes = 0, m_leafNodes = 0;
		int treesLeft = m_numTrees;
		int treesToLaunch = m_maxTreesPerIteration;
		int lastLaunch = 0;
		int checkSum = m_maxTreesPerIteration;
		int newNodes = m_maxTreesPerIteration;
		std::vector<int> checkVars(4,0);

		m_buildTime = 0;
		m_baggingTime = 0;
		m_classificationTime = 0;
		m_depth = 0;

		timerTotal->restart();
		int numIter = ceil(float(m_numTrees)/float(m_maxTreesPerIteration));
		for(unsigned int j=0; j<numIter; ++j){
			checkSum = treesToLaunch;
			newNodes = treesToLaunch;
			m_constants.cb_nodeBufferStart = 0;
			m_constants.cb_nodeIdFlip = 0;

			initResourceBatch(lastLaunch == treesToLaunch);
			lastLaunch = treesToLaunch;

			treesLeft -= treesToLaunch;
			timer->restart();
			for(unsigned int i=0; i<m_MaxDepth; ++i){
				if(i > m_depth)
					m_depth = i;

				assert(newNodes < m_maxNodesPerIteration);
				int nodeLimit = 10000;
				int innerNodes = newNodes;
				int numInnerIter = ceil(float(innerNodes)/float(nodeLimit));
				int launchCount = 0;

				m_constants.cb_availableNodes = newNodes;
				m_constants.cb_numFeatures = 0;
				timerKernel->restart();
				for(unsigned int k=0; k<m_numFeatures; ++k){
					innerNodes = newNodes;
					numInnerIter = ceil(float(innerNodes)/float(nodeLimit));
					launchCount = 0;

					// Best split kernel
					m_gfxMgr->setGPUBuffer(m_devId,m_setBufferIdsExFindSplit,m_setResourceTypesExFindSplit);
					m_gfxMgr->setGPUProgram(m_devId,m_gpuFunctionIds["RFP_ExFindSplit"]);

					innerNodes = newNodes;
					launchCount = 0;
					m_constants.cb_currentDepth = 0;
					for(unsigned int l=0; l<numInnerIter; ++l){
						launchCount = innerNodes > nodeLimit ? nodeLimit : innerNodes;
						
						m_gfxMgr->copyToGPU(m_devId,m_bufferIds["RFB_constants"],&ConstantUpdate(&m_constants,KID_ExtremeFindSplit),sizeof(m_constants));
						m_gfxMgr->launchComputation(m_devId,launchCount*thread_group_size,1,1);

						m_constants.cb_currentDepth += launchCount;
						innerNodes -= launchCount;
						if(innerNodes <= 0)
							break;
					}
					++m_constants.cb_numFeatures;
				}
				if(m_kernelSpecificTimings){
					m_gfxMgr->syncDevice(m_devId);
					m_kernelTimes[L"RFP_ExFindSplit"] += timerKernel->elapsed();
				}

				innerNodes = newNodes;
				launchCount = 0;
				m_constants.cb_currentDepth = 0;
				m_gfxMgr->setGPUBuffer(m_devId,m_setBufferIdsExMakeSplit,m_setResourceTypesExMakeSplit);
				m_gfxMgr->setGPUProgram(m_devId,m_gpuFunctionIds["RFP_ExMakeSplit"]);

				// Split data
				timerKernel->restart();
				for(unsigned int k=0; k<numInnerIter; ++k){
					launchCount = innerNodes > nodeLimit ? nodeLimit : innerNodes;
						
					m_gfxMgr->copyToGPU(m_devId,m_bufferIds["RFB_constants"],&ConstantUpdate(&m_constants,KID_ExtremeMakeSplit),sizeof(m_constants));
					m_gfxMgr->launchComputation(m_devId,launchCount*thread_group_size,1,1);

					m_constants.cb_currentDepth += launchCount;
					innerNodes -= launchCount;
					if(innerNodes <= 0)
						break;
				}
				if(m_kernelSpecificTimings){
//.........这里部分代码省略.........

	void ExRandomTrees::run(){
		std::string setting = m_data->m_gui->getEditText(IDC_RANDFOREST_NUMFEATURES);
		
		try{
			m_numFeatures = boost::lexical_cast<int,std::string>(setting);
		}
		catch(...){
			m_numFeatures = (int)log((float)m_document->getNumAttributes())+1;
		}

		if(m_numFeatures == 0)
			m_numFeatures = (int)log((float)m_document->getNumAttributes())+1;

		setting = m_data->m_gui->getEditText(IDC_RANDFOREST_NUMTREES);
		try{
			m_numTrees = boost::lexical_cast<int,std::string>(setting);
		}
		catch(...){
			m_numTrees = 10;
		}

		setting = m_data->m_gui->getEditText(IDC_RANDFOREST_TREEDEPTH);
		try{
			m_maxDepth = boost::lexical_cast<int,std::string>(setting);
		}
		catch(...){
			m_maxDepth = 100;
		}

		setting = m_data->m_gui->getEditText(IDC_RANDFOREST_SEED);
		try{
			m_randomSeed = boost::lexical_cast<int,std::string>(setting);
		}
		catch(...){
			m_randomSeed = 100;
		}

		setting = m_data->m_gui->getEditText(IDC_RANDFOREST_MAXINST);
		try{
			m_minNumInst = boost::lexical_cast<int,std::string>(setting);
		}
		catch(...){
			m_minNumInst = 10;
		}

		m_dataSetTrain.assign(m_document->getNumAttributes(),std::vector<float>(m_evaluation->getNumTrainingInstances(),0));
		m_classSetTrain.assign(m_document->getNumInstances(),0);
		m_dataSetTest.assign(m_document->getNumAttributes(),std::vector<float>(m_evaluation->getNumTestingInstances(),0));
		m_classSetTest.assign(m_evaluation->getNumTestingInstances(),0);
		for(unsigned int a=0; a<m_document->getNumAttributes(); ++a){
			for(unsigned int i=0; i<m_evaluation->getNumTrainingInstances(); ++i){
				m_dataSetTrain[a][i] = m_evaluation->getTrainingInstance(i)->getValue(a);

				if(a == 0)
					m_classSetTrain[i] = m_evaluation->getTrainingInstance(i)->classValue();
			}

			for(unsigned int i=0; i<m_evaluation->getNumTestingInstances(); ++i){
				m_dataSetTest[a][i] = m_evaluation->getTestingInstance(i)->getValue(a);

				if(a == 0)
					m_classSetTest[i] = m_evaluation->getTestingInstance(i)->classValue();
			}
		}

		// Create trees
		ExTree tree = ExTree(m_evaluation->getNumTrainingInstances());
		m_trees.assign(m_numTrees,tree);
		
		// Seed treees
		boost::random::uniform_int_distribution<> indRand(0,INT_MAX);
		boost::random::mt19937 rng;
		rng.seed(m_randomSeed);
		for(unsigned int i=0; i<m_trees.size(); ++i){
			m_trees[i].seed(indRand(rng));
		}

		m_choiceId = 0;
		m_workLeft = m_numTrees;
		m_chooseIdLock = MutexPtr(new boost::mutex);
		m_barrier = BarrierPtr(new boost::barrier(2));

		TM_runFunctionPtr runFunc = TM_runFunctionPtr(new boost::function<void(void)>(std::bind(std::mem_fun(&ExRandomTrees::buildTree),this)));
		TM_callbackFunctionPtr callbackFunc = TM_callbackFunctionPtr(new boost::function<void(int)>(std::bind1st(std::mem_fun(&ExRandomTrees::buildTreeCallback),this)));
		for(size_t treeIdx = 0; treeIdx < m_trees.size(); ++treeIdx) {
			ThreadManager::queueWorkPackage(runFunc,callbackFunc);
		}

		// Start tree building threads
		TimerPtr timer = TimerPtr(new boost::timer);
		ThreadManager::executeWorkQueue();
		// Make sure all trees have been trained before proceeding
		m_barrier->wait();
		m_buildTimer = timer->elapsed();

		evaluateTestSet();
	}

	void ExRandomTrees::evaluateTestSet(){
		m_votes.assign(m_evaluation->getNumTestingInstances()*2,0);
		m_workLeft = m_trees.size();
		m_choiceId = 0;

		TM_runFunctionPtr runFunc = TM_runFunctionPtr(new boost::function<void(void)>(std::bind(std::mem_fun(&ExRandomTrees::collectSingleVote),this)));
		TM_callbackFunctionPtr callbackFunc = TM_callbackFunctionPtr(new boost::function<void(int)>(std::bind1st(std::mem_fun(&ExRandomTrees::buildTreeCallback),this)));
		for(size_t treeIdx = 0; treeIdx < m_trees.size(); ++treeIdx) {
			ThreadManager::queueWorkPackage(runFunc,callbackFunc);
		}

		// Start tree building threads
		TimerPtr timer = TimerPtr(new boost::timer);
		ThreadManager::executeWorkQueue();
		m_barrier->wait();
		m_testTimer = timer->elapsed();

		unsigned int correct = 0,wrong = 0;

		std::map<double,std::vector<bool>,std::greater<double>> rankingcl1,rankingcl2;
		bool truePositive;
		std::vector<int> clCorrect(m_document->getNumClassValues(),0),clWrong(m_document->getNumClassValues(),0);
		std::vector<double> probs(2,0);
		for(size_t i = 0; i < m_evaluation->getNumTestingInstances(); i++) {
			unsigned int vote = m_votes[2*i] > m_votes[2*i+1] ? 0 : 1;
			probs[0] = m_votes[2*i];
			probs[1] = m_votes[2*i+1];

			if(vote == m_classSetTest[i]){
				++clCorrect[m_classSetTest[i]];
				truePositive;
				++correct;
			}
			else{
				++clWrong[m_classSetTest[i]];
				++wrong;
			}

			rankingcl1[double(probs[0])/double(probs[0]+probs[1])].push_back((0 == m_classSetTest[i]));
			rankingcl2[double(probs[1])/double(probs[0]+probs[1])].push_back((1 == m_classSetTest[i]));
		}

		double auc = (m_evaluation->calculateAUC(rankingcl1)+m_evaluation->calculateAUC(rankingcl2))/2.0;

		m_outputStream <<
			"	Time used for building trees: " << m_buildTimer << "s\r\n" <<
			"	Time used for evaluation of trees: " << m_testTimer << "s\r\n";

		m_outputStream	<< 
			"\r\n	"; 

		std::vector<std::vector<unsigned int>> confusMatrix(m_document->getNumClassValues(),std::vector<unsigned int>(m_document->getNumClassValues(),0));
		for(unsigned int i=0; i<m_document->getNumClassValues(); ++i){
			for(unsigned int j=0; j<m_document->getNumClassValues(); ++j){
				if(i == j)
					confusMatrix[i][j] = clCorrect[i];
				else
					confusMatrix[i][j] = clWrong[i];
			}
		}

		for(unsigned int i=0; i<m_document->getNumClassValues(); ++i){
			m_outputStream << i << "	";
		}
		for(unsigned int i=0; i<m_document->getNumClassValues(); ++i){
			m_outputStream << "\r\n	";
			for(unsigned int j=0; j<m_document->getNumClassValues(); ++j){
				m_outputStream  << confusMatrix[i][j] << "	";
			}
			m_outputStream << i;
		}
		m_outputStream << "\r\n";

		double accuracy = double(double(correct)/double(wrong+correct))*100;

		m_outputStream << 
			"\r\n	" << "Accuracy: " << accuracy << "%\r\n";

		PROCESS_MEMORY_COUNTERS pmc;
		GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
		size_t memUsageCPU = pmc.WorkingSetSize;

		m_resultWriter->addKeyValue("accuracy",accuracy);
		m_resultWriter->addKeyValue("cl1Correct",clCorrect[0]);
		m_resultWriter->addKeyValue("cl1Wrong",clWrong[0]);
		m_resultWriter->addKeyValue("cl2Correct",clCorrect[1]);
		m_resultWriter->addKeyValue("cl2Wrong",clWrong[1]);
		m_resultWriter->addKeyValue("trainingTime",m_buildTimer);
		m_resultWriter->addKeyValue("testingTime",m_testTimer);
		m_resultWriter->addKeyValue("totalTime",m_testTimer+m_buildTimer);
		m_resultWriter->addKeyValue("testingInstances",m_evaluation->getNumTestingInstances());
		m_resultWriter->addKeyValue("trainingInstances",m_evaluation->getNumTrainingInstances());
		m_resultWriter->addKeyValue("auc",auc);
		m_resultWriter->addKeyValue("memUsageCPU",double(memUsageCPU)/1024.0/1024.0);
	}