从网页相关性TF-IDF到余弦定理的新闻分类的程序实现

前提：TF-IDF 模型是搜索引擎等实际应用中被广泛使用的信息检索模型，但对于 TF-IDF 模型一直存在各种疑问。本文为信息检索问题一种基于条件概率的盒子小球模型，其核心思想是把“查询串q和文档d的匹配度问题”转化为“查询串q来自于文档d的条件概率问题”。它从概率的视角为信息检索问题定义了比 TF-IDF 模型所表达的匹配度更为清晰的目标。此模型可将 TF-IDF 模型纳入其中，一方面解释其合理性，另一方面也发现了其不完善之处。另外，此模型还可以解释 PageRank 的意义，以及 PageRank
权重和 TF-IDF 权重之间为什么是乘积关系.--->引用(http://baike.baidu.com/view/1228847.htm?fr=aladdin)。

2014年9月19日23:49:07 实现IF-IDF。才30%。坑啊，后期的阈值怎么设置还是需要研究的~

package com.lean;

import java.util.ArrayList;
import java.util.Arrays;

/*
* 1.如何度量网页和查询的相关性---信息检索领域
* TF-IDF(词频-逆文本频率指数)算法:
* TF词频=(词出现的次数/文本中中单词的总数)
* IDF=log(D/DW)=log(网页总数/包含特定单词的网页)---->为什么是log()，数学之美给出的解释是“一个特定条件下关键词的概率分布的交叉熵”
* 相关性=TF1*IDF1+TF2*IDF2+TF3*IDF3+...
*
* 2.如何利用余弦定理到新闻的自动分类算法
* 计算每个新闻词汇表的IDF。
* 将每个新闻词汇表IDF当做特征向量-->数组实现，每个下标对应特定的单词
* 利用余弦公式计算新闻两两之间的夹角A,(A角度越大，相关性就越小，平行时相关性最大)
* 不断合并A<T(T代表阈值，根据经验划分)产生的小类
* 继续计算各个小类的特征向量，继续合并，直到合并为1个大类。
* 根据合并的层次大小，决定新闻分类的规模，ok
*
*
* 3.优化算法复杂度：
* 余弦定理的分子分母优化，做记忆化存储。
* 删除虚词(的，是，和，一些连词，副词，介词，只定位实词"aXb"模式)
* 位置的加权（主题的关键词权重>正文，正文首尾关键词权重>中间）
*
* 模拟算法开始啦~~~
*/
public class newCate {
int A[]={};
static int news1[]={0,1,2,3,4,5,6,7,8,9,1,2,3,4,5,1,2,3,3,3};//代表一条新闻。文字用数字代替~~~
static int news2[]={12,13,19,11,12,13,14,15,11,12,13,13,3};
static int news3[]={10,11,12,13,24,24,25,21,22,23,23,13};

static int Keys[]={3,2,8};//3个关键词，当然假设已经经过分词处理过的结果

/*
* 计算词频
*/
private double[] getTF(ArrayList<int[]> newsList ,int keys[]) {
int n=newsList.size(),m=Keys.length;
double TF[]=new double[m];//词频

for (int i = 0; i < TF.length; i++) {
TF[i]=0;
}
/*
* 可以优化到nlogn~~~懒的写了~~
*/
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int news[]=newsList.get(j);
int K=news.length;
for (int k = 0; k <K ; k++) {
if(keys[i]==news[k]) TF[i]+=(1.0/K);
}
}
}
return TF;
}
/*
* 计算各个关键词的权重
* IDF=log(D/DW)=log(网页总数/包含特定单词的网页)
*/
private double[] getIDF(ArrayList<int[]> al,int keys[]) {
int D=al.size(),DW=0;
double IDF[]=new double[keys.length];

for (int i = 0; i < IDF.length; i++) {
DW= getDw(al,keys[i]);
IDF[i]+=Math.log(D/DW);
}
return IDF;
}

/*
* 计算出现关键词的新闻数
*/
private int getDw(ArrayList<int[]> newsList, int i) {
int cnt=0;
for (int j = 0; j < newsList.size(); j++) {
int news[]=newsList.get(j);
for (int k = 0; k < news.length; k++) {
if(news[k]==i){
cnt++;
break;
}
}
}
return cnt;
}

/*
* 词频*权重的集合
* 相关性=TF1*IDF1+TF2*IDF2+TF3*IDF3+...
*/
private double getRelate(double TF[],double IDF[]) {
int n=TF.length;
double ans=0.0;
for (int i = 0; i <n; i++) {
ans+=TF[i]*IDF[i];
}
return ans;
}

