Tensorflow学习笔记(函数解析+TF.slim+Keras)

tensorflow小点学习记录
函数Function篇
1、tf.nn.conv2d(input,filter,strides,padding,use_cudnn_on_gpu=None,name=None)

参数解析：
(1)input---输入图像，
        类型：4个维度tensor----[batch_size,in_height,in_width,in_channels]
(2)filter--卷积核的个数
        类型：4个维度tensor----[filter_height,filter_width,in_channels,out_channels]
(3)strides--移动步长
        类型：一维向量，长度为4，
        如：[1,1,1,1]---strides[0]=strides[3]=1;strides[1]代表x方向的步长，strides[2]代表y方向移动的步长
(4)padding--填充类型
        类型：string字符串型(两种情况，必须大写)
        只有“SAME”\"VALID";
        "SAME": 当strides为1时经过卷积之后，卷积前后大小不变；(strides!=1时，尺寸大小发生变化)
        “VALID”: 表示不填充；
(5)use_cudnn_on_gpu--是否使用GPU加速
        类型：bool(只有True\False)
(6)返回结果：类型：Tensor
        [batch_size,out_height,out_width,out_channels]

2、tf.nn.max_pool(value,ksize,strides,padding,name=None)

  参数解析：
(1)value---输入
        类型：4个维度tensor---[batch_size,in_height,in_width,channels]
(2)ksize---池化层的窗口大小
        类型：4维向量---[1,height,width,1]
        ksize[0],ksize[3]=1表示不在batch和channel上做池化l;
(3)strides---移动步长(和卷积一致)
(4)padding---填充类型(和卷积一致)
(5)返回结果：类型：Tensor
        [batch,out_height,out_width,channels]
Note:4个维度Tensor数据存储方式的理解；
   
    列如：[1,4,4,2]的图像，
        channel_1    channel_2
         1 3 5 7      2 4 6 8 
         8 6 4 2      7 5 3 1
         4 2 8 6      3 1 7 5
         1 3 5 7      2 4 6 8
        
        Tensor中存储为：
        [[[[ 1.  2.]  
           [ 3.  4.]  
           [ 5.  6.]  
           [ 7.  8.]]  
           
         [[ 8.  7.]  
          [ 6.  5.]  
          [ 4.  3.]  
          [ 2.  1.]]  
          
          [[ 4.  3.]  
          [ 2.  1.]  
          [ 8.  7.]  
          [ 6.  5.]]  

         [[ 1.  2.] 
          [ 3.  4.]  
          [ 5.  6.]  
          [ 7.  8.]]]] 按照2--4--4--1的方式看

3、tf.nn.relu(features,name=None)非饱和线性端、特点：简单、快速

参数解析：
(1)features---卷积之后的feature map
        类型：4个维度tensor
        float32\float64\int8\int16\int32\int64\uint8\uint16\half
(2)返回结果：类型：Tensor
relu=max(0,x)
relu函数x<0时的抑制作用使得网络加入稀疏性

4、tf.reshape(tensor,shape,name=None)

参数解析：
(1)tensor----输入数据
(2)shape-----目标形状\转换的形状
(3)返回结果：类型：Tensor

5、tf.nn.dropout(x,keep_prob,noise_shape=None,seed=None,name=None)
train时dropout层起作用，test时dropout不起作用，keep_prob:1.0

参数解析：
(1)input---输入
        类型：tensor
(2)keep_prob---每个神经元保留下来的概率
        类型：tf.float型，初始化为一个占位符，keep_prob=tf.placcholder(tf.float32\tf.float64)
        tensorflow在run时通过feed_dict字典的方式设置keep_prob的具体值
(3)noise_shape---1维的int32张量
(4)seed----整型变量，随机数种子
(5)name----该操作的名字
(6)返回结果：类型：Tensor

6、tf.argmax(input,axis=None,name=None,dimension=None)

