[Python人工智能] 十三.如何评价神经网络、loss曲线图绘制、图像分类案例的F值计算

从本专栏开始,作者正式开始研究Python深度学习、神经网络及人工智能相关知识。前一篇文章详细讲解了循环神经网络RNN和长短期记忆网络LSTM的原理知识,并采用TensorFlow实现手写数字识别的RNN分类案例。本文将分享如何评价神经网络,绘制训练过程中的loss曲线,并结合图像分类案例讲解精确率、召回率和F值的计算过程。本文可以指导您撰写简单的深度学习论文,希望对您有所帮助。

本专栏主要结合作者之前的博客、AI经验和相关视频(强推"莫烦大神"视频)及论文介绍,后面随着深入会讲解更多的Python人工智能案例及应用。基础性文章,希望对您有所帮助,如果文章中存在错误或不足之处,还请海涵~作者作为人工智能的菜鸟,希望大家能与我在这一笔一划的博客中成长起来。写了这么多年博客,尝试第一个付费专栏,但更多博客尤其基础性文章,还是会继续免费分享,但该专栏也会用心撰写,望对得起读者,共勉!

在这里插入图片描述

代码下载地址:https://github.com/eastmountyxz/AI-for-TensorFlow
CSDN下载地址:
PS:百度网盘链接总被下线,需要的私聊我,或从CSDN、Github下载。

同时推荐前面作者另外三个Python系列文章。从2014年开始,作者主要写了三个Python系列文章,分别是基础知识、网络爬虫和数据分析。2018年陆续增加了Python图像识别和Python人工智能专栏。

在这里插入图片描述

前文:
[Python人工智能] 一.TensorFlow2.0环境搭建及神经网络入门
[Python人工智能] 二.TensorFlow基础及一元直线预测案例
[Python人工智能] 三.TensorFlow基础之Session、变量、传入值和激励函数
[Python人工智能] 四.TensorFlow创建回归神经网络及Optimizer优化器
[Python人工智能] 五.Tensorboard可视化基本用法及绘制整个神经网络
[Python人工智能] 六.TensorFlow实现分类学习及MNIST手写体识别案例
[Python人工智能] 七.什么是过拟合及dropout解决神经网络中的过拟合问题
[Python人工智能] 八.卷积神经网络CNN原理详解及TensorFlow编写CNN
[Python人工智能] 九.gensim词向量Word2Vec安装及《庆余年》中文短文本相似度计算
[Python人工智能] 十.Tensorflow+Opencv实现CNN自定义图像分类案例及与机器学习KNN图像分类算法对比
[Python人工智能] 十一.Tensorflow如何保存神经网络参数
[Python人工智能] 十二.循环神经网络RNN和LSTM原理详解及TensorFlow编写RNN分类案例


一. 神经网络评价指标

由于各种问题影响,会导致神经网络的学习效率不高,或者干扰因素太多导致分析结果不理想。这些因素可能是数据问题、学习参数问题、算法效率问题等。

那么,如何评价(Evaluate)神经网络呢?我们可以通过一些指标对神经网络进行评价,通过评价来改进神经网络。评价神经网络的方法和评价机器学习的方法大同小异,常见的包括误差、准确率、R2 score、F值等。


1.误差(Error)

先用误差评价神经网络,如下图所示,随着训练时间增长,预测误差会不断减小,得到更为准确的答案,最后误差会趋近于水平。

在这里插入图片描述


2.正确率(Accuracy)

正确率(精准度)是指预测正确结果与真实结果的比例,接近100%是最好的结果。例如,分类神经网络100个样本中有90个分类正确,则其预测正确率为90%。

在这里插入图片描述

正确率对应的是误检率(false positve),假设100个样本中误捡个数为10,则误检率10%(10/100)。


3.准确率、召回率和F值
在机器学习和深度学习中,经常会用到准确率、召回率和F值评价算法。

在这里插入图片描述

