python机器学习-Python TensorFlow

作者 : 慕源网 本文共13063个字,预计阅读时间需要33分钟 发布时间: 2021-10-19 共332人阅读

python机器学习-Python TensorFlow

本文是Python 机器学习系列的一部分。您可以在此处找到本系列之前所有帖子的链接

介绍

在上一章中,我们研究了 Python Seaborn、它的函数和它的 Python 实现。

在本章中,我们将从下一个非常有用且重要的 Python 机器学习库“Python Tensorflow”开始。

什么是 Python TensorFlow? 

TensorFlow 是一个免费的开源软件库,用于跨一系列任务的数据流和可微编程。它是一个符号数学库,也用于机器学习应用程序,如神经网络。它用于谷歌的研究和生产。

其灵活的架构允许跨各种平台(CPU、GPU、TPU)轻松部署计算,从台式机到服务器集群再到移动和边缘设备。

TensorFlow 计算表示为有状态数据流图。TensorFlow 的名称源自此类神经网络对多维数据数组执行的操作,称为tensors。在 2016 年 6 月的 Google I/O 大会上,Jeff Dean 表示 GitHub 上有 1500 个存储库提到了 TensorFlow,其中只有 5 个来自 Google。

2018 年 1 月,谷歌发布了 TensorFlow 2.0。2018 年 3 月,谷歌发布了用于 JavaScript 机器学习的 TensorFlow.js 1.0 版和用于计算机图形学深度学习的 TensorFlow Graphics。

TensorFlow 由 Google Brain 团队开发,供 Google 内部使用。它于 2015 年 11 月 9 日在 Apache License 2.0 下发布。官方网站是www.tensorflow.org

关键术语 

Tensor

Tensorflow 的名字直接来源于它的核心框架:Tensor。在 Tensorflow 中,所有计算都涉及tensors。tensor 是表示所有类型数据的 n 维向量矩阵。张量中的所有值都具有相同的数据类型,并且具有已知(或部分已知)的形状。数据的形状是矩阵或数组的维数。

tensor 可以源自输入数据或计算结果。在 TensorFlow 中,所有操作都在一个中进行。图是一组连续发生的计算。每个操作称为一个操作节点,并相互连接。

该图概述了节点之间的操作和连接。但是,它不显示值。tensor 中节点的边缘,即一种用数据填充操作的方法。

Graphs

TensorFlow 使用图框架。graph 收集并描述了训练期间完成的所有系列计算。graph 有很多优点:

  • 它是为了在多个 CPU 或 GPU 甚至移动操作系统上运行而完成的
  • graph 的可移植性允许保留计算以供立即或以后使用。可以保存图形以供将来执行。
  • graph 中的所有计算都是通过将tensor 连接在一起来完成的。
  • tensor 有一个节点和一条边。节点承载数学运算并产生端点输出。边解释了节点之间的输入/输出关系。

尝试阅读graph ,以便更好地理解TensorFlow并对概念有深刻的理解

DistBelief

从 2011 年开始,Google Brain 将 DistBelief 构建为基于深度学习神经网络的专有机器学习系统。在研究和商业应用中,它在不同的 Alphabet 公司中的使用迅速增长。Google 指派了包括 Jeff Dean 在内的多位计算机科学家来简化和重构 DistBelief 的代码库,使其成为一个更快、更强大的应用级库,即 TensorFlow。2009 年,由 Geoffrey Hinton 领导的团队实施了广义反向传播和其他改进,使生成的神经网络具有更高的准确度,例如,语音识别错误减少了 25%。

CPU

中央处理单元简称CPU,是电子电路,作为计算机的大脑,执行计算机程序指令指定的基本算术、逻辑、控制和输入/输出操作。

GPU

GPU图形处理单元是一种专门的电子电路,旨在与 CPU 一起渲染 2D 和 3D 图形。GPU 在游戏玩家文化中也被称为显卡。现在,GPU 正被更广泛地用于加速金融建模、前沿科学研究、深度学习、分析以及石油和天然气勘探等领域的计算工作负载。

TPU

2016 年 5 月,谷歌发布了其张量处理单元 (TPU),这是一种专用集成电路(一种硬件芯片),专为机器学习构建并为 TensorFlow 量身定制。TPU 是一种可编程 AI 加速器,旨在提供低精度算术(例如 8 位)的高吞吐量,并且面向使用或运行模型而不是训练模型。谷歌宣布他们已经在数据中心内运行 TPU 一年多,并发现它们为机器学习提供了一个数量级的每瓦特优化性能。