public static void main(String[] args) {
newCate nc=new newCate();

//---------------IF-IDF------------
//新闻网页集合
ArrayList<int[]> newsList=new ArrayList<int[]>();
newsList.add(news1);
newsList.add(news2);
newsList.add(news3);
newsList.add(news3);
newsList.add(news3);
newsList.add(news3);
double tf[]=nc.getTF(newsList, Keys);
double idf[]=nc.getIDF(newsList, Keys);
System.out.println("关键词词频集合="+Arrays.toString(tf));
System.out.println("关键词贡献集合="+Arrays.toString(idf));

double relate=nc.getRelate(tf, idf);
System.out.println("关键词的相关性="+relate);

//-----------news_cate-----------------------

}

}

新闻自动分类。程序貌似有点问题~~，实在是坑啊。阈值是硬伤

2014年9月20日12:28:55

package com.lean;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Vector;

/*
* 1.如何度量网页和查询的相关性---信息检索领域
* TF-IDF(词频-逆文本频率指数)算法:
* TF词频=(词出现的次数/文本中中单词的总数)
* IDF=log(D/DW)=log(网页总数/包含特定单词的网页)---->为什么是log()，数学之美给出的解释是“一个特定条件下关键词的概率分布的交叉熵”
* 相关性=TF1*IDF1+TF2*IDF2+TF3*IDF3+...
*
* 2.如何利用余弦定理到新闻的自动分类算法
* 计算每个新闻词汇表的TF-IDF。
* 将每个新闻词汇表TF-IDF当做特征向量-->数组实现，每个下标对应特定的单词
* 利用余弦公式计算新闻两两之间的夹角A,(A角度越大，相关性就越小，平行时相关性最大)
* 不断合并A<T(T代表阈值，根据经验划分)产生的小类
* 继续计算各个小类的特征向量，继续合并，直到合并为1个大类。
* 根据合并的层次大小，决定新闻分类的规模，ok
*
*
* 3.优化算法复杂度：
* 余弦定理的分子分母优化，做记忆化存储。
* 删除虚词(的，是，和，一些连词，副词，介词，只定位实词"aXb"模式)
* 位置的加权（主题的关键词权重>正文，正文首尾关键词权重>中间）
*
* 模拟算法开始啦~~~
*/
public class newCate {
int A[]={};
static int news1[]={0,1,2,3,4,5,6,7,8,9,1,2,3,4,5,1,2,3,3,3};//代表一条新闻。文字用数字代替~~~
static int news2[]={2,12,13,19,11,12,13,14,15,11,12,13,13,3};
static int news3[]={3,10,11,12,13,24,25,21,2,2,23,13};
static int news4[]={1,11,1,13,24,25,21,22,23,23,13};
static int news5[]={10,11,12,3,24,4,25,1,22,23,23,13};

static int Keys[]={3,2,8};//3个关键词，当然假设已经经过分词处理过的结果

static final int MAXN=1<<12;//4096个常用词汇
static final int MAXN_T=1<<5;//4096个常用词汇
static double wolds[]=new double[MAXN];   //词汇表
//double A[][]=new double[MAXN_T][MAXN_T]; //i,j向量的夹角的余弦值

final static double T=0.3;   //新闻归一化设定的阈值

/*
* 计算词频集合--每个实词的词频
*/
private double[] getTF(ArrayList<int[]> newsList ,int keys[]) {
int n=newsList.size(),m=Keys.length;
double TF[]=new double[m];//词频

for (int i = 0; i < TF.length; i++) {
TF[i]=0;
}
/*
* 可以优化到nlogn~~~懒的写了~~
*/
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int news[]=newsList.get(j);
int K=news.length;
for (int k = 0; k <K ; k++) {
if(keys[i]==news[k]) TF[i]+=(1.0/K);
}
}
}
return TF;
}
/*
* 计算各个关键词的权重集合--每个实词贡献率的集合
* IDF=log(D/DW)=log(网页总数/包含特定单词的网页)
*/
private double[] getIDF(ArrayList<int[]> al,int keys[]) {
int D=al.size(),DW=0;
double IDF[]=new double[keys.length];

for (int i = 0; i < IDF.length; i++) {
DW= getDw(al,keys[i]);
IDF[i]+=Math.log(D/DW);
}
return IDF;
}

/*
* 计算出现关键词的新闻数
*/
private int getDw(ArrayList<int[]> newsList, int i) {
int cnt=0;
for (int j = 0; j < newsList.size(); j++) {
int news[]=newsList.get(j);
for (int k = 0; k < news.length; k++) {
if(news[k]==i){
cnt++;
break;
}
}
}
return cnt;
}

/*
* 词频*权重的集合
* 相关性=TF1*IDF1+TF2*IDF2+TF3*IDF3+...
*/
private double getRelate(double TF[],double IDF[]) {
int n=TF.length;
double ans=0.0;
for (int i = 0; i <n; i++) {
ans+=TF[i]*IDF[i];
}
return ans;
}

