vs.cc

经网络提出了一种基于蚁群聚类算法的径向基神经网络. 利用蚁群算法的并行寻优特征和挥发系数方法的自适应更改信息量的能力,并以球面聚类的方式确定了径向基神经网络中基函数的位置, 同时通过比较隐层神经元的相

			rawLatencySample = 0;
			bool myIdValidity = false;
			while (!myIdValidity) 
			{
				myId = unifRand (0, nodeCount);
				myIdValidity = validNode[myId];
			}

			if (neighborCount > 0) 
			{
				int neighborId = unifRand (0, neighborCount);
				yourId = neighbors[myId][neighborId];
			}
			else
			{
				yourId = myId;
				while (yourId == myId || !validNode[yourId] || rtts[myId][yourId] <= 0)
				{
					yourId = unifRand (0, nodeCount);
				}
			}
			assert (validNode[yourId]);
			rawLatencySample = rtts[myId][yourId];
			ASSERT (rawLatencySample > 0);

			node[myId].processSample (stamp, myId, yourId, rawLatencySample);
			perSecondOutput (stamp);

			if (debug) 
			{
				if (myId == 1739)
				{
					printf ("r %d me %d you %d s %f\n",
						stamp, myId, yourId, rawLatencySample);
				}
				if (myId == 2)
				{
					printf ("r %d me %d you %d s %f\n",
						stamp, myId, yourId, rawLatencySample);
				}
			}
			stamp++;
		}

	}

	// make sure to ignore anybody who never did anything
	// validNode is only defined with latency matrix

	if (sysCoordFP != NULL || appCoordFP != NULL || nodeFP != NULL)
	{

		for (int i = 0; i < nodeCount; i++)
		{
			//if (validNode[i] && node[i].lastUpdateTo > 0){
			if (node[i].lastUpdateTo > 0) 
			{

				if (sysCoordFP != NULL)
				{
					fprintf (sysCoordFP, "%d ", i);
					node[i].printCoord (sysCoordFP);
					fprintf (sysCoordFP, "\n");
				}

				if (appCoordFP != NULL)
				{
					fprintf (appCoordFP, "%d ", i);
					node[i].printCoord (appCoordFP);
					fprintf (appCoordFP, "\n");
				}

				if (nodeFP != NULL)
				{
					fprintf (nodeFP, "%d ", i);
					node[i].printStat (nodeFP);
					fprintf (nodeFP, "\n");
				}
			}
		}
	}

	// currently only used for relative error,
	// but could be used for any pair-wise comparison
	if (reFP != NULL || sumreFP != NULL) 
	{
		for (int myId = 0; myId < nodeCount; myId++) 
		{
			if (node[myId].lastUpdateTo > 0)
			{
				vector<double> sys_errors;
				vector<double> app_errors;
				for (int yourId = 0; yourId < nodeCount; yourId++)
				{
					if (yourId != myId) {
						if (node[yourId].lastUpdateTo > 0)
						{    
							float median = 0;
							float sys_relativeErrorAB = 0;
							float app_relativeErrorAB = 0;

							float sys_distanceAB =
								node[myId].vec->getEuclideanDistance (node[yourId].vec);
							float app_distanceAB =
								node[myId].appVector->getEuclideanDistance (node[yourId].appVector);

							if (rtts != NULL) 
							{
								median = rtts[myId][yourId];
								sys_relativeErrorAB = fabs(sys_distanceAB - median) / median;
								app_relativeErrorAB = fabs(app_distanceAB - median) / median;
							}

							if (median > 0) 
							{
								if (reFP != NULL) 
								{
									//fprintf (reFP, "%d %d %f %f\n", myId, yourId, 
									//sys_relativeErrorAB, app_relativeErrorAB);
									fprintf (reFP, "%d %d re %f d %f l %f %d\n", myId, yourId, 
										app_relativeErrorAB, app_distanceAB, median,
										isNeighbor(myId, yourId));
								}
								sys_errors.push_back (sys_relativeErrorAB);
								app_errors.push_back (app_relativeErrorAB);
							}    
						}
					}
				}

				if (sumreFP != NULL) 
				{
					double sys_fifty = percentile (sys_errors, .5);
					double sys_eighty = percentile (sys_errors, .8);
					double sys_ninetyfive = percentile (sys_errors, .95);
					double app_fifty = percentile (app_errors, .5);
					double app_eighty = percentile (app_errors, .8);
					double app_ninetyfive = percentile (app_errors, .95);
					fprintf (sumreFP, "%d sys %f %f %f app %f %f %f\n", myId,
						sys_fifty, sys_eighty, sys_ninetyfive,
						app_fifty, app_eighty, app_ninetyfive);
				}

			}
		}
	}

	if (ralpFP != NULL)
	{

		for (int myId = 0; myId < nodeCount; myId++)
		{
			float ralpLoss = 0;
			float ralpSum = 0; 

			float rrlLoss = 0;
			float rrlSum = 0; 

			float narlLoss = 0;
			float narlSum = 0; 

			for (int nodeA = 0; nodeA < nodeCount; nodeA++)
			{
				for (int nodeB = nodeA+1; nodeB < nodeCount; nodeB++)
				{

					if (myId != nodeA && myId != nodeB &&
						rtts[myId][nodeA] > 0 && rtts[myId][nodeB] > 0 &&
						node[myId].lastUpdateTo > 0 && node[nodeA].lastUpdateTo > 0 &&
						node[nodeB].lastUpdateTo > 0) 
					{

						/*
						float distanceA = 
						node[myId].vec->getEuclideanDistance (node[nodeA].vec);
						float distanceB = 
						node[myId].vec->getEuclideanDistance (node[nodeB].vec);
						*/
						float distanceA = 
							node[myId].appVector->getEuclideanDistance (node[nodeA].appVector);
						float distanceB = 
							node[myId].appVector->getEuclideanDistance (node[nodeB].appVector);

						float medianA = rtts[myId][nodeA];
						float medianB = rtts[myId][nodeB];

						float medianDifference = fabs(medianA-medianB);

						if (debug) 
						{
							printf ("A %d B %d dA %f sA %f dB %f sB %f\n",
								nodeA, nodeB,
								distanceA, medianA,
								distanceB, medianB);
						}

						rrlSum++;
						if (medianA > medianB) 
						{
							if (distanceA < distanceB)
								rrlLoss++;
						}
						else if (medianB > medianA)
						{
							if (distanceB < distanceA)
								rrlLoss++;
						}

						narlSum += medianDifference;
						if (medianA > medianB) 
						{
							if (distanceA < distanceB) 
								narlLoss += medianDifference;
						}
						else if (medianB > medianA) 
						{
							if (distanceB < distanceA) 
								narlLoss += medianDifference;
						}

						if (medianA > medianB) 
						{
							if (distanceA < distanceB) 
							{
								ralpLoss += medianDifference;
								ralpSum += medianA;
							}
						} 
						else if (medianB > medianA) 
						{
							if (distanceB < distanceA)
							{
								ralpLoss += medianDifference;
								ralpSum += medianB;
							}
						}
					}
				}
			}
			float rrlLossPct = rrlLoss/rrlSum;
			float narlLossPct = narlLoss/narlSum;
			float ralpLossPct = ralpLoss/ralpSum;
			fprintf (ralpFP, "%d %.3f %.3f %.3f\n", myId, 
				rrlLossPct, narlLossPct, ralpLossPct);

		}
	}


	delete [] node;

	if (rtts != NULL) 
	{
		for (int myId = 0; myId < nodeCount; myId++)
		{
			delete [] rtts[myId];
			delete [] distanceMatrixSys[myId];
			delete [] errorMatrixSys[myId];
			delete [] distanceMatrixApp[myId];
			delete [] errorMatrixApp[myId];
		}
		delete [] rtts;
		delete [] distanceMatrixSys;
		delete [] errorMatrixSys;
		delete [] distanceMatrixApp;
		delete [] errorMatrixApp;
	}
	return 0;
}

