TensorFlow - 快速指南

TensorFlow - 简介

TensorFlow 是一个软件库或框架，由 Google 团队设计，旨在以最简单的方式实现机器学习和深度学习概念。它结合了优化技术的计算代数，可以轻松计算许多数学表达式。

TensorFlow 的官方网站如下 -

www.tensorflow.org

现在让我们考虑 TensorFlow 的以下重要特征 -

它包括一个借助称为张量的多维数组轻松定义、优化和计算数学表达式的功能。
它包括深度神经网络和机器学习技术的编程支持。
它具有使用各种数据集进行计算的高可扩展性。
TensorFlow 使用 GPU 计算，实现管理自动化。它还包括优化相同内存和所使用数据的独特功能。

为什么 TensorFlow 如此受欢迎？

TensorFlow 文档齐全，包含大量机器学习库。它提供了一些重要的功能和方法。

TensorFlow 也被称为“Google”产品。它包括各种机器学习和深度学习算法。TensorFlow 可以训练和运行深度神经网络，用于手写数字分类、图像识别、词嵌入和创建各种序列模型。

TensorFlow - 安装

要安装 TensorFlow，在系统中安装“Python”非常重要。Python 3.4+ 版本被认为是开始安装 TensorFlow 的最佳版本。

请考虑以下步骤在 Windows 操作系统中安装 TensorFlow。

步骤 1 - 验证正在安装的 python 版本。

步骤 2 - 用户可以选择任何机制在系统中安装 TensorFlow。我们推荐“pip”和“Anaconda”。pip是Python中用于执行和安装模块的命令。

在安装 TensorFlow 之前，我们需要在系统中安装 Anaconda 框架。

安装成功后，通过“conda”命令检查命令提示符。命令的执行如下所示 -

步骤 3 - 执行以下命令来初始化 TensorFlow 的安装 -

conda create --name tensorflow python = 3.5

它会下载 TensorFlow 设置所需的必要包。

步骤 4 - 成功设置环境后，激活 TensorFlow 模块非常重要。

activate tensorflow

步骤 5 - 使用 pip 在系统中安装“Tensorflow”。用于安装的命令如下 -

pip install tensorflow

和，

pip install tensorflow-gpu

安装成功后，了解TensorFlow的示例程序执行情况很重要。

以下示例帮助我们了解 TensorFlow 中的基本程序创建“Hello World”。

第一个程序实现的代码如下 -

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

了解人工智能

人工智能包括机器和专用计算机系统对人类智能的模拟过程。人工智能的例子包括学习、推理和自我纠正。人工智能的应用包括语音识别、专家系统、图像识别和机器视觉。

机器学习是人工智能的一个分支，它涉及可以学习任何新数据和数据模式的系统和算法。

让我们重点关注下面提到的维恩图来理解机器学习和深度学习概念。

机器学习包括机器学习的一部分，深度学习是机器学习的一部分。遵循机器学习概念的程序的能力是提高其观察数据的性能。数据转换的主要动机是提高其知识，以便在未来取得更好的结果，提供更接近特定系统所需输出的输出。机器学习包括“模式识别”，其中包括识别数据模式的能力。

应该训练这些模式以期望的方式显示输出。

机器学习可以通过两种不同的方式进行训练 -

监督培训
无监督训练

监督学习

监督学习或监督训练包括将训练集作为系统的输入给出的过程，其中每个示例都标有期望的输出值。这种类型的训练是使用特定损失函数的最小化来执行的，该损失函数表示相对于所需输出系统的输出误差。

训练完成后，根据训练集（也称为验证集）中不相交的示例来测量每个模型的准确性。

说明“监督学习”的最好例子是一堆包含信息的照片。在这里，用户可以训练模型来识别新照片。

无监督学习

在无监督学习或无监督训练中，包括训练示例，这些示例没有被系统标记为所属类别。系统寻找具有共同特征的数据，并根据内部知识特征改变它们。这类学习算法基本上用于聚类问题。

说明“无监督学习”的最佳示例是使用一堆不包含任何信息的照片，并且用户通过分类和聚类来训练模型。这种类型的训练算法在假设下工作，因为没有给出任何信息。

TensorFlow - 数学基础