上图为一个二分类的混淆矩阵(多分类同理,只需要把不属于当前类的其他类都考虑为负例),表格中的四个参数说明:

  • True Positive(TP):正确预测出的正样本个数(预测为正例,实际为正例)
  • False Positive(FP):错误预测出的正样本个数(本来是负样本,被预测成正样本)
  • True Negative(TN):正确预测出的负样本个数(预测为负例,实际为负例)
  • False Negative(FN):错误预测出的负样本个数(本来是正样本,被预测成负样本)

其中,TP和TN都是预测正确,FP和FN都是预测错误。


正确率(accuracy): 它是最常见的评价指标,正确预测的样本数占总预测样本数的比值,它不考虑预测的样本是正例还是负例。

accuracy=TP+TNTP+TN+FP+FN accuracy = \frac {TP+TN} {TP+TN+FP+FN}

错误率(error rate): 又称为误检率,错误率则与正确率相反,描述被分类器错分的比例。对某一个实例来说,分对与分错是互斥事件,所以 accuracy = 1 - error rate。

error rate=FP+FNTP+TN+FP+FN error \ rate = \frac {FP+FN} {TP+TN+FP+FN}

准确率(precision): 准确率是精确性的度量,表示正确预测的正样本数占所有预测为正样本的数量的比值,也就是说所有预测为正样本的样本中有多少是真正的正样本。注意,precision只关注预测为正样本的部分,而accuracy考虑全部样本。

precision=TPTP+FP precision = \frac {TP} {TP+FP}

召回率(recall): 又称为查全率,是覆盖面的度量,表示正确预测的正样本数占真实正样本总数的比值,也就是能从这些样本中能够正确找出多少个正样本。

recall=TPTP+FN recall = \frac {TP} {TP+FN}

F值(F-score): 有时候precision和recall指标会存在矛盾的现象,此时就需要调用F-score或F-measure指标,它是precision和recall的调和平均值,能够均衡的评价算法。在公式中,precision和recall任何一个数值减小,F-score都会减小;反之亦然。

Fscore=2precisionrecallprecision+recall F-score = \frac {2*precision*recall} {precision+recall}

灵敏度(sensitive): 表示所有正例中被分对的比例,衡量了分类器对正例的识别能力。

sensitive=TPTP+FN=recall sensitive = \frac {TP} {TP+FN}=recall

特效度(specificity): 表示所有负例中被分对的比例,衡量了分类器对负例的识别能力。

specificity=TNTN+FP specificity = \frac {TN} {TN+FP}

ROC和AUC是评价分类器的指标,这部分后续文章作深入分享。


4.R2 Score

前面讲解了分类和聚类问题的评价,那如果是回归问题呢?又如何评价连续值的精准度呢?这里我们使用MSE、MAE、R2 Score等值来衡量。其基本思想是:测试数据集中的点,距离模型的平均距离越小,该模型越精确。

在评价回归模型时,sklearn中提供了四种评价尺度,分别为mean_squared_error、mean_absolute_error、explained_variance_score 和 r2_score。


(1) 均方差(mean_squared_error):

MSE(y,y^)=1nsamplesi=0nsamples1(yiyi^)2 MSE(y,\hat y) = \frac {1} {n_{samples}} \sum_{i=0}^{n_{samples}-1} {(y_i - \hat {y_i})}{^2}

(2) 平均绝对值误差(mean_absolute_error):

MAE(y,y^)=1nsamplesi=0nsamples1(yiyi^) MAE(y,\hat y) = \frac {1} {n_{samples}} \sum_{i=0}^{n_{samples}-1} \left|{(y_i - \hat {y_i})} \right|

(3) 可释方差得分(explained_variance_score):

explained variance(y,y^)=1Var(yy^)y explained \ variance(y,\hat y) = 1 - \frac {Var{ (y - \hat {y})}} {y}

(4) 中值绝对误差(Median absolute error)

MedAE(y,y^)=median((y1y1^),...,(ynyn^)) MedAE(y,\hat y) = median(\left|{(y_1 - \hat {y_1})} \right|,...,\left|{(y_n - \hat {y_n})} \right|)

