深入理解lucene原理
lucene 基本概念

lucene 基本概念Lucene 基本概念Lucene 是一个开源的全文搜索引擎库,被广泛地应用于高性能搜索和索引任务中。
它是 Apache 软件基金会的一个开源项目,并且被许多知名的商业产品使用。
本文将通过一步一步的方式,来介绍 Lucene 的基本概念和其原理。
一、Lucene 是什么?Lucene 是一个基于 Java 的全文搜索引擎库。
它提供了一系列的 API 和工具,用于创建、维护和搜索大规模文本数据集。
通过将文本数据索引到 Lucene 的索引库中,我们可以快速地进行全文搜索、排序和过滤等操作。
二、Lucene 的基本原理1. 倒排索引倒排索引是 Lucene 的核心概念之一。
它是一种数据结构,用于从词项到文档的映射。
通常,我们将文本数据分割成单词,然后对每个词项构建一个索引条目,该条目指向包含该词项的文档。
例如,假设我们有三个文档:文档1 包含 "Lucene 是一个搜索引擎库",文档2 包含 "Apache Lucene 是一个全文搜索库",文档3 包含 "Lucene 是基于 Java 的"。
在倒排索引中,我们将按照词项构建索引,如下所示:词项文档Lucene 1, 2, 3是 1, 2, 3一个 1, 2, 3搜索引擎库 1全文搜索库 2基于 3Java 3倒排索引的优势在于它能够快速地确定包含特定词项的文档,并且支持更复杂的查询表达式。
2. 分词器分词器是将原始文本分割成词项的模块。
Lucene 提供了多种分词器,如标准分词器、简单分词器等。
分词器还可以根据具体的需求进行定制。
分词器在构建索引和搜索时起到关键作用,它们确保在索引和搜索阶段都使用相同的分词规则。
3. 文档和字段在 Lucene 中,文档是一个最小的索引单位。
它由多个字段组成,每个字段包含一个词项或多个词项。
字段可以是文本、数值或日期等不同类型。
Lucene 中的文档和字段的设计灵活,可以根据实际需求进行定义和修改。
lucene 的模糊匹配原理

一、lucene模糊匹配原理概述lucene是一个开源的全文检索引擎工具,提供了强大的文本搜索和分析功能。
在实际应用中,经常需要进行模糊匹配,以处理用户输入的错别字、拼写错误或者同义词。
模糊匹配是lucene中非常重要的功能,它可以帮助用户找到相关的文档,提高搜索的准确性和全面性。
二、lucene模糊匹配的算法原理1. Levenshtein Distance算法Levenshtein Distance是衡量两个字符串相似程度的一种算法,也称为编辑距离。
在lucene中,模糊匹配主要使用Levenshtein Distance算法来实现。
该算法通过计算两个字符串之间的距离,从而确定它们的相似程度。
具体来说,它通过插入、删除和替换操作,将一个字符串转换成另一个字符串所需的最小步骤数来衡量相似度。
2. 模糊查询的实现方式在lucene中,模糊查询可以通过FuzzyQuery类来实现。
利用FuzzyQuery,可以指定一个最大编辑距离,从而允许匹配到具有一定相似度的文档。
FuzzyQuery会基于Levenshtein Distance算法来进行模糊匹配,找到编辑距离小于等于指定值的文档。
三、模糊匹配的应用场景1. 处理用户输入错误当用户在搜索框中输入错别字或者拼写错误时,模糊匹配可以帮助系统找到相关的文档,并提供纠正建议,提高搜索的准确性和用户体验。
2. 同义词匹配在自然语言处理中,同一个概念可能有多种不同的表达方式。
通过模糊匹配,可以将具有相似含义的词语进行匹配,从而提高搜索的全面性。
3. 解决词形变化问题词形变化是自然语言中常见的现象,同一个词可能有不同的变形形式。
通过模糊匹配,可以将不同词形的单词对应起来,使得搜索更加全面和准确。
四、模糊匹配的优化策略1. 设置合适的编辑距离阈值在使用模糊匹配时,需要根据具体的应用场景来设置合适的编辑距离阈值。
如果编辑距离过小,可能会产生大量的不必要匹配;如果编辑距离过大,可能会包含过多的无关文档。
lucene简介原理及实践(共48张)