在 TensorFlow 中创建基本应用程序之前，了解 TensorFlow 所需的数学概念非常重要。数学被认为是任何机器学习算法的核心。它借助数学的核心概念，定义了特定机器学习算法的解决方案。

向量

连续或离散的数字数组被定义为向量。机器学习算法处理固定长度的向量，以更好地生成输出。

机器学习算法处理多维数据，因此向量起着至关重要的作用。

矢量模型的图示如下所示 -

标量

标量可以定义为一维向量。标量是那些只包含大小而不包含方向的标量。对于标量，我们只关心大小。

标量的示例包括儿童的体重和身高参数。

矩阵

矩阵可以定义为多维数组，以行和列的格式排列。矩阵的大小由行长和列长定义。下图显示了任意指定矩阵的表示。

考虑如上所述的“m”行和“n”列的矩阵，矩阵表示将被指定为“m*n 矩阵”，它也定义了矩阵的长度。

数学计算

在本节中，我们将了解 TensorFlow 中的不同数学计算。

矩阵相加

如果矩阵具有相同维度，则可以将两个或多个矩阵相加。添加意味着根据给定位置添加每个元素。

考虑以下示例以了解矩阵加法的工作原理 -

$$示例:A=\begin{bmatrix}1 & 2 \\3 & 4 \end{bmatrix}B=\begin{bmatrix}5 & 6 \\7 & 8 \end{bmatrix}\:然后\:A +B=\begin{bmatrix}1+5 & 2+6 \\3+7 & 4+8 \end{bmatrix}=\begin{bmatrix}6 & 8 \\10 & 12 \end{bmatrix}$$

矩阵减法

矩阵减法的运算方式与两个矩阵的加法类似。只要维度相等，用户就可以对两个矩阵进行减法。

$$示例:A-\begin{bmatrix}1 & 2 \\3 & 4 \end{bmatrix}B-\begin{bmatrix}5 & 6 \\7 & 8 \end{bmatrix}\:然后\:AB -\begin{bmatrix}1-5 & 2-6 \\3-7 & 4-8 \end{bmatrix}-\begin{bmatrix}-4 & -4 \\-4 & -4 \end{bmatrix} $$

矩阵乘法

为了使两个矩阵 A m*n 和 B p*q 可相乘，n应等于p。得到的矩阵是 -

米*q

$$A=\begin{bmatrix}1 & 2 \\3 & 4 \end{bmatrix}B=\begin{bmatrix}5 & 6 \\7 & 8 \end{bmatrix}$$

$$c_{11}=\begin{bmatrix}1 & 2 \end{bmatrix}\begin{bmatrix}5 \\7 \end{bmatrix}=1\times5+2\times7=19\:c_{12} =\begin{bmatrix}1 & 2 \end{bmatrix}\begin{bmatrix}6 \\8 \end{bmatrix}=1\times6+2\times8=22$$

$$c_{21}=\begin{bmatrix}3 & 4 \end{bmatrix}\begin{bmatrix}5 \\7 \end{bmatrix}=3\times5+4\times7=43\:c_{22} =\begin{bmatrix}3 & 4 \end{bmatrix}\begin{bmatrix}6 \\8 \end{bmatrix}=3\times6+4\times8=50$$

$$C=\begin{bmatrix}c_{11} & c_{12} \\c_{21} & c_{22} \end{bmatrix}=\begin{bmatrix}19 & 22 \\43 & 50 \end {b矩阵}$$

矩阵转置

矩阵A，m*n的转置一般用AT(transpose)n*m表示，是通过将列向量转置为行向量而获得的。

$$示例:A=\begin{bmatrix}1 & 2 \\3 & 4 \end{bmatrix}\:然后\:A^{T}\begin{bmatrix}1 & 3 \\2 & 4 \end{ b矩阵}$$

向量的点积

任何 n 维向量都可以表示为矩阵 v = R^n*1。

$$v_{1}=\begin{bmatrix}v_{11} \\v_{12} \\\cdot\\\cdot\\\cdot\\v_{1n}\end{bmatrix}v_{2}= \begin{bmatrix}v_{21} \\v_{22} \\\cdot\\\cdot\\\cdot\\v_{2n}\end{bmatrix}$$

