파이썬 재미 AI 가장 인기있는 애플리케이션 프레임 워크 TensorFlow 연습 ☝☝☝

파이썬 재미 AI 가장 인기있는 애플리케이션 프레임 워크 TensorFlow 연습 

 

점점 더 널리, 많은 개발자와 연구자들은 더이 깊은 학습 프레임 워크를 공부하기 희망하는의 연구에 TensorFlow의 애플리케이션 및 제품과 함께. 프레임 워크 투표에서 거의 인간은 2144 년에 시작 어제 1441 명 참가자가 프레임 워크를 TensorFlow 사용하는이 프레임 워크는 모든 최고 사용합니다. 그러나이 정적 계산 맵은 몇 가지 학습 비용, 따라서 피트 스탑 초보자에 많은 준비를 가지고 TensorFlow. 이 문서에서는 초보자 TensorFlow 프로그래밍 기술을 파악하기 위해 단계에서 간단한 이론과 실천의 단계를 설계 자습서의 학습 TensorFlow 시리즈에 대해 설명합니다.

이 튜토리얼 시리즈는 회선 신경 네트워크를 구현하도록 선택할 이유는 무엇, TensorFlow에서 여섯 개 부분으로 나누어 초보자의 기술을 필요로 소개된다. 대부분의 인간은 본원 장단점 및 정적도 컴퓨팅 텐서 TensorBoard 시각화 및 모델 파라미터를 저장하는 단계를 더 포함하는 등 CAFFE TensorFlow베이스 PyTorch 깊은 학습 틀 등을 설명한다.

 

왜 TensorFlow?

이 글에서, 우리는 당신이 응용 프로그램에 가장 적합한 프레임 워크를 선택하는 데 도움이, (CAFFE, Theano, PyTorch, TensorFlow 및 Keras 포함)에서 가장 인기있는 깊은 학습 프레임 워크를 비교합니다.

CAFFE 1 : 첫 번째 주류 생산 심도있는 학습 도서관, 2014 년, UC 버클리에 의해 시작.

장점 :

• 빠른

• GPU 지원

• 예쁜 MATLAB과 파이썬 인터페이스

단점 :

• 유연하지 않습니다. CAFFE에서 각 노드는 레이어로 처리됩니다, 그래서 당신은 새로운 유형의 층을 원한다면, 당신은 이전 버전과의 완벽한 앞으로 및 그라데이션 업데이트 프로세스를 정의 할 필요가있다. 이 층은 끝없는 목록을 선택해야합니다 네트워크 빌딩 블록입니다. (반면에, TensorFlow에서, 각각의 노드는 또한 행렬 승산 또는 컨벌루션 텐서 등의 조작이다. 쉽게 이러한 작업과 같은 층 구성을 정의 할 수있다. 따라서 TensorFlow 더 작은 수 빌딩 블록 유연하고 모듈 형).

• 그것은 불필요한 중복 코드를 많이 필요로한다. 당신은 CPU와 GPU를 모두 지원하려면 각 추가 기능을 위해 달성해야합니다. 당신은 또한 당신의 모델을 정의하는 일반 텍스트 편집기를 사용해야합니다. 정말 두통! 그것은 서로 다른 구성 요소 사이 좋은 모듈화이기 때문에 대부분의 사람들은, 프로그래밍 모델을 정의하고자합니다. 흥미롭게도, CAFFE TensorFlow의 주요 건축가는 이제 팀에서 작동합니다.

• 특이성. 단지 컴퓨터 비전에서 대상 (하지만 매우 잘).

• 그것은 파이썬으로 작성되지 않습니다! 당신이 새로운 변화를 도입 할 경우, C ++ 및 CUDA에 (작은 변화, 당신은 파이썬과 matlab에 인터페이스에서 사용할 수 있습니다) 프로그램이 필요합니다.

• 빈약 한 문서.

• 설치 더 어려워! 종속의 다수가 있습니다.

• 입력 형식 만 몇 가지, 하나의 출력 형식 HDF5 (항상 실행 파이썬 / C ++ / matlab에 인터페이스를 위해 그것을 사용하고, 출력 데이터를 도출 할 수있다).

• 네트워크 사이클을 구성 할 수 없습니다.