Analyzer
在一个文档被索引之前,首先需要对文档内容进行分词处理, 并且而剔除一些冗余的词句(例如:a,the,they等),这部分工作
就是由 Analyzer 来做的。
Analyzer 类是一个抽象类,它有多个实现。
BrazilianAnalyzer, ChineseAnalyzer, CJKAnalyzer, CzechAnalyzer, DutchAnalyzer, FrenchAnalyzer, GermanAnalyzer, GreekAnalyzer, KeywordAnalyzer, PatternAnalyzer, PerFieldAnalyzerWrapper, RussianAnalyzer, SimpleAnalyzer, SnowballAnalyzer, StandardAnalyzer, StopAnalyzer, ThaiAnalyzer, WhitespaceAnalyzer
通过实现特定API,完成文档建立索引的工 作
第7页,共48页。
Lucene搜索机制-B 基于(jīyú)索引搜索
Lucene通过特定的类,可以对索引进行操 作
通过特定的类,封装搜索结果,供应用程 序处理
第8页,共48页。
Lucene系统结构
第9页,共48页。
Lucene包结构(jiégòu)功能表
第19页,共48页。
Field
Field 对象(duìxiàng)是用来描述一个文档的某个属性的,比如一封电子邮件的标 题和内容可以用两个 Field 对象分别描述。
Field(String name, byte[] value, Field.Store store) Create a stored field with binary value.
lucene倒排索引原理

lucene倒排索引原理
Lucene是一个开源的全文检索引擎库,它采用倒排索引的方式来实现快速检索。
所谓倒排索引,即把文档中所有的词汇按照词汇本身
为key进行索引,每个key对应一组包含该词汇的文档列表,这样,
当进行查询时,只需在索引中查找关键词,找到含有该词汇的文档列表,即可快速定位到相关文档。
相较于顺排索引,倒排索引可以极大
提高检索效率,尤其是当文档数量较大、数据量较大时,体现出其强
大的优势。
Lucene倒排索引的具体实现方式如下:首先,对于每个文档,Lucene会对文档中所有的词汇进行标准化处理,包括切词、去停留词、大小写转换、词干提取等操作,将处理后的词项(Term)按照词典序
进行排序,并对每个词项记录该词项在该文档中的出现位置等信息。
然后,对于每个词项,Lucene会建立一个包含该词项的倒排索引(Inverted Index)表,该表中记录了所有包含该词项的文档列表以
及每个文档中该词项出现的位置、频率等信息。
倒排索引表通常使用
基于内存的数据结构进行存储和查询,包括哈希表、B树、二分查找等,以保证检索效率。
最后,当用户进行查询操作时,Lucene会将查询语句进行分析、标准化等操作,并在倒排索引表中查找包含查询关键词的文档列表,
通过对文档列表进行排序和过滤等操作,得出最终的查询结果。
总之,Lucene倒排索引是一种高效的文本检索方式,通过对文本内容进行标准化和索引化,可以快速地定位到相关文档,具有广泛的
应用价值。
lucene对比中文近义词用法