两个向量的点积是相应分量 - 沿同一维度的分量的乘积之和，可以表示为

$$v_{1}\cdot v_{2}=v_1^Tv_{2}=v_2^Tv_{1}=v_{11}v_{21}+v_{12}v_{22}+\cdot\cdot+ v_{1n}v_{2n}=\displaystyle\sum\limits_{k=1}^n v_{1k}v_{2k}$$

向量点积的例子如下 -

$$示例：v_{1}=\begin{bmatrix}1 \\2 \\3\end{bmatrix}v_{2}=\begin{bmatrix}3 \\5 \\-1\end{bmatrix}v_ {1}\cdot v_{2}=v_1^Tv_{2}=1\times3+2\times5-3\times1=10$$

机器学习和深度学习

人工智能是近年来最流行的趋势之一。机器学习和深度学习构成了人工智能。下面显示的维恩图解释了机器学习和深度学习的关系 -

机器学习

机器学习是让计算机按照设计和编程的算法运行的科学艺术。许多研究人员认为机器学习是迈向人类水平人工智能的最佳途径。机器学习包括以下类型的模式

监督学习模式
无监督学习模式

深度学习

深度学习是机器学习的一个子领域，其中相关算法受到称为人工神经网络的大脑结构和功能的启发。

当今深度学习的所有价值都是通过监督学习或从标记数据和算法中学习来实现的。

深度学习中的每种算法都经历相同的过程。它包括输入的非线性变换的层次结构，可用于生成统计模型作为输出。

考虑定义机器学习过程的以下步骤

识别相关数据集并准备进行分析。
选择要使用的算法类型
根据所使用的算法构建分析模型。
在测试数据集上训练模型，并根据需要进行修改。
运行模型以生成测试分数。

机器学习和深度学习之间的区别

在本节中，我们将了解机器学习和深度学习之间的区别。

数据量

机器学习适用于大量数据。它对于少量数据也很有用。另一方面，如果数据量快速增加，深度学习就会有效地工作。下图显示了机器学习和深度学习与数据量的工作原理 -

硬件依赖性

与传统机器学习算法不同，深度学习算法的设计严重依赖高端机器。深度学习算法执行大量矩阵乘法运算，需要大量的硬件支持。

特征工程

特征工程是将领域知识放入指定特征中的过程，以降低数据的复杂性并形成对学习算法可见的模式。

示例 - 传统的机器学习模式侧重于特征工程过程所需的像素和其他属性。深度学习算法专注于数据的高级特征。它减少了为每个新问题开发新特征提取器的任务。

解决问题的方法

传统的机器学习算法遵循标准程序来解决问题。它将问题分解为多个部分，解决每个部分并将它们组合起来以获得所需的结果。深度学习专注于从头到尾解决问题，而不是将问题分解。

执行时间处理时间

执行时间是训练算法所需的时间量。深度学习需要大量的时间来训练，因为它包含很多参数，需要比平常更长的时间。机器学习算法相对需要较少的执行时间。

可解释性

可解释性是比较机器学习和深度学习算法的主要因素。主要原因是深度学习在工业应用之前仍然受到重新考虑。

机器学习和深度学习的应用

在本节中，我们将了解机器学习和深度学习的不同应用。

计算机视觉用于通过指纹进行面部识别和考勤标记或通过车牌进行车辆识别。
从搜索引擎检索信息，例如文本搜索图像搜索。
具有指定目标识别的自动化电子邮件营销。
癌症肿瘤的医学诊断或任何慢性疾病的异常识别。
适用于照片标记等应用的自然语言处理。解释这种情况的最好例子是 Facebook。
在线广告。

未来的趋势

随着行业中使用数据科学和机器学习的趋势日益增长，每个组织在其业务中灌输机器学习将变得非常重要。
深度学习比机器学习变得更加重要。深度学习被证明是最先进性能的最佳技术之一。
机器学习和深度学习将在研究和学术领域证明是有益的。

结论

在本文中，我们概述了机器学习和深度学习，并提供了插图和差异，同时还重点关注了未来的趋势。许多人工智能应用程序主要利用机器学习算法来推动自助服务、提高客服人员的工作效率并使工作流程更加可靠。机器学习和深度学习算法为许多企业和行业领导者带来了令人兴奋的前景。