(5) R2决定系数(拟合优度)

R2(y,y^)=1i=0nsamples1(yiyi^)2i=0nsamples1(yiyi)2 R^2(y,\hat y) = 1 - \frac {\sum_{i=0}^{n_{samples}-1} {(y_i - \hat {y_i})}{^2}} {\sum_{i=0}^{n_{samples}-1} {(y_i - \overline{y_i})}{^2}}

模型越好:r2→1,模型越差:r2→0。
在这里插入图片描述

Sklearn代码调用如下:

from sklearn.metrics import r2_score
 
y_true = [1,2,4]
y_pred = [1.3,2.5,3.7]
r2_score(y_true,y_pred)

5.交叉验证
神经网络中有很多参数,我们怎么确定哪些参数能更有效解决现有问题呢?这时候交叉验证是最好的途径。交叉验证不仅可以用于神经网络调参,还可以用于其他机器学习的调参。例如:X轴为学习率(Learning rate)、神经网络层数(N-layers),Y轴为Error或精确度,不同神经层数对应的误差值或精准度也不同。

在这里插入图片描述

由于神经层数目越多,计算机消耗的时间也会增加,所以只需要找到满足误差要求又能节约时间的层结构即可。例如,当误差在0.005以下时都能接收时,则采用30层(N-layers=30)的结构即可。

在这里插入图片描述


二.图像分类loss曲线绘制

我们在阅读论文或实践项目中,可能会看到很多评价神经网络训练的曲线,当神经网络训练好了,我们才用它来进行预测及分析。前面第五篇文章Tensorboard也讲解了可视化曲线的绘制方法,而这部分将采用最原始的方法告诉大家loss曲线和accuracy曲线如何跟随神经网络迭代次数变化的,所生成的图是可以直接应用到我们论文中的。希望对您有所帮助~


1.数据集介绍

首先,实验所采用的数据集为Sort_1000pics数据集,该数据集包含了1000张图片,总共分为10大类,分别是人(第0类)、沙滩(第1类)、建筑(第2类)、大卡车(第3类)、恐龙(第4类)、大象(第5类)、花朵(第6类)、马(第7类)、山峰(第8类)和食品(第9类),每类100张。如图所示。

在这里插入图片描述

接着将所有各类图像按照对应的类标划分至“0”至“9”命名的文件夹中,如图所示,每个文件夹中均包含了100张图像,对应同一类别。

在这里插入图片描述

比如,文件夹名称为“6”中包含了100张花的图像,如下图所示。

在这里插入图片描述


2.训练过程

接着是图像分类的CNN代码,这里就不再介绍了,请参考前面的文章和详细注释。
[Python人工智能] 十.Tensorflow+Opencv实现CNN自定义图像分类案例及与机器学习KNN图像分类算法对比

完整代码:

# -*- coding: utf-8 -*-
"""
Created on Tue Jan  7 13:39:19 2020
@author: xiuzhang Eastmount CSDN
"""
import os
import glob
import cv2
import numpy as np
import tensorflow as tf

# 定义图片路径
path = 'photo/'

#---------------------------------第一步 读取图像-----------------------------------
def read_img(path):
    cate = [path + x for x in os.listdir(path) if os.path.isdir(path + x)]
    imgs = []
    labels = []
    fpath = []
    for idx, folder in enumerate(cate):
        # 遍历整个目录判断每个文件是不是符合
        for im in glob.glob(folder + '/*.jpg'):
            #print('reading the images:%s' % (im))
            img = cv2.imread(im)             #调用opencv库读取像素点
            img = cv2.resize(img, (32, 32))  #图像像素大小一致
            imgs.append(img)                 #图像数据
            labels.append(idx)               #图像类标
            fpath.append(path+im)            #图像路径名
            #print(path+im, idx)
    return np.asarray(fpath, np.string_), np.asarray(imgs, np.float32), np.asarray(labels, np.int32)

# 读取图像
fpaths, data, label = read_img(path)
print(data.shape)  # (1000, 256, 256, 3)
# 计算有多少类图片
num_classes = len(set(label))
print(num_classes)

