tf.train.Saver().export_meta_graph()

最新推荐文章于 2020-12-18 20:18:22 发布
最新推荐文章于 2020-12-18 20:18:22 发布
阅读量564 收藏 1
点赞数
分类专栏： Tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liugan528/article/details/109511848
版权

TensorFlow中所有计算都会被表达为计算图上的节点。TensorFlow通过元图MetaGraph（.meta文件）来记录计算图中节点的信息以及运算计算图中节点所需要的元数据。元图是由MetaGraphDef Protocol Buffer定义的，主要包含meta_info_def，graph_def，saver_def等6类信息。
meta_info_def中包括计算图上使用到的所有运算方法的信息，如果某一个运算在计算图上出现多次，在meta_info_def的属性stripped_op_list中也只会出现一次。
graph_def主要记录计算图上的节点信息，TensorFlow计算图的每一个节点对应程序中的一个运算。
导出方式可使用tf.train.Saver().export_meta_graph()如下：

import tensorflow as tf

v1 = tf.Variable(tf.constant(1.0, tf.float32, [1]), 'v1')
v2 = tf.Variable(tf.constant(2.0, tf.float32, [1]), 'v2')
result = v1 + v2

saver = tf.train.Saver()
saver.export_meta_graph(r'test\model.ckpt.meta1.json', as_text=True)

model.ckpt.meta1.json文件内容：

