SceneRecognize/DeepNet.py

最新推荐文章于 2023-02-11 18:15:40 发布
转载 最新推荐文章于 2023-02-11 18:15:40 发布 · 274 阅读 · 0
标签
#Python #Deep Net
本文介绍了一个使用TensorFlow实现的深度学习模型，该模型用于场景识别任务。通过构建复杂的卷积神经网络结构，并利用预处理后的TFRecord数据进行训练，提高了模型的准确性和效率。

出处： https://github.com/wmpscc/SceneRecognize/blob/master/DeepNet.py

#!/usr/bin/env python
# _*_coding:utf-8_*_
import tensorflow as tf
import numpy as np
import os
import time

BATCH_SIZE = 10
slim = tf.contrib.slim


# 读训练集数据
def read_train_data():
    reader = tf.TFRecordReader()
    filename_train = tf.train.string_input_producer(["TFRecord/train.tfrecords"])
    _, serialized_example_test = reader.read(filename_train)
    features = tf.parse_single_example(
        serialized_example_test,
        features={
            'label': tf.FixedLenFeature([], tf.int64),
            'image_raw': tf.FixedLenFeature([], tf.string),
        }
    )

    img_train = features['image_raw']
    images_train = tf.decode_raw(img_train, tf.uint8)
    images_train = tf.reshape(images_train, [229, 229, 3])
    labels_train = tf.cast(features['label'], tf.int64)
    labels_train = tf.cast(labels_train, tf.int64)
    labels_train = tf.one_hot(labels_train, 80)
    return images_train, labels_train


# 读测试集数据
def read_test_data():
    reader = tf.TFRecordReader()
    filename_test = tf.train.string_input_producer(["TFRecord/test.tfrecords"])
    _, serialized_example_test = reader.read(filename_test)
    features_test = tf.parse_single_example(
        serialized_example_test,
        features={
            'label': tf.FixedLenFeature([], tf.int64),
            'image_raw': tf.FixedLenFeature([], tf.string),
        }
    )
    img_test = features_test['image_raw']
    images_test = tf.decode_raw(img_test, tf.uint8)
    images_test = tf.reshape(images_test, [229, 229, 3])
    labels_test = tf.cast(features_test['label'], tf.int64)
    labels_test = tf.one_hot(labels_test, 80)
    return images_test, labels_test


def save_model(sess, step):
    MODEL_SAVE_PATH = "model/"
    MODEL_NAME = "model.ckpt"
    saver = tf.train.Saver()
    saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=step)


def get_accuracy(logits, label):
    print(logits)
    logits = tf.reshape(logits, shape=[BATCH_SIZE, 80])
    current = tf.cast(tf.equal(tf.argmax(logits, 1), tf.argmax(label, 1)), 'float')
    accuracy = tf.reduce_mean(current)
    return accuracy


def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
    """Builds the 35x35 resnet block."""
    with tf.variable_scope(scope, 'Block35', [net], reuse=reuse):
        with tf.variable_scope('Branch_0'):
            tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1')
        with tf.variable_scope('Branch_1'):
            tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
            tower_conv1_1 = slim.conv2d(tower_conv1_0, 32, 3, scope='Conv2d_0b_3x3')
        with tf.variable_scope('Branch_2'):
            tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
            tower_conv2_1 = slim.conv2d(tower_conv2_0, 48, 3, scope='Conv2d_0b_3x3')
            tower_conv2_2 = slim.conv2d(tower_conv2_1, 64, 3, scope='Conv2d_0c_3x3')
        mixed = tf.concat(axis=3, values=[tower_conv, tower_conv1_1, tower_conv2_2])
        up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,
                         activation_fn=None, scope='Conv2d_1x1')
        scaled_up = up * scale
        if activation_fn == tf.nn.relu6:
            # Use clip_by_value to simulate bandpass activation.
            scaled_up = tf.clip_by_value(scaled_up, -6.0, 6.0)

        net += scaled_up
        if activation_fn:
            net = activation_fn(net)
    return net