2017 年 5 月,谷歌宣布了第二代,以及谷歌计算引擎上 TPU 的可用性。第二代 TPU 可提供高达 180 teraflops 的性能,当组织成 64 个 TPU 的集群时,可提供高达 11.5 petaflops。

2018 年 5 月,谷歌宣布推出第三代 TPU,可提供高达 420 teraflops 的性能和 128 GB HBM。Cloud TPU v3 Pod 提供 100+ petaflops 的性能和 32 TB HBM。

Edge TPU

2018 年 7 月,Edge TPU 发布。Edge TPU 是 Google 的专用 ASIC 芯片,旨在在称为边缘计算的智能手机等小型客户端计算设备上运行 TensorFlow Lite 机器学习 (ML) 模型。

TensorFlow Lite

2017 年 5 月,谷歌发布了专门用于移动开发的软件堆栈 TensorFlow Lite。2019 年 1 月,TensorFlow 团队发布了移动 GPU 推理引擎的开发者预览版,Android 设备上有 OpenGL ES 3.1 Compute Shaders,iOS 设备上有 Metal Compute Shaders。2019 年 5 月,谷歌宣布其 TensorFlow Lite Micro(也称为 TensorFlow Lite for Microcontrollers)和 ARM 的 uTensor 将合并。

Pixel Visual Core (PVC)

2017 年 10 月,谷歌发布了谷歌 Pixel 2,它采用了他们的 Pixel Visual Core (PVC),一种用于移动设备的完全可编程的图像、视觉和 AI 处理器。PVC 支持用于机器学习的 TensorFlow(以及用于图像处理的 Halide)。

TensorFlow Session

session将从graph中执行操作。要使用tensor的值提供图表,您需要打开一个session。在session中,您必须运行操作符来创建输出。

Tensorflow 架构组件

1. TensorFlow Servables

这些是 TensorFlow Serving 的核心基本单元。TensorFlow Servables 是客户端用来执行计算的对象。

servable 的大小是灵活的。单个 servable 可能包括从查找表到单个模型再到推理模型元组的任何内容。Servables 可以是任何类型和接口,从而实现灵活性和未来的改进,例如:

  • Streaming results
  • Experimental APIs
  • Asynchronous modes of operation

2. TensorFlow 可服务版本

TensorFlow Serving 可以在单个服务器实例的生命周期内处理一个或多个版本的 servable。这为随着时间的推移加载新的算法配置、权重和其他数据打开了大门。它们还支持同时加载多个版本的 servable,支持逐步推出和试验。在服务时,客户端可以请求特定模型的最新版本或特定版本 ID。

3. TensorFlow 可服务流

按版本号递增的可服务版本的一系列版本。

4. TensorFlow 模型

Serving 将模型表示为一个或多个 servable。机器学习模型可能包括一种或多种算法(包括学习权重)以及查找或嵌入表。servable 也可以作为模型的一部分,例如,一个大的查找表可以作为许多实例。

5. TensorFlow 加载器

加载器管理 servable 的生命周期。Loader API 支持独立于特定学习算法、数据或产品用例的通用基础设施。具体来说,Loaders 标准化了用于加载和卸载 servable 的 API。

6. Tensorflow 架构中的来源

简单来说,源是查找和提供可服务的模块。每个源提供零个或多个可服务的流。对于每个可服务流,Source 为每个可供加载的版本提供一个 Loader 实例。

7. TensorFlow 管理器

Tensorflow 管理器处理 Servables 的整个生命周期,包括:

  • 加载 Servables
  • 服务 Servables
  • 卸载 Servables

管理人员听取来源并跟踪所有版本。管理器尝试满足来源的请求,但可能会拒绝加载想要的版本。管理人员也可以推迟“卸载”。例如,基于确保始终加载至少一个版本的策略,管理器可能会等待卸载,直到较新的版本完成加载。例如,GetServableHandle(),用于客户端访问加载的可服务实例。

8. TensorFlow 核心

使用标准的 TensorFlow Serving API,TensorFlow Serving Core 管理可服务 的以下方面:

  • 生命周期
  • 指标

