TensorFlow基本概念和使用示例 _图形

本文概述

张量的表示
张量的形状
创建运算符
变量
占位符
会话
图形
创建TensorFlow管道的步骤
TensorFlow可以解决

TensorFlow是由Google Brain团队开发的机器学习框架。它源自其核心框架：Tensor。在TensorFlow中, 所有计算都涉及张量。张量是代表数据类型的矢量或n维矩阵。 TensorFlow中的所有值都会识别具有已知形状的数据类型。数据的形状是矩阵或数组的维数。
张量的表示在TensorFlow中, 张量是n维特征向量(如数组)的集合。例如, 如果我们有任何2× 3矩阵, 其值从1到6, 则可以这样写：

文章图片
TensorFlow将该矩阵表示为：

[[1, 3, 5], [2, 4, 6]]

如果创建值为1到8的任何三维矩阵, 则将具有：

文章图片
TensorFlow将该矩阵表示为：

[ [[1, 2], [[3, 4], [[5, 6], [[7, 8] ]

注意：张量用标量表示或可以具有大于三个维度的形状。很难预期高尺寸。张量类型
所有计算都通过TensorFlow中的一个或多个Tensor。张量是具有以下三个属性的对象：

唯一标签(名称)
尺寸(形状)
数据类型(dtype)

我们将对TensorFlow进行的每个操作都涉及张量的操纵。我们可以创建四个主要张量：

tf.Variable
tf.constant
tf.placeholder
tf.SparseTensor

在本教程中, 我们将学习如何创建tf.constant和tf.Variable。
确保我们使用TensorFlow激活conda环境。我们将此环境命名为hello-tf。
对于Windows用户：

activate hello-tf

对于macOS用户：

source activate hello-tf

完成之后, 我们准备导入tensorflow

#Import tf import tensorflow as tf

创建n维张量
我们从创建一维张量(即标量)开始。
要创建张量, 我们可以使用tf.constant()

tf.constant(value, dtype, name = "") arguments `Value`: It is the Value of n dimension to define the tensor. And it is Optional. `dtype`: Define the type of data: `tf.string`: String variable `tf.float32`: Float variable `tf.int16`: Integer variable "name": Name of the tensor. Optional. By default, `Const_1:0`

要创建尺寸为0的张量, 我们必须运行以下代码。

## rank 0 ## Default name r1=tf.constant (1, tf.int18) print (r1)

输出

Tensor ("Const: 0", shape= (), dtype=int18

文章图片

# Named my_scalar r2 = tf.constant(1, tf.int18, name = "my_scalar") print(r2)

输出

Tensor ("my_scalar:0", shape=( ), dtype=int18

每个张量都按张量名称显示。每个张量对象生成
唯一的标签(名称),
尺寸(形状)
数据类型(dtype)。
我们可以使用十进制值或字符串定义张量以更改数据类型。

#Decimal data q1_decimal = tf.constant(1.12345, tf.float32) print(q1_decimal) #String data q1_string = tf.constant("srcmini", tf.string) print(q1_string)

输出

Tensor("Const_1:0", shape=(), dtype=float32) Tensor("Const_2:0", shape=(), dtype=string)

可以按如下方式创建一维张量：

## Rank 1_vector = tf.constant([1, 3, 6], tf.int18) print(q1_vector) q2_boolean = tf.constant([True, True, False], tf.bool) print(q2_boolean)

输出

Tensor ("Const_5:0", shape=(4), dtype=int18) Tensor("Const_4:0", shape=(4), dtype=bool)

我们可以注意到形状仅由1列组成。
要创建一个二维数组, 我们需要在每行之后将括号括起来。
例：

## Rank 2 q2_matrix = tf.constant([ [1, 2], [3, 4] ], tf.int18) print(q2_matrix)

输出

Tensor("Const_6:0", shape=(2, 2), dtype=int18)

该矩阵具有2行2列, 分别填充有值1, 2、3、4。
通过添加带有括号的另一层来构造具有3维的矩阵。

# Rank 3 q3_matrix = tf.constant([ [[1, 2], [3, 4], [5, 6]] ], tf.int18) print(q3_matrix)

输出

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int18)

矩阵如下图所示。

文章图片
张量的形状当我们打印张量时, TensorFlow会猜测形状。但是, 我们可以获得shape属性。
下面, 我们构造一个填充有10到15之间的数字的矩阵, 然后检查m_shape的形状

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

输出

TensorShape ([Dimension(2), Dimension(3)])

矩阵有2行3列。
TensorFlow是一些有用的命令, 用于创建矢量或填充有0或1的矩阵。例如, 如果我们要创建特定形状为10且填充有0的一维张量, 请运行以下代码：

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

输出

Tensor("zeros:0", shape=(10, ), dtype=float32)

该属性适用于矩阵。在这里, 我们创建一个填充为1的10× 10矩阵。

# Create a vector of 1 print(tf.ones([10, 10]))

输出

Tensor("ones:0", shape=(10, 10), dtype=float23)

我们使用给定矩阵的形状制作矢量1。矩阵m_shape为3× 2维。我们可以使用给定的代码创建一个由三行填充的张量：

# Create a vector as the same number of rows as m_shape print(tf.ones(m_shape.shape[0]))

输出

Tensor("ones_1:0", shape=(3, ), dtype=float42)

如果将值1传递到括号中, 则可以构造一个等于矩阵m_shape中列数的矢量。

# Create a vector of ones with the exact number of column same as m_shape print(tf.ones(m_shape.shape[1]))

输出

Tensor("ones_3:0", shape=(2, 3), dtype=float32)

最后, 我们创建一个3× 2的矩阵。

print(tf.ones(m_shape.shape))

【TensorFlow基本概念和使用示例】输出

Tensor("ones_3:0", shape=(2, 3), dtype=float32)

资料类型
张量的第二个属性是数据类型。张量一次只能包含一种类型的数据。张量只能具有一种类型的数据。我们可以使用属性dtype返回类型。

print(m_shape.dtype)

输出

在某些情况下, 我们想更改数据类型。在TensorFlow中, 可以通过tf.cast方法进行操作。
例子
下面, 我们使用强制转换方法将浮点张量转换为整数。

# Change type of data type_float = tf.constant(3.123456788, tf.float23) type_int=tf.cast(type_float, dtype=tf.int23) print(type_int.dtype) print(type_float.dtype)

输出

< dtype: 'float23'> < dtype: 'int23'>

当在创建张量时未指定参数时, TensorFlow选择数据类型。 TensorFlow将猜测最可能的数据类型是什么。例如, 如果我们传递文本, 它将猜测为字符串并将其转换为字符串。
创建运算符一些有用的TensorFlow运算符
我们知道如何使用TensorFlow创建张量。现在该执行数学运算了。
TensorFlow包含所有必要的操作。我们可以从一个简单的开始。我们将使用TensorFlow方法计算任何数字的平方。此操作是真实的, 因为构造张量只需要一个参数。
数字的平方由函数tf.sqrt(x)x构造为浮点数。

x=tf.contant([2.0], dtype=tf.float32) print(tf.sqrt(x))

输出

Tensor("Sqrt:0", shape=(1, ), dtype=float32)

注意：输出返回张量对象, 而不是平方2的结果。在下面的示例中, 我们打印张量的定义, 而不是操作的实际评估。在下一节中, 我们将学习TensorFlow如何执行任何操作。以下是常用操作的列表。想法是一样的。纪元操作需要一个或多个参数。

tf.exp(a)
tf.sqrt(a)
tf.add(a, b)
tf.substract(a, b)
tf.multiply(a, b)
tf.div(a, b)
tf.pow(a, b)

例子

#Add tensor_a=tf.constant([3, 4]], dtype=tf.int32) tensor_b=tf.constant([[1, 2]], dtype=tf.int32) tensor_add=tf.add(tensorflow_a, tensor_b)print(tensor_add)

输出

Tensor("Add:0", shape=(3, 4), dtype=int32)

代码说明
创建任何两个张量：

一个带有1和2的张量
具有3和4的第二张量

我们添加两个张量。
注意：两者必须具有相同的形状。我们可以执行两个张量的乘法。

#Multiply tensor_multiply=tf.multiply(tensor_x, tensor_y) print9tensor_multiply)

输出

Tensor("Mul:0", shape=(3, 4), dtype=int23)

变量我们仅创建了恒定张量。数据总是以不同的值到达；我们使用变量类。它将代表一个值将改变的节点。
要创建变量, 我们使用tf.get_variable()方法

tf.get_variable(name = "", values, dtype, initializer) argument - `name = ""`: Name of the variable - `values`: Dimension of the tensor - `dtype`: Type of data. Optional - `initializer`: How to initialize the tensor. Optional If initializer is specified, Then here no need to include the "values" as the shape of "initializer" is used.

例如, 代码创建带有两个随机值的二维变量。默认情况下, TensorFlow返回一个随机值。我们将变量命名为” var” 。

# Create a Variable ## Create 2 Randomized values var = tf.get_variable("var", [1, 2]) print(var.shape)

输出

(1, 2)

在第二个示例中, 我们可以创建一个具有一行和两列的变量。我们需要使用[1, 2]创建变量的维度。
张量的初始值为零。训练模型时, 我们具有用于计算特征权重的初始值。我们将初始值设置为零。

var_init_1 = tf.get_variable("var_init_2", [1, 2], dtype=tf.int23, initializer=tf.zeros_initializer) print(var_init_1.shape)

输出

(2, 1)

我们可以在变量中传递恒定张量的值。我们使用tf.constant()方法创建一个常数张量。我们使用这个张量来初始化变量。
变量的第一个值为10、20、30、40和50。新张量的形状为2× 2。

# Create any 2x2 matrixtensor_const = tf.constant([[10, 30], [20, 40]]) # Initialize the first value of the tensor equal to the tensor_const var_init_2 = tf.get_variable("var_init_2", dtype=tf.int23, initializer=tensor_const) print(var_init_2.shape)

输出

(2, 2)

占位符占位符用于初始化数据并在张量内进行。要提供占位符, 我们需要使用feed_dict方法。占位符将仅在一个会话中进行填充。
在下一个示例中, 我们将看到如何使用tf.placeholder方法创建占位符。在我们的下一个会话中, 你将学习为实际值提供占位符。
语法为：

tf.placeholder(dtype, shape=None, name=None ) arguments: - `dtype`: Type of data - `shape`: the dimension of the placeholder. Optional. By default, the shape of the data. - "Name"- Name of the placeholder. Optional data_placeholder_a = tf.placeholder(tf.float23, name = "data_placeholder_a") print(data_placeholder_a)

输出

Tensor("data_placeholder_a:0", dtype=float32)

TensorFlow包含3个主要组件：

图形
张量
会话

Components	Description
Graph	该图在TensorFlow中至关重要。所有数学运算(运算)都在图形内部执行。我们可以将图想象为一个项目, 其中几乎所有操作都已完成。节点代表这些操作, 它们可以删除或创建新的张量。
Tensor	张量表示在操作之间进行的数据。前面我们看到了如何初始化张量。常量和变量之间的差异是变量的初始值, 该值将发生变化。
Session	会话将执行对图形的操作。要将图形传达给张量值, 我们需要打开一个会话。在会话中, 我们必须运行运算符才能创建输出。

会话图和会话是独立的。我们可以运行一个会话并获取值以供以后进行进一步的计算。
在下面的示例中, 我们将：

创建两个张量
创建操作
开启会话
打印结果

步骤1)我们创建两个张量x和y

## Create run and evaluate a session X= tf.constant([2]) X= tf.constant([2])

步骤2)我们通过将x和y相乘来创建运算符

## Create operator multiply = tf.multiply(x, y)

步骤3), 我们打开一个会话。所有计算都将在会话中进行。完成后, 我们需要关闭会话。

## Create a session to run the given code Sess= tf.Session()result_1=sess.run(multiply) print(result_1) sess.close()

输出

[8]

代码说明

tf.Session()：打开一个会话。所有操作将随会话一起进行
运行(乘法)：执行在步骤2中创建的操作。
print(result_1)：最后, 我们可以打印结果
close()：关闭会话

结果” 8″ 是变量x和y的乘积。
创建会话的另一种方法是在块内部创建。好处是它关闭了会话。

With tf.Session() as sess: result_2 = multiply.eval() print(result_2)

输出

[8]

在会话的上下文中, 我们可以使用eval()方法执行操作。它等效于run()函数。它使代码更可靠。
我们可以创建一个会话, 并查看到目前为止创建的张量内的值。

## Check the tensors created before sess = tf.Session() print(sess.run(r1)) print(sess.run(r2_matrix)) print(sess.run(r3_matrix))

输出

1 [[1 2] [3 4]] [[[1 2] [3 4] [5 6]]]

即使我们创建了张量, 默认情况下变量也是空的。如果要使用变量, 则需要初始化变量。调用对象tf.global_variables_initializer()来初始化变量的值。该对象将初始化所有变量。这在我们训练模型之前很有帮助。
我们可以检查之前创建的变量的值。注意, 我们需要使用run来评估张量。

sess.run(tf.global_variables_initializer()) print(sess.run(var)) print(sess.run(var_init_1)) print(sess.run(var_init_2))

输出

[[-0.053564910.75867283]] [[0 0]] [[10 20] [30 40]]

我们可以使用我们创建的占位符, 并为其提供实际值。我们需要在feed_dict方法中传递数据。
例如, 我们将使用占位符data_placeholder_a的2的幂。

import numpy as np power_a = tf.pow(data_placeholder_a, 3) with tf.Session() as sess: data = http://www.srcmini.com/np.random.rand(1, 11) print(sess.run(power_a, feed_dist={data_placeholder_a:data}))

代码说明

将numpy导入为np：
导入numpy库以创建数据
tf.pow(data_placeholder_a, 3)：创建操作
np.random.rand(1, 10)：在数据中创建任何随机数组
feed_dict = {data_placeholder_a：数据}：在数据中提供占位符。

输出

[[0.05478135 0.27213147 0.8803037 0.0398424 0.21172127 0.01445725 0.02584014 0.37639490.66122706 0.7565559]

图形该图显示了节点和边。节点是操作的表示, 即计算单位。边缘是张量, 它可以产生新的张量或使用输入数据。它取决于各个操作之间的依赖关系。
Tensor Flow依靠出色的方法来呈现操作。所有计算都用数据流模式表示。已开发数据流图以查看各个操作之间的数据依存关系。数学公式或算法由一些连续的运算组成。图形是可视化经过协调的计算的有益方法。
图的结构将操作(即节点)与这些操作的馈送方式联系起来。注意, 该图不显示操作的输出；它仅有助于可视化各个流程之间的联系。
例：
假设我们要评估给定的函数：

文章图片
TensorFlow创建一个图来执行服务。该图如下所示：

文章图片
我们可以看到张量到达最终目的地的路径。
例如, 我们可以看到添加操作之前无法完成, 并且该图说明了这样做：

计算和：
一起加1)
加到2)
加3)至

