[Python人工智能] 十三.如何评价神经网络、loss曲线图绘制、图像分类案例的F值计算 丨【百变AI秀】
从本专栏开始，作者正式开始研究Python深度学习、神经网络及人工智能相关知识。前一篇文章详细讲解了循环神经网络RNN和长短期记忆网络LSTM的原理知识，并采用TensorFlow实现手写数字识别的RNN分类案例。本文将分享如何评价神经网络，绘制训练过程中的loss曲线，并结合图像分类案例讲解精确率、召回率和F值的计算过程。本文可以指导您撰写简单的深度学习论文，希望对您有所帮助。
本专栏主要结合作者之前的博客、AI经验和相关视频（强推"莫烦大神"视频）及论文介绍，后面随着深入会讲解更多的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分类案例
- [Python人工智能] 十三.如何评价神经网络、loss曲线图绘制、图像分类案例的F值计算 丨【百变AI秀】
由于各种问题影响，会导致神经网络的学习效率不高，或者干扰因素太多导致分析结果不理想。这些因素可能是数据问题、学习参数问题、算法效率问题等。
那么，如何评价（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 = \frac {TP+TN} {TP+TN+FP+FN}
错误率（error rate）： 又称为误检率，错误率则与正确率相反，描述被分类器错分的比例。对某一个实例来说，分对与分错是互斥事件，所以 accuracy = 1 - error rate。
error \ rate = \frac {FP+FN} {TP+TN+FP+FN}
准确率（precision）： 准确率是精确性的度量，表示正确预测的正样本数占所有预测为正样本的数量的比值，也就是说所有预测为正样本的样本中有多少是真正的正样本。注意，precision只关注预测为正样本的部分，而accuracy考虑全部样本。
precision = \frac {TP} {TP+FP}
召回率（recall）： 又称为查全率，是覆盖面的度量，表示正确预测的正样本数占真实正样本总数的比值，也就是能从这些样本中能够正确找出多少个正样本。
recall = \frac {TP} {TP+FN}
F值（F-score）： 有时候precision和recall指标会存在矛盾的现象，此时就需要调用F-score或F-measure指标，它是precision和recall的调和平均值，能够均衡的评价算法。在公式中，precision和recall任何一个数值减小，F-score都会减小；反之亦然。
F-score = \frac {2*precision*recall} {precision+recall}
灵敏度（sensitive）： 表示所有正例中被分对的比例，衡量了分类器对正例的识别能力。
sensitive = \frac {TP} {TP+FN}=recall
特效度（specificity)： 表示所有负例中被分对的比例，衡量了分类器对负例的识别能力。
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,\hat y) = \frac {1} {n_{samples}} \sum_{i=0}^{n_{samples}-1} {(y_i - \hat {y_i})}{^2}
(2) 平均绝对值误差（mean_absolute_error）：
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,\hat y) = 1 - \frac {Var{ (y - \hat {y})}} {y}
(4) 中值绝对误差（Median absolute error）
MedAE(y,\hat y) = median(\left|{(y_1 - \hat {y_1})} \right|,...,\left|{(y_n - \hat {y_n})} \right|)
(5) R2决定系数（拟合优度）
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）的结构即可。
我们在阅读论文或实践项目中，可能会看到很多评价神经网络训练的曲线，当神经网络训练好了，我们才用它来进行预测及分析。前面第五篇文章Tensorboard也讲解了可视化曲线的绘制方法，而这部分将采用最原始的方法告诉大家loss曲线和accuracy曲线如何跟随神经网络迭代次数变化的，所生成的图是可以直接应用到我们论文中的。希望对您有所帮助~
首先，实验所采用的数据集为Sort_1000pics数据集，该数据集包含了1000张图片，总共分为10大类，分别是人（第0类）、沙滩（第1类）、建筑（第2类）、大卡车（第3类）、恐龙（第4类）、大象（第5类）、花朵（第6类）、马（第7类）、山峰（第8类）和食品（第9类），每类100张。如图所示。
接着将所有各类图像按照对应的类标划分至“0”至“9”命名的文件夹中，如图所示，每个文件夹中均包含了100张图像，对应同一类别。
比如，文件夹名称为“6”中包含了100张花的图像，如下图所示。
接着是图像分类的CNN代码，这里就不再介绍了，请参考前面第十篇文章和详细注释。
完整代码：
# -*- 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
首先读取“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%接近，整个神经网络的学习效率不错。
接下来将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
同样，我们将预测的结果和正确的类标复制到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回归、文本识别、图像识别、语音识别等内容。如果读者有什么想学习的，也可以私聊我，我去学习并应用到你的领域。
最后，希望这篇基础性文章对您有所帮助，如果文章中存在错误或不足之处，还请海涵~作为人工智能的菜鸟，我希望自己能不断进步并深入，后续将它应用于图像识别、网络安全、对抗样本等领域，指导大家撰写简单的学术论文，一起加油！
昨晚贵阳的天空也太美了，彩虹中夹杂着闪电，上帝的调色板被打翻啦。下午组会听了师兄分享的出国学习经历，受益匪浅。博士生活远远不止论文和项目，如果这个跑道不能成为人生赢家，就换个跑道，做点自己开心的事！
感恩能与大家在华为云遇见！
希望能与大家一起在华为云社区共同成长。原文地址：https://blog.csdn.net/Eastmount/article/details/103847406
【百变AI秀】有奖征文火热进行中：https://bbs.huaweicloud.com/blogs/296704
(By:娜璋之家 Eastmount 2021-09-10 夜于武汉)
参考文献：
[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
- 点赞
- 收藏
- 关注作者
评论（0）