标题:探讨Lucene对比中文近义词用法1. 简介为了更好地理解Lucene对比中文近义词用法,我们首先需要了解Lucene的基本概念和中文近义词的特点。
Lucene是一个全文检索引擎库,它提供了丰富的API,可以用于构建强大的全文搜索功能。
而中文近义词则是指在中文语境中,表达相似意义的词语,这些词语在不同的语境中可能会有微小的差别,但整体的意思是相通的。
2. Lucene的基本原理和功能Lucene通过倒排索引的方式来快速定位文档中的关键词,从而实现全文搜索的功能。
它采用了分词器来处理文本,将文本分割成若干个独立的单词,并将这些单词进行索引。
在搜索时,用户输入的查询语句也经过相同的分词处理,再与索引进行匹配,最终返回相关的文档。
3. 中文近义词的特点在中文语境中,由于词语的复杂性和多义性,往往会存在大量的近义词。
这些近义词可能在不同的场景中有不同的使用方式,但它们的基本意思是一致的。
“喜欢”和“爱好”就是一对中文近义词,它们都表示喜爱或偏好的意思,只是在语感上有细微的区别。
4. Lucene对比中文近义词用法在使用Lucene进行搜索时,对于中文近义词的处理往往是一个挑战。
由于中文的特殊性,同一个词可能存在多种不同的表达方式,而传统的搜索引擎很难将它们准确地匹配在一起。
针对这一问题,Lucene提供了同义词扩展的功能,可以将一些近义词视作同一个词来处理。
这样一来,用户在搜索时无需考虑到所有的近义词,只需要输入其中一个,就能够搜索到相关的文档。
5. 个人观点和总结通过对Lucene对比中文近义词用法的探讨,我们可以发现,Lucene在处理中文近义词时的确存在一些挑战,但它也提供了相应的解决方案。
在实际应用中,我们可以根据具体的需求,合理地进行同义词扩展,以提升搜索结果的准确性和覆盖范围。
对于中文近义词的掌握也需要结合具体的语境和语气来理解,不能简单地进行机械替换。
Lucene对比中文近义词用法的探讨,有助于我们更好地理解和应用这一强大的全文搜索引擎库。
lucene 原理

lucene 原理
Lucene原理可以归纳为以下几个方面:
1. 倒排索引:Lucene使用一种称为倒排索引的数据结构来存
储文档。
倒排索引是一种将词条映射到其出现的文档的数据结构。
它由一个词条词典和一系列倒排表组成。
词条词典将所有不重复的词条存储在一起,并记录每个词条在哪些文档中出现。
倒排表存储每个词条出现在哪些文档的具体位置。
2. 分词器:在建立倒排索引之前,Lucene需要将文档分割成
独立的词条。
分词器是负责此任务的组件。
Lucene提供了一
些内置的分词器,如标准分词器和简单分词器。
用户也可以自定义分词器来满足自己的需求。
3. 查询解析:Lucene支持用户使用查询字符串来进行检索。
查询解析器负责将查询字符串解析为内部的查询表达式。
查询解析器可以处理通配符、模糊查询以及布尔逻辑等。
解析的查询表达式可以直接用于搜索索引。
4. 相似度计算:在搜索过程中,Lucene根据查询对文档的匹
配程度来计算相似度得分。
相似度计算器使用了一种称为TF-IDF的算法,综合考虑了词频和逆文档频率。
相似度得分决定
了搜索结果的排序。
5. 检索评分:在对搜索结果进行排序时,Lucene使用了一种
称为检索评分的机制。
检索评分根据查询的相似度得分以及其他因素(如文档长度)来计算最终的结果得分。
结果得分决定
了搜索结果的排名。
通过以上原理,Lucene实现了高效的全文搜索功能。
它被广
泛应用于各种信息检索系统中,如搜索引擎、电子邮件过滤等。
一步一步跟我学习lucene(8)---lucene搜索之索引的查询原理和查询工具类

