关系抽取RE任务中的metrics：Precision、Recall、F1-score

已于 2024-12-16 18:13:00 修改
阅读量1.1k 收藏 28
点赞数 17
分类专栏： LLM-IE-关系分类/抽取任务 文章标签： 机器学习 人工智能 关系抽取RE precision recall F1-score
于 2024-12-08 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45947938/article/details/144271288
版权

说在前面

        最近在研究关系抽取任务，接下来会对抽取结果进行数据分析，需要使用到这3个评估指标，在此记录他们的计算方法，有没有代码等问题。

        精确度 (Precision, P)、召回率 (Recall, R) 和 F1-score，这三个指标是用来衡量模型在关系抽取任务中的性能的。

        计算方法：使用工具包 sklearn.metrics 。

        关系抽取任务：LLM关系识别分类任务（关系多分类问题），输入 entity pair、relations。输出 best relation。

理解P/R/F1的公式

precision：预测为关系 instance of 的样本中，实际为关系 instance of 的的概率，看该类别混淆矩阵的列数据。分母是预测数据中为关系 instance of 的样本数据。

recall：真实关系为 instance of 的样本中，实际为关系 instance of 的概率，看该类别混淆矩阵的行数据。分母是 instance of 类别的所有样本数据。

理解TP/FP/FN定义

数据示例：1000个样本数据格式：{text, head, relation, tail}。

任务：关系多分类问题，

  • 输入：entity pair、relations。
  • 输出：让模型从relations里面预测概率最大的一个relation。(LLM认为entity pair间不存在关系如何处理呢？)

TP/FP/FN定义：

  1. TP 的定义：预测关系为A，真实关系也为A。(真实关系为A,预测关系也为A)
  2. FP 的定义：预测关系为A，真实关系为其他关系。
  3. FN 的定义：真实关系为A，预测关系为其他关系。

  • TP 是指模型预测为某一类，且真实标签也是该类（即正确预测）。
  • FP 是指模型预测为某一类，但真实标签不是该类（即错误预测）。
  • FN 是指真实标签为某一类，但模型没有预测为该类（即漏预测）。

理解混淆矩阵：

理解macro/micro/weighted

  • Micro（微平均）：

    • 定义： 在这种方法中，首先对所有类别的 True Positives (TP)、False Positives (FP) 和 False Negatives (FN) 进行汇总，然后使用这些总和来计算 precision、recall 和 F1 分数。
    • 适用场景： 适用于类别分布比较均衡，或者你更关心整体的性能，而不是各个类别的单独性能。它对类别不平衡较为鲁棒，因为每个样本的贡献是均等的。

  • Macro（宏平均）：

    • 定义： 在这种方法中，先计算每个类别的 precision、recall 和 F1 分数，然后对这些单独类别的分数取平均。对每一类都赋予了相同的权重。
    • 适用场景： 适用于各类别的性能比较重要的情况，尤其是在类别不平衡时。它不会受到大类别的主导影响，能反映小类别的性能。但如果某些类别的样本很少，可能导致 F1 分数不稳定。

  • Weighted（加权平均）：

    • 定义： 加权平均方法会根据每个类别在数据集中样本的比例，给每个类别的 precision、recall 和 F1 分数 赋予不同的权重。加权平均是根据类别出现的频率来调整每个类别的贡献。根据每一类的比例分别赋予不同的权重。
    • 适用场景： 适用于类别不平衡的任务，能够综合考虑每个类别的重要性，并对类别频率较高的类别给予更大的权重。

 sklearn.metrics计算分数代码demo

from sklearn.metrics import precision_score, recall_score, f1_score

# 示例数据
y_true = [0, 1, 2, 1, 0]  # 真实关系标签
y_pred = [0, 1, 4, 1, 0]  # 预测关系标签

