吴恩达深度学习第⼆课第三周编程作业_TensorFlowTutorialTensorFlow教程
TensorFlow Tutorial TensorFlow教程
欢迎来到本周的编程作业。到⽬前为⽌，您⼀直使⽤numpy来构建神经⽹络。现在我们将引导你通过⼀个深度学习框架，它将允许你更容易地建⽴神经⽹络。像TensorFlow, PaddlePaddle, Torch, Caffe, Keras等机器学习框架可以显著加快你机器学习的发展。所有这些框架都有⼤量⽂档，您可以随意阅读。在这个作业中，你将学习在TensorFlow中完成以下操作:
初始化变量
开始你⾃⼰的会话
训练算法
实现⼀个神经⽹络
编程框架不仅可以缩短您的编码时间，有时还可以执⾏优化来加速您的代码。
1 - Exploring the Tensorflow Library 探索Tensorflow库
⾸先，您将导⼊库:
1 import math
2 import numpy as np
3 import h5py
4 import matplotlib.pyplot as plt
5 import tensorflow as tf
6 from tensorflow.python.framework import ops
7 from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict
8
9 %matplotlib inline
10 np.random.seed(1)
现在您已经导⼊了库，我们将带您浏览它的不同应⽤程序。你将从⼀个例⼦开始，我们计算⼀个训练例⼦的损失。
原代码为：
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
根据⽹上参考，适应tf2.0版本修改的：
import tensorflow as tf
tfpat.v1.disable_eager_execution()          #保证session.run()能够正常运⾏
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 = tfpat.v1.global_variables_initializer()        # When init is run later (session.run(init)),
# the loss variable will be initialized and ready to be computed
with tfpat.v1.Session () as session:                    # Create a session and print the output
session.run(init)                            # Initializes the variables
print(session.run(loss))
运⾏结果：
在TensorFlow中编写和运⾏程序有以下步骤:
1、创建Tensorflow变量（此时，尚未直接计算）
2、实现Tensorflow变量之间的操作定义。
3、初始化Tensorflow变量
4、创建⼀个会话，也就是session。
5、运⾏会话。这将运⾏您上⾯所写的操作。
因此，当我们为损失创建⼀个变量时，我们只是将损失定义为其他数量的函数，但没有计算它的值。要对它求值，我们必须运⾏
init=tf.global_variables_initializer()。这样就初始化了loss变量，并且在最后⼀⾏中，我们终于能够计算loss的值并打印它的值。
现在让我们看⼀个简单的例⼦。运⾏下⾯的单元格:
  （链接：
  参考的博客为
  原博客中作者⽤的是tf1.x版本的，本⽂⽤的是tf2.x版本，这⾥挂⼀下⽹友整理的两个版本更新的对⽐
  ）
