tensorflow学习1.3-创建会话，启动会话

- - 会话的由来与作用
  - - 由来
    - 作用
  - 会话的定义与结构
  - - 定义
  - 用法
  - - 基本用法
    - 上下文管理器
    - 执行部分计算图
    - 获取多个结果
  - 总结
练习代码
- 报错
- 原因：
- - TensorFlow 2.x中的Eager Execution
  - 使用兼容模式来启用Session
  - Eager Execution和计算图的混合使用
  - 总结
- 修改

在TensorFlow 1.x版本中， Session 会话是一个非常重要的概念。它提供了一个执行计算图（computation graph）的环境。TensorFlow 2.x 版本引入了Eager Execution模式，使得大多数操作立即执行，而不再需要显式的会话管理。但是，为了理解 TensorFlow 的基础，以及在某些情况下可能仍然需要使用的低级操作，我们还是有必要了解一下 TensorFlow 1.x 中的会话机制。

会话的由来与作用

由来

TensorFlow最初是由谷歌大脑团队开发的，用于大规模机器学习任务。最初的设计目标之一是能够高效地在分布式环境中执行计算图。为了实现这一点，TensorFlow引入了 Session 概念来管理和执行计算图。

作用

Session 的主要作用包括：

管理资源：分配和管理计算所需的资源，如GPU和内存。
执行计算图：具体执行计算图中的操作（ops），并返回结果。
控制生命周期：在会话的生命周期内，可以反复执行计算图的一部分或全部。

会话的定义与结构

在 TensorFlow 1.x 中，会话是通过 tf.Session 类定义的。其主要结构和用法如下：

定义

# 创建一个计算图
import tensorflow as tf

# 定义一个计算图节点
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b

# 创建一个会话
sess = tf.Session()

# 在会话中运行计算图
result = sess.run(c)
print(result)  # 输出：11.0

# 关闭会话
sess.close()

用法

基本用法

创建会话：可以通过 tf.Session() 创建一个会话对象。
执行计算：使用 sess.run() 方法执行计算图中的节点。
关闭会话：使用 sess.close() 关闭会话，释放资源。

上下文管理器

为了确保会话在使用后正确关闭，可以使用 Python 的上下文管理器（with 语句）：

import tensorflow as tf

a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b

with tf.Session() as sess:
    result = sess.run(c)
    print(result)  # 输出：11.0

使用上下文管理器的好处是会在代码块执行完毕后自动关闭会话。

执行部分计算图

会话允许你执行计算图的一部分，这对于大型复杂的计算图尤其有用：

import tensorflow as tf

a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b
d = c * 2

with tf.Session() as sess:
    # 只执行c节点
    result_c = sess.run(c)
    print(result_c)  # 输出：11.0

    # 执行d节点，TensorFlow会自动计算c节点的值
    result_d = sess.run(d)
    print(result_d)  # 输出：22.0

获取多个结果

可以在一次会话运行中获取多个节点的结果：

import tensorflow as tf

a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b
d = c * 2

with tf.Session() as sess:
    result_c, result_d = sess.run([c, d])
    print(result_c)  # 输出：11.0
    print(result_d)  # 输出：22.0

总结

Session 会话是 TensorFlow 1.x 中用于执行计算图的环境，通过会话可以管理资源、执行计算图并获取结果。在 TensorFlow 2.x 中，引入了更易用的 Eager Execution 模式，使得大部分操作可以立即执行，而不需要显式管理会话。然而，了解 Session 的概念对于理解 TensorFlow 的设计原理和使用低级 API 仍然是有帮助的。

练习代码

import tensorflow as tf



# 创建一个变量
m1 = tf.constant([[3,3]])

#创建一个常量
m2=tf.constant([[2],[3]])

#矩阵乘法 OP
product = tf.matmul(m1,m2)

print(product)

#定义会话
sess = tf.Session()

#调用sess中的run方法执行矩阵乘法op
result = sess.run(product)
print(result)
sess.close()

with tf.Session() as sess:
    # 调用sess中的run方法来执行矩阵惩罚op
    result = sess.run(product)
    print(result)

报错

在我的环境中运行会遇见以下报错：
sess = tf.Session() AttributeError: module 'tensorflow' has no attribute 'Session'. Did you mean: 'version'?

原因：

在TensorFlow 2.x中，Session已经被弃用了，取而代之的是更加直观和易用的Eager Execution模式。Eager Execution使得TensorFlow操作立即执行，并返回结果，而不是构建一个计算图，然后再通过会话来运行这些图。

尽管如此，如果你确实需要使用与TensorFlow 1.x兼容的功能，比如在某些情况下必须要用到计算图和会话，可以通过在TensorFlow 2.x中启用兼容模式来使用这些功能。

TensorFlow 2.x中的Eager Execution

默认情况下，TensorFlow 2.x启用了Eager Execution模式，这使得编写和调试代码更加直观。下面是一个简单的例子：

import tensorflow as tf

# Eager Execution模式下直接计算
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b
print(c)  # 输出：tf.Tensor(11.0, shape=(), dtype=float32)