功能：返回沿某个维度最大值的位置
参数解析：
(1)input----输入Tensor
(2)axis:0 表示列；1 表示行；
(3)name----操作的名字
(4)dimension--(作用同axis一致，但是axis字段优先)
(5)返回结果：
        类型：Tensor
        表示按照行\列最大值的下标向量

7、tf.cast(input,dtype,name=None)
功能：强制类型转换

参数解析：
(1)input----输入
(2)dtype----转换的目标类型
(3)name-----操作的名称
(4)返回结果：类型：Tensor

8、tf.train.AdamOptimizer(leaning_rate).minimize(loss)

功能：采用Adam优化算法，找到全局最优点；
优点: 不易陷入局部优点，速度快；
包括：
    初始化参数：__init__
    method: apply_gradients()
            minimize()
列子：optimizer=tf.train.AdamOptimizer(learning_rate)//实例化优化函数
    train_step=optimizer.minimize(loss)
优化器的类型：
(1)AdadeltaOptimizer
(2)AdagradOptimizer
(3)MomentumOptimizer
(4)AdamOptimizer
(5)FtrlOptimizer
(6)RMSPropOptimizer

9、汇总操作Summary Operations

可以在一个session中获取summary操作的输出，并将其传输到SummaryWriter以添加至一个事件记录文件(tfevent)中。
tf.summary.merge_all()-----合并graph中的summary

10、tf.graph()
功能：将网络结构通过Tensorboard用图形化的界面显示出来;
11、tf.nn.softmax_cross_entropy_with_logits(logits,labels,name=None)

功能：先做softmax运算，然后计算预测值与实际值的交叉熵
参数解析：
(1)logits---网络最后一层的输出
        类型：有batch时，[logits,num_classes]
             无batch时，[num_classes]
        适用于分类
(2)labels---标签
(3)返回：1个向量[每个元素是每一类的预测值和实际值的交叉熵]
so ,之后做tf.reduce_sum()求和；若要求loss，要加上一步tf.reduce_mean()求得均值。

12、tf.dynamic_partition(data,partition,num_partition,name=None)

功能：拆分Tensor
参数解析：
(1)data----输入Tensor
(2)partition---分块
        类型：Tensor,int32,数值范围在[0,num_partition)
(3)num_partition--->=1,表示输出的个数
(4)name---操作的名字
(5)返回结果：num_partition个Tensor

13、tf.concat(values,axis,name=‘concat’)

功能:按照指定维度连接若干不同tensor
参数解析：
(1)values--类型：一个元素类型是tensor的list或者tuple
(2)axis----连接的维度
(3)返回结果：
     连接后的Tensor
例子：
    t1 = [[[1, 2], [2, 3]], [[4, 4], [5, 3]]]        #shape=[2,2,2]
    t2 = [[[7, 4], [8, 4]], [[2, 10], [15, 11]]]     #shape=[2,2,2]
    tf.concat([t1, t2], -1)或者tf.concat([t1, t2], axis=-1)
    返回结果：shape=[2,2,4]

二、TF-Slim

(1)功能：将模型建立、训练、预估变得简单化;即使是复杂模型，建立过程变得简单化(提供部分已有的模型作为黑盒)
(2)导入方式：import tensorflow.contrib.slim as slim
(3)包含部分：
    arg_scope   ： 提供了一个名为arg_scope的新作用域，允许用户为该作用域内的特定操作定义默认参数。
    data        ： 包含TF-slim的数据集定义，数据提供者，并行编译器和解码工具。
    evaluation  ： 包含评估模型的例程。
    layers      ： 包含使用张量流建立模型的高层次图层。
    learning    ： 包含训练模型的例程。
    losses      ： 包含常用损失函数。
    metrics     ： 包含流行的评估指标。
    nets        ： 包含流行的网络定义，如VGG和AlexNet模型。
    queues      ： 提供了一个上下文管理器，可以轻松安全地启动和关闭QueueRunners。
    regularizers： 包含权重正规化者。
    variables   ： 为变量创建和操作提供便利包装
    