# 计算精确率、召回率和F1分数
precision = precision_score(y_true, y_pred, average='macro')  # 或者使用 'micro', 'weighted'
recall = recall_score(y_true, y_pred, average='macro')        # 或者使用 'micro', 'weighted'
f1 = f1_score(y_true, y_pred, average='macro')                # 或者使用 'micro', 'weighted'

print(f"Precision: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1 Score: {f1:.4f}")

20241211代码最新探究

import json
from sklearn.metrics import classification_report, precision_score, recall_score, f1_score

# 确保类别对齐
labels = ['instance of', 'has part', 'taxon rank', 'parent taxon', 'part of', 'subclass of']

y_true = []  # 真实关系标签
y_pred = []  # 预测关系标签

path = './output/results_final.json'
with open(path, 'r', encoding='utf-8') as file:
    data = json.load(file)

for item in data:
    gold_relation = item['triple']['relation']
    pred_relation = item['output']['relation']
    y_true.append(gold_relation)
    y_pred.append(pred_relation)
print('y_true:',len(y_true) , y_true)
print('y_pred:',len(y_pred) , y_pred)


measure_result = classification_report(y_true, y_pred, labels=labels, zero_division=0)
print('measure_result = \n', measure_result)

print("----------------------------- precision（精确率）-----------------------------")
precision_score_average_None = precision_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
precision_score_average_micro = precision_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
precision_score_average_macro = precision_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
precision_score_average_weighted = precision_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('precision_score_average_None = ', precision_score_average_None)
print('precision_score_average_micro = ', precision_score_average_micro)
print('precision_score_average_macro = ', precision_score_average_macro)
print('precision_score_average_weighted = ', precision_score_average_weighted)

print("\n\n----------------------------- recall（召回率）-----------------------------")
recall_score_average_None = recall_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
recall_score_average_micro = recall_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
recall_score_average_macro = recall_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
recall_score_average_weighted = recall_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('recall_score_average_None = ', recall_score_average_None)
print('recall_score_average_micro = ', recall_score_average_micro)
print('recall_score_average_macro = ', recall_score_average_macro)
print('recall_score_average_weighted = ', recall_score_average_weighted)

print("\n\n----------------------------- F1-value-----------------------------")
f1_score_average_None = f1_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
f1_score_average_micro = f1_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
f1_score_average_macro = f1_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
f1_score_average_weighted = f1_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('f1_score_average_None = ', f1_score_average_None)
print('f1_score_average_micro = ', f1_score_average_micro)
print('f1_score_average_macro = ', f1_score_average_macro)
print('f1_score_average_weighted = ', f1_score_average_weighted)

20241216代码最新探究

import json
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_recall_fscore_support
from sklearn.metrics import classification_report, precision_score, recall_score, f1_score

# 确保类别对齐
labels = ['instance of', 'has part', 'taxon rank', 'parent taxon', 'part of', 'subclass of']

y_true = []  # 真实关系标签
y_pred = []  # 预测关系标签

path = './output/results_final.json'
with open(path, 'r', encoding='utf-8') as file:
    data = json.load(file)
for item in data:
    gold_relation = item['triple']['relation']
    pred_relation = item['output']['relation']
    y_true.append(gold_relation)
    y_pred.append(pred_relation)
print('y_true:',len(y_true) , y_true)
print('y_pred:',len(y_pred) , y_pred)

cm = confusion_matrix(y_true, y_pred, labels=labels)  # 显式指定标签顺序

# 创建混淆矩阵的可视化对象
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
# 生成混淆矩阵的图像, 可设置图形颜色
disp.plot(cmap=plt.cm.Blues)

# 旋转x轴标签，提高可读性
plt.xticks(rotation=45) # x轴旋转45°
plt.yticks(rotation=0)  # y轴水平
plt.tight_layout()  # 自动调整布局
plt.savefig('confusion_matrix.png')

# 通过 precision_recall_fscore_support 提取 TP/FP/FN
precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred, labels=labels)

# 初始化字典存储 TP、FP、FN
results = {label: {'TP': 0, 'FP': 0, 'FN': 0} for label in labels}