bool isNeighbor (int myId, int yourId) 
{
	for (int neighborId = 0; neighborId < neighborCount; neighborId++) 
	{
		if (neighbors[myId][neighborId] == yourId) 
		{
			return true;
		}
	}
	return false;
}

void computeDistanceMatrix ()
{
	int foundDistanceCount = 0;
	for (int myId = 0; myId < nodeCount; myId++) 
	{
		if (node[myId].lastUpdateTo > 0)
		{
			for (int yourId = 0; yourId < nodeCount; yourId++)
			{
				if (yourId != myId) 
				{
					if (node[yourId].lastUpdateTo > 0) 
					{    
						float sys_distanceAB =
							node[myId].vec->getEuclideanDistance 
							(node[yourId].vec);
						float app_distanceAB =
							node[myId].appVector->getEuclideanDistance 
							(node[yourId].appVector);
						distanceMatrixSys[myId][yourId] = sys_distanceAB;
						distanceMatrixApp[myId][yourId] = app_distanceAB;
						foundDistanceCount++;
					}
				}
			}
		}
	}
	//printf ("Found distance for %.3f nodes\n",
	//foundDistanceCount/(double)(nodeCount*nodeCount));
}

void computeErrorMatrix (vector<double> &errorListSys,
						 vector<double> &errorListApp) 
{
	int foundErrorCount = 0;
	if (rtts != NULL) {
		for (int myId = 0; myId < nodeCount; myId++) 
		{
			if (node[myId].lastUpdateTo > 0) 
			{
				for (int yourId = 0; yourId < nodeCount; yourId++) 
				{
					if (yourId != myId) 
					{
						if (node[yourId].lastUpdateTo > 0)
						{    
							double median = rtts[myId][yourId];
							if (median > 0 && distanceMatrixSys[myId][yourId] > 0)
							{
								double sys_relativeErrorAB =
									fabs(distanceMatrixSys[myId][yourId] - median) / median;
								errorMatrixSys[myId][yourId] = sys_relativeErrorAB;
								foundErrorCount++;
								errorListSys.push_back(sys_relativeErrorAB);
							}
							if (median > 0 && distanceMatrixApp[myId][yourId] > 0)
							{
								double app_relativeErrorAB =
									fabs(distanceMatrixApp[myId][yourId] - median) / median;
								errorMatrixApp[myId][yourId] = app_relativeErrorAB;
								errorListApp.push_back(app_relativeErrorAB);
							}
						}
					}
				}
			}
		}
	}
							 //printf ("Found error for %.3f nodes\n",
							 //foundErrorCount/(double)(nodeCount*nodeCount));
}