1、arg_scope(list_op_or_scope,**kwargs)
        参数解析：
        (1)list_op_or_scope---操作列表或作用域列表
        (2)kwargs-------------表示参数，以键值对(key=value)的方式
        例子：
        net = slim.conv2d(inputs, 64, [11, 11], 4, padding='SAME',
                          weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
                          weights_regularizer=slim.l2_regularizer(0.0005), scope='conv1')
        net = slim.conv2d(net, 128, [11, 11], padding='VALID',
                          weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
                          weights_regularizer=slim.l2_regularizer(0.0005), scope='conv2')
        将以上重复的部分通过slim.arg_scope进行整合，简化为：
        with slim.arg_scope([slim.conv2d],padding='SAME',
                          weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
                          weights_regularizer=slim.l2_regularizer(0.0005))
            net = slim.conv2d(inputs, 64, [11, 11], 4,scope='conv1')
            net = slim.conv2d(net, 128, [11, 11], padding='VALID',scope='conv2')
2、data包下边的操作方法
    data_decoder
    data_provider
    dataset
    dataset_data_provider
    parallel_reader
    prefetch_queue
    tfexample_decoder
    导入方法：from tensorflow.contrib.slim.python.slim.data import xxxxxx
3、evaluation.py提供评估函数，计算评估指标、打印、汇总度量结果
4、layers包

    标准接口组建网络：
        slim.bias_add
        slim.batch_norm
        slim.conv2d
        slim.conv2d_in_plane
        slim.conv2d_transpose
        slim.fully_connected
        slim.avg_pool2d
        slim.dropout
        slim.flatten
        slim.max_pool2d
        slim.one_hot_encoding
        slim.separable_conv2d
        slim.unit_norm
    运算符slim.repeat\stack
    例子：
        (1)net=slim.repeat(net,3,slim.conv2d,256,[3,3],scope='conv3')//scope后边自动追加下划线和迭代数字
        等价于
           net=slim.conv2d(net,256,[3,3],scope='conv3_1')
           net=slim.conv2d(net,256,[3,3],scope='conv3_2')
           net=slim.conv2d(net,256,[3,3],scope='conv3_3')
        (2)slim.stack()用不同的参数重复一样的操作，并且scope也会追加
           slim.stack(x,slim.fully_connected,[32,64,128],scope='fc')
        等价于
           x=slim.fully_connected(x,32,scope='fc\fc_1')
           x=slim.fully_connected(x,64,scope='fc\fc_2')
           x=slim.fully_connected(x,128,scope='fc\fc_3')
        例2：卷积核的个数和尺寸不一致
           x=slim.conv2d(x,32,[3,3],scope='core\core_1')
           x=slim.conv2d(x,32,[1,1],scope='core\core_2')
           x=slim.conv2d(x,64,[4,4],scope='core\core_3')
           x=slim.conv2d(x,128,[2,2],scope='core\core_4')
        等价于  //将每一个卷积核的尺寸和个数封装在一起
           slim.stack(x,slim.conv2d,[(32,[3,3]),[(32,[1,1])],[(64,[4,4])],[(128,[2,2])],scope='core'])
5、learning.py
        例子：
        
        total_loss=slim.losses.get_total_loss()
        optimizer=tf.train.GradientDescentOptimizer(learning_rate)
        
        train_op=slim.learning.creat_train_op(total_loss,optimizer)

        logdir=……
        slim.learning.train(
            train_op,
            logdir,
            number_of_steps=1000,
            save_summaries_secs=300,//每隔300s计算刷新一次summary
            save_interval_secs=600 //每隔600s保存一次模型
        )