# 通过 precision, recall 和 support 反推出 TP、FP 和 FN
for i, label in enumerate(labels):
    TP = int(support[i] * recall[i])  # recall = TP / (TP + FN)
    FN = support[i] - TP             # FN = 支持数 - TP
    FP = int(TP / precision[i]) - TP if precision[i] > 0 else 0  # precision = TP / (TP + FP)

    results[label]['TP'] = TP
    results[label]['FP'] = FP
    results[label]['FN'] = FN

# 输出结果
for label in labels:
    print(f"类别: {label}")
    print(f"  TP: {results[label]['TP']}")
    print(f"  FP: {results[label]['FP']}")
    print(f"  FN: {results[label]['FN']}")


measure_result = classification_report(y_true, y_pred, labels=labels, zero_division=0)
print('measure_result = \n', measure_result)

print("----------------------------- precision（精确率）-----------------------------")
precision_score_average_None = precision_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
precision_score_average_micro = precision_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
precision_score_average_macro = precision_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
precision_score_average_weighted = precision_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('precision_score_average_None = ', precision_score_average_None)
print('precision_score_average_micro = ', precision_score_average_micro)
print('precision_score_average_macro = ', precision_score_average_macro)
print('precision_score_average_weighted = ', precision_score_average_weighted)

print("\n\n----------------------------- recall（召回率）-----------------------------")
recall_score_average_None = recall_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
recall_score_average_micro = recall_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
recall_score_average_macro = recall_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
recall_score_average_weighted = recall_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('recall_score_average_None = ', recall_score_average_None)
print('recall_score_average_micro = ', recall_score_average_micro)
print('recall_score_average_macro = ', recall_score_average_macro)
print('recall_score_average_weighted = ', recall_score_average_weighted)

print("\n\n----------------------------- F1-value-----------------------------")
f1_score_average_None = f1_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
f1_score_average_micro = f1_score(y_true, y_pred, labels=labels, average='micro', zero_division=0)
f1_score_average_macro = f1_score(y_true, y_pred, labels=labels, average='macro', zero_division=0)
f1_score_average_weighted = f1_score(y_true, y_pred, labels=labels, average='weighted', zero_division=0)
print('f1_score_average_None = ', f1_score_average_None)
print('f1_score_average_micro = ', f1_score_average_micro)
print('f1_score_average_macro = ', f1_score_average_macro)
print('f1_score_average_weighted = ', f1_score_average_weighted)

20241216-v2代码最新探究

  • TP：预测关系为A，真实关系也为A。
  • FP：预测为关系A，但真实关系为其他关系。
  • FN：真实关系为A，预测关系为其他关系（包含NULL）。

1计算Micro 微平均：

  • Precision = 关系识别正确数/总样本-NULL样本
  • Recall = 关系识别正确数/总样本。

2计算 Macro 宏平均：

计算每个类别的precision、recall、f1-score，汇总取平均值。

import json
import matplotlib
import numpy as np

matplotlib.use('Agg')
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_recall_fscore_support
from sklearn.metrics import classification_report, precision_score, recall_score, f1_score

# 确保类别对齐
labels = ['instance of', 'has part', 'taxon rank', 'parent taxon', 'part of', 'subclass of', 'NULL']

y_true = []  # 真实关系标签
y_pred = []  # 预测关系标签
NULL_SAMPLES = 0    # 预测关系中不存在关系的样本数
RELATIONS = 6 # 关系类型数量

path = './output/results_final.json'
with open(path, 'r', encoding='utf-8') as file:
    data = json.load(file)
for item in data:
    gold_relation = item['triple']['relation']
    pred_relation = item['output']['relation']
    if pred_relation == 'NULL':
        NULL_SAMPLES += 1
    y_true.append(gold_relation)
    y_pred.append(pred_relation)