Theano 2 : 대학 몬트리올의 연구팀에 의해 만들어. Theano 정상 개방 깊이 값은 Keras, 라자냐와 블록을 포함하여 라이브러리를 구축 하였다. 2017년 9월 28일 발표에서 요 수아 벤 지오는 Theano 개발이 종료됩니다 . 그래서 사실 Theano는 죽었다!

장점 :

• 다운 연산 추상 그래프 (비교 TensorFlow)

• CPU와 GPU 최적화되어 있습니다

• 음 수치 최적화 작업에 적합

• 고급 포장 (Keras, 라자냐)

단점 :

• 원래 Theano 상대적으로 낮은 수준의 API

import numpy
           for _ in range(T):
               h = torch.matmul(W, h) + b

• 대형 모델은 컴파일 시간이 오래 걸릴 수 있습니다

• 그것은 멀티 GPU를 지원하지 않습니다

• 오류 메시지가 도움이 (때로는 좌절)하지 않을 수 있습니다

Pytorch 3. : 2017 니안 1 왕위 (루아로 작성) 파이썬 토치 라이브러리 오픈 소스의 페이스 북 버전.

장점 :

• 도 동적 계산 (도 런타임시 생성 수단)는 입력 및 출력 가변 길이, RNN 사용될 때, 예를 들면, 매우 유용를 처리 할 수있다.

• 또 다른 예로서, PyTorch에, 당신은 for 루프를 작성하는 표준 파이썬 구문을 사용할 수 있습니다.

• 사전 교육 모델의 많은 수의

• 모듈 식 구성 요소의 많은 수의 쉬운 조합

• GPU에서 실행, 쉽게 자신의 계층 유형을 쓰기 쉬운

• "TensorBoard는"몇 가지 주요 기능이 부족하면, "Losswise"는 Pytorch 대용으로 사용할 수 있습니다

단점 :

• 공식 문서 이외의 제한 참고 문헌 / 자료

• 상업적인 지원 없음

4. TensorFlow : 같이 낮은 수준의 기호 계산 라이브러리 (예컨대 Theano) 높은 수준의 네트워크 규격 라이브러리 (예컨대, 블록 및 라자냐)의 조합.

장점 :

• 구글에 의해 개발을 지속적으로 지원을 보장 할 수 있으므로 개발, 유지하고 있습니다.

• 거대한, 활발한 커뮤니티

• 네트워크 교육 낮은 수준, 높은 수준의 인터페이스

• "TensorBoard는"네트워크 토폴로지의 성능을 추적하고 디버깅을 쉽게하기 위해 설계된 강력한 시각화 패키지입니다.

• 파이썬으로 작성된 꽤 읽을 수있는 프로그래밍 언어, (일부 부분은 성능에 큰 영향이 C ++로 얻을 수 있지만)

• 멀티 GPU를 지원합니다. 그래서 당신은 자유롭게 중지하거나 프로그램을 다시 시작하지 않고, 다른 컴퓨터에서 코드를 실행할 수 있습니다

• 모델 컴파일러 옵션을 기반으로 Theano보다 빠르게

• Theano보다 짧은 컴파일 시간

• TensorFlow뿐만 아니라 깊은 학습뿐만 아니라 학습 도구와 다른 알고리즘을 강화에 대한 지원을 지원합니다.

단점 :

• 도 순수한 파이썬은 계산 때문에 느린됩니다

• 그림 구조가 정적, 그지도를 의미하는 "컴파일"해야 실행

Keras 5 : Keras는 가장 사용자 친화적 인 API보다 진보 된 구성 후단, 작성 및 구글 브레인 팀 구성원 프랜시스 Chollet에 의해 관리가 있습니다.

장점 :

• 이 읽기 쉽고 사용하기, 깊은 학습 모델을 구축하기 위해 높은 수준의 API를 제공합니다

• 사양 문서의 준비

• 대형 활발한 커뮤니티

• 위에있는 다른 라이브러리 깊은 학습 (예를 들어, Theano 및 TensorFlow, 구성 가능)

• 객체 지향 설계를 사용하여, 모든 콘텐츠 객체 (예를 들어, 네트워크 계층 파라미터, 최적화, 등)을 고려한다. 모든 모델 매개 변수는 객체의 속성으로 액세스 할 수 있습니다.

예를 들면 :