6、losses包
    功能：针对不同的任务，提供不同的损失函数。
    例子：分类任务，选择classification_loss=slim.losses.softmax_cross_entropy()
        平方差之和，选择sum_of_square_loss=slim.losses.sum_of_square()
        总的损失，total_loss=classification_loss+sum_of_square_loss等价于
                 total_loss=slim.losses.get_total_loss()
    可以自定义损失函数，并且将新的损失函数加入到losses中，让losses包来管理自定义的损失函数
    例子：
        pose_loss=Mylossfunction(pose_predictionl,pose_label)

        slim.losses.add_loss(pose_loss)

        regularization_loss=tf.add_n(slim.losses.get_regularization_losses())//加入正则化损失
        total_loss1=classification_loss+sum_of_square_loss+pose_loss+regularization_loss
        等价于
        total_loss2=slim.losses.get_total_loss(add_regularization_losses=True)
7、metrics包
    功能：包含常用的评价指标
8、nets包
    功能：包含常用的神经网络net
    例子：
        from tensorflow.contrib.slim.python.slim.nets import alexnet 
        from tensorflow.contrib.slim.python.slim.nets import overfeat
        from tensorflow.contrib.slim.python.slim.nets import xxxxxx
9、variables包
    功能：创建变量(初始化)
    指明变量名，shape,初始化，指定设备，……
    例子：
        weights=slim.variable('weights',
                                shape=[10,10,10,3],
                                initizlizer=tf.truncated_normal_initializer(stddev=0.1),
                                regularizer=slim.l2_regularizer(0.05),
                                device='/CPU:0')
    类型分类1：全局变量(常规变量)、局部变量(本地变量\瞬态变量)
              全局变量：全局范围有效，可以保存到磁盘；
              局部变量：局部范围有效，生存周期只在会话期间存在的变量，无法保存到磁盘上。
    类型分类2：模型变量、非模型变量
              模型变量：模型参数的变量，可以在训练期间被训练、调整，如:卷积操作中的创建的变量
              例子：
                weights=slim.model_variable(……) #创建模型变量
                model_variables=slim.get_model_variables() #得到模型变量
            regular_variable_and_model_variable=slim.get_variables() #得到常规变量或模型变量
    当然，自己可以创建一个model，并且将自定义模型中的模型变量加入到slim中进行管理和使用
        例子：
            my_model_variable=mymodel()
            slim.add_model_variable(my_model_variable)

三、Kears深度学习库(基于Theao、Tensorflow深层次的学习库)