一步一步跟我学习lucene(8)---lucene搜索之索引的查询原理和查询工具类昨天我们了解了lucene搜索之IndexSearcher构建过程(/wuyinggui10000/article/details/4569866 7),对lucene的IndexSearcher有一个大体的了解,知道了怎么创建IndexSearcher,就要开始学会使用IndexSearcher进行索引的搜索,本节我们学习索引的查询原理和根据其相关原理写索引查询的工具类的编写;IndexSearcher常用方法IndexSearcher提供了几个常用的方法:•IndexSearcher.doc(int docID) 获取索引文件中的第n个索引存储的相关字段,返回为Document类型,可以据此读取document 中的Field.STORE.YES的字段;•IndexSearcher.doc(int docID, StoredFieldVisitor fieldVisitor) 获取StoredFieldVisitor指定的字段的document,StoredFieldVisitor定义如下[java] view plain copy1.StoredFieldVisitor visitor = new DocumentStoredFieldVisi tor(String... fields);•IndexSearcher.doc(int docID, Set<String> fieldsToLoad) 此方法同上边的IndexSearcher.doc(int docID, StoredFieldVisitor fieldVisitor) ,其实现如下图•IndexSearcher.count(Query query) 统计符合query条件的document个数•IndexSearcher.searchAfter(final ScoreDoc after, Queryquery, int numHits) 此方法会返回符合query查询条件的且在after 之后的numHits条记录;其实现原理为:先读取当前索引文件的最大数据条数limit,然后判断after是否为空和after对应的document的下标是否超出limit的限制,如果超出的话抛出非法的参数异常;设置读取的条数为numHits和limit中最小的(因为有超出最大条数的可能,避免超出限制而造成的异常)接下来创建一个CollectorManager类型的对象,该对象定义了要返回的T opDocs的个数,上一页的document的结尾(after),并且对查询结果进行分析合并最后调用search(query,manager)来查询结果•IndexSearcher.search(Query query, int n) 查询符合query条件的前n个记录•IndexSearcher.search(Query query, Collector results) 查询符合collector的记录,collector定义了分页等信息•IndexSearcher.search(Query query, int n,Sort sort, boolean doDocScores, boolean doMaxScore) 实现任意排序的查询,同时控制是否计算hit score和max score是否被计算在内,查询前n条符合query条件的document;•IndexSearcher.search(Query query, CollectorManager<C, T>collectorManager) 利用给定的collectorManager获取符合query 条件的结果,其执行流程如下:先判断是否有ExecutorService执行查询的任务,如果没有executor,IndexSearcher会在单个任务下进行查询操作;如果IndexSearcher有executor,则会由每个线程控制一部分索引的读取,而且查询的过程中采用的是future机制,此种方式是边读边往结果集里边追加数据,这种异步的处理机制也提升了效率,其执行过程如下:编码实践我中午的时候写了一个SearchUtil的工具类,里边添加了多目录查询和分页查询的功能,经测试可用,工具类和测试的代码如下:[java] view plain copy1.package com.lucene.search.util;2.3.import java.io.File;4.import java.io.IOException;5.import java.nio.file.Paths;6.import java.util.Set;7.import java.util.concurrent.ExecutorService;8.9.import org.apache.lucene.document.Document;10.import org.apache.lucene.index.DirectoryReader;11.import org.apache.lucene.index.IndexReader;12.import org.apache.lucene.index.MultiReader;13.import org.apache.lucene.search.BooleanQuery;14.import org.apache.lucene.search.IndexSearcher;15.import org.apache.lucene.search.Query;16.import org.apache.lucene.search.ScoreDoc;17.import org.apache.lucene.search.TopDocs;18.import org.apache.lucene.search.BooleanClause.Occur ;19.import org.apache.lucene.store.FSDirectory;20.21./**lucene索引查询工具类22.* @author lenovo23.*24.*/25.public class SearchUtil {26./**获取IndexSearcher对象27.* @param indexPath28.* @param service29.* @return30.* @throws IOException31.*/32.public static IndexSearcher getIndexSearcherByParent Path(String parentPath,ExecutorService service) throws IOExcep tion{33.MultiReader reader = null;34.//设置35.try {36.File[] files = new File(parentPath).listFiles();37.IndexReader[] readers = new IndexReader[files.length] ;38.for (int i = 0 ; i < files.length ; i ++) {39.readers[i] = DirectoryReader.open(FSDirectory.open(P aths.get(files[i].getPath(), new String[0])));40.}41.reader = new MultiReader(readers);42.} catch (IOException e) {43.// TODO Auto-generated catch block44. e.printStackTrace();45.}46.return new IndexSearcher(reader,service);47.}48./**根据索引路径获取IndexReader49.* @param indexPath50.* @return51.* @throws IOException52.*/53.public static DirectoryReader getIndexReader(String i ndexPath) throws IOException{54.return DirectoryReader.open(FSDirectory.open(Paths.g et(indexPath, new String[0])));55.}56./**根据索引路径获取IndexSearcher57.* @param indexPath58.* @param service59.* @return60.* @throws IOException61.*/62.public static IndexSearcher getIndexSearcherByIndex Path(String indexPath,ExecutorService service) throws IOExcepti on{63.IndexReader reader = getIndexReader(indexPath);64.return new IndexSearcher(reader,service);65.}66.67./**如果索引目录会有变更用此方法获取新的IndexSearcher这种方式会占用较少的资源68.* @param oldSearcher69.* @param service70.* @return71.* @throws IOException72.*/73.public static IndexSearcher getIndexSearcherOpenIfC hanged(IndexSearcher oldSearcher,ExecutorService service) thr ows IOException{74.DirectoryReader reader = (DirectoryReader) oldSearch er.getIndexReader();75.DirectoryReader newReader = DirectoryReader.openIf Changed(reader);76.return new IndexSearcher(newReader, service);77.}78.79./**多条件查询类似于sql in80.* @param querys81.* @return82.*/83.public static Query getMultiQueryLikeSqlIn(Query ...querys){84.BooleanQuery query = new BooleanQuery();85.for (Query subQuery : querys) {86.query.add(subQuery,Occur.SHOULD);87.}88.return query;89.}90.91./**多条件查询类似于sql and92.* @param querys93.* @return94.*/95.public static Query getMultiQueryLikeSqlAnd(Query .. . querys){96.BooleanQuery query = new BooleanQuery();97.for (Query subQuery : querys) {98.query.add(subQuery,Occur.MUST);99.}100.return query;101.}102./**根据IndexSearcher和docID获取默认的document 103.* @param searcher104.* @param docID105.* @return106.* @throws IOException107.*/108.public static Document getDefaultFullDocument(Inde xSearcher searcher,int docID) throws IOException{109.return searcher.doc(docID);110.}111./**根据IndexSearcher和docID112.* @param searcher113.* @param docID114.* @param listField115.* @return116.* @throws IOException117.*/118.public static Document getDocumentByListField(Inde xSearcher searcher,int docID,Set<String> listField) throws IOExc eption{119.return searcher.doc(docID, listField);120.}121.122./**分页查询123.* @param page 当前页数124.* @param perPage 每页显示条数125.* @param searcher searcher查询器126.* @param query 查询条件127.* @return128.* @throws IOException129.*/130.public static TopDocs getScoreDocsByPerPage(int pa ge,int perPage,IndexSearcher searcher,Query query) throws IOE xception{131.TopDocs result = null;132.if(query == null){133.System.out.println(" Query is null return null ");134.return null;135.}136.ScoreDoc before = null;137.if(page != 1){138.TopDocs docsBefore = searcher.search(query, (page-1)*perPage);139.ScoreDoc[] scoreDocs = docsBefore.scoreDocs;140.if(scoreDocs.length > 0){141.before = scoreDocs[scoreDocs.length - 1];142.}143.}144.result = searcher.searchAfter(before, query, perPage);145.return result;146.}147.public static TopDocs getScoreDocs(IndexSearcher se archer,Query query) throws IOException{148.TopDocs docs = searcher.search(query, getMaxDocId(s earcher));149.return docs;150.}151./**统计document的数量,此方法等同于matchAllDocsQuery查询152.* @param searcher153.* @return154.*/155.public static int getMaxDocId(IndexSearcher searcher ){156.return searcher.getIndexReader().maxDoc();157.}158.159.}相关测试代码如下:[java] view plain copy1.package com.lucene.index.test;2.3.import java.io.IOException;4.import java.util.HashSet;5.import java.util.Set;6.import java.util.concurrent.ExecutorService;7.import java.util.concurrent.Executors;8.9.import org.apache.lucene.document.Document;10.import org.apache.lucene.index.Term;11.import org.apache.lucene.search.IndexSearcher;12.import org.apache.lucene.search.Query;13.import org.apache.lucene.search.ScoreDoc;14.import org.apache.lucene.search.TermQuery;15.import org.apache.lucene.search.TopDocs;16.17.import com.lucene.search.util.SearchUtil;18.19.public class TestSearch {20.public static void main(String[] args) {21.ExecutorService service = Executors.newCachedThrea dPool();22.try {23.24.IndexSearcher searcher = SearchUtil.getIndexSearcher ByParentPath("index",service);25.System.out.println(SearchUtil.getMaxDocId(searcher));26.Term term = new Term("content", "lucene");27.Query query = new TermQuery(term);28.TopDocs docs = SearchUtil.getScoreDocsByPerPage(2, 20, searcher, query);29.ScoreDoc[] scoreDocs = docs.scoreDocs;30.System.out.println("所有的数据总数为:"+docs.totalHits);31.System.out.println("本页查询到的总数为:"+scoreDocs.length);32.for (ScoreDoc scoreDoc : scoreDocs) {33.Document doc = SearchUtil.getDefaultFullDocument(s earcher, scoreDoc.doc);34.//System.out.println(doc);35.}36.System.out.println("\n\n");37.TopDocs docsAll = SearchUtil.getScoreDocs(searcher, query);38.Set<String> fieldSet = new HashSet<String>();39.fieldSet.add("path");40.fieldSet.add("modified");41.for (int i = 0 ; i < 20 ; i ++) {42.Document doc = SearchUtil.getDocumentByListField(s earcher, docsAll.scoreDocs[i].doc,fieldSet);43.System.out.println(doc);44.}45.46.} catch (IOException e) {47.// TODO Auto-generated catch block48. e.printStackTrace();49.}finally{50.service.shutdownNow();51.}52.}53.54.}。
lucene字典实现原理——FST

lucene字典实现原理——FST转⾃:1 lucene字典使⽤lucene进⾏查询不可避免都会使⽤到其提供的字典功能,即根据给定的term找到该term所对应的倒排⽂档id列表等信息。
实际上lucene索引⽂件后缀名为tim和tip的⽂件实现的就是lucene的字典功能。
怎么实现⼀个字典呢?我们马上想到排序数组,即term字典是⼀个已经按字母顺序排序好的数组,数组每⼀项存放着term和对应的倒排⽂档id列表。
每次载⼊索引的时候只要将term数组载⼊内存,通过⼆分查找即可。
这种⽅法查询时间复杂度为Log(N),N指的是term数⽬,占⽤的空间⼤⼩是O(N*str(term))。
排序数组的缺点是消耗内存,即需要完整存储每⼀个term,当term数⽬多达上千万时,占⽤的内存将不可接受。
2 常⽤字典数据结构很多数据结构均能完成字典功能,总结如下。
数据结构优缺点排序列表Array/List使⽤⼆分法查找,不平衡HashMap/TreeMap性能⾼,内存消耗⼤,⼏乎是原始数据的三倍Skip List跳跃表,可快速查找词语,在lucene、redis、Hbase等均有实现。
相对于TreeMap等结构,特别适合⾼并发场景()Trie适合英⽂词典,如果系统中存在⼤量字符串且这些字符串基本没有公共前缀,则相应的trie树将⾮常消耗内存()Double Array Trie适合做中⽂词典,内存占⽤⼩,很多分词⼯具均采⽤此种算法()Ternary Search Tree三叉树,每⼀个node有3个节点,兼具省空间和查询快的优点()Finite State Transducers(FST)⼀种有限状态转移机,Lucene 4有开源实现,并⼤量使⽤3 FST原理简析lucene从4开始⼤量使⽤的数据结构是FST(Finite State Transducer)。
FST有两个优点:1)空间占⽤⼩。
通过对词典中单词前缀和后缀的重复利⽤,压缩了存储空间;2)查询速度快。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
深入理解lucene原理
一:什么是索引,为什么需要索引
对非结构化数据也即对全文数据的搜索主要有两种方法:
一种是顺序扫描法(Serial Scanning):所谓顺序扫描,比如要找内容包含某一个字符串的文件,就是一个文档一个文档的看,对于每一个文档,从头看到尾,如果此文档包含此字符串,则此文档为我们要找的文件,接着看下一个文件,直到扫描完所有的文件。
如利用windows的搜索也可以搜索文件内容,只是相当的慢。
如果你有一个80G硬盘,如果想在上面找到一个内容包含某字符串的文件,不花他几个小时,怕是做不到。
Linux下的grep命令也是这一种方式。
大家可能觉得这种方法比较原始,但对于小数据量的文件,这种方法还是最直接,最方便的。
但是对于大量的文件,这种方法就很慢了。
有人可能会说,对非结构化数据顺序扫描很慢,对结构化数据的搜索却相对较快(由于结构化数据有一定的结构可以采取一定的搜索算法加快速度),那么把我们的非结构化数据想办法弄得有一定结构不就行了吗?
这种想法很天然,却构成了全文检索的基本思路,也即将非结构化数据中的一部分信息提取出来,重新组织,使其变得有一定结构,然后对此有一定结构的数据进行搜索,从而达到搜索相对较快的目的。
这部分从非结构化数据中提取出的然后重新组织的信息,我们称之索引
例如:字典,字典的拼音表和部首检字表就相当于字典的索引
二:索引包含哪些东西
其实是由于我们想要搜索的信息和非结构化数据中所存储的信息不一致造成的。
非结构化数据中所存储的信息是每个文件包含哪些字符串,已知文件,欲求字符串相对容易,也即是从文件到字符串的映射。
而我们想搜索的信息是哪些文件包含此字符串,也即已知字符串,欲求文件,也即从字符串到文件的映射。
两者恰恰相反。
于是如果索引总能够保存从字符串到文件的映射,则会大大提高搜索速度。
由于从字符串到文件的映射是文件到字符串映射的反向过程,于是保存这种信息的索引称为反向索引。
左边保存的是一系列字符串,称为词典。
每个字符串都指向包含此字符串的文档(Document)链表,此文档链表称为倒排表(Posting List)。
三:索引的创建过程
1.全文索引相对于顺序扫描的优势:一次索引,多次使用
2.创建索引的步骤:
(1)要索引的原文档
(2)将原文档传给分词组件(Tokenizer)
分词组件会做如下事情:(此过程称为Tokenize)
a.将文档分成一个一个的单词
b.去除标点符号
c.去除停词(Stop Word)停词就是语句中无意义的词汇,英语中比如“the”,“a”,“this”等
每一种分词组件(Tokenize)都有一个停词集合
经过分词组件分词后得到的结果称为(词元)Token
(3)将得到的词元传给语言处理组件(Linguistic Processor)
语言处理组件主要对词元进行一些同语言相关的操作
对于英语,语言处理组件主要做如下处理:
a.变为小写(Lowercase)
b.将单词缩减为词根形式如cars->car,这种操作叫做stemming(缩减)
c.将单词转变为词根形式如drove->drive这种操作为lemmatization (转变)
Stemming和lemmatization的异同:
相同之处:Stemming和lemmatization都要使词汇成为词根形式。
两者的方式不同:
Stemming采用的是“缩减”的方式:“cars”到“car”,“driving”到“drive”。
Lemmatization采用的是“转变”的方式:“drove”到“drove”,“driving”到“drive”。
两者的算法不同:
Stemming主要是采取某种固定的算法来做这种缩减,如去除“s”,去除“ing”加“e”,将“ational”变为“ate”,将“tional”变为“tion”。
Lemmatization主要是采用保存某种字典的方式做这种转变。
比如字典中有“driving”到“drive”,“drove”到“drive”,“am,is,are”到“be”的映射,做转变时,只要查字典就可以了。
Stemming和lemmatization不是互斥关系,是有交集的,有的词利用这两种方式都能达到相同的转换。
也正是因为有语言转化的处理步骤,才能使搜索drove,而drive也能被搜索出来
语言处理组件处理后得到的是词(term)
(4)将得到的词(term)传给索引组件(Indexer)
a.利用得到的词创建一个字典(term,documentId)
b.对字典按字母排序进行排序
c.合并相同的词(Term)成为文档倒排(Posting List)链表
document frequency即文档频次,表示总共有多少文件包含此词
frequency即词频率,表示文档中包含了几个此词
3.对索引进行搜索
(1)用户输入查询语句and or not查询语句有很多语法。
举例lucene AND learned NOT hadoop
(2)对查询语句进行词法分析,语法分析,语言处理。
a.词法分析主要用来识别单词和关键字,如果关键字错误,则视为正常单词如lucene AMD..则视为AMD这个单词
b.语法分析主要是根据查询语句的语法规则形成一颗语法树
c.语言处理与建立索引的语言处理基本相同
(3)搜索索引,得到满足语法树的文档
a.首先,在反向索引表中,分别找出包含lucene,learn,hadoop的文档列表
b.其次,对包含lucene,learn的链表进行合并操作,得到既包含lucene 又包含learn的文档链表
c.然后,将此链表与hadoop的文档链表进行差操作,去除包含hadoop 的文档,从而得到既包含lucene,又包含learn,但是不包含hadoop的文档链表
d.得到的链表就是我们需要的文档
(4)根据得到的文档和查询语句的相关性,对结果进行排序
a.计算权重(Term weight)的过程。
b.判断Term之间的关系从而得到文档相关性的过程,也即向量空间模型的算法(VSM)
查询概括:
1.索引过程
1)有一系列被索引文件
2)被索引文件经过语法分析和语言处理形成一系列词(Term)。
3)经过索引创建形成词典和反向索引表。
4)通过索引存储将索引写入硬盘。
2.搜索过程:
a)用户输入查询语句。
b)对查询语句经过语法分析和语言分析得到一系列词(Term)。
c)通过语法分析得到一个查询树。
d)通过索引存储将索引读入到内存。
e)利用查询树搜索索引,从而得到每个词(Term)的文档链表,对文档链
表进行交,差,并得到结果文档。
f)将搜索到的结果文档对查询的相关性进行排序。
g)返回查询结果给用户
4.lucene的索引文件格式
lucene索引结构是有层次结构的,具体如下:
(1)索引:索引全部是是放在同一个文件夹中,这些内容构成了一个完整的lucene索引
(2)段(segment):一个索引可以包括很多段,段与段之间是独立的,新添加新文档可以生成新的段,段与段可以合并具有相同前缀文件的属于同一段,如segments.gen和segment_5是段的数据文件,也即它们保存了段的属性信息
(3)文档(document):文档是建立索引的基本单位,不同的文档保存在不同的段中,一个段可以包括多篇文档
新添加的文档是单独保存在新生成的段中,随着段的合并,不同的文档合并到同一个段中。
(4)域(field):一篇文档包含不同类型的信息,可以分开索引,比如正题,时间,正文等,都可以保存在不同的域中,不同域的索引方式可以不同
(5)词(term):词是索引的最小单位,是经过词法分析和语言处理后的字符串
lucene的索引结构中,既包括了正向信息,也包括了反向信息
正向信息:按层次保存了从索引一直到词的包含关系,索引(Index)-->段(segment)-->文档(document)-->域(field)-->词(term);
反向信息:保存了字典到倒排表的映射,词(term)-->文档(document)
5.分词组件
(1)ChineseAnalyzer按字分词,并过滤停词,标点英文This year,persidetn Hu科学发展观-->year president hu科学发展观
(2)CJKAnalyzer每两个字组成一个词,并过滤停词,标点英文-->year president hu科学学发发展展观
(3)PorterStemAnalyzer将转为小写的token,利用porter算法进行stemming
(4)SmartChineseAnalyzer分句子,句子中分词组,用porter算法进行stemming,去停词
(5)SnowBallAnalyzer标准分词器,标准过滤器,转换为小写,去停词,利用porter算法进行stemming。