数据挖掘-基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器的JAVA实现(上)...

最新推荐文章于 2019-04-21 18:16:35 发布
最新推荐文章于 2019-04-21 18:16:35 发布
阅读量239 收藏
点赞数
文章标签： java 数据结构与算法 人工智能

(update 2012.12.28 关于本项目下载及运行的常见问题 FAQ见newsgroup18828文本分类器、文本聚类器、关联分析频繁模式挖掘算法的Java实现工程下载及运行FAQ)

本文要点如下：

对newsgroup文档集进行预处理，按照DF法及SVD分解法抽取特征词，实现降维

实现了K-Means，MBSAS，DBSCAN三种聚类算法
用weka工具进行newsgroup文档聚类

计算各种算法聚类的熵，进行算法评价

1、newsgroup文档集预处理

newsgroup是常用的数据挖掘实验数据。文本预处理主要包括单词分片、去除标点等无关符号、去停用词等等，相关详细介绍见我的另一篇博文数据挖掘-基于贝叶斯算法及KNN算法的newsgroup18828文本分类器的JAVA实现（上），此处只给出文本预处理和向量化不同的部分代码。

文本预处理类DataPreProcess.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. packagecom.pku.yangliu;
  3. importjava.io.BufferedReader;
  4. importjava.io.File;
  5. importjava.io.FileReader;
  6. importjava.io.FileWriter;
  7. importjava.io.IOException;
  8. importjava.util.ArrayList;
  10. /**
  11. *Newsgroups文档集预处理类
  12. */
  13. publicclassDataPreProcess{
  15. /**输入文件调用处理数据函数
  16. *@paramstrDirnewsgroup文件目录的绝对路径
  17. *@throwsIOException
  18. */
  19. publicvoiddoProcess(StringstrDir)throwsIOException{
  20. FilefileDir=newFile(strDir);
  21. if(!fileDir.exists()){
  22. System.out.println("Filenotexist:"+strDir);
  23. return;
  24. }
  25. StringsubStrDir=strDir.substring(strDir.lastIndexOf('/'));
  26. StringdirTarget=strDir+"/../../processedSample_includeNotSpecial"+subStrDir;
  27. FilefileTarget=newFile(dirTarget);
  28. if(!fileTarget.exists()){//注意processedSample需要先建立目录建出来，否则会报错，因为母目录不存在
  29. fileTarget.mkdir();
  30. }
  31. File[]srcFiles=fileDir.listFiles();
  32. String[]stemFileNames=newString[srcFiles.length];
  33. for(inti=0;i<srcFiles.length;i++){
  34. StringfileFullName=srcFiles[i].getCanonicalPath();
  35. StringfileShortName=srcFiles[i].getName();
  36. if(!newFile(fileFullName).isDirectory()){//确认子文件名不是目录如果是可以再次递归调用
  37. System.out.println("Beginpreprocess:"+fileFullName);
  38. StringBuilderstringBuilder=newStringBuilder();
  39. stringBuilder.append(dirTarget+"/"+fileShortName);
  40. createProcessFile(fileFullName,stringBuilder.toString());
  41. stemFileNames[i]=stringBuilder.toString();
  42. }
  43. else{
  44. fileFullName=fileFullName.replace("\\","/");
  45. doProcess(fileFullName);
  46. }
  47. }
  48. //下面调用stem算法
  49. if(stemFileNames.length>0&&stemFileNames[0]!=null){
  50. Stemmer.porterMain(stemFileNames);
  51. }
  52. }
  54. /**进行文本预处理生成目标文件
  55. *@paramsrcDir源文件文件目录的绝对路径
  56. *@paramtargetDir生成的目标文件的绝对路径
  57. *@throwsIOException
  58. */
  59. privatestaticvoidcreateProcessFile(StringsrcDir,StringtargetDir)throwsIOException{
  60. //TODOAuto-generatedmethodstub
  61. FileReadersrcFileReader=newFileReader(srcDir);
  62. FileReaderstopWordsReader=newFileReader("F:/DataMiningSample/stopwords.txt");
  63. FileWritertargetFileWriter=newFileWriter(targetDir);
  64. BufferedReadersrcFileBR=newBufferedReader(srcFileReader);//装饰模式
  65. BufferedReaderstopWordsBR=newBufferedReader(stopWordsReader);
  66. Stringline,resLine,stopWordsLine;
  67. //用stopWordsBR够着停用词的ArrayList容器
  68. ArrayList<String>stopWordsArray=newArrayList<String>();
  69. while((stopWordsLine=stopWordsBR.readLine())!=null){
  70. if(!stopWordsLine.isEmpty()){
  71. stopWordsArray.add(stopWordsLine);
  72. }
  73. }
  74. while((line=srcFileBR.readLine())!=null){
  75. resLine=lineProcess(line,stopWordsArray);
  76. if(!resLine.isEmpty()){
  77. //按行写，一行写一个单词
  78. String[]tempStr=resLine.split("");//\s
  79. for(inti=0;i<tempStr.length;i++){
  80. if(!tempStr[i].isEmpty()){
  81. targetFileWriter.append(tempStr[i]+"\n");
  82. }
  83. }
  84. }
  85. }
  86. targetFileWriter.flush();
  87. targetFileWriter.close();
  88. srcFileReader.close();
  89. stopWordsReader.close();
  90. srcFileBR.close();
  91. stopWordsBR.close();
  92. }
  94. /**对每行字符串进行处理，主要是词法分析、去停用词和stemming
  95. *@paramline待处理的一行字符串
  96. *@paramArrayList<String>停用词数组
  97. *@returnString处理好的一行字符串，是由处理好的单词重新生成，以空格为分隔符
  98. *@throwsIOException
  99. */
  100. privatestaticStringlineProcess(Stringline,ArrayList<String>stopWordsArray)throwsIOException{
  101. //TODOAuto-generatedmethodstub
  102. //step1英文词法分析，去除数字、连字符、标点符号、特殊字符，所有大写字母转换成小写，可以考虑用正则表达式
  103. Stringres[]=line.split("[^a-zA-Z]");
  104. //这里要小心，防止把有单词中间有数字和连字符的单词截断了，但是截断也没事
  105. StringresString=newString();
  106. //step2去停用词
  107. //step3stemming,返回后一起做
  108. for(inti=0;i<res.length;i++){
  109. if(!res[i].isEmpty()&&!stopWordsArray.contains(res[i].toLowerCase())){
  110. resString+=""+res[i].toLowerCase()+"";
  111. }
  112. }
  113. returnresString;
  114. }
  116. /**
  117. *@paramargs
  118. *@throwsIOException
  119. */
  120. publicvoidBPPMain(String[]args)throwsIOException{
  121. //TODOAuto-generatedmethodstub
  122. DataPreProcessdataPrePro=newDataPreProcess();
  123. dataPrePro.doProcess("F:/DataMiningSample/orginSample");
  125. }
  127. }
