念笔记TF029:实现上阶卷积网络。学习笔记TF029:实现上阶卷积网络。

经典数据集CIFAR-10,60000张32×32彩色图像,训练集50000摆放,测试集10000布置。标注10类似,每类图片6000摆设。airplance、automobile、bird、cat、deer、dog、frog、horse、ship、truck。没有另外重叠。CIFAR-100,100看似标注。深度上的父
Geoffrey Hinton和学生Alex Krizhevsky、Vinod Nair收集。图片源于80 million
tiny images数据集。State-of-the-art
3.5%错误率,GPU训练十几钟头。详细Benchmark和行在
http://rodrigob.github.io/are\_we\_there\_yet/build/classification\_datasets\_results.html
。LeCun,现有卷积神经网络已经缓解CIFAR-10数据集问题。

藏数据集CIFAR-10,60000摆32×32彩色图像,训练集50000张,测试集10000摆放。标注10近乎,每类图片6000摆放。airplance、automobile、bird、cat、deer、dog、frog、horse、ship、truck。没有任何重叠。CIFAR-100,100类标注。深度上之父
Geoffrey Hinton和学生Alex Krizhevsky、Vinod Nair收集。图片来自80 million
tiny images数据集。State-of-the-art
3.5%错误率,GPU训练十几小时。详细Benchmark和行在
http://rodrigob.github.io/are\_we\_there\_yet/build/classification\_datasets\_results.html
。LeCun,现有卷积神经网络已经缓解CIFAR-10数据集问题。

冲Alex cuda-convnet模型修改,3000个batch,每个batch
128个样本,达到73%正确率。GTX1080才显卡几十秒模型训练日。CPU慢很多。如用100k
batch
结合学习进度decay(每隔一段时间下降学习速率一个率),正确率可至86%。模型训练参数100万只,预测四尽管运算总量2000万蹩脚。对weights进行L2正则化。图片转、随机剪切等数码增长,制造更多样本。每个卷积-最特别池化层后就此LRN层,增强型泛化能力。

基于Alex cuda-convnet模型修改,3000个batch,每个batch
128单样本,达到73%正确率。GTX1080就显卡几十秒模型训练时。CPU慢很多。如用100k
batch
结合上进度decay(每隔一段时间下降学习速率一个比率),正确率可到86%。模型训练参数100万独,预测四虽说运算总量2000万不善。对weights进行L2正则化。图片转、随机剪切等数增长,制造更多样本。每个卷积-最可怜池化层后用LRN层,增强型泛化能力。

下载TensorFlow Models库,使用其中提供CIFAR-10数据类。git clone
https://github.com/tensorflow/models.git。models/tutorials/image/cifar10。

下载TensorFlow Models库,使用中提供CIFAR-10数据类。git clone
https://github.com/tensorflow/models.git。models/tutorials/image/cifar10。

载入常用库,NumPy、time,TensorFlow Models自动下载、读取CIFAR-10数据类。

载入常用库,NumPy、time,TensorFlow Models自动下载、读取CIFAR-10数据类。

定义batch_size,训练轮数max_steps,下载CIFAR-10数据默认路径。

定义batch_size,训练轮数max_steps,下载CIFAR-10数据默认路径。

概念初始化weight函数,tf.truncated_normal截断正态分布初始化权重。Weight加L2
loss ,做L2
正则化。减少特征或处以不重要特色权重,缓解特征了多招了拟合。正则化帮助找到该处的特色权重。为用有特征,需交loss代价。L1刚好则打造稀疏特征,大部分任用特征权重于置0。L2正则为特征权重不过那个,特征权重比平均。wl控制L2
loss大小,tf.nn.l2_loss函数计算weight L2 loss,tf.multiply L2 loss
乘以wl,得最终 weight loss。tf.add_to_collection weight
loss统一在collection losses,计算神经网络总体loss使用。

概念初始化weight函数,tf.truncated_normal截断正态分布初始化权重。Weight加L2
loss ,做L2
正则化。减少特征或惩罚无重要特点权重,缓解特征了多招了拟合。正则化帮助找到该办的特点权重。为运用某特征,需提交loss代价。L1刚刚则打稀疏特征,大部分管用特征权重吃置0。L2正则给特征权重不过大,特征权重于平均。wl控制L2
loss大小,tf.nn.l2_loss函数计算weight L2 loss,tf.multiply L2 loss
乘以wl,得最后 weight loss。tf.add_to_collection weight
loss统一在collection losses,计算神经网络总体loss使用。

于是cifar10看似下充斥数据集,解压、展开到默认位置。

