吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习

最新推荐文章于 2023-07-04 15:27:31 发布

椰楠liu

最新推荐文章于 2023-07-04 15:27:31 发布

阅读量1.5k

点赞数 1

分类专栏：吴恩达课后练习作业文章标签： python 神经网络 tensorflow 机器学习

本文链接：https://blog.csdn.net/qq_34621022/article/details/104772075

版权

吴恩达课后练习作业专栏收录该内容

11 篇文章 6 订阅

订阅专栏

吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习

到现在我们一直使用numpy来构建神经网络，接下来我们将使用深度学习框架来构建神经网络。常见的机器学习框架是TensorFlow、Paddle、Torch、Caffe、Keras等，本次作业中我们将练习使用TensorFlow，我们学习的主要内容是：

初始化参数
启动session
训练算法
实现神经网络
编程框架不仅可以缩短我们的编程时间，还可以优化我们的代码。

1. TensorFlow库

使用的工具函数都附在文章最后

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

np.random.seed(1)

1.1 使用TensorFlow语法简单例子

使用的公式：
$\mathcal{L}(\hat{y}, y) = (\hat y^{(i)} - y^{(i)})^2$

代码：

if __name__ == "__main__":
    #计算损失
    y_hat = tf.constant(36, name='y_hat')
    y = tf.constant(39, name='y')
    loss = tf.Variable((y - y_hat)**2, name='loss')
    init = tf.global_variables_initializer()

    with tf.Session() as session:
        session.run(init)
        print(session.run(loss))

运行结果：
在这里插入图片描述
在TensorFlow中编写和运行程序的步骤如下:

1.创建Tensors变量，这些变量并未被运行。
2.实现Tensorflow变量之间的操作。
3.初始化变量
4.创建Session对话
5.运行Session，上面的所有变量操作都会在session中运行。

因此，当我们创建一个损失变量时，我们简单地将损失定义为其他数量的函数，但不计算它的值。为了求值，我们必须运行init=tf.global_variables_initializer()。在最后一行中，我们可以计算loss的值并打印它的值。

简单例子：

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

运行结果：
在这里插入图片描述
在运行结果中我们没有看到期望的运行结果20，得到的是一个没有形状属性的张量，类型为“int32”，想要得到结果我们需要创建session回话。

代码：

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

运行结果：
在这里插入图片描述
**总结：**要记住初始化变量，创建会话并在会话内运行操作。

接下来我们学习占位符，占位符是一个对象，我们只能在以后指定它的值。要为占位符指定值，可以使用feed_dict变量传入值。下面，我们为x创建了一个占位符，这允许我们在后面运行会话时传入一个数字。

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

结果：
在这里插入图片描述
当我们第一次定义x时，不必为它指定一个值。占位符只是一个变量，我们可以在稍后运行会话时将数据分配给该变量。

1.2 线性函数

让我们通过计算下面的方程来开始这个编程练习: $Y = W X + b$ ，其中 $W$ 和 $X$ 是随机矩阵，而b是随机向量。
计算 $W X + b$ ，其中 $W, X$ ，和 $b$ 来自随机正态分布。W的形状是(4,3)，X是(3,1)，b是(4,1)。举个例子，定义一个有形状(3,1)的常数X的代码:
X = tf.constant(np.random.randn(3,1), name = “X”)
我们还会使用以下语法：

tf.matmul(,)进行矩阵乘法
tf.add(,)进行矩阵加法
np.random.randn()用于随机初始化

def linear_function():
    X = np.random.randn(3, 1)
    W = np.random.randn(4, 3)
    b = np.random.randn(4, 1)
    Y = tf.add(tf.matmul(W, X), b)

    sess = tf.Session()
    result = sess.run(Y)

    sess.close()

    return result

调用：

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

运行结果：
在这里插入图片描述

1.3 计算sigmoid

现在我们来练习如何用tf实现sigmoid函数。
注意，在tensorflow中有两种创建和使用会话的典型方法:
方法一：

    sess = tf.Session()
    result = sess.run(..., feed_dict={...})
    sess.close()

方法二：

    with tf.Session() as sess:
        result = sess.run(..., feed_dict={...})

sigmoid实现代码：

