吳恩達Coursera課程 DeepLearning.ai 程式設計作業系列，本文為《改善深層神經網路：超引數除錯、正則化以及優化 》部分的第三週“超引數除錯 和 Batch Norm”的課程作業，同時增加了一些輔助的測試函式。

TensorFlow Tutorial

1 - Exploring the Tensorflow Library

To start, you will import the library:

import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import
 
 tensorflow as tf
from tensorflow.python.framework import ops
from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict

%matplotlib inline
np.random.seed(1)

There are some help function：

def load_dataset():
    train_dataset = h5py.File('datasets/train_signs.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"
 
][:]) # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels

    test_dataset = h5py.File('datasets/test_signs.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"
 
][:]) # your test set labels

    classes = np.array(test_dataset["list_classes"][:]) # the list of classes

    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))

    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes


def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
    """
    Creates a list of random minibatches from (X, Y)

    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    mini_batch_size - size of the mini-batches, integer
    seed -- this is only for the purpose of grading, so that you're "random minibatches are the same as ours.

    Returns:
    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
    """

    m = X.shape[1]                  # number of training examples
    mini_batches = []
    np.random.seed(seed)

    # Step 1: Shuffle (X, Y)
    permutation = list(np.random.permutation(m))
    shuffled_X = X[:, permutation]
    shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))

    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
    for k in range(0, num_complete_minibatches):
        mini_batch_X = shuffled_X[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]
        mini_batch_Y = shuffled_Y[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)

    # Handling the end case (last mini-batch < mini_batch_size)
    if m % mini_batch_size != 0:
        mini_batch_X = shuffled_X[:, num_complete_minibatches * mini_batch_size : m]
        mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)

    return mini_batches


def convert_to_one_hot(Y, C):
    Y = np.eye(C)[Y.reshape(-1)].T
    return Y


def predict(X, parameters):

    W1 = tf.convert_to_tensor(parameters["W1"])
    b1 = tf.convert_to_tensor(parameters["b1"])
    W2 = tf.convert_to_tensor(parameters["W2"])
    b2 = tf.convert_to_tensor(parameters["b2"])
    W3 = tf.convert_to_tensor(parameters["W3"])
    b3 = tf.convert_to_tensor(parameters["b3"])

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

    x = tf.placeholder("float", [12288, 1])

    z3 = forward_propagation_for_predict(x, params)
    p = tf.argmax(z3)

    sess = tf.Session()
    prediction = sess.run(p, feed_dict = {x: X})

    return prediction

Now that you have imported the library, we will walk you through its different applications. You will start with an example, where we compute for you the loss of one training example.

loss=L(y^,y)=(y^(i)−y(i))2(1)$$\begin{array}{}\text{(1)}& loss=\mathcal{L}(\hat{y},y)=({\hat{y}}^{(i)}-y^{(i)}{)}^2\end{array}$$

y_hat = tf.constant(36, name='y_hat')            # Define y_hat constant. Set to 36.
y = tf.constant(39, name='y')                    # Define y. Set to 39

loss = tf.Variable((y - y_hat)**2, name='loss')  # Create a variable for the loss

init = tf.global_variables_initializer()         # When init is run later (session.run(init)),
                                                 # the loss variable will be initialized and ready to be computed
with tf.Session() as session:                    # Create a session and print the output
    session.run(init)                            # Initializes the variables
    print(session.run(loss))                     # Prints the loss

9

Writing and running programs in TensorFlow has the following steps:

1. Create Tensors (variables) that are not yet executed/evaluated.
2. Write operations between those Tensors.
3. Initialize your Tensors.
4. Create a Session.
5. Run the Session. This will run the operations you’d written above.

Therefore, when we created a variable for the loss, we simply defined the loss as a function of other quantities, but did not evaluate its value. To evaluate it, we had to run init=tf.global_variables_initializer(). That initialized the loss variable, and in the last line we were finally able to evaluate the value of loss and print its value.

Now let us look at an easy example. Run the cell below:

a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)
print(c)

Tensor("Mul:0", shape=(), dtype=int32)

As expected, you will not see 20! You got a tensor saying that the result is a tensor that does not have the shape attribute, and is of type “int32”. All you did was put in the ‘computation graph’, but you have not run this computation yet. In order to actually multiply the two numbers, you will have to create a session and run it.

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

20

Great! To summarize, remember to initialize your variables, create a session and run the operations inside the session.