使用兼容模式来启用Session

如果你需要在TensorFlow 2.x中使用会话和计算图，可以启用兼容模式：

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

# 创建一个计算图
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b

# 创建一个会话
sess = tf.Session()

# 在会话中运行计算图
result = sess.run(c)
print(result)  # 输出：11.0

# 关闭会话
sess.close()

Eager Execution和计算图的混合使用

在某些复杂场景中，你可能需要混合使用Eager Execution和计算图。这种情况下，你可以使用tf.function来定义需要构建为计算图的部分代码：

import tensorflow as tf

# Eager Execution模式下直接计算
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b
print(c)  # 输出：tf.Tensor(11.0, shape=(), dtype=float32)

# 使用tf.function将代码转换为计算图
@tf.function
def compute():
    d = a * b
    return d

result = compute()
print(result)  # 输出：tf.Tensor(30.0, shape=(), dtype=float32)

总结

在TensorFlow 2.x中，建议尽量使用Eager Execution模式，因为它更加直观和易于调试。如果你必须使用与TensorFlow 1.x兼容的功能，可以通过启用兼容模式来使用会话和计算图。在大多数情况下，Eager Execution模式已经足够强大，并且能够满足大多数深度学习任务的需求。

修改

在TensorFlow 2.x中，推荐使用Eager Execution模式，因为它更加直观和易于调试。以下是将代码转换为Eager Execution模式的版本：

import tensorflow as tf

# 确保Eager Execution模式已启用
tf.config.run_functions_eagerly(True)

# 创建一个变量
m1 = tf.constant([[3, 3]])

# 创建一个常量
m2 = tf.constant([[2], [3]])

# 矩阵乘法 OP
product = tf.matmul(m1, m2)

# 立即执行操作并返回结果
print(product.numpy())

# 在Eager Execution模式下，不需要显式定义会话
# 结果已经通过Eager Execution模式返回
result = product.numpy()
print(result)

在这个代码中，我们不需要显式定义会话。Eager Execution模式使得TensorFlow操作立即执行并返回结果，这样代码更加直观和易于调试。如果需要与TensorFlow 1.x兼容的功能，可以启用兼容模式，但在大多数情况下，Eager Execution模式已经足够强大，并且能够满足大多数深度学习任务的需求。

在TensorFlow 2.x中，直接使用Eager Execution模式会避免很多TensorFlow 1.x中的复杂性和问题。如果需要使用与TensorFlow 1.x兼容的功能，确保在兼容模式下正确地定义和使用计算图。

这里是修正后的代码，确保兼容模式下操作添加到计算图中：

import tensorflow as tf

# 使用兼容模式
tf.compat.v1.disable_eager_execution()

# 创建一个变量
m1 = tf.compat.v1.constant([[3, 3]])

# 创建一个常量
m2 = tf.compat.v1.constant([[2], [3]])

# 矩阵乘法 OP
product = tf.compat.v1.matmul(m1, m2)

# 定义会话
sess = tf.compat.v1.Session()

# 调用sess中的run方法执行矩阵乘法op
result = sess.run(product)
print(result)
sess.close()

# 使用上下文管理器定义会话
with tf.compat.v1.Session() as sess:
    # 调用sess中的run方法来执行矩阵乘法op
    result = sess.run(product)
    print(result)

在这个代码中，使用了 tf.compat.v1.disable_eager_execution() 来禁用Eager Execution，并确保所有操作都在兼容模式下添加到计算图中。然后，使用 tf.compat.v1.Session 来运行这些操作。这种方式能够确保在TensorFlow 2.x中使用与1.x兼容的会话模式。

使用上下文管理器定义会话：

# 使用上下文管理器定义会话
with tf.compat.v1.Session() as sess:
    # 调用sess中的run方法来执行矩阵乘法op
    result = sess.run(product)
    print(result)

with tf.compat.v1.Session() as sess:：使用 with 关键字创建一个 tf.compat.v1.Session() 对象，并将其赋值给 sess 变量。tf.compat.v1.Session() 是 TensorFlow 2.x 中兼容 TensorFlow 1.x 的会话对象。
sess.run(product)：在会话中调用 run 方法来执行之前定义的矩阵乘法操作 product。这一步实际上会启动 TensorFlow 的计算图，并执行相应的计算。
print(result)：打印执行结果 result，即矩阵乘法的结果。

上下文管理器的作用：
使用 with 语句块可以确保在进入 with 代码块时会话 sess 被创建，并在代码块执行结束时自动关闭。这种方式避免了手动调用 sess.close() 来关闭会话，同时也确保了资源的正确释放，特别是在 TensorFlow 中，关闭会话能够释放计算资源和内存。

总结来说，这段代码的目的是使用 TensorFlow 2.x 的兼容模式创建一个会话，并在会话中执行矩阵乘法操作，最后打印执行结果。使用上下文管理器 with 确保了会话在使用完毕后正确关闭，避免了资源泄露和错误的释放。