TensorFlow - 基础知识

在本章中，我们将学习 TensorFlow 的基础知识。我们将从了解张量的数据结构开始。

张量数据结构

张量作为 TensorFlow 语言的基本数据结构。张量表示任何称为数据流图的流程图中的连接边。张量被定义为多维数组或列表。

张量由以下三个参数标识 -

秩

张量中描述的维度单位称为秩。它标识张量的维数。张量的秩可以描述为所定义的张量的阶数或n维。

形状

行数和列数共同定义了张量的形状。

类型

类型描述分配给张量元素的数据类型。

用户需要考虑以下构建张量的活动 -

构建一个n维数组
转换n维数组。

TensorFlow 的各个维度

TensorFlow 包含各种维度。尺寸简要描述如下 -

一维张量

一维张量是一种普通的数组结构，包含一组相同数据类型的值。

宣言

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

带有输出的实现如下面的屏幕截图所示 -

元素的索引与 Python 列表相同。第一个元素以索引 0 开始；要通过索引打印值，您所需要做的就是提及索引号。

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

二维张量

数组序列用于创建“二维张量”。

二维张量的创建如下所述 -

以下是创建二维数组的完整语法 -

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
>>>

可以借助指定为索引号的行号和列号来跟踪二维张量的特定元素。

>>> tensor_2d[3][2]
14

张量处理和操作

在本节中，我们将学习张量处理和操作。

首先，让我们考虑以下代码 -

import tensorflow as tf
import numpy as np

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print (matrix1)
print (matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print (matrix_3)

matrix_det = tf.matrix_determinant(matrix_3)
with tf.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print (result1)
print (result2)
print (result3)

输出

上面的代码将生成以下输出 -

解释

我们在上面的源代码中创建了多维数组。现在，了解我们创建的图形和会话非常重要，它们管理张量并生成适当的输出。在图的帮助下，我们得到了指定张量之间数学计算的输出。

TensorFlow - 卷积神经网络

在理解了机器学习概念之后，我们现在可以将注意力转移到深度学习概念上。深度学习是机器学习的一个分支，被研究人员认为是近几十年来迈出的关键一步。深度学习实现的示例包括图像识别和语音识别等应用。

以下是深度神经网络的两种重要类型 -

卷积神经网络
循环神经网络

在本章中，我们将重点关注 CNN（卷积神经网络）。

卷积神经网络

卷积神经网络旨在通过多层阵列处理数据。这种类型的神经网络用于图像识别或人脸识别等应用。CNN 与任何其他普通神经网络的主要区别在于，CNN 将输入作为二维数组并直接对图像进行操作，而不是像其他神经网络那样专注于特征提取。

CNN 的主要方法包括识别问题的解决方案。谷歌和 Facebook 等顶级公司已投资于识别项目的研发，以更快地完成活动。

卷积神经网络使用三个基本思想 -

本地所属领域
卷积
池化

让我们详细了解这些想法。

CNN 利用输入数据中存在的空间相关性。神经网络的每个并发层都连接一些输入神经元。这个特定区域称为局部感受野。局部感受野集中于隐藏神经元。隐藏神经元处理上述字段内的输入数据，而没有意识到特定边界之外的变化。

以下是生成本地各自字段的图表表示 -

如果我们观察上面的表示，每个连接都会学习隐藏神经元的权重以及从一层到另一层的移动的相关连接。在这里，各个神经元不时地进行转换。这个过程称为“卷积”。

从输入层到隐藏特征图的连接映射被定义为“共享权重”，其中包含的偏差称为“共享偏差”。

CNN 或卷积神经网络使用池化层，这些层紧接在 CNN 声明之后。它将用户的输入作为来自卷积网络的特征图并准备压缩的特征图。池化层有助于用前一层的神经元创建层。

CNN 的 TensorFlow 实现

在本节中，我们将学习 CNN 的 TensorFlow 实现。需要整个网络的执行和适当尺寸的步骤如下所示 -

步骤 1 - 包括计算 CNN 模型所需的 TensorFlow 必要模块和数据集模块。

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

步骤 2 - 声明一个名为run_cnn()的函数，其中包含各种参数和优化变量以及数据占位符的声明。这些优化变量将声明训练模式。

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

步骤 3 - 在此步骤中，我们将使用输入参数声明训练数据占位符 - 28 x 28 像素 = 784。这是从mnist.train.nextbatch()绘制的展平图像数据。

我们可以根据我们的要求重塑张量。第一个值 (-1) 告诉函数根据传递给它的数据量动态调整该维度。中间的两个尺寸设置为图像大小（即 28 x 28）。

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

步骤 4 - 现在创建一些卷积层很重要 -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

步骤 5 - 让我们将输出展平，为完全连接的输出级做好准备 - 经过两层尺寸为 28 x 28 的步长 2 池化，到尺寸为 14 x 14 或最小 7 x 7 x,y 坐标，但是具有 64 个输出通道。要创建与“密集”层完全连接的层，新形状需要为 [-1, 7 x 7 x 64]。我们可以为这一层设置一些权重和偏差值，然后用 ReLU 激活。

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

步骤 6 - 具有特定 softmax 激活和所需优化器的另一层定义了准确性评估，这使得初始化算子的设置。

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

步骤 7 - 我们应该设置记录变量。这会添加一个摘要来存储数据的准确性。

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

以下是上述代码生成的输出 -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

TensorFlow - 循环神经网络

循环神经网络是一种面向深度学习的算法，遵循顺序方法。在神经网络中，我们总是假设每个输入和输出都独立于所有其他层。这些类型的神经网络被称为循环网络，因为它们以顺序方式执行数学计算。

考虑以下步骤来训练循环神经网络 -

步骤 1 - 输入数据集中的具体示例。

步骤 2 - 网络将举一个例子并使用随机初始化的变量进行一些计算。

步骤 3 - 然后计算预测结果。

步骤 4 - 生成的实际结果与预期值的比较将产生错误。

步骤 5 - 为了跟踪错误，它通过相同的路径传播，其中变量也被调整。

步骤 6 - 重复步骤 1 到 5，直到我们确信为获取输出而声明的变量已正确定义。

步骤 7 - 通过应用这些变量来获得新的看不见的输入来进行系统预测。

表示循环神经网络的示意性方法如下所述 -

使用 TensorFlow 实现循环神经网络

在本节中，我们将学习如何使用 TensorFlow 实现循环神经网络。

步骤 1 - TensorFlow 包含用于循环神经网络模块具体实现的各种库。

#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

如上所述，这些库有助于定义输入数据，这构成了循环神经网络实现的主要部分。

步骤 2 - 我们的主要动机是使用循环神经网络对图像进行分类，其中我们将每个图像行视为像素序列。MNIST 图像形状具体定义为 28*28 px。现在我们将为提到的每个样本处理 28 个序列，每个序列有 28 个步骤。我们将定义输入参数来完成顺序模式。

n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}