Next, you’ll also have to know about placeholders. A placeholder is an object whose value you can specify only later.
To specify values for a placeholder, you can pass in values by using a “feed dictionary” (feed_dict variable). Below, we created a placeholder for x. This allows us to pass in a number later when we run the session.

# Change the value of x in the feed_dict

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

6

When you first defined x you did not have to specify a value for it. A placeholder is simply a variable that you will assign data to only later, when running the session. We say that you feed data to these placeholders when running the session.

Here’s what’s happening: When you specify the operations needed for a computation, you are telling TensorFlow how to construct a computation graph. The computation graph can have some placeholders whose values you will specify only later. Finally, when you run the session, you are telling TensorFlow to execute the computation graph.

1.1 - Linear function

Lets start this programming exercise by computing the following equation: Y=WX+b$Y=WX+b$, where W$W$ and X$X$ are random matrices and b is a random vector.

Exercise: Compute WX+b$WX+b$ where W,X$W,X$, and b$b$ are drawn from a random normal distribution. W is of shape (4, 3), X is (3,1) and b is (4,1). As an example, here is how you would define a constant X that has shape (3,1):

X = tf.constant(np.random.randn(3,1), name = "X")

You might find the following functions helpful:
- tf.matmul(…, …) to do a matrix multiplication
- tf.add(…, …) to do an addition
- np.random.randn(…) to initialize randomly

# GRADED FUNCTION: linear_function

def linear_function():
    """
    Implements a linear function: 
            Initializes W to be a random tensor of shape (4,3)
            Initializes X to be a random tensor of shape (3,1)
            Initializes b to be a random tensor of shape (4,1)
    Returns: 
    result -- runs the session for Y = WX + b 
    """

    np.random.seed(1)

    ### START CODE HERE ### (4 lines of code)
    X = tf.constant(np.random.randn(3,1), name = "X")
    W = tf.constant(np.random.randn(4,3), name = "W")
    b = tf.constant(np.random.randn(4,1), name  = "b")
    Y = tf.add(tf.matmul(W, X), b)
    ### END CODE HERE ### 

    # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate

    ### START CODE HERE ###
    sess = tf.Session()
    result = sess.run(Y)
    ### END CODE HERE ### 

    # close the session 
    sess.close()

    return result

print( "result = " + str(linear_function()))

result = [[-2.15657382]
 [ 2.95891446]
 [-1.08926781]
 [-0.84538042]]

1.2 - Computing the sigmoid

Great! You just implemented a linear function. Tensorflow offers a variety of commonly used neural network functions like tf.sigmoid and tf.softmax. For this exercise lets compute the sigmoid function of an input.

You will do this exercise using a placeholder variable x. When running the session, you should use the feed dictionary to pass in the input z. In this exercise, you will have to (i) create a placeholder x, (ii) define the operations needed to compute the sigmoid using tf.sigmoid, and then (iii) run the session.

Exercise：Implement the sigmoid function below. You should use the following:

• tf.placeholder(tf.float32, name = "...")
• tf.sigmoid(...)
• sess.run(..., feed_dict = {x: z})

Note that there are two typical ways to create and use sessions in tensorflow:

Method 1:

sess = tf.Session()
# Run the variables initialization (if needed), run the operations
result = sess.run(..., feed_dict = {...})
sess.close() # Close the session

Method 2:

with tf.Session() as sess: 
    # run the variables initialization (if needed), run the operations
    result = sess.run(..., feed_dict = {...})
    # This takes care of closing the session for you :)

# GRADED FUNCTION: sigmoid

def sigmoid(z):
    """
    Computes the sigmoid of z

    Arguments:
    z -- input value, scalar or vector

    Returns: 
    results -- the sigmoid of z
    """

    ### START CODE HERE ### ( approx. 4 lines of code)
    # Create a placeholder for x. Name it 'x'.
    x = tf.placeholder(tf.float32, name = "x")

    # compute sigmoid(x)
    sigmoid = tf.sigmoid(x)

    # Create a session, and run it. Please use the method 2 explained above. 
    # You should use a feed_dict to pass z's value to x. 
    with tf.Session() as sess:
        # Run session and call the output "result"
        result = sess.run(sigmoid, feed_dict = {x:z})

    ### END CODE HERE ###

    return result

print ("sigmoid(0) = " + str(sigmoid(0)))
print ("sigmoid(12) = " + str(sigmoid(12)))