# 生成等差数列随机调整图像顺序
num_example = data.shape[0]
arr = np.arange(num_example)
np.random.shuffle(arr)
data = data[arr]
label = label[arr]
fpaths = fpaths[arr]

# 拆分训练集和测试集 80%训练集 20%测试集
ratio = 0.8
s = np.int(num_example * ratio)
x_train = data[:s]
y_train = label[:s]
fpaths_train = fpaths[:s] 
x_val = data[s:]
y_val = label[s:]
fpaths_test = fpaths[s:] 
print(len(x_train),len(y_train),len(x_val),len(y_val)) #800 800 200 200
print(y_val)

#---------------------------------第二步 建立神经网络-----------------------------------
# 定义Placeholder
xs = tf.placeholder(tf.float32, [None, 32, 32, 3])  #每张图片32*32*3个点
ys = tf.placeholder(tf.int32, [None])               #每个样本有1个输出
# 存放DropOut参数的容器 
drop = tf.placeholder(tf.float32)                   #训练时为0.25 测试时为0

# 定义卷积层 conv0
conv0 = tf.layers.conv2d(xs, 20, 5, activation=tf.nn.relu)    #20个卷积核 卷积核大小为5 Relu激活
# 定义max-pooling层 pool0
pool0 = tf.layers.max_pooling2d(conv0, [2, 2], [2, 2])        #pooling窗口为2x2 步长为2x2
print("Layer0:\n", conv0, pool0)
 
# 定义卷积层 conv1
conv1 = tf.layers.conv2d(pool0, 40, 4, activation=tf.nn.relu) #40个卷积核 卷积核大小为4 Relu激活
# 定义max-pooling层 pool1
pool1 = tf.layers.max_pooling2d(conv1, [2, 2], [2, 2])        #pooling窗口为2x2 步长为2x2
print("Layer1:\n", conv1, pool1)

# 将3维特征转换为1维向量
flatten = tf.layers.flatten(pool1)

# 全连接层 转换为长度为400的特征向量
fc = tf.layers.dense(flatten, 400, activation=tf.nn.relu)
print("Layer2:\n", fc)

# 加上DropOut防止过拟合
dropout_fc = tf.layers.dropout(fc, drop)

# 未激活的输出层
logits = tf.layers.dense(dropout_fc, num_classes)
print("Output:\n", logits)

# 定义输出结果
predicted_labels = tf.arg_max(logits, 1)

#---------------------------------第三步 定义损失函数和优化器---------------------------------

# 利用交叉熵定义损失
losses = tf.nn.softmax_cross_entropy_with_logits(
        labels = tf.one_hot(ys, num_classes),       #将input转化为one-hot类型数据输出
        logits = logits)

# 平均损失
mean_loss = tf.reduce_mean(losses)

# 定义优化器 学习效率设置为0.0001
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(losses)

#------------------------------------第四步 模型训练和预测-----------------------------------
# 用于保存和载入模型
saver = tf.train.Saver()
# 训练或预测
train = True
# 模型文件路径
model_path = "model/image_model"