为此cifar10近似下充斥数据集,解压、展开到默认位置。

用cifar10_input类
distorted_inputs函数产生训练多少,包括特征、label,返回封装tensor,每次执行生成一个batch_size数量样本。Data
Augmentation(数据增长),cifar10_input.distorted_inputs函数,随机水平翻转(tf.image.random_flip_left_right)、随机剪切一片24×24图(tf.random_crop)、设置随机亮度对比度(tf.image.random_brightness、tf.image.random_contrast),数据标准(tf.image.per_image_whitening,数据减均值,除方差,保证数据零均值,方差1)。获得更多样本,带噪声,一摆放图纸样本变多摆放图纸,扩大样本量,提高准确率。数据增长操作消耗大量CPU时间,distored_inputs用16个单身线程加速任务,函数内部生线程池,通过TensorFlow
queue调度。

用cifar10_input类
distorted_inputs函数产生训练多少,包括特征、label,返回封装tensor,每次执行生成一个batch_size数量样本。Data
Augmentation(数据增长),cifar10_input.distorted_inputs函数,随机水平翻转(tf.image.random_flip_left_right)、随机剪切一片24×24图(tf.random_crop)、设置随机亮度对比度(tf.image.random_brightness、tf.image.random_contrast),数据标准(tf.image.per_image_whitening,数据减均值,除方差,保证数据零均值,方差1)。获得更多样本,带噪声,一摆放图片样本变多摆放图片,扩大样本量,提高准确率。数据增长操作消耗大量CPU时间,distored_inputs用16个单身线程加速任务,函数内部发生线程池,通过TensorFlow
queue调度。

用cifar10_input.inputs函数生成测试数据,裁剪图片正中间24×24分外小区块,数据标准。

用cifar10_input.inputs函数生成测试数据,裁剪图片正中间24×24不胜小区块,数据标准。

始建输入数据placeholderx,特征、label。设定placeholder数据尺寸,batch_size定义网络布局要为此,数据尺寸第一个值样本条数需要先设定,不能够如None。数据尺寸的图片尺寸为24×24,裁剪后大小,颜色通道数3,彩色RGB三通道。

始建输入数据placeholderx,特征、label。设定placeholder数据尺寸,batch_size定义网络布局要用,数据尺寸第一独值样本条数需要事先设定,不可知如None。数据尺寸的图片尺寸为24×24,裁剪后大小,颜色通道数3,彩色RGB三通道。

先是单卷积层,variable_with_weight_loss
函数创建卷积核参数初始化。卷积核大小5×5,3独颜色通道,64个卷积核,设置weight初始化函数标准差0.05。wl(weight
loss)设0。tf.nn.conv2d函数对输入数据image_holder卷积操作,步长stride设1,padding模式SAME,bias初始化0,卷积结果加bias,用ReLU激活函数非线化。用尺寸3×3,步长2×2尽可怜池化层处理多少,尺寸、步长不相同,增加数据丰富性。tf.nn.lrn函数,LRN,处理结果。

第一独卷积层,variable_with_weight_loss
函数创建卷积核参数初始化。卷积核大小5×5,3只颜色通道,64只卷积核,设置weight初始化函数标准差0.05。wl(weight
loss)设0。tf.nn.conv2d函数对输入数据image_holder卷积操作,步长stride设1,padding模式SAME,bias初始化0,卷积结果加bias,用ReLU激活函数非线化。用尺寸3×3,步长2×2顶要命池化层处理数据,尺寸、步长不同等,增加数量丰富性。tf.nn.lrn函数,LRN,处理结果。

LRN起于Alex用CNN参加ImageNet比赛论文。LRN模仿生物神经系统侧抑制机制,对片神经元活动创造竞争环境,响应较充分价值变得相对还怪,抑制其他报告较小神经元,增强型泛化能力。用LRN后CNN
Top1错误率降低1.4%。LRN对无上限边界激活函数ReLU有因此,从附近多单卷积核响应(Response)挑选较充分报告,不符合固定边界会杀了大值激活函数Sigmoid。

LRN起于Alex用CNN参加ImageNet比赛论文。LRN模仿生物神经系统侧抑制机制,对片神经元活动开创竞争环境,响应较生价值变得相对还甚,抑制其他报告较小神经元,增强型泛化能力。用LRN后CNN
Top1错误率降低1.4%。LRN对管上限边界激活函数ReLU有因此,从邻近多只卷积核响应(Response)挑选较充分报告,不相符固定边界会遏制了大值激活函数Sigmoid。

次只卷积层,卷积核尺寸第三维度输入通道数64,bias值全初始化0.1。先进行LRN层处理,再就此极可怜池化层。

