Experiment3: IR Evaluation

最新推荐文章于 2024-09-28 22:49:03 发布
最新推荐文章于 2024-09-28 22:49:03 发布
阅读量1.6k 收藏 4
点赞数 2
分类专栏： 信息检索与数据挖掘 文章标签： 数据挖掘 数据分析 信息检索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hzh130727/article/details/121652920
版权

实验内容

实现以下指标评价，并对Experiment2的检索结果进行评价
  • Mean Average Precision (MAP)
  • Mean Reciprocal Rank (MRR)
  • Normalized Discounted Cumulative Gain (NDCG)

实验目的

  • 理解MAP（平均精度均值）、MRR（平均倒数排名）、NDCG（归一化折损累积增益）算法，并且在已有数据上编程实现

实验环境

Windows11、python3.9、Anaconda3

实验基本原理相关算法详解

1.MAP(平均精度值均值)

  • 了解MAP之前我们先了解一下precision和recall，这两个标准的定义是这样的

    • Precision: 即精确率,检索最相关的顶级文档的能力.
    • Recall: 即召回率， 检索到语料库中所有相关项的能力

  • 也就是说，精确率=检索到的相关文档数量/检索的文档总量， 召回率=检索到的相关文档数量/总的相关文档数量，如图所示

在这里插入图片描述

  • 上图比较直观，圆圈内（Relevant documents + Retrieved documents）是我们选出的元素,它对应于分类任务中我们取出的结果

在这里插入图片描述

  • 而实验中的MAP如何计算呢？其实就是AP(可以理解为precision)的总和平均值，计算方法如下

    在这里插入图片描述

  • 在实现代码中，对于每一条query,我先得到了相关文档出现的Rank，然后计算AP，最后累加求平均计算MAP,实现代码如下：

    # 平均精度均值
def MAP_eval(data_dict):
    MAP = 0
    for query_result in data_dict:
        data = data_dict[query_result]              # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        AP = 0                                      # 初始化每一条query的AP为0
        Rank = []                                   # Rank记录每一条query中相关文档出现的位置，方便用来计算AP
        for result in data:                         # [doc_id,rel]
            rel = result[1]
            if(rel > 0):
                index = data.index(result) + 1      # 记录该doc是第几个出现的
                Rank.append(index)
        # print(Rank)
        num_related_doc = len(Rank)                 # 总的相关文档数
        i = 1
        for index in Rank:
            precision = i / index                   # 计算精度
            # print("precision= ",precision)
            AP += precision
            i += 1
        AP /= num_related_doc                       # 计算AP
        # print(AP)
        MAP += AP                   
    MAP = MAP / len(data_dict)                      # 计算所有query的AP,得到MAP
    return MAP

2.Mean Reciprocal Rank (MRR)：平均倒数排名

  • MRR的计算方法很简单，对于每一个query返回的所有文档中，找出第一个真正相关的文档位置，第一个真正相关的文档越靠前，结果越好。具体来说：对于一个query，若第一个真正相关的文档排在第n位，则MRR得分就是 1/n 。（如果没有正确答案，则得分为0）

  • Q为样本query集合，|Q|表示Q中query个数，Rank(i)表示在第i个query中，第一个正确答案的排名

  • MRR计算例子

  • 假设现在有4个query语句,q1,q2,q3,q4

  • q1的正确结果在第4位，q2和q3没有正确结果（即未检索到文档），q4正确结果在第5位,那么得分就是1/4+0+0+1/5=0.45,最后MRR就是求平均，即该系统MRR=0.45/4=0.1125,实现代码如下：

    # 平均倒数排名,对比MAP，当返回的相关结果较少时，使用它更加合适
def MRR_eval(data_dict):
    MRR = 0                                                       
    for query_id in data_dict:                      # query_id
        data = data_dict[query_id]                  # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        RR = 0                                      # 初始化每一条query的RR为0                     
        for result in data:                         # [doc_id,rel]
            rel = result[1]
            if(rel > 0):
                index = data.index(result) + 1      # 记录该doc是第几个出现的相关文档
                RR = 1 / index                      # 计算RR
                MRR += RR
                break
                  
    MRR = MRR / len(data_dict)                      # 计算所有query的RR,得到MRR
    return MRR