with tf.Session() as sess:
    if train:
        print("训练模式")
        # 训练初始化参数
        sess.run(tf.global_variables_initializer())
        # 定义输入和Label以填充容器 训练时dropout为0.25
        train_feed_dict = {
                xs: x_train,
                ys: y_train,
                drop: 0.25
        }
        # 训练学习1000次
        for step in range(1000):
            _, mean_loss_val = sess.run([optimizer, mean_loss], feed_dict=train_feed_dict)
            if step % 20 == 0:  #每隔20次输出一次结果
                # 训练准确率
                pre = sess.run(predicted_labels, feed_dict=train_feed_dict)
                accuracy = 1.0*sum(y_train==pre) / len(pre)
                print("{},{},{}".format(step, mean_loss_val,accuracy))
        # 保存模型
        saver.save(sess, model_path)
        print("训练结束,保存模型到{}".format(model_path))
    else:
        print("测试模式")
        # 测试载入参数
        saver.restore(sess, model_path)
        print("从{}载入模型".format(model_path))
        # label和名称的对照关系
        label_name_dict = {
            0: "人类",
            1: "沙滩",
            2: "建筑",
            3: "公交",
            4: "恐龙",
            5: "大象",
            6: "花朵",
            7: "野马",
            8: "雪山",
            9: "美食"
        }
        # 定义输入和Label以填充容器 测试时dropout为0
        test_feed_dict = {
            xs: x_val,
            ys: y_val,
            drop: 0
        }
        
        # 真实label与模型预测label
        predicted_labels_val = sess.run(predicted_labels, feed_dict=test_feed_dict)
        for fpath, real_label, predicted_label in zip(fpaths_test, y_val, predicted_labels_val):
            # 将label id转换为label名
            real_label_name = label_name_dict[real_label]
            predicted_label_name = label_name_dict[predicted_label]
            print("{}\t{} => {}".format(fpath, real_label_name, predicted_label_name))
        # 评价结果
        print("正确预测个数:", sum(y_val==predicted_labels_val))
        print("准确度为:", 1.0*sum(y_val==predicted_labels_val) / len(y_val))
        k = 0
        while k < len(y_val):
            print(y_val[k], predicted_labels_val[k])
            k = k + 1

当train=True时,训练过程会输出误差和accuracy值,核心代码如下:

在这里插入图片描述

输出结果如下所示,分别代表训练次数、整体误差和正确率。我们将其复制到TXT文件中,再重新写一个py代码绘图。

(1000, 32, 32, 3)
10
800 800 200 200
[4 4 3 0 0 0 8 3 8 6 7 1 7 7 9 0 4 7 0 6 0 7 7 0 9 5 4 3 5 1 2 2 8 2 8 5 1
 7 8 7 1 7 7 2 6 4 0 9 0 6 1 1 2 7 4 3 9 6 2 2 1 2 3 3 4 1 6 0 5 3 0 4 8 1
 8 1 6 5 9 3 6 9 8 4 2 7 2 9 2 0 3 3 0 8 6 5 0 4 4 2 7 2 4 4 3 5 9 6 8 0 9
 0 4 6 9 9 3 5 0 9 8 1 4 1 8 5 3 2 6 5 1 9 0 2 1 9 9 3 0 8 5 7 8 8 3 4 4 4
 0 5 6 2 8 1 5 5 8 9 7 2 0 8 6 1 5 8 9 9 2 8 2 6 0 7 8 0 2 1 9 0 4 3 1 9 0
 0 4 3 3 3 3 1 8 8 1 5 9 8 0 9]
 
训练模式
0,62.20244216918945,0.12
20,8.619616508483887,0.3625
40,3.896609306335449,0.545
...
940,0.0003522337938193232,1.0
960,0.00033640244510024786,1.0
980,0.00032152896164916456,1.0
训练结束,保存模型到model/image_model

3.绘制loss和accuracy曲线

首先读取“train_data.txt”数据集,采用逗号连接,再绘制折线图即可。

import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import host_subplot

# 读取文件数据
fp = open('train_data.txt', 'r')

# 迭代次数 整体误差 正确率
train_iterations = []
train_loss = []
test_accuracy = []

# 解析数据
for line in fp.readlines():
    con = line.strip('\n').split(',')
    print(con)
    train_iterations.append(int(con[0]))
    train_loss.append(float(con[1]))
    test_accuracy.append(float(con[2]))

# 绘制曲线图
host = host_subplot(111)
plt.subplots_adjust(right=0.8) # ajust the right boundary of the plot window
par1 = host.twinx()

# 设置类标
host.set_xlabel("iterations")
host.set_ylabel("loss")
par1.set_ylabel("validation accuracy")

# 绘制曲线
p1, = host.plot(train_iterations, train_loss, "b-", label="training loss")
p2, = host.plot(train_iterations, train_loss, ".") #曲线点
p3, = par1.plot(train_iterations, test_accuracy, label="validation accuracy")
p4, = par1.plot(train_iterations, test_accuracy, "1")

