开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
Classifier.cpp
资源名称：TextClassify.rar　[点击查看]
上传用户：sanxfzhen
上传日期：2014-12-28
资源大小：2324k
文件大小：55k
源码类别：

多国语言处理

开发平台：

Visual C++

Classifier.cpp：源码内容
  1. // Classifier.cpp: implementation of the CClassifier class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "TextClassify.h"
  7. #include "Classifier.h"
  8. #include "WordSegment.h"
  9. #include "Message.h"
  10. #include <math.h>
  11. #include <direct.h>
  13. #ifdef _DEBUG
  14. #undef THIS_FILE
  15. static char THIS_FILE[]=__FILE__;
  16. #define new DEBUG_NEW
  17. #endif
  19. CClassifier theClassifier;
  20. const DWORD CClassifier::dwModelFileID=0xFFEFFFFF;
  21. //////////////////////////////////////////////////////////////////////
  22. // Construction/Destruction
  23. //////////////////////////////////////////////////////////////////////
  25. CClassifier::CClassifier()
  26. {
  27. n_Type=-1;
  28. m_pDocs=NULL;
  29. m_pSimilarityRatio=NULL;
  30. m_pProbability=NULL;
  31. m_lDocNum=0;
  32. m_nClassNum=0;
  33. }
  35. CClassifier::~CClassifier()
  36. {
  38. }
  40. //参数bGenDic=false代表无需重新扫描文档得到训练文档集中所有特征,一般在层次分类时使用
  41. //参数nType用来决定分类模型的类别,nType=0代表KNN分类器,nType=1代表SVM分类器
  42. bool CClassifier::Train(int nType, bool bFlag)
  43. {
  44. this->n_Type=nType;
  45. CTime startTime;
  46. CTimeSpan totalTime;
  47. if(bFlag)
  48. {
  49. InitTrain();
  50. //生成所有候选特征项，将其保存在m_lstWordList中
  51. GenDic();
  52. }
  53. CMessage::PrintStatusInfo("");
  55. if(m_lstWordList.GetCount()==0)
  56. return false;
  57. if(m_lstTrainCatalogList.GetCataNum()==0)
  58. return false;
  60. //清空特征项列表m_lstTrainWordList
  61. m_lstTrainWordList.InitWordList();
  62. //为特征项列表m_lstWordList中的每个特征加权
  63. CMessage::PrintInfo(_T("开始计算候选特征集中每个特征的类别区分度，请稍候..."));
  64. startTime=CTime::GetCurrentTime();
  65. FeatherWeight(m_lstWordList);
  66. totalTime=CTime::GetCurrentTime()-startTime;
  67. CMessage::PrintInfo(_T("特征区分度计算结束，耗时")+totalTime.Format("%H:%M:%S"));
  68. CMessage::PrintStatusInfo("");
  70. //从特征项列表m_lstWordList中选出最优特征
  71. CMessage::PrintInfo(_T("开始进行特征选择，请稍候..."));
  72. startTime=CTime::GetCurrentTime();
  73. FeatherSelection(m_lstTrainWordList);
  74.     //为最优特征集m_lstTrainWordList中的每个特征建立一个ID
  75. m_lstTrainWordList.IndexWord();
  76. totalTime=CTime::GetCurrentTime()-startTime;
  77. CMessage::PrintInfo(_T("特征选择结束，耗时")+totalTime.Format("%H:%M:%S"));
  78. CMessage::PrintStatusInfo("");
  80. // 清空m_lstWordList,释放它占用的空间
  81. m_lstWordList.InitWordList();
  83. CMessage::PrintInfo("开始生成文档向量，请稍候...");
  84. startTime=CTime::GetCurrentTime();
  85. GenModel();
  86. totalTime=CTime::GetCurrentTime()-startTime;
  87. CMessage::PrintInfo(_T("文档向量生成结束，耗时")+totalTime.Format("%H:%M:%S"));
  88. CMessage::PrintStatusInfo("");
  90. CMessage::PrintInfo("开始保存分类模型，请稍候...");
  91. startTime=CTime::GetCurrentTime();
  92. WriteModel(m_paramClassifier.m_txtResultDir+"\model.prj",nType);
  93. totalTime=CTime::GetCurrentTime()-startTime;
  94. CMessage::PrintInfo(_T("保存分类模型结束，耗时")+totalTime.Format("%H:%M:%S"));
  96. //训练SVM分类器必须在保存训练文档的文档向量后进行
  97. if(nType == 1)
  98. {
  99. CMessage::PrintInfo("开始训练SVM，请稍候...");
  100. m_lstTrainCatalogList.InitCatalogList(2); //删除文档向量所占用的空间
  101. startTime=CTime::GetCurrentTime();
  102. TrainSVM();
  103. totalTime=CTime::GetCurrentTime()-startTime;
  104. CMessage::PrintInfo(_T("SVM分类器训练结束，耗时")+totalTime.Format("%H:%M:%S"));
  105. CMessage::PrintStatusInfo("");
  106. }
  107. //为分类做好准备,否则不能进行分类
  108. Prepare();
  109. CMessage::PrintStatusInfo("");
  110. return TRUE;
  111. }
  113. void CClassifier::TrainSVM()
  114. {
  115. CString str;
  116. CTime tmStart;
  117. CTimeSpan tmSpan;
  119. m_paramClassifier.m_strModelFile="model";
  120. for(int i=1;i<=m_lstTrainCatalogList.GetCataNum();i++)
  121. {
  122. tmStart=CTime::GetCurrentTime();
  123. str.Format("正在训练第%d个SVM分类器，请稍侯...",i);
  124. CMessage::PrintInfo(str);
  125. m_theSVM.com_param.trainfile=m_paramClassifier.m_txtResultDir+"\train.txt";
  126. m_theSVM.com_param.modelfile.Format("%s\%s%d.mdl",m_paramClassifier.m_txtResultDir,m_paramClassifier.m_strModelFile,i);
  127. m_theSVM.svm_learn_main(i);
  128. tmSpan=CTime::GetCurrentTime()-tmStart;
  129. str.Format("第%d个SVM分类器训练完成，耗时%s!",i,tmSpan.Format("%H:%M:%S"));
  130. CMessage::PrintInfo(str);
  131. }
  132. }
  134. void CClassifier::TrainBAYES()
  135. {
  136. /*
  137. CString str;
  138. CTime tmStart;
  139. CTimeSpan tmSpan;
  141. m_paramClassifier.m_strModelFile="model";
  142. for(int i=1;i<=m_lstTrainCatalogList.GetCataNum();i++)
  143. {
  144. tmStart=CTime::GetCurrentTime();
  145. str.Format("正在训练第%d个SVM分类器，请稍侯...",i);
  146. CMessage::PrintInfo(str);
  147. m_theSVM.com_param.trainfile=m_paramClassifier.m_txtResultDir+"\train.txt";
  148. m_theSVM.com_param.modelfile.Format("%s\%s%d.mdl",m_paramClassifier.m_txtResultDir,m_paramClassifier.m_strModelFile,i);
  149. m_theSVM.svm_learn_main(i);
  150. tmSpan=CTime::GetCurrentTime()-tmStart;
  151. str.Format("第%d个SVM分类器训练完成，耗时%s!",i,tmSpan.Format("%H:%M:%S"));
  152. CMessage::PrintInfo(str);
  153. }
  154. */
  155. }
  157. // fill an array of CTrain::sSortType (train word length)
  158. // nCatalog mean the value of element of the array is the weight
  159. // of nCatalog(as an index of catalog) for each individual word
  160. // if nCatalog==-1 then sum weight for all catalog
  161. void CClassifier::GenSortBuf(CWordList& wordList,sSortType *psSortBuf,int nCatalog)
  162. {
  163. int nTotalCata=m_lstTrainCatalogList.GetCataNum();
  164. int i;
  165. ASSERT(nCatalog<nTotalCata);
  166. long lWordCount=0 ;
  167. POSITION pos_word = wordList.GetFirstPosition();
  168. CString str;
  169. while(pos_word!= NULL)  // for each word
  170. {
  171. CWordNode& wordnode = wordList.GetNext(pos_word,str);
  172. psSortBuf[lWordCount].pclsWordNode = &wordnode; 
  173. strcpy(psSortBuf[lWordCount].word,str);
  174. ASSERT(wordnode.m_nAllocLen==nTotalCata);
  175. if(nCatalog==-1)
  176. {
  177. psSortBuf[lWordCount].dWeight+=wordnode.m_dWeight;
  178. }
  179. else
  180. psSortBuf[lWordCount].dWeight=wordnode.m_pCataWeight[nCatalog];
  182. //拷贝词属于类的概率
  183. if(this->n_Type==2)
  184. for(i=0;i<nTotalCata;i++)
  185. {
  186. psSortBuf[lWordCount].pclsWordNode->m_pCataWeightPro[i]=wordnode.m_pCataWeightPro[i];
  187. // CString strtemp;
  188. // strtemp.Format("123 %f",psSortBuf[lWordCount].pclsWordNode->m_pCataWeightPro[i]);
  189. // CMessage::PrintInfo(strtemp);
  190. }
  191. lWordCount++;
  192. }
  193. }
  196. //从m_lstWordList选出最优特征子集,存到dstWordList中
  197. void CClassifier::FeatherSelection(CWordList& dstWordList)
  198. {
  199. if(m_lstWordList.GetCount()<=0) return;
  200. dstWordList.InitWordList();
  201. m_lstWordList.IndexWord();
  203. sSortType *psSortBuf;
  204. int nDistinctWordNum = m_lstWordList.GetCount();
  205. psSortBuf = new sSortType[nDistinctWordNum ];  // the distinct number of the word 
  206. ASSERT(psSortBuf!=NULL);
  207. long lDocNum=m_lstTrainCatalogList.GetDocNum();
  208. for(int i=0;i<nDistinctWordNum ;i++)
  209. {
  210. psSortBuf[i].pclsWordNode = NULL;
  211. psSortBuf[i].dWeight   = 0;
  212. }
  214. // catalog indivial selecting
  215. if(m_paramClassifier.m_nSelMode==CClassifierParam::nFSM_IndividualModel)
  216. {
  217. int nCatalogWordSize=m_paramClassifier.m_nWordSize;
  218. int nTotalCata=m_lstTrainCatalogList.GetCataNum();
  219. for(int i=0;i<nTotalCata;i++)
  220. {
  221. GenSortBuf(m_lstWordList,psSortBuf,i);//-1 mean sum all catalog
  222. Sort(psSortBuf,nDistinctWordNum-1);
  223. int nSelectWordNum=0;
  224. for(int j=0;j<nDistinctWordNum&&nSelectWordNum<nCatalogWordSize;j++)
  225. {
  226. CWordNode wordNode;
  227. if(m_paramClassifier.m_nWeightMode==CClassifierParam::nWM_TF_IDF)
  228. psSortBuf[i].pclsWordNode->ComputeWeight(lDocNum);
  229. else if(m_paramClassifier.m_nWeightMode==CClassifierParam::nWM_TF_IDF_DIFF)
  230. psSortBuf[i].pclsWordNode->ComputeWeight(lDocNum,true);
  231. wordNode.m_dWeight=psSortBuf[j].pclsWordNode->m_dWeight;
  232. wordNode.m_lDocFreq=psSortBuf[j].pclsWordNode->m_lDocFreq;
  233. wordNode.m_lWordFreq=psSortBuf[j].pclsWordNode->m_lWordFreq;
  235. dstWordList.SetAt(psSortBuf[j].word,wordNode);
  236. nSelectWordNum++;
  237. }
  238. }
  239. }
  240. // total selecting
  241. else //if(m_paramClassifier.m_nSelMode==CClassifierParam::nFSM_GolbalMode)
  242. {
  243. int iWord=0;
  244. GenSortBuf(m_lstWordList,psSortBuf,-1);//-1 mean sum all catalog
  245. Sort(psSortBuf,nDistinctWordNum-1);
  247. int nSelectWordNum=m_paramClassifier.m_nWordSize;
  248. if (nSelectWordNum>nDistinctWordNum)
  249. nSelectWordNum=nDistinctWordNum;
  251. for(i=0;i<nSelectWordNum;i++)
  252. {
  253. CWordNode wordNode;
  254. wordNode.InitBuffer(m_lstTrainCatalogList.GetCataNum());
  255. if(m_paramClassifier.m_nWeightMode==CClassifierParam::nWM_TF_IDF)
  256. psSortBuf[i].pclsWordNode->ComputeWeight(lDocNum);
  257. else if(m_paramClassifier.m_nWeightMode==CClassifierParam::nWM_TF_IDF_DIFF)
  258. psSortBuf[i].pclsWordNode->ComputeWeight(lDocNum,true);
  259. wordNode.m_dWeight=psSortBuf[i].pclsWordNode->m_dWeight;
  260. wordNode.m_lDocFreq=psSortBuf[i].pclsWordNode->m_lDocFreq;
  261. wordNode.m_lWordFreq=psSortBuf[i].pclsWordNode->m_lWordFreq;
  263. if(this->n_Type==2)
  264. // 拷贝词在不同类中的概率
  265. for(int k=0;k<m_lstTrainCatalogList.GetCataNum();k++)
  266. {
  267. double abc = psSortBuf[i].pclsWordNode->m_pCataWeightPro[k];
  268. wordNode.m_pCataWeightPro[k] = psSortBuf[i].pclsWordNode->m_pCataWeightPro[k];
  269. // CString strtemp;
  270. // strtemp.Format("123 %f",wordNode.m_pCataWeightPro[k]);
  271. // CMessage::PrintInfo(strtemp);
  272. }
  274. dstWordList.SetAt(psSortBuf[i].word,wordNode);
  275. }
  276. }
  277. delete [] psSortBuf;
  278. }
  280. void CClassifier::FeatherWeight(CWordList& wordList)
  281. {
  282. // ------------------------------------------------------------------------------
  283. //  based on document number model
  284. int N; //总的文档数;
  285. int N_c; //C类的文档数
  286. int N_ft; //含有ft的文档数
  287. int N_c_ft; //C类中含有ft的文档数
  288. // ------------------------------------------------------------------------------
  289. //  based on word number model
  290. long N_W;    //总的词数 m_lWordNum;
  291. long N_W_C;  //C类词数 CCatalogNode.m_lTotalWordNum;
  292. long N_W_f_t; //f_t出现的总次数
  293. long N_W_C_f_t;//C类中f_t出现的次数
  294. // ------------------------------------------------------------------------------
  295. double P_c_ft,P_c_n_ft,P_n_c_ft,P_n_c_n_ft;
  296. double P_c,P_n_c;
  297. double P_ft,P_n_ft;
  299. // ------------------------------------------------------------------------------
  300. POSITION pos_cata,pos_word;
  301. CString     strWord;
  303. // calculate the weight of each word to all catalog
  304. N = m_lstTrainCatalogList.GetDocNum();
  305. N_W = wordList.GetWordNum();
  307. int nTotalCata=m_lstTrainCatalogList.GetCataNum();
  308. pos_word = wordList.GetFirstPosition();
  309. while(pos_word!= NULL)  // for each word
  310. {
  311. CWordNode& wordnode = wordList.GetNext(pos_word,strWord);
  313. wordnode.m_dWeight=0;
  315. ASSERT(wordnode.m_pCataWeight);
  316. ASSERT(wordnode.m_pCataWeightPro);
  318. CMessage::PrintStatusInfo("特征:"+strWord+"..."); 
  320. N_ft = wordnode.GetDocNum();  
  321. N_W_f_t = wordnode.GetWordNum();
  322. int nCataCount=0;
  323. pos_cata = m_lstTrainCatalogList.GetFirstPosition();
  325. while(pos_cata!=NULL)  // for each catalog 
  326. {
  327. CCatalogNode& catanode = m_lstTrainCatalogList.GetNext(pos_cata);
  328. N_c  = catanode.GetDocNum();
  329. N_W_C  = catanode.m_lTotalWordNum;
  330. N_c_ft = wordnode.GetCataDocNum(catanode.m_idxCata);
  331. N_W_C_f_t =wordnode.GetCataWordNum(catanode.m_idxCata);
  332. // calculation model 
  333. if(m_paramClassifier.m_nOpMode==CClassifierParam::nOpWordMode)   
  334. {
  335. P_c     = 1.0 * N_W_C /N_W;
  336. P_ft = 1.0 * N_W_f_t/N_W;
  337. P_c_ft  = 1.0 * N_W_C_f_t/N_W;
  338. }
  339. else //if(m_paramClassifier.m_nOpMode==CClassifierParam::nOpDocMode)
  340. {
  341. P_c = 1.0 * N_c /N; //C类出现的概率
  342. P_ft = 1.0 * N_ft/N; //含有ft的文档出现的概率
  343. P_c_ft = 1.0 * N_c_ft/N; //C类中含有ft的文档的概率
  344. }
  346. P_n_c = 1 - P_c;
  347. P_n_ft = 1 - P_ft;
  348. P_n_c_ft = P_ft - P_c_ft;
  349. P_c_n_ft = P_c - P_c_ft;
  350. P_n_c_n_ft  = P_n_ft - P_c_n_ft;
  352. wordnode.m_pCataWeight[nCataCount]=0;
  353. // feature selection model
  354. if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_XXMode)
  355. {
  356. // Right half of IG
  357. if ( (fabs(P_c * P_n_ft) > dZero) && ( fabs(P_c_n_ft) > dZero) ) 
  358. {
  359. wordnode.m_pCataWeight[nCataCount]+=P_c_n_ft * log( P_c_n_ft/(P_c * P_n_ft) );
  360. }
  361. }
  362. else if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_MIMode)
  363. {
  364. // Mutual Informaiton feature selection
  365. if ( (fabs(P_c * P_ft) > dZero) && (fabs(P_c_ft) > dZero) ) 
  366. {
  367. wordnode.m_pCataWeight[nCataCount]+= P_c * log( P_c_ft/(P_c * P_ft) );
  368. }
  369. }
  370. else if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_CEMode)
  371. {
  372. // Cross Entropy for text feature selection
  373. if ( (fabs(P_c * P_ft) > dZero) && (fabs(P_c_ft) > dZero) ) 
  374. {
  375. wordnode.m_pCataWeight[nCataCount]+= P_c_ft * log( P_c_ft/(P_c * P_ft) );
  376. }
  377. }
  378. else if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_X2Mode)
  379. {
  380. // X^2 Statistics feature selection
  381. if ( (fabs(P_n_c * P_ft * P_n_ft) > dZero) ) 
  382. {
  383. wordnode.m_pCataWeight[nCataCount]+= (P_c_ft * P_n_c_n_ft - P_n_c_ft * P_c_n_ft) * (P_c_ft * P_n_c_n_ft - P_n_c_ft * P_c_n_ft) / ( P_ft * P_n_c * P_n_ft);
  384. }
  385. }
  386. else if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_WEMode)
  387. {
  388. // Weight of Evielence for text feature selection
  389. double odds_c_ft;
  390. double odds_c;
  391. double P_c_inv_ft=P_c_ft/P_ft;
  393. if( fabs(P_c_inv_ft) < dZero )
  394. odds_c_ft = 1.0 / ( N * N -1);
  395. else if ( fabs(P_c_inv_ft-1) < dZero )
  396. odds_c_ft = N * N -1;
  397. else
  398. odds_c_ft = P_c_inv_ft / (1.0 - P_c_inv_ft);
  400. if( fabs(P_c) < dZero )
  401. odds_c = 1.0 / ( N * N -1);
  402. else if ( fabs(P_c-1) < dZero )
  403. odds_c = N * N -1;
  404. else
  405. odds_c = P_c / (1.0 - P_c);
  406. if( fabs(odds_c) > dZero && fabs(odds_c_ft) > dZero )
  407. {
  408. wordnode.m_pCataWeight[nCataCount]+= P_c * P_ft * fabs( log(odds_c_ft / odds_c) );
  409. }
  410. }
  411. else //if(m_paramClassifier.m_nFSMode==CClassifierParam::nFS_IGMode) 
  412. {
  413. // Information gain feature selection
  414. if ( (fabs(P_c * P_n_ft) > dZero) && ( fabs(P_c_n_ft) > dZero) ) 
  415. {
  416. wordnode.m_pCataWeight[nCataCount]+=P_c_n_ft * log( P_c_n_ft/(P_c * P_n_ft) );
  417. }
  418. if ( (fabs(P_c * P_ft) > dZero) && (fabs(P_c_ft) > dZero) ) 
  419. {
  420. wordnode.m_pCataWeight[nCataCount]+= P_c_ft * log( P_c_ft/(P_c * P_ft) );
  421. }
  422. }
  423. wordnode.m_dWeight+=wordnode.m_pCataWeight[nCataCount];
  424. wordnode.m_pCataWeightPro[nCataCount] = 1.0 * (N_c_ft+1)/(2+N);//词str属于类别nCataCount的概率
  425. /*
  426. CString strtemp;
  427. strtemp.Format("第%d个类中，词的权重是%lf",nCataCount,wordnode.m_pCataWeight[nCataCount]);
  428. CMessage::PrintInfo(strtemp);
  429. */
  430. nCataCount++;
  431. }
  432. ASSERT(nCataCount==nTotalCata);
  433. }
  434. CMessage::PrintStatusInfo("");
  435. }
  437. //计算每一篇训练文档向量的每一维的权重
  438. void CClassifier::ComputeWeight(bool bMult)
  439. {
  440. long lWordNum=m_lstTrainWordList.GetCount();
  441. if(m_lstTrainWordList.GetCount()<=0) return;
  442. long lDocNum=m_lstTrainCatalogList.GetDocNum();
  443. if(lDocNum<=0) return;
  444. m_lstTrainWordList.ComputeWeight(lDocNum,bMult);
  446. double sum=0.0;
  447. int i=0;
  448. POSITION pos_cata = m_lstTrainCatalogList.GetFirstPosition();
  449. while(pos_cata != NULL)  // for each catalog 
  450. {
  451. //取类列表中的每一个类
  452. CCatalogNode& cataNode = m_lstTrainCatalogList.GetNext(pos_cata);
  453. POSITION pos_doc  = cataNode.GetFirstPosition();
  454. while(pos_doc!=NULL)
  455. {
  456. CDocNode& docNode=cataNode.GetNext(pos_doc);
  458. sum=0.0;
  459. for(i=0;i<docNode.m_nAllocLen;i++)
  460. {
  461. docNode.m_sWeightSet[i].s_dWeight*=docNode.m_sWeightSet[i].s_tfi;
  462. sum+=(docNode.m_sWeightSet[i].s_dWeight*docNode.m_sWeightSet[i].s_dWeight);
  463. }
  464. sum=sqrt(sum);
  465. for(i=0;i<docNode.m_nAllocLen;i++)
  466. docNode.m_sWeightSet[i].s_dWeight/=sum;
  468. CMessage::PrintStatusInfo("计算文档"+docNode.m_strDocName+"向量每一维的权重");
  469. }
  470. }
  471. }
  473. void CClassifier::QuickSort(sSortType *psData, int iLo,int iHi)
  474. {
  475.     int Lo, Hi;
  476. double Mid;
  477. sSortType t;
  478.     Lo = iLo;
  479.     Hi = iHi;
  480.     Mid = psData[(Lo + Hi)/2].dWeight;
  481.     do
  482. {
  483. while(psData[Lo].dWeight > Mid) Lo++;
  484. while(psData[Hi].dWeight < Mid) Hi--;
  485. if(Lo <= Hi)
  486. {
  487. t = psData[Lo];
  488. psData[Lo]=psData[Hi];
  489. psData[Hi]=t;
  490. Lo++;
  491. Hi--;
  492. }
  493. }while(Hi>Lo);
  494.     if(Hi > iLo) QuickSort(psData, iLo, Hi);
  495.     if(Lo < iHi) QuickSort(psData, Lo, iHi);
  496. }
  498. void CClassifier::Sort(sSortType *psData,int nSize)
  499. {
  500. QuickSort(psData,0,nSize);
  501. }
  504. // Give m_lstWordList & m_lstTrainCatalogList
  505. // Output the present vector of each document;
  506. // bFlag=false 层次分类的时候使用
  507. void CClassifier::GenModel()
  508. {
  509. CDocNode::AllocTempBuffer(m_lstTrainWordList.GetCount());
  510. POSITION pos_cata = m_lstTrainCatalogList.GetFirstPosition();
  511. while(pos_cata != NULL)  // for each catalog 
  512. {
  513. //取类列表中的每一个类
  514. CCatalogNode& cataNode = m_lstTrainCatalogList.GetNext(pos_cata);
  515. POSITION pos_doc  = cataNode.GetFirstPosition();
  516. while(pos_doc!=NULL)
  517. {
  518. CDocNode& docNode=cataNode.GetNext(pos_doc);
  519. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  520. docNode.ScanChineseWithDict(cataNode.m_strDirName.GetBuffer(0),m_lstTrainWordList);
  521. else
  522. docNode.ScanEnglishWithDict(cataNode.m_strDirName.GetBuffer(0),m_lstTrainWordList,m_paramClassifier.m_bStem);
  523. docNode.GenDocVector();
  524. CMessage::PrintStatusInfo("生成文档"+docNode.m_strDocName+"的文档向量");
  525. }
  526. }
  527. CDocNode::DeallocTempBuffer();
  528. }
  531. // generate original dictionary (the largest one)
  532. // form train files
  533. bool CClassifier::GenDic()
  534. {
  535. m_lstWordList.InitWordList();
  536. CTime startTime;
  537. CTimeSpan totalTime;
  539. startTime=CTime::GetCurrentTime();
  540. CMessage::PrintInfo(_T("分词程序初始化，请稍候..."));
  541. if(!g_wordSeg.InitWorgSegment(theApp.m_strPath.GetBuffer(0),m_paramClassifier.m_nLanguageType))
  542. {
  543. CMessage::PrintError(_T("分词程序初始化失败!"));
  544. return false;
  545. }
  546. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  547. g_wordSeg.SetSegSetting(CWordSegment::uPlace);
  548. totalTime=CTime::GetCurrentTime()-startTime;
  549. CMessage::PrintInfo(_T("分词程序初始化结束，耗时")+totalTime.Format("%H:%M:%S"));
  552. startTime=CTime::GetCurrentTime();
  553. CMessage::PrintInfo(_T("开始扫描训练文档，请稍候..."));
  554. if(m_lstTrainCatalogList.BuildLib(m_paramClassifier.m_txtTrainDir)<=0)
  555. {
  556. CMessage::PrintError("训练文档的总数为0!");
  557. return false;
  558. }
  560. CString strFileName;
  561. POSITION pos_cata=m_lstTrainCatalogList.GetFirstPosition();
  562. int nCount,nCataNum;
  563. nCataNum=m_lstTrainCatalogList.GetCataNum();
  564. while(pos_cata!=NULL)
  565. {
  566. CCatalogNode& catalognode=m_lstTrainCatalogList.GetNext(pos_cata);
  567. POSITION pos_doc=catalognode.GetFirstPosition();
  568. while(pos_doc!=NULL)
  569. {
  570. CDocNode& docnode=catalognode.GetNext(pos_doc);
  571. CMessage::PrintStatusInfo(_T("扫描文档")+docnode.m_strDocName);
  573. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  574. nCount=docnode.ScanChinese(catalognode.m_strDirName.GetBuffer(0),
  575. m_lstWordList,nCataNum,catalognode.m_idxCata);
  576. else
  577. nCount=docnode.ScanEnglish(catalognode.m_strDirName.GetBuffer(0),
  578. m_lstWordList,nCataNum,catalognode.m_idxCata,
  579. m_paramClassifier.m_bStem);
  580. if(nCount==0)
  581. {
  582. CMessage::PrintError("文件"+catalognode.m_strDirName+"\"+docnode.m_strDocName+"无内容!");
  583. continue;
  584. }
  585. else if(nCount<0)
  586. {
  587. CMessage::PrintError("文件"+catalognode.m_strDirName+"\"+docnode.m_strDocName+"无法打开!");
  588. continue;
  589. }
  590. catalognode.m_lTotalWordNum+=nCount;// information collection point
  591. }
  592. }
  593. g_wordSeg.FreeWordSegment();
  594. totalTime=CTime::GetCurrentTime()-startTime;
  595. CMessage::PrintInfo(_T("扫描训练文档结束，耗时")+totalTime.Format("%H:%M:%S"));
  596. return true;
  597. }
  599. void CClassifier::InitTrain()
  600. {
  601. m_lstTrainWordList.InitWordList();
  602. m_lstTrainCatalogList.InitCatalogList();
  603. m_lstWordList.InitWordList();
  604. }
  606. //参数nType用来决定分类模型的类别,nType=0代表KNN分类器,nType=1代表SVM分类器
  607. bool CClassifier::WriteModel(CString strFileName, int nType)
  608. {
  609. CFile fOut;
  610. if( !fOut.Open(strFileName,CFile::modeCreate | CFile::modeWrite) )
  611. {
  612. CMessage::PrintError("无法创建文件"+strFileName+"!");
  613. return false;
  614. }
  616. CArchive ar(&fOut,CArchive::store);
  617. if(nType==0)
  618. {
  619. m_lstTrainWordList.DumpToFile(m_paramClassifier.m_txtResultDir+"\features.dat");
  620. m_lstTrainWordList.DumpWordList(m_paramClassifier.m_txtResultDir+"\features.txt");
  621. m_lstTrainCatalogList.DumpToFile(m_paramClassifier.m_txtResultDir+"\train.dat");
  622. m_lstTrainCatalogList.DumpDocList(m_paramClassifier.m_txtResultDir+"\train.txt");
  623. m_paramClassifier.DumpToFile(m_paramClassifier.m_txtResultDir+"\params.dat");
  625. ar<<dwModelFileID;
  626. ar<<CString("params.dat");
  627. ar<<CString("features.dat");
  628. ar<<CString("train.dat");
  629. }
  630. else if(nType==1)
  631. {
  632. m_lstTrainWordList.DumpToFile(m_paramClassifier.m_txtResultDir+"\features.dat");
  633. m_lstTrainWordList.DumpWordList(m_paramClassifier.m_txtResultDir+"\features.txt");
  634. m_lstTrainCatalogList.DumpToFile(m_paramClassifier.m_txtResultDir+"\train.dat",1);
  635. m_lstTrainCatalogList.DumpDocList(m_paramClassifier.m_txtResultDir+"\train.txt");
  636. m_paramClassifier.DumpToFile(m_paramClassifier.m_txtResultDir+"\params.dat");
  638. m_theSVM.com_param.classifier_num=m_lstTrainCatalogList.GetCataNum();
  639. m_theSVM.com_param.trainfile="train.txt";
  640. m_theSVM.com_param.resultpath=m_paramClassifier.m_txtResultDir;
  641. m_theSVM.com_param.DumpToFile(m_paramClassifier.m_txtResultDir+"\svmparams.dat");
  643. ar<<dwModelFileID;
  644. ar<<CString("params.dat");
  645. ar<<CString("features.dat");
  646. ar<<CString("train.dat");
  647. ar<<CString("svmparams.dat");
  648. }
  649. else if(nType==2)
  650. {
  651. m_lstTrainWordList.DumpToFile(m_paramClassifier.m_txtResultDir+"\features.dat");
  652. m_lstTrainWordList.DumpWordList(m_paramClassifier.m_txtResultDir+"\features.txt");
  653. m_lstTrainWordList.DumpWordProList(m_paramClassifier.m_txtResultDir+"\WordPro.txt",m_lstTrainCatalogList.GetCataNum());
  655. m_lstTrainCatalogList.DumpToFile(m_paramClassifier.m_txtResultDir+"\train.dat");
  656. m_lstTrainCatalogList.DumpDocList(m_paramClassifier.m_txtResultDir+"\train.txt");
  657. m_paramClassifier.DumpToFile(m_paramClassifier.m_txtResultDir+"\params.dat");
  659. ar<<dwModelFileID;
  660. ar<<CString("params.dat");
  661. ar<<CString("features.dat");
  662. ar<<CString("train.dat");
  663. ar<<CString("WordPro.txt");
  664. }
  665. ar.Close();
  666. fOut.Close(); 
  667. return true;
  668. }
  670. bool CClassifier::OpenModel(CString strFileName)
  671. {
  672. CFile fIn;
  673. if(!fIn.Open(strFileName,CFile::modeRead))
  674. {
  675. CMessage::PrintError("无法打开文件"+strFileName+"!") ;
  676. return false;
  677. }
  678. CTime startTime=CTime::GetCurrentTime();
  679. CMessage::PrintInfo(_T("正在打开分类模型文件，请稍候..."));
  682. CArchive ar(&fIn,CArchive::load);
  683. CString str,strPath;
  684. DWORD dwFileID;
  686. //读入文件格式标识符
  687. strPath=strFileName.Left(strFileName.ReverseFind('\'));
  688. ar>>dwFileID;
  689. if(dwFileID!=dwModelFileID)
  690. {
  691. ar.Close();
  692. fIn.Close();
  693. CMessage::PrintError("分类模型文件的格式不正确!");
  694. return false;
  695. }
  697. ar>>str;
  699. if(!m_paramClassifier.GetFromFile(strPath+"\"+str))
  700. {
  701. CMessage::PrintError(_T("无法打开训练参数文件"+str+"!"));
  702. return false;
  703. }
  704. m_paramClassifier.m_txtResultDir=strPath;
  706. if(m_paramClassifier.m_nClassifierType==0)
  707. {
  708. ar>>str;
  709. m_lstTrainWordList.InitWordList();
  710. if(!m_lstTrainWordList.GetFromFile(strPath+"\"+str))
  711. {
  712. CMessage::PrintError(_T("无法打开特征类表文件"+str+"!"));
  713. return false;
  714. }
  715. ar>>str;
  716. m_lstTrainCatalogList.InitCatalogList();
  717. if(!m_lstTrainCatalogList.GetFromFile(strPath+"\"+str))
  718. {
  719. CMessage::PrintError(_T("无法打开训练文档列表文件"+str+"!"));
  720. return false;
  721. }
  722. }
  723. else if(m_paramClassifier.m_nClassifierType==1)
  724. {
  725. ar>>str;
  726. m_lstTrainWordList.InitWordList();
  727. if(!m_lstTrainWordList.GetFromFile(strPath+"\"+str))
  728. {
  729. CMessage::PrintError(_T("无法打开特征类表文件"+str+"!"));
  730. return false;
  731. }
  732. //对于SVM分类起来说m_lstTrainCatalogList其实没用
  733. //此处读入它只是为了在CLeftViw中显示某些统计信息时使用
  734. ar>>str;
  735. m_lstTrainCatalogList.InitCatalogList();
  736. if(!m_lstTrainCatalogList.GetFromFile(strPath+"\"+str))
  737. {
  738. CMessage::PrintError(_T("无法打开训练文档列表文件"+str+"!"));
  739. return false;
  740. }
  741. ar>>str;
  742. if(!m_theSVM.com_param.GetFromFile(strPath+"\"+str))
  743. {
  744. CMessage::PrintError(_T("无法打开SVM训练参数文件"+str+"!"));
  745. return false;
  746. }
  747. m_theSVM.com_param.trainfile=strPath+"\train.txt";
  748. m_theSVM.com_param.resultpath=strPath;
  749. }
  750. else if(m_paramClassifier.m_nClassifierType==2)
  751. {
  752. ar>>str;
  753. m_lstTrainWordList.InitWordList();
  754. if(!m_lstTrainWordList.GetFromFile(strPath+"\"+str))
  755. {
  756. CMessage::PrintError(_T("无法打开特征类表文件"+str+"!"));
  757. return false;
  758. }
  759. ar>>str;
  760. m_lstTrainCatalogList.InitCatalogList();
  761. if(!m_lstTrainCatalogList.GetFromFile(strPath+"\"+str))
  762. {
  763. CMessage::PrintError(_T("无法打开训练文档列表文件"+str+"!"));
  764. return false;
  765. }
  766. ar>>str;
  767. if(!m_lstTrainWordList.GetProFromFile(strPath+"\"+str))
  768. {
  769. CMessage::PrintError(_T("无法打开特征词类属概率文件"+str+"!"));
  770. return false;
  771. }
  772. }
  773. ar.Close();
  774. fIn.Close();
  775. Prepare();
  776. CTimeSpan totalTime=CTime::GetCurrentTime()-startTime;
  777. CMessage::PrintInfo(_T("分类模型文件已经打开，耗时")+totalTime.Format("%H:%M:%S")+"rn");
  779. str.Empty();
  780. m_paramClassifier.GetParamString(str);
  781. CMessage::PrintInfo(str);
  782. return true;
  783. }
  785. bool CClassifier::Classify()
  786. {
  787. m_lstTrainCatalogList.DumpCataList(m_paramClassifier.m_strResultDir+"\classes.txt");
  788. CTime startTime;
  789. CTimeSpan totalTime;
  790. startTime=CTime::GetCurrentTime();
  791. CMessage::PrintInfo(_T("正在扫描测试文档，请稍候..."));
  792. if(m_paramClassifier.m_bEvaluation)
  793. {
  794. //vBuildLib方法中已经清空了g_lstTestCatalogList，所以此处无需再对其初始化
  795. m_lstTestCatalogList.BuildLib(m_paramClassifier.m_strTestDir);
  796. if(!m_lstTestCatalogList.BuildCatalogID(m_lstTrainCatalogList))
  797. {
  798. CMessage::PrintError("测试文件中包含有无法识别的类别!");
  799. return false;
  800. }
  801. }
  802. else
  803. {
  804. m_lstTestCatalogList.InitCatalogList();
  805. CCatalogNode catalognode;
  806. catalognode.m_strDirName=m_paramClassifier.m_strTestDir;
  807. catalognode.m_strCatalogName="测试文档";
  808. catalognode.m_idxCata=-1;
  809. POSITION posTemp=m_lstTestCatalogList.AddCata(catalognode);
  810. CCatalogNode& cataTemp=m_lstTestCatalogList.GetAt(posTemp);
  811. cataTemp.SetStartDocID(0);
  812. cataTemp.ScanDirectory(m_paramClassifier.m_strTestDir);
  813. }
  814. if(m_lstTestCatalogList.GetDocNum()<=0)
  815. {
  816. CMessage::PrintError("测试文件总数为0!rn如果不需要对分类结果进行评价时,分类文档必须在"分类文档目录"下,而不是它的子目录下!");
  817. return false;
  818. }
  819. totalTime=CTime::GetCurrentTime()-startTime;
  820. CMessage::PrintInfo(_T("扫描测试文档结束，耗时")+totalTime.Format("%H:%M:%S"));
  822. startTime=CTime::GetCurrentTime();
  823. CMessage::PrintInfo(_T("正在对测试文档进行分类，请稍候..."));
  824. long lCorrect=0,lUnknown=0;
  825. lUnknown=Classify(m_lstTestCatalogList);
  828. lCorrect=SaveResults(m_lstTestCatalogList,m_paramClassifier.m_strResultDir+"\results.txt");
  829. long lTotalNum=m_lstTestCatalogList.GetDocNum()-lUnknown;
  830. CString str;
  831. totalTime=CTime::GetCurrentTime()-startTime;
  832. CMessage::PrintInfo(_T("测试文档分类结束，耗时")+totalTime.Format("%H:%M:%S"));
  833. if (lUnknown>0) 
  834. {
  835. str.Format("无法分类的文档数%d:",lUnknown);
  836. CMessage::PrintInfo(str);
  837. }
  838. if(m_paramClassifier.m_bEvaluation&&lTotalNum>0&&lCorrect>0)
  839. str.Format("测试文档总数:%d,准确率:%f",m_lstTestCatalogList.GetDocNum(),(float)(lCorrect)/(float)(lTotalNum));
  840. else
  841. str.Format("测试文档总数:%d",m_lstTestCatalogList.GetDocNum());
  842. CMessage::PrintInfo(str);
  843. return true;
  844. }
  846. //对Smart格式的文档进行分类
  847. bool CClassifier::ClassifySmart()
  848. {
  849. m_lstTrainCatalogList.DumpCataList(m_paramClassifier.m_strResultDir+"\classes.txt");
  850. m_lstTestCatalogList.InitCatalogList();
  851. CCatalogNode catalognode;
  852. catalognode.m_strDirName=m_paramClassifier.m_strTestDir;
  853. catalognode.m_strCatalogName="测试文档";
  854. catalognode.m_idxCata=-1;
  855. POSITION posTemp=m_lstTestCatalogList.AddCata(catalognode);
  856. CCatalogNode& cataTemp=m_lstTestCatalogList.GetAt(posTemp);
  858. FILE *stream1,*stream2;
  859. if( (stream1 = fopen( m_paramClassifier.m_strTestDir, "r" )) == NULL )
  860. {
  861. CMessage::PrintError("无法打开文件"+m_paramClassifier.m_strTestDir+"!");
  862. return false;
  863. }
  865. //如果是SVM分类器,则需要先将所有测试文档转换为向量,保存到文件test.dat
  866. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM)
  867. {
  868. m_theSVM.com_param.classifyfile=m_paramClassifier.m_strResultDir+"\test.dat";
  869. if((stream2=fopen(m_theSVM.com_param.classifyfile,"w"))==NULL)
  870. {
  871. CMessage::PrintError("无法创建测试文档向量文件"+m_theSVM.com_param.classifyfile+"!");
  872. return false;
  873. }
  874. }
  876. CTime startTime;
  877. CTimeSpan totalTime;
  878. startTime=CTime::GetCurrentTime();
  879. CMessage::PrintInfo(_T("正在对测试文档进行分类，请稍候..."));
  881. char fname[10],type[1024],line[4096],content[100*1024];
  882. //falg=1 下一行的内容是文档的类别
  883. //flag=2 下一行的内容是文档的标题
  884. //flag=3 下一行的内容是文档的内容
  885. int flag=0,nCount,len,i;
  886. long lUnknown=0,lDocNum=0;
  887. CStringArray typeArray;
  888. CString strFileName,strCopyFile;
  889. bool bTitle=false; //是否已经读出标题
  890. double dThreshold=(double)m_paramClassifier.m_dThreshold/100.0;
  891. int nWordNum=m_lstTrainWordList.GetCount();
  892. while(!feof(stream1))
  893. {
  894. if(fgets(line,4096,stream1)==NULL) continue;
  895. if(line[0]=='.')
  896. {
  897. if(flag==3)
  898. {
  899. CDocNode doc;
  900. posTemp=cataTemp.AddDoc(doc);
  901. CDocNode& docnode=cataTemp.GetAt(posTemp);
  902. docnode.m_strDocName=fname;
  903. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_KNN)
  904. {
  905. nCount=KNNCategory(content,docnode,false);
  906. }
  907. else
  908. {
  909. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  910. nCount=docnode.ScanChineseStringWithDict(content,m_lstTrainWordList)-1;
  911. else
  912. nCount=docnode.ScanEnglishStringWithDict(content,m_lstTrainWordList,
  913. m_paramClassifier.m_bStem)-1;
  915. fprintf(stream2,"%d",1);
  916. for(i=0;i<nWordNum;i++)
  917. {
  918. if(docnode.m_pTemp[i].s_tfi!=0) 
  919. fprintf(stream2," %d:%f",i+1,docnode.m_pTemp[i].s_dWeight);
  920. }
  921. fprintf(stream2,"n");
  922. }
  923. if(m_paramClassifier.m_bEvaluation) typeArray.Add(type);
  924. if(nCount<0) 
  925. {
  926. CMessage::PrintError("无法识别文档"+docnode.m_strDocName+"的类别!");
  927. lUnknown++;
  928. }
  929. CMessage::PrintStatusInfo(_T("扫描文档")+docnode.m_strDocName);
  930. flag=0;
  931. bTitle=false;
  932. fname[0]=0;
  933. type[0]=0;
  934. content[0]=0;
  935. lDocNum++;
  936. }
  937. switch(line[1])
  938. {
  939. case 'I':
  940. strcpy(fname,line+3);
  941. len=strlen(fname);
  942. if(fname[len-1]='r') fname[len-1]='';
  943. break;
  944. case 'C':
  945. flag=1;
  946. break;
  947. case 'T':
  948. flag=2;
  949. break;
  950. case 'W':
  951. flag=3;
  952. break;
  953. }
  954. }
  955. else
  956. {
  957. switch(flag)
  958. {
  959. case 1:
  960. strcpy(type,line);
  961. break;
  962. case 2:
  963. if(!bTitle)
  964. {
  965. strcpy(content,line);
  966. bTitle=true;
  967. }
  968. else
  969. strcat(content,line);
  970. break;
  971. case 3:
  972. strcat(content,line);
  973. break;
  974. }
  975. }
  976. }
  977. fclose(stream1);
  978. CMessage::PrintStatusInfo("");
  979. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM) 
  980. {
  981. fclose(stream2);
  982. startTime=CTime::GetCurrentTime();
  983. CMessage::PrintInfo(_T("正在使用SVM分类器对文档进行分类,请稍候..."));
  984. m_theSVM.com_param.classifyfile=m_paramClassifier.m_strResultDir+"\test.dat";
  985. SVMClassifyVectorFile(m_theSVM.com_param.classifyfile);
  986. totalTime=CTime::GetCurrentTime()-startTime;
  987. CMessage::PrintInfo(_T("SVM分类过程结束，耗时")+totalTime.Format("%H:%M:%S"));
  988. }
  990. long lCorrect=SaveResults(m_lstTestCatalogList,m_paramClassifier.m_strResultDir+"\results.txt",&typeArray);
  991. long lTotalNum=m_lstTestCatalogList.GetDocNum()-lUnknown;
  992. CString str;
  993. totalTime=CTime::GetCurrentTime()-startTime;
  994. CMessage::PrintInfo(_T("测试文档分类结束，耗时")+totalTime.Format("%H:%M:%S"));
  995. if (lUnknown>0) 
  996. {
  997. str.Format("无法分类的文档数%d:",lUnknown);
  998. CMessage::PrintInfo(str);
  999. }
  1000. if(m_paramClassifier.m_bEvaluation&&lTotalNum>0&&lCorrect>0)
  1001. str.Format("测试文档总数:%d,准确率:%f",m_lstTestCatalogList.GetDocNum(),(float)(lCorrect)/(float)(lTotalNum));
  1002. else
  1003. str.Format("测试文档总数:%d",m_lstTestCatalogList.GetDocNum());
  1004. CMessage::PrintInfo(str);
  1005. return true;
  1006. }
  1008. //对文档进行分类，计算文档和每个类别的相似度，返回值为类别无法识别的文档总数
  1009. long CClassifier::SVMClassify(CCatalogList &cataList)
  1010. {
  1011. long lUnknown=0;
  1012. FILE *stream;
  1013. m_theSVM.com_param.classifyfile=m_paramClassifier.m_strResultDir+"\test.dat";
  1014. if((stream=fopen(m_theSVM.com_param.classifyfile,"w"))==NULL)
  1015. {
  1016. CMessage::PrintError("无法创建测试文档向量文件"+m_theSVM.com_param.classifyfile+"!");
  1017. return 0;
  1018. }
  1020. CTime startTime;
  1021. CTimeSpan totalTime;
  1022. CString str;
  1023. int nCount=0;
  1024. long lWordNum=m_lstTrainWordList.GetCount();
  1025. startTime=CTime::GetCurrentTime();
  1026. CMessage::PrintInfo(_T("正在生成测试文档的向量形式，请稍候..."));
  1027. POSITION pos_cata=cataList.GetFirstPosition();
  1028. while(pos_cata!=NULL)
  1029. {
  1030. CCatalogNode& catalognode=cataList.GetNext(pos_cata);
  1031. char *path=catalognode.m_strDirName.GetBuffer(0);
  1032. POSITION pos_doc=catalognode.GetFirstPosition();
  1033. while(pos_doc!=NULL)
  1034. {
  1035. CDocNode& docnode=catalognode.GetNext(pos_doc);
  1036. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1037. nCount=docnode.ScanChineseWithDict(path,m_lstTrainWordList);
  1038. else
  1039. nCount=docnode.ScanEnglishWithDict(path,m_lstTrainWordList,
  1040. m_paramClassifier.m_bStem);
  1042. fprintf(stream,"%d",catalognode.m_idxCata+1);
  1043. for(int i=0;i<lWordNum;i++)
  1044. {
  1045. if(docnode.m_pTemp[i].s_tfi!=0) 
  1046. fprintf(stream," %d:%f",i+1,docnode.m_pTemp[i].s_dWeight);
  1047. }
  1048. fprintf(stream,"n");
  1049. CMessage::PrintStatusInfo(_T("扫描文档")+docnode.m_strDocName);
  1051. if(nCount<0)
  1052. {
  1053. str="无法识别文档";
  1054. str+=catalognode.m_strDirName;
  1055. str+="\"+docnode.m_strDocName+"的类别!";
  1056. lUnknown++;
  1057. CMessage::PrintError(str);
  1058. }
  1059. }
  1060. }
  1061. CMessage::PrintStatusInfo(_T(""));
  1062. fclose(stream);
  1063. totalTime=CTime::GetCurrentTime()-startTime;
  1064. CMessage::PrintInfo(_T("测试文档的向量生成结束，耗时")+totalTime.Format("%H:%M:%S"));
  1066. startTime=CTime::GetCurrentTime();
  1067. CMessage::PrintInfo(_T("正在使用SVM分类器对文档进行分类,请稍候..."));
  1068. //为每篇文档和各个类别的相似读数组分配内存
  1069. pos_cata=cataList.GetFirstPosition();
  1070. while(pos_cata!=NULL)
  1071. {
  1072. CCatalogNode& catalognode=cataList.GetNext(pos_cata);
  1073. POSITION pos_doc=catalognode.GetFirstPosition();
  1074. while(pos_doc!=NULL)
  1075. {
  1076. CDocNode& docnode=catalognode.GetNext(pos_doc);
  1077. docnode.AllocResultsBuffer(m_nClassNum);
  1078. }
  1079. }
  1080. SVMClassifyVectorFile(m_theSVM.com_param.classifyfile);
  1081. CMessage::PrintStatusInfo(_T(""));
  1083. totalTime=CTime::GetCurrentTime()-startTime;
  1084. CMessage::PrintInfo(_T("SVM分类过程结束，耗时")+totalTime.Format("%H:%M:%S"));
  1085. return lUnknown;
  1086. }
  1088. //使用KNN方法对文档进行分类，计算文档和每个类别的相似度
  1089. //返回值为类别无法识别的文档总数
  1090. long CClassifier::KNNClassify(CCatalogList& cataList,int nCmpType)
  1091. {
  1092. long docID=0,lUnknown=0;
  1093. CString str;
  1094. POSITION pos_cata=cataList.GetFirstPosition();
  1095. while(pos_cata!=NULL)
  1096. {
  1097. CCatalogNode& cataNode=cataList.GetNext(pos_cata);
  1098. POSITION pos_doc=cataNode.GetFirstPosition();
  1099. char *path=cataNode.m_strDirName.GetBuffer(0);
  1100. while(pos_doc!=NULL)
  1101. {
  1102. CDocNode& docNode=cataNode.GetNext(pos_doc);
  1103. short id=KNNCategory(path, docNode, true, nCmpType);
  1104. if(id==-1) 
  1105. {
  1106. str="无法识别文档";
  1107. str+=cataNode.m_strDirName;
  1108. str+="\"+docNode.m_strDocName+"的类别!";
  1109. CMessage::PrintError(str);
  1110. lUnknown++;
  1111. }
  1112. CMessage::PrintStatusInfo(_T("扫描文档")+docNode.m_strDocName);
  1113. }
  1114. }
  1115. return lUnknown;
  1116. }
  1118. //计算文档和每个类别的相似度，返回与文档相似度最大的类别ID
  1119. //nCmpType代表相似度的不同计算方式
  1120. short CClassifier::KNNCategory(char *pPath, CDocNode &docNode, bool bFile, int nCmpType)
  1121. {
  1122. short nCataID=-1;
  1123. if(KNNClassify(pPath,docNode,bFile,nCmpType)) nCataID=SingleCategory(docNode);
  1124. return nCataID;
  1125. }
  1127. //如果bFile为真,则参数file为文件的文件名称(包括它的路径)
  1128. short CClassifier::KNNCategory(char *file, bool bFile, int nCmpType)
  1129. {
  1130. CDocNode docNode;
  1131. short id=-1;
  1132. if(bFile)
  1133. {
  1134. char *fname=strrchr(file,'\');
  1135. if(fname==NULL) return -1;
  1136. docNode.m_strDocName=(fname+1);
  1138. char path[MAX_PATH];
  1139. strncpy(path,file,fname-file);
  1140. path[fname-file]=0;
  1141. id=KNNCategory(path,docNode,bFile,nCmpType);
  1142. }
  1143. else
  1144. id=KNNCategory(file,docNode,bFile,nCmpType);
  1145. return id;
  1146. }
  1148. //生成文档docNode的向量形式，调用方法ComputeSimRatio计算器其和每一个类别的相似度
  1149. //参数bFile为真代表pPath为docNode的路径,否则代表需要进行分类的文档的内容
  1150. //参数nCmpType代表相似度的不同计算方式
  1151. bool CClassifier::KNNClassify(char *pPath, CDocNode &docNode, bool bFile, int nCmpType)
  1152. {
  1153. int nCount=0;
  1154. if(bFile)
  1155. {
  1156. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1157. nCount=docNode.ScanChineseWithDict(pPath,m_lstTrainWordList);
  1158. else
  1159. nCount=docNode.ScanEnglishWithDict(pPath,m_lstTrainWordList,
  1160. m_paramClassifier.m_bStem);
  1161. }
  1162. else
  1163. {
  1164. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1165. nCount=docNode.ScanChineseStringWithDict(pPath,m_lstTrainWordList);
  1166. else
  1167. nCount=docNode.ScanEnglishStringWithDict(pPath,m_lstTrainWordList,
  1168. m_paramClassifier.m_bStem);
  1169. }
  1171. if((m_lDocNum>0)&&(nCount>0))
  1172. {
  1173. ComputeSimRatio(docNode,nCmpType);
  1174. return true;
  1175. }
  1176. else
  1177. return false;
  1178. }
  1180. //得到与文档docNode的相似度大于阈值dThreshold的所有类别
  1181. //如果没有大于值阈值的类别，则返回相似度最大的类别
  1182. bool CClassifier::MultiCategory(CDocNode &docNode, CArray<short,short>& aryResult, double dThreshold)
  1183. {
  1184. double *pSimRatio=docNode.m_pResults;
  1185. if(pSimRatio==NULL) return false;
  1187. double dMax=pSimRatio[0];
  1188. short nMax=0;
  1189. bool bFound=false;
  1190. aryResult.RemoveAll();
  1191. for(short i=1;i<m_nClassNum;i++)
  1192. {
  1193. if(pSimRatio[i]>dMax)
  1194. {
  1195. dMax=pSimRatio[i];
  1196. nMax=i;
  1197. }
  1198. if(pSimRatio[i]>dThreshold) 
  1199. {
  1200. aryResult.Add(i);
  1201. bFound=true;
  1202. }
  1203. }
  1204. if(!bFound) aryResult.Add(nMax);
  1205. return true;
  1206. }
  1208. //计算文档docNode和每一个类别的相似度
  1209. //nCmpType代表相似度的不同计算方式
  1210. void CClassifier::ComputeSimRatio(CDocNode &docNode,int nCmpType)
  1211. {
  1212. //计算文档与训练集中每一篇文档的相似度
  1213. int i;
  1214. long k;
  1215. for(i=0;i<m_lDocNum;i++)
  1216. {
  1217. m_pSimilarityRatio[i].dWeight=m_pDocs[i].pDocNode->ComputeSimilarityRatio();
  1218. m_pSimilarityRatio[i].lDocID=i;
  1219. }
  1220. //将测试文档与训练文档集中文档的相似度进行降序排序
  1221. Sort(m_pSimilarityRatio,m_lDocNum-1);
  1222. docNode.AllocResultsBuffer(m_nClassNum);
  1223. double *pSimRatio=docNode.m_pResults;
  1224. for(i=0;i<m_nClassNum;i++) pSimRatio[i]=0;
  1225. if(nCmpType<=0)
  1226. {
  1227. //计算出测试文档的k近邻在每个类别中的数目
  1228. for(i=0;i<m_paramClassifier.m_nKNN;i++)
  1229. {
  1230. k=m_pSimilarityRatio[i].lDocID;
  1231. k=m_pDocs[k].nCataID;
  1232. pSimRatio[k]+=1;
  1233. }
  1234. //按照"测试文档的k近邻在某个类别中的数目/k"得到测试文档和这个类别的相似度
  1235. for(i=0;i<m_nClassNum;i++)
  1236. pSimRatio[i]/=m_paramClassifier.m_nKNN;
  1237. }
  1238. else if(nCmpType==1)
  1239. {
  1240. for(i=0;i<m_paramClassifier.m_nKNN;i++)
  1241. {
  1242. k=m_pSimilarityRatio[i].lDocID;
  1243. k=m_pDocs[k].nCataID;
  1244. pSimRatio[k]+=m_pSimilarityRatio[i].dWeight;
  1245. }
  1246. }
  1247. }
  1249. bool CClassifier::SVMClassify(char *pPath, CDocNode &docNode, bool bFile)
  1250. {
  1251. int nCount=0;
  1252. if(bFile)
  1253. {
  1254. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1255. nCount=docNode.ScanChineseWithDict(pPath,m_lstTrainWordList);
  1256. else
  1257. nCount=docNode.ScanEnglishWithDict(pPath,m_lstTrainWordList,
  1258. m_paramClassifier.m_bStem);
  1259. }
  1260. else
  1261. {
  1262. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1263. nCount=docNode.ScanChineseStringWithDict(pPath,m_lstTrainWordList);
  1264. else
  1265. nCount=docNode.ScanEnglishStringWithDict(pPath,m_lstTrainWordList,
  1266. m_paramClassifier.m_bStem);
  1267. }
  1269. if((m_lDocNum>0)&&(nCount>0))
  1270. {
  1271. DOC doc;
  1272. CString str;
  1273. docNode.GenDocVector(doc);
  1274. docNode.AllocResultsBuffer(m_nClassNum);
  1275. for(int i=0;i<m_nClassNum;i++)
  1276. {
  1277. str.Format("%s\%s%d.mdl",m_paramClassifier.m_txtResultDir,m_paramClassifier.m_strModelFile,i+1);
  1278. theClassifier.m_theSVM.com_param.modelfile=str;
  1279. docNode.m_pResults[i]=theClassifier.m_theSVM.svm_classify(doc);
  1280. }
  1281. free(doc.words);
  1282. return true;
  1283. }
  1284. else
  1285. return false;
  1286. }
  1288. void CClassifier::Prepare()
  1289. {
  1290. CTime startTime;
  1291. CTimeSpan totalTime;
  1293. if(m_pDocs!=NULL)
  1294. {
  1295. m_lDocNum=0;
  1296. free(m_pDocs);
  1297. m_pDocs=NULL;
  1298. }
  1299. if(m_pSimilarityRatio!=NULL)
  1300. {
  1301. m_lDocNum=0;
  1302. delete[] m_pSimilarityRatio;
  1303. m_pSimilarityRatio=NULL;
  1304. }
  1305. if(m_pProbability!=NULL)
  1306. {
  1307. m_nClassNum=0;
  1308. delete[] m_pProbability;
  1309. m_pProbability=NULL;
  1310. }
  1312. m_nClassNum=m_lstTrainCatalogList.GetCataNum();
  1313. m_lDocNum=m_lstTrainCatalogList.GetDocNum();
  1314. if(m_paramClassifier.m_nKNN>m_lDocNum) m_paramClassifier.m_nKNN=m_lDocNum;
  1315. m_pSimilarityRatio=new DocWeight[m_lDocNum];
  1316. m_pProbability=new DocWeight[m_nClassNum];
  1317. m_pDocs=(DocCatalog*)malloc(sizeof(DocCatalog)*m_lDocNum);
  1318. long num=0;
  1319. POSITION pos_cata = m_lstTrainCatalogList.GetFirstPosition();
  1320. while(pos_cata != NULL)  // for each catalog 
  1321. {
  1322. CCatalogNode& catanode = m_lstTrainCatalogList.GetNext(pos_cata);
  1323. short idxCata=catanode.m_idxCata;
  1324. POSITION pos_doc  = catanode.GetFirstPosition();
  1325. while(pos_doc!=NULL)
  1326. {
  1327. CDocNode& docnode=catanode.GetNext(pos_doc);
  1328. m_pDocs[num].pDocNode=&docnode;
  1329. m_pDocs[num].nCataID=idxCata;
  1330. num++;
  1331. }
  1332. }
  1333. CDocNode::AllocTempBuffer(m_lstTrainWordList.GetCount());
  1334. }
  1336. void CClassifier::Sort(DocWeight *pData,int nSize)
  1337. {
  1338. QuickSort(pData,0,nSize);
  1339. }
  1341. void CClassifier::QuickSort(DocWeight *psData, int iLo,int iHi)
  1342. {
  1343.     int Lo, Hi;
  1344. double Mid;
  1345. DocWeight t;
  1346.     Lo = iLo;
  1347.     Hi = iHi;
  1348.     Mid = psData[(Lo + Hi)/2].dWeight;
  1349.     do
  1350. {
  1351. while(psData[Lo].dWeight > Mid) Lo++;
  1352. while(psData[Hi].dWeight < Mid) Hi--;
  1353. if(Lo <= Hi)
  1354. {
  1355. t = psData[Lo];
  1356. psData[Lo]=psData[Hi];
  1357. psData[Hi]=t;
  1358. Lo++;
  1359. Hi--;
  1360. }
  1361. }while(Hi>Lo);
  1362.     if(Hi > iLo) QuickSort(psData, iLo, Hi);
  1363.     if(Lo < iHi) QuickSort(psData, Lo, iHi);
  1364. }
  1366. //将分类结果保存到文件strFileName中,返回正确分类的文档总数
  1367. //如果分类参数中要求拷贝文件到结果类别目录，则执行拷贝操作
  1368. //参数typeArray只有在多类分类,且需要进行评价的时候才会用到
  1369. long CClassifier::SaveResults(CCatalogList &cataList, CString strFileName, CStringArray *aryType)
  1370. {
  1371. FILE *stream;
  1372. if( (stream = fopen(strFileName, "w+" )) == NULL )
  1373. {
  1374. CMessage::PrintError("无法创建分类结果文件"+strFileName+"!");
  1375. return -1;
  1376. }
  1378. CString str1,str2;
  1379. long lCorrect=0;
  1380. long docID=0;
  1381. int i;
  1382. char path[MAX_PATH];
  1383. CArray<short,short> aryResult;
  1384. CArray<short,short> aryAnswer;
  1385. double dThreshold=(double)m_paramClassifier.m_dThreshold/100.0;
  1387. POSITION pos_cata=cataList.GetFirstPosition();
  1388. while(pos_cata!=NULL)
  1389. {
  1390. CCatalogNode& cataNode=cataList.GetNext(pos_cata);
  1391. short id=cataNode.m_idxCata;
  1392. strcpy(path,cataNode.m_strDirName.GetBuffer(0));
  1393. POSITION pos_doc=cataNode.GetFirstPosition();
  1394. while(pos_doc!=NULL)
  1395. {
  1396. CDocNode& docNode=cataNode.GetNext(pos_doc);
  1397. if(docNode.m_nCataID<0) continue;
  1398. str1.Empty();
  1399. str2.Empty();
  1400. //如果是多类分类
  1401. if(m_paramClassifier.m_nClassifyType==CClassifierParam::nFT_Multi)
  1402. {
  1403. MultiCategory(docNode,aryResult,dThreshold);
  1404. //如果需要将分类结果拷贝到分类结果目录
  1405. if(m_paramClassifier.m_bCopyFiles)
  1406. {
  1407. for(i=0;i<aryResult.GetSize();i++)
  1408. {
  1409. m_lstTrainCatalogList.GetCataName(aryResult[i],str1);
  1410. str2=str2+str1+",";
  1411. if(m_paramClassifier.m_bCopyFiles)
  1412. CopyFile(docNode.m_strDocName.GetBuffer(0),path,
  1413. m_paramClassifier.m_strResultDir.GetBuffer(0),str1.GetBuffer(0));
  1414. }
  1415. str2.SetAt(str2.GetLength()-1,' ');
  1416. }
  1417. //如果需要对分类结果进行评价
  1418. if(m_paramClassifier.m_bEvaluation)
  1419. {
  1420. m_lstTrainCatalogList.GetCataIDArrayFromString(aryType->GetAt(docID).GetBuffer(0),aryAnswer);
  1421. //得到答案字符串
  1422. for(i=0;i<aryAnswer.GetSize();i++)
  1423. {
  1424. str1.Format("%d",aryAnswer[i]);
  1425. str2+=(str1+",");
  1426. }
  1427. str2.SetAt(str2.GetLength()-1,' ');
  1428. fprintf(stream,"%d %s %s",docID,docNode.m_strDocName,str2);
  1430. //得到分类结果字符串
  1431. str2.Empty();
  1432. for(i=0;i<aryResult.GetSize();i++)
  1433. {
  1434. str1.Format("%d",aryResult[i]);
  1435. str2+=(str1+",");
  1436. }
  1437. str2=str2.Left(str2.GetLength()-1);
  1438. fprintf(stream,"%sn",str2);
  1439. }
  1440. else
  1441. {
  1442. if(str2.IsEmpty())
  1443. {
  1444. for(i=0;i<aryResult.GetSize();i++)
  1445. {
  1446. m_lstTrainCatalogList.GetCataName(aryResult[i],str1);
  1447. str2=str2+str1+",";
  1448. }
  1449. str2.SetAt(str2.GetLength()-1,' ');
  1450. }
  1451. fprintf(stream,"%dt%stt%sn",docID,docNode.m_strDocName,str2);
  1452. }
  1453. }
  1454. //如果是单类分类
  1455. else
  1456. {
  1457. //如果需要将分类结果拷贝到分类结果目录
  1458. if(m_paramClassifier.m_bCopyFiles)
  1459. {
  1460. m_lstTrainCatalogList.GetCataName(docNode.m_nCataID,str1);
  1461. CopyFile(docNode.m_strDocName.GetBuffer(0),
  1462. cataNode.m_strDirName.GetBuffer(0),
  1463. m_paramClassifier.m_strResultDir.GetBuffer(0),
  1464. str1.GetBuffer(0));
  1465. }
  1466. //如果需要对分类结果进行评价
  1467. if(m_paramClassifier.m_bEvaluation)
  1468. {
  1469. if(docNode.m_nCataID==id) lCorrect++;
  1470. fprintf(stream,"%d %s %d %dn",docID,docNode.m_strDocName,
  1471. cataNode.m_idxCata,docNode.m_nCataID);
  1472. }
  1473. else
  1474. {
  1475. if(str1.IsEmpty()) m_lstTrainCatalogList.GetCataName(docNode.m_nCataID,str1);
  1476. fprintf(stream,"%dt%stt%sn",docID,docNode.m_strDocName,str1);
  1477. }
  1478. }
  1479. docID++;
  1480. }
  1481. }
  1482. fclose(stream);
  1483. return lCorrect;
  1484. }
  1486. void CClassifier::CopyFile(char *pFileName, char *pSource, char *pTarget, char *pCatalog)
  1487. {
  1488. char targetFile[MAX_PATH];
  1489. strcpy(targetFile,pTarget);
  1490. strcat(targetFile,"\");
  1491. strcat(targetFile,pCatalog);
  1492. if(_chdir(targetFile)<0)
  1493. if(_mkdir(targetFile)<0) return;
  1494. char sourceFile[MAX_PATH];
  1495. strcpy(sourceFile,pSource);
  1496. strcat(sourceFile,"\");
  1497. strcat(sourceFile,pFileName);
  1498. strcat(targetFile,"\");
  1499. strcat(targetFile,pFileName);
  1500. ::CopyFile(sourceFile,targetFile,false);
  1501. }
  1503. void CClassifier::Evaluate(CString strPath)
  1504. {
  1505. CString strFileName=strPath;
  1506. strFileName=strFileName+"\multieval.exe ";
  1507. strFileName=strFileName+theClassifier.m_paramClassifier.m_strResultDir+"\classes.txt ";
  1508. strFileName=strFileName+theClassifier.m_paramClassifier.m_strResultDir+"\results.txt";
  1509. if(WinExec(strFileName,SW_SHOWNORMAL)<32)
  1510. AfxMessageBox("分类结果评测程序不存在!");
  1511. }
  1513. short CClassifier::SingleCategory(CDocNode &docNode)
  1514. {
  1515. short nCataID=-1;
  1516. double *pSimRatio=docNode.m_pResults;
  1517. //得到文档的所属类别nMaxCatID
  1518. double dMaxNum=pSimRatio[0];
  1519. nCataID=0;
  1520. for(int i=1;i<m_nClassNum;i++)
  1521. {
  1522. if(pSimRatio[i]>dMaxNum)
  1523. {
  1524. dMaxNum=pSimRatio[i];
  1525. nCataID=i;
  1526. }
  1527. }
  1528. docNode.m_nCataID=nCataID;
  1529. return nCataID;
  1530. }
  1532. short CClassifier::SVMCategory(char *pPath, CDocNode &docNode, bool bFile)
  1533. {
  1534. short nCataID=-1;
  1535. if(SVMClassify(pPath,docNode,bFile)) nCataID=SingleCategory(docNode);
  1536. return nCataID;
  1537. }
  1539. short CClassifier::SVMCategory(char *file, bool bFile)
  1540. {
  1541. CDocNode docNode;
  1542. short id=-1;
  1543. if(bFile)
  1544. {
  1545. char *fname=strrchr(file,'\');
  1546. if(fname==NULL) return -1;
  1547. docNode.m_strDocName=(fname+1);
  1549. char path[MAX_PATH];
  1550. strncpy(path,file,fname-file);
  1551. path[fname-file]=0;
  1552. id=SVMCategory(path,docNode,bFile);
  1553. }
  1554. else
  1555. id=SVMCategory(file,docNode,bFile);
  1556. return id;
  1557. }
  1559. void CClassifier::SVMClassifyVectorFile(CString strFileName)
  1560. {
  1561. //为了计算分类结果，用来保存每个分类器分类结果的数组
  1562. CTime startTime;
  1563. CTimeSpan totalTime;
  1564. CString str;
  1565. long num=m_lstTestCatalogList.GetDocNum(),lDocNum=0;
  1566. double *fpWeight=new double[num];
  1567. POSITION pos_doc, pos_cata;
  1569. m_theSVM.com_param.classifyfile=strFileName;
  1570. for(int i=1;i<=m_nClassNum;i++)
  1571. {
  1572. memset(fpWeight,0,sizeof(double)*num);
  1573. startTime=CTime::GetCurrentTime();
  1574. str.Format("正在使用第%d个SVM分类器对文档进行分类,请稍候...",i);
  1575. CMessage::PrintInfo(str);
  1576. str.Format("%s\%s%d.mdl",m_paramClassifier.m_txtResultDir,m_paramClassifier.m_strModelFile,i);
  1577. m_theSVM.com_param.modelfile=str;
  1578. m_theSVM.svm_classify(i,fpWeight);
  1579. //将文档和当前类别的相似度赋给m_pResults[i-1]
  1580. lDocNum=0;
  1581. pos_cata=m_lstTestCatalogList.GetFirstPosition();
  1582. while(pos_cata!=NULL)
  1583. {
  1584. CCatalogNode& catalognode=m_lstTestCatalogList.GetNext(pos_cata);
  1585. pos_doc=catalognode.GetFirstPosition();
  1586. while(pos_doc!=NULL)
  1587. {
  1588. CDocNode& docnode=catalognode.GetNext(pos_doc);
  1589. docnode.AllocResultsBuffer(m_nClassNum);
  1590. docnode.m_pResults[i-1]=fpWeight[lDocNum];
  1591. lDocNum++;
  1592. }
  1593. }
  1594. totalTime=CTime::GetCurrentTime()-startTime;
  1595. str.Format("第%d个SVM分类器分类结束,耗时",i);
  1596. CMessage::PrintInfo(str+totalTime.Format("%H:%M:%S"));
  1597. }
  1598. delete[] fpWeight;
  1600. //计算和文档的相似度最大的类别
  1601. pos_cata=m_lstTestCatalogList.GetFirstPosition();
  1602. while(pos_cata!=NULL)
  1603. {
  1604. CCatalogNode& catalognode=m_lstTestCatalogList.GetNext(pos_cata);
  1605. pos_doc=catalognode.GetFirstPosition();
  1606. while(pos_doc!=NULL)
  1607. {
  1608. CDocNode& docnode=catalognode.GetNext(pos_doc);
  1609. docnode.m_nCataID=SingleCategory(docnode);
  1610. }
  1611. }
  1612. }
  1614. //计算文档docNode属于每一个类别的概率
  1615. void CClassifier::ComputePro(CDocNode &docNode)
  1616. {
  1617. //计算文档与训练集中每一类文档的概率
  1618. int i,j,l,FeaNum=0;
  1619. long k;
  1621. int N; //总的文档数;
  1622. int N_c; //C类的文档数
  1623. int N_Cata; //总类数
  1624. N = m_lstTrainCatalogList.GetDocNum();
  1626. POSITION pos_cata;
  1627. CString     strWord;
  1629. // calculate the weight of each word to all catalog
  1630. N = m_lstTrainCatalogList.GetDocNum();
  1631. N_Cata=m_lstTrainCatalogList.GetCataNum();
  1633. docNode.AllocResultsBuffer(m_nClassNum);
  1635. int nCataCount=0;
  1636. double ClassPro=0.0;
  1637. pos_cata = m_lstTrainCatalogList.GetFirstPosition();
  1639. i=m_lstTrainWordList.GetCount();
  1640. POSITION pos=m_lstTrainWordList.GetFirstPosition();
  1643. for(l=0;l<m_nClassNum;l++)
  1644. {
  1645. CCatalogNode& catanode = m_lstTrainCatalogList.GetNext(pos_cata);
  1646. N_c  = catanode.GetDocNum();
  1647. m_pProbability[l].dWeight=(1.0+N_c)/(N_Cata+N);
  1648. m_pProbability[l].lDocID=l;
  1649. }
  1651. for(j=0;j<i;j++)
  1652. {
  1653. if(docNode.m_pTemp[j].s_tfi!=0) 
  1654. {
  1655. FeaNum++;
  1656. CWordNode &WordProNode = m_lstTrainWordList.GetWordProByID(pos,j);
  1657. for(l=0;l<m_nClassNum;l++)
  1658. {
  1659. m_pProbability[l].dWeight+=WordProNode.m_pCataWeightPro[l];
  1660. // CString strtemp;
  1661. // strtemp.Format("%lf  %d",m_pProbability[s].dWeight,s);
  1662. // CMessage::PrintInfo(strtemp);
  1663. }
  1664. }
  1665. }
  1667. for(l=0;l<m_nClassNum;l++)
  1668. {
  1669. m_pProbability[l].dWeight/=FeaNum;
  1670. if(ClassPro<m_pProbability[l].dWeight)
  1671. {
  1672. ClassPro = m_pProbability[l].dWeight;
  1673. docNode.m_nCataID = l;
  1674. }
  1675. }
  1677. /*
  1678. while(pos_cata!=NULL)  // for each catalog 
  1679. {
  1680. docNode.m_pResults[nCataCount]=0;
  1681. CCatalogNode& catanode = m_lstTrainCatalogList.GetNext(pos_cata);
  1682. N_c  = catanode.GetDocNum();
  1684. m_pProbability[nCataCount].dWeight=(1.0+N_c)/(N_Cata+N);
  1685. m_pProbability[nCataCount].lDocID=nCataCount;
  1687. // for(int i=0;i<lWordNum;i++)
  1688. // {
  1689. // if(docnode.m_pTemp[i].s_tfi!=0) 
  1690. // fprintf(stream," %d:%f",i+1,docnode.m_pTemp[i].s_dWeight);
  1691. // }
  1693. // m_pProbability[nCataCount].dWeight+=docNode.ComputeProbability(m_lstTrainWordList,nCataCount);
  1694. // CString strttemp;
  1695. // strttemp.Format("%lf",m_pProbability[nCataCount].dWeight);
  1696. // CMessage::PrintInfo(strttemp);
  1697. POSITION pos=m_lstTrainWordList.GetFirstPosition();
  1698. for(j=0;j<i;j++)
  1699. {
  1700. if(docNode.m_pTemp[j].s_tfi!=0) 
  1701. {
  1702. m_pProbability[nCataCount].dWeight+=m_lstTrainWordList.GetWordProByID(pos,j,nCataCount);
  1703. // CString str = m_lstTrainWordList.GetWordByID(j);
  1704. // m_pProbability[nCataCount].dWeight+=1;
  1705. // CWordNode &wordnode = m_lstTrainWordList.m_lstWordList[str];
  1706. // m_pProbability[nCataCount].dWeight+= wordnode.m_pCataWeightPro[nCataCount];
  1707. }
  1709. // i=docNode.m_sWeightSet[nCataCount].s_idxWord;
  1710. // CString str = m_lstTrainWordList.GetWordByID(i);
  1711. // CWordNode &wordnode = m_lstTrainWordList.m_lstWordList[str];
  1712. // m_pProbability[nCataCount].dWeight*= wordnode.m_pCataWeightPro[nCataCount];
  1714. }
  1715. if(ClassPro<m_pProbability[nCataCount].dWeight)
  1716. {
  1717. ClassPro = m_pProbability[nCataCount].dWeight;
  1718. docNode.m_nCataID = nCataCount;
  1719. // CString strtemp;
  1720. // strtemp.Format("%d  %lf  %lf",nCataCount,(1.0+N_c)/(N_Cata+N),ClassPro);
  1721. // CMessage::PrintInfo(strtemp);
  1722. }
  1723. nCataCount++;
  1724. }
  1725. */
  1726. }
  1729. //生成文档docNode的向量形式，调用方法ComputePro计算器其和每一个类别的相似度
  1730. //参数bFile为真代表pPath为docNode的路径,否则代表需要进行分类的文档的内容
  1731. //参数nCmpType代表相似度的不同计算方式
  1732. bool CClassifier::BAYESClassify(char *pPath, CDocNode &docNode, bool bFile)
  1733. {
  1734. int nCount=0;
  1735. if(bFile)
  1736. {
  1737. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1738. nCount=docNode.ScanChineseWithDict(pPath,m_lstTrainWordList);
  1739. else
  1740. nCount=docNode.ScanEnglishWithDict(pPath,m_lstTrainWordList,
  1741. m_paramClassifier.m_bStem);
  1742. }
  1743. else
  1744. {
  1745. if(m_paramClassifier.m_nLanguageType==CClassifierParam::nLT_Chinese)
  1746. nCount=docNode.ScanChineseStringWithDict(pPath,m_lstTrainWordList);
  1747. else
  1748. nCount=docNode.ScanEnglishStringWithDict(pPath,m_lstTrainWordList,
  1749. m_paramClassifier.m_bStem);
  1750. }
  1752. if((m_lDocNum>0)&&(nCount>0))
  1753. {
  1754. ComputePro(docNode);
  1755. return true;
  1756. }
  1757. else
  1758. return false;
  1759. }
  1762. //计算文档和每个类别的相似度，返回与文档相似度最大的类别ID
  1763. short CClassifier::BAYESCategory(char *pPath, CDocNode &docNode, bool bFile)
  1764. {
  1765. BAYESClassify(pPath,docNode,bFile);
  1766. return docNode.m_nCataID;
  1767. }
  1769. long CClassifier::BAYESClassify(CCatalogList &cataList)
  1770. {
  1771. long docID=0,lUnknown=0;
  1772. CString str;
  1773. POSITION pos_cata=cataList.GetFirstPosition();
  1774. while(pos_cata!=NULL)
  1775. {
  1776. CCatalogNode& cataNode=cataList.GetNext(pos_cata);
  1777. POSITION pos_doc=cataNode.GetFirstPosition();
  1778. char *path=cataNode.m_strDirName.GetBuffer(0);
  1779. while(pos_doc!=NULL)
  1780. {
  1781. CDocNode& docNode=cataNode.GetNext(pos_doc);
  1782. short id=BAYESCategory(path, docNode, true);
  1783. if(id==-1) 
  1784. {
  1785. str="无法识别文档";
  1786. str+=cataNode.m_strDirName;
  1787. str+="\"+docNode.m_strDocName+"的类别!";
  1788. CMessage::PrintError(str);
  1789. lUnknown++;
  1790. }
  1791. CMessage::PrintStatusInfo(_T("扫描文档")+docNode.m_strDocName);
  1792. }
  1793. }
  1794. return lUnknown;
  1795. }
  1801. short CClassifier::GetCategory(char *file, bool bFile)
  1802. {
  1803. short result=-1;
  1804. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_KNN)
  1805. result=KNNCategory(file,bFile);
  1806. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM)
  1807. result=SVMCategory(file,bFile);
  1808. return result;
  1809. }
  1811. short CClassifier::GetCategory(char *path, CDocNode &docNode, bool bFile)
  1812. {
  1813. short result=-1;
  1814. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_KNN)
  1815. result=KNNCategory(path,docNode,bFile);
  1816. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM)
  1817. result=SVMCategory(path,docNode,bFile);
  1818. return result;
  1819. }
  1821. bool CClassifier::Classify(char *path, CDocNode &docNode, bool bFile)
  1822. {
  1823. bool result=false;
  1824. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_KNN)
  1825. result=KNNClassify(path,docNode,bFile);
  1826. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM)
  1827. result=SVMClassify(path,docNode,bFile);
  1828. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_BAYES)
  1829. result=BAYESClassify(path,docNode,bFile);
  1830. return result;
  1831. }
  1833. long CClassifier::Classify(CCatalogList &cataList)
  1834. {
  1835. long lUnknown=0;
  1836. if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_KNN)
  1837. lUnknown=KNNClassify(m_lstTestCatalogList);
  1838. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_SVM)
  1839. lUnknown=SVMClassify(m_lstTestCatalogList);
  1840. else if(m_paramClassifier.m_nClassifierType==CClassifierParam::nCT_BAYES)
  1841. lUnknown=BAYESClassify(m_lstTestCatalogList);
  1842. else 
  1843. CMessage::PrintError("无法确定分类器的类型!");
  1844. return lUnknown;
  1845. }