TensorFlow Serving Core 将 servables 和 loader 视为不透明对象。

9. TensorFlow 批处理器

将多个请求批处理为单个请求可以显着降低执行推理的成本,尤其是在 GPU 等硬件加速器存在的情况下。TensorFlow Serving 包含一个请求批处理小部件,可让客户端轻松地将跨请求的特定于类型的推理批处理为算法系统可以更有效地处理的批处理请求。

TensorFlow Servable 的生命周期

1. 源为可服务版本创建加载器,然后加载器作为 Aspired 版本发送到管理器,管理器加载它们并为客户端请求提供服务。
2. 加载器包含加载 Servable 所需的任何元数据。
3. Source 使用回调来通知 Aspired 版本的管理器。
4. 经理应用配置的版本策略来确定下一步要采取的行动。
5. 如果管理器确定它是安全的,它会给Loader 所需的资源并告诉Loader 加载新版本。
6. 客户端向管理器询问 Servable,或者明确指定一个版本,或者只是请求最新版本。管理器返回 Servable 的句柄。动态管理器应用版本策略并决定加载新版本。
7. 动态管理器告诉加载器有足够的内存。Loader 使用新的权重实例化 TensorFlow 图。
8. 客户端请求模型最新版本的句柄,动态管理器返回新版本 Servable 的句柄。

安装 Python Tensorflow

1. Ubuntu/Linux

sudo apt update -y                        
sudo apt upgrade -y                        
sudo apt install python3-tk python3-pip -y                        
      
pip install tensorflow      # Python 2.7; CPU support (no GPU support)      
pip3 install tensorflow     # Python 3.n; CPU support (no GPU support)      
pip install tensorflow-gpu  # Python 2.7;  GPU support      
pip3 install tensorflow-gpu # Python 3.n; GPU support  

如果上述命令失败,则可能您使用的是旧二进制文件来运行以下命令

sudo pip  install --upgrade tfBinaryURL   # Python 2.7      
sudo pip3 install --upgrade tfBinaryURL   # Python 3.n

2. 使用 Docker

1. 如果尚未安装,请使用链接在您的系统上安装 Docker
2. 要在 Linux 上支持 GPU,请安装 nvidia-docker。最新版本的 Docker包括对 GPU 的本机支持nvidia-docker不是必需的。
3. TensorFlow Docker 官方镜像位于tensorflow/tensorflow Docker Hub 仓库
4.以下将TensorFlow发布镜像下载到您的机器上:
docker pull tensorflow/tensorflow                     # latest stable release  
docker pull tensorflow/tensorflow:devel-gpu           # nightly dev release w/ GPU support  
docker pull tensorflow/tensorflow:latest-gpu-jupyter  # latest release w/ GPU support and Jupyter 

要运行 TensorFlow Docker 映像,请执行以下命令

docker run [-it] [--rm] [-p hostPort:containerPort] tensorflow/tensorflow[:tag] [command]  

3. Anaconda Prompt

conda create -n tensorflow_env tensorflow  
conda activate tensorflow_env #for CPU  

在 CPU 上安装时使用上述命令

conda create -n tensorflow_gpuenv tensorflow-gpu  
conda activate tensorflow_gpuenv  

在 GPU 上安装时使用上述命令

TensorFlow 中常用的算法

以下是算法列表及其对应的 TensorFlow 函数

  • 线性回归: tf.estimator.LinearRegressor
  • 分类: tf.estimator.LinearClassifier
  • 深度学习分类: tf.estimator.DNNClassifier
  • 深度学习擦除和深度: tf.estimator.DNNLinearCombinedClassifier
  • Booster 树回归: tf.estimator.BoostedTreesRegressor
  • 提升树分类: tf.estimator.BoostedTreesClassifier

创建Tensor

以下是创建Tensor 的过程

句法

tf.constant(value, dtype, name = “”)

争论

      -`value`:定义tensor的 n 维值。
可选 – `
   dtype`:定义数据类型:
      – `tf.string`:字符串变量
      – `tf.float32`:浮动变量
      – `tf.int16`:整数变量
      – “name”:tensor的名称。

可选的。

默认情况下,`Const_1:0`

1.创建一个维度为0的tensor

## rank 0  
# Default name  
import tensorflow as tf  
r1 = tf.constant(1, tf.int16)   
print(r1)  
r2 = tf.constant(1, tf.int16, name = "my_scalar")   
print(r2)  

