前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >TensorFlow基础入门

TensorFlow基础入门

作者头像
云水木石
发布于 2019-07-01 07:30:27
发布于 2019-07-01 07:30:27
1.7K00
代码可运行
举报
运行总次数:0
代码可运行

注:这篇文章的内容来自课程[Improving Deep Neural Networks: Hyperparameter tuning, Regularization and Optimization]的编程练习。coursera上的编程练习设计得非常贴心,一步步引导学员完成练习,对于编程基础薄弱的同学尤为友好。

到目前为止,您一直使用numpy来构建神经网络。现在我们将引导您使用一个深度学习框架,让您可以更轻松地构建神经网络。TensorFlow、PaddlePaddle、Torch、Caffe、Keras等机器学习框架可显著加速机器学习开发。在此作业中,您将学习在TensorFlow中执行以下操作:

  • 初始化变量
  • 开始会话
  • 训练算法
  • 实施神经网络

编程框架不仅可以缩短编码时间,而且有时还可以执行优化来加速代码。

1 - 探索Tensorflow程序库

首先,请导入相关库:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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)

现在您已经导入了该库,我们将引导您完成不同的应用程序。您将从一个例子开始,在这里我们为您计算一个训练样例的损失。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
y_hat = tf.constant(36, name='y_hat')            # 定义y_hat常量,值为36.
y = tf.constant(39, name='y')                    # 定义y,值为39loss = tf.Variable((y - y_hat)**2, name='loss')  # 为损失创建一个变量init = tf.global_variables_initializer()         # init将在后面运行 (session.run(init)),
                                                # loss变量将被初始化,准备计算
with tf.Session() as session:                    # 创建一个会话并打印输出
   session.run(init)                            # 初始化变量
   print(session.run(loss))                     # 打印loss值

在TensorFlow中编写和运行程序有以下步骤:

  1. 创建尚未执行/评估的张量(变量)。
  2. 在这些张量之间写入操作。
  3. 初始化张量。
  4. 创建一个会话。
  5. 运行会话,它将运行您上面写的操作。

因此,当我们为损失创建一个变量时,我们简单地将损失定义为其他数的函数,但没有评估它的值。为了评估它,我们必须运行init=tf.global_variables_initializer()。它初始化损失变量,并在最后一行代码中,评估损失的值并打印其值。

现在让我们看一个简单的例子:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)
print(c)

输出为 Tensor(“Mul:0”, shape=(), dtype=int32)

正如所料,您不会看到20!而是得到一个张量,结果是一个没有shape属性的张量,它的类型是”int32”。您所做的只是放在’计算图’中,但您还没有运行这个计算。为了真正相加这两个数字,您将不得不创建一个会话并运行它。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
sess = tf.Session()
print(sess.run(c))

输出为 20

很棒! 总结一下,记得初始化变量,创建一个会话并在会话中运行这些操作

接下来,您还必须了解占位符。占位符是一个对象,其值只能在稍后指定。要指定占位符的值,可以使用”馈送字典”(feed_dict变量)传入值。下面,我们为x创建了一个占位符,这允许我们稍后在运行会话时传入一个数字。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 在feed_dict中改变x的值x = tf.placeholder(tf.int64, name = 'x')
print(sess.run(2 * x, feed_dict = {x: 3}))
sess.close()

输出为 6

当您第一次定义x时,您不必为它指定一个值。占位符只是一个变量,您将仅在以后运行会话时分配数据。也就是说您在运行会话时向这些占位符提供数据

以下是所发生的事情:当您指定计算所需的操作时,也就是告诉TensorFlow如何构建计算图。计算图可以有一些占位符,其值将在稍后指定。最后,当您运行会话时,告诉TensorFlow执行计算图。

1.1 - 线性函数

让我们通过计算以下等式来开始编程练习:Y = WX + bY,其中W和X是随机矩阵,b是随机向量。

