kddcup.cpp

KddCUP 神经网络数据处理,用于提取数据

#include <stdlib.h>
#include <iostream.h>
#include <fstream.h>
#include <string.h>
const int NUM=100;         /* 待处理的样本记录条数,改变其值
                              可实现对任意条记录的处理 */
/*int shiCiFang(int i)
{ 
	int val=1;
	if(i==0)
	{return val;}
	else
	{
		while(i!=0)
		{val=val*10;i--;}
		return val;
	}
}*/
 

  
/*double charToDouble(char* s)
{   char* sh=s;
    double value=0;
	int len=strlen(s);
	int i=0;
	while((*sh)!='\0')
	{sh++;}
	sh=sh-1;
	for(int j=0;j<len;j++)
	{     
		value=value+((*sh)-48)*(shiCiFang(i));
		i++;
		sh--;
	}
	return value;
}*/


struct kddcup
{
	char protocol_type[5];
	//char* protocol_type[20];
	char service[10];
	char flag[5];
	char attackType[20];
	double continuousData[38];

};



void main()
{
	char ch;                                           //用于临时存储读入的每个字符
	char sh[20];                                       //用于临时存储读入的每个字段值
	int i=0;                                             //数组sh[]的下标
	int fh=0;                                            //用于对读入的字段计数，每满42个字段为
	                                                   //一条网络连接记录
	kddcup kdd[NUM];
	double inputVector[NUM][42];                       //存放最终处理结果
    double maxValue[42];
	double minValue[42];
	int differentCode[NUM];                            //存储字符型字段的十进制编码值
	int diffCode=0;                                    //记录不同取值的字符字段的个数
	int Flag=0;
	int sameItem=0;
	double t0=0;
	ofstream outfile1,outfile;
	fstream infile("KDDCUP 数据源.txt",ios::in);      //以读的方式打开 KDDCUP 数据源
    outfile1.open("简明数据源.txt");            //用于存放数据源的简明表示，便于验证程序的正确性
	outfile.open("神经网络输入向量.txt");             //用于存储处理后的样本数据
    /*   以下为对原始数据进行预处理的过程   */


	/* while(infile>>ch)
	 {	 cout<<ch;
	     outfile<<ch;
	 }  */


	//char* Ch;
	//char sh;
	//int value;
	//char* s;
	//double sourceData[4];
	//s=Ch;
	//for(int j=0;j<4;j++)
	//{    int i=0;
    //   while(infile>>ch && ch!=',')
		 /*{
			  Ch[i++]=ch;

		 }*/

	//	sourceData[j]=(int)Ch;
	//}
	//value=sourceData[0]+sourceData[1];
    //outfile<<value;   


	//char* p="2.713";
	//cout<<strlen(p);
	//double v=charToDouble(p);
	//double v=atof(p);
	//cout<<v;
    //outfile<<v;
    //outfile<<",";
	//outfile<<"\n";
	//outfile<<v;
	//int i=4,j=0;
	//cout<<3*shiCiFang(i);
	//double v=0;
	//cout<<v;


	for(int I=0;I<NUM;I++)
	{
	   i=0;
	   fh=0;
	   infile>>ch;
	   while(!(fh==41&&ch=='.'))
	   {
		  //infile>>ch;
	      if(fh!=41&&ch!=',')
		  { sh[i++]=ch; }
	   
		  else if(fh!=41&&ch==',')
		  {
			sh[i]='\0';
            fh++;
			//outfile<<fh;
			//outfile<<'\n';
			if(fh==2)
			 {
			   strcpy(kdd[I].protocol_type,sh);
			   //cout<<sh;
			   			   
			 }
		    else if(fh==3)
			{
			   strcpy(kdd[I].service,sh);
			   //cout<<sh;
			 }
			else if(fh==4)
			{
			   strcpy(kdd[I].flag,sh);
			   //cout<<sh;
			}
			else if(fh==1)
			 {
			   kdd[I].continuousData[0]=atof(sh);
			   //cout<<kdd[I].continuousData[0];
			   //cout<<sh;
			   //cout<<',';

			 }
			else
			 {
			   kdd[I].continuousData[fh-4]=atof(sh);
			   //cout<<kdd[I].continuousData[fh-4];
			   //cout<<sh;
			   //cout<<',';

			 }
			 
			 i=0;
		}

		   else if(fh==41)
			   {
				   sh[i++]=ch;
			   }
		   infile>>ch;
	   }

           sh[i]='\0';
	       strcpy(kdd[I].attackType,sh);
		   //cout<<sh;
		   //cout<<endl;


	}



for(int J=0;J<NUM;J++)
{
	outfile1<<kdd[J].continuousData[0];
    outfile1<<",                    ";
	outfile1<<kdd[J].protocol_type;
	outfile1<<",                    ";
    outfile1<<kdd[J].service;
	outfile1<<",                    ";
	outfile1<<kdd[J].flag;
	outfile1<<",                    ";
	for(int i=1;i<38;i++)
	{	outfile1<<kdd[J].continuousData[i];
	    outfile1<<",                    ";
	}
	outfile1<<kdd[J].attackType;
	outfile1<<'\n';
	outfile1<<'\n';

}


/* 初始化，字符型字段的最小值规定为0 */
/*minValue[1]=0;
minValue[2]=0;
minValue[3]=0;
minValue[41]=0;*/


for( int i1=0;i1<NUM;i1++)
{  inputVector[i1][0]=kdd[i1].continuousData[0];
    for(int j=4;j<41;j++)
	{
		inputVector[i1][j]=kdd[i1].continuousData[j-3];
	}
}

	/*给inputVector[i][1]初始化*/
	//Flag=0;sameItem=0;
      diffCode=0;
	for( int i2=0;i2<NUM;i2++)
	{	Flag=0;sameItem=0;
		for(int t1=0;t1<i2;t1++)
	{
		if(!strcmp(kdd[i2].protocol_type,kdd[t1].protocol_type))
		{Flag=1;sameItem=t1;break;}

	}
		if(Flag==1)
		{
			inputVector[i2][1]=differentCode[sameItem];
			//cout<<inputVector[i2][1];
			differentCode[i2]=differentCode[sameItem];
		}
		else
		{    //cout<<diffCode;
			 diffCode++;
			 //cout<<diffCode;
             inputVector[i2][1]=diffCode;
		     differentCode[i2]=diffCode;

		}
	}

	/*给inputVector[i][2]初始化*/
    //Flag=0;sameItem=0;
	diffCode=0;
		for( int i3=0;i3<NUM;i3++)
	{Flag=0;sameItem=0;
			for(int t2=0;t2<i3;t2++)
	{
		if(!strcmp(kdd[t2].service,kdd[i3].service))
		{Flag=1;sameItem=t2;break;}

	}
		if(Flag)
		{
			inputVector[i3][2]=differentCode[sameItem];
			differentCode[i3]=differentCode[sameItem];
		}
		else
		{    
			 diffCode++;
             inputVector[i3][2]=diffCode;
		     differentCode[i3]=diffCode;
		}
	}

	/*给inputVector[i][3]初始化*/
//Flag=0;sameItem=0;
	diffCode=0;
	for( int i4=0;i4<NUM;i4++)
{Flag=0;sameItem=0;
		for(int t3=0;t3<i4;t3++)
	{
		if(!strcmp(kdd[t3].flag,kdd[i4].flag))
		{Flag=1;sameItem=t3;break;}

	}
		if(Flag)
		{
			inputVector[i4][3]=differentCode[sameItem];
			differentCode[i4]=differentCode[sameItem];
		}
		else
		{    //cout<<diffCode;
			 diffCode++;
			 //cout<<diffCode;
             inputVector[i4][3]=diffCode;
		     differentCode[i4]=diffCode;

		}
	}

	/*给inputVector[i][41]初始化*/
//Flag=0;sameItem=0;
diffCode=0;
	for( int i5=0;i5<NUM;i5++)
{Flag=0;sameItem=0;
		for(int t41=0;t41<i5;t41++)
	{
		if(!strcmp(kdd[t41].attackType,kdd[i5].attackType))
		{Flag=1;sameItem=t41;break;}

	}
		if(Flag)
		{
			inputVector[i5][41]=differentCode[sameItem];
			differentCode[i5]=differentCode[sameItem];
		}
		else
		{    
			 diffCode++;
             inputVector[i5][41]=diffCode;
		     differentCode[i5]=diffCode;
		}
}


//算最大最小值
for(int k1=0;k1<42;k1++)
{
    maxValue[k1]=inputVector[0][k1];
	minValue[k1]=inputVector[0][k1];
	for(int k2=1;k2<NUM;k2++)
	{
	   if(maxValue[k1]<inputVector[k2][k1])
	   {
		   maxValue[k1]=inputVector[k2][k1];
	   }
	   if(minValue[k1]>inputVector[k2][k1])
	   {
		   minValue[k1]=inputVector[k2][k1];
	   }
	}
	//cout<<maxValue[k1]<<",    ";
	//cout<<minValue[k1]<<",    ";
}





/****************************************数据处理向量生成**********************************/

for(int k3=0;k3<NUM;k3++)
{    
	for(int k4=0;k4<42;k4++)
	{
		if(maxValue[k4]==minValue[k4])
		{
			if(maxValue[k4]==0)
			{
				inputVector[k3][k4]=0;
			}
			else if(maxValue[k4]==1)
			{
				inputVector[k3][k4]=1;
			}
			else
			{
				inputVector[k3][k4]=0;
			}
		}
		else if((k4==1)||(k4==2)||(k4==3)||(k4==41))
		{
			inputVector[k3][k4]=inputVector[k3][k4]/(maxValue[k4]+1);
		}
		else
		{
			inputVector[k3][k4]=(inputVector[k3][k4]-minValue[k4])/(maxValue[k4]-minValue[k4]);
		}
	}
}







/*输出数据*/

for(int i6=0;i6<NUM;i6++)
{
  for(int j6=0;j6<42;j6++)
  {
	  outfile<<inputVector[i6][j6];
      outfile<<",     ";
  }
  outfile<<'\n';
}













//	infile>>ch;
//	cout<<ch;
/*for( int k=0;k<100;k++)
{cout<<kdd[k].protocol_type;
cout<<kdd[k].service;
cout<<kdd[k].flag;
cout<<kdd[k].attackType;
}*/
	/*cout<<kdd[8].protocol_type;
	outfile<<kdd[8].protocol_type;
	cout<<kdd[8].service;
	cout<<kdd[8].flag;
	cout<<kdd[2].attackType;*/




     


	







     /*   数据处理完毕   */
	 cout<<endl;
     infile.close();
	 outfile1.close();
	 outfile.close();
     
}