void perSecondOutput (int stamp) 
{
	if (stamp > lastFrameStamp + FRAME_INTERVAL)
	{
		lastFrameStamp += FRAME_INTERVAL;
		if (secFP)
		{

			double sys_matrix_re50 = 0;
			double sys_matrix_re95 = 0;
			double app_matrix_re50 = 0;
			double app_matrix_re95 = 0;

			if (rtts != NULL)
			{
				vector<double> errorListSys;
				vector<double> errorListApp;
				computeDistanceMatrix ();
				computeErrorMatrix (errorListSys,errorListApp);
				//printf ("error size %d\n", errorListSys.size());
				sys_matrix_re50 = percentile(errorListSys, .5);
				sys_matrix_re95 = percentile(errorListSys, .95);
				app_matrix_re50 = percentile(errorListApp, .5);
				app_matrix_re95 = percentile(errorListApp, .95);
			}

			double sysRawRE_50 = percentile (sec_sysRawRE_list, .5);
			//double sysRawRE_80 = percentile (sec_sysRawRE_list, .8);
			double sysRawRE_95 = percentile (sec_sysRawRE_list, .95);

			double appRawRE_50 = percentile (sec_appRawRE_list, .5);
			//double appRawRE_80 = percentile (sec_appRawRE_list, .8);
			double appRawRE_95 = percentile (sec_appRawRE_list, .95);

			fprintf (secFP, "%d num %d sm50 %.3f sm95 %.3f am50 %.3f am95 %.3f s50 %.3f s95 %.3f sDD %.3f a50 %.3f a95 %.3f aDD %.3f\n",
				lastFrameStamp/FRAME_INTERVAL, sec_appRawRE_list.size(),
				sys_matrix_re50, sys_matrix_re95,	       
				app_matrix_re50, app_matrix_re95,	       
				sysRawRE_50, sysRawRE_95, sec_sysDD_sum, 
				appRawRE_50, appRawRE_95, sec_appDD_sum);
			if (flushSecFP)
				fflush (secFP);
			sec_sysRawRE_list.clear ();
			sec_appRawRE_list.clear ();
			sec_sysDD_sum = 0;
			sec_appDD_sum = 0;
		}

		if (strchr(outputFormat,'g') != NULL) 
		{
			FILE *gnuplotFP = new FILE;
			openOutputFile (gnuplotFP, outputPrefix, ".gp", lastFrameStamp/FRAME_INTERVAL);

			for (int i = 0; i < nodeCount; i++)
			{
				if (node[i].lastUpdateTo > 0)
				{
					fprintf (gnuplotFP, "%d ", i);
					node[i].printCoord (gnuplotFP);
					node[i].printAppCoord (gnuplotFP);
					fprintf (gnuplotFP, "\n");
				}
			}
			closeOutputFile (gnuplotFP);
		}
	}
}