cm = confusion_matrix(y_true, y_pred, labels=labels)  # 显式指定标签顺序
# 创建混淆矩阵的可视化对象
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
# 生成混淆矩阵的图像, 可设置图形颜色
disp.plot(cmap=plt.cm.Blues)
# 旋转x轴标签，提高可读性
plt.xticks(rotation=45) # x轴旋转45°
plt.yticks(rotation=0)  # y轴水平
plt.tight_layout()  # 自动调整布局
plt.savefig('confusion_matrix.png')


# 获取每个类别的precision/recall/f1/support
precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred, labels=labels, zero_division=0)
# 初始化字典存储 TP、FP、FN
results = {label: {'TP': 0, 'FP': 0, 'FN': 0} for label in labels}
# 通过 precision, recall 和 support 反推出 TP、FP 和 FN
for i, label in enumerate(labels):
    TP = int(support[i] * recall[i])  # recall = TP / (TP + FN)
    FN = support[i] - TP             # FN = 支持数 - TP
    FP = int(TP / precision[i]) - TP if precision[i] > 0 else 0  # precision = TP / (TP + FP)
    results[label]['TP'] = TP
    results[label]['FP'] = FP
    results[label]['FN'] = FN
    results[label]['support'] = support[i]

# 输出结果
ALL_TP = 0
ALL_SAMPLES = 0
for label in labels:
    ALL_TP += results[label]['TP']
    ALL_SAMPLES += results[label]['support']

micro_P = ALL_TP/(ALL_SAMPLES-NULL_SAMPLES) if ALL_SAMPLES-NULL_SAMPLES > 0 else 0
micro_R = ALL_TP/ALL_SAMPLES if ALL_SAMPLES > 0 else 0
micro_F1 = (2 * micro_P * micro_R) / (micro_P + micro_R) if (micro_P + micro_R) > 0 else 0

# 将结果保存到文本文件
with open('results.txt', 'w') as f:
    f.write("----------------------------- 方法1-手动计算 -----------------------------\n")
    f.write("----------------------------- micro（微平均）-----------------------------\n")
    f.write(f"micro_P: {micro_P * 100:.2f}%\n")
    f.write(f"micro_R: {micro_R * 100:.2f}%\n")
    f.write(f"micro_F1: {micro_F1 * 100:.2f}%\n\n")

    f.write(f"micro_P: {micro_P :.2f}\n")
    f.write(f"micro_R: {micro_R :.2f}\n")
    f.write(f"micro_F1: {micro_F1 :.2f}\n\n")

    precision_score_average_Single = precision_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    recall_score_average_Single = recall_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    f1_score_average_Single = f1_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    macro_P = np.sum(precision_score_average_Single) / RELATIONS
    macro_R = np.sum(recall_score_average_Single) / RELATIONS
    macro_F1 = np.sum(f1_score_average_Single) / RELATIONS

    f.write("----------------------------- macro（宏平均）-----------------------------\n")
    f.write(f"macro_P: {macro_P * 100:.2f}%\n")
    f.write(f"macro_R: {macro_R * 100:.2f}%\n")
    f.write(f"macro_F1: {macro_F1 * 100:.2f}%\n\n")

    f.write(f"macro_P: {macro_P :.2f}\n")
    f.write(f"macro_R: {macro_R :.2f}\n")
    f.write(f"macro_F1: {macro_F1 :.2f}\n\n")

    f.write("----------------------------- 方法2-自动计算（classification_report）-----------------------------\n")
    # 方法2
    measure_result = classification_report(y_true, y_pred, labels=[label for label in labels if label != 'NULL'], zero_division=0)   # 计算macro需要labels去掉NULL
    # print('measure_result = \n', measure_result)
    f.write(f"measure_result: {measure_result}\n")

