`

生成文本聚类java实现 (2)

Java算法C#C++C 
阅读更多

   呵呵，继续。

　本节的学习内容：

 

4.从剩余的词中提取文本特征，即最能代表文本的词  
5.用空间向量表示文本，空间向量需标准化，即将数值映射到-1到1之间  
6.利用所获取的空间向量进行聚类分析  
7.交叉验证

第四步，提取文本特征

　本文使用KNN算法和SVM算法学习提取文本特征的思想。

　研究最终目的。
　训练材料：

语料 分类
腐化  "生活作风"  "女色"  "情妇"   "权色"   "生活糜烂"   "生活堕落" 生活作风

"东城" "西城" "崇文" "宣武" "朝阳" "海淀" "丰台" "石景山" "房山" "通州" "顺义" "大兴" "昌平

" "平谷" "怀柔" "门头沟" "密云" "延庆"

 北京
上访  信访  举报  揭发  揭露  "买官"  "卖官" 上访举报
李刚  "河大撞人"　撞人 我爸是李刚
"送钱短信" OR ( 驾校 AND 交警 ) 送钱短信

"乐东县" "保亭县" "陵水县" "琼中县" "白沙县" "昌江县" "屯昌县" "定安县" "澄迈县" "临高县"

"儋州" "东方" "五指山" "万宁" "琼海" "文昌" "三亚" "海口"

 海南

 

　训练结果就是跟上面语料和分类的有极高的相似度。

 

下面是基本的KNN算法。KNN.java

package com.antbee.cluster.knn;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;

/**
 * @author KNN算法主体类
 * @version 创建时间：2011-4-2 下午03:47:28
 * 类说明
 */
public class KNN {
	/** 
     * 设置优先级队列的比较函数，距离越大，优先级越高 
     */  
    private Comparator<KNNNode> comparator = new Comparator<KNNNode>() {  
        public int compare(KNNNode o1, KNNNode o2) {  
            if (o1.getDistance() >= o2.getDistance()) {  
                return 1;  
            } else {  
                return 0;  
            }  
        }  
    };  
    /** 
     * 获取K个不同的随机数 
     * @param k 随机数的个数 
     * @param max 随机数最大的范围 
     * @return 生成的随机数数组 
     */  
    public List<Integer> getRandKNum(int k, int max) {  
        List<Integer> rand = new ArrayList<Integer>(k);  
        for (int i = 0; i < k; i++) {  
            int temp = (int) (Math.random() * max);  
            if (!rand.contains(temp)) {  
                rand.add(temp);  
            } else {  
                i--;  
            }  
        }  
        return rand;  
    }  
    /** 
     * 计算测试元组与训练元组之前的距离 
     * @param d1 测试元组 
     * @param d2 训练元组 
     * @return 距离值 
     */  
    public double calDistance(List<Double> d1, List<Double> d2) {  
        double distance = 0.00;  
        for (int i = 0; i < d1.size(); i++) {  
            distance += (d1.get(i) - d2.get(i)) * (d1.get(i) - d2.get(i));  
        }  
        return distance;  
    }  
    /** 
     * 执行KNN算法，获取测试元组的类别 
     * @param datas 训练数据集 
     * @param testData 测试元组 
     * @param k 设定的K值 
     * @return 测试元组的类别 
     */  
    public String knn(List<List<Double>> datas, List<Double> testData, int k) {  
        PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k, comparator);  
        List<Integer> randNum = getRandKNum(k, datas.size());  
        for (int i = 0; i < k; i++) {  
            int index = randNum.get(i);  
            List<Double> currData = datas.get(index);  
            String c = currData.get(currData.size() - 1).toString();  
            KNNNode node = new KNNNode(index, calDistance(testData, currData), c);  
            pq.add(node);  
        }  
        for (int i = 0; i < datas.size(); i++) {  
            List<Double> t = datas.get(i);  
            double distance = calDistance(testData, t);  
            KNNNode top = pq.peek();  
            if (top.getDistance() > distance) {  
                pq.remove();  
                pq.add(new KNNNode(i, distance, t.get(t.size() - 1).toString()));  
            }  
        }  
          
        return getMostClass(pq);  
    }  
    /** 
     * 获取所得到的k个最近邻元组的多数类 
     * @param pq 存储k个最近近邻元组的优先级队列 
     * @return 多数类的名称 
     */  
    private String getMostClass(PriorityQueue<KNNNode> pq) {  
        Map<String, Integer> classCount = new HashMap<String, Integer>();  
        for (int i = 0; i < pq.size(); i++) {  
            KNNNode node = pq.remove();  
            String c = node.getC();  
            if (classCount.containsKey(c)) {  
                classCount.put(c, classCount.get(c) + 1);  
            } else {  
                classCount.put(c, 1);  
            }  
        }  
        int maxIndex = -1;  
        int maxCount = 0;  
        Object[] classes = classCount.keySet().toArray();  
        for (int i = 0; i < classes.length; i++) {  
            if (classCount.get(classes[i]) > maxCount) {  
                maxIndex = i;  
                maxCount = classCount.get(classes[i]);  
            }  
        }  
        return classes[maxIndex].toString();  
    }  
}

   KNNNode.java　结点类

package com.antbee.cluster.knn;
/**
 * @author KNN结点类，用来存储最近邻的k个元组相关的信息 
 * @version 创建时间：2011-4-2 下午03:43:39
 * 类说明
 */
public class KNNNode {
	private int index; // 元组标号  
    private double distance; // 与测试元组的距离  
    private String c; // 所属类别  
    public KNNNode(int index, double distance, String c) {  
        super();  
        this.index = index;  
        this.distance = distance;  
        this.c = c;  
    }  
      
      
    public int getIndex() {  
        return index;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
    public double getDistance() {  
        return distance;  
    }  
    public void setDistance(double distance) {  
        this.distance = distance;  
    }  
    public String getC() {  
        return c;  
    }  
    public void setC(String c) {  
        this.c = c;  
    }  
}

 TestKNN.java　测试类

package com.antbee.cluster.knn;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

/**
 * @author Weiya He E-mail:heweiya@gmail.com
 * @version 创建时间：2011-4-2 下午03:49:04
 * 类说明
 */
public class TestKNN {
	/** 
     * 从数据文件中读取数据 
     * @param datas 存储数据的集合对象 
     * @param path 数据文件的路径 
     */  
    public void read(List<List<Double>> datas, String path){  
        try {  
            BufferedReader br = new BufferedReader(new FileReader(new File(path)));  
            String data = br.readLine();  
            List<Double> l = null;  
            while (data != null) {  
                String t[] = data.split(" ");  
                l = new ArrayList<Double>();  
                for (int i = 0; i < t.length; i++) {  
                    l.add(Double.parseDouble(t[i]));  
                }  
                datas.add(l);  
                data = br.readLine();  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 程序执行入口 
     * @param args 
     */  
    @Test
    public void test() {  
        TestKNN t = new TestKNN();  
        String datafile = this.getClass().getClassLoader().getResource("datafile.txt").toString();
        datafile = datafile.replace("file:/", "");//windows 环境上要做的一步
        String testfile = this.getClass().getClassLoader().getResource("testfile.txt").toString();
        testfile = testfile.replace("file:/", "");//windows 环境上要做的一步
        try {  
            List<List<Double>> datas = new ArrayList<List<Double>>();  
            List<List<Double>> testDatas = new ArrayList<List<Double>>();  
            t.read(datas, datafile);  
            t.read(testDatas, testfile);  
            KNN knn = new KNN();  
            for (int i = 0; i < testDatas.size(); i++) {  
                List<Double> test = testDatas.get(i);  
                System.out.print("测试元组: ");  
                for (int j = 0; j < test.size(); j++) {  
                    System.out.print(test.get(j) + " ");  
                }  
                System.out.print("类别为: ");  
                System.out.println(Math.round(Float.parseFloat((knn.knn(datas, test, 2)))));  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

 　datafile.txt文件内容：

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 1  
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 1  
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 1  
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 0  
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 1  
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 0

 　testfile.txt文件内容：

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5  
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8  
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2  
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5  
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5  
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5

 最终的运行结果：

测试元组: 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 类别为: 1
测试元组: 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 类别为: 1
测试元组: 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 类别为: 1
测试元组: 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 类别为: 0
测试元组: 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 类别为: 1
测试元组: 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 类别为: 0

 下面的工作就是如何让汉字也成为如上的Long类型的数字呢，我们现在使用词频的空间向量来代替这些文字。

 

分享到：
| 抓取口碑网店铺资料
评论
9 楼 w630636065 2015-01-23  
楼主，期待后续！！！！！！！！
8 楼 zilong513 2014-03-18  
十分感谢楼主，期待后续。
7 楼 hui94781674 2013-04-03  
楼主怎么没有后续了啊？？
6 楼 tailong6868 2012-08-27  
期待继续啊 
5 楼 ilxx1988 2012-07-03  
怎么没有后续了呢？？期待
4 楼 lands2 2012-03-26  
楼主牛人啊，正需这方面内容，楼主能不能介绍一下这些知识在哪里学的吗？还有就是真心希望楼主能更新下一篇文章：
4.从剩余的词中提取文本特征，即最能代表文本的词   
5.用空间向量表示文本，空间向量需标准化，即将数值映射到-1到1之间   
6.利用所获取的空间向量进行聚类分析   
7.交叉验证
3 楼 luobo525 2012-01-29  
怎么没有后续了呢,非常期待啊
2 楼 liuxueyuyong 2011-06-02  
多谢楼主， 正在研究分类聚类，学习了！
1 楼 zhzhl202 2011-05-12  
楼主 这个系列文章怎么没有更新了，大家都等着看呢？楼主 加油呀
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Kmeans文本聚类java实现

    在Java环境中实现KMeans算法进行文本聚类，可以为大数据分析、信息检索和推荐系统等应用场景提供有力支持。 KMeans算法的基本思想是通过迭代过程，不断调整样本的归属，使得同一簇内的样本尽可能接近，不同簇间的...

    Java中通过HanLP实现文本分词、提取关键词、聚类（工具资源+实例）

    HanLP是由一系列模型与算法组成的工具包，目标是普及自然语言处理在生产环境中的应用。HanLP具备功能完善、性能高效、架构...提供词法分析（中文分词、词性标注、命名实体识别）、句法分析、文本分类和情感分析等功能。

    计算机研究 -后缀树及其在中文文本聚类中的应用探索.pdf

    在研究的过程中，本人首先实现了将中文文本生成后缀树结构的演示程序，然后用 java 实现了针对单篇文档的高频短语发现器和针对多篇文档的公共短语发现器，并以主题相似的文档集、不同主题的文档集和主题一致的网页...

    凝聚层次聚类算法JAVA实现.docx

    凝聚层次聚类算法的实现相对复杂，但下面是一个简化的JAVA代码示例，可以帮助理解其实现的基本思路： ```java import java.util.ArrayList; import java.util.List; public class AgglomerativeClustering { ...

    doc2vec的java实现

    虽然原生的Gensim是用Python编写的，但通过Jython（Python的Java实现）或其他Java调用Python库的方法，可以在Java项目中使用Gensim的DOC2Vec功能。 **步骤详解** 1. **数据预处理**：首先，你需要对输入的文本进行...

    dbscan.rar_DBSCAN_DBScan java_clustering in jsp_dbscan.zip_聚类 ja

    2. 初始化参数：确定ε和MinPts的值，这两个参数的选择直接影响聚类结果。 3. 执行DBSCAN：遍历数据集中的每个点，对每个点执行密度可达性判断和聚类过程。 4. 输出结果：将聚类结果以适当的形式返回，如颜色编码的...

    hadoop kmeans中文网页聚类 实验文档

    根据提供的测试数据，可以通过提取网页正文得到文档(document)，再通过分词获取文档中的词汇，从而将聚类问题转化为文本聚类问题。考虑到中文的特殊性，实验采用了Unicode编码范围（\u4e00-\u9fa5）来提取所有的汉字...

    人工智能-LDA-主题分析-LDA（潜在狄利克雷分配）的 Java 实现， 用几行 Java 代码从一组文档中推断主题

    总之，LDA作为一种强大的文本挖掘工具，通过Java实现能够高效处理大量文本数据，揭示文档中的潜在主题。LDA4j等Java库的出现，使得开发人员能够轻松地将主题分析技术融入到各种应用场景中，如新闻分类、用户兴趣分析...

    java利用matlib导出的jar包计算特征值

    2. **编译Matlab代码**：使用Matlab的` mcc -m`命令将Matlab代码编译为Java类，生成相应的jar包。 3. **在Eclipse中导入jar包**：将生成的jar包添加到Eclipse项目的类路径中。 4. **编写Java代码**：在Java代码中...

    java版本的EM

    2. **EM.java**：这是EM算法的主要实现部分，可能包含了EM算法的迭代过程，包括期望（E）步骤和最大化（M）步骤。在E步骤中，计算每个观测数据点的后验概率；在M步骤中，基于这些概率更新模型参数。这个类可能还包含...

    优质课件 北京大学研究生课程文本挖掘 文本数据挖掘全套PPT教程（共106页） TextMining03-检索(2).pptx

    Lucene是Java实现的全文索引库，广泛应用于搜索引擎开发，其开发者有丰富的全文检索经验。 在文本特征提取技术中，可能会涉及词频统计、TF-IDF权重计算、停用词移除和词干提取等预处理步骤，这些是提高检索效果的...

    62种常见算法（JAVA,C实现都有）

    "62种常见算法（JAVA,C实现都有）"这个资源集合提供了一套丰富的算法实现，涵盖了多种基础到进阶的算法，对于学习者和开发者来说，这是一个宝贵的资料库。下面将详细讨论这些算法以及它们在Java和C语言中的实现。 ...

    优质课件 北京大学研究生课程文本挖掘 文本数据挖掘全套PPT教程（共67页） TextMining14-文本挖掘工具与应用.ra

    10. **文本生成**：近年来，随着深度学习的发展，自动生成文本的技术也取得了显著进步，如使用seq2seq模型、transformer等。 11. **文本挖掘工具**：课程可能会介绍一些常用工具，如NLTK、Spacy（Python）、Gensim...

    GetFileTimes.rar_IF-IDF_TF_java TF-IDF_tf idf_tf idf java

    在压缩包内的文件中，"GetFileTimes.java"很可能是实现TF-IDF算法的主要源代码文件，可能包括读取文本、计算词频、计算IDF值以及生成输出等功能。而"www.pudn.com.txt"则可能是一个示例文本文件，用于测试代码，这个...

    基于关键词提取的矩阵生成程序

    2. `doc1.txt` 和 `doc2.txt`：这些可能是测试用的文本文件，用于检验程序的关键词提取和矩阵生成功能。 3. `Readme.txt`：这是一个标准的文档，通常包含关于程序如何运行、如何使用以及注意事项的信息。 综上所述...

    机器学习/深度学习、数据分析/风险控制/数据挖掘和算法 文本分类、信息提取和文本生成

    在文本处理中，这些算法可以用于特征选择、模型训练和参数调优，以实现更高效和准确的模型。 在文件"charent-main"中，可能包含了关于这些主题的代码、模型、数据集或其他相关资源，供研究者和开发者使用，以进一步...

    elasticsearch-carrot2-7.5.0.zip

    7. elasticsearch-carrot2-7.5.0.jar：这是 Elasticsearch Carrot2 插件的主要实现，包含了与 Elasticsearch 的集成代码以及 Carrot2 聚类算法的适配逻辑。 8. jackson-annotations-2.8.11.jar：Jackson 注解库，...

    elasticsearch-carrot2-7.5.2.zip

    elasticsearch-carrot2 插件就是针对这一需求设计的，它为 ElasticSearch 提供了强大的文本聚类功能。 Carrot2 是一个开源的搜索结果聚类库，支持多种数据源和多种语言。在 ElasticSearch 中集成 Carrot2 插件，...

    LDA.rar_LDA 文档主题_java LDA_lda_lda java_lda模型

    Gensim虽然主要以Python实现，但也有Java接口，允许Java开发者利用其强大的文本处理能力。 **LDA模型的步骤** 1. **数据预处理**：首先，需要对输入的文本数据进行清洗，包括去除标点符号、数字、特殊字符，转换为...

    智能问答系统demo, word2vec语义匹配

    3. 文本分类与聚类：word2vec向量可以作为特征输入，用于文本分类、情感分析等任务，提高模型的准确性。 4. 问答系统：在智能问答系统中，word2vec可以用来计算问题和候选答案之间的语义相似度，从而找出最合适的...

Magicbox
Global site tag (gtag.js) - Google Analytics