private Vector<double[]> getWoldsByNewsList(ArrayList<int[]> newsList, int[] Keys, double[] tf, double[] idf) {
newCate nc=new newCate();
int n=newsList.size(),m=Keys.length;

Vector<double[]> v=new Vector<double[]>();//新闻向量集合

for (int i = 0; i < n; i++) {//newsList
double v_k[]=new double[MAXN_T];
for (int j = 0; j <m; j++) {//Key
int news[]=newsList.get(i);
int K=news.length;
for (int k = 0; k <K ; k++) {  //news
if(Keys[j]==news[k])v_k[Keys[j]]+=(1.0/K); ;
}

}
for (int j = 0; j <m; j++) {
v_k[j]=idf[j]*v_k[j];
}
v.add(v_k);
}
return v;
}

/*
* 每条新闻的特征向量--->计算两两之间的余弦值
*
*/
private static double[][] getAByVect(Vector<double[]> v) {
int n=v.size();
double A[][]=new double[n*n][n*n];

for (int i = 0; i <n; i++) {
for (int j = i; j <n; j++) {
double fenzi=0.0,fenmu=0.0;
double a1[]=v.get(i),a2[]=v.get(j);
int m=a1.length;
for (int k = 0; k < m; k++) {
if(a1[k]==0 || a2[k]==0)continue;
fenzi+=a1[k]*a2[k];
}
double fm_1=0.0,fm_2=0.0;
for (int k = 0; k < m; k++) {
if(a1[k]==0)
continue;
fm_1+=a1[k]*a1[k];
}
for (int k = 0; k < m; k++) {
if(a2[k]==0)
continue;
fm_2+=a2[k]*a2[k];
}
fenmu=Math.sqrt(fm_1)*Math.sqrt(fm_2);
A[i][j]=fenzi/fenmu;
}
}
return A;
}

public static void main(String[] args) {
newCate nc=new newCate();
//---------------IF-IDF------------
//新闻网页集合
ArrayList<int[]> newsList=new ArrayList<int[]>();
newsList.add(news1);
newsList.add(news2);
newsList.add(news3);
newsList.add(news4);
newsList.add(news5);
double tf[]=nc.getTF(newsList, Keys);
double idf[]=nc.getIDF(newsList, Keys);
System.out.println("关键词词频集合="+Arrays.toString(tf));
System.out.println("关键词贡献集合="+Arrays.toString(idf));
double relate=nc.getRelate(tf, idf);
System.out.println("本次查询的相关性="+relate);

//-----------news_cate-----------------------
//计算每个新闻的词汇表集合
Vector<double[]> TF_IDF_list= nc.getWoldsByNewsList(newsList,Keys,tf,idf);
for (int i = 0; i < TF_IDF_list.size(); i++) {
System.out.println(Arrays.toString(TF_IDF_list.get(i)));
}

//输出新闻之间的余弦值
double A[][]=getAByVect(TF_IDF_list);
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.print(A[i][j]+" ");
}
System.out.println("");
}
System.out.println("归一化新闻分类");
//设定阈值，合并新闻分类--自低向上合并，归一化
megerByA(A,T);

}

/*
* 归一化-->新闻分类合并
*
*/
private static void megerByA(double[][] A, double T) {
int n=A.length;
//NewsA na[]=new NewsA[n*(n-1)];
ArrayList<NewsA> al=new ArrayList<NewsA>();
int k=0;
for (int i = 0; i < n; i++) {
for (int j = i; j <=i; j++) {
NewsA ne=new NewsA(i,j,A[i][j]);
al.add(ne);
}
}
Collections.sort(al, new cmp());
int nn=al.size();
int r=nn-1;
double d=al.get(r).data;

/*for (int i = 0; i < nn; i++) {
System.out.println(al.get(i).data);
}*/
int cnt=1;
while(true){
System.out.println("第"+(cnt++)+"类");
double dd=d;
while(0<=r && (d-dd)<=T && dd>=0){
NewsA aa=al.get(r);
dd=aa.data;
if(dd>-0.00001 && dd<0.00001) {
r--;
continue;
}else{
if(dd>0){
System.out.println(aa.i+","+aa.j+"  "+dd);
}
}
r--;
}
d-=T;
if(d<0) break;
}

}

}
class cmp implements Comparator<NewsA>{

@Override
public int compare(NewsA o1, NewsA o2) {
if(o1.data>=o2.data){
return 1;
}
return 0;
}

}
class NewsA{
int i;
int j;
double data;
public NewsA(int i,int j,double data) {
this.i=i;
this.j=j;
this.data=data;

}
}

托坑了。本想用c语言写的。java语言突然不熟悉了。。。。也算是出坑了。

算法复杂度有点高了。我想说优化代码还木写。赶紧吃饭~~~先