呵呵，继续。
本节的学习内容：
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类型的数字呢，我们现在使用词频的空间向量来代替这些文字。
分享到：
楼主，期待后续！！！！！！！！
相关推荐
HanLP实现功能完善，性能高效，架构清晰，语料时新，可自定义的特点。 穿越世界上最大的多语言种语料库，HanLP2.1支持包括简繁中英日俄法德内部的104种语言上的10种联合任务：分词（粗分，细分2个标准，强制，合并，...
TextProcessor Java软件包是一个文本处理工具包，它提供了一些常用的文本处理功能，例如词干，删除停用词，生成术语词汇表以及计算术语-文档频率矩阵。 还支持基本主题挖掘模型，例如LDA和稀疏NMF。 该软件包还可以...
一个用于处理2D分类，回归和聚类问题的简单工具。 它建立在JSAT之上，并使用Java 8。 该项目的意思是将简单的2D数据用于某些算法的简单方法。 我已经在测试中使用此代码一段时间了，或者只是在玩耍，所以我决定将...
6.) 在 Java 中编程 K-means 聚类以生成相关网页的聚类。 7.) 从前“N”个网页中提取代码段和标题以将它们显示给用户，以便用户可以选择与其查询更相关的网页。 8.) 编码和应用标量聚类，以便用户在输入查询词时...
文本分类聚类 拼音简繁转换 自然语言处理 HanLP: Han Language Processing | | | 面向生产环境的多语种自然语言处理工具包，基于 TensorFlow 2.0，目标是普及落地最前沿的NLP技术。HanLP具备功能完善、性能高效、...
LEAN是一组Java工具，用于从文本文档中生成词频矩阵。 LEAN工具旨在与GTRI / GA Tech SmallK软件发行版兼容，该软件发行版消耗术语频率矩阵并执行分层和平面聚类。 LEAN软件发行版目前包含两个工具：DocIndexer和...
其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本（如 Word、PDF）的处理。Solr 是高度可扩展的，并提供了分布式搜索和索引复制。Solr 4 还增 加了 NoSQL 支持，以及基于 Zookeeper ...
核心算法是用Java实现的并且自成体系。 核心核心机器学习库。 Scala Scala中的高级操作员。 数学线性代数，统计分布，假设检验，随机数生成器，排序，特殊函数，各种核，距离和rbf函数。 数据解析器，用于arff，...
核心算法是用Java实现的并且自成体系。 核心核心机器学习库。 Scala Scala中的高级操作员。 数学线性代数，统计分布，假设检验，随机数生成器，排序，特殊函数，各种核，距离和rbf函数。 数据解析器，用于arff，...
OpenIMAJ是屡获殊荣的库和工具集合，用于多媒体（图像，文本，视频，音频等）内容分析和内容生成。 OpenIMAJ的范围非常广泛，包括从最先进的计算机视觉（例如SIFT描述符，显着区域检测，面部检测等）和高级数据聚类...
10.7 基于相似性传播算法的聚类分析 240 10.8 均值漂移算法 242 10.9 遗传算法 244 10.10 神经网络 249 10.11 决策树 251 10.12 小结 253 第 11章 Python生态系统的外部环境和云计算 255 11.1 与MATLAB/...
communities.py在脚本中指定的网络上运行 2 种聚类算法（Girvan-Newman 和 Closet-Newman-Moore）。 如果您想更改使用的网络，您可以修改它。 最后，您将获得生成的集群数量和其他信息。 printInfo.py用颜色制作...