老二只卷积层,卷积核尺寸第三维度输入通道数64,bias值全初始化0.1。先进行LRN层处理,再就此最特别池化层。

全连接层,把前面两独卷积层输出结果一切flatten,tf.reshape函数把每个样本变成一维向量。get_shape函数获取数据扁平化长度。variable_with_weight_loss函数初始化全连接层weight,隐含节点384,正态分布标准差0.04,bias初始化0.1。设非零weight
loss值0.04,所有参数为L2正则约,避免了拟合。ReLU激活函数非线性化。

全连接层,把前两个卷积层输出结果一切flatten,tf.reshape函数把每个样本变成一维向量。get_shape函数获取数据扁平化长度。variable_with_weight_loss函数初始化全连接层weight,隐含节点384,正态分布标准差0.04,bias初始化0.1。设非零weight
loss值0.04,所有参数为L2正则约,避免过拟合。ReLU激活函数非线性化。

亚个全连接层,隐含节点192。

其次单全连接层,隐含节点192。

最后一重叠,先创造weight,正态分布标准差设上等同隐含层节点数倒数,不计入L2恰恰则。Softmax操作放在计算loss部分,不待对inference输出softmax处理,就可取得最后分类,直接比较inference输出各类数值大小。

终极一交汇,先创造weight,正态分布标准差设上亦然隐含层节点数倒数,不计入L2刚刚则。Softmax操作放在计算loss部分,不需对inference输出softmax处理,就可抱最后分类,直接比较inference输出各类数值大小。

一体卷积神经网络从输入到输出流程。设计CNN,安排卷积层、池化层、全连接层分布与一一,超参数设置、Trick使用。卷积神经网络结构:
conv1:卷积层和ReLU激活函数
pool1:最深池化
norm1:LRN
conv2:卷积层和ReLU激活函数
norm2:LRN
pool2:最特别池化
local3:全连接层和ReLU激活函数
local4:全连接层和ReLU激活函数
logits:模型Inference输出结果

漫卷积神经网络从输入到输出流程。设计CNN,安排卷积层、池化层、全连接层分布与一一,超参数设置、Trick使用。卷积神经网络结构:
conv1:卷积层和ReLU激活函数
pool1:最可怜池化
norm1:LRN
conv2:卷积层和ReLU激活函数
norm2:LRN
pool2:最老池化
local3:全连接层和ReLU激活函数
local4:全连接层和ReLU激活函数
logits:模型Inference输出结果

计量CNN loss。softmax计算和cross entropy loss
计算合在一起,tf.nn.sparse_softmax_cross_entropy_with_logits。tf.reduce_mean计算cross
entropy均值,tf.add_to_collection 添加cross entropy loss 到整体losses
collection。tf.add_n整体losses collection
全部loss求和,得最后loss,包括cross entropy loss,和后个别单连层weight
L2 loss。Logits节点、label_placeholder传入loss小孩子数,获得最后loss。

计量CNN loss。softmax计算和cross entropy loss
计算合在一起,tf.nn.sparse_softmax_cross_entropy_with_logits。tf.reduce_mean计算cross
entropy均值,tf.add_to_collection 添加cross entropy loss 到整体losses
collection。tf.add_n整体losses collection
全部loss求和,得最后loss,包括cross entropy loss,和后少于个连层weight
L2 loss。Logits节点、label_placeholder传入loss小孩子数,获得最终loss。

优化器选择Adam Optimizer,学习速率1e-3。

优化器选择Adam Optimizer,学习速率1e-3。

tf.nn.in_top_k函数要输出结果top k准确率,默认top
1,输出分类最高近乎准确率。

tf.nn.in_top_k函数要输出结果top k准确率,默认top
1,输出分类最高近乎准确率。

tf.InteractiveSession创建默认session ,初始化全部模参数。

tf.InteractiveSession创建默认session ,初始化全部型参数。

启航图片数增长线程队列,16只线程加速。

起步图片数增长线程队列,16个线程加速。

训练。每个step训练过程,session run方法执行images_train、
labels_train计算,获得batch训练多少,传入train_op和loss计算。记录每个step时间,每隔10独step计算展示时loss、每秒钟训练样本数量、训练batch数据时,监控所有训练过程。GTX
1080,每秒训练1800只样本,batch_size 128,每个batch
0.066s。损失爱博体育loss,开始4.6,3000步训练下降到1.0。