# 设置图标
# 1->rightup corner, 2->leftup corner, 3->leftdown corner
# 4->rightdown corner, 5->rightmid ...
host.legend(loc=5)

# 设置颜色
host.axis["left"].label.set_color(p1.get_color())
par1.axis["right"].label.set_color(p3.get_color())

# 设置范围
host.set_xlim([-10, 1000])

plt.draw()
plt.show()

输出结果如下图所示,可以看到整体误差趋近于0.0003拟合,正确率朝着100%接近,整个神经网络的学习效率不错。

在这里插入图片描述


三.图像分类准确率、召回率、F值计算

1.预测

接下来将CNN神经网络中的train标记变量设置为False,使用上一步训练好的神经网络进行预测。核心代码如下:

在这里插入图片描述

输出结果如下所示,其中在200测试样本中,正确预测个数181,正确度为0.905。

(1000, 32, 32, 3)
10
800 800 200 200
[9 4 8 7 0 7 5 7 1 4 9 3 0 5 8 0 0 2 5 8 7 4 7 8 8 9 4 1 6 7 8 4 8 4 9 9 6
 1 6 7 9 8 6 3 1 8 7 8 0 4 6 9 8 5 2 6 0 0 1 9 9 6 8 1 5 9 1 1 6 0 1 7 2 1
 7 1 8 7 9 7 7 5 1 0 6 0 1 5 5 0 7 5 8 6 7 7 5 0 9 7 8 9 7 3 0 9 2 4 7 9 1
 7 0 2 2 5 6 5 1 0 9 5 9 7 0 6 2 5 4 4 2 6 8 6 2 5 7 1 5 0 0 4 5 7 9 3 5 5
 4 6 1 3 9 9 7 5 6 9 2 3 3 2 4 1 4 8 2 7 3 4 3 9 1 5 7 6 4 2 6 4 0 0 4 5 1
 7 2 4 6 6 2 4 1 7 5 0 6 8 3 7]
 
测试模式
INFO:tensorflow:Restoring parameters from model/image_model
从model/image_model载入模型
b'photo/photo/9\\960.jpg'       美食 => 美食
b'photo/photo/4\\414.jpg'       恐龙 => 恐龙
b'photo/photo/8\\809.jpg'       雪山 => 雪山
b'photo/photo/7\\745.jpg'       野马 => 大象
b'photo/photo/0\\12.jpg'        人类 => 人类
...
b'photo/photo/0\\53.jpg'        人类 => 人类
b'photo/photo/6\\658.jpg'       花朵 => 花朵
b'photo/photo/8\\850.jpg'       雪山 => 雪山
b'photo/photo/3\\318.jpg'       公交 => 美食
b'photo/photo/7\\796.jpg'       野马 => 野马
正确预测个数: 181
准确度为: 0.905

9 9
4 4
8 8
...
6 6
8 8
3 9
7 7

2.计算

同样,我们将预测的结果和正确的类标复制到TXT文件中,然后计算其准确率、召回率、F值。基本步骤:

  • 读取数据集
  • 分别计算0-9类(共10类)不同类标正确识别的个数和总识别的个数
  • 按照第一部分的公式计算准确率、召回率和F值
  • 调用matplotlib库绘制对比柱状图

比如,测试集实际有20张人类图片,预测出18张人类图片,正确的类标14,则准确率为14/18,召回率为14/20。

在这里插入图片描述

最终绘制图形如下:

在这里插入图片描述

完整代码如下:

# -*- coding: utf-8 -*-
"""
Created on Tue Jan  7 13:39:19 2020
@author: xiuzhang Eastmount CSDN
"""
import numpy as np
import matplotlib.pyplot as plt

#--------------------------------------------------------------------------
# 第一部分 计算准确率 召回率 F值
#--------------------------------------------------------------------------

# 读取文件数据
fp = open('test_data.txt', 'r')