文本向量化表示主要基于TF-IDF值 ComputeWordsVector.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. packagecom.pku.yangliu;
  2. importjava.io.BufferedReader;
  3. importjava.io.File;
  4. importjava.io.FileReader;
  5. importjava.io.FileWriter;
  6. importjava.io.IOException;
  7. importjava.util.HashSet;
  8. importjava.util.SortedMap;
  9. importjava.util.Map;
  10. importjava.util.Set;
  11. importjava.util.SortedSet;
  12. importjava.util.TreeMap;
  13. importjava.util.Iterator;
  14. importjava.util.TreeSet;
  16. /**计算文档的属性向量，将所有文档向量化
  17. *
  18. */
  19. publicclassComputeWordsVector{
  21. /**计算文档的TF-IDF属性向量,返回Map<文件名，Map<特征词，TF-IDF值>>
  22. *@paramtestSampleDir处理好的聚类样本测试样例集合
  23. *@returnMap<String,Map<String,Double>>所有测试样例的属性向量构成的map
  24. *@throwsIOException
  25. */
  26. publicMap<String,Map<String,Double>>computeTFMultiIDF(StringtestSampleDir)throwsIOException{
  27. Stringword;
  28. Map<String,Map<String,Double>>allTestSampleMap=newTreeMap<String,Map<String,Double>>();
  29. Map<String,Double>idfPerWordMap=computeIDF(testSampleDir);
  30. Map<String,Double>TFPerDocMap=newTreeMap<String,Double>();//计算每篇文档中含有各特征词数量
  31. File[]samples=newFile(testSampleDir).listFiles();
  32. System.out.println("thetotalnumberoftestfilesis"+samples.length);
  33. for(inti=0;i<samples.length;i++){
  34. TFPerDocMap.clear();
  35. FileReadersamReader=newFileReader(samples[i]);
  36. BufferedReadersamBR=newBufferedReader(samReader);
  37. DoublewordSumPerDoc=0.0;//计算每篇文档的总词数
  38. while((word=samBR.readLine())!=null){
  39. if(!word.isEmpty()){
  40. wordSumPerDoc++;
  41. if(TFPerDocMap.containsKey(word)){
  42. Doublecount=TFPerDocMap.get(word);
  43. TFPerDocMap.put(word,count+1.0);
  44. }
  45. else{
  46. TFPerDocMap.put(word,1.0);
  47. }
  48. }
  49. }
  51. DoublemaxCount=0.0,wordWeight;//记录出现次数最多的词出现的次数，用做归一化
  52. Set<Map.Entry<String,Double>>tempTF=TFPerDocMap.entrySet();
  53. for(Iterator<Map.Entry<String,Double>>mt=tempTF.iterator();mt.hasNext();){
  54. Map.Entry<String,Double>me=mt.next();
  55. if(me.getValue()>maxCount)maxCount=me.getValue();
  56. }
  57. for(Iterator<Map.Entry<String,Double>>mt=tempTF.iterator();mt.hasNext();){
  58. Map.Entry<String,Double>me=mt.next();
  59. DoubleIDF=Math.log(samples.length/idfPerWordMap.get(me.getKey()))/Math.log(10);
  60. wordWeight=(me.getValue()/maxCount)*IDF;
  61. TFPerDocMap.put(me.getKey(),wordWeight);
  62. }
  63. TreeMap<String,Double>tempMap=newTreeMap<String,Double>();
  64. tempMap.putAll(TFPerDocMap);
  65. allTestSampleMap.put(samples[i].getName(),tempMap);
  66. }
  67. //printTestSampleMap(allTestSampleMap);
  68. returnallTestSampleMap;
  69. }
  71. /**输出测试样例map内容，用于测试
  72. *@paramSortedMap<String,Double>属性词典
  73. *@throwsIOException
  74. */
  75. voidprintTestSampleMap(Map<String,Map<String,Double>>allTestSampleMap)throwsIOException{
  76. //TODOAuto-generatedmethodstub
  77. FileoutPutFile=newFile("F:/DataMiningSample/KmeansClusterResult/allTestSampleMap.txt");
  78. FileWriteroutPutFileWriter=newFileWriter(outPutFile);
  79. Set<Map.Entry<String,Map<String,Double>>>allWords=allTestSampleMap.entrySet();
  80. for(Iterator<Map.Entry<String,Map<String,Double>>>it=allWords.iterator();it.hasNext();){
  81. Map.Entry<String,Map<String,Double>>me=it.next();
  82. outPutFileWriter.append(me.getKey()+"");
  83. Set<Map.Entry<String,Double>>vecSet=me.getValue().entrySet();
  84. for(Iterator<Map.Entry<String,Double>>jt=vecSet.iterator();jt.hasNext();){
  85. Map.Entry<String,Double>ne=jt.next();
  86. outPutFileWriter.append(ne.getKey()+""+ne.getValue()+"");
  87. }
  88. outPutFileWriter.append("\n");
  89. outPutFileWriter.flush();
  90. }
  91. outPutFileWriter.close();
  92. }
  94. /**统计每个词的总的出现次数，返回出现次数大于n次的词汇构成最终的属性词典
  95. *@paramstrDir处理好的newsgroup文件目录的绝对路径
  96. *@throwsIOException
  97. */
  98. publicSortedMap<String,Double>countWords(StringstrDir,Map<String,Double>wordMap)throwsIOException{
  99. FilesampleFile=newFile(strDir);
  100. File[]sampleDir=sampleFile.listFiles();
  101. Stringword;
  102. for(intj=0;j<sampleDir.length;j++){
  103. File[]sample=sampleDir[j].listFiles();
  104. for(inti=0;i<sample.length;i++){
  105. if(sample[i].getName().contains("stemed")){
  106. FileReadersamReader=newFileReader(sample[i]);
  107. BufferedReadersamBR=newBufferedReader(samReader);
  108. while((word=samBR.readLine())!=null){
  109. if(!word.isEmpty()&&wordMap.containsKey(word)){
  110. doublecount=wordMap.get(word)+1;
  111. wordMap.put(word,count);
  112. }
  113. else{
  114. wordMap.put(word,1.0);
  115. }
  116. }
  117. }
  118. }
  119. }
  121. //去除停用词后，先用DF法选取特征词，后面再加入特征词的选取算法
  122. SortedMap<String,Double>newWordMap=newTreeMap<String,Double>();
  123. Set<Map.Entry<String,Double>>allWords=wordMap.entrySet();
  124. for(Iterator<Map.Entry<String,Double>>it=allWords.iterator();it.hasNext();){
  125. Map.Entry<String,Double>me=it.next();
  126. if(me.getValue()>100){//DF法降维
  127. newWordMap.put(me.getKey(),me.getValue());
  128. }
  129. }
  130. returnnewWordMap;
  131. }
  133. /**计算IDF，即属性词典中每个词在多少个文档中出现过
  134. *@paramtestSampleDir聚类算法测试样本所在目录
  135. *@return单词的IDFmap格式为SortedMap<String,Double>即<单词，包含该单词的文档数>
  136. *@throwsIOException
  137. */
  138. Map<String,Double>computeIDF(StringtestSampleDir)throwsIOException{
  139. //TODOAuto-generatedmethodstub
  140. Map<String,Double>IDFPerWordMap=newTreeMap<String,Double>();
  141. Set<String>alreadyCountWord=newHashSet<String>();//记下当前已经遇到过的该文档中的词
  142. Stringword;
  143. File[]samples=newFile(testSampleDir).listFiles();
  144. for(inti=0;i<samples.length;i++){
  145. alreadyCountWord.clear();
  146. FileReadertsReader=newFileReader(samples[i]);
  147. BufferedReadertsBR=newBufferedReader(tsReader);
  148. while((word=tsBR.readLine())!=null){
  149. if(!alreadyCountWord.contains(word)){
  150. if(IDFPerWordMap.containsKey(word)){
  151. IDFPerWordMap.put(word,IDFPerWordMap.get(word)+1.0);
  152. }
  153. elseIDFPerWordMap.put(word,1.0);
  154. alreadyCountWord.add(word);
  155. }
  156. }
  157. }
  158. returnIDFPerWordMap;
  159. }
  161. /**创建聚类算法的测试样例集，主要是过滤出只含有特征词的文档写到一个目录下
  162. *@paramStringsrcDir源目录，已经经过预处理但还没有过滤非特征词的文档目录
  163. *@paramStringdestDir目的目录，聚类算法的测试样例目录
  164. *@returnString[]创建测试样例集中特征词数组
  165. *@throwsIOException
  166. */
  167. String[]createTestSamples(StringsrcDir,StringdestDir)throwsIOException{
  168. //TODOAuto-generatedmethodstub
  169. SortedMap<String,Double>wordMap=newTreeMap<String,Double>();
  170. wordMap=countWords(srcDir,wordMap);
  171. System.out.println("specialwordsmapsizes:"+wordMap.size());
  172. Stringword,testSampleFile;
  173. File[]sampleDir=newFile(srcDir).listFiles();
  174. for(inti=0;i<sampleDir.length;i++){
  175. File[]sample=sampleDir[i].listFiles();
  176. for(intj=0;j<sample.length;j++){
  177. if(sample[j].getName().contains("stemed")){
  178. testSampleFile=destDir+sampleDir[i].getName()+"_"+sample[j].getName();
  179. FileReadersamReader=newFileReader(sample[j]);
  180. BufferedReadersamBR=newBufferedReader(samReader);
  181. FileWritertsWriter=newFileWriter(newFile(testSampleFile));
  182. while((word=samBR.readLine())!=null){
  183. if(wordMap.containsKey(word)){
  184. tsWriter.append(word+"\n");
  185. }
  186. }
  187. tsWriter.flush();
  188. tsWriter.close();
  189. }
  190. }
  191. }
  192. //返回属性词典
  193. String[]terms=newString[wordMap.size()];
  194. inti=0;
  195. Set<Map.Entry<String,Double>>allWords=wordMap.entrySet();
  196. for(Iterator<Map.Entry<String,Double>>it=allWords.iterator();it.hasNext();){
  197. Map.Entry<String,Double>me=it.next();
  198. terms[i]=me.getKey();
  199. i++;
  200. }
  201. returnterms;
  202. }
  204. /**评估函数根据聚类结果文件统计熵和混淆矩阵
  205. *@paramclusterResultFile聚类结果文件
  206. *@paramK聚类数目
  207. *@returndouble聚类结果的熵值
  208. *@throwsIOException
  209. */
  210. doubleevaluateClusterRes(StringclusterResultFile,intK)throwsIOException{
  211. //TODOAuto-generatedmethodstub
  212. Map<String,String>rightCate=newTreeMap<String,String>();
  213. Map<String,String>resultCate=newTreeMap<String,String>();
  214. FileReadercrReader=newFileReader(clusterResultFile);
  215. BufferedReadercrBR=newBufferedReader(crReader);
  216. String[]s;
  217. Stringline;
  218. while((line=crBR.readLine())!=null){
  219. s=line.split("");
  220. resultCate.put(s[0],s[1]);
  221. //再把s[0]用_分片
  222. rightCate.put(s[0],s[0].split("_")[0]);
  223. }
  224. returncomputeEntropyAndConfuMatrix(rightCate,resultCate,K);//返回熵
  225. }
  227. /**计算混淆矩阵并且输出，返回熵
  228. *@paramrightCate正确类目对应map
  229. *@paramresultCate聚类结果对应map
  230. *@returndouble返回聚类的熵
  231. *@throwsIOException
  232. */
  233. privatedoublecomputeEntropyAndConfuMatrix(Map<String,String>rightCate,
  234. Map<String,String>resultCate,intK){
  235. //TODOAuto-generatedmethodstub
  236. int[][]confusionMatrix=newint[K][20];//K行20列，[i,j]表示聚类i中属于类目j的文件数
  237. //首先求出类目对应的数组索引
  238. SortedSet<String>cateNames=newTreeSet<String>();
  239. Set<Map.Entry<String,String>>rightCateSet=rightCate.entrySet();
  240. for(Iterator<Map.Entry<String,String>>it=rightCateSet.iterator();it.hasNext();){
  241. Map.Entry<String,String>me=it.next();
  242. cateNames.add(me.getValue());
  243. }
  244. String[]cateNamesArray=cateNames.toArray(newString[0]);
  245. Map<String,Integer>cateNamesToIndex=newTreeMap<String,Integer>();
  246. for(inti=0;i<cateNamesArray.length;i++){
  247. cateNamesToIndex.put(cateNamesArray[i],i);
  248. }
  249. for(Iterator<Map.Entry<String,String>>it=rightCateSet.iterator();it.hasNext();){
  250. Map.Entry<String,String>me=it.next();
  251. confusionMatrix[Integer.parseInt(resultCate.get(me.getKey()))][cateNamesToIndex.get(me.getValue())]++;
  252. }
  253. //输出混淆矩阵
  254. double[]clusterSum=newdouble[K];//记录每个聚类的文件数
  255. double[]everyClusterEntropy=newdouble[K];//记录每个聚类的熵
  256. doubleclusterEntropy=0;
  257. System.out.print("");
  258. for(inti=0;i<20;i++){
  259. System.out.print(i+"");
  260. }
  261. System.out.println();
  262. for(inti=0;i<K;i++){
  263. System.out.print(i+"");
  264. for(intj=0;j<20;j++){
  265. clusterSum[i]+=confusionMatrix[i][j];
  266. System.out.print(confusionMatrix[i][j]+"");
  267. }
  268. System.out.println();
  269. }
  270. System.out.println();
  271. for(inti=0;i<K;i++){
  272. if(clusterSum[i]!=0){
  273. for(intj=0;j<20;j++){
  274. doublep=(double)confusionMatrix[i][j]/clusterSum[i];
  275. if(p!=0){
  276. everyClusterEntropy[i]+=-p*Math.log(p);
  277. }
  278. }
  279. clusterEntropy+=clusterSum[i]/(double)rightCate.size()*everyClusterEntropy[i];
  280. }
  281. }
  282. returnclusterEntropy;
  283. }
  285. }

