吴恩达深度学习 | (13) 改善深层神经网络专项课程第三周编程作业

吴恩达深度学习专项课程的所有实验均采用iPython Notebooks实现，不熟悉的朋友可以提前使用一下Notebooks。本周的实验主要是熟悉一下深度学习框架Tensorflow的使用，并用Tensorflow搭建一个简单的3层神经网络完成多分类。之前我们学习了很多正则化(dropout,L2等）和加速模型训练（Adam，Batch Norm，Momentum，mini-batch等）的技术，这些技术首先要掌握它的原理，然后可以纯手写实现这些技术进一步加深理解就够了。至于把这些技术整合在一起实现一个复杂的深度模型时，推荐使用深度学习框架，可以极大的提高开发效率。所以掌握一种主流的深度学习框架非常重要，推荐使用Tensorflow。而且使用Tensorflow，只需要保证前向传播过程和计算代价函数正确实施，那么就定义好了模型结构(计算图)，然后选择一个优化算法最小化代价函数更新参数就好了，反向传播计算梯度的过程可以自动沿着定义好的计算图完成。

目录

1.实验综述

2.导入必要的包

3.Tensorflow的简单使用

4.用Tensorflow搭建第一个神经网络

5.总结

6.实验完整代码

---

1.实验综述

2.导入必要的包

import math
import numpy as np
import h5py  #用于与存储为h5文件格式的数据集进行交互
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
#tf_utils.py 中定义了本次实验中必要的函数 如加载数据集，划分mini-batch，转换one-hot编码，predict等
from tf_utils import load_dataset,random_mini_batches,convert_to_one_hot,predict

%matplotlib inline
np.random.seed(1)

3.Tensorflow的简单使用

• 计算一个样本的损失

y_hat = tf.constant(36,name='y_hat') #把y_hat定义为一个常量 36
y = tf.constant(39,name='y') #把y定义为一个常量 39

loss = tf.Variable((y-y_hat)**2,name='loss') #为loss创建一个变量

init = tf.global_variables_initializer() #当init运行时 sess.run(init)
                                        #loss变量将会被初始化并被计算

with tf.Session() as sess: #创建一个会话
    sess.run(init)        #初始化变量
    print(sess.run(loss))  #打印损失

• 简单例子

a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)  #也可以写成 c=a*b  tf不仅封装了各种运算 而且也重载了各种运算符
print(c)

sess = tf.Session()
print(sess.run(c))

• placeholder

x = tf.placeholder(tf.int64,name='x')
print(sess.run(2*x,feed_dict={x:2}))
sess.close()

• 线性函数

def linear_function():
    """
    实现线性函数
            初始化W为一个（4，3）的随机tensor
            初始化X为一个（3，1）的随机tensor
            初始化b为一个（4，1）的随机tensor
    返回: 
    result -- 运行session 计算Y=WX+b
    """
    
    np.random.seed(1)
    
    #初始化constant
    W = tf.constant(np.random.randn(4,3),name='W')
    X = tf.constant(np.random.randn(3,1),name='X')
    b = tf.constant(np.random.randn(4,1),name='b')
    #定义一个计算图
    Y = tf.add(tf.matmul(W, X), b)

    
    #创建session 运行计算图 计算Y的值
    sess = tf.Session()
    result = sess.run(Y)
    
    #关闭session
    sess.close()

    return result

• 计算sigmoid

# GRADED FUNCTION: sigmoid

def sigmoid(z):
    """
    计算sigmoid(z)  
    
    参数:
    z -- 输入值 变量或向量
    
    返回: 
    results -- sigmoid(z)
    """
    #创建placeholder
    x = tf.placeholder(tf.float32,name='x')
    #定义计算图 计算sigmoid（x）
    sigmoid = tf.sigmoid(x)
    
    #创建session 并运行
    #需要通过feed_dict 把z feed 给x
    with tf.Session() as sess:
        result = sess.run(sigmoid,feed_dict={x:z})
    
    return result

• 计算cost

def cost(logits, labels):
    """
    使用sigmoid cross entropy计算cost
    
    参数:
    logits -- 向量z(1,m)，输出层再经过sigmoid激活函数前的中间结果
    labels -- 真实标签 0/1 (1,m) y
    
    Note: z在tf称为logits，y称为labels
    
    返回:
    cost -- 运行session得到的cost (formula (2))
    """
    
    
    #为logits，labels创建placeholder
    z = tf.placeholder(tf.float32,name='z')
    y = tf.placeholder(tf.float32,name='y')
    
    #定义计算图
    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z,labels=y)
    
    #创建session 运行计算图 
    with tf.Session() as sess:
        cost = sess.run(cost,feed_dict={z:logits,y:labels}) 
    

    return cost