# 迭代次数 整体误差 正确率
real = []
pre = []

# 解析数据
for line in fp.readlines():
    con = line.strip('\n').split(' ')
    #print(con)
    real.append(int(con[0])) #真实类标
    pre.append(int(con[1]))  #预测类标

# 计算各类结果 共10类图片
real_10 = list(range(0, 10))   #真实10个类标数量的统计
pre_10 = list(range(0, 10))    #预测10个类标数量的统计
right_10 = list(range(0, 10))  #预测正确的10个类标数量

k = 0
while k < len(real):
    v1 = int(real[k])
    v2 = int(pre[k])
    print(v1, v2)
    real_10[v1] = real_10[v1] + 1     # 计数
    pre_10[v2] = pre_10[v2] + 1       # 计数
    if v1==v2:
        right_10[v1] = right_10[v1] + 1
    k = k + 1
print("统计各类数量")
print(real_10, pre_10, right_10)

# 准确率 = 正确数 / 预测数
precision = list(range(0, 10))
k = 0
while k < len(real_10):
    value = right_10[k] * 1.0 / pre_10[k] 
    precision[k] = value
    k = k + 1
print(precision)

# 召回率 = 正确数 / 真实数
recall = list(range(0, 10))
k = 0
while k < len(real_10):
    value = right_10[k] * 1.0 / real_10[k] 
    recall[k] = value
    k = k + 1
print(recall)
   
# F值 = 2*准确率*召回率/(准确率+召回率)
f_measure = list(range(0, 10))
k = 0
while k < len(real_10):
    value = (2 * precision[k] * recall[k] * 1.0) / (precision[k] + recall[k])
    f_measure[k] = value
    k = k + 1
print(f_measure)

#--------------------------------------------------------------------------
# 第二部分 绘制曲线
#--------------------------------------------------------------------------

# 设置类别
n_groups = 10
fig, ax = plt.subplots()

index = np.arange(n_groups)
bar_width = 0.2
 
opacity = 0.4
error_config = {'ecolor': '0.3'}

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
 
# 绘制
rects1 = ax.bar(index, precision, bar_width,
                alpha=opacity, color='b',
                error_kw=error_config,
                label='precision')
 
rects2 = ax.bar(index + bar_width, recall, bar_width,
                alpha=opacity, color='m',
                error_kw=error_config,
                label='recall')
 
rects3 = ax.bar(index + bar_width + bar_width, f_measure, bar_width,
                alpha=opacity, color='r',
                error_kw=error_config,
                label='f_measure')
            
# 设置标签
ax.set_xticks(index + 3 * bar_width / 3)
ax.set_xticklabels(('0-人类', '1-沙滩', '2-建筑', '3-公交', '4-恐龙',
                    '5-大象', '6-花朵', '7-野马', '8-雪山', '9-美食'))
# 设置类标
ax.legend()
plt.xlabel("类标")
plt.ylabel("评价")
fig.tight_layout()
plt.savefig('result.png', dpi=200)
plt.show()

输出结果如下所示,读者也可以尝试直接复制下面的precision、recall、f-measure绘制图形。

统计各类数量
[21, 22, 17, 13, 24, 28, 27, 36, 26, 31] 
[19, 23, 18, 12, 24, 30, 29, 34, 25, 31] 
[17, 19, 15, 11, 24, 26, 27, 34, 24, 29]

[0.8947368421052632, 0.8260869565217391, 0.8333333333333334, 0.9166666666666666, 1.0, 
0.8666666666666667, 0.9310344827586207, 1.0, 0.96, 0.9354838709677419]
[0.8095238095238095, 0.8636363636363636, 0.8823529411764706, 0.8461538461538461, 1.0, 
0.9285714285714286, 1.0, 0.9444444444444444, 0.9230769230769231, 0.9354838709677419]
[0.8500000000000001, 0.8444444444444444, 0.8571428571428571, 0.8799999999999999, 1.0, 
0.896551724137931, 0.9642857142857143, 0.9714285714285714, 0.9411764705882353, 0.9354838709677419]