教练。每个step训练过程,session run方法执行images_train、
labels_train计算,获得batch训练多少,传入train_op和loss计算。记录每个step时间,每隔10个step计算展示时loss、每秒钟训练样本数量、训练batch数据时,监控整个训练过程。GTX
1080,每秒训练1800独样本,batch_size 128,每个batch
0.066s。损失loss,开始4.6,3000步训练下降至1.0。

评测模型测试集准确率。测试集10000个样本,使用固定batch_size,逐个batch输入测试数据。计算全部样书评测完batch数量。每个step用session
run方法赢得images_test、labels_test的batch,执行top_k_op计算模型
batch top
1预测是样本数。汇总所有预测是结果,求所有测试样本预测是数量。

评测模型测试集准确率。测试集10000个样本,使用固定batch_size,逐个batch输入测试数据。计算全部样本评测完batch数量。每个step用session
run方法赢得images_test、labels_test的batch,执行top_k_op计算模型
batch top
1预测是样本数。汇总所有预测是结果,求万事测试样本预测是数量。

打印准确率评测结果算。

打印准确率评测结果算。

73%准确率。持续加码max_steps,期望准确率逐渐增加。max_steps较充分,用习速率衰减(decay)的SGD训练,接近86%。L2正则,LRN层提升型准确率,提升框泛化性。

73%准确率。持续增多max_steps,期望准确率逐渐多。max_steps较生,用上速率衰减(decay)的SGD训练,接近86%。L2正则,LRN层提升型准确率,提升框泛化性。

数量增长(Data
Augmentation),给就幅图多多单副本,提高图片利用率,防止图片结构学习过拟合。利用图片本身性能,图片冗余信息量较生,制造不同噪声,依可甄别。神经网络克服噪声准确辨认,泛化性更好。深度上而提供足够多样本,准确率可以穿梭升级。
规模更为老更是繁杂神经网络模型,可以达到准确率水平越来越强,需要重多数据训练。Alex
cuda-convnet测试结果,CIFAR-10,不数增长,错误最低跌至17%,数据增长,错误率下降到11%。

