精华内容
下载资源
问答
  • 准确率和召回率matlab代码SPBL_Pytorch PyTorch实施“用于临床皮肤病识别的自动平衡学习” 安装 该项目基于和。 并且我们在其中添加了不平衡的学习方法,并修改了一些代码以实现兼容性。 要求 Python 3.4以上 ...
  • 多分类的 准确率 召回率 代码

    千次阅读 2020-02-18 10:45:28
    from sklearn.metrics import classification_report,confusion_matrix ...# 准确率 召回率 F1 每个类的数据量 precision_recall_report = classification_report( y_true=all_groundtruth_list, y_pre...
    from sklearn.metrics import classification_report,confusion_matrix
    
    # 准确率 召回率 F1 每个类的数据量
    precision_recall_report = classification_report(
                  y_true=all_groundtruth_list,
                  y_pred=all_predict_list,
                  labels=list(range(0,len(all_label_list))),
                  target_names=all_label_list)
    print(precision_recall_report)
    
    # 混淆矩阵
    matrix = confusion_matrix(
             y_true=all_groundtruth_list,
             y_pred=all_predict_list,
             labels=list(range(0,len(all_label_list))))  
    print(matrix)
                
    
    展开全文
  • 今天小编就为大家分享一篇Pytorch 计算误判率,计算准确率,计算召回率的例子,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 在进行二分类后需要对分类结果进行评价,评价的标准除了常用的正确率之外还有召回率精确度,虚警率和漏警率等。首先介绍一下最常用的正确率 正确率(Accuracy)表示正负样本被正确分类的比例,计算公式如下: 其中...

    1.二分类评价标准介绍

    在进行二分类后需要对分类结果进行评价,评价的标准除了常用的正确率之外还有召回率精确度,虚警率和漏警率等。首先介绍一下最常用的正确率

    正确率(Accuracy)表示正负样本被正确分类的比例,计算公式如下:
    在这里插入图片描述

    其中 N T P N_{TP} NTP 表示正类样本被正确分类的数目, N T N N_{TN} NTN表示负类样本被正确分类的数目, N F P N_{FP} NFP表示负类样本被分为正类的数目, N F N N_{FN} NFN表示正类样本被分为负类的数目。
    如下表所示:
    在这里插入图片描述

    • 精确率(Precision)表示原本为正类样本在所有被分为正类样本(正的被分为正的+错的被分为正的)的比例
      在这里插入图片描述

    • 召回率(Recall)表示原本为正类样本在原本正类样本(正的被分为正的+正的被分为错的)的比例
      在这里插入图片描述

    • 虚警率(False alarm)表示负类样本被分为正类样本在所有负类样本中的比例
      在这里插入图片描述

    • 漏警率表示(Missing alarm)表示正类样本被分为负类样本在所有正类样本中的比例
      在这里插入图片描述

    2. Tensorflow实现代码

    计算公式已经在第一节给出了,代码实现最难的部分不是计算而是对于数据格式的转换。本文背景为,利用保存好的模型在测试集上进行测试,然后对测试集的分分类结果进行评估。
    直接上代码,其中函数的predict是预测结果,也就是神经网络的输出,real是真实的标签,sess就是tensorflow当前的会话,feed_dict是需要喂的数据。下面详细讲解一下代码

    prediction=tf.matmul(tf.reshape(outputs, [-1, 2 * lstmUnits]), weight) + bias  #注意这里的维度,lstmUnits是双向LSTM隐藏层单元,weight和bias为全连接层权重和偏置,outputs为BiLSTM最后一个输出
    labels = tf.placeholder(tf.float32, [batchSize, numClasses])
    pred=tf.argmax(prediction, 1)
    lab= tf.argmax(labels,1)
    #函数tf.argmax()返回值是是数值最大值的索引位置,如果最大值位置相同,则分类正确,反之则分类错误
    

    下面的代码是将上述代码获得到变量设置为元素为0或者1的矩阵,在后面计算的时候只需要按照逻辑与计算即可.

    ones_like_actuals = tf.ones_like(lab)
    zeros_like_actuals = tf.zeros_like(lab)
    ones_like_predictions = tf.ones_like(pred)
    zeros_like_predictions = tf.zeros_like(pred)
    

    后面的都是按第一节公式计算的部分

    tp_op = tf.reduce_sum(
        tf.cast(
            tf.logical_and(
                tf.equal(lab, ones_like_actuals),
                tf.equal(pred, ones_like_predictions)#zeros_like_predictions多分类,替换tp_op和fp_op 中的ones_like_predictions
            ),
            "float"
        )
    )
    
    tn_op = tf.reduce_sum(
        tf.cast(
            tf.logical_and(
                tf.equal(lab, zeros_like_actuals),
                tf.equal(pred, zeros_like_predictions)
            ),
            "float"
        )
    )
    
    fp_op = tf.reduce_sum(
        tf.cast(
            tf.logical_and(
                tf.equal(lab, zeros_like_actuals),
                tf.equal(pred, ones_like_predictions)
            ),
            "float"
        )
    )
    
    fn_op = tf.reduce_sum(
        tf.cast(
            tf.logical_and(
                tf.equal(lab, ones_like_actuals),
                tf.equal(pred, zeros_like_predictions)
            ),
            "float"
        )
    )
    
    

    完整函数代码

    def tf_confusion_metrics(predict, real, session, feed_dict):
        predictions = tf.argmax(predict, 1)
        actuals = tf.argmax(real, 1)
     
        ones_like_actuals = tf.ones_like(actuals)
        zeros_like_actuals = tf.zeros_like(actuals)
        ones_like_predictions = tf.ones_like(predictions)
        zeros_like_predictions = tf.zeros_like(predictions)
     
        tp_op = tf.reduce_sum(
            tf.cast(
                tf.logical_and(
                    tf.equal(actuals, ones_like_actuals),
                    tf.equal(predictions, ones_like_predictions)
                ),
                "float"
            )
        )
     
        tn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )
     
        fp_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, ones_like_predictions)
              ),
              "float"
            )
        )
     
        fn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, ones_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )
        tp, tn, fp, fn = session.run([tp_op, tn_op, fp_op, fn_op], feed_dict)
    #feed_dict为喂养的数据,比如我这批预测数据为数据是nextBatch, nextBatchLabels = getTestBatch(),nextBatch为数据,而nextBatchLabels 则是数据标签。则 feed_dict={input_data: nextBatch, labels: nextBatchLabels})
        tpr = float(tp)/(float(tp) + float(fn))
        fpr = float(fp)/(float(fp) + float(tn))
        fnr = float(fn)/(float(tp) + float(fn))
        accuracy = (float(tp) + float(tn))/(float(tp) + float(fp) + float(fn) + float(tn))
        recall = tpr
        precision = float(tp)/(float(tp) + float(fp))
        f1_score = (2 * (precision * recall)) / (precision + recall)
    

    计算评价标准的函数不难,难得是调用函数,这部分可以结合:Tensorflow在训练好的模型上进行测试来看。
    尊重原创,文章摘自:Tensorflow计算正确率、精确率、召回率、虚警率和漏检率

    展开全文
  • python实现召回率、精度、f1代码

    千次阅读 2020-11-03 11:11:10
    = 0: recall = round(100 * float(label_correct_sum) / float(label_total_sum), 4) label_recall.append(recall) print("每类召回率:", label_recall) all_recall = round(np.array(label_recall).sum() / metrix...
    import matplotlib.pyplot as plt
    import numpy as np
    

    1、统计训练和测试精度

    # 读取实验结果中的精度和损失
    def data_plot(path):
        # path = r'./model_png\5gcn_128_node_pos_floor_2000.log'
        # path = r'./[6, 6]_Standard_taz.csv'
        with open(path, mode="r", encoding="utf-8") as f:
            data = f.readlines()
        Train = []
        Test = []
        for item in data:
            if "Train Acc" in item:
                # print(item)
                train = item.split(":")[1].strip()
                if train == "":
                    continue
                Train.append(float(train))
    
            elif "Test Acc" in item:
                test = item.split(":")[1].strip()
                if test == "":
                    continue
                Test.append(float(test))
        plt.title('train')
        plt.plot(Train)
        # plt.savefig("./model_png/5gcn_128_node_pos_floor_2000_acc.png")
        # plt.show()
        plt.clf()  # 重置画布
        plt.title('test')
        plt.plot(Test)
        # plt.savefig("./model_png/5gcn_128_node_pos_floor_2000_loss.png")
        # plt.show()
    
    if __name__ == '__main__':
        # 1、绘制损失精度图
        path = r"./[6, 6, 6, 6]_Standard_taz.csv"
        data_plot(path)
    
    

    2、计算混淆矩阵的精度、召回率和f1

    def calculate_prediction(metrix):
        """
        计算精度
        """
        label_pre = []
        current_sum = 0
        for i in range(metrix.shape[0]):
            current_sum += metrix[i][i]
            label_total_sum = metrix.sum(axis=0)[i]
            pre = round(100 * metrix[i][i] / label_total_sum, 4)
            label_pre.append(pre)
        print("每类精度:", label_pre)
        all_pre = round(100 * current_sum / metrix.sum(), 4)
        print("总精度:", all_pre)
        return label_pre, all_pre
    
    
    def calculate_recall(metrix):
        """
        先计算某一个类标的召回率;
        再计算出总体召回率
        """
        label_recall = []
        for i in range(metrix.shape[0]):
            label_total_sum = metrix.sum(axis=1)[i]
            label_correct_sum = metrix[i][i]
            recall = 0
            if label_total_sum != 0:
                recall = round(100 * float(label_correct_sum) / float(label_total_sum), 4)
    
            label_recall.append(recall)
        print("每类召回率:", label_recall)
        all_recall = round(np.array(label_recall).sum() / metrix.shape[0], 4)
        print("总召回率:", all_recall)
        return label_recall, all_recall
    
    
    def calculate_f1(prediction, all_pre, recall, all_recall):
        """
        计算f1分数
        """
        all_f1 = []
        for i in range(len(prediction)):
            pre, reca = prediction[i], recall[i]
            f1 = 0
            if (pre + reca) != 0:
                f1 = round(2 * pre * reca / (pre + reca), 4)
    
            all_f1.append(f1)
        print("每类f1:", all_f1)
        print("总的f1:", round(2 * all_pre * all_recall / (all_pre + all_recall), 4))
        return all_f1
    
    if __name__ == '__main__':
        # ************************************
        # 2、计算召回率、精度、f1
        metrix = \
            np.array([[84, 30, 16, 4, 4],
                      [11, 88, 14, 5, 1],
                      [13, 31, 75, 0, 0],
                      [12, 15, 3, 71, 1],
                      [31, 7, 5, 12, 67]])
        # metrix = np.array()
        # print(metrix,metrix.shape[0])
        print(metrix.sum(axis=0)[0], metrix.sum(axis=1)[0])
        # print("召回率:", calculate_recall(metrix))
        # print("精度:", calculate_prediction(metrix))
        label_pre, all_pre = calculate_prediction(metrix)
        label_recall, all_recall = calculate_recall(metrix)
        # ************************************
        calculate_f1(label_pre, all_pre, label_recall, all_recall)
    

    3、绘制混淆矩阵展示图形,已经混淆矩阵平均值

    def get_Confusion_matrix(path):
        numCount = 200  # 统计后多少数据,例如后200个,直接写200
        with open(path, mode="r", encoding="utf-8") as f:
            data = f.readlines()
        Confusion = []
        epoch_con = []
        for item in data:
            if ("Train" in item) or ("Test" in item):
                continue
            if "[[" in item:
                epoch_con = []
                # data = (np.array(item.strip()[2:])).tolist()
                datas = list((item.strip()[2:-1]).split())
                epoch_con.append(datas)
                continue
            if "]]" in item:
                datas = list((item.strip()[1:-2]).split())
                epoch_con.append(datas)
                Confusion.append(epoch_con)
                continue
            if "[" in item:
                datas = list((item.strip()[1:-1]).split())
                epoch_con.append(datas)
    
        sum = np.zeros((5, 5), dtype=int)
        # numCount = 200
        for temp in Confusion[-numCount:]:
            print(temp)
            sum += np.array(temp, dtype=int)
    
            metrix = sum / numCount
        print(metrix)
        # 绘制混淆矩阵
        plot_Confusion_matrix(metrix=metrix)
    
        print(metrix.sum(axis=0)[0], metrix.sum(axis=1)[0])
        # print("召回率:", calculate_recall(metrix))
        # print("精度:", calculate_prediction(metrix))
        label_pre, all_pre = calculate_prediction(metrix)
        label_recall, all_recall = calculate_recall(metrix)
        # ************************************
        calculate_f1(label_pre, all_pre, label_recall, all_recall)
    
    if __name__ == '__main__':
    	path = r"C:\Users\Administrator\Desktop\nj单一特征对比实验\12-16号graphsage的结果" \
               r"\lstm\[7, 7, 7, 7]_Standard_taz_lstm.csv"
        get_Confusion_matrix(path)
        
    
    
    展开全文
  • 计算微观和宏观平均:精度、召回率、F-score。 从混淆矩阵计算。 如果您有任何问题,请发表评论或给我发电子邮件。
  • 语义分割准确率、精确率、召回率、F1值计算代码

    千次阅读 热门讨论 2021-03-08 15:10:44
    语义分割准确率、精确率、召回率、F1值计算 使用提示: 需要opencv库 只需将预测结果文件路径与标签路径改一下 版权专属小轩 import cv2 import numpy as np import os #预测结果路径 pred_path = r'D:\experiment\...

    语义分割准确率、精确率、召回率、F1值计算

    使用提示

    需要opencv库
    只需将预测结果文件路径与标签路径改一下
    只针对二分类哦
    (多分类可稍作修改)
    代码里正类的像素值为255,可做修改!

    1.精度指标
    TP 正类判定为正类

    FP 负类判定为正类

    FN 正类判定为负类

    TN 负类判定为负类

    import cv2
    import numpy as np
    import os
    
    #预测结果路径
    pred_path = r'D:\experiment\u-net\predict'
    #标签路径
    lab_path = r'F:\dataset\LEVIR-CD-deal\test\label'
    
    
    def tpcount(imgp,imgl):
        n = 0
        for i in range(WIDTH):
            for j in range(HIGTH):
                if imgp[i,j] == 255 and imgl[i,j] == 255:
                    n = n+1
        return n
    
    def fncount (imgp,imgl):
        n = 0
        for i in range(WIDTH):
            for j in range(HIGTH):
                if imgl[i,j] == 255 and imgp[i,j] == 0:
                    n = n+1
        return n
    
    def fpcount(imgp,imgl):
        n = 0
        for i in range(WIDTH):
            for j in range(HIGTH):
                if imgl[i,j] == 0 and imgp[i,j] == 255:
                    n+=1
        return n
    
    def tncount(imgp,imgl):
        n=0
        for i in range(WIDTH):
            for j in range(HIGTH):
                if imgl[i,j] == 0 and imgp[i,j] == 0:
                    n += 1
        return n
    
    
    
    
    imgs = os.listdir(pred_path)
    a = len(imgs)
    TP = 0
    FN = 0
    FP = 0
    TN = 0
    c = 0
    for name in imgs:
    
        imgp = cv2.imread(pred_path + '/' + name, -1)
        imgp = np.array(imgp)
    
        imgl = cv2.imread(lab_path + '/' + name, -1)
        imgl = np.array(imgl)
    
        WIDTH = imgl.shape[0]
        HIGTH = imgl.shape[1]
    
        TP += tpcount(imgp, imgl)
        FN += fncount(imgp, imgl)
        FP += fpcount(imgp, imgl)
        TN += tncount(imgp, imgl)
    
        c += 1
        print('已经计算:'+str(c) + ',剩余数目:'+str(a-c))
    
    print('TP:'+str(TP))
    print('FN:'+str(FN))
    print('FP:'+str(FP))
    print('TN:'+str(TN))
    
    
    #准确率
    zq = (int(TN)+int(TP))/(int(WIDTH)*int(HIGTH)*int(len(imgs)))
    #精确率
    jq = int(TP)/(int(TP)+int(FP))
    #召回率
    zh = int(TP)/(int(TP)+int(FN))
    #F1
    f1 = int(TP)*2/(int(TP)*2+int(FN)+int(FP))
    
    print('准确率:'+ str(zq))
    print('精确率:'+ str(jq))
    print('召回率:'+ str(zh))
    print('F1值:'+ str(f1))
    

    有任何疑问请直接在评论区提问!
    有任何疑问请直接在评论区提问!
    有任何疑问请直接在评论区提问!
    重要的事说三遍!
    (如非必要请勿私信,确有必要,请先点赞!)

    版权专属小轩

    展开全文
  • 图像矩阵matlab代码检测建议 评估检测建议算法。 该代码属于BMVC论文,检测建议真的有多好? 以及PAMI论文对有效的检测建议有何影响? 。 看看以获得更多信息。 如果您在使用代码时遇到问题,请与我联系! 绘制评估...
  • 具体代码如下: P=TP/(TP+FP) R=TP/(TP+FN) F1=2*(P+R)/(P*R) FPR=FP/(TN+FP) print("精确率R,真正率TPR: {:.3f}".format(P)) print("召回率:{:.3f}".format(R)) print("F1值:{:.3f}".format(R)) print("假正率:{:.3...
  • 1、召回率:评价模型的完整性 预测样本中的预测正确的信息条数/总样本中所有的属于这类样本的信息条数 举例: 这里用鱼和虾举例 TP: 将鱼预测为鱼 FP: 将虾预测为鱼 FN: 将鱼预测虾 TN: 将虾预测为虾 召回率R = TP...
  • 图4、 物体检测的P-R曲线 ​ 然而,即使有了P-R曲线,评价模型仍然不直观,如果直接取曲线 上的点,在哪里选取都不合适,因为召回率高的时候准确率会很低,准 确率高的时候往往召回率很低。这时,AP就派上用场了,...
  • 代码开源在github上,有需要的同学可以点这里multiclassify-eval来git clone。 A simple python module to calculate precision, recall, accuracy and f-measure for multi-classify evaluation. 一个基于Python的...
  • 用一个F1值来综合评估精确率和召回率,它是精确率和召回率的调和均值,当精确率和召回率都高时,F1值也会高。 Python代码 from sklearn.linear_model import LogisticRegression #逻辑回归模型 from sklearn.metrics...
  • 精度(查准率)和召回率(查全率)等指标对衡量机器学习的模型性能是非常基本的,特别是在不平衡分布数据集的案例中,在周志华教授的「西瓜书」中就特别详细地介绍了这些概念。 为分类任务选择正确的衡量指标 栗子1...
  • 记录一下,在学习用SVM分类时,需要对分类结果进行评价,光有正确是不够的,所以就使用了混淆矩阵。原理的话,很多博客上都有,但为了便于理解程序,就简单讲一下。 结合程序,我们的类别是(-1,1),在Matlab中...
  • 混淆矩阵中的准确率与召回率

    万次阅读 2018-08-22 22:04:21
    精度(查准率)和召回率(查全率)等指标对衡量机器学习的模型性能是非常基本的,特别是在不平衡分布数据集的案例中,在周志华教授的「西瓜书」中就特别详细地介绍了这些概念。 GitHub 地址:...
  • 使用Python Numpy向量化实现准确率与召回率的计算
  • 混淆矩阵 P(Positive):代表1 N(Negative):代表0 T(True):代表预测正确 F(False):代表错误 ...照上面的字符表示,混淆矩阵就变成了下面这样: ...2. 准确 ...准确的定义是预测正确的结果占总...准确=(T
  • 现需要利用mmdetection计算每种标签的精确率(precision),召回率(recall),AP,和这个模型的mAP。并且将检测结果写成xml,且该xml可被labelimg识别。 网上大多讨论的是二分类的做法,当下的问题相当于五类,说一下...
  • 机器学习模型指标之准确率、精确率、召回率、F1 score 第一篇看代码 第二篇看图解概念 第三篇看意义
  • https://blog.csdn.net/hxg2006/article/details/796491541、准确率(Accuracy), 精确率(Precision), 召回率(Recall)和F1-Measuryu Code 15 Comments 机器学习(ML),自然语言处理(NLP),信息检索(IR)等领域,评估...
  • 1.召回率和正确率计算对于一个KK元的分类结果,我们可以得到一个K∗KK*K的混淆矩阵,得到的举证结果如下图所示。 从上图所示的结果中不同的元素表示的含义如下: mijm_{ij} :表示实际分类属于类ii,在预测过程中被...
  • def precision(y_true, y_pred): # Calculates the precision true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) ...
  • 利用tf-idf算法和余弦相似度算法计算了文本之间的余弦相似系数,可是结果出来了,不知道结果的好坏啊,请问大神们有没有知道怎么评测结果的好坏啊?上网查到可以计算精准率与召回率,这个用Python怎么实现啊?
  • 在生活中,最常用的就是准确,因为它定义简单而且比较通用,但在机器学习中,它往往不是评估模型的最佳工具, 特别是在数据分布不平衡的时候,请看一个例子: 比如我们训练了一个预测地震的模型,预测类别只有两个...
  • 其中传入的pred_bboxes格式为3维的数组的list格式,也就是说每个list都是一个3维数组(有batch...list化可以参考下面代码 pred_bboxes, pred_labels, pred_scores = list(), list(), list() gt_bboxes, gt_labels, ...
  • 由于要用keras做一个多分类的问题,评价标准采用precision,recall,和f1_score;但是keras中没有给出precision和recall。同时,keras中的f1_score只是一个平均值,所以我把结果输出出来,用sklearn得到的上面3个...
  • 参考以下链接: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,297
精华内容 5,718
关键字:

召回率代码