信息检索第四次实验--向量相似度的算法实现

        向量的相似度是指两个向量之间的相似程度，通常用余弦相似度来衡量。在机器学习和自然语言处理中，向量的相似度是非常重要的概念，因为它可以用来比较不同的文本、图像或其他类型的数据。

        在自然语言处理中，向量的相似度可以用来比较两个文本的相似程度；在图像处理中，向量的相似度可以用来比较两个图像之间的相似程度；在机器学习中，向量的相似度可以用来比较不同的数据点之间的相似程度。

实验内容：

        向量相似度是对向量空间模型评分的重要依据，编程实现向量相似度的基本算法实现，系统设计分为权重计算模块与结果展示模块两个功能模块。

代码实现：

import prettytable as pt
import numpy as np
from math import log
import warnings

warnings.filterwarnings("ignore")

# 词项频率计算
def tf(D, D1):  # 输入查询和文档包含的所有词项、查询信息
    l = len(D)
    tf = np.zeros(l)  # 初始化一个全0矩阵
    for i in range(l):
        tf[i] = D1.count(D[i])
    return tf  # 返回文档频率

# 对数词频计算
def wf(tf, flag):
    wf = tf.copy()
    l = len(tf)
    if flag == 'l':
        for i in range(l):
            wf[i] = 1 + round(log(tf[i], 10), 2) if tf[i] != 0 else 0
    elif flag == 'a':
        maxt = max(tf)
        for i in range(l):
            wf[i] = 0.5 + 0.5 * tf[i] / maxt
    elif flag == 'b':
        for i in range(l):
            wf[i] = 1 if tf[i] > 0 else 0
    return wf

# 逆文档频率计算
def idf(N, df, flag):
    l = len(df)
    idf = [1]*l
    if flag == 't':
       for i in range(l):
           idf[i] = round(log(N/df[i], 10), 1)
    return idf

# 词项权重计算
def Wtq(wf, idf, flag):
    Wtq = np.array(wf)*np.array(idf)
    sq = pow(sum(Wtq*Wtq), 0.5)
    if flag == 'c':
        for i in range(len(Wtq)):
            Wtq[i] = round(Wtq[i]/sq, 2)
    return Wtq

# 去除数字尾部无用的0
def rz(ls):
    l = len(ls)
    ls1 = []
    for i in range(l):
        a = ls[i]
        ls1.append([str(a), int(a)][int(a) == a])
    return ls1


if __name__ == '__main__':
    I = input('请输入查询信息(用空格分割)：')    # 查询信息
    D1 = input('请输入文档信息(用空格分割)：')   # 文档信息
    N = int(input('请输入文档总数目：'))        # 文档数目
    D = list(set((D1 + ' ' + I).split(' ')))  # 将文档信息和查询信息整合起来，形成一个词项列表
    l = len(D)    # 统计一共多少词项
    df = [0] * l  # 初始化一个列表存放每个词项的文档频率
    for i in range(l):
        df[i] = int(input('请输入' + D[i] + '的文档频率df：'))   # 手动输入包含每个词条的文档数量
    flags = input('请输入权重机制：nnc.ltn').split('.')

    # I = 'best car insurance'
    # D1, N = 'car insurance auto insurance, 1000000'.split(',')
    # N = int(N)
    # df = list(map(int, '1000, 10000, 5000, 50000'.split(',')))
    # D = list(set((D1 + ' ' + I).split(' ')))
    # flags = 'nnc.ltn'.split('.')

    flagd = [i for i in flags[0]]
    flagi = [i for i in flags[1]]

    # 标准化表格属性
    tb = pt.PrettyTable()
    itf = tf(D, I)
    iwf = wf(itf, flagi[0])
    iidf = idf(N, df, flagi[1])
    iWtq = Wtq(iwf, iidf, flagi[2])
    tb.add_column('word', D)
    tb.add_column('I tf', rz(itf))
    tb.add_column('I wf', rz(iwf))
    tb.add_column('I df', rz(df))
    tb.add_column('I idf', rz(iidf))
    tb.add_column('I Wtq', rz(iWtq))

    dtf = tf(D, D1)
    dwf = wf(dtf, flagd[0])
    didf = idf(N, df, flagd[1])     # 对数词频计算
    dWtq = Wtq(dwf, didf, flagd[2])
    tb.add_column('D tf', rz(dtf))
    tb.add_column('D wf', rz(dwf))
    tb.add_column('D Wtq', rz(dWtq))
    neiji = np.array(iWtq) * np.array(dWtq)
    tb.add_column('IP', rz(neiji))
    tb.align = 'l'
    print('\n+' + '-' * 25 + 'I表示查询, D表示文档, IP为内积' + '-' * 25 + '+')
    print(tb)
    score = sum(neiji)
    print('相似度为:' + str(score))

结果展示：