Sequential模型
泛型模型
常用层
卷积层
池化层
递归层
嵌入层(Embedding)
基本概念梳理
    1、Sequential模型----一系列网络层按一定顺序构成的栈
    特点：
        (1)单输入、单输出
        (2)层层堆叠，只有相邻关系，没有跨层连接
        (3)编译速度快
        (4)操作简单
    例子：
    模型对象---网络层的搭建----编译----迭代训练----测试评估
        from keras.models import Sequential            #导入Sequential模块
        model=Sequential()                             #实例化一个对象
                                                    #堆叠网络层到model中
        from keras.layers import Dense,Activation   
        model.add(Dense(output_dim=64,input_dim=10))   #add的方式加入网络层
        model.add(Activation('relu'))
        model.add(Dense(output_dim=10))
        model.add(Activation('softmax'))               #model搭建over
        or模型堆叠过程也可以简化为list形式:
        model=Sequential(
            [
                Dense(output_dim=64,input_dim=10),
                Activation('relu'),
                Dense(output_dim=10)
                Activation('softmax')
            ]
        )
                                                    #complie编译模型,需要指明损失函数和优化器类型，完成相应配置
        model.compile(loss='categorical_crossentropy',optimizer='sgd',metric=['accuracy']) 
                                                    #按照batch训练一定次数的迭代训练
        model.fit(X_train,y_train,nb_epoch=5,batch_size=32)
        或者循环的方式一次将每个batch数据送入到网络中进行训练 
        具体为：  model.train_on_batch(X_batch,y_batch)
                                                    #使用test数据进行模型评估
        loss_and_metrics=model.evaluate(X_test,y_test,batch_size=32)     
    2、模型的第一层一般需要指定输入数据的shape，之后的各层可以自动的推导出中间数据的shape,so 不需要指定该参数
        三种方式的列子：
            (1)input_shape=(10,64)     #batch需要在额外参数指明
            (2)batch_input_shape=(None,10,64)
            (3)input_length=10,input_dim=64
    3、merge层(相当于tf.concat)
        功能：合并多个Sequential的输出到一个输出，同时可以将merge
        格式：
            merged=Merge([s1.s2],mode='concat')
            参数解析：
                (1)Tensor组成的list；
                (2)mode---合并模式，
                模式分类：sum--------默认模式，逐元素相加；
                        concat-----按照某个维度进行连接；
                        mul--------逐元素相乘；
                        ave--------张量平均值
                        dot--------张量相乘
                        cos--------张量中各向量的cos值；
    4、compile()
        功能：完成对学习过程的配置，编译
        参数解析：
            (1)优化器optimizer----预先定义好的优化器名(rmsprop\adagrad)或者Optimizer类对象;
            (2)损失函数loss-------最小化的目标，可以是预先定义的损失函数名(categprical_crossentropy\mse)
            (3)指标列表metrics
        例子：
            (1)分类问题-----model.compile(loss='categorical_crossentropy',optimizer='rmsprop',metrics=['accuracy'])
            (2)回归问题-----model.complie(loss='mse',optimizer='rmsprop')
    5、fit()
        功能：输入需要训练的数据和对应的label，完成模型的训练。
        model.fit(input_data,input_label,nb_epoch=10,batch_size=32)
        参数解析：
            (1)input_data----输入数据---------类型-----numpy
            (2)input_label---对应的Label------类型-----numpy
            (3)nb_epoch------训练的轮次-------类型-----int
            (4)batch_size----每个batch的大小--类型-----int
        例子：将两个LSTM合并作为编码端来处理两路序列的分类
            from keras.models import Sequential
            from keras.layers import Dense,LSTM,Merge
            import numpy as num_partition

            data_dim=16
            timestep=8
            np_classes=10

            encoder_a=Sequential()
            encoder_a.add(LSTM(32,input_shape=(timestep,data_dim)))

            encoder_b=Sequential()
            encoder_b.add(LSTM(32，input_shape=(timestep,data_dim)))

            decoder=Sequential()
            decoder.add(Merge([encoder_a,encoder_b],mode='concat'))
            decoder.add(Dense(32,activation='relu'))
            decoder.add(Dense(10,activation='softmax'))

            decoder.compile(loss='categorical_crossentropy',optimizer=''rmsprop,metrics=['accuracy'])

            x_train_a=np.random.random(1000,timestep,data_dim)
            x_train_b=np.random.random(1000,timestep,data_dim)
            y_train=np.random.random(1000,np_classes)

            x_val_a=np.random.random(1000,timestep,data_dim)
            x_val_b=np.random.random(1000,timestep,data_dim)
            y_val=np.random.random(1000,np_classes)

            decoder.fit([x_train_a,x_train_b],y_train,nb_epoch=10,batch_size=64,validation_data=([x_val_a,x_val_b],y_val))
    新模型的建立，就是将一个搭建好的网络，组合输入、输出，即是一个model
        例子：
            input_1=……
            input_2=……
            #中间进行若干处理#
            out_1=……
            out_2=……
            model=Model(input=[input_1,input_2],output=[out_1,out_2])
    6、常用层
        Dense层--------------------------全连接层(必须指明输出维度output_dim，其他参数均有default)
        Activation层---------------------对一个层的输出施加激活函数
        Dropout层------------------------防止过拟合，以一定百分比随机断开某些神经元的连接
        Flatten层------------------------多维输入一维化,不改变batch的大小
        Reshape层------------------------调整输入的shape转化为指定的shape，不改变batch的大小
        Permute层---------****-----------按照给定模式将输入的维度进行重排(多用在RNN\CNN)
        RepeatVector层-------------------输入重复n次后输出
        Merge层--------------------------将一个张量列表中的张量按照某种合并模式变成一个张量
        Lambda层----------****-----------对上一层输出施加某种操作
        ActivityRegularizer层
        Masking层---------****-----------使用给定的指对输入的序列掩盖\屏蔽某些时间步
        Highway层------------------------建立全连接的Highway网络
        MaxoutDense层--------------------全连接的Maxout层，选泽最大值作为输出
        
        (1)Permute(dims)
            dims----类型：tuple-----不包含样本数的维度，从1开始
        (2)Lambda(function,output_shape=None,arguments={})
            function-------对输入施加的某种操作，
                        函数仅仅接受一个变量，即上一层的输入;
        (3)Masking(mask_value=0.,input_shape=(timesteps,features))
            假设输入x[:,3,:]=0,x[:,5,:]=0
            则masking层将时间步为3和5的信号掩盖，并且3和5的时间步将在模型接下来的所有支持masking的层中被跳过。
    7、卷积层
        Convolution1D------------------对一维输入进行邻域滤波
        AtrousConvolution1D------------对一维输入进行带膨胀滤波(atrous_rate为膨胀率)
        Convolution2D------------------对二维输入进行滤波(dim_ordering指明通道排列在input中的位置)
                                    若：dim_ordering='th'-----通道维度在第1个位置(不同库默认值不同)
                                    若：dim_ordering='tf'-----通道维度在第3个位置
        AtrousConvolution2D------------对二维输入进行带膨胀滤波(atrous_rate为膨胀率)
        MaxPooling1D-------------------对时域1D信号进行最大值池化
                                    参数:pool_length=2
        MaxPooling2D-------------------对二维信号进行最大值池化
        AveragePooling1D---------------对时域1D信号进行平均值池化
                                    参数:pool_length=2
        GlobalMaxPooling1D-------------对时域1D信号进行全局最大池化
        AveragePooling2D---------------对时域2D信号进行平均值池化
    8、递归层
        SimpleRNN----------------------全连接RNN，RNN的输出会被回馈到输入
                                    keras.layers.recurrent.SimpleRNN()
        GRU----------------------------门限递归单元
                                    keras.layers.recurrent.GRU()
        LSTM---------------------------长短期记忆模型
                                    keras.layers.recurrent.LSTM()
    9、嵌入层Embedding------------------数字化到向量化的编码方式(将正整数转为固定大小的向量)
                                    note:Embeddding只能作为model的第一层