多少增长(Data
Augmentation),给就幅图多多个副本,提高图片利用率,防止图片结构学习过拟合。利用图片本身性能,图片冗余信息量较充分,制造不同噪声,依可辨识。神经网络克服噪声准确识别,泛化性更好。深度上要提供足够多样本,准确率可以不停提升。
规模更怪益繁杂神经网络模型,可以高达准确率水平更强,需要再行多多少训练。Alex
cuda-convnet测试结果,CIFAR-10,不数增长,错误最低跌到17%,数据增长,错误率下降至11%。

    import cifar10,cifar10_input
    import tensorflow as tf
    import numpy as np
    import time
    max_steps = 3000
    batch_size = 128
    data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'
    def variable_with_weight_loss(shape, stddev, wl):
        var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
        if wl is not None:
            weight_loss = tf.multiply(tf.nn.l2_loss(var), wl, name='weight_loss')
            tf.add_to_collection('losses', weight_loss)
        return var
    def loss(logits, labels):
        labels = tf.cast(labels, tf.int64)
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
            logits=logits, labels=labels, name='cross_entropy_per_example')
        cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
        tf.add_to_collection('losses', cross_entropy_mean)
        return tf.add_n(tf.get_collection('losses'), name='total_loss')

    ###
    cifar10.maybe_download_and_extract()
    images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir,
                                                            batch_size=batch_size)
    images_test, labels_test = cifar10_input.inputs(eval_data=True,
                                                data_dir=data_dir,
                                                batch_size=batch_size)                                                  
    #images_train, labels_train = cifar10.distorted_inputs()
    #images_test, labels_test = cifar10.inputs(eval_data=True)
    image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
    label_holder = tf.placeholder(tf.int32, [batch_size])
    #logits = inference(image_holder)
    weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2, wl=0.0)
    kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1], padding='SAME')
    bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
    conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
    pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')
    norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
    weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2, wl=0.0)
    kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding='SAME')
    bias2 = tf.Variable(tf.constant(0.1, shape=[64]))
    conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
    norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
    pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')
    reshape = tf.reshape(pool2, [batch_size, -1])
    dim = reshape.get_shape()[1].value
    weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, wl=0.004)
    bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
    local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)
    weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, wl=0.004)
    bias4 = tf.Variable(tf.constant(0.1, shape=[192]))                                      
    local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)
    weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, wl=0.0)
    bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
    logits = tf.add(tf.matmul(local4, weight5), bias5)
    loss = loss(logits, label_holder)
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss) #0.72
    top_k_op = tf.nn.in_top_k(logits, label_holder, 1)
    sess = tf.InteractiveSession()
    tf.global_variables_initializer().run()
    tf.train.start_queue_runners()
    ###
    for step in range(max_steps):
        start_time = time.time()
        image_batch,label_batch = sess.run([images_train,labels_train])
        _, loss_value = sess.run([train_op, loss],feed_dict={image_holder: image_batch, 
                                                         label_holder:label_batch})
        duration = time.time() - start_time
        if step % 10 == 0:
            examples_per_sec = batch_size / duration
            sec_per_batch = float(duration)

            format_str = ('step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)')
            print(format_str % (step, loss_value, examples_per_sec, sec_per_batch))

    ###
    num_examples = 10000
    import math
    num_iter = int(math.ceil(num_examples / batch_size))
    true_count = 0  
    total_sample_count = num_iter * batch_size
    step = 0
    while step < num_iter:
        image_batch,label_batch = sess.run([images_test,labels_test])
        predictions = sess.run([top_k_op],feed_dict={image_holder: image_batch,
                                                 label_holder:label_batch})
        true_count += np.sum(predictions)
        step += 1
    precision = true_count / total_sample_count
    print('precision @ 1 = %.3f' % precision)
    import cifar10,cifar10_input
    import tensorflow as tf
    import numpy as np
    import time
    max_steps = 3000
    batch_size = 128
    data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'
    def variable_with_weight_loss(shape, stddev, wl):
        var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
        if wl is not None:
            weight_loss = tf.multiply(tf.nn.l2_loss(var), wl, name='weight_loss')
            tf.add_to_collection('losses', weight_loss)
        return var
    def loss(logits, labels):
        labels = tf.cast(labels, tf.int64)
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
            logits=logits, labels=labels, name='cross_entropy_per_example')
        cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
        tf.add_to_collection('losses', cross_entropy_mean)
        return tf.add_n(tf.get_collection('losses'), name='total_loss')

    ###
    cifar10.maybe_download_and_extract()
    images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir,
                                                            batch_size=batch_size)
    images_test, labels_test = cifar10_input.inputs(eval_data=True,
                                                data_dir=data_dir,
                                                batch_size=batch_size)                                                  
    #images_train, labels_train = cifar10.distorted_inputs()
    #images_test, labels_test = cifar10.inputs(eval_data=True)
    image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
    label_holder = tf.placeholder(tf.int32, [batch_size])
    #logits = inference(image_holder)
    weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2, wl=0.0)
    kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1], padding='SAME')
    bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
    conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
    pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')
    norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
    weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2, wl=0.0)
    kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding='SAME')
    bias2 = tf.Variable(tf.constant(0.1, shape=[64]))
    conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
    norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
    pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                       padding='SAME')
    reshape = tf.reshape(pool2, [batch_size, -1])
    dim = reshape.get_shape()[1].value
    weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, wl=0.004)
    bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
    local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)
    weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, wl=0.004)
    bias4 = tf.Variable(tf.constant(0.1, shape=[192]))                                      
    local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)
    weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, wl=0.0)
    bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
    logits = tf.add(tf.matmul(local4, weight5), bias5)
    loss = loss(logits, label_holder)
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss) #0.72
    top_k_op = tf.nn.in_top_k(logits, label_holder, 1)
    sess = tf.InteractiveSession()
    tf.global_variables_initializer().run()
    tf.train.start_queue_runners()
    ###
    for step in range(max_steps):
        start_time = time.time()
        image_batch,label_batch = sess.run([images_train,labels_train])
        _, loss_value = sess.run([train_op, loss],feed_dict={image_holder: image_batch, 
                                                         label_holder:label_batch})
        duration = time.time() - start_time
        if step % 10 == 0:
            examples_per_sec = batch_size / duration
            sec_per_batch = float(duration)

            format_str = ('step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)')
            print(format_str % (step, loss_value, examples_per_sec, sec_per_batch))

    ###
    num_examples = 10000
    import math
    num_iter = int(math.ceil(num_examples / batch_size))
    true_count = 0  
    total_sample_count = num_iter * batch_size
    step = 0
    while step < num_iter:
        image_batch,label_batch = sess.run([images_test,labels_test])
        predictions = sess.run([top_k_op],feed_dict={image_holder: image_batch,
                                                 label_holder:label_batch})
        true_count += np.sum(predictions)
        step += 1
    precision = true_count / total_sample_count
    print('precision @ 1 = %.3f' % precision)

 

 

参考资料:
《TensorFlow实战》

参考资料:
《TensorFlow实战》

欢迎付费咨询(150首届各个小时),我的微信:qingxingfengzi

接付费咨询(150头版各个小时),我的微信:qingxingfengzi

相关文章