meta_info_def {
  stripped_op_list {
    op {
      name: "AddV2"
      input_arg {
        name: "x"
        type_attr: "T"
      }
      input_arg {
        name: "y"
        type_attr: "T"
      }
      output_arg {
        name: "z"
        type_attr: "T"
      }
      attr {
        name: "T"
        type: "type"
        allowed_values {
          list {
            type: DT_BFLOAT16
            type: DT_HALF
            type: DT_FLOAT
            type: DT_DOUBLE
            type: DT_UINT8
            type: DT_INT8
            type: DT_INT16
            type: DT_INT32
            type: DT_INT64
            type: DT_COMPLEX64
            type: DT_COMPLEX128
          }
        }
      }
      is_aggregate: true
      is_commutative: true
    }
    op {
      name: "Assign"
      input_arg {
        name: "ref"
        type_attr: "T"
        is_ref: true
      }
      input_arg {
        name: "value"
        type_attr: "T"
      }
      output_arg {
        name: "output_ref"
        type_attr: "T"
        is_ref: true
      }
      attr {
        name: "T"
        type: "type"
      }
      attr {
        name: "validate_shape"
        type: "bool"
        default_value {
          b: true
        }
      }
      attr {
        name: "use_locking"
        type: "bool"
        default_value {
          b: true
        }
      }
      allows_uninitialized_input: true
    }
    op {
      name: "Const"
      output_arg {
        name: "output"
        type_attr: "dtype"
      }
      attr {
        name: "value"
        type: "tensor"
      }
      attr {
        name: "dtype"
        type: "type"
      }
    }
    op {
      name: "Identity"
      input_arg {
        name: "input"
        type_attr: "T"
      }
      output_arg {
        name: "output"
        type_attr: "T"
      }
      attr {
        name: "T"
        type: "type"
      }
    }
    op {
      name: "NoOp"
    }
    op {
      name: "PlaceholderWithDefault"
      input_arg {
        name: "input"
        type_attr: "dtype"
      }
      output_arg {
        name: "output"
        type_attr: "dtype"
      }
      attr {
        name: "dtype"
        type: "type"
      }
      attr {
        name: "shape"
        type: "shape"
      }
    }
    op {
      name: "RestoreV2"
      input_arg {
        name: "prefix"
        type: DT_STRING
      }
      input_arg {
        name: "tensor_names"
        type: DT_STRING
      }
      input_arg {
        name: "shape_and_slices"
        type: DT_STRING
      }
      output_arg {
        name: "tensors"
        type_list_attr: "dtypes"
      }
      attr {
        name: "dtypes"
        type: "list(type)"
        has_minimum: true
        minimum: 1
      }
      is_stateful: true
    }
    op {
      name: "SaveV2"
      input_arg {
        name: "prefix"
        type: DT_STRING
      }
      input_arg {
        name: "tensor_names"
        type: DT_STRING
      }
      input_arg {
        name: "shape_and_slices"
        type: DT_STRING
      }
      input_arg {
        name: "tensors"
        type_list_attr: "dtypes"
      }
      attr {
        name: "dtypes"
        type: "list(type)"
        has_minimum: true
        minimum: 1
      }
      is_stateful: true
    }
    op {
      name: "VariableV2"
      output_arg {
        name: "ref"
        type_attr: "dtype"
        is_ref: true
      }
      attr {
        name: "shape"
        type: "shape"
      }
      attr {
        name: "dtype"
        type: "type"
      }
      attr {
        name: "container"
        type: "string"
        default_value {
          s: ""
        }
      }
      attr {
        name: "shared_name"
        type: "string"
        default_value {
          s: ""
        }
      }
      is_stateful: true
    }
  }
  tensorflow_version: "1.15.4"
  tensorflow_git_version: "v1.15.3-68-gdf8c55ce12"
}
graph_def {
  node {
    name: "Const"
    op: "Const"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_FLOAT
          tensor_shape {
            dim {
              size: 1
            }
          }
          float_val: 1.0
        }
      }
    }
  }
  node {
    name: "Variable"
    op: "VariableV2"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "container"
      value {
        s: ""
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "shape"
      value {
        shape {
          dim {
            size: 1
          }
        }
      }
    }
    attr {
      key: "shared_name"
      value {
        s: ""
      }
    }
  }
  node {
    name: "Variable/Assign"
    op: "Assign"
    input: "Variable"
    input: "Const"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "use_locking"
      value {
        b: true
      }
    }
    attr {
      key: "validate_shape"
      value {
        b: true
      }
    }
  }
  node {
    name: "Variable/read"
    op: "Identity"
    input: "Variable"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
  }
  node {
    name: "Const_1"
    op: "Const"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_FLOAT
          tensor_shape {
            dim {
              size: 1
            }
          }
          float_val: 2.0
        }
      }
    }
  }
  node {
    name: "Variable_1"
    op: "VariableV2"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "container"
      value {
        s: ""
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "shape"
      value {
        shape {
          dim {
            size: 1
          }
        }
      }
    }
    attr {
      key: "shared_name"
      value {
        s: ""
      }
    }
  }
  node {
    name: "Variable_1/Assign"
    op: "Assign"
    input: "Variable_1"
    input: "Const_1"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable_1"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "use_locking"
      value {
        b: true
      }
    }
    attr {
      key: "validate_shape"
      value {
        b: true
      }
    }
  }
  node {
    name: "Variable_1/read"
    op: "Identity"
    input: "Variable_1"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable_1"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
  }
  node {
    name: "add"
    op: "AddV2"
    input: "Variable/read"
    input: "Variable_1/read"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
  }
  node {
    name: "save/filename/input"
    op: "Const"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_STRING
          tensor_shape {
          }
          string_val: "model"
        }
      }
    }
  }
  node {
    name: "save/filename"
    op: "PlaceholderWithDefault"
    input: "save/filename/input"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "shape"
      value {
        shape {
        }
      }
    }
  }
  node {
    name: "save/Const"
    op: "PlaceholderWithDefault"
    input: "save/filename"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "shape"
      value {
        shape {
        }
      }
    }
  }
  node {
    name: "save/SaveV2/tensor_names"
    op: "Const"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 2
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_STRING
          tensor_shape {
            dim {
              size: 2
            }
          }
          string_val: "Variable"
          string_val: "Variable_1"
        }
      }
    }
  }
  node {
    name: "save/SaveV2/shape_and_slices"
    op: "Const"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 2
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_STRING
          tensor_shape {
            dim {
              size: 2
            }
          }
          string_val: ""
          string_val: ""
        }
      }
    }
  }
  node {
    name: "save/SaveV2"
    op: "SaveV2"
    input: "save/Const"
    input: "save/SaveV2/tensor_names"
    input: "save/SaveV2/shape_and_slices"
    input: "Variable"
    input: "Variable_1"
    attr {
      key: "dtypes"
      value {
        list {
          type: DT_FLOAT
          type: DT_FLOAT
        }
      }
    }
  }
  node {
    name: "save/control_dependency"
    op: "Identity"
    input: "save/Const"
    input: "^save/SaveV2"
    attr {
      key: "T"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@save/Const"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
          }
        }
      }
    }
  }
  node {
    name: "save/RestoreV2/tensor_names"
    op: "Const"
    device: "/device:CPU:0"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 2
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_STRING
          tensor_shape {
            dim {
              size: 2
            }
          }
          string_val: "Variable"
          string_val: "Variable_1"
        }
      }
    }
  }
  node {
    name: "save/RestoreV2/shape_and_slices"
    op: "Const"
    device: "/device:CPU:0"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 2
            }
          }
        }
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_STRING
          tensor_shape {
            dim {
              size: 2
            }
          }
          string_val: ""
          string_val: ""
        }
      }
    }
  }
  node {
    name: "save/RestoreV2"
    op: "RestoreV2"
    input: "save/Const"
    input: "save/RestoreV2/tensor_names"
    input: "save/RestoreV2/shape_and_slices"
    device: "/device:CPU:0"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            unknown_rank: true
          }
          shape {
            unknown_rank: true
          }
        }
      }
    }
    attr {
      key: "dtypes"
      value {
        list {
          type: DT_FLOAT
          type: DT_FLOAT
        }
      }
    }
  }
  node {
    name: "save/Assign"
    op: "Assign"
    input: "Variable"
    input: "save/RestoreV2"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "use_locking"
      value {
        b: true
      }
    }
    attr {
      key: "validate_shape"
      value {
        b: true
      }
    }
  }
  node {
    name: "save/Assign_1"
    op: "Assign"
    input: "Variable_1"
    input: "save/RestoreV2:1"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@Variable_1"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "use_locking"
      value {
        b: true
      }
    }
    attr {
      key: "validate_shape"
      value {
        b: true
      }
    }
  }
  node {
    name: "save/restore_all"
    op: "NoOp"
    input: "^save/Assign"
    input: "^save/Assign_1"
  }
  versions {
    producer: 134
  }
}
saver_def {
  filename_tensor_name: "save/Const:0"
  save_tensor_name: "save/control_dependency:0"
  restore_op_name: "save/restore_all"
  max_to_keep: 5
  keep_checkpoint_every_n_hours: 10000.0
  version: V2
}
GarryLau
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tensorflow模型持久化与恢复
jinying2224的博客
09-15 6408
1.保存model的weights/variables和graph 保存weights/variables为.cpkt文件,主要用到tf.train.Saver类，保存graph为.pb文件，主要用到tf.train.write_graph()函数。 data = np.arange(10,dtype=np.int32) with tf.Session() as sess:
tensorflow 模型保存与加载
spylyt的专栏
05-11 1万+
http://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/ 什么是TF模型：在训练一个神经网络模型后，你会保存这个模型未来使用或部署到产品中。所以，什么是TF模型？TF模型基本包含网络设计或图，与训练得到的网络参数和变量。因此，TF模型具有两个主要文件： a)me
TensorFlow学习笔记（8）--网络模型的保存和读取
热门推荐
对角巷
03-16 5万+
之前的笔记里实现了softmax回归分类、简单的含有一个隐层的神经网络、卷积神经网络等等，但是这些代码在训练完成之后就直接退出了，并没有将训练得到的模型保存下来方便下次直接使用。为了让训练结果可以复用，需要将训练好的神经网络模型持久化，这就是这篇笔记里要写的东西。TensorFlow提供了一个非常简单的API，即tf.train.Saver类来保存和还原一个神经网络模型。下面代码给出了保存Tenso
Tensorflow保存模型详解（进阶版二）：如何保存最近的.ckpt文件 及 如何分开保存.ckpt数据文件和.meta图文件
qq_41368074的博客
04-25 896
在学会了如何有选择的保存变量后，我们来学习如何如何分开保存.ckpt数据文件和.meta图文件 和 如何 保存最近几轮的.ckpt数据文件。 直接上代码： import tensorflow as tf model_dir = 'xx/xxx/' model_name = 'data_model_name' meta_name = 'meta_model_name' #启动一个会话，意...
【Tensorflow】报错：ValueError: At least two variables have the same name
小白兔的窝
06-03 1万+
案例1 问题描述： import tensorflow as tf with tf.Session() as sess: var = tf.Variable(42, name='var') sess.run(tf.global_variables_initializer()) tf.train.export_meta_graph('file.meta') with
TensorFlow入门使用 tf.train.Saver()保存模型
09-20
主要介绍了TensorFlow入门使用 tf.train.Saver()保存模型，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
screensaver.rar_matrix screen saver_screensaver vc_visual c
07-14
VC屏幕保护程序，模拟黑客帝国效果，不过是2d的。
pb.rar_VC screen saver
09-22
这是一个很有意思的VC++屏幕保护源码，用Windows的常用程序图标做为屏幕保护的背景，在屏幕上飘动，刚打开屏幕保护的时候感觉真的特别有创意哦，挺搞笑的。效果演示如图所示。
pb.rar_screen saver_屏保程序
09-24
C#屏保程序 初学者可以看看C#如何编写屏保程序
界面漂亮的VC++屏幕保镖.rar_VC++ sereen saver_屏幕保护
09-24
这个一个漂亮的VC++屏幕保护程序，可以按自己喜欢进行修改。
tensorflow数据结构-MetaGraphDef
写了 = 会了.gif
11-08 2591
tensorflow数据结构 https://github.com/tensorflow/tensorflow/blob/r1.11/tensorflow/core/protobuf/meta_graph.proto 《Tensorflow实战深度学习框架》 ​ Tensorflow的计算图在运行时，以MetaGrapDef的形式实行计算图，并且在进行计算图保存（save）时，将MetaGra...
5.4.2 TensorFlow模型持久化——持久化原理及数据格式
xuesuoziluoshu的博客
06-07 107
5.4.1小节介绍了当调用saver.save函数时，TensorFlow程序会自动生成3个文件。TensorFlow模型的持久化就是通过这3个文件完成的。这一小节将详细介绍这3个文件中保存的内容以及数据格式。在具体介绍每一个文件之前，先简单回顾一下第3章中介绍过得TensorFlow的一些基本概念。TensorFlow是一个通过图的形式来表述计算的编程系统，TensorFlow程序中的所有计算都...
Tensorflow 模型的保存和读取
fsd‘s blog’
06-28 1万+
Tensorflow 模型的保存和读取 tensorflow 保存模型主要有两种途径，一个是通过tf.train.Saver,另一种是通过tf.python.saved_model.builder.SavedModelBuilder 可以保存的内容主要包括Variable/Constant/Placeholder， GraphDef，metaGraph Graph &...
Tensorflow持久化原理及数据格式
随我的博客
11-16 1727
Tensorflow持久化原理及数据格式Tensorflow是一个通过图的形式来表述计算的编程系统，Tensorflow中所有的计算都会被表达成计算图上的节点。Tensorflow通过元图（MetaGraph）来记录计算图中的信息，以及运行计算图中节点所需要的元数据。以下代码给出了MetaGraphDef类型的定义message MetaGraphDef{ MeatInfoDef meta_
TensorFlow - 框架实现中的三种 Graph
yegeli的博客
12-18 732
文章目录TensorFlow - 框架实现中的三种 Graph1. Graph2. GraphDef3. MetaGraph4. Checkpoint5. 总结 TensorFlow - 框架实现中的三种 Graph 图(Graph) 是 TensorFlow 用于表达计算任务的一个核心概念. 从前端(python) 描述神经网络的结构，到后端在多机和分布式系统上部署，到底层 Device(CPU、GPU、TPU)上运行，都是基于图来完成. 然而在实际使用过程中遇到了三对API， [1] - tf.trai
Tensorflow Graphs and Sessions
cx1425924660的博客
08-22 897
Tensorflow Graphs and Sessionsdataflow的优势 dataflow是并行计算的通用编程模型。在dataflow中，节点表示计算单位，边缘表示计算消耗或产生的数据。例如，在TensorFlow图中，tf.matmul操作将对应于具有两个输入边（要乘以的矩阵）和一个输出边（乘法的结果）的单个节点。并行：通过使用显式边来表示操作之间的依赖关系，系统很容易识别并行
tensorflow的pd文件
Loong Cheng的博客
05-12 2649
抄的 TensorFlow模型保存函数 save = tf.train.Saver() ...... saver.save(sess,"checkpoint/model.ckpt",global_step=step) 运行后保存模型，会得到三个文件，例如： model.ckpt-129220.data-00000-of-00001#保存了模型的所有变量的值。 model.ckpt-1...
tf.train.Saver() 与tf.train.import_meta_graph要点
sinat_36618660的博客
08-07 1万+
（一）tf.train.Saver() (1)tf.train.Saver() 是用来保存tensorflow训练的模型的 (2)用来加载参数,注意:只加载存储在data中的权重和偏置项等需要训练的参数,其他一律不加载 包括meta文件中的图也不加载 （二）tf.train.import_meta_graph (1)用来加载meta文件中的图,以及图上定义的结点参数包括权重偏置项等需要训练的参数...
【TensorFlow学习笔记】TensorFlow模型的保存与恢复
筱
10-11 1176
tf.train.Saver 类提供了保存和恢复模型（变量、图、图的元数据）的方法 1、保存模型 tf.train.Saver.save 方法以将变量保存到checkpoint文件中 # 创建 Saver 来管理模型中的所有变量 saver = tf.train.Saver() with tf.Session() as sess: ······ # Save the variable...
saver = tf.train.import_meta_graph(self.meta_path)
最新发布
05-19
这行代码的作用是从一个已经保存的 TensorFlow 模型中导入计算图。具体来说，`tf.train.import_meta_graph` 函数会读取指定的 meta 文件（通常以 `.meta` 为后缀名），并返回一个 `tf.Graph` 对象，该对象表示了之前保存的模型的计算图结构。通过导入计算图，我们可以重用之前训练好的模型，或者在其基础上继续训练模型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值