步骤 3 - 使用 RNN 中定义的函数计算结果以获得最佳结果。在这里，每个数据形状与当前输入形状进行比较，并计算结果以保持准确率。

def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()

步骤 4 - 在此步骤中，我们将启动图表以获取计算结果。这也有助于计算测试结果的准确性。

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   
   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
      
      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
         
         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
         
         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
   
   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

下面的屏幕截图显示了生成的输出 -

TensorFlow - TensorBoard 可视化

TensorFlow 包含一个可视化工具，称为 TensorBoard。它用于分析数据流图，也用于理解机器学习模型。TensorBoard 的重要功能包括有关垂直对齐的任何图形的参数和详细信息的不同类型统计数据的视图。

深度神经网络包括多达 36,000 个节点。TensorBoard 有助于折叠高级块中的这些节点并突出显示相同的结构。这可以更好地分析图，重点关注计算图的主要部分。TensorBoard 可视化据说具有很强的交互性，用户可以平移、缩放和展开节点来显示详细信息。

以下示意图显示了 TensorBoard 可视化的完整工作原理 -

该算法将节点折叠为高级块，并突出显示具有相同结构的特定组，这些组将高级节点分开。由此创建的 TensorBoard 非常有用，并且对于调整机器学习模型同样重要。该可视化工具专为配置日志文件而设计，其中包含需要显示的摘要信息和详细信息。

让我们借助以下代码重点关注 TensorBoard 可视化的演示示例 -