• model.layers [3] 모델을 제공하는 제 3 층을 · 출력

• model.layers [3] 기호 목록 텐서 중량 .weights

단점 :

• 목적은 매우 일반적이기 때문에, 아주 성능면에서 부족

• (그것을 위해 최적화되지 때문에)하지만 백엔드 Theano 좋은 결과와 함께 사용하면 백 엔드와 함께 사용하면 성능 문제가 TensorFlow

• TensorFlow 또는가요 PyTorch 달리

TensorFlow 기준

수치 계산하기위한 데이터 플로우 그래프 (데이터 플로우 그래프)를 사용 TensorFlow, 개방 소스 소프트웨어 라이브러리. 데이터 전송이 텐서 텐서 (다차원 어레이)를 대표하며, 흐름을 대표하여 계산도를 산출한다. "노드"(노드) 및 "에지"(에지)와 데이터 흐름도는 수학적 연산을 유향 그래프를 설명하기 위해 구성된다. "노드"일반적 / 쓰기 단부 영구 변수 (영구 변수)의 데이터 입력과 시작점의 출력의 종료를 지시하거나 읽을 수에도 적용 수학 연산을 표시하기 위해 사용되지만이다. 노드 간의 입력 / 출력 관계의 측면. 데이터 전송 가장자리 동적 다차원 데이터 어레이, 즉 텐서 (텐서)의 치수를 조정할 수있다.

도 컴퓨팅 세션

"계산지도"방법 - 첫 번째 단계는 TensorFlow의 주요 기능을 배우고 이해하는 것입니다. TensorFlow는 실질적으로 모든 코드는 두 가지 중요한 부분으로 구성되어 있습니다 :

1. "계산 맵"을 작성하여 표시하는 계산 된 데이터 흐름이

2. 실행 "세션"작업을 실행

실제로, 별도의 정의는 해당 실행 계산 TensorFlow. 두 부분은 다음 섹션에서 자세히 설명한다. 그때까지, 첫 번째 단계는 TensorFlow을 가져올 수 있다는 사실을!

import tensorflow as tf

이러한 방법으로, 파이썬은 TensorFlow의 모든 클래스, 메소드 및 기호에 액세스 할 수 있습니다. 즉, 나중에 우리가 대신의 이름을 입력으로 사용할 수 있도록이 명령을 TensorFlow 라이브러리는, 별명 "TF"에서 가져옵니다 "TensorFlow."

1.도 계산

TensorFlow 창의적인 아이디어는 최대 수치 계산으로도 표현된다. 다른 방법을 넣어, 어떤 백본 TensorFlow 프로그램은 계산지도입니다. 언급 TensorFlow 공식 웹 사이트로, "계산 차트 TensorFlow 그래프 노드에 대한 일련의 작업으로 구성되어 있습니다."

첫째, 노드 및 운영은 무엇인가? 가장 좋은 방법은 예를 들어 설명합니다. 우리는 "X ^ 2Y + Y + 2 F (X, Y) ="는 함수에 대한 코드를 작성하자. 다음도 TensorFlow 계산은 :

도 2 :도 TensorFlow 산출 건설.

상술 한 바와 같이, 구성도를 상호 가장자리 계산 일련의 노드들이있다. 각 노드는 작동 (동작)의 약어, OP 불린다. 각 노드는 따라서 동작이 발생 또는 텐서 텐서 계산 될 수있는 계산을 나타낸다. 각 입력 제로 이상의 카드의 양 노드와 출력으로 텐서를 생성한다.

이제 간단한 계산 그래프를 생성 할 수 있습니다.

import tensorflow as tf
a = 2
b = 3
c = tf.add(a, b, name='Add')
print(c)
______________________________________________________
Tensor("Add:0", shape=(), dtype=int32)

도 계산하고 변수 생성 :

그림 3 : 왼쪽 : Tensorboard도에서 생성 된 시각화, 오른쪽 : 변수를 생성 (획득 디버거 PyCharm 스크린 샷에서 디버그 모드에서 작동 할 때)

실제 노드를 평가하기 위해,도 계산 세션에서 실행해야합니다. 요약하면, 코드는 기록 만이를 수행 예상 크기와 텐서도 동작을 결정하는 데 사용 생성한다. 그러나, 어떤 텐서에 할당되지 않습니다.