def sigmoid(z):
    x = tf.placeholder(tf.float32, name="x")
    sigmoid = tf.sigmoid(x)

    with tf.Session() as sess:
        result = sess.run(sigmoid, feed_dict={x:z})
    return result

调用：

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

运行结果：
在这里插入图片描述

1.4 计算代价

这一小节我们将学习利用TF计算神经网络的成本。
例如，对于 $a^{[2](i)}$ 和 $y^{(i)}$ 对于i=1… m:
$\frac{1}{m} \sum_{i = 1}^m \large ( \small y^{(i)} \log a^{ [2] (i)} + (1-y^{(i)})\log (1-a^{ [2] (i)} )\large )\small$

我们将使用的主要代码：

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

假设我们已经有了z的值，使用sigmoid函数计算得到a，然后再计算交叉熵J，这些步骤我们都可以使用tf.nn.sigmoid_cross_entropy_with_logits实现，可以计算：

$\frac{1}{m} \sum_{i = 1}^m \large ( \small y^{(i)} \log \sigma(z^{[2](i)}) + (1-y^{(i)})\log (1-\sigma(z^{[2](i)})\large )\small$
代码：

def cost(logits, labels):
    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)
    sess = tf.Session()
    
    cost = sess.run(cost, feed_dict={z:logits, y:labels})
    sess.close()
    
    return cost

调用：

    logits = sigmoid(np.array(0.2, 0.4, 0.7, 0.9))
    cost = cost(logits, np.array([0, 0, 1, 1]))
    print("cost = " + str(cost))

运行结果：
在这里插入图片描述

1.5 使用One Hot编码

很多时候，在深度学习中，你会得到一个y向量，它的数字从0到C-1，其中C是类的数量。如果C中有4个类型，那么我们会有如下的y向量，我们将y需要转换如下:
在这里插入图片描述
“one hot”编码的含义：在转换后的表示中每一列只有一个元素是“hot”(意思是设置为1)。在tensorflow中，你可以使用一行代码:tf.one_hot(labels, depth, axis)

代码：

def one_hot_matrix(labels, C):
    """
    :param labels:标签向量
    :param C:分类数
    :return:One hot矩阵
    """
    C = tf.constant(C, name='C')
    one_hot_matrix = tf.one_hot(indices=labels, depth=C, axis=0)
    sess = tf.Session()
    one_hot = sess.run(one_hot_matrix)
    sess.close()

    return one_hot

调用：

    labels = np.array([1, 2, 3, 0, 2, 1])
    one_hot = one_hot_matrix(labels, C=4)
    print("one_hot = " + str(one_hot))

运行结果：
在这里插入图片描述

1.6 用0与1初始化

现在，您将学习如何初始化一个由0和1组成的向量。您将调用的函数是tf.ones()。要使用0进行初始化，可以使用tf.zeros()。这些函数接收维数并分别返回一个满是0和1的维度形状数组。

练习：实现下面的函数根据提供的维数返回一个数值都是1的数组。

def ones(shape):
    ones = tf.ones(shape)
    sess = tf.Session()
    ones = sess.run(ones)

    sess.close()
    return ones

调用：

   print("ones = " + str(ones([3])))

运行结果：
在这里插入图片描述

2. 使用TensorFlow构建神经网络

在这部分作业中，我们将使用tensorflow建立一个神经网络。实现一个tensorflow模型主要分两部分:

创建计算图
运行图

2.1 问题陈述：SIGNS数据集

我们要完成的工作是利用吴恩达老师提供的数据集建立一种算法，帮助语言障碍人士和不懂手语的人进行交流。

训练集：1080张图片（64*64),每张图片中包含一个手势，表示数字（0~5），每个数字有180张照片表示。
训练集：120张图片（64*64），每张图片包含表示数字（0~5）的手势，每个数字有20张图片表示。
下面是每个数字的例子。

加载数据集（使用的工具函数都附在文章最后）。
代码：

    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(Y_train_orig[0, index]))

运行结果：
在这里插入图片描述
和往常一样，我们先将图像数据集平展，然后通过除以255对其进行归一化。最重要的是，我们需要将把每个标签转换为一个热向量。
代码：

    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))

运行结果：
在这里插入图片描述
注意12288来自64×64×3。每个图像是正方形的，64×64像素，3是RGB颜色。
我们的目标是建立一个有较高准确性的能够识别手势符号的算法。我们将使用TensorFlow构建模型，这个模型和我们使用numpy构建的识别猫的模型相同，不同的是这个模型我们将使用softmax输出结果，我们也可以借助此次的模型观察以下numpy与TensorFlow的异同。

