MoreLikeThis 相似检索

出处:http://www.cnblogs.com/huangfox/archive/2012/07/05/2578179.html

MoreLikeThis,相似检索。找出某篇文档的相似文档,常见于“类似新闻”、“相关文章”等,这里完全是基于内容的分析。

 

1)MoreLikeThis的使用

                 FSDirectory directory = SimpleFSDirectory.open( new File( "d:/nrtTest2" ));
         IndexReader reader = IndexReader.open(directory);
         IndexSearcher searcher = new IndexSearcher(reader);
         //
         MoreLikeThis mlt = new MoreLikeThis(reader);
         mlt.setFieldNames( new String[] { "ab" }); //用于计算的字段
         //
         int docNum = 1 ;
//      TermFreqVector vector = reader.getTermFreqVector(docNum, "ab");
//      System.out.println(vector.toString());
         Query query = mlt.like(docNum); //试图找到与docnum=1相似的documents
         System.out.println(reader.document(docNum));
         System.out.println(query.toString()); //查看构造的query,后面的就是常规的lucene的检索过程。
         TopDocs topDocs = searcher.search(query, 10 );
         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
         for (ScoreDoc sdoc : scoreDocs) {
             Document doc = reader.document(sdoc.doc);
             System.out.println(doc.get( "ti" ));
             // System.out.println(doc.get("ti"));
         }

 

2)MoreLikeThis的源码解读

把MLT运行起来很简单,那么我们进一步看看他是怎么实现的。

关键就是 Query query = mlt.like(docNum); 我们就从他下手。

 

2.1)like

public Query like( int docNum) throws IOException {
     if (fieldNames == null ) {
       // gather list of valid fields from lucene
       Collection<String> fields = ReaderUtil.getIndexedFields(ir);
       fieldNames = fields.toArray( new String[fields.size()]);
     }
     
     return createQuery(retrieveTerms(docNum));
   }

filedNames为参与“more like this”运算的字段,在moreLikeThis对象的setFiledNames方法中进行设置。

 

2.2)retrieveTerms

public PriorityQueue<Object[]> retrieveTerms( int docNum) throws IOException {
     Map<String,Int> termFreqMap = new HashMap<String,Int>();
     for ( int i = 0 ; i < fieldNames.length; i++) {
       String fieldName = fieldNames[i];
       TermFreqVector vector = ir.getTermFreqVector(docNum, fieldName); //取出term向量
       
       // 如果当前字段没有存储termVector,那么需要重新计算。其实这里就是分词,并计算term词频的过程,注意他默认使用的是StandardAnalyzer分词器!!!
       if (vector == null ) {
         Document d = ir.document(docNum);
         String text[] = d.getValues(fieldName);
         if (text != null ) {
           for ( int j = 0 ; j < text.length; j++) {
             addTermFrequencies( new StringReader(text[j]), termFreqMap,
                 fieldName);
           }
         }
       } else { //如果之前保存了termVector那么就方便多了。
         addTermFrequencies(termFreqMap, vector);
       }
       
     }

 

2.3)addTermFrequencies

由于TermVector中的term和field没有关系,不管是标题还是正文,只要term内容一样就将其频率累加。addTermFrequencies就做这个事情!

把累加的结果存放到termFreqMap中。

private void addTermFrequencies(Map<String,Int> termFreqMap,
       TermFreqVector vector) {
     String[] terms = vector.getTerms();
     int freqs[] = vector.getTermFrequencies();
     for ( int j = 0 ; j < terms.length; j++) {
       String term = terms[j];
       
       if (isNoiseWord(term)) {
         continue ;
       }
       // increment frequency
       Int cnt = termFreqMap.get(term);
       if (cnt == null ) {
         cnt = new Int();
         termFreqMap.put(term, cnt);
         cnt.x = freqs[j];
       } else {
         cnt.x += freqs[j];
       }
     }
   }

截止,我们将指定的文档(被匹配文档)按照指定的运算字段,将其term和对应的frequency存放到了map中。在这个过程中,我们看到了一个听起来比较牛逼的操作——去噪

那么这里怎么判断一个Term是不是噪音呢?

private boolean isNoiseWord(String term) {
     int len = term.length();
     if (minWordLen > 0 && len < minWordLen) {
       return true ;
     }
     if (maxWordLen > 0 && len > maxWordLen) {
       return true ;
     }
     if (stopWords != null && stopWords.contains(term)) {
       return true ;
     }
     return false ;
   }

他判断的标准十分简单,第一:是否是规定的停用词;第二:term长度是否过长或过短,这个范围由minWordLen和maxWordLen控制。

 

2.4)createQueue

这里的queue应该是一个优先级队列,上一步我们获得了所有<term, frequency>,虽然做了去噪,但是term项目还是太多了,还需要找出相对重要的前N个Term。