3.NDCG(归一化折损累积增益)

  • NDCG(Normalized Discounted cumulative gain)归一化折损累计增益，这个指标通常是用来衡量和评价搜索结果算法,其主要思想就是高关联度的结果比一般关联度的结果更影响最终的指标得分，有高关联度的结果出现在更靠前的位置的时候，指标会越高，那么具体如何计算呢？

  • 首先计算累计增益**(CG)**，它是当前文档之前所有文档的相关性得分之和，计算公式如下

    在这里插入图片描述

  • 优化累加式指标**(DCG)**，当我们计算出CG之后发现，排名越往后的文档的CG越高，而用户更关心高排名的文档，所以我们
    折扣结果。在这里，我们将越往后的文档的权重设置的越小,代表更低的关注度，公式如下

    在这里插入图片描述

  • 然后我们发现针对不同的query,返回的文档集合是不一样的，不能简单地用DCG,为了比较DCG，对其值进行规范化，从而得到一个理想的rank的归一化DCG为1.0,称为IDCG,将返回的文档按照相关性从大到小排序,计算IDCG,实现公式如下

    在这里插入图片描述

  • 最后我们将DCG和IDCG综合起来得到归一化的DCG理想的排名NDCG,NDCG具有可比性不同的查询，衡量返回的结果和理想结果之间的差距，当得分越接近1时，代表返回的结果越接近理想情况，模型越好，实现公式如下

    在这里插入图片描述

  • 实现代码如下：

    # 归一化折损累积增益,
def NDCG_eval(data_dict):
    NDCG = 0
    for query_id in data_dict:
        data = data_dict[query_id]                                      # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        CG = 0                                                          # 初始化每一条query的CG为0
        DCG = 0                                                         # 初始化每一条query的CG为0
        IDCG = 0                                                        # 初始化每一条query的IDCG为0
        # 计算DCG
        i = 1
        for result in data:                                             # [doc_id,rel]
            rel = result[1]
            CG +=  rel                                                  # CGn = sum(rel(i))
            if i == 1:
                DCG = rel                                               # DCGn = rel1 + sum(2-n)rel(i) / log2(i)
            else:
                DCG += (rel / math.log2(i))
            i += 1

        # 计算IDCG
        sorted_data = sorted(data, key = lambda x:x[1],reverse = True)  # 按照文档评分rel排序
        i = 1
        for result in sorted_data:                                      # [doc_id,rel]
            rel = result[1]
            # IDCG += ((2 ** rel - 1) / math.log2(i + 1))
            if i == 1:
                IDCG = rel                                              # IDCGn = rel1 + sum(2-n)rel(i) / log2(i)
            else:
                IDCG += (rel / math.log2(i))
            i += 1

        NDCG += DCG / IDCG
        
    NDCG = NDCG / len(data_dict)                                        # 计算NDCG
    return NDCG

实验预处理

  • 首先对得到的数据进行预处理，我们得到的数据是与实验2相关的，也就是把实验2的每一条query对应的document的真正相关性得到，处理后得到如图所示的文件，分别代表查询id，对应文档id以及相关性

    在这里插入图片描述

  • 下面我们对数据进行处理，这里建立数据字典，键值为query_id，值为列表，存储返回的已排好序的文档id及评分，如图所示

    在这里插入图片描述

  • 实现代码如下

    def generate_tweetid_gain(file_path):
    data_dict = {}
    with open(file_path, 'r', errors='ignore') as f:
        for line in f:
            result = line.strip().split(' ')    # 171 Q0 305345146675949568 0
            query_id = result[0]                # 查询id
            docu_id = result[2]                 # 文档id
            rel = int(result[3])                # 文档相关性
            if query_id not in data_dict:       # 为每个query建立列表，记录query查询回来的排序后的文档以及相关性
                data_dict[query_id] = []
            if rel > 0:                         # 记录文档id和相关性
                data_dict[query_id].append([docu_id,rel])
            else:
                data_dict[query_id].append([docu_id,0])
    return data_dict

    实验结果

    在这里插入图片描述

    实验代码
    import pandas as pd
import math
import numpy as np

