精华内容
下载资源
问答
  • 一种基于海量数据的智能信息检索系统实现,一种基于海量数据的智能信息检索系统实现
  • 智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf
  • 利用Lucene接口编写简单的信息检索系统实现对本地目录建立索引和搜索功能。代码包含两个JSP页面,放入tomcat的webapp目录中即可在浏览器中运行程序。选择文档路径时如若涉及浏览器权限问题,可直接输入。
  • 通过结合Hadoop以及Lucene技术模型,对Web电子产品信息进行检索,结合分布式索引文件的存储过程,并应用Lucene检索技术将引文件中的访问实现,并将信息检索效率提高。在Lucene_Hadoop架构分析过程,结合粗粒度检索...
  • 互联网信息检索系统的研究与实现论文.doc
  • 基于结构化向量空间模型的中文信息检索系统研究与实现
  • 基于Oracle的医疗信息检索系统设计与实现.pdf
  • 详细地描述了使用语义Web技术实现智能信息检索的思想和工作流程,提出了一个基于本体的信息检索系统的框架,并以一个地理信息领域的应用为例分析了该检索系统的实现技术。
  • 对在Internct上实现网络化联想检索的基本机制和有关核心技术进行了分析,并对系统设计的基本逻辑思路和技术路线进行了论证,利用Internet上的WWW体系设计实现了一个网络化联想信息检索系统
  • 基于GIS数据库信息的面向某一行业的信息检索系统的设计与实现,林祥涛,彭泳,本文在分析当前的信息检索系统优缺点和GIS数据库信息特点的基础上,利用GIS数据库信息分类明确的优势,提出了一种面向某个行业的信
  • 主要介绍信息检索及信息检索系统的基本概念、原理、算法进行详尽介绍。主要内容包括信息检索模型、文本操作技术、文本索引和搜索技术、查询处理与Web检索技术、分布式信息检索、文本分类与聚类、信息过滤等,并给出...
  • 基于电力公司的多格式文档智能信息检索系统的设计与实现.pdf
  • 在现代中文信息检索系统中,用户输入的字符串和实际数据库中的条目往往存在局部偏差,而基于关键词 匹配的检索技术不能很好地解决这一问题。本文参考并改进了Tarhio和Ukkonen提出的过滤算法 ],针对汉字 拼音输入法...
  • 基于SQLServer2008的小型信息检索系统框架的设计与实现,一篇非常实用的论文
  • 信息检索系统——VSM算法实现

    千次阅读 2020-07-05 00:55:32
    匹配文档样例 查询样例 匹配结果样例 python–源码如下 import math from tqdm import tqdm df_dict={} global docs_num #一个全局变量,保留全部文档数 ...def doc_pl(doc): #求出文档中的词频数,及总词数,用于tf...

    匹配文档样例

    在这里插入图片描述

    查询样例

    在这里插入图片描述匹配结果样例

    在这里插入图片描述

    python–源码如下

    import math
    from tqdm import tqdm
    
    df_dict={}
    global docs_num      #一个全局变量,保留全部文档数
    docs_num=0
    
    def doc_pl(doc):     #求出文档中的词频数,及总词数,用于tf-idf的计算
        word_list=doc.split()
        num=0
        word_pl={}
        for word in word_list[1:]:
            word_pl[word]=word_pl.get(word,0)+1
            num+=1
        for word in word_pl.keys():
            df_dict[word]=df_dict.get(word,0)+1
        return (word_pl,num)
    
    def tf_idf(doc,flag):          #求tf-idf的值
        global docs_num
        word_tfidf={}
        for word in doc[0].keys():
            tf=doc[0][word]/doc[1]                              #tf---某词在文章出现的次数/总词数
            if flag==1:
                idf = math.log((docs_num / (df_dict[word]+1)))  #idf---log(文档总数/包含该词文档数+1)
                #idf=(docs_num/df_dict[word])**2
                #idf=(1/df_dict[word])**1.8
            else:                                               #对于一个问询的的tf-idf情形
                idf=1
            word_tfidf[word]=tf*idf
        return word_tfidf
    
    def simolarity(doc1,doc2):       #求文档相似度
        zi=0
        mu1=0
        mu2=0
        for word in doc1.keys():
            if doc2.get(word,0)!=0:
                zi+=doc1[word]*doc2[word]
        for word in doc1.values():
            mu1+=word**2
        for word in doc2.values():
            mu2+=word**2
        return zi/((mu2**0.5)*(mu1**0.5))
    
    def vsm(dlist,que):             #利用夹角余弦(Cosine)计算距离
        global docs_num
        docs_num=0                  #查询前清零总文档书
        doc_pl_list=[]              #各个文档的词频,及此文档总词数
        tfidf_list=[]               #各个文档中词的tf-idf字典
        sim_list=[]                 #各文档与查询的相似度
        for doc in dlist:
            doc.strip()
            doc_pl_list.append(doc_pl(doc))                                                #对于list的每一个元素为一个元组,元组中第0号元素为包含文档中词频率的字典,第二个元素为该文档的总词数
            docs_num+=1
        for pl in doc_pl_list:
            tfidf_list.append(tf_idf(pl,1))                                                #每一个文档中包含其所有词的tf-idf的字典构成的list
    
        docs_num=1
        tfidf_que=tf_idf(doc_pl(que),0)                                                    #一个查询的所有词的tf-idf字典
        for i in range(len(tfidf_list)):
            sim_list.append([simolarity(tfidf_que,tfidf_list[i]),dlist[i].split()[0]])     #各文档与查询的余弦相似度
        return sorted(sim_list,key=lambda x:(-x[0]))                                       #使各文档按余弦相似度由高到低排序
    
    docs = open(r"C:\Users\CYY\Desktop\documents.txt",encoding='utf-8')
    doc_list = docs.readlines()
    docs.close()
    
    query = open(r"C:\Users\CYY\Desktop\q100.txt", encoding='utf-8')            #问询的文档
    query_list = query.readlines()
    query.close()
    
    Result = open(r"C:\Users\CYY\Desktop\result.txt", 'w',encoding='utf-8')     #写入结果的文档
    
    que_dict=dict()
    for i in tqdm(range(100)):                                #查询的数目
        df_dict = {}
        result = vsm(doc_list, query_list[i])
        Docs = []
        Docs.append(query_list[i].split()[0])
        k = 0
        for doc in result:                                    #去重
            if doc[1] not in Docs:
                Docs.append(doc[1])
                k += 1
            if k == 10:                                       #单次查询匹配的文档数
                break
        que_dict[i] = Docs
    
    for i in range(100):                                       #将一百个问询的前十个最匹配的文档写入
        Result.write(que_dict[i][0])
        Result.write("\t")
        for j in range(10):
            Result.write(que_dict[i][j+1])
            Result.write(' ')
        Result.write('\n')
    Result.close()
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 基于电力公司的多格式文档智能信息检索系统的设计与实现.rar
  • 在本课程中,我们将研究基于文本和基于Web的信息检索系统的理论,设计和实现,包括检查现代搜索和数据挖掘应用程序核心的Web和社交媒体挖掘算法和技术。到学期结束时,您将能够:定义和解释与信息存储和检索相关的...
  • 利用倒排索引和向量空间模型实现信息检索系统。 完成工作: 带位置信息的倒排索引 转化空间模型 TOP K查询 BOOL查询 初步查询 拼写矫正 名词查询 拼写矫正(以下) 运行 环境要求:python3 在初次运行程序前请下载...
  • 信息检索系统——基于Lucene实现 题目要求 基于课程学习内容,实现简单的搜索引擎功能(界面可视化不做要求,可终端输出),要求实现以下基本功能: 拼写检查(参考最小编辑距离原理) 倒排索引 使用TF/IDF或者VSM...

    信息检索系统——基于Lucene实现

    题目要求

    基于课程学习内容,实现简单的搜索引擎功能(界面可视化不做要求,可终端输出),要求实现以下基本功能:

    1. 拼写检查(参考最小编辑距离原理)
    2. 倒排索引
    3. 使用TF/IDF或者VSM进行文档排序

    实现

    这里使用的是lucene-8.0.0,由于版本不同,网上很多博客的教程已经失效,具体的api参数或者调用要参考官网最新的手册,这里需要一定的搜索与查阅文档的能力。

    http://lucene.apache.org/core/8_0_0/core/

    项目完整源码:Github传送门

    下面只讲述部分关键的代码

    1.构建倒排索引

    • 这里利用IndexWriter类来构建索引,由于这里使用的是中文文档,故要使用分析中文的分析器SmartChineseAnalyzer.

    • 根据建立索引的目录以及数据的目录来读取。

    • 定义一个fieldType,并设置其属性,既保存在文件又用于索引建立

    • 读取 file 转 string

    • 用文件内容来建立倒排索引

    • 用文件名来建立倒排索引

    • 用文件路径来建立倒排索引

    public class Indexer {
       private IndexWriter writer;
       public Indexer(String indexDirectoryPath) throws IOException{
          // 获取目录directory
          Directory indexDirectory = FSDirectory.open(FileSystems.getDefault().getPath(indexDirectoryPath));
    
          // 中文分析器
          Analyzer analyzer = new SmartChineseAnalyzer();
          IndexWriterConfig config = new IndexWriterConfig(analyzer);
          writer = new IndexWriter(indexDirectory, config);
       }
    
       public void close() throws CorruptIndexException, IOException{
          writer.close();
       }
    
       private Document getDocument(File file) throws IOException{
          Document document = new Document();
          
           // 定义一个fieldType,并设置其属性,既保存在文件又用于索引建立
          FieldType fieldType = new FieldType();
          fieldType.setStored(true);
          fieldType.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
          
          // 读取 file 转 string
          StringBuffer buffer = new StringBuffer();
          BufferedReader bf= new BufferedReader(new FileReader(file));
          String s = null;
          while((s = bf.readLine())!=null){//使用readLine方法,一次读一行
              buffer.append(s.trim());
          }
    
          String xml = buffer.toString();
          // 用文件内容来建立倒排索引
          Field contentField = new Field(LuceneConstants.CONTENTS, xml,fieldType);
          // 用文件名来建立倒排索引
          Field fileNameField = new Field(LuceneConstants.FILE_NAME,file.getName(),fieldType);
          // 用文件路径来建立倒排索引
          Field filePathField = new Field(LuceneConstants.FILE_PATH,file.getCanonicalPath(),fieldType);
    	  
          // 添加到document
          document.add(contentField);
          document.add(fileNameField);
          document.add(filePathField);
    
          return document;
       }   
    
       private void indexFile(File file) throws IOException{
          System.out.println("Indexing "+file.getCanonicalPath());
          Document document = getDocument(file);
          writer.addDocument(document);
       }
       
        
       public int createIndex(String dataDirPath, FileFilter filter) 
          throws IOException{
          //get all files in the data directory
          File[] files = new File(dataDirPath).listFiles();
          
          int count = 0;
          for (File file : files) {
    //    	  System.out.println(file);
             if(!file.isDirectory()
                && !file.isHidden()
                && file.exists()
                && file.canRead()
                && filter.accept(file)
             ){
                indexFile(file);
                count++;
             }
          }
          return count;
       }
    }
    

    测试函数:

    public class LuceneTester {
    	
       String indexDir = "C:/Users/asus/Desktop/java/information-retrieval-system/index";
       String dataDir = "C:/Users/asus/Desktop/java/information-retrieval-system/data";
       Indexer indexer;
       
       public static void main(String[] args) {
          LuceneTester tester;
    //      File[] fs = new File("C:/Users/asus/Desktop/java/information-retrieval-system/data").listFiles();
    //      for (File f : fs){  
    //          System.out.println(f);  
    //      }  
          try {
             tester = new LuceneTester();
             tester.createIndex();
          } catch (IOException e) {
             e.printStackTrace();
          } 
       }
    
       private void createIndex() throws IOException{
          indexer = new Indexer(indexDir);
          int numIndexed;
          long startTime = System.currentTimeMillis();	
          numIndexed = indexer.createIndex(dataDir, new TextFileFilter());
          long endTime = System.currentTimeMillis();
          indexer.close();
          System.out.println(numIndexed+" File indexed, time taken: "
             +(endTime-startTime)+" ms");		
       }
    }
    

    输出结果:这里我们就已经建立好索引,并在文件目录能找到索引文件

    1

    文件目录中的索引:

    2

    2. 使用TF/IDF进行文档排序,并使用关键词搜索文档

    • 得到读取索引文件的路径
    • 通过dir得到的路径下的所有的文件
    • 设置为TF/IDF 排序
    • 实例化分析器
    • 建立查询解析器
    • 根据传进来的q查找
    • 开始查询
    public class ReaderByIndexerTest {
     
    	public static void search(String indexDir,String q)throws Exception{
    		
    		//得到读取索引文件的路径
    		Directory dir=FSDirectory.open(Paths.get(indexDir));
    		
    		//通过dir得到的路径下的所有的文件
    		IndexReader reader=DirectoryReader.open(dir);
    		
    		//建立索引查询器
    		IndexSearcher is=new IndexSearcher(reader);
    		
    		// 设置为TF/IDF 排序
    		ClassicSimilarity sim = new ClassicSimilarity();
    		// Implemented as sqrt(freq).
    		// sim.tf(reader.getSumDocFreq(q));
    		
    		// Implemented as log((docCount+1)/(docFreq+1)) + 1.
    		// sim.idf(reader.getSumDocFreq(q), reader.numDocs());
    		is.setSimilarity(sim);
    		// 实例化分析器
    		Analyzer analyzer=new SmartChineseAnalyzer(); 
    		
    		// 建立查询解析器
    		/**
    		 * 第一个参数是要查询的字段;
    		 * 第二个参数是分析器Analyzer
    		 * */
    		QueryParser parser=new QueryParser("contents", analyzer);
    		
    		// 根据传进来的q查找
    		Query query=parser.parse(q);
    
    		// 计算索引开始时间
    		long start=System.currentTimeMillis();
    		
    		// 开始查询
    		/**
    		 * 第一个参数是通过传过来的参数来查找得到的query;
    		 * 第二个参数是要出查询的行数
    		 * */
    		TopDocs hits=is.search(query, 10);
    		
    		// 计算索引结束时间
    		long end=System.currentTimeMillis();
    		
    		System.out.println("匹配 "+q+" ,总共花费"+(end-start)+"毫秒"+"查询到"+hits.totalHits+"个记录");
    		
    		//遍历hits.scoreDocs,得到scoreDoc
    		/**
    		 * ScoreDoc:得分文档,即得到文档
    		 * scoreDocs:代表的是topDocs这个文档数组
    		 * @throws Exception 
    		 * */
    		for(ScoreDoc scoreDoc:hits.scoreDocs){
    			Document doc=is.doc(scoreDoc.doc);
    			System.out.println(doc.get(LuceneConstants.FILE_PATH));
    		}
    		
    		//关闭reader
    		reader.close();
    	}
    

    3. 拼写检查

    • 建立目录
    • 创建初始化索引
    • 根据创建好的索引来检查k个建议的关键词
    • 返回正确的关键词
    public static String[] checkWord(String queryWord){
    		//新索引目录
    		String spellIndexPath = "C:\\Users\\asus\\Desktop\\java\\information-retrieval-system\\newPath";
    		//已有索引目录
    		String oriIndexPath = "C:\\Users\\asus\\Desktop\\java\\information-retrieval-system\\index";
    
    		//拼写检查
    		try {
    			//目录
    			Directory directory = FSDirectory.open((new File(spellIndexPath)).toPath());
    
    			SpellChecker spellChecker = new SpellChecker(directory);
    
    			// 以下几步用来初始化索引
    			IndexReader reader = DirectoryReader.open(FSDirectory.open((new File(oriIndexPath)).toPath()));
    			// 利用已有索引
    			Dictionary dictionary = new LuceneDictionary(reader, LuceneConstants.CONTENTS);
    			
    			IndexWriterConfig config = new IndexWriterConfig(new SmartChineseAnalyzer());
    			spellChecker.indexDictionary(dictionary, config, true);
    			
    			int numSug = 5;
    			String[] suggestions = 
                    spellChecker.suggestSimilar(queryWord, numSug);
    			reader.close();
    			spellChecker.close();
    			directory.close();
    			return suggestions;
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    

    4. 综合测试

    这里调用之前实现好的基类和工具类,并制作简陋的命令行界面来进行信息检索

    //测试
    	public static void main(String[] args) throws IOException {
    		String indexDir="C:\\Users\\asus\\Desktop\\java\\information-retrieval-system\\index";
    		// 处理输入
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
            String str = null; 
            System.out.println("请输入你要搜索的关键词:"); 
            try {
    			str = br.readLine();
    			System.out.println(); 
    		} catch (IOException e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
            // 拼写检查
            String temp = str;
            String[] suggestions = checkWord(str);
            if (suggestions != null && suggestions.length != 0){
                System.out.println("你可能想输入的是:"); 
            	for(int i = 0; i < suggestions.length; i++){
    		        System.out.println((i+1) + " : " + suggestions[i]); 
    			}
    
                System.out.println("请选择上面的一个正确的关键词(输入 1 ~ 5),或继续原词(输入0)进行搜索:"); 
                str = br.readLine();
    			System.out.println(); 
                if (str != "0"){
                	str = suggestions[str.charAt(0) - '1'];
                }
                else{
                	str = temp;
                }
            }
    		
    		try {
    			search(indexDir,str);
    		} catch (Exception e) {
    		    // TODO Auto-generated catch block
    		     e.printStackTrace();
    		}
    	}
    

    测试结果:

    3

    测试用例1解析:

    这里我输入一个错误的关键词美利坚共和国,试图进行搜索,然后系统马上就会告诉我拼写检查的结果让我重新选择。

    重新选择后会输出美利坚合众国的正确查询结果

    4

    测试用例2解析:

    这里直接输入一个正确的存在的关键词,就会直接输出美利坚合众国的正确查询结果,不会出现拼写检查的提醒

    展开全文
  • 一个基于用户上下文的个性化信息检索系统的设计与实现,张磊,孙文生,理想的搜索引擎能够依据用户浏览和检索的习惯信息,熟悉用户的兴趣爱好,建立一定的用户描述,主动向用户提供相关的信息。针对大
  • 基于概念云与本体的信息检索系统(IRSCCO)的设计与实现,任瑞娟,濮德敏,基于本体的语义检索是提高信息系统检索精确度的有效途径之一。概念云是云模型在信息领域的应用,是本体中的概念按照一定算法在页
  • 模糊查询-信息-检索 基于 Apache Lucene FuzzyQuery 的信息检索系统,用 Java 实现
  • Wumpus(《信息检索:实现和评价搜索引擎》其中一位作者开发的一个多用户开源信息检索系统 可以在网上下载)提供了模型实现 可作为学生练习的一个基础 《信息检索:实现和评价搜索引擎》采用的模块化结构使教师可以将...
  • 基于3G技术的移动图书馆在线信息检索系统的技术实现
  • 电信设备-实现信息检索系统.zip
  • 针对传统图书信息检索系统通过本地服务器提供信息检索,其检索速率与结果准确率低,且受本地计算设施性能影响较大等问题,文中采用云计算以及人工智能技术开发了高效的图书信息检索系统,通过布置云端服务器,将图书...
  • 新闻检索系统的设计与实现,其中有新闻信息浏览模块、新闻评论模块、新闻分类列表、新闻后台管理模块、管理员管理模块、RSS新闻聚合管理模块,其中登录密码采用加密方式。
  • 平均检索覆盖率达到96.64%,平均检索延迟仅为12.36 s,这一结果要好于基于Lucene、B/S两种架构设计的一般档案信息数据库检索系统检索效果,由此可知本系统能在更短的时间内实现更为全面的档案信息搜索。
  • 随着地理信息数据获取技术日渐完善,地理信息数据在遥感领域应用的不断深入,人们对海量地理...论文分析并探讨了Vue在地理信息检索系统应用的可行性及实现方法,并证明了Vue的优势可在地理信息检索系统得到有效的利用。
  • 基于Web数据库技术的植物检索信息系统的设计与实现 asp.net C#

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 238,440
精华内容 95,376
关键字:

信息检索系统实现