private PriorityQueue<Object[]> createQueue(Map<String,Int> words)
       throws IOException {
     // 获取当前index的文档总数。
     int numDocs = ir.numDocs();
     FreqQ res = new FreqQ(words.size()); // 按照term的得分进行存放
     
     Iterator<String> it = words.keySet().iterator();
     while (it.hasNext()) { // 对所有term进行遍历
       String word = it.next();
       
       int tf = words.get(word).x; // 对应term的tf
       if (minTermFreq > 0 && tf < minTermFreq) {
         continue ; // 和去噪类似,tf太小的term直接过掉。
       }
       
       // 对于同一个term,找到df最大的那个字段,存放到topField。
       String topField = fieldNames[ 0 ];
       int docFreq = 0 ;
       for ( int i = 0 ; i < fieldNames.length; i++) {
         int freq = ir.docFreq( new Term(fieldNames[i], word));
         topField = (freq > docFreq) ? fieldNames[i] : topField;
         docFreq = (freq > docFreq) ? freq : docFreq;
       }
       //df太小的term也要直接过掉
       if (minDocFreq > 0 && docFreq < minDocFreq) {
         continue ; // filter out words that don't occur in enough docs
       }
       //df太大的term也要直接过掉
       if (docFreq > maxDocFreq) {
         continue ; // filter out words that occur in too many docs
       }
       //df==0的term也要直接过掉,怎么会有df的term???这里说是index文件的问题
       if (docFreq == 0 ) {
         continue ; // index update problem?
       }
       //经典的idf、tf又来了
       float idf = similarity.idf(docFreq, numDocs);
       float score = tf * idf;
       
       //将结果存放到优先队列中。
       res.insertWithOverflow( new Object[] {word, // the word
           topField, // the top field
           Float.valueOf(score), // overall score
           Float.valueOf(idf), // idf
           Integer.valueOf(docFreq), // freq in all docs
           Integer.valueOf(tf)});
     }
     return res;
   }

在这里,我们对每个term进行了打分排序,主要还是通过tf、idf进行计算。

这里他的意思就是:

1.将指定参与运算字段的term的frequency进行累加;(这里对ti、ab字段的tf进行累加)

2.通过df的比较,选取df大的字段作为最终“运算”的字段,但tf为所有字段的累加值。这和我们看普通检索时的打分算法不太一样,普通检索中tf为当前字段的词频。

至于为什么这么做,还得验证!!!

 

2.5)createQuery

到此我们将term的打分排序拿到了,分值越大的term更能表述整篇document的主要内容!(有没有想到这就类似主题词!!!

private Query createQuery(PriorityQueue<Object[]> q) {
     BooleanQuery query = new BooleanQuery();
     Object cur;
     int qterms = 0 ;
     float bestScore = 0 ;
     
     while (((cur = q.pop()) != null )) {
       Object[] ar = (Object[]) cur;
       TermQuery tq = new TermQuery( new Term((String) ar[ 1 ], (String) ar[ 0 ]));
       //这里还可以对termquery进行boost的设置。默认为false
       if (boost) {
         if (qterms == 0 ) {
           bestScore = ((Float) ar[ 2 ]).floatValue();
         }
         float myScore = ((Float) ar[ 2 ]).floatValue();
         
         tq.setBoost(boostFactor * myScore / bestScore);
       }
       //构建boolean query,should关联。
       try {
         query.add(tq, BooleanClause.Occur.SHOULD);
       } catch (BooleanQuery.TooManyClauses ignore) {
         break ;
       }
       
       qterms++;
       if (maxQueryTerms > 0 && qterms >= maxQueryTerms) { //限定参与运算的term的数量
         break ;
       }
     }
     
     return query;
   }

这样就根据一篇document和指定字段得到了一个query。这个query作为代表着document的灵魂,将寻找和他类似的documents。

 

3)实例

被匹配的document为:

Document<stored,indexed,tokenized<an:CN00103249.6>

stored,indexed<ad:20000320> stored,indexed,tokenized,termVector<ab:    本发明涉及一种高级毛料服装洗涤剂。使用该洗涤剂,洗衣服可不用到干洗店,自己在家水洗就行,且洗涤后毛料服装笔挺膨松,抗静电,不缩水,洗涤中不刺激皮肤。此剂主要由去污剂、抗静电剂、防缩剂、表面活性剂与其它助剂配制而成。去污率≥90%,缩水率≤1‰。>

stored,indexed,tokenized,termVector<ti:高级毛料服装洗涤剂>>

计算出来的query为:

ab:毛料 ab:服装 ab:洗涤剂 ab:抗静电 ab:高级 ab:剂 ab:洗涤

计算结果为:

高级毛料服装洗涤剂
抗静电防尘污灭菌广谱洗涤剂及制备方法
一种抗紫外线的织物涂层材料
服装绿色干洗及服装翻新技术
洗碟用柔性含蛋白酶的液体或凝胶洗涤组合物
复合洗霉制剂
洗衣机
一种抗静电合成纤维
实验室专用洗涤剂
液晶相结构型液体洗涤剂及制造工艺

貌似结果不是很相似,那么我们可以试着只用ti做运算,这样从标题看起来比较相似。

还可以对MLT的各项参数进行设置,这里就不在实验了!


评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值