模型架构：LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX

2.2 创建占位符

我们将使用这个函数创建X和Y的占位符。

def create_placeholders(n_x, n_y):
    """
    :param n_x:图像向量的大小
    :param n_y: 类别种类
    :return:X,Y
    注意:因为测试集/训练集数据集数目不同，所以我们会使用none来表示个数
    """
    X = tf.placeholder(tf.float32,shape=[n_x, None], name="X")
    Y = tf.placeholder(tf.float32, shape=[n_y, None], name="Y")
    
    return X, Y

调用：

    X, Y = create_placeholders(12288, 6)
    print("X = " + str(X))
    print("Y = " + str(Y))

运行结果：
在这里插入图片描述

2.3 初始化参数

实现下面的函数来初始化tensorflow中的参数。我们将使用Xavier初始化权值和零初始化偏差。举个例子，对于W1和b1你可以使用:

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())

代码：

def initialize_parameters():
    """
    使用tensorflow建立神经网络模型，参数维数如下
        W1 : [25, 12288]
        b1 : [25, 1]
        W2 : [12, 25]
        b2 : [12, 1]
        W3 : [6, 12]
        b3 : [6, 1]
    :return:
    parameters--W1, b1, W2, b2, W3, b3
    """
    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

调用：

    with tf.Session() as sess:
        parameters = initialize_parameters()
        print("W1 = " + str(parameters["W1"]))
        print("b1 = " + str(parameters["b1"]))
        print("W2 = " + str(parameters["W2"]))
        print("b2 = " + str(parameters["b2"]))

运行结果：
在这里插入图片描述

2.4 TenforFlow实现前向传播

在这一部分中我们将使用TensorFlow实现前向传播，本次需要使用的一些函数：

tf.add(...,...)实现矩阵相加
tf.matmul(...,...)实现矩阵相乘
tf.nn.relu(...)实现relu激活函数

需要注意的是，正向传播在z3处停止。原因是在tensorflow中，最后一个线性层的输出作为计算损耗的函数的输入。因此，我们不再需要计算a3。

代码：