练习:计算WX + b,其中W,X和b符合随机正态分布。W的形状是(4,3),X为(3,1),b是(4,1)。作为一个示例,下面代码是如何定义一个具有shape(3,1)的常量X:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
X = tf.constant(np.random.randn(3,1),name ="X")

您可能会发现以下函数很有用:

  • tf.matmul(…, …)做一个矩阵乘法
  • tf.add(…, …)做一个加法
  • np.random.randn(…)随机初始化
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: linear_functiondef linear_function():
   """
   实现一个线性函数:
           初始化W为一个形状为(4,3)的随机张量
           初始化X为一个形状为(3,1)的随机张量
           初始化b为一个形状为(4,1)的随机张量
   返回:
   result -- 运行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 ###   # 使用tf.Session()创建会话,并用sess.run运行您要计算的变量   ### START CODE HERE ###
   sess = tf.Session()
   result = sess.run(Y)
   ### END CODE HERE ###   # 关闭会话
   sess.close()   return result

1.2 - 计算sigmoid

非常棒! 您刚刚实现了一个线性函数。Tensorflow提供了各种常用的神经网络函数,如tf.sigmoid和tf.softmax。对于这个练习,我们计算一个输入的sigmoid函数。

您将使用占位符变量x执行此练习。运行会话时,应该使用馈送字典传入z。在本练习中,您需要(1) 创建一个占位符x,(2) 使用tf.sigmoid定义计算sigmoid值,然后(3) 运行会话。

练习:实现下面的sigmoid函数,参考使用以下代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
tf.placeholder(tf.float32,name ="...")
tf.sigmoid(...)
sess.run(..., feed_dict = {x: z})

请注意,有两种典型的方式来创建和使用tensorflow中的会话:

方法1:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
sess = tf.Session()
# Run the variables initialization (if needed), run the operations
result = sess.run(..., feed_dict = {...})
sess.close() # Close the session

方法2:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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 :)
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: sigmoiddef sigmoid(z):
   """
   计算z的sigmoid值   参数:
   z -- 输入值,标量或向量   返回:
   results -- z的sigmoid值
   """   ### START CODE HERE ### ( approx. 4 lines of code)
   # 为x创建一个占位符,命名为'x'.
   x = tf.placeholder(tf.float32, name = "x")   # 计算sigmoid(x)
   sigmoid = tf.sigmoid(x)   # 创建一个会话,运行之。请使用上面提到的方法2。
   # 您应该使用一个feed_dic将z的值传递给x。
   with tf.Session() as sess:
       # 运行会话并输出结果给"result"
       result = sess.run(sigmoid, feed_dict = {x:z})   ### END CODE HERE ###   return result

总结一下,您现在知道如何:

  1. 创建占位符
  2. 指定计算对应的计算图
  3. 创建会话
  4. 运行会话,必要时使用馈送字典来指定占位符变量的值。

1.3 - 计算代价(cost)

您也可以使用内置函数来计算神经网络的代价。因此,您大可不必编写代码计算函数:

在tensorflow中只需一行代码即可完成!

练习:实现交叉熵损失,您将使用的函数是:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
tf.nn.sigmoid_cross_entropy_with_logits(logits = ..., labels = ...)

您的代码应该输入z,计算sigmoid(得到a),然后计算交叉熵代价J。所有这些都可以通过一次调用tf.nn.sigmoid_cross_entropy_with_logits来完成,它将计算:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: costdef cost(logits, labels):
   """
   使用交叉熵计算代价   参数:
   logits -- 包含z的向量,最后一个线性单元的输出(在sigmoid激活之前)
   labels -- 标签向量y(10)   注意: 在本类中我们叫做"z""y"的,在TensorFlow文档中分别称作"logits""labels"。所以logits将传入z, 而labels传入y.   返回:
   cost -- 运行会话计算出的成本(根据公式(2))
   """   ### START CODE HERE ###   # 为"logits" (z) 和 "labels" (y)创建占位符
   z = tf.placeholder(tf.float32, shape = logits.shape, name = "logits")
   y = tf.placeholder(tf.float32, shape = labels.shape, name = "labels")   # 使用损失函数
   cost = tf.nn.sigmoid_cross_entropy_with_logits(logits = z, labels = y)   # 创建会话,参考上面的方法1
   sess = tf.Session()   # 运行会话
   cost = sess.run(cost, feed_dict={z: logits, y: labels})   # 关闭会话
   sess.close()   ### END CODE HERE ###   return cost

1.4 - 使用一位有效编码(One Hot encoding)

在很多深度学习里,您会得到一个y向量,数字范围从0到C-1,其中C是类的数量。比如C为4,那么您可能得到以下的y矢量,您需要按如下方式进行转换:

这通常称为”一位有效(one hot)”编码,因为在转换的表示中,每列的对应元素是”有效位(hot)”(意思是设置为1)。要在numpy中进行这种转换,您可能需要编写好几行代码。在tensorflow中,只需一行代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
tf.one_hot(labels, depth, axis)

练习:运行下面的函数,取一个标签向量和类别总数C,返回one hot编码。请使用tf.one_hot()来实现。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: one_hot_matrixdef one_hot_matrix(labels, C):
   """
   创建一个矩阵,其第i行对应第i个类别,且第j列对应第j个训练样本,也即如果样本j的标签为i,则矩阵(i,j)的元素值为1。   参数:
   labels -- 包含标签的向量
   C -- 类别的数量,也是one hot维度值   返回:
   one_hot -- one hot矩阵
   """   ### START CODE HERE ###   # 创建等于C的常量,命名为'C'.
   C = tf.constant(C)   # 使用tf.one_hot, 请注意axis参数值
   one_hot_matrix = tf.one_hot(labels, C, axis = 0)   # 创建会话
   sess = tf.Session()   # 运行会话
   one_hot = sess.run(one_hot_matrix)   # 关闭会话
   sess.close()   ### END CODE HERE ###   return one_hot

1.5 - 使用零和一初始化

现在您将学习如何初始化一个零和一的向量。你要调用的函数是tf.ones()。要用零初始化,你可以使用tf.zeros()来代替。这些函数传入一个shape,分别返回一个全部元素为0和1的且维数等于shape的数组。

练习:实现下面的函数,传入shape并返回一个数组(维数和shape相同)。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
tf.ones(shape)
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: onesdef ones(shape):
   """
   创建一个维度为shape的全1数组   参数:
   shape -- 您要创建的数组的维度shape   返回:
   ones --1数组
   """   ### START CODE HERE ###   # 使用tf.ones(...)创建"ones"张量
   ones = tf.ones(shape)   # 创建会话
   sess = tf.Session()   # 运行会话,计算'ones'
   ones = sess.run(ones)   # 关闭会话
   sess.close()   ### END CODE HERE ###
   return ones

2 - 在tensorflow中构建您的第一个神经网络

在这部分任务中,您将使用tensorflow建立一个神经网络。请记住,实现tensorflow模型分为两部分:

  • 创建计算图
  • 运行图

让我们深入探讨您要解决的问题!

2.0 - 问题陈述:SIGNS数据集

有一天下午,和一些朋友一起,我们决定教电脑破译手语。我们花了几个小时在白墙前拍摄照片,得到了以下数据集。现在您的工作是构建一个算法,以便帮助语言障碍人士与不懂手语的人进行沟通。

  • 训练数据集:1080个图片(64×64像素),代表从0到5的手势(每个数字180张图片)。
  • 测试数据集:120张图片(64×64像素),代表从0到5的手势(每个数字20张图片)。

请注意,这是SIGNS数据集的一个子集。完整的数据集包含更多的手势。

以下是每个数字的示例,以及我们如何表示标签。这些是在我们将图像解像度降低到64×64像素之前的原始图片。

运行以下代码以加载数据集。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

通常,我们需要将图像数据集压平(flatten),然后除以255将其归一化。最重要的是,将每个标签转换为one hot矢量。运行下面的代码以执行此操作。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 压平训练和测试图片
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.
# 将训练和测试标签转换为one hot矩阵
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))

number of training examples = 1080 number of test examples = 120 X_train shape: (12288, 1080) Y_train shape: (6, 1080) X_test shape: (12288, 120) Y_test shape: (6, 120)

请注意,12288来自64×64×364×64×3。每个图像是方形的,64×64像素,3是RGB颜色。在继续任务之前,请确保您了解所有这些形状的含义。

您的目标是构建能够高准确度识别手势的算法。要做到这一点,您要建立一个tensorflow模型,这个模型几乎和您之前使用numpy构建的猫识别模型一样(但现在使用softmax输出)。将您的numpy实现与tensorflow实现进行比较是一个不错的点子。

模型定义为LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX。SIGMOID输出层替换为SOFTMAX。当超过两个类别时,SOFTMAX层比SIGMOID更通用。

2.1 - 创建占位符

您的第一项任务是为X和Y创建占位符,可以稍后在运行会话时传递训练数据。

练习:执行下面的函数以创建tensorflow中的占位符。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: create_placeholdersdef create_placeholders(n_x, n_y):
   """
   为tensorflow会话创建占位符.   参数:
   n_x -- 标量, 图像向量的大小(num_px * num_px = 64 * 64 * 3 = 12288)
   n_y -- 标量, 类别的数量(05, 所以 -> 6)   返回:
   X -- 数据输入占位符,形状为[n_x, None],数据类型"float"
   Y -- 输入标签的占位符,形状[n_y, None],数据类型"float"   提示:
   - 您将使用None,因为它使我们能够灵活处理占位符所代表的样本的数量.
     事实上,测试/训练阶段样本的数量是不同的.
   """   ### START CODE HERE ### (approx. 2 lines)
   X = tf.placeholder(dtype = tf.float32, shape = (n_x, None), name = "X")
   Y = tf.placeholder(dtype = tf.float32, shape = (n_y, None), name = "Y")
   ### END CODE HERE ###   return X, Y

2.2 - 初始化参数

您的第二个任务是在tensorflow中初始化参数。

练习:执行下面的函数来初始化tensorflow中的参数。您将使用Xavier来初始化权重,使用零初始化偏置,其形状如下所示。作为一个示范,对于W1和b1您可以使用:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
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())

请使用seed = 1来确保您的结果与我们的结果相符。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: initialize_parametersdef initialize_parameters():
   """
   Initializes parameters to build a neural network with tensorflow. The shapes are:
                       W1 : [25, 12288]
                       b1 : [25, 1]
                       W2 : [12, 25]
                       b2 : [12, 1]
                       W3 : [6, 12]
                       b3 : [6, 1]   Returns:
   parameters -- a dictionary of tensors containing W1, b1, W2, b2, W3, b3
   """   tf.set_random_seed(1)                   # so that your "random" numbers match ours   ### START CODE HERE ### (approx. 6 lines of code)
   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())
   ### END CODE HERE ###   parameters = {"W1": W1,
                 "b1": b1,
                 "W2": W2,
                 "b2": b2,
                 "W3": W3,
                 "b3": b3}   return parameters

2.3 - Tensorflow中的前向传播

您现在将实现tensorflow中的前向传播模块。该函数将接收参数字典并完成前向传递。您将使用的函数有:

  • tf.add(…, …)做一个加法
  • tf.matmul(…, …)做一个矩阵乘法
  • tf.nn.relu(…)应用ReLU激活

问题:实现神经网络的前向传递。我们为您添加了numpy等价代码注释,以便您可以将tensorflow实现与numpy进行比较。重要的是要注意前向传播在z3处停止。原因在于,在tensorflow中,最后的线性层输出作为输入给计算损失的函数。因此,您不需要a3!

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: forward_propagationdef forward_propagation(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']   ### START CODE HERE ### (approx. 5 lines)              # 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
   ### END CODE HERE ###   return Z3

2.4 - 计算代价

如前所见,使用以下方法计算代价非常简单:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = ..., labels = ...))

问题:实现如下代价函数。

  • 重的一点,tf.nn.softmax_cross_entropy_with_logits的“logits”和“labels”输入形状为(样本数量, 类别数目)。 我们已经为您转换了Z3和Y.
  • 另外,tf.reduce_mean是对样本进行求和的。
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# GRADED FUNCTION: compute_costdef compute_cost(Z3, Y):
   """
   Computes the cost   Arguments:
   Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)
   Y -- "true" labels vector placeholder, same shape as Z3   Returns:
   cost - Tensor of the cost function
   """   # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)
   logits = tf.transpose(Z3)
   labels = tf.transpose(Y)   ### START CODE HERE ### (1 line of code)
   cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits, labels = labels))
   ### END CODE HERE ###   return cost

2.5 - 反向传播 & 参数更新

这里您要感谢编程框架。所有反向传播和参数更新都在1行代码里处理,模型中加入这行代码非常容易。

计算代价函数后,您将创建一个“优化器”对象。运行tf.session时,必须一起调用此对象与代价。当被调用时,它将使用所选择的方法和学习速率对给定代价进行优化。

例如,梯度下降优化器:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)

要进行优化,您应该这样做:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
_ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})

通过tensorflow图以相反顺序来计算反向传播,从代价到输入。

注意编码时,我们经常使用_作为“一次性”变量来存储我们稍后不需要使用的值。这里,_返回我们不需要的优化器的评估值(c取值代价变量)。

2.6 - 构建模型

现在,将把它们组合在一起!

练习:实现模型。您将会调用之前实现的功能。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,
         num_epochs = 1500, minibatch_size = 32, print_cost = True):
   """
   Implements a three-layer tensorflow neural network: 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()                         # to be able to rerun the model without overwriting tf variables
   tf.set_random_seed(1)                             # to keep consistent results
   seed = 3                                          # to keep consistent results
   (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   # Create Placeholders of shape (n_x, n_y)
   ### START CODE HERE ### (1 line)
   X, Y = tf.placeholder(dtype=tf.float32, shape=(n_x, None), name = "X"), tf.placeholder(dtype=tf.float32, shape=(n_y, None), name = "Y")
   ### END CODE HERE ###   # Initialize parameters
   ### START CODE HERE ### (1 line)
   parameters = initialize_parameters()
   ### END CODE HERE ###   # Forward propagation: Build the forward propagation in the tensorflow graph
   ### START CODE HERE ### (1 line)
   Z3 = forward_propagation(X, parameters)
   ### END CODE HERE ###   # Cost function: Add cost function to tensorflow graph
   ### START CODE HERE ### (1 line)
   cost = compute_cost(Z3, Y)
   ### END CODE HERE ###   # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
   ### START CODE HERE ### (1 line)
   optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)
   ### END CODE HERE ###   # Initialize all the variables
   init = tf.global_variables_initializer()   # Start the session to compute the tensorflow graph
   with tf.Session() as sess:       # Run the initialization
       sess.run(init)       # Do the training loop
       for epoch in range(num_epochs):           epoch_cost = 0.                       # Defines a cost related to an epoch
           num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set
           seed = seed + 1
           minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)           for minibatch in minibatches:               # Select a minibatch
               (minibatch_X, minibatch_Y) = minibatch               # IMPORTANT: The line that runs the graph on a minibatch.
               # Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
               ### START CODE HERE ### (1 line)
               _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
               ### END CODE HERE ###               epoch_cost += minibatch_cost / num_minibatches           # Print the cost every epoch
           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)       # plot the cost
       plt.plot(np.squeeze(costs))
       plt.ylabel('cost')
       plt.xlabel('iterations (per tens)')
       plt.title("Learning rate =" + str(learning_rate))
       plt.show()       # lets save the parameters in a variable
       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

