Python使用tensorflow实现图像识别（猫狗大战）-02

model.py

import tensorflow as tf

def inference(images, batch_size, n_classes):
    # cov1, shape = [kernel size, kernel size, channels, kernel numbers]
    with tf.variable_scope('conv1') as scope:
    #使用 tf.variable_scope() 让定义的变量可以有相同的名字
        weights = tf.get_variable('weights', 
                                  shape = [3, 3, 3, 16],   # 16[kernel numbers]：跟计算的精度有关
                                  dtype = tf.float32,
                                  initializer = tf.truncated_normal_initializer(stddev = 0.1,
                                                                                dtype = tf.float32)) 
                        #截取的正态分布  tf.truncated_normal_initializer()
                 '''
                mean：一个python标量或一个标量张量。要生成的随机值的均值。
                stddev：一个python标量或一个标量张量。要生成的随机值的标准偏差。
				seed：一个Python整数。用于创建随机种子。查看 tf.set_random_seed 行为。
				dtype：数据类型。只支持浮点类型。
                '''       
        biases = tf.get_variable('biases', 
                                 shape = [16], 
                                 dtype = tf.float32,
                                 initializer = tf.constant_initializer(0.1)) # 初始化0.1
                                 # tf.constant_initializer() 参数初始化为给定的值
        # tf.get_variable()函数的用法----------------------------------------------------------------(1)
        
        conv = tf.nn.conv2d(images, weights, strides = [1, 1, 1, 1], padding = 'SAME')
        #--------------------------------------------------------------------------------------------(2)
        pre_activation = tf.nn.bias_add(conv, biases)
        conv1 = tf.nn.relu(pre_activation, name = scope.name)
        
    #pool1 and norm1
    with tf.variable_scope('poling_lrn') as scope:
        pool1 = tf.nn.max_pool(conv1, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], # 标准数值
                               padding = 'SAME', name = 'pooling1')
        norm1 = tf.nn.lrn(pool1, depth_radius = 4, bias = 1.0, alpha = 0.001/9.0,
                          beta = 0.75, name = 'norm1')
 
    # conv2 
    with tf.variable_scope('conv2') as scope:
        weights = tf.get_variable('weights', shape = [3, 3, 16, 16],
                                  dtype = tf.float32,
                                  initializer = tf.truncated_normal_initializer(stddev = 0.1,
                                                                                dtype = tf.float32))
        biases = tf.get_variable('biases', 
                                 shape = [16], 
                                 dtype = tf.float32,
                                 initializer = tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(norm1,weights, strides = [1, 1, 1, 1], padding = 'SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv2 = tf.nn.relu(pre_activation, name = 'conv2')
        
    # pool2 and norm2
    with tf.variable_scope('pooling2_lrn') as scope:
        norm2 = tf.nn.lrn(conv2, depth_radius = 4, bias = 1.0, alpha = 0.001/9.0,
                          beta = 0.75, name = 'norm2')
        pool2 = tf.nn.max_pool(norm2, ksize = [1, 3, 3, 1], strides = [1, 1, 1, 1],
                               padding = 'SAME', name = 'pooling2')
        
    # local3
    with tf.variable_scope('local3') as scope:
        reshape = tf.reshape(pool2, shape = [batch_size, -1]) # 变换成向量
        dim = reshape.get_shape()[1].value
        weights = tf.get_variable('weights',
                                  shape = [dim, 128],  # 全连接个数，128
                                  dtype = tf.float32,
                                  initializer = tf.truncated_normal_initializer(stddev = 0.005,
                                                                                dtype = tf.float32))

        biases = tf.get_variable('biases',
                                shape = [128],
                                dtype = tf.float32,
                                initializer = tf.constant_initializer(0.1))  
        local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name = scope.name)
        
    # local4
    with tf.variable_scope('local4') as scope:
        weights = tf.get_variable('weights',
                                  shape = [128, 128], 
                                  dtype = tf.float32,
                                  initializer = tf.truncated_normal_initializer(stddev = 0.005,
                                                                                dtype = tf.float32))
        biases = tf.get_variable('biases',
                                 shape = [128], 
                                 dtype = tf.float32,
                                 initializer = tf.constant_initializer(0.1))
        local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name = 'local4')
        
    # softmax
    with tf.variable_scope('softmax_linear') as scope:
        weights = tf.get_variable('softmax_linear',
                                  shape = [128, n_classes],  # n_classes:2，表示二分类
                                  dtype = tf.float32,
                                  initializer = tf.truncated_normal_initializer(stddev = 0.005,
                                                                                dtype = tf.float32))
        biases = tf.get_variable('biases',
                                 shape = [n_classes], 
                                 dtype = tf.float32,
                                 initializer = tf.constant_initializer(0.1))
        softmax_linear = tf.add(tf.matmul(local4, weights), biases, name = 'softmax_linear')
        # tf.matmul()  矩阵相乘
        
    return softmax_linear

def losses(logits, labels):
    with tf.variable_scope('lose') as scope:
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = logits, 
        labels = labels, name = 'xentropy_per_example')
        loss = tf.reduce_mean(cross_entropy, name = 'loss')
        tf.summary.scalar(scope.name+'/loss', loss)
    
    return loss

#优化
def training(loss, learning_rate):
    with tf.name_scope('optimizer'):
        optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)
        global_step = tf.Variable(0, name = 'global_step', trainable = False)
        train_op = optimizer.minimize(loss, global_step = global_step)
        
    return train_op

def evalution(logits, labels):
    with tf.variable_scope('accuracy') as scope:
        correct = tf.nn.in_top_k(logits, labels, 1) # 取最大值
        correct = tf.cast(correct, tf.float16)
        accuracy = tf.reduce_mean(correct)
        tf.summary.scalar(scope.name+'/accuracy', accuracy)
    return accuracy

1. tf.get_variable()
   转载自：https://blog.csdn.net/uestc_c2_403/article/details/72327321 写的很详细了哦

tf.get_variable(name,  shape, initializer): 
#name就是变量的名称，shape是变量的维度，initializer是变量初始化的方式

2. tf.nn.conv2d()
   https://blog.csdn.net/zuolixiangfisher/article/details/80528989 详细点的

import tnsorflow as tf
tf.nn.conv2d(input,filter,strides=[1,1,1,1],padding='SAME')
#input是输入做卷积的图片，是一个张量；filter卷积核；strides步长；padding是否考虑边界，SAME用0填充，VALID不考虑