따라서, TensorFlow 그래프는 파이썬의 정의와 유사한 기능을 수행합니다. 그것은 당신이 어떤 계산을 수행 할 때 (단지 함수 정의처럼 더 실행 결과가 없을 것) "아니오"입니다. 그것은 "은"작업을 계산 정의합니다.

2. 세션 (세션)

TensorFlow에서, 모든 다른 변수 및 동작은도 1의 계산에 저장된다. 우리가 차트에 필요한 모델을 구축했습니다 그래서 후에, 또한 전체 계산 차트를 실행하는 세션 (세션)을 열어야합니다. 세션에서, 우리는 가능한 모든 CPU와 GPU 자원 분포를 계산할 수 있습니다. 간단한 예로서,도가 연산을 실행하고 (C)의 값을 획득 :

sess = tf.Session()
print(sess.run(c))
sess.close()
__________________________________________
5

이 코드는 다음 세션 () (SESS 할당) 개체, 및 (두 번째 행)도 충분한 컴퓨팅 C 평가를 실행하기 위해 운영 방법 호출을 생성한다. 계산이 시스템 자원을 확보하기 위해 세션을 닫을 필요, 또는 자원 누출을 완료 한 후 문제가 발생합니다.

TensorFlow 텐서

import tensorflow as tf

TensorFlow 中最基本的单位是常量（Constant）、变量（Variable）和占位符（Placeholder）。常量定义后值和维度不可变，变量定义后值可变而维度不可变。在神经网络中，变量一般可作为储存权重和其他信息的矩阵，而常量可作为储存超参数或其他结构信息的变量。

1. 常量

创建一个节点取常数值，它接收以下的变量：

tf.constant(value, dtype=None, shape=None, name='Const', verify_shape=False)

我们来创建两个常量并将它们加起来。常量张量可以通过定义一个值来简单地定义：

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = a + b
# launch the graph in a session
with tf.Session() as sess:
    print(sess.run(c))
____________________________________________________
5    

现在我们来看看创建的计算图和生成的数据类型：

2. 变量

变量是状态性的节点，输出的是它们当前的值，意味着它们可以在一个计算图的多次执行中保留它们的值。它们有一系列的有用特征，例如：

它们可以在训练期间或训练后保存到硬盘上。这允许来自不同公司和团队的人们保存、恢复和发送他们的模型参数给别人。

默认情况下，梯度更新（在所有神经网络中应用）将应用到计算图中的所有变量。实际上，变量是你希望调整以最小化损失函数的东西。

为了创建变量，你可以按如下方式使用 tf.Variable：

# Create a variable.
w = tf.Variable(<initial-value>, name=<optional-name>)

以下语句声明一个 2 行 3 列的变量矩阵，该变量的值服从标准差为 1 的正态分布，并随机生成。

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))

TensorFlow 还有 tf.truncated_normal() 函数，即截断正态分布随机数，它只保留 [mean-2*stddev,mean+2*stddev] 范围内的随机数。

调用 tf.Variable 来创建一个变量是一种老方法。TensorFlow 推荐使用封装器 tf.get_variable，它能接收命名、形状等参数：

tf.get_variable(name,
                shape=None,
                dtype=None,
                initializer=None,
                regularizer=None,
                trainable=True,
                collections=None,
                caching_device=None,
                partitioner=None,
                validate_shape=True,
                use_resource=None,
                custom_getter=None,
                constraint=None)

变量在使用前需要初始化。为此，我们必须调用「变量初始值设定项操作」，并在 session 上运行该操作。

a = tf.get_variable(name="var_1", initializer=tf.constant(2))
b = tf.get_variable(name="var_2", initializer=tf.constant(3))
c = tf.add(a, b, name="Add1")

# launch the graph in a session
with tf.Session() as sess:
    # now let's evaluate their value
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))

3. 占位符

我们已经创建了各种形式的常量和变量，但 TensorFlow 同样还支持占位符。占位符并没有初始值，它只会分配必要的内存。在会话中，占位符可以使用 feed_dict 馈送数据。