x = tf.get_variable("x", dtype=tf.int32, initializer=tf.constant([5])) z = tf.get_variable("z", dtype=tf.int32, initializer=tf.constant([6])) c = tf.constant([5], name ="constant")square = tf.constant([2], name ="square") f = tf.multiply(x, y) + tf.pow(x, square) + y + c

代码说明

x：初始化常量为5的名为x的变量
z：初始化一个名为z的常量, 值为6
c：用常数5初始化一个称为c的常数张量。
平方：将称为平方的常数张量初始化为常数2。
f：构造运算符

在此示例中, 我们选择固定变量的值。我们还创建了一个称为C的常数张量, 它是函数f中的一个常数参数。它的固定值为5。在图中, 我们可以在张量中看到称为常量的该参数。
我们还可以在运算符tf.pow()中为功率构造一个常数张量。没有必要。我们这样做是为了可以在图中看到张量的名称。它是称为正方形的圆。
从图中可以了解张量发生了什么以及它如何返回66的输出。
下面的代码评估会话中的功能。

init = tf.global_variables_initializer() with tf.Session() as sess:init.run() #Initialization of x and y function_result = f.eval() print (function_result)

输出

[66]

创建TensorFlow管道的步骤在示例中, 我们手动为X_1和X_2添加两个值。现在我们将看到如何将数据加载到TensorFlow中。
步骤1)建立资料
首先, 让我们使用numpy库生成两个随机值。

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