四.总结

写到这里,这篇文章就讲解完毕,更多TensorFlow深度学习文章会继续分享,接下来我们会分享RNN回归、文本识别、图像识别、语音识别等内容。如果读者有什么想学习的,也可以私聊我,我去学习并应用到你的领域。

最后,希望这篇基础性文章对您有所帮助,如果文章中存在错误或不足之处,还请海涵~作为人工智能的菜鸟,我希望自己能不断进步并深入,后续将它应用于图像识别、网络安全、对抗样本等领域,指导大家撰写简单的学术论文,一起加油!

昨晚贵阳的天空也太美了,彩虹中夹杂着闪电,上帝的调色板被打翻啦。下午组会听了师兄分享的出国学习经历,受益匪浅。博士生活远远不止论文和项目,如果这个跑道不能成为人生赢家,就换个跑道,做点自己开心的事!

在这里插入图片描述

PS:这是作者的第一个付费专栏,会非常用心的去撰写,写了八年的免费文章,这也算知识付费的一个简单尝试吧!毕竟读博也不易,写文章也花费时间和精力,但作者更多的文章会免费分享。如果您购买了该专栏,有Python数据分析、图像处理、人工智能、网络安全的问题,我们都可以深入探讨,尤其是做研究的同学,共同进步~

(By:Eastmount 2020-01-07 下午6点夜于珞珈山 http://blog.csdn.net/eastmount/ )


闲谈:
最后希望大家帮我2019年CSDN博客之星投投票,每天可以投5票喔,谢谢大家!八年,在CSDN分享了410篇文章,15个专栏,400多万人次浏览,包括Python人工智能、数据挖掘、网络爬虫、图象处理、网络安全、JAVA网站、Android开发、LAMP/WAMP、C#网络编程、C++游戏、算法和数据结构、面试总结、人生感悟等。当然还有我和你的故事,感恩一路有你,感谢一路同行,希望通过编程分享帮助到更多人,也希望学成之后回贵州教更多学生。因为喜欢,所以分享,且看且珍惜,加油!等我四年学成归来~

投票地址:http://m234140.nofollow.ax.mvote.cn/opage/ed8141a0-ed19-774b-6b0d-39c3aaf89dde.html?from=singlemessage

在这里插入图片描述


作者theano人工智能系列:
[Python人工智能] 一.神经网络入门及theano基础代码讲解
[Python人工智能] 二.theano实现回归神经网络分析
[Python人工智能] 三.theano实现分类神经网络及机器学习基础
[Python人工智能] 四.神经网络和深度学习入门知识
[Python人工智能] 五.theano实现神经网络正规化Regularization处理
[Python人工智能] 六.神经网络的评价指标、特征标准化和特征选择
[Python人工智能] 七.加速神经网络、激励函数和过拟合

参考文献:
[1] 杨秀璋, 颜娜. Python网络数据爬取及分析从入门到精通(分析篇)[M]. 北京:北京航天航空大学出版社, 2018.
[2] “莫烦大神” 网易云视频地址
[3] https://study.163.com/course/courseLearn.htm?courseId=1003209007
[4] https://github.com/siucaan/CNN_MNIST
[5] https://github.com/eastmountyxz/AI-for-TensorFlow
[6]《机器学习》周志华
[7] 神经网络模型的评价指标 - ZHANG ALIN
[8] [深度学习] 分类指标accuracy,recall,precision等的区别 - z小白
[9] 分类指标准确率(Precision)和正确率(Accuracy)的区别 - mxp_neu
[10] 学习笔记2:scikit-learn中使用r2_score评价回归模型 - Softdiamonds
[11] 方差、协方差、标准差、均方差、均方根值、均方误差、均方根误差对比分析 - cqfdcw
[12] 机器学习:衡量线性回归法的指标(MSE、RMSE、MAE、R Squared)- volcao


发布了416 篇原创文章 · 获赞 5065 · 访问量 424万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览

应支付9.90元
点击重新获取
扫码支付

支付成功即可阅读