上面代码的输出将是 Tensor(“Const_1:0”, shape=(), dtype=int16) Tensor(“my_scalar:0”, shape=(), dtype=int16)

2. 用十进制或字符串值创建tensor

import tensorflow as tf  
# Decimal  
r1_decimal = tf.constant(1.12345, tf.float32)  
print(r1_decimal)  
# String  
r1_string = tf.constant("Guru99", tf.string)  
print(r1_string)  

上述代码的输出将是 Tensor(“Const_2:0”, shape=(), dtype=float32) Tensor(“Const_3:0”, shape=(), dtype=string)

3. 创建一个维度为 1 的tensor

import tensorflow as tf  
  
r2_boolean = tf.constant([True, True, False], tf.bool)  
print(r2_boolean)  
## Rank 2  
r2_matrix = tf.constant([ [1, 2],  
                          [3, 4] ],tf.int16)  
print(r2_matrix)  

上述代码的输出将是 Tensor(“Const_4:0”, shape=(3,), dtype=bool) Tensor(“Const_5:0”, shape=(2, 2), dtype=int16)

Tensor 属性

下面给出了一个常用属性列表

1. tensorflow.shape

它用于返回tensor 的形状

import tensorflow as tf  
  
# Shape of tensor  
m_shape = tf.constant([ [10, 11],  
                        [12, 13],  
                        [14, 15] ]                        
                     )   
m_shape.shape  

上述代码的输出将是 TensorShape([Dimension(3), Dimension(2)])

2. tensorflow.zeros

它用于创建所有元素为零的给定维度的tensor

import tensorflow as tf  
# Create a vector of 0  
print(tf.zeros(10))  

上面代码的输出将是 Tensor(“zeros:0”, shape=(10,), dtype=float32)

3.tensorflow.ones

它用于创建给定维度的tensor,其中所有元素都是一个

import tensorflow as tf  
# Create a vector of 1  
print(tf.ones([10, 10]))              
# Create a vector of ones with the same number of rows as m_shape  
print(tf.ones(m_shape.shape[0]))  
# Create a vector of ones with the same number of column as m_shape  
print(tf.ones(m_shape.shape[1]))  
  
print(tf.ones(m_shape.shape))    

上述代码的输出将是 TTensor(“ones_1:0”, shape=(10, 10), dtype=float32) Tensor(“ones_2:0”, shape=(3,), dtype=float32) Tensor(“ones_3:0”, shape=(2,), dtype=float32) Tensor(“ones_4:0”, shape=(3, 2), dtype=float32)

4. tensorflow.dtype

用于查找tensor元素的数据类型

import tensorflow as tf  
m_shape = tf.constant([ [10, 11],  
                        [12, 13],  
                        [14, 15] ]                        
                     )   
print(m_shape.dtype) 

上面代码的输出将是 <dtype: ‘int32’>

import tensorflow as tf  
  
# Change type of data  
type_float = tf.constant(3.123456789, tf.float32)  
type_int = tf.cast(type_float, dtype=tf.int32)  
print(type_float.dtype)  
print(type_int.dtype)   

上面代码的输出将是 <dtype: ‘float32’> <dtype: ‘int32’>

TensorFlow 有用的函数

以下是一些可用于处理tensor 的数学函数

  • tensorflow.add(a, b)
  • tensorflow.substract(a, b)
  • tensorflow.multiply(a, b)
  • tensorflow.div(a, b)
  • tensorflow.pow(a, b)
  • tensorflow.exp(a)
  • tensorflow.sqrt(a)
import tensorflow as tf  
  
x = tf.constant([2.0], dtype = tf.float32)  
tensor_a = tf.constant([[1,2]], dtype = tf.int32)  
tensor_b = tf.constant([[3, 4]], dtype = tf.int32)  
  
#Sqaure Root  
print(tf.sqrt(x))  
#Exponential  
print(tf.exp(x))  
#Power  
print(tf.pow(x,x))  
#Add  
tensor_add = tf.add(tensor_a, tensor_b)  
print(tensor_add)  
#Substarct  
tensor_sub = tf.subtract(tensor_a, tensor_b)  
print(tensor_sub)  
#Multiply  
tensor_mul = tf.multiply(tensor_a, tensor_b)  
print(tensor_mul)  
#Divide  
tensor_div = tf.div(tensor_a, tensor_b)  
print(tensor_div)  