• 使用one-hot编码

def one_hot_matrix(labels, C):
    """
    创建一个矩阵 第i行代表第i个分类类别，第j列对应第j个样本. 因此第j个样本的标签如果是i，那么(i,j)=1 
                     
                     
    参数:
    labels -- 样本真实标签向量 y (1,m)
    C -- 分类的类别数 one-hot矩阵的depth
    
    返回: 
    one_hot -- one hot 矩阵 (C,m)
    """
    
    #创建一个tf常量等于C（depth） 命名为C  进行一个封装
    C = tf.constant(C,name='C')
    
    #定义一个计算图
    one_hot_matrix = tf.one_hot(labels,C,axis=0)  #axis=0 是one-hot矩阵中每一列代表一个样本
    
    #创建session 并运行计算图
    with tf.Session() as sess:
        one_hot = sess.run(one_hot_matrix)

    return one_hot

• 用0或1初始化数组

def ones(shape):
    """
    创建一个shape维的全为1 的数组(tensor)
    
    参数:
    shape -- 你要创建的数组(tensor)的维度
        
    返回: 
    ones -- shape维的 元素全为1 的数组(tensor)
    """
    #定义一个计算图
    ones = tf.ones(shape)
    
    #创建session 运行计算图
    with tf.Session() as sess:
        ones = sess.run(ones)
    return ones

4.用Tensorflow搭建第一个神经网络

• signs数据集

• 加载数据集

#加载数据集
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()
#可视化某个样本
index = 0
plt.imshow(X_train_orig[index])
print ("y = " + str(np.squeeze(Y_train_orig[:, index])))

• 数据集预处理

X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0],-1).T
X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0],-1).T

X_train = X_train_flatten/255
X_test = X_test_flatten/255

Y_train = convert_to_one_hot(Y_train_orig,6)
Y_test = convert_to_one_hot(Y_test_orig,6)

print ("number of training examples = " + str(X_train.shape[1]))
print ("number of test examples = " + str(X_test.shape[1]))
print ("X_train shape: " + str(X_train.shape))
print ("Y_train shape: " + str(Y_train.shape))
print ("X_test shape: " + str(X_test.shape))
print ("Y_test shape: " + str(Y_test.shape))

• 创建placeholder

首先需要为X，Y创建placeholder。在之后运行session时，再feed相应的训练数据。

def create_placeholders(n_x, n_y):
    """
    为X，Y创建placeholder
    
    Arguments:
    n_x -- 标量，一张图片特征向量的大小，num_px * num_px*3 = 64 * 64 * 3 = 12288
    n_y -- 标量，分类的类别数 6 （0-5）
    
    Returns:
    X -- 输入数据特征矩阵的placeholder [n_x,None] 每一列代表一张图片的特征向量 float32
    Y -- 输入数据标签的placeholder [n_y,None] 每一列代表一张图片的标签(one-hot) float32
          None代表图片/样本数不确定  以运行session时 feed的样本数为准，可以灵活的传入任何样本数
    
    """
    

    #创建placeholder
    X = tf.placeholder(tf.float32,[n_x,None])
    Y = tf.placeholder(tf.float32,[n_y,None])
    
    return X, Y

• 初始化模型参数

def initialize_parameters():
    """
    用TF为神经网络初始化参数（3层）
                        W1 : [25, 12288]
                        b1 : [25, 1]
                        W2 : [12, 25]
                        b2 : [12, 1]
                        W3 : [6, 12]
                        b3 : [6, 1]
    
    Returns:
    parameters -- 字典形式 包含W1, b1, W2, b2, W3, b3
    """
    
    tf.set_random_seed(1)                   
        
    W1 = tf.get_variable('W1',[25,12288],initializer=tf.contrib.layers.xavier_initializer(seed=1))
    b1 = tf.get_variable('b1',[25,1],initializer=tf.zeros_initializer())
    W2 = tf.get_variable('W2',[12,25],initializer=tf.contrib.layers.xavier_initializer(seed=1))
    b2 = tf.get_variable('b2',[12,1],initializer=tf.zeros_initializer())
    W3 = tf.get_variable('W3',[6,12],initializer=tf.contrib.layers.xavier_initializer(seed=1))
    b3 = tf.get_variable('b3',[6,1],initializer=tf.zeros_initializer())

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2,
                  "W3": W3,
                  "b3": b3}
    
    return parameters

• TF中的前向传播