def generate_tweetid_gain(file_path):
    data_dict = {}
    with open(file_path, 'r', errors='ignore') as f:
        for line in f:
            result = line.strip().split(' ')    # 171 Q0 305345146675949568 0
            query_id = result[0]                # 查询id
            docu_id = result[2]                 # 文档id
            rel = int(result[3])                # 文档相关性
            if query_id not in data_dict:       # 为每个query建立列表，记录query查询回来的排序后的文档以及相关性
                data_dict[query_id] = []
            if rel > 0:                         # 记录文档id和相关性
                data_dict[query_id].append([docu_id,rel])
            else:
                data_dict[query_id].append([docu_id,0])
    return data_dict

# 平均精度均值
def MAP_eval(data_dict):
    MAP = 0
    for query_result in data_dict:
        data = data_dict[query_result]              # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        AP = 0                                      # 初始化每一条query的AP为0
        Rank = []                                   # Rank记录每一条query中相关文档出现的位置，方便用来计算AP
        for result in data:                         # [doc_id,rel]
            rel = result[1]
            if(rel > 0):
                index = data.index(result) + 1      # 记录该doc是第几个出现的
                Rank.append(index)
        # print(Rank)
        num_related_doc = len(Rank)                 # 总的相关文档数
        i = 1
        for index in Rank:
            precision = i / index                   # 计算精度
            # print("precision= ",precision)
            AP += precision
            i += 1
        AP /= num_related_doc                       # 计算AP
        # print(AP)
        MAP += AP                   
    MAP = MAP / len(data_dict)                      # 计算所有query的AP,得到MAP
    return MAP

# 平均倒数排名,对比MAP，当返回的相关结果较少时，使用它更加合适
def MRR_eval(data_dict):
    MRR = 0                                                       
    for query_id in data_dict:                      # query_id
        data = data_dict[query_id]                  # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        RR = 0                                      # 初始化每一条query的RR为0                     
        for result in data:                         # [doc_id,rel]
            rel = result[1]
            if(rel > 0):
                index = data.index(result) + 1      # 记录该doc是第几个出现的相关文档
                RR = 1 / index                      # 计算RR
                MRR += RR
                break
                  
    MRR = MRR / len(data_dict)                      # 计算所有query的RR,得到MRR
    return MRR

# 归一化折损累积增益,
def NDCG_eval(data_dict):
    NDCG = 0
    for query_id in data_dict:
        data = data_dict[query_id]                                      # 一条查询对应的所有文档及其相关性 query_id[[doc_id,rel]，[doc_id,rel],.....]
        CG = 0                                                          # 初始化每一条query的CG为0
        DCG = 0                                                         # 初始化每一条query的CG为0
        IDCG = 0                                                        # 初始化每一条query的IDCG为0
        # 计算DCG
        i = 1
        for result in data:                                             # [doc_id,rel]
            rel = result[1]
            CG +=  rel                                                  # CGn = sum(rel(i))
            if i == 1:
                DCG = rel                                               # DCGn = rel1 + sum(2-n)rel(i) / log2(i)
            else:
                DCG += (rel / math.log2(i))
            i += 1

        # 计算IDCG
        sorted_data = sorted(data, key = lambda x:x[1],reverse = True)  # 按照文档评分rel排序
        i = 1
        for result in sorted_data:                                      # [doc_id,rel]
            rel = result[1]
            # IDCG += ((2 ** rel - 1) / math.log2(i + 1))
            if i == 1:
                IDCG = rel                                              # IDCGn = rel1 + sum(2-n)rel(i) / log2(i)
            else:
                IDCG += (rel / math.log2(i))
            i += 1

        NDCG += DCG / IDCG
        
    NDCG = NDCG / len(data_dict)                                        # 计算NDCG
    return NDCG

def evaluation():
    # query relevance file
    file_path = './qrels.txt'
    data_dict = generate_tweetid_gain(file_path)
    MAP = MAP_eval(data_dict)
    print('MAP', ' = ', round(MAP, 5), sep='')
    MRR = MRR_eval(data_dict)
    print('MRR', ' = ', round(MRR, 5), sep='')
    NDCG = NDCG_eval(data_dict)
    print('NDCG', ' = ', round(NDCG, 5), sep='')
    
if __name__ == '__main__':
    evaluation()

实验数据及源码

https://github.com/NuanBaobao/Information-Retrieval/tree/main/Exp3