feed_dict 是一个字典，在字典中需要给出每一个用到的占位符的取值。在训练神经网络时需要每次提供一个批量的训练样本，如果每次迭代选取的数据要通过常量表示，那么 TensorFlow 的计算图会非常大。因为每增加一个常量，TensorFlow 都会在计算图中增加一个节点。所以说拥有几百万次迭代的神经网络会拥有极其庞大的计算图，而占位符却可以解决这一点，它只会拥有占位符这一个节点。

a = tf.constant([5, 5, 5], tf.float32, name='A')
b = tf.placeholder(tf.float32, shape=[3], name='B')
c = tf.add(a, b, name="Add")

with tf.Session() as sess:
    # create a dictionary:
    d = {b: [1, 2, 3]}
    # feed it to the placeholder
    print(sess.run(c, feed_dict=d)) 
 ___________________________________________________
 [6. 7. 8.]

它生成的计算图与变量如下所示：

现在，我们已经能创建一个简单的神经网络。如下利用随机生成的数据创建了一个三层全连接网络：

import tensorflow as tf
from numpy.random import RandomState

batch_size=10
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

# None 可以根据batch 大小确定维度，在shape的一个维度上使用None
x=tf.placeholder(tf.float32,shape=(None,2))
y=tf.placeholder(tf.float32,shape=(None,1))

#激活函数使用ReLU
a=tf.nn.relu(tf.matmul(x,w1))
yhat=tf.nn.relu(tf.matmul(a,w2))

#定义交叉熵为损失函数，训练过程使用Adam算法最小化交叉熵
cross_entropy=-tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat,1e-10,1.0)))
train_step=tf.train.AdamOptimizer(0.001).minimize(cross_entropy)

rdm=RandomState(1)
data_size=516

#生成两个特征，共data_size个样本
X=rdm.rand(data_size,2)
#定义规则给出样本标签，所有x1+x2<1的样本认为是正样本，其他为负样本。Y，1为正样本
Y = [[int(x1+x2 < 1)] for (x1, x2) in X]

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w1))
    print(sess.run(w2))
    steps=11000
    for i in range(steps):

        #选定每一个批量读取的首尾位置，确保在1个epoch内采样训练
        start = i * batch_size % data_size
        end = min(start + batch_size,data_size)
        sess.run(train_step,feed_dict={x:X[start:end],y:Y[start:end]})
        if i % 1000 == 0:
            training_loss= sess.run(cross_entropy,feed_dict={x:X,y:Y})
            print("在迭代 %d 次后，训练损失为 %g"%(i,training_loss))

上面的代码定义了一个简单的三层全连接网络（输入层、隐藏层和输出层分别为 2、3 和 2 个神经元），隐藏层和输出层的激活函数使用的是 ReLU 函数。该模型训练的样本总数为 512，每次迭代读取的批量为 10。这个简单的全连接网络以交叉熵为损失函数，并使用 Adam 优化算法进行权重更新。

其中需要注意的几个函数如 tf.nn.relu() 代表调用 ReLU 激活函数，tf.matmul() 为矩阵乘法等。tf.clip_by_value(yhat,1e-10,1.0) 这一语句代表的是截断 yhat 的值，因为这一语句是嵌套在 tf.log() 函数内的，所以我们需要确保 yhat 的取值不会导致对数无穷大。

TensorBoard 基础

TensorBoard 是一个可视化软件，在所有的 TensorFlow 标准安装中都包含了 TensorBoard。按谷歌的话说：「使用 TensorFlow 执行的计算，例如训练一个大规模深度神经网络，可能复杂且令人困惑。为了更加容易理解、调试和优化 TensorFlow 程序，我们内置了一套可视化工具，即 TensorBoard。」

TensorFlow 程序既能解决非常简单也能解决非常复杂的问题，它们都有两种基本组件——运算和张量。如前所述，你创建了一个由一系列运算构成的模型，馈送数据到模型上，张量将在运算之间流动，直到得到了输出张量，即你的结果。

完全配置好后，TensorBoard 窗口将呈现与下图类似的画面：

TensorBoard 的创建是为了帮助你了解模型中张量的流动，以便调试和优化模型。它通常用于两项任务:

1. 图形可视化

2. 编写摘要（或可视化学习）

在本教程中，我们将介绍 TensorBoard 的上述两项主要用法。尽早学习使用 TensorBoard，可以让使用 TensorFlow 的工作更有趣也更有成效。

1. 计算图可视化