def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
    """Builds the 17x17 resnet block."""
    with tf.variable_scope(scope, 'Block17', [net], reuse=reuse):
        with tf.variable_scope('Branch_0'):
            tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1')
        with tf.variable_scope('Branch_1'):
            tower_conv1_0 = slim.conv2d(net, 128, 1, scope='Conv2d_0a_1x1')
            tower_conv1_1 = slim.conv2d(tower_conv1_0, 160, [1, 7],
                                        scope='Conv2d_0b_1x7')
            tower_conv1_2 = slim.conv2d(tower_conv1_1, 192, [7, 1],
                                        scope='Conv2d_0c_7x1')
        mixed = tf.concat(axis=3, values=[tower_conv, tower_conv1_2])
        up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,
                         activation_fn=None, scope='Conv2d_1x1')

        scaled_up = up * scale
        if activation_fn == tf.nn.relu6:
            # Use clip_by_value to simulate bandpass activation.
            scaled_up = tf.clip_by_value(scaled_up, -6.0, 6.0)

        net += scaled_up
        if activation_fn:
            net = activation_fn(net)
    return net


def net(inputs, dropout_keep_prob):
    # 229*229*3
    net = slim.repeat(inputs, 2, slim.conv2d, 64, 3, normalizer_fn=slim.batch_norm,
                      normalizer_params={'is_training': True}, padding='VALID')
    net = slim.max_pool2d(net, 2, stride=2)

    net = slim.conv2d(net, 64, 1, padding='SAME')
    net = slim.repeat(net, 2, slim.conv2d, 128, 3, normalizer_fn=slim.batch_norm,
                      normalizer_params={'is_training': True}, padding='VALID')
    net = slim.max_pool2d(net, 2, stride=2)

    net = slim.conv2d(net, 128, 1, padding='SAME')
    net = slim.repeat(net, 3, slim.conv2d, 256, 3, normalizer_fn=slim.batch_norm,
                      normalizer_params={'is_training': True}, padding='VALID')
    net = slim.max_pool2d(net, 2, stride=2)

    net = slim.conv2d(net, 256, 1, padding='SAME')
    net = slim.repeat(net, 3, slim.conv2d, 512, 3, normalizer_fn=slim.batch_norm,
                      normalizer_params={'is_training': True}, padding='VALID')
    net = slim.max_pool2d(net, 2, stride=2)

    net = slim.conv2d(net, 512, 1, padding='SAME')
    net = slim.repeat(net, 3, slim.conv2d, 512, 3, normalizer_fn=slim.batch_norm,
                      normalizer_params={'is_training': True}, padding='VALID')
    # net = slim.max_pool2d(net, 2, stride=2)

    # net = slim.repeat(net, 2, slim.conv2d, 512, 3, normalizer_fn=slim.batch_norm,
    #                   normalizer_params={'is_training': True}, padding='SAME')
    # net = slim.conv2d(net, 80, 1, scope='f1')
    # net = tf.reduce_mean(net, [1, 2], keep_dims=True)
    net = slim.flatten(net)
    fc1 = slim.fully_connected(net, 80, activation_fn=None)

    return fc1