泷叶er
关注
专栏目录
【图像拼接】论文精读：STREAMLINING THE IMAGE STITCHING PIPELINE: INTEGRATINGFUSION AND RECTANGLING INTO A UNIFI
畅游计算机视觉的海洋
04-30 992
基于学习的图像拼接技术通常涉及三个不同的阶段：配准、融合和矩形。这些阶段通常是按顺序执行的，每个阶段都是独立训练的，导致潜在的级联错误传播和复杂的参数调整挑战。在重新思考融合和矩形阶段的数学建模时，我们发现这些过程可以有效地组合成一个单一的、各种强度的修复问题。因此，我们提出了一种有效的无训练图像拼接方法Simple和Robust Stitcher (SRStitcher)，将融合阶段和矩形阶段合并为一个统一的模型。通过使用加权掩码和大规模生成模型，SRStitcher 可以在单个推理中解决融合和矩形问题，
信息检索实验3-IR Evaluation
ニャンコちゃん的博客
01-15 3759
目录实验数据实验要求 实验数据 lab3实验数据：lab3实验数据 实验要求 实验内容： 实现以下指标评价，并对Experiment2的检索结果进行评价 • Mean Average Precision (MAP) • Mean Reciprocal Rank (MRR) • Normalized Discounted Cumulative Gain (NDCG) 实验目的： 理解MAP（平均精度均值）、MRR（平均倒数排名）、NDCG（归一化折损累积增益）算法，并且在已有数据上编程实现 ...
论文阅读：Enhanced 3D Urban Scene Reconstruction and Point Cloud Densification using Gaussian Splatting
fishfuck的博客
07-20 970
尽管基于大规模遥感图像的3D城市场景重建和建模对于数字孪生和智能城市等许多关键应用至关重要，但由于异构数据集和几何模型的不确定性，这是一个困难的任务。本文提出了一种基于高斯溅射的方法，用于3D城市场景建模和几何检索，贡献如下。首先，我们开发并实现了一种大规模3D城市场景建模的3D高斯溅射（3DGS）方法。其次，我们在提出的3DGS模型中设计了点云密集化方法，以提高城市场景3D几何提取的质量。
ACL 2018 Highlights： Understanding Representations and Evaluation in More Challenging Settings
SunJackson的博客
07-27 610
You are using an outdated browser. Please upgrade your browser to improve your experience. I attended the 56th Annual Meeting of the Association for Computational Linguistics (ACL 2018) According to...
LLMs：《BLOOM: A 176B-Parameter Open-Access Multilingual Language Model》翻译与解读
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
12-31 4608
​ LLMs：《BLOOM: A 176B-Parameter Open-Access Multilingual Language Model》翻译与解读 目录 《BLOOM: A 176B-Parameter Open-Access Multilingual Language Model》翻译与解读 Abstract 1、Introduction介绍 2、Background背景 3、BLOOM
IR领域资料
yfw418的专栏
04-21 2461
信息检索领域相关资料
So you want to study IR?
Blog of Tom Chao Zhou
10-04 1015
<br />Original post:<br />http://windowoffice.tumblr.com/post/898277337/so-you-want-to-study-ir<br /> <br /> <br /><br />I occasionally get questions from aspiring IR students asking for advice on getting started as an IR researcher.*  Here’s an attempt at
IR资料
Jagua的专栏
09-18 3041
        Books                 + Finding Out About: Search Engine Technology from a cognitive                         Perspective (Belew, R.K., 2000)                         http://www-cse.ucsd.edu/~r