sigmoid(0) = 0.5
sigmoid(12) = 0.999994

To summarize, you how know how to:
1. Create placeholders
2. Specify the computation graph corresponding to operations you want to compute
3. Create the session
4. Run the session, using a feed dictionary if necessary to specify placeholder variables’ values.

1.3 - Computing the Cost

You can also use a built-in function to compute the cost of your neural network. So instead of needing to write code to compute this as a function of a[2](i)$a^{[2](i)}$ and y(i)$y^{(i)}$ for i=1…m:

J=−1m∑i=1m(y(i)loga[2](i)+(1−y(i))log(1−a[2](i)))(2)$$\begin{array}{}\text{(2)}& J=-\frac{1}{m}\sum _{i=1}^m(y^{(i)}\log a^{[2](i)}+(1-y^{(i)})\log (1-a^{[2](i)}))\end{array}$$

you can do it in one line of code in tensorflow!

Exercise: Implement the cross entropy loss. The function you will use is:

• tf.nn.sigmoid_cross_entropy_with_logits(logits = ..., labels = ...)

Your code should input z, compute the sigmoid (to get a) and then compute the cross entropy cost J$J$. All this can be done using one call to tf.nn.sigmoid_cross_entropy_with_logits, which computes

−1m∑i=1m(y(i)logσ(z[2](i))+(1−y(i))log(1−σ(z[2](i)))

相關推薦

吳恩達 深度學習 程式設計作業（2-3）- TensorFlow Tutorial

吳恩達Coursera課程 DeepLearning.ai 程式設計作業系列，本文為《改善深層神經網路：超引數除錯、正則化以及優化 》部分的第三週“超引數除錯 和 Batch Norm”的課程作業，同時增加了一些輔助的測試函式。 Tensor

吳恩達 深度學習 程式設計作業（4-3）- Autonomous driving

吳恩達 Coursera 課程 DeepLearning.ai 程式設計作業系列，本文為《卷積神經網路 》部分的第三週“目標檢測”的課程作業。 Autonomous driving - Car detection Welcome to you

吳恩達 深度學習 程式設計作業（2-1）- Initialization & Regularization & Gradient Checking

吳恩達Coursera課程 DeepLearning.ai 程式設計作業系列，本文為《改善深層神經網路：超引數除錯、正則化以及優化 》部分的第四周“深度學習的實踐方面”的課程作業，同時增加了一些輔助的測試函式。 You can get the s

吳恩達 深度學習 程式設計作業（5-1）Part 2

吳恩達 Coursera 課程 DeepLearning.ai 程式設計作業系列，本文為《序列模型》部分的第一週“迴圈神經網路”的課程作業——第二部分：字母級的語言模型：恐龍獸島。 Character level language model -

吳恩達 深度學習 程式設計作業（4-1）- Convolutional Neural Networks & CNN Application

吳恩達Coursera課程 DeepLearning.ai 程式設計作業系列，本文為《卷積神經網路 》部分的第一週“卷積神經網路基礎”的課程作業。 Part 1：Convolutional Neural Networks: Step by St

吳恩達 深度學習 程式設計作業（4-4）- Face Recognition for the Happy House & Art: Neural Style Transfer

吳恩達 Coursera 課程 DeepLearning.ai 程式設計作業系列，本文為《卷積神經網路》部分的第四周“特殊應用：人臉識別和神經風格遷移”的課程作業。 Part 1：Face Recognition for the Happy H

Elam的吳恩達深度學習課程筆記（一）

記憶力是真的差，看過的東西要是一直不用的話就會馬上忘記,於是乎有了寫部落格把學過的東西儲存下來，大概就是所謂的集鞏固，分享，後期查閱與一身的思想吧，下面開始正題 深度學習概論 什麼是神經網路 什麼是神經網路呢，我們就以房價預測為例子來描述一個最簡單的神經網路模型。 　　假設有6間

吳恩達深度學習(二)-第一週(2)：Regularization

Regularization # import packages import numpy as np import matplotlib.pyplot as plt from reg_utils import sigmoid, relu, plot_de

吳恩達.深度學習系列-C1神經網路與深度學習-w3-（作業：一個隱藏層進行二維資料分類）

前言 **注意：coursera要求不要在網際網路公佈自己的作業。如果你在學習這個課程，建議你進入課程系統自行完成作業。使用邏輯迴歸作為一個最簡單的類似神經網路來進行影象判別。我覺得程式碼有參考和保留的意義。v 使用一個 2×4×1的網路來對資料進

吳恩達.深度學習系列-C1神經網路與深度學習-W2-（作業：神經網路思想的邏輯迴歸）

注意：coursera要求不要在網際網路公佈自己的作業。如果你在學習這個課程，建議你進入課程系統自行完成作業。使用邏輯迴歸作為一個最簡單的類似神經網路來進行影象判別。我覺得程式碼有參考和保留的意義。 Logistic Regression with a N

吳恩達.深度學習系列-C1神經網路與深度學習-w4-（ 作業：建立神經網路）

前言 注意：coursera要求不要在網際網路公佈自己的作業。如果你在學習這個課程，建議你進入課程系統自行完成作業。我覺得程式碼有參考和保留的意義。 本週的作業包含兩個部分。Building your Deep Neural Network， De

吳恩達深度學習筆記（deeplearning.ai）之循環神經網絡（RNN）（一）

不同的 圖片 存在 最終 一個 har end markdown 輸入 1. RNN 首先思考這樣一個問題：在處理序列學習問題時，為什麽不使用標準的神經網絡（建立多個隱藏層得到最終的輸出）解決，而是提出了RNN這一新概念？ 標準神經網絡如下圖所示： 標準神經網絡在解決序列

吳恩達深度學習筆記（deeplearning.ai）之循環神經網絡（RNN）（二）

blog 如何 這一 累加 soft 學習 測試 接下來 數據 導讀 本節內容介紹如何使用RNN訓練語言模型，並生成新的文本序列。 語言模型（Language model） 通過語言模型，我們可以計算某個特定句子出現的概率是多少，或者說該句子屬於真實句子的概率是多少。正式點

吳恩達深度學習筆記（deeplearning.ai）之循環神經網絡（RNN）（三）

崩潰 body 很難 mark 因此 梯度 處理方法 弊端 原理 1. 導讀 本節內容介紹普通RNN的弊端，從而引入各種變體RNN，主要講述GRU與LSTM的工作原理。 2. 普通RNN的弊端 在NLP中，句子內部以及句子之間可能存在很長的依賴關系（long-term d

吳恩達深度學習筆記（七） —— Batch Normalization

學習 bat 中括號 和平 一個 內容 batch 可能 加權 主要內容： 一.Batch Norm簡介 二.歸一化網絡的激活函數 三.Batch Norm擬合進神經網絡 四.測試時的Batch Norm 一.Batch Norm簡介 1.在機器學習中，我們一般

吳恩達深度學習筆記（八） —— ResNets殘差網絡

con 一個 學習 ets str 帶來 圖片 梯度 就是 （好累……，明日在寫……） 主要內容： 一.殘差網絡簡介 二.identity block 和 convolutional block 一.殘差網絡簡介 1.深度神經網絡很大的一個優點就是能夠表示一個

吳恩達深度學習2-Week2課後作業3-優化演算法

一、deeplearning-assignment 到目前為止，在之前的練習中我們一直使用梯度下降來更新引數並最小化成本函式。在本次作業中，將學習更先進的優化方法，它在加快學習速度的同時，甚至可以獲得更好的最終值。一個好的優化演算法可以讓你幾個小時內就獲得一個結果，而不是等待幾天。 1.

吳恩達深度學習2-Week1課後作業3-梯度檢測

一、deeplearning-assignment 神經網路的反向傳播很複雜，在某些時候需要對反向傳播演算法進行驗證，以證明確實有效，這時我們引入了“梯度檢測”。 反向傳播需要計算梯度 , 其中θ表示模型的引數。J是使用前向傳播和損失函式計算的。因為前向傳播實現相對簡單, 所以

吳恩達深度學習2-Week3課後作業-Tensorflow

一、deeplearning-assignment 到目前為止，我們一直使用numpy來建立神經網路。這次作業將深入學習框架，可以更容易地建立神經網路。 TensorFlow，PaddlePaddle，Torch，Caffe，Keras等機器學習框架可以顯著地加速機器學習開發。這些框架有

吳恩達深度學習筆記（3）-神經網路如何實現監督學習？

神經網路的監督學習(Supervised Learning with Neural Networks) 關於神經網路也有很多的種類，考慮到它們的使用效果，有些使用起來恰到好處，但事實表明，到目前幾乎所有由神經網路創造的經濟價值，本質上都離不開一種叫做監督學習的機器學習類別，讓我們舉例看看。