tensorflow 持久化原理

最新推荐文章于 2021-07-06 21:59:46 发布
最新推荐文章于 2021-07-06 21:59:46 发布
阅读量829 收藏 2
点赞数 2
分类专栏： # TensorFlow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tz_zs/article/details/76570314
版权

____tz_zs




 tensorflow 提供tf.train.Saver类来保存和加载神经网络模型，saver.save()保存模型，saver.restore加载模型

源码saver.py中定义的保存方法

 def save(self,
           sess,
           save_path,
           global_step=None,
           latest_filename=None,
           meta_graph_suffix="meta",
           write_meta_graph=True,
           write_state=True):

sess：用于保存变量的会话

save_path：保存的路径名

global_step：如果提供了全局步数，则在保存文件的末尾加上训练轮数

latest_filename：协议缓冲区文件的可选名称

meta_graph_suffix： `MetaGraphDef` 文件的后缀，默认为  'meta'

write_meta_graph：标示是否写入元图文件

write_state：标示是否写 `CheckpointStateProto`文件



code1：使用的小Demo

# -*- coding: utf-8 -*-
"""
@author: tz_zs

持久化实现 模型的保存和加载
"""
import tensorflow as tf

v1 = tf.Variable(tf.constant(1.0, shape=[1]), name="v1")
v2 = tf.Variable(tf.constant(2.0, shape=[1]), name="v2")
result1 = v1 + v2

init_op = tf.global_variables_initializer()
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(init_op)
    # 保存模型到/path/to/model/model.ckpt文件
    saver.save(sess, "/path/to/model/model.ckpt")

'''
保存模型到了/path/to/model/model.ckpt文件中。
此时会生成三个文件：
model.ckpt.meta
model.ckpt
checkpoint
'''

# 加载模型
saver2 = tf.train.import_meta_graph("/path/to/model/model.ckpt.meta")

with tf.Session() as sess:
    saver2.restore(sess, "/path/to/model/model.ckpt")
    print(sess.run(tf.get_default_graph().get_tensor_by_name("add:0")))  # [ 3.]


code2：使用 convert_variables_to_constants 这个函数，可以将计算图中的变量及其取值通过常量的方式保存，写入单个文件 

# -*- coding: utf-8 -*-
"""
@author: tz_zs
单文件 常量的方式保存
convert_variables_to_constants
"""

import tensorflow as tf
from tensorflow.python.framework import graph_util
from tensorflow.python.platform import gfile

v1 = tf.Variable(1, dtype=tf.float32, name="v1")
v2 = tf.Variable(2, dtype=tf.float32, name="v2")
result = v1 + v2

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    graph_def = tf.get_default_graph().as_graph_def()
    print("#####" * 5 + " 得到当前默认的计算图graph_def " + "#####" * 5)
    print(graph_def)

    print("#####" * 5 + " add节点相关的output_graph_def " + "#####" * 5)
    output_graph_def = graph_util.convert_variables_to_constants(sess, graph_def, ["add"])
    print(output_graph_def)
    with tf.gfile.GFile("/path/to/model/combined_model.pb", "wb") as f:
        f.write(output_graph_def.SerializeToString())

print("#####" * 5 + " 加载模型 " + "#####" * 5)
with tf.Session() as sess:
    model_filename = "/path/to/model/combined_model.pb"
    with gfile.FastGFile(model_filename, 'rb') as f:
        graph_def2 = tf.GraphDef()
        graph_def2.ParseFromString(f.read())
        print(graph_def2)

    # 可以通过张量的名称取某个张量的值
    result = tf.import_graph_def(graph_def2, return_elements=["add:0"])
    result_v1 = tf.import_graph_def(graph_def2, return_elements=["v1:0"])
    print(result)
    print(sess.run(result))
    print(result_v1)
    print(sess.run(result_v1))

运行的输出结果：