强大的 TensorFlow 计算图会变得极其复杂。可视化图形有助于理解并对其进行调试。这是一个在 TensorFlow 网站工作的可视化示例。

为了激活 TensorFlow 程序 TensorBoard，需要向其中添加几行代码。这将把 TensorFlow 运算导出到一个名为「event file」（或 event log file）的文件中。TensorBoard 能够读取此文件并深入了解模型图及其性能。

现在我们来编写一个简单的 TensorFlow 程序，并用 TensorBoard 可视化其计算图。先创建两个常量并将其添加到一起。常数张量可以简单地通过定义它们的值来定义：

import tensorflow as tf

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = tf.add(a, b)
# launch the graph in a session
with tf.Session() as sess:
    print(sess.run(c))
_____________________________________________
5 

为了用 TensorBoard 可视化程序，我们需要编写程序的日志文件。为了编写事件文件，我们首先需要为那些日志编写一个 writer，使用以下代码：

writer = tf.summary.FileWriter([logdir], [graph])

其中 [logdir] 是你想要保存那些日志文件的文件夹。你可以选择 [logdir] 作为某些有意义的东西，例如『./graphs』。第二个参数 [graph] 是我们正在编写的程序的计算图。有两种获取计算图的方法：

1. 使用 tf.get_default_graph() 调用计算图，返回程序的默认计算图

2. 将计算图设置为 sess.graph，返回会话的计算图（注意这里需要我们已经创建了会话）

我们将在以下的例子中展示两种方法。然而，第二种方法更加常用。不管用哪种方法，确保仅当你定义了计算图之后才创建一个 writer。否则，TensorBoard 中可视化的计算图将是不完整的。让我们添加 writer 到第一个例子中并可视化计算图。

import tensorflow as tf

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = tf.add(a, b)

# creating the writer out of the session
# writer = tf.summary.FileWriter('./graphs', tf.get_default_graph())

# launch the graph in a session
with tf.Session() as sess:
    # or creating the writer inside the session
    writer = tf.summary.FileWriter('./graphs', sess.graph)
    print(sess.run(c))
    # don't forget to close the writer at the end
    writer.close()

接下来转到 Terminal，确保当前工作目录与运行 Python 代码的位置相同。例如，此处我们可以使用以下代码切换到目录

$ cd ~/Desktop/tensorboard

接下来运行：

$ tensorboard --logdir="./graphs" —port 6006

这将为你生成一个链接。ctrl + 左键单击该链接（或将其复制到浏览器中，或只需打开浏览器并转到 http://localhost:6006/）。接下来将显示 TensorBoard 页面，如下所示：

参数存储与加载

在基础部分中，最后还介绍了模型参数的保存与恢复。一般 TensorFlow 模型持久化可使用 tf.train.Saver() 完成，它会将 TensorFlow 模型保存为 .ckpt 格式的文件。一般该文件目录下会有三个文件，第一个 model.ckpt.meta 保存了 TensorFlow 计算图的结构，第二个 model.ckpt 文件保存了 TensorFlow 中每一个变量的取值，而最后一个 cheekpoint 文件保存了同目录下所有的模型文件列表。

为了保存和恢复模型变量，我们需要在构建计算图后调用 tf.train.Saver()，例如：

# create the graph
X = tf.placeholder(..)
Y = tf.placeholder(..)
w = tf.get_variale(..)
b = tf.get_variale(..)
...
loss = tf.losses.mean_squared_error(..)
optimizer = tf.train.AdamOptimizer(..).minimize(loss)
...

saver = tf.tfain.Saver()

在训练模式中，我们需要打开会话初始化变量和运行计算图，并在训练结束时调用 saver.save() 保存变量：

# TRAIN
with tf.Session() as sess:
    sess.run(tf.globale_variables_initializer())
    # train our model
    for step in range(steps):
        sess.run(optimizer)
        ...
    saved_path = saver.save(sess, './my-model', global_step=step)

在测试模式中，我们需要使用 saver.restore() 恢复参数：

# TEST
with tf.Session() as sess:
    saver.restore(sess, './my-model')
    ...

当然，模型持久化还有非常多的内容，例如由 MetaGraphDef Protocol Buffer 定义的计算图节点元数据。读者可继续阅读完整的教程或其它书籍以了解详细信息。