def forward_propagation(X, parameters):
    """
    实现3层网络的前向传播: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX
    
    参数:
    X -- 输入数据特征矩阵的placeholder [n_x,None] 每一列代表一张图片的特征向量
    parameters -- Python字典 包含模型参数 "W1", "b1", "W2", "b2", "W3", "b3"

    Returns:
    Z3 -- 输出层的线性组合中间结果 ，通过激活函数之前的结果
    """
    
    # 取出参数
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    W3 = parameters['W3']
    b3 = parameters['b3']
    
    #前向传播   定义计算图（网络结构）
    Z1 = tf.add(tf.matmul(W1,X),b1)
    A1 = tf.nn.relu(Z1)
    Z2 = tf.add(tf.matmul(W2,A1),b2)
    A2 = tf.nn.relu(Z2)
    Z3 = tf.add(tf.matmul(W3,A2),b3)
    
    return Z3

• 计算cost

def compute_cost(Z3, Y):
    """
    计算 cost
    
    Arguments:
    Z3 -- 前向传播的输出 输出层的线性单元 (num_classes=6,number of examples(None))
    Y -- 输入数据标签的placeholder [n_y=6,None] 每一列代表一张图片的标签(one-hot) 
    
    Returns:
    cost 
    """
    #转换为默认维度
    logits = tf.transpose(Z3)
    labels = tf.transpose(Y)
    
    #计算cost
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=labels))

    return cost

• 反向传播&更新参数

• 构建模型

把之前实现的部分都组合在一起。

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,
          num_epochs = 1500, minibatch_size = 32, print_cost = True):
    """
    实现一个3层TF神经网络: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
    
    Arguments:
    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
    X_test -- training set, of shape (input size = 12288, number of training examples = 120)
    Y_test -- test set, of shape (output size = 6, number of test examples = 120)
    learning_rate -- learning rate of the optimization
    num_epochs -- number of epochs of the optimization loop
    minibatch_size -- size of a minibatch
    print_cost -- True to print the cost every 100 epochs
    
    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """
    
    ops.reset_default_graph()                        
    tf.set_random_seed(1)                             
    seed = 3                                          
    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)
    n_y = Y_train.shape[0]                            # n_y : output size
    costs = []                                        # To keep track of the cost
    
    '''***定义一个计算图***'''
    #为X，Y创建placeholder
    X,Y = create_placeholders(n_x,n_y)
    
    #初始化模型参数
    parameters = initialize_parameters()
    
    #前向传播
    Z3 = forward_propagation(X,parameters)
    
    #计算cost
    cost = compute_cost(Z3,Y)
    
    #反向传播 更新参数
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
    
    init = tf.global_variables_initializer()
    
    '''***多次运行计算图，通过设置的placeholder每次灵活的feed不同的mini-batch***'''
    
    with tf.Session() as sess:
        
        # 运行init 
        sess.run(init)
        
        # 设置epoch
        for epoch in range(num_epochs):

            epoch_cost = 0.                      
            num_minibatches = int(m / minibatch_size) # 划分mini-batch的数量
            seed = seed + 1
            #对训练集划分mini-batch
            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

            for minibatch in minibatches: #遍历每个mini-batch

                # 选择一个mini-batch
                (minibatch_X, minibatch_Y) = minibatch
                
                #反复运行定义好的计算图 每次feed一个mini-batch
                _,minibatch_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
                
                epoch_cost += minibatch_cost / num_minibatches

           
            if print_cost == True and epoch % 100 == 0:
                print ("Cost after epoch %i: %f" % (epoch, epoch_cost))
            if print_cost == True and epoch % 5 == 0:
                costs.append(epoch_cost)
                
       
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()

        # 把模型参数保存起来
        parameters = sess.run(parameters)
        print ("Parameters have been trained!")

        # Calculate the correct predictions
        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))

        # Calculate accuracy on the test set
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

        print ("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
        print ("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))
        
        return parameters

• 训练模型

• 总结

• 用自己的图片做测试

#读取图片需要的库
import scipy
from PIL import Image
from scipy import ndimage

#图片的名称
my_image = "thumbs_up.jpg"

fname = "images/" + my_image #图片的相对路径
image = np.array(ndimage.imread(fname, flatten=False))#读取图片保存到3维数组中
my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T#把3维数组拉伸为列向量(用2维数组表示)
my_image_prediction = predict(my_image, parameters)#用训练好的模型参数 对自己的图片做预测

plt.imshow(image) #可视化图片
print("Your algorithm predicts: y = " + str(np.squeeze(my_image_prediction)))#打印图片的预测类别

5.总结

6.实验完整代码

实验代码