import tensorflow as tf 

# Constants creation for TensorBoard visualization 
a = tf.constant(10,name = "a") 
b = tf.constant(90,name = "b") 
y = tf.Variable(a+b*2,name = 'y') 
model = tf.initialize_all_variables() #Creation of model 

with tf.Session() as session: 
   merged = tf.merge_all_summaries() 
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph) 
   session.run(model) 
   print(session.run(y))

下表显示了用于节点表示的 TensorBoard 可视化的各种符号 -

TensorFlow - 词嵌入

词嵌入是从离散对象（例如单词）映射到向量和实数的概念。这对于机器学习的输入很重要。该概念包括标准函数，可有效地将离散输入对象转换为有用的向量。

词嵌入输入的示例说明如下所示 -

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

Word2vec 是无监督词嵌入技术最常用的方法。它以这样的方式训练模型：给定的输入单词通过使用skip-gram来预测单词的上下文。

TensorFlow 支持多种方法来实现此类模型，其复杂性和优化水平不断提高，并使用多线程概念和更高级别的抽象。

import os 
import math 
import numpy as np 
import tensorflow as tf 

from tensorflow.contrib.tensorboard.plugins import projector 
batch_size = 64 
embedding_dimension = 5 
negative_samples = 8 
LOG_DIR = "logs/word2vec_intro" 

digit_to_word_map = {
   1: "One", 
   2: "Two", 
   3: "Three", 
   4: "Four", 
   5: "Five", 
   6: "Six", 
   7: "Seven", 
   8: "Eight", 
   9: "Nine"} 
sentences = [] 

# Create two kinds of sentences - sequences of odd and even digits. 
   for i in range(10000): 
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints])) 
   rand_even_ints = np.random.choice(range(2, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints])) 
   
# Map words to indices
word2index_map = {} 
index = 0 

for sent in sentences: 
   for word in sent.lower().split(): 
   
   if word not in word2index_map: 
      word2index_map[word] = index 
      index += 1 
index2word_map = {index: word for word, index in word2index_map.items()} 

vocabulary_size = len(index2word_map) 

# Generate skip-gram pairs 
skip_gram_pairs = [] 

for sent in sentences: 
   tokenized_sent = sent.lower().split() 
   
   for i in range(1, len(tokenized_sent)-1):        
      word_context_pair = [[word2index_map[tokenized_sent[i-1]], 
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]] 
      
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]]) 
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]]) 

def get_skipgram_batch(batch_size): 
   instance_indices = list(range(len(skip_gram_pairs))) 
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size] 
   x = [skip_gram_pairs[i][0] for i in batch] 
   y = [[skip_gram_pairs[i][1]] for i in batch] 
   return x, y 
   
# batch example 
x_batch, y_batch = get_skipgram_batch(8) 
x_batch 
y_batch 
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch] 

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size]) 
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1]) 

# Embedding lookup table currently only implemented in CPU with 
   tf.name_scope("embeddings"): 
   embeddings = tf.Variable(    
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0), 
         name = 'embedding') 
   # This is essentialy a lookup table 
   embed = tf.nn.embedding_lookup(embeddings, train_inputs) 
   
# Create variables for the NCE loss
nce_weights = tf.Variable(     
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0 / 
      math.sqrt(embedding_dimension))) 
   
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

loss = tf.reduce_mean(     
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed, 
   labels = train_labels,num_sampled = negative_samples, 
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss) 
   
# Learning rate decay 
global_step = tf.Variable(0, trainable = False) 
   learningRate = tf.train.exponential_decay(learning_rate = 0.1, 
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True) 

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss) 
   merged = tf.summary.merge_all() 
with tf.Session() as sess: 
   train_writer = tf.summary.FileWriter(LOG_DIR,    
      graph = tf.get_default_graph()) 
   saver = tf.train.Saver() 
   
   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata: 
      metadata.write('Name\tClass\n') for k, v in index2word_map.items(): 
      metadata.write('%s\t%d\n' % (v, k)) 
   
   config = projector.ProjectorConfig() 
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name 
   
   # Link this tensor to its metadata file (e.g. labels). 
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv') 
      projector.visualize_embeddings(train_writer, config) 
   
   tf.global_variables_initializer().run() 
   
   for step in range(1000): 
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)
      
      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings /
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)
   
ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