模块包(Keras包括14个模块包)
    (1)Models--------------------------对各个组件进行组装--from keras.models import Sequential
    (2)Layers--------------------------包含不同的网络层(Core layers\Convolutional layers\Recurrent layers\advanced_activations layers\normalization layers\embeddings layers)
    (3)initializations-----------------对网络中参数初始化(uniform\normal\orthogonal\zero\...)
                                        (......init='uniform')
    (4)Activation----------------------为网络层加入激活函数(linear\sigmoid\tanh\relu\hard_sigmoid\softplus\softmax\leakyrelu\prelu\...)
                                        (......activation='relu')
    (5)Objectives----------------------为网络附加损失目标函数(mean_squared_error\mean_absolute_error\squared_hinge\binary_crossentropy\categorical_crossentropy\...)
                                        (....loss='binary_crossentropy')
    (6)Optimizers----------------------设定网络的优化办法(sgd\adagrad\rmsprop\adam\adadelta\...)
                                        (....optimizer='sgd')
                                       or keras.optimizers.SGD(lr=0.001,decay=0.9,momentum=0.9,nesterov=False)
                                       上面的代码是SGD的使用方法，
                                       lr表示学习速率,
                                       momentum表示动量项，
                                       decay是学习速率的衰减系数(每个epoch衰减一次),
                                       Nesterov的值是False或者True，表示使不使用Nesterov momentum。
    (7)Preprocessing-------------------数据预处理----对序列数据\文本数据\图像数据的处理
    (8)metrics-------------------------评价模块
                                       predict=model.predict_classes(test_x)
                                       keras.metrics.binary_accuracy(test_y,predict)#得到二分类问题的accuracy