上面的代码,演示了上面提到的所有TensorFlow函数的使用0

TensorFlow 变量

要在 TensorFlow 中创建变量,我们使用 tensorflow.get_variable()

句法

tf.get_variable(name = “”, values, dtype, initializer)

争论

      – `name = “”`: 变量名
      – `values`:tensor的维度
      – `dtype`:数据类型。可选的
      – `initializer`:如何初始化tensor。可选的

如果指定了初始化器,则不需要包含“值”,因为使用了“初始化器”的形状。

import tensorflow as tf  
  
# Create a Variable  
var = tf.get_variable("var", [1, 2])  
print(var)  
  
#following initializes the variable with a initial/default value  
var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)  
print(var_init_1)         
  
#Initializes the first value of the tensor equals to tensor_const  
tensor_const = tf.constant([[10, 20],[30, 40]])  
var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32,  initializer=tensor_const)  
print(var_init_2)     

上面代码的输出将是 <tf.Variable ‘var:0’ shape=(1, 2) dtype=float32_ref> <tf.Variable ‘var_init_1:0’ shape=(1, 2) dtype=int32_ref> <tf .Variable ‘var_init_2:0’ shape=(2, 2) dtype=int32_ref>

TensorFlow 占位符

占位符的目的是提供tensor。占位符用于初始化数据以在tensor内流动。要提供占位符,您需要使用方法 feed_dict。占位符将仅在会话中提供。

句法

tf.placeholder(dtype,shape=None,name=None)

论据:

      – `dtype`:数据类型
      – `shape`:占位符的尺寸。可选的。默认情况下,数据的形状
      – `name`:占位符的名称。可选的
import tensorflow as tf  
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")  
print(data_placeholder_a)  

上面代码的输出将是 Tensor(“data_placeholder_a:0”, dtype=float32)

TensorFlowSession

下面我们将演示使用 TensorFlow Session

import tensorflow as tf  
  
## Create, run  and evaluate a session  
x = tf.constant([2])  
y = tf.constant([4])              
  
## Create operator  
multiply = tf.multiply(x, y)  
  
## Create a session to run the code  
sess = tf.Session()  
result_1 = sess.run(multiply)  
print(result_1)  
sess.close()  

上述代码的输出将是 [8]

简单的 Python Tensorflow 程序

import numpy as np  
import tensorflow as tf 

在上面的代码中,我们导入了 numpy 和 TensorFlow,并将它们分别重命名为 np 和 tf。

X_1 = tf.placeholder(tf.float32, name = "X_1")  
X_2 = tf.placeholder(tf.float32, name = "X_2")  

在上面的代码中,我们定义了两个变量 X_1 和 X_2。当我们创建一个占位符节点时,我们必须传入数据类型将在这里添加数字以便我们可以使用浮点数据类型,让我们使用 tf.float32。我们还需要为这个节点命名。当我们查看模型的图形可视化时,会显示此名称。

multiply = tf.multiply(X_1, X_2, name = "multiply")  

在上面的代码中,我们定义了进行乘法运算的节点。在 Tensorflow 中,我们可以通过创建一个 tf.multiply 节点来做到这一点。此节点将导致 X_1 和 X_2 的乘积

with tf.Session() as session:    
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})    
    print(result)   

要在图中执行操作,我们必须创建一个session 。在 Tensorflow 中,它是由 tf.Session() 完成的。现在我们有了一个session,我们可以通过调用 session 来要求session 在我们的计算graph 上运行操作。要运行计算,我们需要使用 run。

当加法运算运行时,会看到需要抓取X_1和X_2节点的值,所以我们还需要输入X_1和X_2的值。我们可以通过提供一个名为 feed_dict 的参数来做到这一点。我们为 X_1 传递值 1,2,3,为 X_2 传递值 4,5,6。

Simple_TensorFlow.py

import numpy as np  
import tensorflow as tf  
  
X_1 = tf.placeholder(tf.float32, name = "X_1")  
X_2 = tf.placeholder(tf.float32, name = "X_2")  
  
multiply = tf.multiply(X_1, X_2, name = "multiply")  
  
with tf.Session() as session:  
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})  
    print(result)  