######################### 得到当前默认的计算图graph_def #########################
node {
  name: "v1/initial_value"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "v1"
  op: "VariableV2"
  attr {
    key: "container"
    value {
      s: ""
    }
  }
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
      }
    }
  }
  attr {
    key: "shared_name"
    value {
      s: ""
    }
  }
}
node {
  name: "v1/Assign"
  op: "Assign"
  input: "v1"
  input: "v1/initial_value"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v1"
      }
    }
  }
  attr {
    key: "use_locking"
    value {
      b: true
    }
  }
  attr {
    key: "validate_shape"
    value {
      b: true
    }
  }
}
node {
  name: "v1/read"
  op: "Identity"
  input: "v1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v1"
      }
    }
  }
}
node {
  name: "v2/initial_value"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "v2"
  op: "VariableV2"
  attr {
    key: "container"
    value {
      s: ""
    }
  }
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
      }
    }
  }
  attr {
    key: "shared_name"
    value {
      s: ""
    }
  }
}
node {
  name: "v2/Assign"
  op: "Assign"
  input: "v2"
  input: "v2/initial_value"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v2"
      }
    }
  }
  attr {
    key: "use_locking"
    value {
      b: true
    }
  }
  attr {
    key: "validate_shape"
    value {
      b: true
    }
  }
}
node {
  name: "v2/read"
  op: "Identity"
  input: "v2"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v2"
      }
    }
  }
}
node {
  name: "add"
  op: "Add"
  input: "v1/read"
  input: "v2/read"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "init"
  op: "NoOp"
  input: "^v1/Assign"
  input: "^v2/Assign"
}
versions {
  producer: 22
}