2、K-means算法

K-means算法是非常经典的聚类算法。其算法思路是：先选K个初始聚类点作为初始中心点，然后计算其他所有点到K个聚类点的距离做聚类，将点分到最近的聚类，聚完类后中心点发生变化了，于是更新中心点。然后再计算其他所有点到这K个中心点的距离重新聚类，中心点又会发生变化，如此迭代下去。其伪代码如下：

K-means算法的实现有以下关键点：

初始点的选择策略：随机选、均匀抽样、最大最小法等
距离的度量 1-余弦相似度，欧式距离，1-向量内积，测试发现1-余弦相似度效果最好，而1-向量内积速度最快。
中心点的计算 向量各维取评价
算法停止条件 计算准则函数及设置最大迭代次数
空聚类的处理 注意空聚类导致的程序bug

K-means算法实现类KmeansCluster.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. packagecom.pku.yangliu;
  2. importjava.io.FileWriter;
  3. importjava.io.IOException;
  4. importjava.util.Iterator;
  5. importjava.util.Map;
  6. importjava.util.Set;
  7. importjava.util.TreeMap;
  8. importjava.util.Vector;
  10. /**Kmeans聚类算法的实现类，将newsgroups文档集聚成10类、20类、30类
  11. *算法结束条件:当每个点最近的聚类中心点就是它所属的聚类中心点时，算法结束
  12. *
  13. */
  15. publicclassKmeansCluster{
  17. /**Kmeans算法主过程
  18. *@paramMap<String,Map<String,Double>>allTestSampleMap聚类算法测试样本map
  19. *@paramintK聚类的数量
  20. *@returnMap<String,Integer>聚类的结果即<文件名，聚类完成后所属的类别标号>
  21. *@throwsIOException
  22. */
  23. privateMap<String,Integer>doProcess(
  24. Map<String,Map<String,Double>>allTestSampleMap,intK){
  25. //TODOAuto-generatedmethodstub
  26. //0、首先获取allTestSampleMap所有文件名顺序组成的数组
  27. String[]testSampleNames=newString[allTestSampleMap.size()];
  28. intcount=0,tsLength=allTestSampleMap.size();
  29. Set<Map.Entry<String,Map<String,Double>>>allTestSampeleMapSet=allTestSampleMap.entrySet();
  30. for(Iterator<Map.Entry<String,Map<String,Double>>>it=allTestSampeleMapSet.iterator();it.hasNext();){
  31. Map.Entry<String,Map<String,Double>>me=it.next();
  32. testSampleNames[count++]=me.getKey();
  33. }
  34. //1、初始点的选择算法是随机选择或者是均匀分开选择，这里采用后者
  35. Map<Integer,Map<String,Double>>meansMap=getInitPoint(allTestSampleMap,K);//保存K个中心点
  36. double[][]distance=newdouble[tsLength][K];//distance[i][j]记录点i到聚类中心j的距离
  37. //2、初始化K个聚类
  38. int[]assignMeans=newint[tsLength];//记录所有点属于的聚类序号，初始化全部为0
  39. Map<Integer,Vector<Integer>>clusterMember=newTreeMap<Integer,Vector<Integer>>();//记录每个聚类的成员点序号
  40. Vector<Integer>mem=newVector<Integer>();
  41. intiterNum=0;//迭代次数
  42. while(true){
  43. System.out.println("IterationNo."+(iterNum++)+"----------------------");
  44. //3、计算每个点和每个聚类中心的距离
  45. for(inti=0;i<tsLength;i++){
  46. for(intj=0;j<K;j++){
  47. distance[i][j]=getDistance(allTestSampleMap.get(testSampleNames[i]),meansMap.get(j));
  48. }
  49. }
  50. //4、找出每个点最近的聚类中心
  51. int[]nearestMeans=newint[tsLength];
  52. for(inti=0;i<tsLength;i++){
  53. nearestMeans[i]=findNearestMeans(distance,i);
  54. }
  55. //5、判断当前所有点属于的聚类序号是否已经全部是其离得最近的聚类，如果是或者达到最大的迭代次数，那么结束算法
  56. intokCount=0;
  57. for(inti=0;i<tsLength;i++){
  58. if(nearestMeans[i]==assignMeans[i])okCount++;
  59. }
  60. System.out.println("okCount="+okCount);
  61. if(okCount==tsLength||iterNum>=10)break;
  62. //6、如果前面条件不满足，那么需要重新聚类再进行一次迭代，需要修改每个聚类的成员和每个点属于的聚类信息
  63. clusterMember.clear();
  64. for(inti=0;i<tsLength;i++){
  65. assignMeans[i]=nearestMeans[i];
  66. if(clusterMember.containsKey(nearestMeans[i])){
  67. clusterMember.get(nearestMeans[i]).add(i);
  68. }
  69. else{
  70. mem.clear();
  71. mem.add(i);
  72. Vector<Integer>tempMem=newVector<Integer>();
  73. tempMem.addAll(mem);
  74. clusterMember.put(nearestMeans[i],tempMem);
  75. }
  76. }
  77. //7、重新计算每个聚类的中心点!
  78. for(inti=0;i<K;i++){
  79. if(!clusterMember.containsKey(i)){//注意kmeans可能产生空聚类
  80. continue;
  81. }
  82. Map<String,Double>newMean=computeNewMean(clusterMember.get(i),allTestSampleMap,testSampleNames);
  83. Map<String,Double>tempMean=newTreeMap<String,Double>();
  84. tempMean.putAll(newMean);
  85. meansMap.put(i,tempMean);
  86. }
  87. }
  88. //8、形成聚类结果并且返回
  89. Map<String,Integer>resMap=newTreeMap<String,Integer>();
  90. for(inti=0;i<tsLength;i++){
  91. resMap.put(testSampleNames[i],assignMeans[i]);
  92. }
  93. returnresMap;
  94. }
  96. /**计算当前聚类新的中心，采用向量平均
  97. *@paramclusterM该点到所有聚类中心的距离
  98. *@paramallTestSampleMap所有测试样例的<文件名，向量>构成的map
  99. *@paramtestSampleNames所有测试样例文件名构成的数组
  100. *@returnMap<String,Double>新的聚类中心的向量
  101. *@throwsIOException
  102. */
  103. privateMap<String,Double>computeNewMean(Vector<Integer>clusterM,
  104. Map<String,Map<String,Double>>allTestSampleMap,
  105. String[]testSampleNames){
  106. //TODOAuto-generatedmethodstub
  107. doublememberNum=(double)clusterM.size();
  108. Map<String,Double>newMeanMap=newTreeMap<String,Double>();
  109. Map<String,Double>currentMemMap=newTreeMap<String,Double>();
  110. for(Iterator<Integer>it=clusterM.iterator();it.hasNext();){
  111. intme=it.next();
  112. currentMemMap=allTestSampleMap.get(testSampleNames[me]);
  113. Set<Map.Entry<String,Double>>currentMemMapSet=currentMemMap.entrySet();
  114. for(Iterator<Map.Entry<String,Double>>jt=currentMemMapSet.iterator();jt.hasNext();){
  115. Map.Entry<String,Double>ne=jt.next();
  116. if(newMeanMap.containsKey(ne.getKey())){
  117. newMeanMap.put(ne.getKey(),newMeanMap.get(ne.getKey())+ne.getValue());
  118. }
  119. else{
  120. newMeanMap.put(ne.getKey(),ne.getValue());
  121. }
  122. }
  123. }
  125. Set<Map.Entry<String,Double>>newMeanMapSet=newMeanMap.entrySet();
  126. for(Iterator<Map.Entry<String,Double>>jt=newMeanMapSet.iterator();jt.hasNext();){
  127. Map.Entry<String,Double>ne=jt.next();
  128. newMeanMap.put(ne.getKey(),newMeanMap.get(ne.getKey())/memberNum);
  129. }
  130. returnnewMeanMap;
  131. }
  133. /**找出距离当前点最近的聚类中心
  134. *@paramdouble[][]点到所有聚类中心的距离
  135. *@returni最近的聚类中心的序号
  136. *@throwsIOException
  137. */
  138. privateintfindNearestMeans(double[][]distance,intm){
  139. //TODOAuto-generatedmethodstub
  140. doubleminDist=10;
  141. intj=0;
  142. for(inti=0;i<distance[m].length;i++){
  143. if(distance[m][i]<minDist){
  144. minDist=distance[m][i];
  145. j=i;
  146. }
  147. }
  148. returnj;
  149. }
  152. /**计算两个点的距离
  153. *@parammap1点1的向量map
  154. *@parammap2点2的向量map
  155. *@returndouble两个点的欧式距离
  156. */
  157. privatedoublegetDistance(Map<String,Double>map1,Map<String,Double>map2){
  158. //TODOAuto-generatedmethodstub
  159. return1-computeSim(map1,map2);
  160. }
  162. /**计算两个文本的相似度
  163. *@paramtestWordTFMap文本1的<单词,词频>向量
  164. *@paramtrainWordTFMap文本2<单词,词频>向量
  165. *@returnDouble向量之间的相似度以向量夹角余弦计算或者向量内积计算（效果相当而速度更快）
  166. *@throwsIOException
  167. */
  168. privatedoublecomputeSim(Map<String,Double>testWordTFMap,
  169. Map<String,Double>trainWordTFMap){
  170. //TODOAuto-generatedmethodstub
  171. doublemul=0;//,testAbs=0,trainAbs=0;
  172. Set<Map.Entry<String,Double>>testWordTFMapSet=testWordTFMap.entrySet();
  173. for(Iterator<Map.Entry<String,Double>>it=testWordTFMapSet.iterator();it.hasNext();){
  174. Map.Entry<String,Double>me=it.next();
  175. if(trainWordTFMap.containsKey(me.getKey())){
  176. mul+=me.getValue()*trainWordTFMap.get(me.getKey());
  177. }
  178. //testAbs+=me.getValue()*me.getValue();
  179. }
  180. //testAbs=Math.sqrt(testAbs);
  182. /*Set<Map.Entry<String,Double>>trainWordTFMapSet=trainWordTFMap.entrySet();
  183. for(Iterator<Map.Entry<String,Double>>it=trainWordTFMapSet.iterator();it.hasNext();){
  184. Map.Entry<String,Double>me=it.next();
  185. trainAbs+=me.getValue()*me.getValue();
  186. }
  187. trainAbs=Math.sqrt(trainAbs);*/
  188. returnmul;///(testAbs*trainAbs);
  189. }
  191. /**获取kmeans算法迭代的初始点
  192. *@paramk聚类的数量
  193. *@paramMap<String,Map<String,Double>>allTestSampleMap所有测试样例的<文件名，向量>构成的map
  194. *@returnMap<Integer,Map<String,Double>>初始中心点的Map
  195. *@throwsIOException
  196. */
  197. privateMap<Integer,Map<String,Double>>getInitPoint(Map<String,Map<String,Double>>allTestSampleMap,intK){
  198. //TODOAuto-generatedmethodstub
  199. intcount=0,i=0;
  200. Map<Integer,Map<String,Double>>meansMap=newTreeMap<Integer,Map<String,Double>>();//保存K个聚类中心点向量
  201. System.out.println("本次聚类的初始点对应的文件为：");
  202. Set<Map.Entry<String,Map<String,Double>>>allTestSampleMapSet=allTestSampleMap.entrySet();
  203. for(Iterator<Map.Entry<String,Map<String,Double>>>it=allTestSampleMapSet.iterator();it.hasNext();){
  204. Map.Entry<String,Map<String,Double>>me=it.next();
  205. if(count==i*allTestSampleMapSet.size()/K){
  206. meansMap.put(i,me.getValue());
  207. System.out.println(me.getKey()+"mapsizeis"+me.getValue().size());
  208. i++;
  209. }
  210. count++;
  211. }
  212. returnmeansMap;
  213. }
  215. /**输出聚类结果到文件中
  216. *@paramkmeansClusterResultFile输出文件目录
  217. *@paramkmeansClusterResult聚类结果
  218. *@throwsIOException
  219. */
  220. privatevoidprintClusterResult(Map<String,Integer>kmeansClusterResult,StringkmeansClusterResultFile)throwsIOException{
  221. //TODOAuto-generatedmethodstub
  222. FileWriterresWriter=newFileWriter(kmeansClusterResultFile);
  223. Set<Map.Entry<String,Integer>>kmeansClusterResultSet=kmeansClusterResult.entrySet();
  224. for(Iterator<Map.Entry<String,Integer>>it=kmeansClusterResultSet.iterator();it.hasNext();){
  225. Map.Entry<String,Integer>me=it.next();
  226. resWriter.append(me.getKey()+""+me.getValue()+"\n");
  227. }
  228. resWriter.flush();
  229. resWriter.close();
  230. }
  232. publicvoidKmeansClusterMain(StringtestSampleDir)throwsIOException{
  233. //首先计算文档TF-IDF向量，保存为Map<String,Map<String,Double>>即为Map<文件名，Map<特征词，TF-IDF值>>
  234. ComputeWordsVectorcomputeV=newComputeWordsVector();
  235. int[]K={10,20,30};
  236. Map<String,Map<String,Double>>allTestSampleMap=computeV.computeTFMultiIDF(testSampleDir);
  237. for(inti=0;i<K.length;i++){
  238. System.out.println("开始聚类，聚成"+K[i]+"类");
  239. StringKmeansClusterResultFile="F:/DataMiningSample/KmeansClusterResult/";
  240. Map<String,Integer>KmeansClusterResult=newTreeMap<String,Integer>();
  241. KmeansClusterResult=doProcess(allTestSampleMap,K[i]);
  242. KmeansClusterResultFile+=K[i];
  243. printClusterResult(KmeansClusterResult,KmeansClusterResultFile);
  244. System.out.println("TheEntropyforthisClusteris"+computeV.evaluateClusterRes(KmeansClusterResultFile,K[i]));
  245. }
  246. }
  247. }
