精华内容
下载资源
问答
  • 布尔模型
    2021-07-01 14:41:13

    最早的IR模型,也是应用最广泛的模型;目前仍然应用于商业系统中;Lucene是基于布尔(Boolean)模型的。

    布尔模型描述

    文档D表示:一个文档被表示为关键词的集合
    查询式Q表示:查询式(Queries)被表示为关键词的布尔组合,用“与、或、非”连接起来,并用括弧指示优先次序
    匹配F:一个文档当且仅当它能够满足布尔查询式时,才将其检索出来

    检索策略基于二值判定标准
    算法R:根据匹配框架F判定相关, 计算相关度排名,这里不涉及doc得分和tfidf,只是boolean关系。
    查询表示
    在布尔模型中,所有索引项的权值变量和文档d与查询q的相关度都是二值的,查询q被表述成一个常规的布尔表达式,为方便计算查询q和文档d的相关度,一般将查询q的布尔表达式转换成析取范式DNF。也就是QueryParser解析后,看到的BooleanQuery。

    要从文档集合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

    模型缺点

    • 布尔模型没有考虑索引词和文档中词的权重
    • 布尔模型是命中模型,不涉及对召回结果的排序
    • 布尔模型是完全匹配,不支持部分匹配,会导致太多或太少的结果被召回
    更多相关内容
  • grep 在文本中查某个词足够了,但有其他需求 其他需求: 数据量大而多,快速处理 flexible matching operations 排序 布尔模型 query:布尔表达式 任务: ad hoc retrieval task. 输入query,输出doc列表(排序后) ...

    1.Information Retrieval

    定义:
    Information retrieval (IR) is finding material (usually documents) of an unstructured nature (usually text) that satisfies an information need from within large collections (usually stored on computers).
    web search

    • 数量庞大
    • 需要索引
    • 反欺诈
    • 利用超链接

    personal information retrieval:

    • eg:Email
    • 分类
    • 垃圾邮件过滤
    • 存储大量类别
    • 维护免费
    • 磁盘空间

    enterprise,institutional, and domain-specific search

    • stored on centralized file systems

    线性查找:grep

    • 在文本中查某个词足够了,但有其他需求

    其他需求:

    • 数据量大而多,快速处理
    • flexible matching operations
    • 排序

    布尔模型

    • query:布尔表达式

    任务:

    • ad hoc retrieval task.
      • 输入query,输出doc列表(排序后)

    评估

    • precision
    • recall

    专有名词

    • term:索引的单元,如词、词组、潜在词等
    • document:检索的单位,如网站列表,也可能是某一章节
    • collection或者corpus:doc的集合
    • information need
      • 用户向计算机传递的需求
      • 可能并不精确
    • relevant:如果用户认为包含与其个人信息需求相关的信息

    1.1 term-document matrix

    在这里插入图片描述
    词袋->doc向量:每列一个doc向量,每行一个term向量
    query:Brutus AND Caesar AND NOT Calpurnia,
    在这里插入图片描述
    答案:Antony and Cleopatra and Hamlet
    问题

    • 稀疏,词表大难以存储–>倒排索引

    1.2 倒排索引

    在这里插入图片描述

    INVERTED INDEX

    • dictionary(vacabulary):
      • 内存
      • key:term列表,也排序了,也会记录postings的长度(doc freq)
      • value:postings list/postings:排好序的,按doc id,出线相关词的freq,…
    • postings
      • posting记录:docid,term在doc中出现的位置、freq,…
      • 存储:disk
        • 固定长度:不行,浪费
        • linked list:链表,
          • 便于插入,
          • 便于扩展到advanced indexing strategies
            • skip list,需要新的指针
          • 问题:要存储指针
        • 可变数组
          • 顺序存储,遍历快
          • 无需存储指针,指针可以是offset
        • 混合
          • 不变数组的链表

    建立:

    • Collect the documents to be indexed:
    • 分词
    • normalized
    • index
      • merge:相同term的相同doc合并
        在这里插入图片描述

    1.3 Processing Boolean queries

    1. 得到每个term的postings
    2. OR:则两个表融合,取并集,AND:取交集,转化为AND链接的形式

    取交集:(标准方法)
    在这里插入图片描述
    问题:取交集时,常数复杂度,但这个常数很大
    解决:

    • 先按doc freq排序(posting的长度),先合并短的
      • 最终结果的长度不会超过最短的列表
      • 这是保存doc freq.的原因
      • 先算OR,再算AND
        在这里插入图片描述
    • 先算短的,然后保存到中间结果
      • 每次下一个输入与中间结果求交集
      • 问题:不对称
        • 中间结果:内存;下一个输入:disk
        • 但下一个输入可能比中间结果大得多(两个数量级?)
      • 加速合并过程
        • 中间结果的doc在长positng中二分查找合并
        • 长postings采用哈希存储
        • 上述无法用于压缩后的positngs
      • 都是常见词,仍可以用标准法

    带中间结果的求交集:
    在这里插入图片描述

    1.4 对基本布尔操作的扩展和有序检索

    布尔检索和有序检索(排序检索模型)对应

    布尔检索:

    • query:精确的逻辑表达式
    • 结果:无序
    • 布尔操作符的扩展
      • 邻近操作符:term的距离在文档中接近(中间含有几个词,来表征接近的程度
    • 专业人士更喜欢布尔检索:查询精确,控制力和透明度
      • 排序:按时间。。。

    有序检索

    • query:不像逻辑表达式这么精确,采用一个或多个词构建(自由文本查询)
    • 结果:有序

    要点

    • term:提供,容忍拼写错误,词语表达不一致(语义相同)
    • 复合词和短语:(Gates Near Microsoft)
    • 相似度:布尔查询仅记录存在与否,但是我们需要得到文档相关的可靠程度
      • 词项频率:term在doc中的频率高,权重高
    • 排序

    ad hoc search:

    • 大搜、电商搜索。。。
    • 部分支持布尔操作,专业人士喜欢,大多人用的少
    展开全文
  • 文本信息检索——布尔模型和TF-IDF模型1. 布尔模型​如要检索“布尔检索”或“概率检索”但不包括“向量检索”方面的文档,其相应的查询表达式为:Q=检索 and (布尔or 概率 not向量),那么Q可以在其相应的(检索,布尔...

    文本信息检索——布尔模型和TF-IDF模型

    1. 布尔模型

    ​如要检索“布尔检索”或“概率检索”但不包括“向量检索”方面的文档,其相应的查询表达式为:Q=检索 and (布尔or 概率 not向量),那么Q可以在其相应的(检索,布尔,概率,向量)标引词向量上取(1,1,0,0)(1,0,1,0)(1,1,1,0),那么文档Dj的向量如果与这中间一个相等,那么即可认为他们之间存在相似关系,而这种相互关系也是布尔值,即sim(Q,Dj)只能为0或1。

    2.TF-IDF模型

    ​在某个一共有一千词的网页中“原子能”、“的”和“应用”分别出现了 2 次、35 次 和 5 次,那么它们的词频TF就分别是 0.002、0.035 和 0.005。 我们将这三个数相加,其和 0.042 就是相应网页和查询“原子能的应用”。

    一个词预测主题能力越强,权重就越大,反之,权重就越小。我们在网页中看到“原子能”这个词,或多或少地能了解网页的主题。我们看到“应用”一次,对主题基本上还是一无所知。因此,“原子能“的权重就应该比应用大。

    应删除词的权重应该是零。

    2.1权重计算

    我们假定中文网页数是D=10亿,应删除词“的”在所有的网页中都出现,即|{𝑗:𝑡_𝑖 "∈" 𝑑_𝑗}|=10亿,那么它的idf=log(10亿/10亿)= log (1) =0

    假如专用词“原子能”在两百万个网页中出现,即|{𝑗:𝑡_𝑖 "∈" 𝑑_𝑗}| =200万,则它的权重

    ​ idf=log(500) =6.2

    假定通用词“应用”,出现在五亿个网页中,它的权重

    ​ idf = log(2)= 0.7。

    最终获得某一网页的TF-IDF计算如下

    0.002(tf)6.2(idf)+ 0.035(tf)0(idf)+0.005(tf)*0.7(idf)

    3.实现代码

    布尔模型

    def regularization(s):

    ss = s.split(' ')

    expression = []

    target = {}

    for i in ss:

    if i != "and" and i != "or" and i != "not" and i != "(" and i != ")":

    if i[0] == "(":

    expression.append("(")

    expression.append(i[1:])

    target[i[1:]] = 0

    elif i[-1] == ")":

    expression.append(i[:-1])

    expression.append(")")

    target[i[:-1]] = 0

    else:

    expression.append(i)

    target[i] = 0

    else:

    expression.append(i)

    return target, expression

    def analysis(line):

    output = []

    # 去除每行的换行符

    t_line = line.strip('\n')

    # 按空格分开每个词

    words = t_line.split(' ')

    for word in words[1:]:

    if word == "":

    continue

    # 按/分开标记和词

    t_word = word.split('/')

    # 左方括号去除

    tf_word = t_word[0].split('[')

    if len(tf_word) == 2:

    f_word = tf_word[1]

    else:

    f_word = t_word[0]

    # 若不在列表中

    if f_word not in output:

    output.append(f_word)

    big_word1 = t_line.split('[')

    for i in range(1, len(big_word1)):

    big_word2 = big_word1[i].split(']')[0]

    words = big_word2.split(' ')

    big_word = ""

    for word in words:

    # 按/分开标记和词

    t_word = word.split('/')

    big_word = big_word + t_word[0]

    # 若不在列表中

    if big_word not in output:

    output.append(big_word)

    return output

    def getValue(target, reg):

    # 逆波兰

    RPN = []

    stack = []

    stack.append("#")

    for i in reg:

    if i in target.keys():

    RPN.append(target[i])

    elif i == "(":

    stack.append(i)

    elif i == ")":

    while stack[-1] != "(":

    RPN.append(stack.pop())

    stack.pop()

    elif i == "not":

    while stack[-1] == "not":

    RPN.append(stack.pop())

    stack.append(i)

    elif i == "and":

    while stack[-1] == "not" or stack[-1] == "and":

    RPN.append(stack.pop())

    stack.append(i)

    else:

    while stack[-1] == "not" or stack[-1] == "and" or stack[-1] == "or":

    RPN.append(stack.pop())

    stack.append(i)

    while len(stack) != 1:

    RPN.append(stack.pop())

    # 计算逆波兰式

    ans = []

    for i in RPN:

    if i == 0 or i == 1:

    ans.append(i)

    elif i == "not":

    ans.append(1 ^ ans.pop())

    elif i == "and":

    op1 = ans.pop()

    op2 = ans.pop()

    ans.append(op1 and op2)

    elif i == "or":

    op1 = ans.pop()

    op2 = ans.pop()

    ans.append(op1 or op2)

    return ans[0]

    if __name__ == '__main__':

    booltext = input("输入布尔表达式:")

    target, reg = regularization(booltext)

    key_target = target.keys()

    num = 0

    with open('语料库.txt', mode='r', encoding='UTF-8') as f:

    for line in f.readlines():

    if num >=10:

    break

    for i in key_target:

    target[i] = 0

    if line is not None and line != "\n":

    output = analysis(line)

    for i in key_target:

    if i in output:

    target[i] = 1

    if getValue(target, reg):

    print(line)

    num = num + 1

    f.close()

    TF-IDF模型

    getWeight.py(提前计算权重)

    import sys

    output = {}

    with open('语料库.txt', mode='r', encoding='UTF-8') as f:

    for line in f.readlines():

    if line is not None and line != "\n":

    t_line = line.strip('\n')

    words = t_line.split(' ')

    word_w = []

    for word in words[1:]:

    if word == "":

    continue

    t_word = word.split('/')

    # 左方括号

    tf_word = t_word[0].split('[')

    if len(tf_word) == 2:

    f_word = tf_word[1]

    else:

    f_word = t_word[0]

    if f_word not in word_w:

    word_w.append(f_word)

    for f_word in word_w:

    if f_word in output.keys():

    output[f_word] = output[f_word]+1

    else:

    output[f_word] = 1

    f.close()

    with open('outputWeight.txt', mode='w', encoding='UTF-8') as f:

    while output:

    minNum = sys.maxsize

    minName = ""

    for key, values in output.items():

    if values < minNum:

    minNum = values

    minName = key

    f.write(minName+": "+str(minNum)+"\n")

    del output[minName]

    f.close()

    TF-IDF.py

    import math

    def analysis(line):

    output = []

    # 去除每行的换行符

    t_line = line.strip('\n')

    # 按空格分开每个词

    words = t_line.split(' ')

    for word in words[1:]:

    if word == "":

    continue

    # 按/分开标记和词

    t_word = word.split('/')

    # 左方括号去除

    tf_word = t_word[0].split('[')

    if len(tf_word) == 2:

    f_word = tf_word[1]

    else:

    f_word = t_word[0]

    # 若不在列表中

    if f_word not in output:

    output.append(f_word)

    big_word1 = t_line.split('[')

    for i in range(1, len(big_word1)):

    big_word2 = big_word1[i].split(']')[0]

    words = big_word2.split(' ')

    big_word = ""

    for word in words:

    # 按/分开标记和词

    t_word = word.split('/')

    big_word = big_word + t_word[0]

    # 若不在列表中

    if big_word not in output:

    output.append(big_word)

    return output

    def getValue(target, reg):

    # 逆波兰

    RPN = []

    stack = []

    stack.append("#")

    for i in reg:

    if i in target.keys():

    RPN.append(target[i])

    elif i == "(":

    stack.append(i)

    elif i == ")":

    while stack[-1] != "(":

    RPN.append(stack.pop())

    stack.pop()

    elif i == "not":

    while stack[-1] == "not":

    RPN.append(stack.pop())

    stack.append(i)

    elif i == "and":

    while stack[-1] == "not" or stack[-1] == "and":

    RPN.append(stack.pop())

    stack.append(i)

    else:

    while stack[-1] == "not" or stack[-1] == "and" or stack[-1] == "or":

    RPN.append(stack.pop())

    stack.append(i)

    while len(stack) != 1:

    RPN.append(stack.pop())

    # 计算逆波兰式

    ans = []

    for i in RPN:

    if i == 0 or i == 1:

    ans.append(i)

    elif i == "not":

    ans.append(1 ^ ans.pop())

    elif i == "and":

    op1 = ans.pop()

    op2 = ans.pop()

    ans.append(op1 and op2)

    elif i == "or":

    op1 = ans.pop()

    op2 = ans.pop()

    ans.append(op1 or op2)

    return ans[0]

    def getW():

    word_list = {}

    with open('outputWeight.txt', mode='r', encoding='UTF-8')as f:

    for line in f.readlines():

    if line is not None:

    word = line.split(':')

    word_list[word[0]]=word[1]

    f.close()

    return word_list

    def BMM(origin_sentence):

    MAX_WORD = 19

    word_list = []

    with open('output.txt', mode='r', encoding='UTF-8')as f:

    for line in f.readlines():

    if line is not None:

    word = line.split(':')

    word_list.append(word[0])

    f.close()

    ans_word = []

    while len(origin_sentence) != 0:

    len_word = MAX_WORD

    while len_word > 0:

    # 从后读取最大词长度的数据,若该数据在字典中,则存入数组,并将其去除

    if origin_sentence[-len_word:] in word_list:

    ans_word.append(origin_sentence[-len_word:])

    len_sentence = len(origin_sentence)

    origin_sentence = origin_sentence[0:len_sentence - len_word]

    break

    # 不在词典中,则从后取词长度-1

    else:

    len_word = len_word - 1

    # 单词直接存入数组

    if len_word == 0:

    if origin_sentence[-1:] != ' ':

    ans_word.append(origin_sentence[-1:])

    len_sentence = len(origin_sentence)

    origin_sentence = origin_sentence[0:len_sentence - 1]

    return ans_word

    if __name__ == '__main__':

    w = getW()

    sentence = input("输入短语:")

    words = BMM(sentence)

    ans = []

    # 计算总文档数(一行一文档)

    count = 0

    for index, line in enumerate(open('语料库.txt', 'r', encoding='UTF-8')):

    count += 1

    with open('语料库.txt', mode='r', encoding='UTF-8') as f:

    for line in f.readlines():

    score = 0

    if line is not None and line != "\n":

    out = analysis(line)

    for word in words:

    # TF-IDF计算

    score = score + out.count(word) / len(out) * math.log(count*1.0/int(w[word]))

    ans.append((line, score))

    f.close()

    new_ans = sorted(ans, key=lambda a: a[1], reverse=True)

    for i in range(10):

    print(new_ans[i])

    4.实现效果

    c2b5c4154767b0d40f50cad2f8f5fcab.png

    929559dc68bb132d6304333acfb83bc3.png

    44b22e33badad715f32a0578eab37556.png

    展开全文
  • 造血干细胞网络的布尔模型 推介会 该项目基于以下提到的文章: Bonzanni N、Garg A、Feenstra KA、Schütte J、Kinston S、Miranda-Saavedra D、Heringa J、Xenarios I 和 Göttgens B Bioinformatics,2014 郑德...
  • 布尔模型(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θ = V e c t o r Q ⋅ V e c t o r D ∣ V e c t o r Q ∣ ∣ V e c t o r D ∣ \frac{VectorQ·VectorD}{|VectorQ||VectorD|} VectorQVectorDVectorQVectorD = q 1 d 1 + q 2 d 2 + . . . + q n d n q 1 2 + q 2 2 + . . . + q n 2 ∗ d 1 2 + d 2 2 + . . . + d n 2 \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}} q12+q22+...+qn2 d12+d22+...+dn2 q1d1+q2d2+...+qndn

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

    VSM缺点

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

    展开全文
  • 提出一种基于布尔模型的网页查重算法,利用布尔模型寻找适当的特征,建立索引以减少网页文档之间的比较次数。实验验证了这种算法的性能,并取得了较好的效果。
  • 布尔模型3. 倒排索引 1. 一些基础概念 两个检索有效性参数: IDF逆向文件频率 (Inverse Document Frequency) for term Tj dfjdf_jdfj​ (document frequency of term Tj) is number of documents in which Tj ...
  • 在学习布尔模型之前首先让我们了解一下模型的基本概念为后面的学习奠定基础。模型是采用数学工具对现实世界某种事物或某种运动的抽象描述,面对相同的输入,模型输出应能够无限地逼近现实世界的输出(如:天气预报模型...
  • 布尔模型、DSNP 模型、DSNP+ 模型)七参数转换,空间直角坐标的转换模型有很多,这里只讨论三种:布尔模型、DSNP 模型、DSNP+ 模型
  • 基于MATLAB的布尔模型七参数解算实现.pdf
  • 布尔文献检索模型简介

    千次阅读 2019-08-01 16:36:25
    在没有网络的时候,手头能访问的信息量太少是个问题。现在有了网络,怎么在海量的数据中找到自己需要的信息是另一...布尔逻辑将是建立最早的模型,也是目前应用最广泛的检索技术。它是通过布尔逻辑运算符:逻辑与(A...
  • 模型是一个过程或者对象的抽象,用于研究属性、得出结论、做出预测。结论的质量依赖于模型表示现实的相近程度 结论的质量依赖于模型表示现实的相近程度,如机器人 2.什么是检索模型 IR的核心问题:预测哪些...
  • 如果用以下布尔模型, 会加快检索速度. 取横向量, 再进行bitwise运算。 Brutus AND Caesar AND NOT Calpurnia 110100 AND 110111 AND 101111 = 100100 这样可以极快的得到结果, 第一部和第四部作品满足条件。 ...
  • 布尔检索模型

    万次阅读 2017-10-08 20:53:01
    布尔检索模型接受布尔表达式查询,用户可以通过使用AND,OR以及NOT等逻辑操作符来构建查询表达式。假如用户提交查询“cat AND NOT apple”(表示寻找带有cat但不含有apple的文档),我们从表2分别取出cat和apple对应...
  • 这是Asset Store下载的CSG 编辑器扩充/建模工具,里面含有实例和说明文档,亲测非常好用,内含中文说明文档。
  • 利用观察到的数据集,提出了几种构建这种布尔网络动态模型的方法。 不是直接构建布尔网络的逻辑动力学,而是先构建其代数形式,然后再转换回逻辑形式。 首先,提出了一种通用的施工技术。 为了减少所需数据的大小,...
  • ①是否采用布尔搜索 ②输入查询文档或布尔表达式 4.2输出: 5、讨论和分析 ①向量空间算法是根据关键词进行判断的,对于本实验中的一词多义问题难以处理(gold既指金色也指黄金) ②构建的布尔搜索模型较为原始,仅...
  • 模型布尔算法

    2017-10-21 16:45:24
    BooleanRT 模型布尔算法插件,模型扣洞,模型相交,等等
  • 生成dll的主要代码部分,需提前配置cgal和相关boost库,本人用于在ue4中使用
  • 布尔查询的对象中,包含一个子句的集合,各个子句间都是如“与”、“或”这样的布尔逻辑。Lucene中所遇到的各种复杂查询,最终都可以表示成布尔型的查询。下面代码就是实现了一个简单的布尔查询。 package Lucene...
  • 无线传感器网络监视预警系统的区域边界具有特殊重要性,针对节点的布尔感知模型,根据节点感知圆盘的相互关系,可将整条边界线划分为不可再分割的可数个最小曲线段,利用改进的贪婪式算法研究了集中式多重覆盖算法和...
  • C#实现布尔模型中7个参数的求解

    热门讨论 2014-12-01 16:18:57
    利用C#实现了布尔模型中7个参数的求解,最小二乘法,程序中包含了矩阵转置、矩阵求乘积、矩阵求逆三个类,本人亲测。
  • 示例图如下: 布尔检索模型(bool retrieval model):布尔检索是根据关键词检索包含该词的所有文档。并且支持多个关键词之间的“AND”,“OR”,"NOT"操作。 根据上面的词项-文档关联矩阵,我们可以很容易的做到这...
  • 以某市控制测量项目的 GPS点成果数据为例,基于布尔模型大地高误差对坐标转换精度的影响进行以常见的3种高程系统(以1985国家高程代替大地高;利用高程异常估算大地高;将大地高置0)进行坐标转换试验,认为“原坐标系...
  • 网络信息检索(二)扩展检索模型

    千次阅读 2020-03-11 16:32:33
    文章结构总览布尔模型扩展(1)模糊集合模型① 查询词扩展(2)扩展布尔模型3.向量空间模型扩展(1)广义向量空间模型(2)潜语义索引模型(3)词向量4.概率模型的扩展(1)语言模型 总览 布尔模型扩展 需要改进...
  • 布尔检索一个简单的布尔检索搜索引擎,它在数据集中搜索给定的查询并返回相关的文档名称。 还实现了布尔运算AND,OR和NOT。 例如,您可以按照以下给出的格式指定查询: 笔记型电脑笔记本电脑和戴尔笔记本电脑或手机...
  • 通过时间序列数据学习受限布尔网络模型
  • Unity 模型布尔运算插件,模型切割工具,自动分割补全材质,已翻译为中文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,284
精华内容 37,313
关键字:

布尔模型