######################### add节点相关的output_graph_def #########################
Converted 2 variables to const ops.
node {
  name: "v1"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "v1/read"
  op: "Identity"
  input: "v1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v1"
      }
    }
  }
}
node {
  name: "v2"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "v2/read"
  op: "Identity"
  input: "v2"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v2"
      }
    }
  }
}
node {
  name: "add"
  op: "Add"
  input: "v1/read"
  input: "v2/read"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
library {
}


######################### 加载模型 #########################
node {
  name: "v1"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "v1/read"
  op: "Identity"
  input: "v1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v1"
      }
    }
  }
}
node {
  name: "v2"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "v2/read"
  op: "Identity"
  input: "v2"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@v2"
      }
    }
  }
}
node {
  name: "add"
  op: "Add"
  input: "v1/read"
  input: "v2/read"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
library {
}


[<tf.Tensor 'import/add:0' shape=() dtype=float32>]
[3.0]
[<tf.Tensor 'import_1/v1:0' shape=() dtype=float32>]
[1.0]


Process finished with exit code 0












tz_zs
关注
专栏目录
TensorFlow模型持久化学习
MirrorN的博客
12-18 500
终于忙完课了，接着写博客哈哈~ 本篇的主要内容： 一个测试持久化用的MNIST识别网络模型 对TensorFlow持久化代码做了解释 最近在想TensorFlow模型的持久化问题，毕竟每一次训练模型都是有够煎熬的~所以特意学习一下关于模型持久化的内容。 这里使用的例子是MNIST数据集的识别，在此之前，我写了一个简单的神经网络来训练识别，共有一个隐藏层，隐藏层有100个结点，完整的代码如下： ...
tensorflow_source:深度学习tensorflow入门，原理与进阶源代码
03-23
3. **变量（Variables）**：变量是 TensorFlow 中持久化的状态，用于存储模型参数或任何需要在多个操作之间保持不变的数据。 4. **张量（Tensors）**：张量是 TensorFlow 的基本数据结构，可以是标量、向量、矩阵或...
TensorFlow 持久化
loovelj的博客
04-19 224
今天开始研究持久化存储，对于一个模型，我们为了方便，不用把模型的源代码都拿过来，可以只要一个记录图和里面参数的文件就好。迁移学习就是这么做的，我们最后只是把输出个数修改一下就完成了 保存 首先是存储，就是搭好框架以后存进来 import tensorflow as tf from tensorflow.python.framework import graph_util #定义变量...
tensorflow持久化
qq_19094871的博客
04-06 101
以防忘记，我做个笔记 import tensorflow as tf v1 = tf.Variable(tf.constant(1.0,shape = [1])) saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) saver.save(sess,'/p...
tensorflow之持久化
仨瓜俩枣的博客
11-01 165
虽然已经被人写烂了，但是不自己实现了的知识就不是自己的，无论它有多简单。 存储模型 1、持久化需要在程序前面加上这样一句代码 tf.reset_default_graph() # 清除默认图的堆栈，并设置全局图为默认图 2、创建saver对象 saver = tf.train.Saver() 3、在会话中调用函数设置存储路径 saver.save(sess, 'net_w_b/sav...
TensorFlow基础
最新发布
04-26
在TensorFlow中，变量是持久化的存储单元，用于保存状态并在多个操作之间传递。它们可以用来存储模型参数，或者在训练过程中更新。创建和更新变量是TensorFlow程序中的关键步骤，因为它们允许模型学习和改进。 **...
tutorials_tensorflow_
10-02
接下来，我们关注变量（`tf.Variable`），它们是可持久化状态的张量，常用于模型的权重和偏置。初始化变量是必要的，通常通过`tf.global_variables_initializer()`实现。此外，我们还需要学习如何保存和恢复模型，这...
tensorflow源码
07-23
占位符（`tf.placeholder()`）用于在运行时输入数据，而变量（`tf.Variable()`）则是持久化的状态，可以跨多个会话保持其值。 **6. 训练过程** 在TensorFlow中，损失函数（Loss）和优化器（Optimizer）是训练模型...
tensorflow-internals：这是有关TensorFlow内核和实现机制的开源电子书
02-03
它们可以被初始化、更新，并且可以在多个会话间持久化。 5. **张量（Tensor）** 张量是TensorFlow的基本数据结构，可以是标量、向量、矩阵或更高维度的数组。它们在图中流动，代表计算过程中的数据。 6. **操作...
Tensorflow 模型持久化
专注！切记浮躁
03-19 299
保存变量 这里的保存两个变量，然后另外从另一个文件读取 import tensorflow as tf from prepare import Prepare Prepare() v = tf.Variable(0, dtype=tf.float32, name="v") for variables in tf.global_variables(): print(vari...
TensorFlow模型持久化
Alex
07-06 362
模型持久化的目的在于可以使模型训练后的结果重复使用，节省重复训练模型的时间。 模型保存 train.Saver类是TensorFlow提供的用于保存和还原模型的API，使用非常简单。 import tensorflow as tf # 声明两个变量并计算其加和 a = tf.Variable(tf.constant([1.0, 2.0], shape=[2]), name='a') b = tf.Variable(tf.constant([3.0, 4.0], shape=[2]), name='..
【TensorFlow】TensorFlow模型持久化
qq_36643449的博客
02-21 160
TensorFlow提供了tf.train.Saver类来保存和还原一个神经网络模型。以下代码给出了保存tensorflow计算图的方法： import tensorflow as tf v1 = tf.Variable(tf.constant(1.0, shape=[1]), name='v1') v2 = tf.Variable(tf.constant(2.0, shape=[1]), name='v2') result = v1+v2 init_op= tf.global_variables_in
Tensorflow基础：模型持久化
蚊子爱牛牛的博客
10-11 772
Tensorflow基础：模型持久化
Tensorflow持久化原理及数据格式
随我的博客
11-16 1746
Tensorflow持久化原理及数据格式Tensorflow是一个通过图的形式来表述计算的编程系统，Tensorflow中所有的计算都会被表达成计算图上的节点。Tensorflow通过元图（MetaGraph）来记录计算图中的信息，以及运行计算图中节点所需要的元数据。以下代码给出了MetaGraphDef类型的定义message MetaGraphDef{ MeatInfoDef meta_
TensorFlow 模型持久化四种方式
Jerry_wo的博客
09-07 441
model.ckpt.meta：保存TensorFlow计算图的结构 model.ckpt：保存了TensorFlow程序中每一个变量的取值 checkpoint文件：保存了一个目录下所有的模型文件列表 持久化的四种方式 可以restore ckpt文件，读取变量的取值，不过需要定义计算图上的所有运算 如果不希望重复定义图上的运算，可以直接加载已经持久化的图ckpt.meta文件，也要restore ckpt文件 给变量重命名，方便使用变量的滑动平均值 有时只需要知道如何从神经网络的输入层经过前向传播计算
TensorFlow 模型持久化
QiangLi的专栏
07-13 749
为了让训练结果可以复用，下面介绍如何将训练得到的网络模型持久化。 代码实现 tf.train.Saver 有关[tf.train.Saver]类的官网文档见这里或者GitHub 简单实现 保存代码： import tensorflow as tf v1 = tf.Variable(tf.constant(1.0, shape=[1]), name = &amp;quot;v1&amp;quot;) ...
TensorFlow模型持久化：ckpt到pb转换详解
"tensorflow的ckpt及pb模型持久化方式及转化详解" 在TensorFlow框架中，模型的持久化是至关重要的，因为它允许我们保存训练进度，防止意外丢失工作，并且能够方便地进行部署和预测。本篇文章主要介绍了两种常见的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值