运行下面的代码来训练您的模型!在我们的机器上大约需要5分钟。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
parameters = model(X_train, Y_train, X_test, Y_test)

令人惊讶的是,您的算法可以识别代表0到5之间的数字的手势,精确度为71.7%。

总结

  • 您的模型看起来足够大,足以适应训练集。但是,考虑到训练和测试之间的精度差异,您可以尝试添加L2或dropout正则化来减少过拟合。
  • 将会话视为一组代码来训练模型。每次在小批次上运行会话时,都会训练参数。总的来说,您已经运行了很多次(1500个epoch)的会话,直到您获得训练好的参数。

2.7 - 使用自己的图片进行测试

祝贺您完成这项任务。现在可以拍摄您的手势,并查看模型的输出:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
import scipy
from PIL import Image
from scipy import ndimage## START CODE HERE ## (PUT YOUR IMAGE NAME)
my_image = "thumbs_up.jpg"
## END CODE HERE ### We preprocess your image to fit your algorithm.
fname = "images/" + my_image
image = np.array(ndimage.imread(fname, flatten=False))
my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T
my_image_prediction = predict(my_image, parameters)plt.imshow(image)
print("Your algorithm predicts: y = " + str(np.squeeze(my_image_prediction)))

Your algorithm predicts: y = 3