def net2(inputs, dropout_keep_prob):
    net = slim.conv2d(inputs, 32, 3, stride=2, padding='SAME')
    net = slim.conv2d(net, 32, 3, stride=1, padding='VALID')
    net = slim.conv2d(net, 64, 3, stride=1, padding='SAME')
    net = slim.batch_norm(net, is_training=True)
    with tf.variable_scope('FilterConcat1'):
        with tf.variable_scope('Branch0'):
            branch_0 = slim.max_pool2d(net, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch1'):
            branch_1 = slim.conv2d(net, 96, 3, stride=2, padding='VALID')
        net = tf.concat([branch_0, branch_1], 3)
    with tf.variable_scope('FilterConcat2'):
        with tf.variable_scope('Branch0'):
            branch0_0 = slim.conv2d(net, 64, 1, padding='SAME')
            branch0_1 = slim.conv2d(branch0_0, 96, 3, padding='VALID')
        with tf.variable_scope('Branch1'):
            branch1_0 = slim.conv2d(net, 64, 1, padding='SAME')
            branch1_1 = slim.conv2d(branch1_0, 64, [7, 1], padding='SAME')
            branch1_2 = slim.conv2d(branch1_1, 64, [1, 7], padding='SAME')
            branch1_3 = slim.conv2d(branch1_2, 96, 3, padding='VALID')
        net = tf.concat([branch0_1, branch1_3], 3)
    with tf.variable_scope('FilterConcat3'):
        with tf.variable_scope('Branch0'):
            branch_0 = slim.conv2d(net, 192, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch1'):
            branch_1 = slim.max_pool2d(net, 3, stride=2, padding='VALID')
        net = tf.concat([branch_0, branch_1], 3)
        net = slim.batch_norm(net, is_training=True)

    # 35*35*384
    net = slim.repeat(net, 5, block35, scale=0.34, activation_fn=tf.nn.leaky_relu)
    net = slim.batch_norm(net, is_training=True)

    with tf.variable_scope('FilterConcat4'):
        with tf.variable_scope('Branch0'):
            branch0 = slim.max_pool2d(net, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch1'):
            branch1 = slim.conv2d(net, 384, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch2'):
            branch2_0 = slim.conv2d(net, 256, 1, stride=2, padding='SAME')
            branch2_1 = slim.conv2d(branch2_0, 256, 3, padding='SAME')
            branch2_2 = slim.conv2d(branch2_1, 384, 2, padding='VALID')
        net = tf.concat([branch0, branch1, branch2_2], 3)
        net = slim.batch_norm(net, is_training=True)
    # 12*12
    net = slim.repeat(net, 10, block17, scale=0.20, activation_fn=tf.nn.leaky_relu)
    net = slim.batch_norm(net, is_training=True)

    with tf.variable_scope('FilterConcat5'):
        with tf.variable_scope('Branch0'):
            branch0 = slim.max_pool2d(net, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch1'):
            branch1_0 = slim.conv2d(net, 256, 1, padding='SAME')
            branch1_1 = slim.conv2d(branch1_0, 384, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch2'):
            branch2_0 = slim.conv2d(net, 256, 1, padding='SAME')
            branch2_1 = slim.conv2d(branch2_0, 288, 3, stride=2, padding='VALID')
        with tf.variable_scope('Branch3'):
            branch3_0 = slim.conv2d(net, 256, 1, padding='SAME')
            branch3_1 = slim.conv2d(branch3_0, 288, 3, padding='SAME')
            branch3_2 = slim.conv2d(branch3_1, 320, 3, stride=2, padding='VALID')
        net = tf.concat([branch0, branch1_1, branch2_1, branch3_2], 3)
    net = slim.batch_norm(net, is_training=True)
    net = slim.conv2d(net, 1024, 1, padding='SAME')
    # Global Average Pooling
    kernel_size = net.get_shape()[1:3]
    if kernel_size.is_fully_defined():
        net = slim.avg_pool2d(net, kernel_size, padding='VALID')
    else:
        net = tf.reduce_mean(net, [1, 2], keep_dims=True)

    # dropout
    if dropout_keep_prob !=1:
        net = slim.dropout(net, dropout_keep_prob, is_training=True)

    # Use conv2d instead of fully_connected layers.
    net = slim.conv2d(net, 80, [1, 1])
    return net


def train():
    x_train, y_train = read_train_data()
    x_test, y_test = read_test_data()
    x_batch_train, y_batch_train = tf.train.shuffle_batch([x_train, y_train], batch_size=BATCH_SIZE, capacity=100,
                                                          min_after_dequeue=50, num_threads=3)
    x_batch_test, y_batch_test = tf.train.shuffle_batch([x_test, y_test], batch_size=BATCH_SIZE, capacity=100,
                                                        min_after_dequeue=50, num_threads=3)
    dropout = tf.placeholder('float')
    x = tf.placeholder(tf.float32, shape=[None, 229 * 229 * 3])
    y = tf.placeholder(tf.float32, shape=[None, 80])

    inputs = tf.reshape(x, shape=[BATCH_SIZE, 229, 229, 3])

    logits = net2(inputs, dropout)
    accuracy = get_accuracy(logits, y)
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=y))
    global_step = tf.Variable(0, name='global_step')
    train_gdop = tf.train.GradientDescentOptimizer(0.001).minimize(cross_entropy, global_step=global_step)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    for i in range(2500):
        input_x, input_y = sess.run([x_batch_train, y_batch_test])
        input_x = np.reshape(input_x, [BATCH_SIZE, 229 * 229 * 3])
        if i % 100 == 0:
            acc = sess.run(accuracy, feed_dict={x: input_x, y: input_y, dropout: 1})
            loss = sess.run(cross_entropy, feed_dict={x: input_x, y: input_y, dropout: 1})
            print("Step: %d -----> accuracy: %g -----> loss: %g" % (i, acc, loss))
        sess.run(train_gdop, feed_dict={x: input_x, y: input_y, dropout: 0.7})
    save_model(sess, i)
    coord.request_stop()
    coord.join(threads)


if __name__ == '__main__':
    start = time.time()
    train()
    print("All steps use time: %g S" % (time.time() - start))

tf.concat中axis的含义与使用详解
09-18
今天小编就为大家分享一篇tf.concat中axis的含义与使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Inception-V4和Inception-Resnet论文阅读和代码解析
stesha_chen的博客
09-08 9583
目录： 论文阅读 代码解析 小结   论文阅读 论文地址：Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning 此论文主要是作者尝试将inception与residual结合，而提出了inception-resnet-v1和inception-resnet-v2网络，并且为了...
计算机视觉：场景识别（Scene Recognition）
博学而笃志，切问而近思。
02-11 1万+
计算机视觉：场景识别（Scene Recognition）
tf.concat()用法
ZHUQIUSHI123的博客
02-25 443
调用格式： tf.concat( values, axis, name='concat' ) axis=0代表在第0个维度拼接，axis=1代表在第一个维度拼接。 注意：tf.concat()拼接的张量只会改变一个维度，其他维度是保存不变的。比如两个shape为[2,3]的矩阵拼接，要么通过axis=0变成[4,3]，要么通过axis=1变成[2,6]。改变的维度索引对应...
tensorflow踩坑
A2333_2333的博客
02-07 274
首先，贴出来我要使用的模型，我想要在Pytorch使用相同的模型，需要先理解并且测试一下模型的运行情况，我需要打印一些张量数值用来确定两种框架的模型可以输出相同的结果。使用sess.run(tf.global_variables_initializer())进行初始化权重，切记要在使用紧贴着使用模型语句之后，不报错的代码如下。论文：https://daooshee.github.io/BMVC2018website/代码：https://github.com/weichen582/RetinexNet。
使用Densenet模型训练自己的数据集
YYLin
07-02 1万+
前言： 之前四篇文章分别介绍了如何使用AlexNet、VGG19、ResNet_152 、Inception_V4训练自己数据集，本节将介绍最后一个经典图像识别模型Densenet，Densenet是CVPR2017年的Best Paper, DenseNet脱离了加深网络层数(ResNet)和加宽网络结构(Inception)来提升网络性能的定式思维。它建立的是前面所有层与后面层的密...
tf.concat中axis的含义与使用
韦人人韦
12-12 1万+
tensorflow中tf.concat的axis的使用我一直理解的比较模糊，这次做个笔记理下自己的思路。 import tensorflow as tf tf.enable_eager_execution() import numpy as np 先生成两个矩阵m1, 和m2, 大小为两行三列 m1 = np.random.rand(2,3) # m1.shape (2,3) m1 >&...
tf.concat()详解
热门推荐
木盏
09-04 18万+
tensorflow中用来拼接张量的函数tf.concat()，用法: tf.concat([tensor1, tensor2, tensor3,...], axis) 先给出tf源代码中的解释: t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat([t1, t2], 0) # [[1, ...
concat连接多个通道
qiqiaiairen的博客
11-11 7118
深度学习中，经常要使用的技术之一，连接多个通道作为下一个网络层的输入。 tf.concat(concat_dim, values, name='concat') concat_dim是tensor 连接的方向（维度），values 是要连接的tensor 链表，name是操作名。concat_dim维度可以不一样，其他维度的尺寸必须一样。 1. 两个二维tensor连接 concat_di
keras中的K.concatenate()详解
木盏
09-04 5万+
keras中concatenate源代码如下: def concatenate(tensors, axis=-1): """Concatenates a list of tensors alongside the specified axis. # Arguments tensors: list of tensors to concatenate. ...
tf.concat()函数介绍和示例
wk的博客
09-07 1073
tf.concat()函数介绍和示例 tf.concat([tensor1, tensor2, tensor3, … ], axis) 释义：将张量 tensor1, tensor2, tensor3, … 拼接 axis，指定轴（维度） 示例： import tensorflow as tf t1 = tf.constant([[1, 2, 3], [4, 5, 6]], dtype=tf...
tensorflow学习之tf.concat()详解
Leo_whj的博客
03-07 1216
tensorflow中用来拼接张量的函数tf.concat()，用法: tf.concat([tensor1, tensor2, tensor3,...], axis) 先给出tf源代码中的解释: t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat([t1, t2], 0) # [[1,...
densenet tensorflow 中文汉字手写识别
djph26741的博客
05-15 634
densenet 中文汉字手写识别，代码如下： import tensorflow as tf import os import random import math import tensorflow.contrib.slim as slim import time import logging import numpy as np import pickl...
DenseNet--Tensorflow
zhangboshen的博客
03-23 2488
一个Tensorflow的DenseNet实现。
tensorflow 中tf.concat()用法
momaojia的博客
08-26 1万+
concat()是将tensor沿着指定维度连接起来。其中tensorflow1.3版中是这样定义的： concat(values,axis,name='concat')    一、对于2维来说，0表示行，1表示列 t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] with tf.Session() as sess
python concat axis_tf.concat中axis的含义与使用详解
weixin_39929602的博客
12-17 1137
tensorflow中tf.concat的axis的使用我一直理解的比较模糊，这次做个笔记理下自己的思路。import tensorflow as tftf.enable_eager_execution()import numpy as np先生成两个矩阵m1, 和m2, 大小为两行三列m1 = np.random.rand(2,3) # m1.shape (2,3)m1>>array...
深度学习--Inception-ResNet-v1网络结构
dulingtingzi的博客
04-09 3718
本文转载自：https://blog.csdn.net/lovelyaiq/article/details/79026181，只有一小部分根据自己的理解做了修整版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lovelyaiq/article/details/79026181目录(?)[-]Stem结构Inception-resnet-A模块Red...
低光照图像增强算法汇总
weixin_36670529的博客
04-11 2万+
1、场景需求   在现实场景中，由于光线、视角等问题会导致我们拍摄出来的照片比较阴暗，具体的图片如下图中的1、3、5列所示，然后这些阴暗的图片不仅会影响我们的观察，而且会极大的影响计算机视觉处理算法的效果，2、4、6列表示的是使用了低光照图像增强算法之后的效果。本文主要针对低光照的图片展开论述，对经典的一些低光照图像增强算法进行了总结和初略的分析。 2、Retinex算法 论文链接-Github链接 2.1 Retinex算法简介   Retinex是一种常用的建立在科学实验和科学分析基础上的
Tensorflow一些常用基本概念与函数（1）
lenbow的博客
08-08 15万+
摘要：本文主要对tf的一些常用概念与方法进行描述。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值