python-tensorflow(1)C3D代码解析

川长思鸟来 2022-06-08 02:41 342阅读 0赞

标签（空格分隔）： 文章复现

--------------------

C3D代码解析

### 1、main函数 ###

def main(_):
      run_training()
    
    if __name__ == '__main__':
      tf.app.run()

`if __name__ == "__main__":` means current file is executed under a shell instead of imported as a module.  
`__name__`是当前模块名，当模块被直接运行时模块名为 `__main__`。这句话的意思就是，当模块被直接运行时，以下代码块将被运行，当模块是被导入时，代码块不被运行。  
`tf.app.run()`  
执行main函数之前首先进行flags的解析，也就是说TensorFlow通过设置flags来传递tf.app.run()所需要的参数，我们可以直接在程序运行前初始化flags，也可以在运行程序的时候设置命令行参数来达到传参的目的。

```
          学习使用 tf.app.flags 使用，全局变量
         可以再命令行中运行也是比较方便，如果只写 python app_flags.py 则代码运行时默认程序里面设置的默认设置
       若 python app_flags.py --train_data_path <绝对路径 train.txt> --max_sentence_len 100
         --embedding_size 100 --learning_rate 0.05  代码再执行的时候将会按照上面的参数来运行程序
     ````
         - import tensorflow as tf
        -
        - FLAGS = tf.app.flags.FLAGS
        -
        - # tf.app.flags.DEFINE_string("param_name", "default_val", "description")
        - tf.app.flags.DEFINE_string("train_data_path", "/home/yongcai/chinese_fenci/train.txt", "training data dir")
        - tf.app.flags.DEFINE_string("log_dir", "./logs", " the log dir")
        - tf.app.flags.DEFINE_integer("max_sentence_len", 80, "max num of tokens per query")
        - tf.app.flags.DEFINE_integer("embedding_size", 50, "embedding size")
        -
        - tf.app.flags.DEFINE_float("learning_rate", 0.001, "learning rate")
        -
        -
        - def main(unused_argv):
        -     train_data_path = FLAGS.train_data_path  #大写的FLAG中存储这些变量

### 2、tensorflow函数解析 ###

#### **`tf.app.run()`** ####

的定义为：

def run(main=None, argv=None):
    ...
    main = main or _sys.modules['__main__'].main

如果传入了参数，传入的参数就是main，没有传入，那么模块 `__main__`中的main函数就是main

#### **`with tf.Graph().as_default():`** 开始创建图 ####

为了方便起见，TensorFlow在加载库的时候会自动创建图，并且将这个图指定为默认图。

global_step = tf.get_variable(
                        'global_step',
                        [],
                        initializer=tf.constant_initializer(0),
                        trainable=False
                        )

#### **tf.get\_variable**\`给变量赋予这些参数或者创建一个新的变量，用法解析如下 ####

with tf.variable_scope("foo"):
        v = tf.get_variable("v", [1])  # v.name == "foo/v:0"
        w = tf.get_variable("w", [1])  # w.name == "foo/w:0"
    with tf.variable_scope("foo", reuse=True):
        v1 = tf.get_variable("v")  # The same as v above.

#### **`tf.name_scope`和`tf.variable_scope`** ####

tf.variable\_scope可以让变量有相同的命名，包括tf.get\_variable得到的变量，还有tf.Variable的变量  
tf.name\_scope可以让变量有相同的命名，只是限于tf.Variable的变量

for gpu_index in range(0, gpu_num):
          with tf.device('/gpu:%d' % gpu_index):
            with tf.name_scope('%s_%d' % ('dextro-research', gpu_index)) as scope:
              with tf.variable_scope('var_name') as var_scope:

`tf.Variable`和`tf.get_variable`的区别  
建议都使用tf.get\_variable，可以在任何时候共享变量的名字，比如在多GPU设置的情况下  
函数`tf.concat`  
Concatenates(串联) tensors along one dimension.

### 3.函数解析 ###

#### **`_variable_with_weight_decay`**函数调用 ####

'wc1': _variable_with_weight_decay('wc1', [3, 3, 3, 3, 64], 0.0005)

def _variable_on_cpu(name, shape, initializer):
        '''
        辅助函数:在CPU中创建Variable
        :param name:变量名称
        :param shape:形状
        :param initializer:初始化
        :return:
            Variable Tensor
        '''
      with tf.device('/cpu:0'):
        var = tf.get_variable(name, shape, initializer=initializer)
      return var
    
    def _variable_with_weight_decay(name, shape, wd):
      '''
        辅助函数:利用权重衰减初始化Variable
    
        变量利用truncated normal distribution
        只有指定的时候才进行权重衰减(weight decay)
        :param name:变量的名称
        :param shape:形状
        :param stddev:trucated Gaussian的标准差
        :param wd:增加 L2Loss 权重衰减,如果是None,weight decay不被增加
    
        :return:
            Variabel Tensor
        '''
      var = _variable_on_cpu(name, shape, tf.contrib.layers.xavier_initializer())  
      if wd is not None:
        weight_decay = tf.mul(tf.nn.l2_loss(var), wd, name='weight_loss')
        tf.add_to_collection('losses', weight_decay)
      return var

varlist1 = weights.values()
    varlist2 = biases.values()

#### **函数`inference_c3d`** ####

logit = c3d_model.inference_c3d(
                              images_placeholder[gpu_index * FLAGS.batch_size:(gpu_index + 1) * FLAGS.batch_size,:,:,:,:],
                              0.5,
                              FLAGS.batch_size,
                              weights,
                              biases
                              )

def inference_c3d(_X, _dropout, batch_size, _weights, _biases):
        ```
       主要函数：网络结构
       :_X:images_placeholder
    
       :return：分类结果
    
        ```

#### **函数`tower_loss`** ####

def tower_loss(name_scope, logit, labels):
        ```
        计算损失函数
        :name_scope：name_scope
        :logit:神经网络分类结果
        :labels： labels_placeholder
    
        return：tower_loss
    
        ```
      cross_entropy_mean = tf.reduce_mean(
                      tf.nn.sparse_softmax_cross_entropy_with_logits(logit, labels)
                      )
      tf.scalar_summary(
                      name_scope + 'cross entropy',
                      cross_entropy_mean
                      )

loss = tower_loss(
                scope,
                logit,
                labels_placeholder[gpu_index * FLAGS.batch_size:(gpu_index + 1) * FLAGS.batch_size]
                              )

#### **函数：优化器** ####

opt1 = tf.train.AdamOptimizer(1e-4)
      ```
      Class AdamOptimizer
      1e-4：learning rate
      ```

函数`compute_gradients`  
method of tf.train.AdamOptimizer

grads1 = opt1.compute_gradients(loss, varlist1)
     ```
     优化器：计算反向传播梯度
     loss: 损失函数
     varlist1:variable（权重）
    
     return：Compute gradients of loss for the variables in var_list.minimize的第一步
     ```

函数`apply_gradients`  
method of tf.train.AdamOptimizer

apply_gradient_op1 = opt1.apply_gradients(grads1)
        ```
        优化器：应用反向传播梯度
        return：It returns an Operation that applies gradients. minimize的第二步
        ```
     ```
    ````
    
    
    
    
    
    <div class="se-preview-section-delimiter"></div>