USENIX Security 23 论文解读 # VulChecker: Graph-based Vulnerability Localization in Source Code
skysys的研究小屋
07-09 1305
基于AI实现的SAST实现漏洞检测、分类和精确定位
TorchDynamo初探：Python ByteCode的动态修改
OneFlow深度学习框架
12-29 5013
深度学习框架编译优化时，需要先根据计算逻辑形成一个逻辑计算图，然后再改写计算图，最后执行改写后的计算图。其中生成逻辑计算图方式有两种。一种计算图生成是基于 trace tensor 的，跟踪 tensor 的执行路径。tensor 执行时，基于函数重载，可以落到支持 tensor 计算的框架自定义函数，该函数一般是 c++ 层的。c++ 层的自定义函数中，功能是用于生成一个...
全文翻译（全文合集）：TVM: An Automated End-to-End Optimizing Compiler for Deep Learning
吴建明wujianming_110117
10-29 750
全文翻译（全文合集）：TVM: An Automated End-to-End Optimizing Compiler for Deep Learning 摘要 人们越来越需要将机器学习应用到各种各样的硬件设备中。现在的框架依赖于特定于供应商的算子库，针对窄带的服务器级GPU进行优化。将工作负荷部署到新平台，如移动电话，嵌入式设备和加速算子（如FPGA，ASIC）-需要大量手动操作。 提出了TVM，一个开源图形级别的编译器和算子级优化，提供高效跨多个应用程序移植到深度学习工作负荷硬件后端。TVM解决了深度学
Best Practices for Model Deployment: 5 Steps to Ensure Your Model Runs Steadily
# Model Deployment Best Practices: 5 Steps to Ensure Stable Model Operation ## Overview Model deployment is the essential process of transforming machine learning models into actual applications....
【数据挖掘】2023年 Quiz 1-3 整理 带答案
最新发布
叼辣条闯天涯
09-28 118
B, and C. Les SH∣6S​h1/4−δD​h​≤errS​h2∣S∣ln1/δln∣H∣​​≤1/416ln1/δln6​​​0.01D​h≤1/416ln1/0.01ln6​000. We use A. Define BCDand Esimilarly.⋅A0, update wto wA000202⋅A0, update w。
基于大数据的亚健康人群数据分析及可视化系统
计算机学姐的博客
09-27 1051
【2025最新】基于大数据+大屏可视化+SpringBoot+Vue+MySQL的亚健康人群数据分析及可视化系统。
最新全流程GPT+Python近红外光谱数据分析
weixin_48230888的博客
09-25 1292
第一章、ChatGPT4入门基础1、ChatGPT概述（GPT-1、GPT-2、GPT-3、GPT-3.5、GPT-4模型的演变）2、ChatGPT对话初体验（注册与充值、购买方法）3、GPT-4与GPT-3.5的区别，以及与国内大语言模型（文心一言、星火等）的区别4、ChatGPT科研必备插件（Data Interpreter、Wolfram、WebPilot、MixerBox Scholar、ScholarAI、Show Me、AskYourPDF等）
Python知识点：如何使用Python进行基因组数据分析
码农超哥的博客
09-23 1233
在本文中，我们将探讨使用Python进行基因组数据分析的流程，包括数据质控、变异检测、注释和可视化。然而，重要的是要理解每个步骤的生物学意义和计算原理，以便正确解释结果。基因组数据分析通常从原始测序数据开始，这些数据需要经过一系列的处理步骤才能转化为有用的生物学信息。我们的目标是确保数据的质量，识别基因组中的变异，并理解这些变异的生物学意义。一旦我们有了干净的数据，下一步是识别基因组中的变异，如SNPs和INDELs。最后，为了更好地理解数据和交流结果，我们需要将基因组数据和变异结果可视化。
共享单车轨迹数据分析：以厦门市共享单车数据为例（七）
weixin_45812624的博客
09-25 1089
本文基于POI数据，使用K均值聚类算法对厦门市岛内地铁站站点进行了分类分析。研究使用IBM SPSS Statistics 27.0软件及SPSSPRO在线平台进行数据处理和聚类分析。通过手肘法则确定最佳聚类数量为3类。结果显示，类别1主要以企业办公为主导，生活服务设施丰富但公司企业POI数量较少，适合居住；类别2为混合功能性站点，POI功能分布均衡，适合多种需求；类别3为商业生活服务为主导型站点，生活服务和公司企业POI数量均较高，适合既有居住需求又有工作需求的人群。研究发现，先建成的站点周边业态更为成熟
Python 数据分析与可视化：从入门到实践
Fanstay985的博客
09-25 860
可以使用以下命令安装这些库：Bash深色版本。
print('the accuracy of ', EXPERIMENT_NUM, ' times experiment is :', accs)
05-11
其中，EXPERIMENT_NUM表示实验的次数，accs是一个包含每次实验的准确率的列表。 可以用以下代码实现： ``` print('the accuracy of', EXPERIMENT_NUM, 'times experiment is:', sum(accs)/len(accs)) ``` 这会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

泷叶er

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值