输出

上面的代码生成以下输出 -

TensorFlow - 单层感知器

为了理解单层感知器，理解人工神经网络（ANN）非常重要。人工神经网络是一种信息处理系统，其机制受到生物神经回路功能的启发。人工神经网络拥有许多相互连接的处理单元。以下是人工神经网络的示意图 -

该图显示隐藏单元与外层进行通信。而输入和输出单元仅通过网络的隐藏层进行通信。

节点的连接模式、输入和输出之间的总层数和节点级别以及每层神经元的数量定义了神经网络的架构。

有两种类型的架构。这些类型侧重于人工神经网络的功能，如下所示 -

单层感知器
多层感知器

单层感知器

单层感知器是第一个提出的神经模型。神经元本地存储器的内容由权重向量组成。单层感知器的计算是通过计算输入向量的总和（每个向量的值乘以权重向量的相应元素）来执行的。输出中显示的值将是激活函数的输入。

让我们重点关注使用 TensorFlow 实现图像分类问题的单层感知器。说明单层感知器的最好例子是通过“逻辑回归”的表示。

现在，让我们考虑训练逻辑回归的以下基本步骤 -

权重在训练开始时用随机值初始化。
对于训练集的每个元素，误差是根据期望输出与实际输出之间的差异来计算的。计算出的误差用于调整权重。
重复该过程，直到整个训练集上的误差不小于指定阈值，直至达到最大迭代次数。

下面提到了逻辑回归评估的完整代码 -

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

输出

上面的代码生成以下输出 -

逻辑回归被认为是一种预测分析。逻辑回归用于描述数据并解释一个因二元变量与一个或多个名义变量或自变量之间的关系。

TensorFlow - 线性回归

在本章中，我们将重点介绍使用 TensorFlow 实现线性回归的基本示例。逻辑回归或线性回归是一种用于分类离散类别的监督机器学习方法。本章的目标是建立一个模型，用户可以通过该模型预测预测变量与一个或多个自变量之间的关系。

这两个变量之间的关系被认为是线性的。如果 y 是因变量，x 被视为自变量，那么两个变量的线性回归关系将类似于以下等式 -

Y = Ax+b

我们将设计一个线性回归算法。这将使我们能够理解以下两个重要概念 -

成本函数
梯度下降算法

线性回归的示意图如下 -

线性回归方程的图形视图如下 -

设计线性回归算法的步骤

我们现在将了解有助于设计线性回归算法的步骤。

步骤1

导入绘制线性回归模块所需的模块非常重要。我们开始导入 Python 库 NumPy 和 Matplotlib。

import numpy as np 
import matplotlib.pyplot as plt

第2步

定义逻辑回归所需的系数数量。

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78

步骤3

迭代变量以围绕回归方程生成 300 个随机点 -

Y = 0.22x+0.78

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y])

步骤4

使用 Matplotlib 查看生成的点。

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

逻辑回归的完整代码如下 -

import numpy as np 
import matplotlib.pyplot as plt 

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78 

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y]) 
   
plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() 
plt.show()

作为输入的点数被视为输入数据。

TensorFlow - TFLearn 及其安装

TFLearn 可以定义为 TensorFlow 框架中使用的模块化且透明的深度学习方面。TFLearn 的主要动机是为 TensorFlow 提供更高级别的 API，以促进和展示新的实验。

考虑 TFLearn 的以下重要特征 -

TFLearn 易于使用和理解。
它包括构建高度模块化网络层、优化器和嵌入其中的各种指标的简单概念。
它包括 TensorFlow 工作系统的完全透明性。
它包括强大的辅助函数来训练接受多个输入、输出和优化器的内置张量。
它包括简单而美观的图形可视化。
图形可视化包括权重、梯度和激活的各种细节。

通过执行以下命令安装 TFLearn -

pip install tflearn

执行上述代码后，将生成以下输出 -

下图显示了 TFLearn 与随机森林分类器的实现 -

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

TensorFlow - CNN 和 RNN 区别

在本章中，我们将重点讨论 CNN 和 RNN 之间的区别 -