上述综合程序将给出以下结果:[ 4. 10. 18.]

使用 Python TensorFlow 加载数据的方法

加载数据有两种方式,分别如下:

1. 使用 NumPy Array 加载数据

我们可以将数据硬编码到 NumPy 数组中,也可以将数据从 xls 或 xlsx 或 CSV 加载到 Pandas DataFrame 中,然后可以将其转换为 NumPy 数组。如果您的数据集不是太大,即小于 10 GB,则可以使用此方法。数据可以装入内存。

## Numpy to pandas    
import numpy as np    
import pandas as pd  
  
h = [[1,2],[3,4]]     
df_h = pd.DataFrame(h)    
print('Data Frame:', df_h)    
    
## Pandas to numpy    
df_h_n = np.array(df_h)    
print('Numpy array:', df_h_n)    
上面代码的输出将是 Data Frame: 0 1 0 1 2 1 3 4 Numpy array: [[1 2] [3 4]]

2. 使用 TensorFlow Data Pipeline 加载数据

Tensorflow 具有内置 API,可帮助您轻松加载数据、执行操作并提供机器学习算法。这种方法非常有效,尤其是当您拥有大型数据集时。例如,众所周知,图像记录非常庞大,无法放入内存中。数据管道自己管理内存。如果您有一个大型数据集,此方法最有效。例如,如果您有一个 50 GB 的数据集,而您的计算机只有 16 GB 的内存,那么机器就会崩溃。在这种情况下,您需要构建一个 Tensorflow 管道。管道将批量或小块加载数据。每个批次都将被推送到管道并准备好进行训练。构建管道是一个很好的解决方案,因为它允许您使用并行计算。这意味着 Tensorflow 将在多个 CPU 上训练模型。它促进了计算并允许训练强大的神经网络。

创建 TensorFlow 数据管道的方法

1. 创建数据

import numpy as np  
import tensorflow as tf  
x_input = np.random.sample((1,2))  
print(x_input) 

在上面的代码中,我们使用 NumPy 的随机数生成器生成两个随机数2. 创建占位符

x = tf.placeholder(tf.float32, shape=[ 1 , 2 ], name =  'X' )  

我们正在使用 tf.placeholder() 创建一个占位符3. 定义数据集方法

dataset = tf.data.Dataset.from_tensor_slices(x)  

我们将数据集方法定义为 tf.data.Dataset.from_tensor_slices()4. 创建管道

iterator = dataset.make_initializable_iterator()   
get_next = iterator.get_next()  

在上面的代码中,我们需要初始化数据将流动的管道。我们需要使用 make_initializable_iterator 创建一个iterator 。我们将其命名为iterator 。然后我们需要调用这个iterator 来馈送下一批数据,get_next。我们将此步骤命名为 get_next。请注意,在我们的示例中,只有一批数据只有两个值。 5. 执行操作

with tf.Session() as sess:  
    # feed the placeholder with data  
    sess.run(iterator.initializer, feed_dict={ x: x_input })   
    print(sess.run(get_next)) # output [ 0.52374458  0.71968478] 

在上面的代码中,我们发起了一个会话,并运行了操作iterator 。我们将 numpy 生成的值提供给 feed_dict。这两个值将填充占位符 x。然后我们运行 get_next 来打印结果。TensorFlow_Pipeline.py

import numpy as np  
import tensorflow as tf  
x_input = np.random.sample((1,2))  
print(x_input)  
# using a placeholder  
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')  
dataset = tf.data.Dataset.from_tensor_slices(x)  
iterator = dataset.make_initializable_iterator()   
get_next = iterator.get_next()  
with tf.Session() as sess:  
    # feed the placeholder with data  
    sess.run(iterator.initializer, feed_dict={ x: x_input })   
    print(sess.run(get_next))   

上述代码的输出将是 [[0.87908525 0.80727791]] [0.87908524 0.8072779]

结论

在本章中,我们学习了 Python Seaborn。在下一章中,我们将开始讨论统计。


慕源网 » python机器学习-Python TensorFlow

常见问题FAQ

程序仅供学习研究,请勿用于非法用途,不得违反国家法律,否则后果自负,一切法律责任与本站无关。
请仔细阅读以上条款再购买,拍下即代表同意条款并遵守约定,谢谢大家支持理解!

发表评论

开通VIP 享更多特权,建议使用QQ登录