精华内容
下载资源
问答
  • 一种基于海量数据的智能信息检索系统实现,一种基于海量数据的智能信息检索系统实现
  • 利用Lucene接口编写简单的信息检索系统实现对本地目录建立索引和搜索功能。代码包含两个JSP页面,放入tomcat的webapp目录中即可在浏览器中运行程序。选择文档路径时如若涉及浏览器权限问题,可直接输入。
  • 教学管理文件信息检索系统设计与实现

    教学管理文件信息检索系统设计与实现


    前言

    提示:,使用基于 Python 的数据处理与分析技术 对教学管理文件进行预
    处理 ,利用 了 倒排索引 算法 的 快速检索 技术对校规校纪进行快速查询 和词频 逆文本
    频率评分 进行 排序 的 方法 分析学校教学管理文件 ,设计 与实现 教学 管理文
    件信息检索 系统 减轻教务管理人员的工作负担 。


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、系统开发环境

    系统开发环境
    教学管理文件信息检索系统的设计与实现具体开发环境如下:
    (1) Window 10 操作系统
    (2) Tomcat 8.5+Jdk11.0.1
    (3) JavaEE 开发语言
    (4) Python 3.5.3 语言
    (5) eclipse 4.10.0 工具
    (6) Pycharm 2019.3.3 C ommunity Edition

    二、关键算法及代码

    1.文档切分代码在这里插入代码片

    在这里插入图片描述

    2.倒排索引的构建

    ``` 经过上述文件预处理,获得了两种文件,一种是每个章节的校规对应的文件,另一 种是每个章节对应的校规进行结巴分词后的文件,并且每个文件有它对应的编号 id 。现 在可以根据 划分的 文件,确定该章节所对应的关键词及该词的词频。此时,根据文档编 号,关键词,词频,就可以构成正向索引表,用来表示每个关键词与文档的关系, 如表所示:

    在这里插入图片描述

    在使用正向索引表进行校规校纪的查询时,只能根据输入的信息,提取关键词,对
    文档进行逐一查询, 判断该文档是否包含该关键词, 当文档数量很多时, 频繁的读取和
    关闭文件, 就会导致消耗大量的计算机资源,搜索效率很低等问题。为了能快速的根据
    用户的输入信息,检索到相应的校规,我们将正向索引表,重新组合,构建成每个关键
    词对应该词所属于的文档编号及词频, 然后我们根据关键词就可以快速的获取文档 id
    集合, 这种结构就是倒排索引结构,我所构建的结构如下表 所示
    在这里插入图片描述
    通过使用倒排索引表,对用户输入的信息进行结巴分词,关键词提取,然后,就可
    以过滤不相关的文本编号, 获取目标文档 id的集合 进行快速的检索,查找出相应的关键
    词所对应的文本编号,提高检索效率。
    但是,在第一次构建上
    述 索引时,由于代码要对 2 11 个文件进行频繁的读取,频繁
    的进行结巴分词,然后提取关键词,判断词语是否包含某一关键词时,进行统计词频,
    代码跑了两天两夜,没有跑出结果。对每个词的处理时间进行计算后,得出处理一个词,
    还有其对应的索引和 词频,大致需要两分钟,然后 总的教学管理文件 大约有 9 000 个关键词,跑完这么多词,需要
    1 2 天, 所以需要换一种方法进行数据处理 和索引的构建 。
    浪费了两天的时间后,对
    上述方法 进行修改。为了减少时间的耗费,所以,需要对
    2 11 个文件,进行提前 去除停用词并 分词,存到相应的文本中, 以便后续快速的构建索
    引。 此时需要 重新构思代码,把这 211 个章节的 词,都 相应的 提前读取到二维数组中去,
    全部把数据 提前放 到内存中,在进行处理数据时,运行五分钟左右,就能构建出形为
    Word _n 文档 id ,词频 的索引了。但是,根据在构建检索 模块 时,单纯的根据词
    频进行排序, 存在很多问题, 既没有很好的说服力,效果也不是很好,经过重新的构思
    和审阅任务书,决定使用词频 逆文件频率进行 综合 排序 。所以需要 重新构建索引 需
    要 把原索引中词频的值,替换为词频 逆文件频率的值。

    检索排序
    本段落主要讲解排序过程,我分别使用了词频和逆文件频率进行排序,设计和实现
    过程如下。
    根据用户的输入信息,提取关键词,然后通过多个关键词的词频进行相加,根据相
    加后词频的大小,对其所在的文档编号进行排序,过程如下图 所示 。
    在这里插入图片描述
    例如
    用户输入创新学分 系统 进行分词 后 ,提取出创新和学分两个关键词。根据这两
    个词,查询倒排索引表,查找出其所在的文档编号和对应的词频 w ,把文档编号相同的
    行所对应的词频 w 进行相加,根据数字按从大到小排序,得出检索结果。但是这样做,
    很容易出现图 3.5 所示 的情况,因为,在提取出的倒排索引文件中,很多关键词(这类
    低频率 词的比例很高),在某一文档中就只出现一次,但 有可能 在其他文档中出现很多
    次(如下图 3 6 为我处理的词频数据, 关键词: 文档 id ,词频 w 但是这并不能
    体现该词所在文档的重要性,所以采用新的排序方法很有必要。
    在这里插入图片描述


    系统截图

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf智能新闻信息检索系统的设计与实现.pdf
  • 1 简介这是一个利用Django搭建的一个人物信息检索系统,大约从Wikipedia爬取了10000 个人物信息,并且提取了其中 Infobox 的对应信息。对于 Wikipedia 中爬取的信息,我们重新组织了其格式并且进行显示。左侧为搜索...

    1 简介

    这是一个利用Django搭建的一个人物信息检索系统,大约从Wikipedia爬取了10000 个人物信息,并且提取了其中 Infobox 的对应信息。

    对于 Wikipedia 中爬取的信息,我们重新组织了其格式并且进行显示。

    左侧为搜索页面,右侧为搜索结果,匹配的字段被高亮显示。

    对于已经爬取的信息,我们提供了一个对其进行搜索的页面,可以根据关键词在 其中搜索,并且还可以根据原先 Infobox 中的标题进行特定字段的查询(例如 Born、 Died、Name、Nationality 等),同时还可以让用户自行添加可以查询的字段。

    搜索的结果按照匹配的关键字个数从高到底排序后显示,如果结果过多将会分页显 示。同时匹配的关键字会被高亮标出。

    左侧为搜索结果过多时的分页显示效果,右侧为按照字段搜索 Born 中含 1997 的人物结果。

    Alan Turing 信息的展现。

    2 部分实现

    爬虫部分利用 BeautifulSoup 来处理获取的页面,提取 Infobox 中的信息。

    具体来说,人物超链接的爬取是通过寻找 ID 为 mw-content-text 的元素下所有 li 标签的第一个超链接来实现的。在爬取完毕后检查是否存在 infobox,如果存在则开始 提取信息。由于其中信息具有一定规律(例如大部分信息是以标题、内容的形式来组织 的),只需要用 BeautifulSoup 提取相应的

    以及 部分即可。 前端界面利用 Bootstrap 来优化显示效果。

    关于数据的存储,在提取出信息后利用 JSON 来保存在 sqlite 数据库中,并且额外 提取出一个关键字字符串用于搜索。对于每个人物都会分配一个唯一的 ID 以方便索引。 分页功能利用了 Django 自带的 Paginator 类。查询关键词的高亮以及自定义字段 搜索框的增加与删除使用 Javascript 在前端完成。

    展开全文
  • service:信息检索逻辑实现,包括切词、词频统计、词的权重计算、构建向量空间模型、检索等。 test:不用说了,肯定测试用的 两个配置文件:paoding分词器核心配置文件和项目属性配置文件 依赖的jar包: ...

    首先eclipse搭建一个java项目,项目结构如下:

    common:放公共类,如常量、工具类、dto等

    demos:放控制类,相当于程序执行入口

    service:信息检索逻辑实现,包括切词、词频统计、词的权重计算、构建向量空间模型、检索等。

    test:不用说了,肯定测试用的

    两个配置文件:paoding分词器核心配置文件和项目属性配置文件

    依赖的jar包:

     

     

    集成paoding分词器:

    官网下载paoding解压后,将jar包和paoding.dic.home.properties拷贝到项目里,将dic文件放到磁盘E:/paoding/

    配置paoding.dic.home.properties

    paoding.dic.home=E:/paoding/dic

     

    自定义词典:

    paoding分词器可以自定义词典以及停用词典,打开dic目录,新建一个.dic文件即可

     

    测试一下分词器好不好使:

    AnalyzerTest添加

     1  protected String dissect(String input) {
     2        try {
     3            TokenStream ts = analyzer.tokenStream("", new StringReader(input));
     4            Token token;
     5            sb.setLength(0);
     6            while ((token = ts.next()) != null) {
     7               sb.append(token.termText()).append('/');
     8            }
     9            if (sb.length() > 0) {
    10               sb.setLength(sb.length() - 1);
    11            }
    12            return sb.toString();
    13        } catch (Exception e) {
    14            e.printStackTrace();
    15            return "error";
    16        }
    17     }
    18     
    19     /**
    20      * 分词测试
    21      */
    22     public void testDisect(){
    23         try {
    24             //String content = ContentReader.readText(Demo.class);
    25             String content ="你问我爱你有多深";
    26             String result = dissect(content);
    27             System.out.println(result);
    28         } catch (Exception e) {
    29             // TODO Auto-generated catch block
    30             e.printStackTrace();
    31         }
    32     }

    运行结果:

    ok,paoding分词器没什么问题。接下来进入正题

    文档集是30篇word文档,DOC_PATH = "E:/Doc"

    工具类方法:将doc文档转为字符串,用了第三方jar包tm-extractors-0.4.jar

    /**
    * 将word文档转换为存文本
    * @param file
    * @return
    * @throws Exception
    */
    public static String wordToStr(File file) throws Exception{
            
        FileInputStream in = new FileInputStream(file);
        WordExtractor extractor = null;
        String text = null;
        // 创建WordExtractor
        extractor = new WordExtractor();
        // 对doc文件进行提取
         text = extractor.extractText(in);
        return text.trim();
    }
        

    思路:打开文档集文件,获取所有.doc文档,循环将doc文档转化为String,然后对String切词,切词后进行词频统计,每篇文档保存一个中间结果到本地磁盘,中间结果的存储结构为

    (文档编号/词项/词频)

    词频统计算法:

     1 /**
     2      * 统计列表中的每个词出现的次数(词频统计)
     3      * @param list
     4      * @return
     5      */
     6     public static Map count(List list){
     7         Map<String,Integer> map = new HashMap<>();
     8         String temp = "";
     9         for(int i=0 ; i<list.size();i++){
    10             temp = (String) list.get(i);
    11             if(map == null){
    12                 map.put(temp, 1);
    13             }else{
    14                 if(map.get(temp)==null){
    15                     map.put(temp, 1);
    16                 }
    17                 else{
    18                     int num = map.get(temp);
    19                     num++;
    20                     map.put(temp, num);
    21                 }
    22             }
    23         }
    24         return map;
    25     }

    整个过程代码:

     1     /**
     2      * 每一篇文档成成一个词项文本(中间结果)
     3      * 文本每行格式 :文档ID/词项/词频
     4      * @throws Exception
     5      */
     6     public void docToTerms() throws Exception{
     7         long start = System.currentTimeMillis(); 
     8         prop = MyTools.getProp("application.properties");
     9         if(prop==null){
    10             return;
    11         }
    12         String DOC_PATH = prop.getProperty("doc_path");
    13     
    14         Analyzer analyzer = new PaodingAnalyzer();
    15         File root = new File(DOC_PATH);
    16         File[] docs = root.listFiles();        
    17         
    18         try {
    19             String maxStr = "";
    20             for(int i=0;i<docs.length;i++){
    21                 String docStr = MyTools.wordToStr(docs[i]);
    22                 List<String> tokenList = new ArrayList<>(); 
    23                 tokenList = MyTools.dissectToList(analyzer, docStr);
    24                 Map<String,Integer> tfmap = new HashMap<>();
    25                 tfmap = MyTools.count(tokenList);
    26     
    27                 StringBuilder sb = new StringBuilder();
    28 
    29                 int max=1;
    30                 Iterator iter = tfmap.entrySet().iterator();
    31                 while(iter.hasNext()){
    32                     Map.Entry enter = (Map.Entry)iter.next();
    33                     String word = (String)enter.getKey();
    34                     int wordNum = (int)enter.getValue();
    35                     
    36                     if(wordNum>max){
    37                         max = wordNum;
    38                     }
    39                     
    40                     String docId = docs[i].getName().substring(3);
    41                     docId= docId.substring(0,docId.length()-4);
    42                     sb.append(docId+"/"+word+"/"+wordNum+"\r\n");
    43                 }
    44                 maxStr += (max+"/");
    45                 
    46 
    47                 //每一篇文档成成一个词项文本
    48                 String docId = docs[i].getName().substring(3);
    49                 docId= docId.substring(0,docId.length()-4);
    50                 String fileStr = "E:/index2/termDoc/"+docId+".txt";
    51                 File file = new File(fileStr);
    52                 if(!file.exists()){
    53                     file.createNewFile();
    54                 }
    55                 FileOutputStream fo = new FileOutputStream(file);
    56                 OutputStreamWriter os = new OutputStreamWriter(fo);
    57                 BufferedWriter bw = new BufferedWriter(os);
    58                 bw.write(sb.toString().trim());
    59                 
    60                 bw.close();
    61                 os.close();
    62                 fo.close();
    63                 
    64                 //统计每片文档中的最大词频数
    65                 File maxtffile = new File("E:/index2/maxtf.txt");
    66                 if(!maxtffile.exists()){
    67                     maxtffile.createNewFile();
    68                 }
    69                 FileOutputStream fo1 = new FileOutputStream(maxtffile);
    70                 OutputStreamWriter os1 = new OutputStreamWriter(fo1);
    71                 BufferedWriter bw1 = new BufferedWriter(os1);
    72                 bw1.write(maxStr);
    73                 
    74                 bw1.close();
    75                 os1.close();
    76                 fo1.close();
    77                 
    78             }
    79             
    80         } catch (Exception e) {
    81             // TODO Auto-generated catch block
    82             e.printStackTrace();
    83         }
    84         
    85         long end = System.currentTimeMillis(); 
    86         
    87         double runTimes = (end-start)/1000.0;
    88         System.out.print("文档词频统计中间文件生成时间是:"+runTimes+"秒");
    89                 
    90     }

    代码过程中统计了每篇文档的最大词频数maxStr,也序列化到本地,方便词频的归一化:词频归一化=词频/最大词频

    使用的java旧I/O处理,并没有考虑多线程问题,流的关闭有瑕疵,也懒得改了。

    30篇文档集,产生了30个中间结果,取一个中间文件部分如下:文档ID/词项/词频

    1/浪费/1
    1/法权/1
    1/提高/2
    1/重视/2
    1/利用率/1
    1/引起/1
    1/保证/1
    1/效益/1
    1/利于/4

     

    下面的词频归一化和权重的计算都是基于上述中间结果的,weight(docId,term) = tf(docId,term) * idf(docId,term)

    tf(docId,term):表示某一文档中,词项的词频(该词在这篇文档中出现的次数),这里要归一化表示为tf/maxtf。例如:1/浪费/1,maxtf=4,则tf(1,浪费)=1/4

    idf(docId,term):倒置文档频率,词项term在文档集中出现的次数(在文档i中出现记1,不出现记0)表示为文档频率,倒置文档频率为文档频率的倒数。这里也用数学方法处理一下idf取对数log(idf)。

    weight(docId,term):表示词的权重

    至于这部分怎么算:

      1     /**
      2      * 统计文档出现的所有需要建索引的词项
      3      * @return
      4      */
      5     public List<String> getIndexTerms(){
      6         
      7         long start = System.currentTimeMillis(); 
      8         double threshold = Constant.threshold;
      9         Set<String> set = new HashSet<>();
     10         File file = new File("E:/index2/DocIndex(tfidf).txt");
     11         List<Inverted> list = MyTools.readDocIndex(file);
     12         for(Inverted invert : list){
     13             if(invert.getFrequency()>threshold){
     14                 set.add(invert.getLexicalItem());
     15                 //System.out.println(invert.getFrequency());
     16             }
     17             
     18         }
     19         List<String> result = new ArrayList<>(set);
     20         
     21         long end = System.currentTimeMillis(); 
     22         double runTimes = (end-start)/1000.0;
     23         System.out.println("统计文档所有需要建索引de词项运行时间是:"+runTimes+"秒");
     24         return result;
     25     }
     26     
     27     /*
     28      * 将所有的文档放入hashMap数组中 <词项, 词频>
     29      * 文档编号-1,对应数组编号
     30      */
     31     public Map<String,Double>[] getMapArray(){
     32     
     33         long start = System.currentTimeMillis(); 
     34         
     35         File file = new File(Constant.TERMDOC_PATH);
     36         File[] fileList = file.listFiles();
     37         Map<String,Double>[] map = new Map[30];
     38         for(int i=0;i<Constant.DOC_NUMS;i++){
     39             List<Inverted> list = MyTools.readDocIndex(fileList[i]);
     40             map[(Constant.docnum[i]-1)] = new HashMap<String,Double>();
     41             for(Inverted inverted:list){
     42                 map[(Constant.docnum[i]-1)].put(inverted.getLexicalItem(), inverted.getFrequency());
     43             }
     44         }
     45         
     46         long end = System.currentTimeMillis(); 
     47         double runTimes = (end-start)/1000.0;
     48         System.out.println("文档转成hash表运行时间是:"+runTimes+"秒");
     49         
     50         return map;
     51         
     52     }
     53     
     54     /**
     55      * 统计词-文档数
     56      */
     57     public void countTermDocNum(){
     58         long start = System.currentTimeMillis(); 
     59         List<String> result = getAllTerms();
     60         Map<String,Double>[] map = getMapArray();
     61         System.out.println(result.size());
     62         for(String s:result){
     63             int num=0;
     64             for(int i=0;i<Constant.DOC_NUMS;i++){
     65                 if(map[i].containsKey(s)){
     66                     num++;
     67                 }
     68             }
     69             System.out.println(s+":"+num);
     70         }
     71         long end = System.currentTimeMillis(); 
     72         double runTimes = (end-start)/1000.0;
     73         System.out.println("运行时间是:"+runTimes+"秒");
     74     }
     75     
     76     /**
     77      * 建立词项文档数
     78      * @throws Exception
     79      */
     80     public void countTermDocNumCopy() throws Exception{
     81         long start = System.currentTimeMillis(); 
     82         List<String> result = getAllTerms();
     83         Map<String,Double>[] map = getMapArray();
     84         File file = new File("E:/index2/DocIndex(df).txt");
     85         if(!file.exists()){
     86             file.createNewFile();
     87         }
     88         FileOutputStream fo = new FileOutputStream(file);
     89         OutputStreamWriter os = new OutputStreamWriter(fo);
     90         BufferedWriter bw = new BufferedWriter(os);
     91         List<Inverted> list = MyTools.readDocIndex(new File("E:/index2/DocIndex(tf).txt"));
     92         for(Inverted inverted:list){
     93             String term = inverted.getLexicalItem();
     94             int num=0;
     95             for(int i=0;i<Constant.DOC_NUMS;i++){
     96                 if(map[i].containsKey(term)){
     97                     num++;
     98                 }
     99             }
    100             //inverted.setFrequency(num);
    101             bw.write(inverted.getDocId()+"/"+inverted.getLexicalItem()+"/"+num);
    102             bw.write("\r\n");
    103         }
    104         bw.close();
    105         os.close();
    106         fo.close();
    107         //System.out.println(result.size());
    108         
    109         long end = System.currentTimeMillis(); 
    110         double runTimes = (end-start)/1000.0;
    111         System.out.println("建立词项文档数运行时间是:"+runTimes+"秒");
    112     }
    113     
    114     /**
    115      * 生成idf
    116      * @throws Exception
    117      */
    118     public void getDocIdf() throws Exception{
    119         long start = System.currentTimeMillis(); 
    120         List<String> result = getAllTerms();
    121         Map<String,Double>[] map = getMapArray();
    122         File file = new File("E:/index2/DocIndex(idf).txt");
    123         if(!file.exists()){
    124             file.createNewFile();
    125         }
    126         FileOutputStream fo = new FileOutputStream(file);
    127         OutputStreamWriter os = new OutputStreamWriter(fo);
    128         BufferedWriter bw = new BufferedWriter(os);
    129         List<Inverted> list = MyTools.readDocIndex(new File("E:/index2/DocIndex(df).txt"));
    130         for(Inverted inverted:list){
    131             String term = inverted.getLexicalItem();
    132             int num=0;
    133             for(int i=0;i<Constant.DOC_NUMS;i++){
    134                 if(map[i].containsKey(term)){
    135                     num++;
    136                 }
    137             }
    138             //inverted.setFrequency(num);
    139             bw.write(inverted.getDocId()+"/"+inverted.getLexicalItem()+"/"+(Math.log(Constant.DOC_NUMS/num))/Math.log(10));
    140             bw.write("\r\n");
    141         }
    142         bw.close();
    143         os.close();
    144         fo.close();
    145         //System.out.println(result.size());
    146         
    147         long end = System.currentTimeMillis(); 
    148         double runTimes = (end-start)/1000.0;
    149         System.out.println("生成idf文件运行时间是:"+runTimes+"秒");
    150     }
    151     
    152     /**
    153      * 生成tf*idf文件
    154      * @throws Exception 
    155      */
    156     public void getTfIdf() throws Exception{
    157         long start = System.currentTimeMillis(); 
    158         File fileTfIdf = new File("E:/index2/DocIndex(tfidf).txt");
    159         if(!fileTfIdf.exists()){
    160             fileTfIdf.createNewFile();
    161         }
    162         
    163         FileOutputStream fo = new FileOutputStream(fileTfIdf);
    164         OutputStreamWriter os = new OutputStreamWriter(fo);
    165         BufferedWriter bw = new BufferedWriter(os);
    166         
    167         List<Inverted> listTf = MyTools.readDocIndex(new File("E:/index2/DocIndex(tf).txt"));
    168         List<Inverted> listIdf = MyTools.readDocIndex(new File("E:/index2/DocIndex(idf).txt"));
    169         
    170         for(int i=0;i<listTf.size();i++){
    171             double tf = listTf.get(i).getFrequency();
    172             double idf = listIdf.get(i).getFrequency();
    173             bw.write(listTf.get(i).getDocId()+"/"+listTf.get(i).getLexicalItem()+"/"+tf*idf);
    174             bw.write("\r\n");
    175         }
    176         bw.close();
    177         os.close();
    178         fo.close();
    179         long end = System.currentTimeMillis(); 
    180         double runTimes = (end-start)/1000.0;
    181         System.out.println("生成tf*idf文件运行时间是:"+runTimes+"秒");
    182     }
    183     

     

     

    选定一个阈值,将权重低于这个阈值的词项删掉,剩下的所有词项放到一个集合(注意集合的性质:元素的唯一性)里面。然后基于该集合的所有词项,建立一个词项文档的倒排

    建立倒排代码:

     1 /**
     2      * 倒排
     3      * @throws Exception 
     4      */
     5     public void invertedIndex() throws Exception{
     6         long start = System.currentTimeMillis(); 
     7         List<String> result = getAllTerms();
     8         Map<String,Double>[] map = getMapArray();
     9         System.out.println(result.size());
    10         
    11         File file = new File("E:/index2/inverted.txt");
    12         FileOutputStream fo = new FileOutputStream(file);
    13         OutputStreamWriter os = new OutputStreamWriter(fo);
    14         BufferedWriter bw = new BufferedWriter(os);
    15         
    16         for(String s:result){
    17             
    18             List<Integer> sortDoc = new ArrayList<>();
    19             for(int i=0;i<Constant.DOC_NUMS;i++){
    20                 if(map[i].containsKey(s)){
    21                     sortDoc.add(i+1);
    22                 }
    23             }
    24             bw.write(s+":");
    25             String str = "";
    26             for(int i:sortDoc){
    27                 str+=i+"/";
    28                 
    29             }
    30             bw.write(str.substring(0, str.length()-1));
    31             bw.write("\r\n");
    32             //System.out.println(s+":"+sortDoc);
    33         }
    34         bw.close();
    35         os.close();
    36         fo.close();
    37         long end = System.currentTimeMillis(); 
    38         double runTimes = (end-start)/1000.0;
    39         System.out.println("建立倒排运行时间是:"+runTimes+"秒");
    40     }

    倒排结果部分展示:

    正式:16
    老:2
    仅是:4/11/24
    退耕:24
    者:12/27
    最有:22
    深远:23/27
    公司:25
    长方:25/27/28
    内部:3/11
    决策:2/9/20/29
    为国:22
    专家:3
    准备:11
    领域:3/21/22/24
    法制:30
    挥了:12/22
    加产:17
    倍:17
    供求:23
    知情权:29
    为最:26
    加人:22
    登场:18
    逐渐:5/27
    耗费:27
    确立:5/7/27
    突击队:12
    就是:9/10/12/16/22/24/27

     

    就是:9/10/12/16/22/24/27:表示“就是”这个词项在文档9、文档10、文档12、...、文档27都出现了

     

    检索部分:

    输入一个query,对query切词

    方式1(布尔):建立词项布尔表达式,然后在倒排库里找,不断求交集和并集的,得到相关文档集。缺点是无法计算文档与query的相关度。

    方式2(向量空间):对上一节得到的词项,将每篇文档建立一个向量,词项出现为1,不出现为0。然后对query也建立向量,利用SVM的公式求文档与查询的相似度。

    对文档的建模

     1     /**
     2      * 构建文档向量(向量空间模型)
     3      * 问题:得到的文档向量是一个稀疏矩阵,存储空间有待优化
     4      * @throws Exception 
     5      */
     6     public void getVector() throws Exception{
     7         
     8         long start = System.currentTimeMillis(); 
     9         //List<String> result = getAllTerms();
    10         List<String> result = getIndexTerms();
    11         Map<String,Double>[] map = getMapArray();
    12         
    13         File file = new File("E:/index2/DocVector1.txt");
    14         FileOutputStream fo = new FileOutputStream(file);
    15         OutputStreamWriter os = new OutputStreamWriter(fo);
    16         BufferedWriter bw = new BufferedWriter(os);
    17         
    18         for(int i=0;i<Constant.DOC_NUMS;i++){
    19             List<Double> list = new ArrayList<>();
    20             for(String s : result){
    21                 if(map[i].containsKey(s)){
    22                     list.add(map[i].get(s));
    23                 }else{
    24                     list.add(0.0);
    25                 }
    26             }
    27             bw.write((i+1)+":");
    28             String str = "";
    29             for(double j:list){
    30                 str+=j+"/";
    31                 
    32             }
    33             bw.write(str.substring(0, str.length()-1));
    34             bw.write("\r\n");
    35         }
    36         bw.close();
    37         os.close();
    38         fo.close();
    39         long end = System.currentTimeMillis(); 
    40         double runTimes = (end-start)/1000.0;
    41         System.out.println("构建向量空间运行时间是:"+runTimes+"秒");
    42     }
    43     

    好了,接下来的就自己实现吧~

     

    转载于:https://www.cnblogs.com/ouym/p/6126134.html

    展开全文
  • 详细地描述了使用语义Web技术实现智能信息检索的思想和工作流程,提出了一个基于本体的信息检索系统的框架,并以一个地理信息领域的应用为例分析了该检索系统的实现技术。
  • 信息检索系统利用倒排索引和向量空间模型实现信息检索系统.完成工作:带位置信息的倒排索引向量空间模型TOP K查询BOOL查询短语查询拼写矫正同义词查询拼写矫正(短语)运行环境要求:python3在初次运行程序前请下载...

    信息检索系统

    利用倒排索引和向量空间模型实现的信息检索系统.

    完成工作:

    带位置信息的倒排索引

    向量空间模型

    TOP K查询

    BOOL查询

    短语查询

    拼写矫正

    同义词查询

    拼写矫正(短语)

    运行

    环境要求:python3

    在初次运行程序前请下载词干还原依赖的语料库

    在SearchSystem/main.py中已经注释掉下载语料库的命令

    nltk.download("wordnet")

    nltk.download("averaged_perceptron_tagger")

    nltk.download("punkt")

    nltk.download("maxnet_treebank_pos_tagger")

    取消注释后运行一次即可,语料库下载完成即可正常运行

    windows下如果嫌弃语料库下载比较慢,可以直接将该目录下的nltk_data文件夹替换掉user下的AppData/Roaming/nltk_data文件夹,根目录的nltk_data文件夹是已经下载好的语料库

    语料库下载完成后请将相应的下载语注释掉。

    在SearchSystem目录下运行命令:

    python main.py

    注意:运行前请不要修改工程文件的名字和相对位置

    SearchSystem工程目录是pycharm的工程

    实现功能

    词干还原

    利用python中自然语言处理的库:nltk对文章中的单词进行词干还原。

    在词干还原的过程中会去除无用的标点符号。

    索引构建

    带位置信息的倒排索引:

    例子:

    {

    "word1":{

    "1":[5,6,10],

    "5":[10,20,30]

    },

    "word2":{

    "2":[5,6,10],

    "33":[15,28,30]

    }

    ···

    }

    索引事先建立好储存在文件中,每次运行程序时将索引加载到内存中。

    向量空间模型

    通过查询向量计算出文档的wf-idf评分进行排序。

    wf-idf计算方法:

    首先对query中出现的单词对应的文档列表取并集。

    随后对query中出现的单词对文档进行wf-idf计算并评分。

    得到所有文档对该查询的评分后再对所有文档进行排序。

    wf-idf 和 tf-idf比较:

    通过log计算削弱词项频率对评分的影响。

    一篇文章中单词出现n次不代表其权重扩大n倍。

    TOP K 查询

    首先通过向量空间模型得到所有文档的评分。

    通过堆排序建好最小堆以后进行K次precDown操作。

    堆最后的K个元素即为评分前K大的元素。

    短语查询

    利用带位置信息的倒排索引。

    首先得到包含query中所有单词的文档列表的交集。

    从这些文档集中根据位置索引查找是否有匹配的短语。

    遍历第一个词项在文档中的位置,依次检测后面的词项位置中是否包含与其匹配的位置。

    通配符查询

    利用正则表达式找到所有匹配的词项,利用倒排索引检索出词项对应的文档。

    支持通配符的短语查询:

    首先将检索到的词项存在一个二维数组中,随后对出现的每个短语组合进行短语查询。

    同义词查询

    同样利用nltk语言处理库获取单个单词的同义词列表(有可能是短语)

    随后对每个单词或者短语进行检索,获取文档集。

    BOOL查询

    将查询表达式转为后序表达式:

    如 A OR B AND C 转为

    A B C AND OR

    用一个栈来计算后序表达式

    拼写矫正

    c 是 编辑距离为1或者2或者0的词,并且词属于给定的词典.

    P(c)是每个词在字典中出现的频率.

    P(w)是每一种拼写错误可能出现的概率,这里认为是一个常数

    根据贝叶斯理论

    计算 P(c|w),即给定词w,纠正到每个c的概率,并且从中选出概率最高的词

    这里还需要知道一个项 P(w|c|),即给定c,c就是输入者想要的单词的概率

    由于没有错误模型数据,我们简单这么认为

    P(W|C0) >> P(W|C1) >> P(W|C2)

    C0/1/2 是编辑距离为0/1/2的词,即编辑距离小的有更高的优先级

    最后,模型工作如下

    如果输入词在词典里找到了原词,这返回

    从编辑距离为1的词选出频率最高的,返回

    从编辑距离为2的词选出频率最高的返回。

    展开全文
  • 信息检索系统——VSM算法实现

    千次阅读 2020-07-05 00:55:32
    匹配文档样例 查询样例 匹配结果样例 python–源码如下 import math from tqdm import tqdm df_dict={} global docs_num #一个全局变量,保留全部文档数 ...def doc_pl(doc): #求出文档中的词频数,及总词数,用于tf...
  • 甲骨文研究中的信息资源非常丰富,但是从这浩瀚的资源中如何快速、全面并且精确地查找到用户所要查找的信息,这是一个令所有研究者头疼的一个问题,快速、精确的搜索引擎就是解决这个难题的最佳方法,但在实践中发现单个...
  • 在本课程中,我们将研究基于文本和基于Web的信息检索系统的理论,设计和实现,包括检查现代搜索和数据挖掘应用程序核心的Web和社交媒体挖掘算法和技术。到学期结束时,您将能够:定义和解释与信息存储和检索相关的...
  • 基于概念云与本体的信息检索系统(IRSCCO)的设计与实现,任瑞娟,濮德敏,基于本体的语义检索是提高信息系统检索精确度的有效途径之一。概念云是云模型在信息领域的应用,是本体中的概念按照一定算法在页
  • 基于GIS数据库信息的面向某一行业的信息检索系统的设计与实现,林祥涛,彭泳,本文在分析当前的信息检索系统优缺点和GIS数据库信息特点的基础上,利用GIS数据库信息分类明确的优势,提出了一种面向某个行业的信
  • Wumpus(《信息检索:实现和评价搜索引擎》其中一位作者开发的一个多用户开源信息检索系统 可以在网上下载)提供了模型实现 可作为学生练习的一个基础 《信息检索:实现和评价搜索引擎》采用的模块化结构使教师可以将...
  • 这是一个利用Django搭建的一个人物信息检索系统,大约从Wikipedia爬取了10000 个人物信息,并且提取了其中 Infobox 的对应信息。 对于 Wikipedia 中爬取的信息,我们重新组织了其格式并且进行显示。 .....
  • 基于Maemo平台的图书馆信息检索系统的设计与实现,徐冬,,图书馆是人们获取信息的一个非常重要的渠道,但是在浩瀚的书海中寻找到自己需要的文献资料并不是一件容易的事。传统的方式是通过
  • 一个基于用户上下文的个性化信息检索系统的设计与实现,张磊,孙文生,理想的搜索引擎能够依据用户浏览和检索的习惯信息,熟悉用户的兴趣爱好,建立一定的用户描述,主动向用户提供相关的信息。针对大
  • 信息检索系统——基于Lucene实现 题目要求 基于课程学习内容,实现简单的搜索引擎功能(界面可视化不做要求,可终端输出),要求实现以下基本功能: 拼写检查(参考最小编辑距离原理) 倒排索引 使用TF/IDF或者VSM...
  • 基于Lucene的专家信息检索服务系统的设计与实现,黎幸子,,信息技术与网络技术的发展,推动人类社会进入了信息划时代。行业项目申请审批的信息化是各行各业信息化建设的一个重要组成部分。
  • 中文全文信息检索系统中索引项技术及分词系统的实现 文章来源: 昆明理工大学计算机系 文章作者:黄青松 发布时间:2005-06-02 摘要:本文对中文全文检索系统中常用的索引项技术n元语法,字,n元...
  • 这是一个利用Django搭建的一个人物信息检索系统,大约从Wikipedia爬取了10000 个人物信息,并且提取了其中 Infobox 的对应信息。 对于 Wikipedia 中爬取的信息,我们重新组织了其格式并且进行显示。 .....
  • 摘 要 介绍了在中文全文检索系统实现主题词标引的思路及具体实现过程、各种词表的构造及更新方法和措施、基于主题词标引的优化检索功能等。关键词 主题词标引 全文检索 关键词标引 主题词表  主题标引技术...
  • 简易的信息检索系统

    2019-10-05 10:17:29
    设计并实现一个简易的信息检索系统,构成搜索引擎的核心模块。该系统读取一组英文文本 文件,为该组文件创建反向索引(请参考“补充知识”部分),并借助创建好的反向索引实 现对文件内容的快速查询。 基本功能...
  • 新闻检索系统的设计与实现,其中有新闻信息浏览模块、新闻评论模块、新闻分类列表、新闻后台管理模块、管理员管理模块、RSS新闻聚合管理模块,其中登录密码采用加密方式。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,794
精华内容 717
关键字:

信息检索系统实现