F1Score在自然语言处理任务中的应用
AI智能涌现深度研究
07-24 1020
F1Score在自然语言处理任务中的应用 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：F1Score, 自然语言处理, 评估指标, 精确率, 召回率 1. 背景介绍
自然语言处理之命名实体识别：Bi-LSTM-CRF在信息抽取中的应用
最新发布
zhubeibei168的博客
04-20 930
在命名实体识别（NER）任务中，评估模型的性能至关重要。常用的评估指标包括准确率（Precision）、召回率（Recall）和F1分数（F1 Score）。这些指标帮助我们理解模型在预测实体时的精确度和全面性。在本节中，我们将通过一个具体的案例来深入理解Bi-LSTM-CRF模型在命名实体识别（NER）任务中的应用。案例将基于一个公开的中文命名实体识别数据集——MSRA NER数据集。这个数据集广泛用于中文NER的研究和评估，包含了大量标注了人名、地名和机构名的文本数据。双向LSTM（Bi-LSTM）
预测评价系统_「机器学习」一文读懂分类算法常用评价指标
weixin_39606575的博客
11-19 800
前言评价指标是针对将相同的数据，输入不同的算法模型，或者输入不同参数的同一种算法模型，而给出这个算法或者参数好坏的定量指标。在模型评估过程中，往往需要使用多种不同的指标进行评估，在诸多的评价指标中，大部分指标只能片面的反应模型的一部分性能，如果不能合理的运用评估指标，不仅不能发现模型本身的问题，而且会得出错误的结论。最近恰好在做文本分类的工作，所以把机器学习分类任务的评价指标又过了一遍。本文将详细...
第4章 关系抽取——《知识图谱概念与技术》肖仰华
fufu_good的博客
04-23 2912
4.1 概述 知识抽取（Information Extraction，IE）旨在从非结构化和半结构化文本中抽取出结构化数据。一般而言，关系抽取产生的结果为三元组<主体（Subject），谓语（Predicate），客体（Object）>，表示主体和客体之间存在谓词表达的关系。 除了从文本中或半结构化数据中国抽取关系，还可以有： 人工输入 从结构化数据转换而来 4.1.1 关系抽取的...
sklearn(四)计算recall:使用metrics.recall_score()计算多分类的召回率
凝眸伏笔的博客
11-20 1万+
写在前面： sklearn(三)计算recall:使用metrics.recall_score()计算二分类的召回率 1.sklearn.metrics.recall_score()的使用方法 2.例子
关系抽取（分类）总结【转载】
微澜同学
05-10 3万+
366 次阅读关系抽取(分类)总结文章目录基本介绍Fully Supervised Learning相关文献总结1Distant Supervised Learning相关文献总结2附2018.04.04更新：z增加对NYT+Freebase数据集的两个版本的说明对近几年(到2017)一些关系抽取/分类(Relation Extraction)的部分文献的一个简单总结。基本介绍基本定义关系抽取: ...
知识抽取-实体及关系抽取(一)
u010955999的博客
09-27 3万+
知识抽取涉及的“知识”通常是 清楚的、事实性的信息，这些信息来自不同的来源和结构，而对不同数据源进行的知识抽取的方法各有不同，从结构化数据中获取知识用 D2R，其难点在于复杂表数据的处理，包括嵌套表、多列、外键关联等，从链接数据中获取知识用图映射，难点在于数据对齐，从半结构化数据中获取知识用包装器，难点在于 wrapper 的自动生成、更新和维护，这一篇主要讲从文本中获取知识，也就是我们广义上说的...
机器学习之评价指标（混淆矩阵、准确度accuracy、精确率precision、召回率recall、F1-score）
qq_38947129的博客
09-17 3327
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
F1-Score：如何在NLP中优雅地解决类别不平衡问题
F1-Score通过精确率（Precision）和召回率（Recall）的调和平均，为模型提供了一个单一的性能度量，这在许多情况下比单一使用准确率（Accuracy）更加有效。本章将深入探讨F1-Score的理论基础，其核心概念以及在实际...
F1-Score：深度剖析其在机器学习中的局限性与优化策略
F1-Score是机器学习评估中的一个重要指标，它是精确率（Precision）和召回率（Recall）的调和平均数。当模型的精确率和召回率都很重要时，F1-Score提供了一个单一的指标来平衡二者。 ## 1.2 F1-Score的计算方法 F1-...
用通俗易懂的方式讲解：实体关系抽取入门教程
2201_75499313的博客
01-01 1333
在自然语言处理领域，关系通常主要指代文本中实体之间的联系，如语法关系、语义关系等。通常将实体间的关系形式化地描述为关系三元组, 其中E指的是实体类型，R为的是关系描述类型。基于以上的定义，可以直观地将关系抽取任务分成３个关键的模块：命名实体识别：是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等触发词识别：对触发实体关系的词进行分类，识别出是触发词还是非触发词，判定抽取出的关系是正类还是负类；关系抽取模块：从识别出的实体中抽取实体间的语义关系；
【机器学习】Metrics: 衡量算法性能的关键指标
鑫宝的博客
07-16 2403
在算法开发和机器学习项目中，选择正确的评估指标（metrics）至关重要。它们不仅帮助我们理解模型的性能，还指导我们如何优化模型以达到预期的目标。本文将探讨几种常用的评估指标，并解释它们在不同场景下的应用。
sklearn(三)计算recall:使用metrics.recall_score()计算二分类的召回率
凝眸伏笔的博客
11-20 9825
从常用评价指标文章中摘出来： 召回率是覆盖面的度量，度量有多个正例被分为正例，recall=TP/(TP+FN)=TP/P。被预测为正的样本占正样本总量的比例。
Python 智能银行卡识别系统的实现
datayx的文章
07-14 1739
向AI转型的程序员都关注了这个号????????????机器学习AI算法工程 公众号：datayx本文视频演示如下：（一）先看看系统的效果（二）系统实现的大致思路系统开发环境要求：1...
实体关系抽取学习笔记
zerozzl01的博客
12-08 4411
1 关系抽取概述 1.1 简介 关系抽取可分为全局关系抽取与提及关系抽取。全局关系抽取基于一个很大的语料库，抽取其中所有关系对，而提及关系抽取，则是判断一句话中，一个实体对是否存在关系，存在哪种关系的工作。 常见的关系抽取结果可以用SPO结构的三元组来表示，即 (Subject, Predication, Object)，如：中国的首都是北京 ==> (中国, 首都, 北京) 关系抽取的分类： 是否有确定的关系集合： 限定关系抽取：事先确定好所有需要抽取的关系集合，则可讲关系抽取看作是一中
sklearn.metrics中的评估方法介绍（accuracy_score, recall_score, roc_curve, roc_auc_score, confusion_matrix）
热门推荐
Cherzhoucheer的博客
02-19 9万+
accuracy_score 分类准确率分数是指所有分类正确的百分比。分类准确率这一衡量分类器的标准比较容易理解，但是它不能告诉你响应值的潜在分布，并且它也不能告诉你分类器犯错的类型。 形式： sklearn.metrics.accuracy_score(y_true, y_pred, normalize=True, sample_weight=None) normalize：默认
关系抽取数据集评价方法scorer.py解读
nstarLDS的博客
03-18 1584
真实关系的列表存在key中，预测关系的列表存在prediction中，从dev数据集中获取样本，以tacred为例，包含两万多条记录。以真实label存储，不是one-hot。 在该评价方法中，也有TP，FP，TN，FN的概念，positive就代表了实体之间存在关系的样本，negative则代表不存在关系的样本。 def score(key, prediction, verbose=False)...
sklearn计算准确率和召回率----accuracy_score、metrics.precision_score、metrics.recall_score
LFGxiaogang的博客
09-08 5万+
转自：http://d0evi1.com/sklearn/model_evaluation/ accuracy_score  ** clf.score(X_test, y_test)引用的就是accuracy_score方法（clf为分类器对象） accuracy_score函数计算了准确率，不管是正确预测的fraction（default），还是count(normalize=False...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值