美国有线电视新闻网	循环神经网络
它适用于图像等空间数据。	RNN 适用于时态数据，也称为顺序数据。
CNN被认为比RNN更强大。	与 CNN 相比，RNN 的功能兼容性较少。
该网络采用固定大小的输入并生成固定大小的输出。	RNN 可以处理任意输入/输出长度。
CNN 是一种前馈人工神经网络，具有多层感知器的变体，旨在使用最少量的预处理。	RNN 与前馈神经网络不同 - 可以使用其内部存储器来处理任意输入序列。
CNN 使用神经元之间的连接模式。这是受到动物视觉皮层组织的启发，动物视觉皮层的各个神经元的排列方式使得它们能够对覆盖视野的重叠区域做出反应。	循环神经网络使用时间序列信息 - 用户最后所说的内容将影响他/她接下来所说的内容。
CNN 非常适合图像和视频处理。	RNN 非常适合文本和语音分析。

下图显示了 CNN 和 RNN 的示意图 -

TensorFlow - Keras

Keras 是一个紧凑、易于学习的高级 Python 库，运行在 TensorFlow 框架之上。它的重点是理解深度学习技术，例如为维护形状和数学细节概念的神经网络创建层。自由作品的创建可以有以下两种类型 -

顺序API
功能性API

考虑以下八个步骤在 Keras 中创建深度学习模型 -

加载数据
预处理加载的数据
型号定义
编译模型
适合指定型号
评价一下
做出所需的预测
保存模型

我们将使用 Jupyter Notebook 来执行和显示输出，如下所示 -

步骤 1 - 首先加载数据并对加载的数据进行预处理以执行深度学习模型。

import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

此步骤可以定义为“导入库和模块”，这意味着所有库和模块都作为初始步骤导入。

步骤 2 - 在这一步中，我们将定义模型架构 -

model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

步骤 3 - 现在让我们编译指定的模型 -

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

步骤 4 - 我们现在将使用训练数据拟合模型 -

model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

创建的迭代的输出如下 -

Epoch 1/10 60000/60000 [==============================] - 65s - 
loss: 0.2124 - 
acc: 0.9345 
Epoch 2/10 60000/60000 [==============================] - 62s - 
loss: 0.0893 - 
acc: 0.9740 
Epoch 3/10 60000/60000 [==============================] - 58s - 
loss: 0.0665 - 
acc: 0.9802 
Epoch 4/10 60000/60000 [==============================] - 62s - 
loss: 0.0571 - 
acc: 0.9830 
Epoch 5/10 60000/60000 [==============================] - 62s - 
loss: 0.0474 - 
acc: 0.9855 
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 - 
acc: 0.9871 
Epoch 7/10 60000/60000 [==============================] - 61s - 
loss: 0.0380 - 
acc: 0.9877 
Epoch 8/10 60000/60000 [==============================] - 63s - 
loss: 0.0333 - 
acc: 0.9895 
Epoch 9/10 60000/60000 [==============================] - 64s - 
loss: 0.0325 - 
acc: 0.9898 
Epoch 10/10 60000/60000 [==============================] - 60s - 
loss: 0.0284 - 
acc: 0.9910

TensorFlow - 分布式计算

本章将重点介绍如何开始使用分布式 TensorFlow。目的是帮助开发人员理解重复出现的基本分布式 TF 概念，例如 TF 服务器。我们将使用 Jupyter Notebook 来评估分布式 TensorFlow。下面提到使用 TensorFlow 进行分布式计算 -

步骤 1 - 导入分布式计算必需的必要模块 -

import tensorflow as tf

第 2 步- 创建一个具有一个节点的 TensorFlow 集群。让该节点负责一项名为“worker”的作业，该作业将在 localhost:2222 上运行一个镜头。

cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

上述脚本生成以下输出 -

'grpc://localhost:2222'
The server is currently running.

步骤 3 - 可以通过执行以下命令来计算具有相应会话的服务器配置 -

server.server_def

上述命令生成以下输出 -

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

步骤 4 - 启动 TensorFlow 会话，执行引擎为服务器。使用 TensorFlow 创建本地服务器并使用lsof找出服务器的位置。

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()

步骤 5 - 查看此会话中可用的设备并关闭相应的会话。

devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

上述命令生成以下输出 -

/job:worker