尽管您可以看到算法似乎对其进行了错误分类,但您还是值得表扬。原因在于训练集不包含任何“竖起大拇指”手势,所以模型不知道如何处理它!我们称之为“不匹配的数据分布”,它是下一门课程“构建机器学习项目”将会研究的内容。

您应该记住的是:

  • Tensorflow是用于深度学习的编程框架
  • Tensorflow中的两个主要对象类是张量和操作符。
  • 在tensorflow中编码时,您必须采取以下步骤:
    • 创建一个包含张量(变量,占位符…)和操作(tf.matmul,tf.add,…)的图
    • 创建一个会话
    • 初始化会话
    • 运行会话以执行图
  • 您可以像在model()中看到的那样多次执行图
  • 在“优化器”对象上运行会话时,会自动完成反向传播和优化。
本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2018-06-05,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 云水木石 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
初步了解TensorFlow
在本章中,我们一起来学习下TensorFlow。我们将会学习到TensorFlow的一些基本库。通过计算一个线性函数来熟悉这些库。最后还学习使用TensorFlow搭建一个神经网络来识别手势。本章用到的一些库在这里下载。
夜雨飘零
2020/05/06
5580
TensorFlow_Tutorial_v3b——improving NN performance测验
Welcome to this week's programming assignment. Until now, you've always used numpy to build neural networks. Now we will step you through a deep learning framework that will allow you to build neural networks more easily. Machine learning frameworks like TensorFlow, PaddlePaddle, Torch, Caffe, Keras, and many others can speed up your machine learning development significantly. All of these frameworks also have a lot of documentation, which you should feel free to read. In this assignment, you will learn to do the following in TensorFlow:
列夫托尔斯昊
2020/08/25
1.4K0
TensorFlow_Tutorial_v3b——improving NN performance测验
改善深层神经网络 - 第二课第三周作业 TensorFlow Tutorial
Welcome to this week’s programming assignment. Until now, you’ve always used numpy to build neural networks. Now we will step you through a deep learning framework that will allow you to build neural networks more easily. Machine learning frameworks like TensorFlow, PaddlePaddle, Torch, Caffe, Keras, and many others can speed up your machine learning development significantly. All of these frameworks also have a lot of documentation, which you should feel free to read. In this assignment, you will learn to do the following in TensorFlow:
Steve Wang
2019/05/29
2.2K0
02.改善深层神经网络:超参数调试、正则化以及优化 W3. 超参数调试、Batch Norm和程序框架(作业:TensorFlow教程+数字手势预测)
笔记:02.改善深层神经网络:超参数调试、正则化以及优化 W3. 超参数调试、Batch Norm和程序框架
Michael阿明
2021/02/19
9330
【DL笔记5】一文上手TensorFlow,并搭建神经网络实现手写数字识别
从【DL笔记1】到【DL笔记N】,是我学习深度学习一路上的点点滴滴的记录,是从Coursera网课、各大博客、论文的学习以及自己的实践中总结而来。从基本的概念、原理、公式,到用生动形象的例子去理解,到动手做实验去感知,到著名案例的学习,到用所学来实现自己的小而有趣的想法......我相信,一路看下来,我们可以感受到深度学习的无穷的乐趣,并有兴趣和激情继续钻研学习。 正所谓 Learning by teaching,写下一篇篇笔记的同时,我也收获了更多深刻的体会,希望大家可以和我一同进步,共同享受AI无穷的乐趣。
beyondGuo
2018/10/25
8040
【DL笔记5】一文上手TensorFlow,并搭建神经网络实现手写数字识别
Convolution_model_Application_v1a
Welcome to Course 4's second assignment! In this notebook, you will:
列夫托尔斯昊
2020/08/25
1.7K0
Convolution_model_Application_v1a
卷积神经网络 第一周作业 Convolution+model+-+Application+-+v1
Welcome to Course 4’s second assignment! In this notebook, you will:
Steve Wang
2019/05/29
1.2K0
三天速成 TensorFlow课件分享
该教程第一天先介绍了深度学习和机器学习的潜力与基本概念,而后便开始探讨深度学习框架 TensorFlow。首先我们将学到如何安装 TensorFlow,其实我们感觉 TensorFlow 环境配置还是相当便捷的,基本上按照官网的教程就能完成安装。随后就从「Hello TensorFlow」开始依次讲解计算图、占位符、张量等基本概念。
刘盼
2018/03/16
2K0
三天速成 TensorFlow课件分享
04.卷积神经网络 W1.卷积神经网络(作业:手动/TensorFlow 实现卷积神经网络)
0 padding 会在图片周围填充 0 元素(下图 p = 2 p=2 p=2 )
Michael阿明
2021/02/19
9730
TensorFlow 深度学习第二版:1~5
人工神经网络利用了 DL 的概念 。它们是人类神经系统的抽象表示,其中包含一组神经元,这些神经元通过称为轴突的连接相互通信。
ApacheCN_飞龙
2023/04/23
1.7K0
TensorFlow 深度学习第二版:1~5
数据科学 IPython 笔记本 一、TensorFlow
一、TensorFlow 原文:TensorFlow Tutorials 译者:飞龙 协议:CC BY-NC-SA 4.0 1.1 TensorFlow 基本操作 致谢:派生于 Aymeric Damien 的 TensorFlow 示例 配置 参考配置指南。 import tensorflow as tf # 基本的常量操作 # 由构造器返回的值 # 表示常量操作的输出 a = tf.constant(2) b = tf.constant(3) # 加载默认图 with tf.Session(
ApacheCN_飞龙
2022/05/07
3900
数据科学 IPython 笔记本 一、TensorFlow
深入浅出解读卷积神经网络
作者:石文华 编辑:田 旭 卷积神经网络 图1 全连接神经网络结构图 图2 卷积神经网络结构图 卷积神经网络和全连接的神经网络结构上的差异还是比较大的,全连接的网络,相邻两层的节点都有边相连,而卷积神
机器学习算法工程师
2018/03/06
7110
深入浅出解读卷积神经网络
TensorFlow-GPU线性回归可视化代码,以及问题总结
通过TensorBoard将TensorFlow模型的训练过程进行可视化的展示出来,将训练的损失值随迭代次数的变化情况,以及神经网络的内部结构展示出来,以此更好的了解神经网络。
andrew_a
2019/07/30
7810
TensorFlow-GPU线性回归可视化代码,以及问题总结
简单的TensorFlow分类教程
本篇文章有2个topic,简单的分类器和TensorFlow。首先,我们会编写函数生成三种类别的模拟数据。第一组数据是线性可分的,第二种是数据是月牙形数据咬合在一起,第三种是土星环形数据。每组数据有两个类型,我们将分别建立模型,对每组数据分类。
用户1332428
2018/07/30
5480
简单的TensorFlow分类教程
解决AttributeError: module tensorflow has no attribute placeholder
如果你在使用TensorFlow时遇到了"AttributeError: module 'tensorflow' has no attribute 'placeholder'"的错误,这意味着你正在使用的TensorFlow版本与你的代码不兼容。这个错误通常是因为在TensorFlow 2.0及更高版本中,'placeholder'被移除了。 为了解决这个问题,有几种方法可以尝试:
大盘鸡拌面
2023/10/17
2.7K0
TensorFlow线性回归与逻辑回归实战
Huber loss是为了增强平方误差损失函数(squared loss function)对噪声(或叫离群点,outliers)的鲁棒性提出的。
公众号guangcity
2019/09/20
1.6K0
TensorFlow线性回归与逻辑回归实战
深度学习之 TensorFlow(五):mnist 的 Alexnet 实现
尝试用 Alexnet 来构建一个网络模型,并使用 mnist 数据查看训练结果。 我们将代码实现分为三个过程,加载数据、定义网络模型、训练数据和评估模型。 实现代码如下: #-*- coding:utf-8 -*_ #加载数据 import tensorflow as tf # 输入数据 from tensorflow.examples.tutorials.mnist import input_data #TensorFlow 自带,用来下载并返回 mnist 数据。可以自己下载 mnist数据
希希里之海
2018/05/16
7160
机器之心GitHub项目:从零开始用TensorFlow搭建卷积神经网络
机器之心原创 参与:蒋思源 机器之心基于 Ahmet Taspinar 的博文使用 TensorFlow 手动搭建卷积神经网络,并提供所有代码和注释的 Jupyter Notebook 文档。我们将不仅描述训练情况,同时还将提供各种背景知识和分析。所有的代码和运行结果都已上传至 Github,机器之心希望通过我们的试验提供精确的代码和运行经验,我们将持续试验这一类高质量的教程和代码。 机器之心项目地址:https://github.com/jiqizhixin/ML-Tutorial-Experiment
机器之心
2018/05/08
1.5K0
机器之心GitHub项目:从零开始用TensorFlow搭建卷积神经网络
Tensorflow快速入门
作者:叶 虎 编辑:李文臣 PART 01 Tensorflow简介 引言 实践深度学习肯定要至少学习并掌握一个深度学习框架。这里我们介绍一个最流行的深度学习框架:Tensorflow。Tensorf
机器学习算法工程师
2018/03/06
1.1K0
Tensorflow快速入门
tensorflow入门:Neural Network for mnist
我们使用tensorflow实现类似于上图的简单深度网络,用于mnist数据集预测模型的实现。理论方面不再赘述。
Steve Wang
2019/05/26
4910
推荐阅读
相关推荐
初步了解TensorFlow
更多 >
LV.0
上海兆芯集成电路有限公司资深软件工程师
目录
  • 1 - 探索Tensorflow程序库
    • 1.1 - 线性函数
    • 1.2 - 计算sigmoid
    • 1.3 - 计算代价(cost)
    • 1.4 - 使用一位有效编码(One Hot encoding)
    • 1.5 - 使用零和一初始化
  • 2 - 在tensorflow中构建您的第一个神经网络
    • 2.0 - 问题陈述:SIGNS数据集
    • 2.1 - 创建占位符
    • 2.2 - 初始化参数
    • 2.3 - Tensorflow中的前向传播
    • 2.4 - 计算代价
    • 2.5 - 反向传播 & 参数更新
    • 2.6 - 构建模型
    • 2.7 - 使用自己的图片进行测试
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档