精华内容
下载资源
问答
  • 向量空间模型(VSM)的JAVA实现,从文档表示到相似度计算,使用两种相似度计算方式:cos和tf-idf算法
  • 向量空间模型的构建 C++实现 VS2013上做的,绝对的好用
  • 在传统向量空间模型的基础上,提出一种新的信息检索算法模型——N层向量模型。此模型应用在Web信息检索上,能较好地适应文档集合的动态扩充。
  • 基于结构化向量空间模型的中文信息检索系统研究与实现
  • 基于N层向量空间模型的网络信息检索平台 基于N层向量空间模型的网络信息检索平台
  • main() 1、实验环境 Python 3.6.4 、Visual Studio Code 2、实验目的和要求 2.1实验目的: 基于向量空间模型理论,构造一定数量的文本库,采用TFIDF权重进行关键词排序选择,并采用向量夹角余弦判断检索词和文本库中...
    import numpy as np 
    import pandas as pd
    import math
    
    def bool_retrieval(string):
        if string.count('and')*string.count('or') > 0:
            a = string[:string.find('or')]
            b = string[string.find('or')+3:]
            bool_retrieval(a)
            bool_retrieval(b)
        elif 'or' in string:
            key = string.split(' or ')
            for i in range(len(documentbase)):
                for j in range(len(key)):
                    if key[j] in documentbase[i]:
                        print('D%d:'%(i+1),documentbase[i])
        elif 'and' in string:
            key = string.split(' ')
            del key[key.index('and')]
            for i in range(len(documentbase)):
                flag = 1
                for j in range(len(key)):
                    if key[j] not in documentbase[i]:
                        flag = 0
                        break 
                if(flag):
                    print('D%d:'%(i+1),documentbase[i])
    
    #统计词项tj在文档Di中出现的次数,也就是词频。
    def computeTF(wordSet,split):
        tf = dict.fromkeys(wordSet, 0)
        for word in split:
            tf[word] += 1
        return tf
    
    #计算逆文档频率IDF
    def computeIDF(tfList): 
        idfDict = dict.fromkeys(tfList[0],0) #词为key,初始值为0
        N = len(tfList)  #总文档数量 
        for tf in tfList: # 遍历字典中每一篇文章
            for word, count in tf.items(): #遍历当前文章的每一个词
                if count > 0 : #当前遍历的词语在当前遍历到的文章中出现
                    idfDict[word] += 1 #包含词项tj的文档的篇数df+1  
        for word, Ni in idfDict.items(): #利用公式将df替换为逆文档频率idf
            idfDict[word] = round(math.log10(N/Ni),4)  #N,Ni均不会为0
        return idfDict   #返回逆文档频率IDF字典
    
    #计算tf-idf(term frequency–inverse document frequency)
    def computeTFIDF(tf, idfs): #tf词频,idf逆文档频率
        tfidf = {}
        for word, tfval in tf.items():
            tfidf[word] = tfval * idfs[word]
        return tfidf
    
    def length(key_list):
        num = 0
        for i in range(len(key_list)):
            num = num + key_list[i][1]**2
        return round(math.sqrt(num), 2)
    
    def main():
        split1 = D1.split(' ')
        split2 = D2.split(' ')
        split3 = D3.split(' ')
        split4 = D2.split(' ')
        split5 = D3.split(' ')
        wordSet = set(split1).union(split2,split3,split4,split5)  #通过set去重来构建词库
        #print(wordSet)
        tf1 = computeTF(wordSet,split1)
        tf2 = computeTF(wordSet,split2)
        tf3 = computeTF(wordSet,split3)
        tf4 = computeTF(wordSet,split4)
        tf5 = computeTF(wordSet,split5)
        #print('tf1:\n',tf1)
        idfs = computeIDF([tf1, tf2, tf3, tf4, tf5])
        tfidf1 = computeTFIDF(tf1, idfs)
        tfidf2 = computeTFIDF(tf2, idfs)
        tfidf3 = computeTFIDF(tf3, idfs)
        tfidf4 = computeTFIDF(tf4, idfs)
        tfidf5 = computeTFIDF(tf5, idfs)
        tfidf_list = [tfidf1, tfidf2, tfidf3, tfidf4, tfidf5]
        tfidf = pd.DataFrame([tfidf1, tfidf2, tfidf3, tfidf4, tfidf5])
        #print(tfidf)
        key_tfidf1 = sorted(tfidf1.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        key_tfidf2 = sorted(tfidf2.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        key_tfidf3 = sorted(tfidf3.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        key_tfidf4 = sorted(tfidf4.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        key_tfidf5 = sorted(tfidf5.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        key_tfidf_list = [key_tfidf1, key_tfidf2, key_tfidf3, key_tfidf4, key_tfidf5]
        print('****************通过TDIDF权重排序选取的关键词****************')
        for i in range(len(key_tfidf_list)):
            print('文档D%d:'%(i+1),key_tfidf_list[i])
        #print(key_tfidf_list)
            #5.查询与文档Q最相似的文章
        q = 'gold silver car'
        split_q = q.split(' ')   #分词
        tf_q = computeTF(wordSet,split_q) #计算Q的词频
        tfidf_q = computeTFIDF(tf_q, idfs) #计算Q的tf_idf(构建向量)
        key_query = sorted(tfidf_q.items(),key=lambda d: d[1], reverse=True)[:keynumber]
        len_key_query = length(key_query)
    
        # vector space
        df = pd.DataFrame([tfidf1, tfidf2, tfidf3, tfidf4, tfidf5, tfidf_q])
        i = 0
        while i < len(df.columns):
            if any(df.values.T[i])==0:
                df = df.drop(columns=df.columns[i],axis=1)
            else:
                i = i + 1
        print('**************************向量空间***************************')
        print(df)
    
        #计算余弦相似度并排序
        result = []
        for i in range(len(key_tfidf_list)):#对于每篇文档
            num = 0
            for j in range(len(key_query)):#对于查询式中的每个词
                for k in range(len(key_tfidf_list[i])):#对于每篇文档中的每个关键词
                    if key_query[j][0] == key_tfidf_list[i][k][0]:
                        num = num + key_query[j][1] * key_tfidf_list[i][k][1]
            result.append((i+1,round(num/math.sqrt(len_key_query * length(key_tfidf_list[i])),4)))
        result = sorted(result,key=lambda d: d[1], reverse=True)
        print('**************************文档排序***************************')
        print('按照Query和文档Di的余弦相似度从高到低排序为:')
        for i in range(len(result)):
            print('cos<D%d,Query> = %.3f'%(result[i][0],result[i][1]))
        print('************************************************************')
    
    if __name__=="__main__":
        keynumber = 3
        #1.声明文档 分词 去重合并
        D1 = 'Delivery of gold damaged in a fire'
        D2 = 'Delivery of silver arrived in a silver car'
        D3 = 'Delivery of gold arrived in a car'
        D4 = 'Delivery of gold arrived in a gold ship damaged in a fire'
        D5 = 'Delivery of silver arrived in a silver car made of silver'
        documentbase = [D1,D2,D3,D4,D5]
        print('是否采用布尔搜索?')
        if(input()=='yes'):
            print('Please input:')
            bool_retrieval(input())       
        else:
            print('正在对文档进行分词......\n正在计算文档的tf和idf值......\n正在对文档进行关键词选择......\n预处理完成!\n请输入查询文档:\ngold silver car')
            main()
    

    1、实验环境

    Python 3.6.4 、Visual Studio Code
    

    2、实验目的和要求

    2.1实验目的:

    基于向量空间模型理论,构造一定数量的文本库,采用TFIDF权重进行关键词排序选择,并采用向量夹角余弦判断检索词和文本库中文本的相似度。
    

    2.2基本要求:
    ①构造一组文本库、关键词、检索内容
    ②将文本库和检索内容根据关键词转化向量表示
    ③采用向量夹角余弦判断检索词和文本库中文本的相似度
    ④按照相似度大小将检索出的内容进行排序
    ⑤在上述基本要求之上可以整合布尔检索、过滤推送和倒排文档等功能。

    3、文档库,查询内容,解题思路

    3.1文档库
    D1 = ‘Delivery of gold damaged in a fire’
    D2 = ‘Delivery of silver arrived in a silver car’
    D3 = ‘Delivery of gold arrived in a car’
    D4 = ‘Delivery of gold arrived in a gold ship damaged in a fire’
    D5 = ‘Delivery of silver arrived in a silver car made of silver’
    3.2查询内容
    q = ‘gold silver car’
    q = ‘fire and gold or ship’(布尔检索)
    3.3解题思路
    (1)向量空间检索
    ①在已构建的文本库中进行分词,构建词库,然后计算各个文档的tf值和idf值,并用tfidf值对各个关键词进行排序,选出权值最大的3个关键词
    ②输入查询文档,将其和各文本库文档进行向量空间表示,通过夹角余弦值大小判断相似度并排序
    (2)在此基础上进行布尔检索
    ①若查询表达式中存在多个and和or,即此表达式存在多层嵌套,找出其中的or,将该文档截取成两部分,然后进行递归,直至子文档中不同时存在and和or,进行第二步
    ②若查询表达式中连接词为or,进行遍历查找,若找到其中一个即输出;若查询表达式中连接词为and,进行遍历查找,若其中一个不存在即退出遍历,直至最后一个必需关键词被查找到,则输出该文档;

    4、实验步骤

    4.1输入:
    ①是否采用布尔搜索
    ②输入查询文档或布尔表达式
    4.2输出:
    在这里插入图片描述
    在这里插入图片描述

    5、讨论和分析

    ①向量空间算法是根据关键词进行判断的,对于本实验中的一词多义问题难以处理(gold既指金色也指黄金)
    ②构建的布尔搜索模型较为原始,仅能处理简单的多层嵌套布尔表达式,对于复杂逻辑的多层嵌套布尔表达式并不适用。
    ③由于文本库所含文档数较少以及文档长度较短,可能存在相似度并列的情况。

    展开全文
  • 将查询也看作一个文档,构造向量后与向量空间中的每个向量计算余弦相似度,进行排序,即可得到结果。 基本步骤 对文档进行分词处理,去除停用词等 计算每个文档中词项的tf值,计算公式: 计算文档集中所有词项的...

    我觉得这个关键是理解思想,因为实现还是比较简单的。说说我对VSM的理解吧,每个文档对应一个向量,向量的维度是一定范围的词项(有两种选取方法),对应的值为tf-idf。将查询也看作一个文档,构造向量后与向量空间中的每个向量计算余弦相似度,进行排序,即可得到结果。


    基本步骤

    1. 对文档进行分词处理,去除停用词等
    2. 计算每个文档中词项的tf值,计算公式:
      在这里插入图片描述
    3. 计算文档集中所有词项的idf值,计算公式:
      在这里插入图片描述
    4. 计算每个文档中词项的tf-idf值,计算公式:
      在这里插入图片描述
    5. 对查询进行上述处理
    6. 构造向量,有两种向量维度的选取方法:
      (1)整个文档集合有n个词,那么向量就已Vn表示,即涉及整个词汇
      (2)取q和d的合集词汇形成Vx,x=|q|+|d|
      这里要提醒一句,对于大规模的向量空间,方法1将会极为耗时,方法二可能几秒搞定的事,方法一要运行个几小时(亲身经历)。
    7. 计算余弦相似度,进行排序。

    注意点

    1. 没有出现的词tf-idf一般不取0,而是取一个很小的值
    2. 可进行优化,如设置闸值,将小于某个合适tf-idf值的词项删去

    我将课程资料和代码都放到百度云了,要者自取。
    链接:https://pan.baidu.com/s/1Fr94yOt_5l4rgkqCv517Dw
    提取码:eenc

    展开全文
  • 信息检索技术——向量空间模型

    千次阅读 2012-05-19 13:12:38
    上次介绍了信息检索技术——布尔检索,布尔模型已经可以解决一个很重要的问题,就是找到和用户需求相关的文档(其中还需要很多处理,比如分词,归一化,去掉停用词等等,我们只是介绍主要的框架流程)。但是这样找到的...

    上次介绍了信息检索技术——布尔检索,布尔模型已经可以解决一个很重要的问题,就是找到和用户需求相关的文档(其中还需要很多处理,比如分词,归一化,去掉停用词等等,我们只是介绍主要的框架流程)。但是这样找到的文档会有很多,也许上千个,也许上万个,这远远不是用户所要的。用户也不会去从几万个文档中挑选自己要找的。因此我们需要对结果进行排序,把最能满足用户需求的文档放在最上面显示给用户,就像google和baidu做的一样。细心的朋友就能发现,其实信息检索是一个循序渐进的剪枝和筛选过程,最后留下的就是用户想要的。

    因此,我们需要一种评分机制来进行排序,通过得分的高低排除top N的文档返回给用户。这个评分通过什么来确定呢?当然是用户查询的query和返回文档的相似度了。计算相似度有很多种方法:

    方法1 Jaccard coefficient

    此方法看上去很好理解,就是用query和文档共同出现的词的个数,除以一共的词数。当然也有很多问题

    1 没有考虑文档中词出现的次数(没有考虑tf因素)

    2 没有考虑文档的频率(没考虑idf因素)

    3 没有考虑文档的长度,长文档和短文档计算相似度的差别会很大

    下面我们一起看看一个非常著名的模型——空间向量模型

    方法2  向量空间模型(VSM)

    首先介绍2个概念,tf和idf

    tf即term frequency, 表示一个term t出现在document d中的次数,这是文档中一个很重要的概念。出现次数更多意味着重要程度越高,但是需要注意的是,相关度的提高并不是和次数的提高成同比的。因此通常tf需要做如下的处理

    w1= log10(tf+1)

    这样做就是要弱化次数对于相关度的影响

    df即document frequency,表示一个term在整个文档集中出现的频率。与tf相反,一个term的重要程度是随着它在语料库中出现的频率成反比的。比如and,or等词在几乎所有文档中都出现,那么这些词的意义就很弱,而一些专业词汇只在几篇文档中出现过,显然意义更加重要。idf就是df取倒数,这里只是为了表示方便。

    同样,为了弱化频率的效果,我们也做如下处理

    w2= log10(N/df) 其中N为文档总数,df是文档term在所有文档集合中出现的次数。

    需要注明的是,tf和idf的计算有很多中变体,不一定要完全使用上面的公式,很多情况还要根据文档集合的大小具体分析。

    有了上面的tfidf作为权重,我们可以很简单的计算所有词的权重,然后用一个N维的向量来表示一个文档,同样用N维的向量来表示query,query中如果没有对应的term,则该维权重为0。

    于是,利用我们的数据知识,我们可以知道,在同样的空间中,如果两个向量的夹角越小,说明两个向量越相似,反之两个向量越无关。因此使用cosine定理,我们可以很简单地得到向量之间的相似度

    空间向量模型可以说是信息检索中相当常见并且非常重要的模型之一。理解起来非常简单直观,并且效果也是不错的。希望对大家有所帮助。

    展开全文
  • 布尔模型(Boolean Model) 要从文档集合D={d1,d2,…,dn}中检索出: 包含"北京妹纸",或者"杭州妹纸, "但不包括"日本妹纸"的文档。 假设D = {“北京的妹纸豪爽”,“北京是中国首都,而东京不是日本首都,一个妹纸说”,...

    布尔模型(Boolean Model)

    要从文档集合D={d1,d2,…,dn}中检索出: 包含"北京妹纸",或者"杭州妹纸, "但不包括"日本妹纸"的文档。
    假设D = {“北京的妹纸豪爽”,“北京是中国首都,而东京不是日本首都,一个妹纸说”,“北京和杭州都是旅游名城”,“杭州的妹纸温婉”}

    将查询语句表示为布尔表达式:Q = 妹纸 AND (北京 OR 杭州) NOT 日本
    将布尔表达式Q转换为向量表达:
    ①(1,1,0,0) 即:包含"妹纸"和"北京",且没包含"杭州"和"日本"的语句
    ②(1,0,1,0) 即:包含"妹纸"和"杭州",且没包含"北京"和"日本"的语句
    ③(1,1,1,0) 即:包含"妹纸",“北京"和"杭州”,且没包含"日本"的语句

    文档集合D中的文档四元组对应的向量值如果包含于上述①②③向量中的任何一个,就可认为他们之间是相似关系,且sim(Q,D)只能为0或1。

    将文档集合D解析为向量表达:
    d1的向量解析为:(1,1,0,0)
    d2的向量解析为:(1,1,0,1)
    d3的向量解析为:(0,1,1,0)
    d4的向量解析为:(1,0,1,0)

    综上可得:d1与向量①相同,d4和③相同,所以查询召回文档d1和d4

    布尔模型缺点

    • 布尔模型没有考虑索引词和文档中词的权重
    • 布尔模型是命中模型,不涉及对召回结果的排序
    • 布尔模型是完全匹配,不支持部分匹配,会导致太多或太少的结果被召回

    向量空间模型(Vector Space Model)

    VSM是把对文本转换为空间向量, 通过向量的计算来处理文本内容

    • 把文本内容转换为空间向量 (一般使用词的tf-idf值作为向量来表征文本内容)
    • 计算向量之间的相似度来度量文档间的相似性 (常用余弦值来度量相似性)

    计算VSM的步骤

    要从文档中找出与查询语句最相关的文档

    查询语句:Query={q1,q2,…,qn}
    文档:
    Document1 = {term11,term12,…,term1N},
    Document2 = {term21,term22,…,term2N},
    Document3 = {term31,term32,…,term3N}

    计算每个文档中所有词的TF-IDF值作为文档的向量表达:
    Vector1 ={weight11, weight12,…,weight1N},
    Vector2 ={weight21, weight22,…,weight2N},
    Vector3 ={weight31, weight32,…,weight3N}

    把查询语句Query当作一个文档并计算其中所有词的TF-IDF值作为向量表达:
    VectorQ = {weightq1, weightq2, …… , weightqN}

    分别计算Query与Document1、Document2、Document3的夹角余弦值sim(Q,D1)、sim(Q,D2)、sim(Q,D3作为相关性的打分,两个向量之间的夹角越小,余弦值就越大,打分就越高,相关也就性越大。

    最终根据sim(Q,D)的大小进行召回、排序

    计算VSM的公式

    sim(Q,D) = cosθ = VectorQVectorDVectorQVectorD\frac{VectorQ·VectorD}{|VectorQ||VectorD|} = q1d1+q2d2+...+qndnq12+q22+...+qn2d12+d22+...+dn2\frac{q_1d_1+q_2d_2+...+q_nd_n}{\sqrt{q_1^2+q_2^2+...+q_n^2}*\sqrt{d_1^2+d_2^2+...+d_n^2}}

    在求得各个文档中词的TF-IDF后,有时会再除以文档长度来消除长文档对结果的影响
    在计算cosθ值时Query与Document的维度要一样,对于维度不一样的可以使用补零等方式使维度变的一致

    VSM缺点

    用户想查询的是一个跟query相关度大的文档,并不一定是这个文档中出现了查询词。
    换句话说就是即便这个文档中出现了查询词,并不一定相关性就大。

    展开全文
  • 万维网给信息检索技术带来了极大的机遇和挑战。经过近十几年的发展,信息检索已经由一个纯粹的学术研究学科转变成大多数人信息获取的技术基础。 随着Web 2.0概念的普及和发展,万维网不再仅仅是一个巨大的信息库,更...
  • 于是,利用我们的数据知识,我们可以知道,在同样的空间中,如果两个向量的夹角越小,说明两个向量越相似,反之两个向量越无关。因此使用cosine定理,我们可以很简单地得到向量之间的相似度 ...
  • 信息检索中,相似度表示的是两个文档之间的相似程度或者查询与文档的相似程度。 首先回想一下检索过程: 1:首先用户输入查询词。 2:搜索引擎根据查询词查找相应的文档。 3:搜索引擎把查询结果以一定的方式...
  • 利用倒排索引和向量空间模型实现的信息检索系统。 完成工作: 带位置信息的倒排索引 转化空间模型 TOP K查询 BOOL查询 初步查询 拼写矫正 名词查询 拼写矫正(以下) 运行 环境要求:python3 在初次运行程序前请下载...
  • Information Retrieval(信息检索)笔记05:文档评分、词项权重计算以及向量空间模型排名检索模型(Ranked retrieval models)Jaccard Coefficient (Jaccard 系数)Bag of words model(词袋模型)Term Frequency tf:...
  • 万维网给信息检索技术带来了极大的机遇和挑战。经过最近十几年的发展,信息检索已经由一个纯粹的学术研究学科转变成大多数人信息获取的技术基础。 随着Web 2.0概念的普及和发展,万维网不再仅仅是一个巨大的信息库,...
  • 向量空间模型

    千次阅读 2012-11-18 17:03:16
    向量空间模型 (或者 词组向量模型) 作为向量的标识符(比如索引),是一个用来表示文本文件的代数模型。它应用于信息过滤、信息检索、索引以及关联规则。SMART是第一个使用这个模型的信息检索系统。 ...
  • 信息检索系统利用倒排索引和向量空间模型实现的信息检索系统.完成工作:带位置信息的倒排索引向量空间模型TOP K查询BOOL查询短语查询拼写矫正同义词查询拼写矫正(短语)运行环境要求:python3在初次运行程序前请下载...
  • 比如两句话 我爱吃鸭, 他爱吃鸡可以构造出一个二维矩阵:横坐标是每一句话包含的信息,纵坐标是所有文字 句子1 句子2 句子n。。。。你00。。我10。。他01。。吃11。。等等。。。。。当用户想要检索某些文字的时候...
  • 检索模型1.1 bool模式bool模式下,是最简单的检索模式,依据操作符AND 或者 OR 过滤document,结果只是包含指定的term的文档。他不会对document打分,只是为了减少后续要计算的document的数量,提升性能1.2 TF/IDF...
  • 王老师的现代信息索引讲的很精彩,但是三节联排的课程总让我的注意力没办法太集中。在这里记录一下知识,也但是回顾了。 支持布尔查询的索引办法,在给定一个查询的情况下,可能匹配到的结果非常的多,那么对匹配...
  • 目的:1、可以通过元数据(文档的作者、标题、出版日期等)来对文档进行索引和检索;2、上述索引能够提供一个简单的文档评分;  ②、词项字在文档中的权重的概念,并通过期出现的统计信息进行权重
  • 第六章 文档评分、词项权重计算及向量空间模型 在文档集规模很大时,满足布尔查询结果的文档数量可能非常多,往往会大大超过用户能够浏览的文档的数目。对于给定的查询,搜索引擎会计算每个匹配文档的得分并排序。 ...
  • 第6章 文档评分、词项权重计算及向量空间模型 参数化索引及域索引 元数据是指和文档有关的一些特定形式的数据,比如标题、出版日期等,这些元数据通常会包含字段(field)信息。 对每个字段(比如文档创建时间)...
  • 实际上,大多数文档都具有额外的结构信息.数字文档通常会把与之相关的元数据(metadata)以机读的方式一起编码.所谓元数据,指的是和文档相关的一些特定形式的数据,比如文档的作者,标题以及出版日期等等. 问题:...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 237
精华内容 94
关键字:

信息检索向量空间模型