聚类器主类ClusterMain.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. packagecom.pku.yangliu;
  3. importjava.io.IOException;
  4. importjava.text.SimpleDateFormat;
  6. /**聚类器主类，提供主函数入口
  7. *
  8. */
  9. publicclassClusterMain{
  11. /**
  12. *@paramargs
  13. *@throwsIOException
  14. */
  15. publicstaticvoidmain(String[]args)throwsIOException{
  16. //TODOAuto-generatedmethodstub
  17. DataPreProcessDataPP=newDataPreProcess();
  18. ComputeWordsVectorcomputeV=newComputeWordsVector();
  19. //KmeansSVDClusterkmeansCluster1=newKmeansSVDCluster();
  20. KmeansClusterkmeansCluster2=newKmeansCluster();
  21. DataPP.BPPMain(args);//数据预处理,注意如果已经完成数据预处理，此函数可以不执行
  22. //下面创建聚类算法的测试样例集合
  23. StringsrcDir="F:/DataMiningSample/processedSample_includeNotSpecial/";
  24. StringdestDir="F:/DataMiningSample/clusterTestSample/";
  25. SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
  26. StringbeginTime=sdf.format(newjava.util.Date());
  27. System.out.println("程序开始执行时间:"+beginTime);
  28. String[]terms=computeV.createTestSamples(srcDir,destDir);
  29. //kmeansCluster1.KmeansClusterMain(destDir,terms);
  30. kmeansCluster2.KmeansClusterMain(destDir);
  31. StringendTime=sdf.format(newjava.util.Date());
  32. System.out.println("程序结束执行时间:"+endTime);
  33. }
  34. }