a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)
print(c)
运⾏结果：
正如所料，您不会看到20!你得到⼀个变量，说结果是⼀个没有形状属性的张量（没有维度），类型是“int32”。你所做的⼀切都被放到了“计算图(computation graph)”中，但是你还没有运⾏这个计算。为了实际地将两个数字相乘，您必须创建⼀个会话并运⾏它。
sess = tfpat.v1.Session()
print(sess.run(c))
运⾏结果：
20
太棒了!总之，请记住初始化变量、创建会话并在会话内运⾏操作。
接下来，您还需要了解占位符。占位符是只能在以后指定其值的对象。要为占位符指定值，可以使⽤“feed字典”(feed_dict变量)传⼊值。下⾯，我们为x创建了⼀个占位符。这允许我们在稍后运⾏会话时传⼊⼀个数字。
# Change the value of x in the feed_dict
x = tfpat.v1.placeholder(tf.int64, name = 'x')
print(sess.run(2 * x, feed_dict = {x: 3}))
tensorflow版本选择sess.close()
运⾏结果：
6
placeholder means '占位符'
当你第⼀次定义x时，你不需要为它指定⼀个值。占位符只是⼀个变量，您将在稍后运⾏会话时将数据分配给它。我们说，在运⾏会话时向这些占位符提供数据。
当您指定⼀个计算所需的操作时，您正在告诉TensorFlow如何构造⼀个计算图。计算图中可以有⼀些占位符，它们的值将稍后指定。最后，当您运⾏会话时，您告诉TensorFlow执⾏计算图。
1.1 - Linear function 线性函数
你可能会发现以下功能有帮助:
·tf.matmul(…，…)来做⼀个矩阵乘法 #matmul 就是matrix和multiply
·tf.add(…，…)做加法
·随机初始化n .random.randn(…）
# 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 = tfpat.v1.Session()
result = sess.run(Y)
### END CODE HERE ###
# close the session
sess.close()
return result
# GRADED FUNCTION: linear_function
print( "result = " + str(linear_function()))
运⾏结果：
1.2 - Computing the sigmoid 计算sigmoid
太棒了!你只是实现了⼀个线性函数。Tensorflow提供了各种常⽤的神经⽹络函数，⽐如tf.sigmoid和tf.softmax。在这个练习中，我们计算输⼊的sigmoid函数。在这个练习中，您必须
(i)创建⼀个占位符x，
(ii)定义使⽤tf计算sigmoid所需的操作。
(iii)运⾏会话。
练习**：实现下⾯的sigmoid函数。你应该使⽤以下⽅法:
tf.placeholder(tf.float32, name = "...")
tf.sigmoid(...)
sess.run(..., feed_dict = {x: z})
注意，在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 = tfpat.v1.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 tfpat.v1.Session() as sess:
# Run session and call the output "result"
result = sess.run(sigmoid, feed_dict = {x : z})
### END CODE HERE ###
return result
# GRADED FUNCTION: sigmoid
print ("sigmoid(0) = " + str(sigmoid(0)))
print ("sigmoid(12) = " + str(sigmoid(12)))
运⾏结果：
总结⼀下，你如何知道如何去**:
1、创建占位符。
2、指定与要计算的操作对应的计算图。
3、创建会话
4、运⾏会话，必要时使⽤feed字典指定占位符变量的值。
1.3 - Computing the Cost 计算成本
you can do it in one line of code in tensorflow!
练习：实现交叉熵损失。您将使⽤的函数是:
1 # GRADED FUNCTION: cost
2
3 def cost(logits, labels):
4    """
5    Computes the cost using the sigmoid cross entropy
6
7    Arguments:
8    logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)
9                  包含z的向量，最后⼀个线性单元的输出(在最后的s型激活之前)
10    labels -- vector of labels y (1 or 0)  标签向量y
11
12    Note: What we've been calling "z" and "y" in this class are respectively called "logits" and "labels"
13    in the TensorFlow documentation. So logits will feed into z, and labels into y.
14  注意：我们在这个类中所称的“z”和“y”分别称为“logits”和“label”
15    在TensorFlow⽂档中。所以logits会被输⼊z, label会被输⼊y。
16    Returns:
17    cost -- runs the session of the cost (formula (2))
18    """
19
20    ### START CODE HERE ###
21
22    # Create the placeholders for "logits" (z) and "labels" (y) (approx. 2 lines)
23    z = tfpat.v1.placeholder(tf.float32, name = 'z')
24    y = tfpat.v1.placeholder(tf.float32, name = 'y')
25
26    # Use the loss function (approx. 1 line)
27    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits = z, labels = y)
28
29    # Create a session (approx. 1 line). See method 1 above.
30    sess = tfpat.v1.Session()
31
32    # Run the session (approx. 1 line).
33    cost = sess.run(cost, feed_dict = {z:logits, y:labels})#使⽤feed字典来输⼊，⽤z去喂logits，⽤y去喂label
34
35    # Close the session (approx. 1 line). See method 1 above.
36    sess.close()
37
38    ### END CODE HERE ###
39
40    return cost
# GRADED FUNCTION: 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.4 - Using One Hot encodings 使⽤独热编码（0、1编码）
在深度学习中，很多时候你会得到⼀个数字从0到C-1的y向量，其中C是类别的数量。如果C是样本数4，那么你可能有以下y向量，你将需要转换如下:
这被称为“one hot”编码，因为在转换后的表⽰中，每列中只有⼀个元素是“hot”(即设置为1)。在tensorflow中，你可以使⽤⼀⾏代码:
<_hot(labels, depth, axis)
练习：执⾏下⾯的函数取⼀个向量的标签和类 的总数，并返回⼀个独热编码。使⽤tf.one_hot()来完成此操作。
1 # GRADED FUNCTION: one_hot_matrix
2
3 def one_hot_matrix(labels, C):
4    """
5    Creates a matrix where the i-th row corresponds to the ith class number and the jth column
6                      corresponds to the jth training example. So if example j had a label i. Then entry (i,j)
7                      will be 1.    创建⼀个矩阵，其中第i⾏对应第i个类号，第j列对应第j个训练样本
8                                    所以如果第j个样本对应着第i个标签，那么entry (i,j)将会是1
9
10    Arguments:
11    labels -- vector containing the labels          lables - 标签向量
12    C -- number of classes, the depth of the one hot dimension          C - 分类数⼀个热维度的深度
13
14    Returns:
15    one_hot -- one hot matrix ⼀个热矩阵
16    """
17
18    ### START CODE HERE ###
19
20    # Create stant equal to C (depth), name it 'C'. (approx. 1 line)
21    C = tf.constant(C, name = 'C')
22
23    # _hot, be careful with the axis (approx. 1 line)
24    one_hot_matrix = tf.one_hot(labels, C, axis = 0)#这⾥是初始化，第⼀、⼆个参数都是靠形参来说输⼊的
25
26    # Create the session (approx. 1 line)
27    sess = tfpat.v1.Session()
28
29    # Run the session (approx. 1 line)
30    one_hot = sess.run(one_hot_matrix)#为啥这⾥不⽤喂数据呢？数据靠形参输⼊的；run⼀下返回的是⼀个矩阵
31
32    # Close the session (approx. 1 line). See method 1 above.
33    sess.close()
34
35    ### END CODE HERE ###
36
37    return one_hot
# GRADED FUNCTION: one_hot_matrix
labels = np.array([1,2,3,0,2,1])
one_hot = one_hot_matrix(labels, C = 4)
print ("one_hot = " + str(one_hot))
运⾏结果：
1.5 - Initialize with zeros and ones 初始化0和1
现在您将学习如何初始化⼀个由0和1组成的向量。您将要调⽤的函数是tf.ones()。要⽤零进⾏初始化，可以使⽤tf.zeros()。这些函数采⽤⼀个形状，并分别返回⼀个充满0和1的维形数组。
练习：实现下⾯的函数以获取⼀个形状并返回⼀个数组(形状的维数为1)。
1 # GRADED FUNCTION: ones
2
3 def ones(shape):
4    """

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。