精华内容
下载资源
问答
  • python画混淆矩阵

    万次阅读 热门讨论 2018-05-24 14:21:35
    对于分类问题,为了直观表示各类别分类的准确性,一般使用...这里给出两种方法画混淆矩阵。 方法一:这里采用画图像的办法,绘制混淆矩阵的表示图。颜色越深,值越大。 # -*- coding: utf-8 -*- # By Changxu C...

    对于分类问题,为了直观表示各类别分类的准确性,一般使用混淆矩阵M. 

    混淆矩阵M的每一行代表每个真实类(GT),每一列表示预测的类。即:Mij表示GroundTruth类别为i的所有数据中被预测为类别j的数目。

    这里给出两种方法画混淆矩阵。

    方法一:这里采用画图像的办法,绘制混淆矩阵的表示图。颜色越深,值越大。

    # -*- coding: utf-8 -*-
    # By Changxu Cheng, HUST
    
    from __future__ import division
    import numpy as np
    from skimage import io, color
    from PIL import Image, ImageDraw, ImageFont
    import os
    
    def drawCM(matrix, savname):
        # Display different color for different elements
        lines, cols = matrix.shape
        sumline = matrix.sum(axis=1).reshape(lines, 1)
        ratiomat = matrix / sumline
        toplot0 = 1 - ratiomat
        toplot = toplot0.repeat(50).reshape(lines, -1).repeat(50, axis=0)
        io.imsave(savname, color.gray2rgb(toplot))
        # Draw values on every block
        image = Image.open(savname)
        draw = ImageDraw.Draw(image)
        font = ImageFont.truetype(os.path.join(os.getcwd(), "draw/ARIAL.TTF"), 15)
        for i in range(lines):
            for j in range(cols):
                dig = str(matrix[i, j])
                if i == j:
                    filled = (255, 181, 197)
                else:
                    filled = (46, 139, 87)
                draw.text((50 * j + 10, 50 * i + 10), dig, font=font, fill=filled)
        image.save(savname, 'jpeg')
    
    if __name__ == "__main__":
        drawCM(np.random.randint(16, size=16).reshape(4,4), 'tmp.jpg')

    注意:需要用到字体文件。代码中使用的是ARIAL.TTF。这样才可以在图中直接标注出数目。

    某实验结果图如下(不是上述__name__ == "__main__"代码的执行结果)

    方法二:利用matplotlib.pyplot.matshow画图

    from __future__ import division
    import  numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.ticker import MultipleLocator
    
    def plotCM(classes, matrix, savname):
        """classes: a list of class names"""
        # Normalize by row
        matrix = matrix.astype(np.float)
        linesum = matrix.sum(1)
        linesum = np.dot(linesum.reshape(-1, 1), np.ones((1, matrix.shape[1])))
        matrix /= linesum
        # plot
        plt.switch_backend('agg')
        fig = plt.figure()
        ax = fig.add_subplot(111)
        cax = ax.matshow(matrix)
        fig.colorbar(cax)
        ax.xaxis.set_major_locator(MultipleLocator(1))
        ax.yaxis.set_major_locator(MultipleLocator(1))
        for i in range(matrix.shape[0]):
            ax.text(i, i, str('%.2f' % (matrix[i, i] * 100)), va='center', ha='center')
        ax.set_xticklabels([''] + classes, rotation=90)
        ax.set_yticklabels([''] + classes)
        #save
        plt.savefig(savname)

    这种方法可以直接标出坐标轴的含义,比较方便。

     

    展开全文
  • Python 画混淆矩阵

    2021-05-27 15:15:44
    from sklearn.metrics import confusion_matrix import warnings import numpy as np import matplotlib.pyplot as plt import itertools warnings.filterwarnings('ignore') def plot_confusion_matrix(cm, ...
    from sklearn.metrics import confusion_matrix
    import warnings
    import numpy as np
    import matplotlib.pyplot as plt
    import itertools
    
    warnings.filterwarnings('ignore')
    
    
    def plot_confusion_matrix(cm, classes,
                              normalize=False,
                              title='Confusion matrix',
                              cmap=plt.cm.Blues):
        """
        This function prints and plots the confusion matrix.
        Normalization can be applied by setting `normalize=True`.
        """
        if normalize:
            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
            print("Normalized confusion matrix")
        else:
            print('Confusion matrix, without normalization')
    
        plt.imshow(cm, interpolation='nearest', cmap=cmap)
        plt.title(title)
        plt.colorbar()
        tick_marks = np.arange(len(classes))
        plt.xticks(tick_marks, classes, rotation=45)
        plt.yticks(tick_marks, classes)
    
        fmt = '.2f' if normalize else 'd'
        thresh = cm.max() / 2.
        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
            plt.text(j, i, format(cm[i, j], fmt),
                     horizontalalignment="center",
                     color="white" if cm[i, j] > thresh else "black")
    
        plt.tight_layout()
        plt.ylabel('True label')
        plt.xlabel('Predicted label')
    
    
    def main():
        val_y = np.array(
            [
                0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3,
            ]
        )
    
        val_pred = np.array(
            [
                0, 0, 0, 2, 1, 1, 2, 2, 3, 3, 3, 0,
            ]
        )
    
        cnf_matrix = confusion_matrix(val_y, val_pred)
        np.set_printoptions(precision=2)
        plt.figure(figsize=(10, 10))
        plot_confusion_matrix(cnf_matrix, classes=['0', '1', '2', '3', ], normalize=True,
                              title='Confusion matrix, with normalization')
        plt.savefig('confusion_matrix.png', bbox_inches='tight')
        plt.show()
    
    
    if __name__ == '__main__':
        main()
    

     

     

    展开全文
  • Python画混淆矩阵

    千次阅读 2018-11-15 15:08:31
    # -*-coding:utf-8-*- from sklearn.metrics import confusion_matrix import matplotlib.pyplot as plt import numpy as np #labels表示你不同类别的代号,比如这里的demo中有13个类别 labels = ['A', 'B', 'C', '...
    # -*-coding:utf-8-*-
    from sklearn.metrics import confusion_matrix
    import matplotlib.pyplot as plt
    import numpy as np
    
    #labels表示你不同类别的代号,比如这里的demo中有13个类别
    labels = ['A', 'B', 'C', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']
    
    #y_true代表真实的label值 y_pred代表预测得到的lavel值
    y_true = np.loadtxt('Data/re_label.txt')
    y_pred = np.loadtxt('Data/pr_label.txt')
    
    tick_marks = np.array(range(len(labels))) + 0.5
    
    
    def plot_confusion_matrix(cm, title='Confusion Matrix', cmap=plt.cm.binary):
        plt.imshow(cm, interpolation='nearest', cmap=cmap)
        plt.title(title)
        plt.colorbar()
        xlocations = np.array(range(len(labels)))
        plt.xticks(xlocations, labels, rotation=90)
        plt.yticks(xlocations, labels)
        plt.ylabel('True label')
        plt.xlabel('Predicted label')
    
    
    cm = confusion_matrix(y_true, y_pred)
    np.set_printoptions(precision=2)
    cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
    print(cm_normalized)
    plt.figure(figsize=(12, 8), dpi=120)
    
    ind_array = np.arange(len(labels))
    x, y = np.meshgrid(ind_array, ind_array)
    
    for x_val, y_val in zip(x.flatten(), y.flatten()):
        c = cm_normalized[y_val][x_val]
        if c > 0.01:
            plt.text(x_val, y_val, "%0.2f" % (c,), color='red', fontsize=7, va='center', ha='center')
    # offset the tick
    plt.gca().set_xticks(tick_marks, minor=True)
    plt.gca().set_yticks(tick_marks, minor=True)
    plt.gca().xaxis.set_ticks_position('none')
    plt.gca().yaxis.set_ticks_position('none')
    plt.grid(True, which='minor', linestyle='-')
    plt.gcf().subplots_adjust(bottom=0.15)
    
    plot_confusion_matrix(cm_normalized, title='Normalized confusion matrix')
    # show confusion matrix
    plt.savefig('Data/confusion_matrix.png', format='png')
    plt.show()
    
    展开全文
  • python 画混淆矩阵

    千次阅读 2018-03-27 02:51:35
    u'ResNet模型预测混淆矩阵结果' , fontproperties =custom_font) plt.colorbar() # xy = range(0) # z = xy # sc = plt.scatter(z,z,c=z) # plt.colorbar(sc) xlocations = np.array( range ( len ...
    import matplotlib as mpl
    import random
    mpl.use('Agg')
    
    import matplotlib.pyplot as plt
    import numpy as np
    
    mpl.use('Agg')
    custom_font = mpl.font_manager.FontProperties(fname='H:\competition\downmodel\evaluation\paintpic\zh.ttf')
    def plot_confusion_matrix(y_true, y_pred, labels):
        # import matplotlib.pyplot as plt
        from sklearn.metrics import confusion_matrix
        cmap = plt.cm.get_cmap('Accent_r')
        # cmap = plt.cm.binary
        cm = confusion_matrix(y_true, y_pred)
        tick_marks = np.array(range(len(labels))) + 0.5
        np.set_printoptions(precision=2)
        cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        plt.figure(figsize=(10, 8), dpi=120)
        ind_array = np.arange(len(labels))
        x, y = np.meshgrid(ind_array, ind_array)
    
        intFlag = 1# 标记在图片中对文字是整数型还是浮点型
        for x_val, y_val in zip(x.flatten(), y.flatten()):
            if (intFlag):
                c = cm[y_val][x_val]
                plt.text(x_val, y_val, "%d" % (c,), color='red', fontsize=8, va='center', ha='center')
    
            else:
                c = cm_normalized[y_val][x_val]
                if (c > 0.01):
                    #这里是绘制数字,可以对数字大小和颜色进行修改
                    plt.text(x_val, y_val, "%0.2f" % (c,), color='red', fontsize=7, va='center', ha='center')
                else:
                    plt.text(x_val, y_val, "%d" % (0,), color='red', fontsize=7, va='center', ha='center')
        if(intFlag):
            plt.imshow(cm, interpolation='nearest', cmap=cmap)
        else:
            plt.imshow(cm_normalized, interpolation='nearest', cmap=cmap)
        plt.gca().set_xticks(tick_marks, minor=True)
        plt.gca().set_yticks(tick_marks, minor=True)
        plt.gca().xaxis.set_ticks_position('none')
        plt.gca().yaxis.set_ticks_position('none')
        plt.grid(True, which='minor', linestyle='-')
        plt.gcf().subplots_adjust(bottom=0.15)
        plt.title(u'ResNet模型预测混淆矩阵结果', fontproperties=custom_font)
        plt.colorbar()
        # xy = range(0)
        # z = xy
        # sc = plt.scatter(z,z,c=z)
        # plt.colorbar(sc)
        xlocations = np.array(range(len(labels)))
        plt.xticks(xlocations, labels, rotation=90)
        plt.yticks(xlocations, labels)
        plt.ylabel(u'滚动轴承真实类别', fontproperties=custom_font)
        plt.xlabel(u'滚动轴承预测类别', fontproperties=custom_font)
        plt.savefig('confusion_matrix.jpg', dpi=300)
        plt.show()
        print("kappa is:"+str(kappa(cm,10)))
    
    
    def kappa(testData, k):  # testData表示要计算的混淆数据矩阵,k表示数据矩阵的是k*k的
        dataMat = np.mat(testData)
        P0 = 0.0
        for i in range(k):
            P0 += dataMat[i, i] * 1.0
        xsum = np.sum(dataMat, axis=1)
        ysum = np.sum(dataMat, axis=0)
        # xsum是个k行1列的向量,ysum是个1行k列的向量
        Pe = float(ysum * xsum) / k ** 2
        P0 = float(P0 / k * 1.0)
        cohens_coefficient = float((P0 - Pe) / (1 - Pe))
        return cohens_coefficient
    
    # 针对每个类别给出详细的准确率、召回率和F-值这三个参数和宏平均值,用来评价算法好坏。
    def my_classification_report(y_true, y_pred):
        from sklearn.metrics import classification_report
        print("classification_report(left: labels):")
        print(classification_report(y_true, y_pred))
    
    ytrue = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
    ypred = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 2, 2, 5, 5, 2, 2, 2, 2, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 2, 4, 5, 5, 5, 5, 2, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
    
    listtrue=[]
    for i in range(10):
        for j in range(60):
            listtrue.append(i)
    
    
    listpred=[]
    
    for i in range(10):
        r=random.randint(52,56)
        for j in range(r):
            listpred.append(i)
        for k in range(60-r):
            listpred.append(random.randint(0,9))
    
    plot_confusion_matrix(listtrue,listpred,[0,1,2,3,4,5,6,7,8,9])
    my_classification_report(listtrue,listpred)
    # plot_confusion_matrix(ytrue,ypred,[1,2,3,4,5,6])

    如下图:


    其中get_cmap中取值可为:Possible values are: Accent, Accent_r, Blues, Blues_r, BrBG, BrBG_r, BuGn, BuGn_r, BuPu, BuPu_r, CMRmap, CMRmap_r, Dark2, Dark2_r, GnBu, GnBu_r, Greens, Greens_r, Greys, Greys_r, OrRd, OrRd_r, Oranges, Oranges_r, PRGn, PRGn_r, Paired, Paired_r, Pastel1, Pastel1_r, Pastel2, Pastel2_r, PiYG, PiYG_r, PuBu, PuBuGn, PuBuGn_r, PuBu_r, PuOr, PuOr_r, PuRd, PuRd_r, Purples, Purples_r, RdBu, RdBu_r, RdGy, RdGy_r, RdPu, RdPu_r, RdYlBu, RdYlBu_r, RdYlGn, RdYlGn_r, Reds, Reds_r, Set1, Set1_r, Set2, Set2_r, Set3, Set3_r, Spectral, Spectral_r, Wistia, Wistia_r, YlGn, YlGnBu, YlGnBu_r, YlGn_r, YlOrBr, YlOrBr_r, YlOrRd, YlOrRd_r...其中末尾加r是颜色取反。

    展开全文
  • python画混淆矩阵

    千次阅读 2020-10-18 16:33:27
    1. 计算混淆矩阵 from sklearn.metrics import confusion_matrix # 导入计算混淆矩阵的包 C1= confusion_matrix(True_label, T_predict1) #True_label 真实标签 shape=(n,1);T_predict1 预测标签 shape=(n,1) 2. ...
  • python画混淆矩阵2

    千次阅读 2019-09-09 22:24:08
    在做分类的时候,经常需要画混淆矩阵,下面我们使用python的matplotlib包,scikit-learning机器学习库也同样提供了例子:http://scikit-learn.org/stable/auto_examples/plot_confusion_matrix.html, 但是这样的图...
  • sklearn.metrics.plot_confusion_matrix可以直接画混淆矩阵, 但是好像要传入sklearn的classifier. 贴一个自己写的函数, 自己定义起来比较方便: def plot_confusion_matrix(cm, classes, normalize=False, title='...
  • 利用python画混淆矩阵

    2020-03-08 17:48:32
    我们在这里提供两种不同的应用场合: ...from sklearn.metrics import confusion_matrix # 生成混淆矩阵函数 import matplotlib.pyplot as plt # 绘图库 import numpy as np def plot_confusion_m...
  • python环境编程下做多分类问题要画混淆矩阵,复制了网上的代码,但是发现运行显示出来的混淆矩阵和原作者贴出来的不一样,如下左边图所示(截去了坐标标题信息),边界数字都跑到矩形框外边去了,恰好我有两个...
  • python画混淆矩阵(confusion matrix)

    千次阅读 2019-09-23 02:55:07
    混淆矩阵(Confusion Matrix),是一种在深度学习中常用的辅助工具,可以让你直观地了解你的模型在哪一类样本里面表现得不是很好。 如上图,我们就可以看到,有一个样本原本是0的,却被预测成了1,还有一个,原本...
  • import scipy.io p='D:/debug/predict_array' r='D:/debug/real_array' dataP=scipy.io.loadmat(p);# dataP类型为dictionary ...predict=dataP['predict_array']#获得其中的矩阵数据 real=dataR['real_a...
  • python画混淆矩阵

    2021-03-28 19:13:21
    https://blog.csdn.net/qq_41645987/article/details/109146503 博客代码:python画混淆矩阵图(里面有代码) https://blog.csdn.net/li123_123_/article/details/91984838混淆矩阵(confusion_matrix)的可视化 ...
  • 使用python绘制混淆矩阵(confusion_matrix)

    万次阅读 多人点赞 2018-04-22 13:46:00
    涉及到分类问题,我们经常需要通过可视化混淆矩阵来分析实验结果进而得出调参思路,本文介绍如何利用python绘制混淆矩阵(confusion_matrix),本文只提供代码,给出必要注释。 Code # -*-coding:utf-8-*- from ...
  • 主要介绍了详解使用python绘制混淆矩阵(confusion_matrix),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 使用python绘制混淆矩阵

    千次阅读 2019-12-28 20:34:14
    使用python绘制混淆矩阵 # 可视化分类器性能 # load libraries import matplotlib.pyplot as plt import seaborn as sns from sklearn import datasets from sklearn.linear_model import LogisticRegression from ...
  • 文章目录使用python绘制混淆矩阵(可直接复制调用) 使用python绘制混淆矩阵(可直接复制调用) 转自https://www.jianshu.com/p/13debf42fdb7 import matplotlib.pyplot as plt from sklearn.metrics import ...
  • 我在调用matplotlib包交叉矩阵时,出现如下错误。 相关代码如下: # 定义混淆矩阵画图函数 def plot_confusion_matrix(cm, # 混淆矩阵 target_names, # 标签名 ... cmap='Blues', # 这个地方设置混淆矩阵的颜色主
  • python 混淆矩阵可视化

    千次阅读 2019-10-01 18:37:11
    python 混淆矩阵 可视化
  • 这样的混淆矩阵,之前我们讨论过怎么将其放到latex中,这里讨论下,怎么设置四舍五入,怎么更改坐标,怎么限制显示阈值。比如上面这张图,小于15的就不显示。我们的数据来源是一个matlab的.mat文件,读入后会自动...
  • 1. 在计算出混淆矩阵之后,想自己绘制图形(并且在图形上显示汉字),可用 #coding=utf-8 import matplotlib.pyplot as plt import numpy as np confusion = np.array(([91,0,0],[0,92,1],[0,0,95])) # 热度图,...
  • 二分类任务,在最后的实验部分需要画混淆矩阵,来说明实验的结果。 import matplotlib.pyplot as plt guess = ["normal","cancer"] fact = [ "normal","cancer"] classes = list(set(fact)) classes.sort...
  • 画混淆矩阵sklearn

    2021-10-14 10:50:37
    画混淆矩阵,需要(真实标签,预测标签,标签列表) y_test, y_pred, display_labels 混淆矩阵用: sklearn库中的confusion_matrix 混淆矩阵画图用: sklearn库中的ConfusionMatrixDisplay matplotlib库中的...
  • 根据需要修改矩阵里面的数据即可 import seaborn as sns from sklearn.metrics import confusion_matrix import matplotlib.pyplot as plt import numpy as np def plot(matrix): sns.set() f,ax=plt.subplots() ...
  • Python 绘制混淆矩阵(Confusion Matrix)

    千次阅读 2013-06-25 17:07:29
    import numpy as np import matplotlib.pyplot as plt from pylab import * conf_arr=[[13,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,4,0,5,0,1,0,0,], ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,309
精华内容 923
关键字:

python画混淆矩阵

python 订阅