3、K-means算法聚类结果

K-means算法对newsgroup文本聚类的结果用聚类结果的熵值来度量，熵值定义如下


对newsgroup文本聚类的结果混淆矩阵如下：


这是用DF法降维到6070词的聚类结果，熵值已经比较小了聚20类时只有1.144，特征词抽取降维是数据挖掘研究中的一个重要内容，我还尝试了用LSI中的SVD分解来进行特征降维，详细介绍实现和其他两种聚类算法的聚类结果对比见下一篇博文数据挖掘-基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器的JAVA实现(下)

小飞侠-2
关注
【JAVA实现】K-means聚类算法
C_son的专栏
02-22 5285
上一篇博文介绍了层次聚类算法的实现http://blog.csdn.net/c_son/article/details/43900503 ，可以发现其效率比较低下，因为每次迭代都要计算每两个聚簇之间的距离。这次的k-means算法在效率上要优于层次聚类算法。               算法实现：        1）从样本D中随机选取K个元素，作为K个簇的中心        2）分别计算剩下
数据挖掘-基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器的JAVA实现(上)
热门推荐
Coding for Dreams
04-18 2万+
(update 2012.12.28 关于本项目下载及运行的常见问题 FAQ见 newsgroup18828文本分类器、文本聚类器、关联分析频繁模式挖掘算法的Java实现工程下载及运行FAQ )本文要点如下：对newsgroup文档集进行预处理，按照DF法及SVD分解法抽取特征词，实现降维实现了K-Means，MBSAS，DBSCAN三种聚类算法用weka工具进行newsgroup文档聚类计算各种
kmeans中文文本聚类java源码（包括对文本tf，idf的计算，文本相似度计算）
05-08
算法思想：提取文档的TF/IDF权重，然后用余弦定理计算两个多维向量的距离来计算两篇文档的相似度，用标准的k-means算法就可以实现文本聚类。源码为java实现
Java中通过HanLP实现文本分词、提取关键词、聚类（工具资源+实例）
05-20
HanLP是由一系列模型与算法组成的工具包，目标是普及自然语言处理在生产环境中的应用。HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点；提供词法分析（中文分词、词性标注、命名实体识别）、句法分析、文本分类和情感分析等功能。
聚类算法---MBSAS
xiepeng1128的专栏
04-10 1019
算法思路：确定一种恒量两个数据之间相似度（距离），确定一个阀值theta以及最多能够聚类的类别个数q.先将第一个作为第一类，然后每进入一个样本与之前的所有样本计算距离，当距离大于阀值并且没有达到类别个数的时候，我们将其当作另外一类，否则把它归为离它最近的那个。同时这里与一个类别的距离是与这一类样本的均值(m)的距离，不断更新。 mCnewk=(nCnewk−1)mColdk+xnCnewkm_{C
基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器
04-17
基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器 程序运行方法：用eclipse打开工程，并将newsgroup文档集解压到 F:\DataMiningSample\orginSample目录下，同时在F:\DataMiningSample\ 下建好如附件“F盘DataMiningSample目录下的数据子目录结构”图中的目录， 停用词表也放在"F:/DataMiningSample/目录下，即可运行eclipse工程。 本project源代码一共三个工程文件 DataMiningCluster-Kmeans算法及SVD分解降维代码 MBSAS-MBSAS算法代码 DBSCAN-DBSCAN算法代码 结果文件：Kmeans_result MBSAS_result
数据挖掘实战-基于KMeans算法对超市客户进行聚类分群（数据集+代码）.rar
最新发布
06-20
KMeans算法作为一种常见的聚类算法，具有计算效率高、易于理解和实现的优点，被广泛应用于客户细分领域。 因此，本实验旨在使用KMeans算法对超市客户进行聚类分群，从而识别出不同的客户群体，并分析这些群体的...
数据挖掘-基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器的JAVA实现(下)
Coding for Dreams
04-17 1万+
本文接数据挖掘-基于Kmeans算法、MBSAS算法及DBSCAN算法的newsgroup18828文本聚类器的JAVA实现(上).(update 2012.12.28 关于本项目下载及运行的常见问题 FAQ见 newsgroup18828文本分类器、文本聚类器、关联分析频繁模式挖掘算法的Java实现工程下载及运行FAQ )本文要点如下：介绍基于LSI(隐性语义索引)中SVD分解做特征降维的方法介
项目实战-Python基于KMeans算法进行文本聚类项目实战.zip
06-18
项目实战-Python基于KMeans算法进行文本聚类项目实战.zip本项目是一套成熟的大作业项目系统，获取98分，主要针对计算机相关专业的正在做大作业的学生和需要项目实战练习的学习者，可作为课程设计、期末大作业。...
TFIDF文本聚类
06-18
使用Java实现TFIDF方法的文本聚类
生成文本聚类java实现 (1)
十年呵护的专栏
08-09 1323
本文转自http://www.iteye.com/topic/989012 https://blog.csdn.net/jasontome/article/details/7933618  本文章纯属个人学习笔记,持续不断的增加中...   　  本章主要的学习是中文分词 和两种统计词频(传统词频和TF-IDF算法 ) 的方法.        学习目的:通过N多的新闻标题 or 新闻摘...
VSM向量空间模型对文本的分类以及简单实现
silence1214的专栏
07-12 1万+
1：对文本的分类，不管用什么高级的方法，首先还是需要建立数学模型的，这个地方就用SVM来建立，他的原理是根据文本的特征，比如一个文本有10个特征（一般来说每个特征是一个代表这个文本的关键词），那么这个文本向量大小就是10了。具体的每个值就是这个特征的权重（关于权重的计算很多种，我这个地方只用了词频来代表）。然后读入测试本文，根据该测试文本中的特征，看和样本中的特征的向量做运算，这个地方用的是求向量
层次聚类实例以及Java实现
mpk_no1的博客
05-22 6778
本文主要讲述一个层次聚类实例，使用层次聚类算法将相似图书的目录进行聚类。由于不知道要聚为多少类，所以Kmeans聚类算法不适用，而层次聚类由于不需要设置聚类中心数，只要传递一个阈值即可，所以正好适合于这个问题。本文将结合层次聚算法的原理以及其Java代码实现来展现文本聚类的一个实现方式。具体代码见我的GitHub（点击打开链接）
csdn博客推荐系统实战-5文本聚类-话题模型LDA
生命不息，学习不止
04-20 4218
话题模型topic model是自然语言处理领域里面热门的一个技术，可以用来做很多的事情，例如相似度比较，关键词提取，分类，还有就是具体产品业务上的事了，总之可以干很多的事情。今天不会讲LDA模型的很多细节和原理，没有满屏的数学公式，只讲一讲LDA模型是个什么东西，简单的原理，用什么技术实现的LDA，以及LDA能做什么开发和LDA在实现中的一些问题。什么是主题对于一篇新闻报道，看到里面讲了昨天NB...
基于word2vec和k-means的词聚类
allan2222的博客
04-21 8039
import re from sklearn.cluster import KMeans from sklearn.externals import joblib import numpy from gensim.models import Word2Vec from gensim.models.word2vec import LineSentence from sklearn import m...
K-means算法及文本聚类实践
琼华
04-20 1万+
K-Means是常用的聚类算法，与其他聚类算法相比，其时间复杂度低，聚类的效果也还不错，这里简单介绍一下k-means算法，下图是一个手写体数据集聚类的结果。  基本思想 　k-means算法需要事先指定簇的个数k，算法开始随机选择k个记录点作为中心点，然后遍历整个数据集的各条记录，将每条记录归到离它最近的中心点所在的簇中，之后以各个簇的记录的均值中心点取代之前的中心点，然后不
云计算平台上的Canopy-Kmeans并行聚类算法优化
该文档是关于云计算平台上Canopy-Kmeans并行聚类算法的研究，旨在解决大数据处理中的高维和海量特性问题。该算法利用三角不等式原理减少计算冗余，提高执行效率。在不同规模的数据集上，实验表明该并行聚类算法具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值