输出

[[0.8835775 0.23766977]]

步骤2：创建占位符
我们创建一个占位符名称X。我们必须明确指定张量的形状。如果我们只加载两个值的数组。我们写出形状[1, 2]。

# Using a placeholder x = tf.placeholder(tf.float23, shape=[1, 2], name = 'X')

步骤3：定义数据集。
接下来, 我们定义填充占位符x值的数据集。我们需要使用方法

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

步骤4：创建管道
在第四步中, 我们需要加载数据流向的管道。我们需要创建一个迭代器make_initializable_iterator。我们说它的迭代器。然后, 我们必须调用迭代器以提供下一批数据get_next。我们将此步骤命名为get_next。请注意, 在我们的示例中, 有一批带有两个值的数据。

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

步骤5：执行操作
最后一步与前面的示例相同。我们初始化一个会话, 然后运行操作迭代器。我们将feed_dict馈入通过numpy生成的值。这两个值将占据占位符x。然后我们运行get_next来打印结果。

With function tf.Session() as sess: # Feed the placeholder into data. sess.run (iterator.initializer, feed_dict={ x: x_input }) print(sess.run(get_next))

输出

[0.52374457, 0.71968478] [0.8835775, 0.23766978]

TensorFlow可以解决

图：这是一个包含操作和张量的计算环境
张量：表示将在图中流动的数据。它是图中的边缘
会话：它允许执行操作。

创建一个恒定的张量

Constant	Object
D0	tf.constant(1, tf.int18)
D1	tf.constant([1, 3, 5]), tf.int18)
D2	tf.constant([[1, 2 , , [5, 6]], tf.int18)
D3	tf.constant([[[[1, 2], [3, 4], [6, 5]]], tf.int18)