def forward_propagation(X, parameters):
    """
    神经网络模型：LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX
    :param X:输入数据集，（输入大小，样例）
    :param parameters:"W1", "b1", "W2", "b2", "W3", "b3"
    :return: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)      # Z1 = np.dot(W1, X) + b1
    A1 = tf.nn.relu(Z1)                    # A1 = relu(Z1)
    Z2 = tf.add(tf.matmul(W2, A1), b2)     # Z2 = np.dot(W2, a1) + b2
    A2 = tf.nn.relu(Z2)                     # A2 = relu(Z2)
    Z3 = tf.add(tf.matmul(W3, A2), b3)

    return Z3

调用：

    tf.reset_default_graph()

    with tf.Session() as sess:
        X, Y = create_placeholders(12288, 6)
        parameters = initialize_parameters()
        Z3 = forward_propagation(X, parameters)
        print("Z3 = " + str(Z3))

运行结果：
在这里插入图片描述

2.5 计算代价

计算代价的主要代码：tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = ..., labels = ...))

def compute_cost(Z3, Y):
    """
    :param Z3:正向传播返回的值，维数（6，样本例子）
    :param Y:真实标签，和Z3维数相同
    :return:cost
    注意：softmax_cross_entropy_with_logits是由维数要求的(例子的数量，num_classes)所以下面需要将矩阵进行转置
    """
    logits = tf.transpose(Z3)
    labels = tf.transpose(Y)
    
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
    
    return cost

调用：

    tf.reset_default_graph()

    with tf.Session() as sess:
        X, Y = create_placeholders(12288, 6)
        parameters = initialize_parameters()
        Z3 = forward_propagation(X, parameters)
        print("Z3 = " + str(Z3))

运行结果：
在这里插入图片描述

2.6 反向传播和参数更新

使用框架实现反向传播十分简单。
在你计算了成本函数之后。我们需要创建一个“优化器”对象，在运行tf.session时，必须调用这个对象和成本，当被调用时，它将根据所选择的方法和学习率对给定的成本进行优化。
我们需要使用的函数：

梯度下降方法：optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)
优化方法：_ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})

注意，在编码时，我们经常使用_作为“一次性”变量来存储我们以后不需要的值。这里，_接受优化器的评估值，这是我们不需要的。

2.61 建立模型

代码：

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001, num_epochs = 1500, minibatch_size = 32, print_cost = True):
    """
     神经网络模型：LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.
    :param X_train:训练集，(input size = 12288, 训练样本数量 = 1080)
    :param Y_train:训练集标签，(output size = 6, 训练样本数量 = 1080)
    :param X_test:测试集，(input size = 12288, 测试集数量 = 120)
    :param Y_test:测试集标签，(output size = 6, 测试集数量 = 120)
    :param learning_rate:学习率
    :param num_epochs:优化次数
    :param minibatch_size:mini_batch大小
    :param print_cost:是否每100次打印代价
    :return:
    """
    #能够在不覆盖tf变量的情况下重新运行模型
    ops.reset_default_graph()
    tf.set_random_seed(1)
    seed = 3
    n_x, m = X_train.shape
    n_y = Y_train.shape[0]
    costs = []

    #创建占位符
    X, Y = create_placeholders(n_x, n_y)
    #初始化参数
    parameters = initialize_parameters()
    #前向传播
    Z3 = forward_propagation(X, parameters)
    #计算代价
    cost = compute_cost(Z3, Y)
    #反向传播
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
    #初始化所有变量
    init = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init)

        for epoch in range(num_epochs):
            epoch_cost = 0
            num_minibatches = int(m / minibatch_size)

            seed = seed + 1
            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

            for minibatch in minibatches:
                minibatch_X, minibatch_Y = minibatch
                _, 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("参数已经训练过！")
        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

        print("训练集准确率:", accuracy.eval({X: X_train, Y: Y_train}))
        print("测试集准确率:", accuracy.eval({X: X_test, Y: Y_test}))

        return parameters

调用：

    parameters = model(X_train, Y_train, X_test, Y_test)

注意：这次的运行时间大约在5-8分钟左右，如果在epoch = 100的时候，你的epoch_cost与1.017255相差较大，那就证明你的模型实现有误，请停止运行检查修正。
在这里插入图片描述

我们的模型看起来足够大，可以很好地适应训练集。然而，考虑到训练和测试准确性之间的差异，可以尝试添加L2或dropout正则化来减少过度拟合。
将session看作训练模型的代码块。每次在minibatch上运行session时，它都会训练参数。总的来说，您已经运行了大量的session(1500个epoch)，直到您获得了训练良好的参数

2.7 用自己的图片测试模型

代码：

运行结果：
在这里插入图片描述
我们得到的结果并不正确，因为在我们使用的训练集中没有类似大拇指这样的图片，我们称之为“不匹配的数据分布”，将在下一门课程“结构化机器学习项目”中学习它。

3. 工具代码：

1.tf_utils.py

import h5py
import numpy as np
import tensorflow as tf
import math

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

def forward_propagation_for_predict(X, parameters):
    """
    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX
    
    Arguments:
    X -- input dataset placeholder, of shape (input size, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3"
                  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']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    W3 = parameters['W3']
    b3 = parameters['b3'] 
                                                           # Numpy Equivalents:
    Z1 = tf.add(tf.matmul(W1, X), b1)                      # Z1 = np.dot(W1, X) + b1
    A1 = tf.nn.relu(Z1)                                    # A1 = relu(Z1)
    Z2 = tf.add(tf.matmul(W2, A1), b2)                     # Z2 = np.dot(W2, a1) + b2
    A2 = tf.nn.relu(Z2)                                    # A2 = relu(Z2)
    Z3 = tf.add(tf.matmul(W3, A2), b3)                     # Z3 = np.dot(W3,Z2) + b3
    
    return Z3

椰楠liu

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习

吴恩达Deep Learning编程作业 Course2- 改善深层神经网络-第三周作业：TensorFlow练习到现在我们一直使用numpy来构建神经网络，接下来我们将使用深度学习框架来构建神经网络。常见的机器学习框架是TensorFlow、Paddle、Torch、Caffe、Keras等，本次作业中我们将练习使用TensorFlow，我们学习的主要内容是：初始化参数启动session...
复制链接

扫一扫