Coursera-吴恩达-深度学习-第四章：Convolutional Neural Network- 第一周-Computer Vision

本周学习内容

• Convolutional Neural Networks
  • Compute vision
  • Edge Detection Example (边缘检测示例)
  • More Edge Detection
  • Padding
  • Strided Convolutions （卷积步长）
  • Convolutions Over Volume （三维卷积）
  • One Layer of a Convolutional Network （单层卷积网络）
  • Pooling Layers （池化层）
  • CNN Example
  • Why Convolutions?

测验

1.因为左边部分是正的，右边是负的，即左亮右暗；另外中心区域的权重被增加了。

2. $W^{[1]}=[l^{[1]},X]$ = [100,3003003] = 100300300*3=27,000,000, 另外100个节点，每个节点有一个偏置参数，共100个。
3. （1.7单层卷积网络）CNN的参数数目与图片尺寸无关，至由滤波器组决定，数目相对来说要少得多，这是CNN的优势之一。
权重维度公式$f^{[l]}\ast f^{[l]}\ast n_c^{[l-1]}\ast n_c^{[l1]}$ 前三项为一个滤波器维度，最后一项为滤波器数目；所以此题中 5x5x3，每一个滤波器还有一个偏置参数，所以每一个滤波器有76个参数，共100个滤波器。

代码练习

1.逐步实现CNN

将使用numpy实现卷积（CONV）和池化（POOL）层，包括正向传播和反向传播。

作业大纲

• 卷积函数
  • zero padding
  • Convolve window
  • Convolution forward
  • Convolution backward
• 池化函数
  • Pooling forward
  • Create mask
  • Distribute value
  • Pooling backward

1.Convolutional Neural Networks

1.1 Zero-Padding

def zero_pad(X,pad):
    """
    把数据集X的图像边界全部使用0来扩充pad个宽度和高度。
    
    参数：
        X - 图像数据集，维度为（样本数，图像高度，图像宽度，图像通道数）
        pad - 整数，每个图像在垂直和水平维度上的填充量
    返回：
        X_paded - 扩充后的图像数据集，维度为（样本数，图像高度 + 2*pad，图像宽度 + 2*pad，图像通道数）
    
    """
    
    X_paded = np.pad(X,(
                        (0,0),       #样本数，不填充
                        (pad,pad),   #图像高度,你可以视为上面填充x个，下面填充y个(x,y)
                        (pad,pad),   #图像宽度,你可以视为左边填充x个，右边填充y个(x,y)
                        (0,0)),      #通道数，不填充
                        'constant', constant_values=0)      #连续一样的值填充
    
    return X_paded
                          

1.2 单步卷积

---

2.卷积网络的应用

• 完成模型构建所需的辅助函数
• 使用Tensorflow实现功能全面的ConvNet

1.TensorFlow model

1.1 Create placeholders

def create_placeholders(n_H0, n_W0, n_C0, n_y):
    """
    为session创建占位符
    
    参数：
        n_H0 - 实数，输入图像的高度
        n_W0 - 实数，输入图像的宽度
        n_C0 - 实数，输入的通道数
        n_y  - 实数，分类数
        
    输出：
        X - 输入数据的占位符，维度为[None, n_H0, n_W0, n_C0]，类型为"float"
        Y - 输入数据的标签的占位符，维度为[None, n_y]，维度为"float"
    """
    X = tf.placeholder(tf.float32,[None, n_H0, n_W0, n_C0])
    Y = tf.placeholder(tf.float32,[None, n_y])
    
    return X,Y

1.2 Initialize Parameters

• 使用tf.contrib.layers.xavier_initializer(seed = 0)初始化权重/滤波器 W1,W2;
• 注意只会为conv2d函数初始化权重/滤波器，TensoFlow将自动初始化全连接部分的层；
• 初始化参数W使用：W = tf.get_variable("W", [1,2,3,4], initializer = ...)

def create_placeholders(n_H0, n_W0, n_C0, n_y):
    """
    为session创建占位符
    
    参数：
        n_H0 - 实数，输入图像的高度
        n_W0 - 实数，输入图像的宽度
        n_C0 - 实数，输入的通道数
        n_y  - 实数，分类数
        
    输出：
        X - 输入数据的占位符，维度为[None, n_H0, n_W0, n_C0]，类型为"float"
        Y - 输入数据的标签的占位符，维度为[None, n_y]，维度为"float"
    """
    X = tf.placeholder(tf.float32,[None, n_H0, n_W0, n_C0])
    Y = tf.placeholder(tf.float32,[None, n_y])
    
    return X,Y

1.3 Forward Propagation

• tf.nn.conv2d(X, W1, strides = [1,s,s,1], padding = 'SAME') 给定输入和一组滤波器，函数将使用的滤波器卷积X。第三个输入([1,f,f,1])表示输入的每个维度(m, n_H_prev, n_W_prev, n_C_prev)的步幅.
  *tf.nn.max_pool(A,ksize=[1,f,f,1],strides=[1,s,s,1],padding = 'SAME'): 给定输入A，此函数使用大小为（f，f）的窗口和大小为（s，s）的步幅在每个窗口上进行最大池化。
• tf.nn.relu(Z1)
• tf.contrib.layers.flatten(P)
• tf.contrib.layers.full_connectd(F, num_outputs)

# GRADED FUNCTION: forward_propagation

def forward_propagation(X, parameters):
    """
    Implements the forward propagation for the model:
    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
    
    Note that for simplicity and grading purposes, we'll hard-code some values
    such as the stride and kernel (filter) sizes. 
    Normally, functions should take these values as function parameters.
    
    Arguments:
    X -- input dataset placeholder, of shape (input size, number of examples)
    parameters -- python dictionary containing your parameters "W1", "W2"
                  the shapes are given in initialize_parameters

    Returns:
    Z3 -- the output of the last LINEAR unit
    """
    
    # Retrieve the parameters from the dictionary "parameters" 
    W1 = parameters['W1']
    W2 = parameters['W2']
    
    ### START CODE HERE ###
    # CONV2D: stride of 1, padding 'SAME'
    Z1 = tf.nn.conv2d(X, W1, strides = [1,1,1,1], padding = 'SAME')
    # RELU
    A1 = tf.nn.relu(Z1)
    # MAXPOOL: window 8x8, stride 8, padding 'SAME'
    P1 = tf.nn.max_pool(A1, ksize = [1,8,8,1], strides = [1, 8, 8,1], padding = 'SAME')
    # CONV2D: filters W2, stride 1, padding 'SAME'
    Z2 = tf.nn.conv2d(P1,W2, strides = [1,1,1,1], padding = 'SAME')
    # RELU
    A2 = tf.nn.relu(Z2)
    # MAXPOOL: window 4x4, stride 4, padding 'SAME'
    P2 = tf.nn.max_pool(A2, ksize = [1,4,4,1], strides = [1,4,4,1], padding = 'SAME')
    # FLATTEN
    F = tf.contrib.layers.flatten(P2)
    # FULLY-CONNECTED without non-linear activation function (not not call softmax).
    # 6 neurons in output layer. Hint: one of the arguments should be "activation_fn=None" 
    Z3 = tf.contrib.layers.fully_connected(F, num_outputs = 6, activation_fn=None)
    ### END CODE HERE ###

    return Z3

1.4 Compute Cost

• tf.nn.softmax_cross_entropy_with_logists(logits = Z3, labels = Y）
• tf.reduce_mean() 计算张量各维度上元素的均值，用它来对所有训练示例的损失求和，以活的总损失。