参考[tensorlfow操作gradient][tensorlfow_gradient]

**函数`tower_acc` 计算精度**

def tower_acc(logit, labels):
      correct_pred = tf.equal(tf.argmax(logit, 1), labels)
      accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
      return accuracy
    
    
    
    
    <div class="se-preview-section-delimiter"></div>

函数`average_gradients`  
计算平均梯度干什么

def average_gradients(tower_grads):
     ```
     input：每个variable的梯度
     return：平均梯度  ？？？？
     ```
    return average_grads
    
    
    
    
    
    <div class="se-preview-section-delimiter"></div>

tf.train.ExponentialMovingAverage

### 5、神经网络理论基础 ###

`weight_decay`  
在训练神经网络的时候，通常在训练刚开始的时候使用较大的learning rate， 随着训练的进行，我们会慢慢的减小learning rate  
比如tensorflow中有这样的定义

decayed_learning_rate = learning_rate *  decay_rate ^ (global_step / decay_steps)
    
    
    
    
    <div class="se-preview-section-delimiter"></div>

### 参考 ###

[cifar模型][cifar]

tower_grads1 = [] #梯度
    logits = [] #分类结果
    ...
    tower_grads1.append(grads1) #更新梯度
    tower_grads2.append(grads2)
    logits.append(logit)#更新分类结果
    
    tf.get_variable_scope().reuse_variables() 
    `这句话出现在这里什么意思`

[tensorlfow_gradient]: http://blog.csdn.net/u012436149/article/details/53006953
[cifar]: http://www.voidcn.com/article/p-taqpxuin-w.html