[op.values() for op in tf.get_default_graph().get_operations()]

model_checkpoint_path= xxx;
all_model_checkpoint_path=xxx;

graph=tf.get_default_graph()
graph_def=graph.as_graph_def()
##
type(graph_def)
>>> tensorflow.core.framework.graph_pb2.GraphDef

##
graph_def
>>>
  node {
    name: "start"
    op: "Const"
    attr {
      key: "dtype"
      value {
        type: DT_INT64
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_INT64
          tensor_shape {
          }
          int64_val: 0
        }
      }
    }
  }
  library {
    function {
      signature {
        name: "_make_dataset_YADYq1MF2s4"
        output_arg {
          name: "modeldataset"
          type: DT_VARIANT
        }
        description: "Factory function for a dataset."
        is_stateful: true
      }
      node_def {
        name: "RangeDataset/start"
        op: "Const"
        attr {
          key: "dtype"
          value {
            type: DT_INT64
          }
        }
        attr {
          key: "value"
          value {
            tensor {
              dtype: DT_INT64
              tensor_shape {
              }
              int64_val: 0
            }
          }
        }
      }
      ret {
        key: "modeldataset"
        value: "ModelDataset:handle:0"
      }
    }
  }
  versions {
    producer: 27
    min_consumer: 12
  }

class Saver()
        def __init__(
                var_list=None,
                reshape=False,
                sharded=False,
                max_to_keep=5, #即保存最近五个checkpoint模型文件
                keep_checkpoint_every_n_hours=10000.0,
                name=None,
                restore_sequentially=False,
                saver_def=None,
                builder=None,
                defer_build=False,
                allow_empty=False,
                write_version=tf.train.SaverDef.V2,
                pad_step_number=False,
                save_relative_paths=False, #为True时，checkpoint文件将不会记录完整的模型路径，而只会仅仅记录模型名字，这方便于将保存下来的模型复制到其他目录并使用的情况；
                filename=None
        )

1. as_saver_def
         返回一个 SaverDef proto
2. build 
3. export_meta_graph  返回一个MetaGraphDef
4. from_proto   从  saver_def 返回以一个Saver built
5. recover_last_checkpoints 从错误中恢复 saver的初始状态
6. restore  --恢复先前保存的参数变量
7. save -- 保存参数变量

save(
    sess,
    save_path,
    global_step=None,
    latest_filename=None,
    meta_graph_suffix='meta',
    write_meta_graph=True,
    write_state=True,
    strip_default_attrs=False
)

8. set_last_checkpoints --
9. set_last_checkpoints_with_time
10. to_proto。将  Saver 转化成 a SaverDef protocol buffer.

with tf.Session() as sess:
  ....
  saver = tf.train.Saver()
  step=0
  while is_runing:
    ...
    step+=1
    saver_path = saver.save(sess, <file_name>, global_step=step)

# saver_path: str <file_name>-<global_step>

# <file_name> 不带文件格式，仅仅是文件名
saver_path= saver.save(sess, 'my-model', global_step=0) 
>>> saver_path: 'my-model-0'
saver_path=saver.save(sess, 'my-model.ckpt', global_step=0) 
>>> saver_path: 'my-model.ckpt-0'
...
saver_path= saver.save(sess, 'my-model', global_step=1000) 
>>> saver_path: 'my-model-1000'

export_dir = ...
...
# 1. 模型构建实例 builder
builder = tf.saved_model.builder.SavedModelBuilder(export_dir)
with tf.Session(graph=tf.Graph()) as sess:
  ...
  # 2. sess 中往builder 添加元图和变量信息
  builder.add_meta_graph_and_variables(sess,
                                       [tf.saved_model.tag_constants.TRAINING],
                                       signature_def_map=foo_signatures,
                                       assets_collection=foo_assets)
...
with tf.Session(graph=tf.Graph()) as sess:
  ...
  builder.add_meta_graph(["bar-tag", "baz-tag"])
...

# 3.builder 持久化保存
builder.save()

add_meta_graph_and_variables(
    sess,
    tags,# tags:list; tags=["tag_string","..",...]
    signature_def_map=None, # signature_def_map:dict{"string_name":(signature_def)} :{string:tuple}
    assets_collection=None,
    legacy_init_op=None,
    clear_devices=False,
    main_op=None,
    strip_default_attrs=False, # 通过 strip_default_attrs=True 确保向前兼容性
    saver=None
)

# sess：用于执行添加元图和变量功能的会话；
# tags：用于保存元图的标签,[str,str..]；
# signature_def_map：用于保存元图的签名；
# assets_collection：使用SavedModel保存的资源集合；
# legacy_init_op：在恢复模型操作后，对Op和Ops组的遗留支持；
# clear_devices：如果默认图形上的设备信息应该被清除，则应该设置为true；
# main_op：在加载图时执行Op或Ops组的操作。请注意，当main_op被指定时，它将在加载恢复op后运行；

signature_def_map={"name":(SignatureDef)}

tf.saved_model.signature_def_utils.build_signature_def(
    inputs={'images': tensor_x},
    outputs={'scores': tensor_y},
    method_name="predict"
    )

# Build the signature_def_map.
# 构建 签名 signature_def_map 
# signature_def_map 主要有两部分组成：
# 1.predict_images 2.serving_default

# *********** 1. 构建分类签名
classification_inputs = tf.saved_model.utils.build_tensor_info(
    serialized_tf_example)
classification_outputs_classes = tf.saved_model.utils.build_tensor_info(
    prediction_classes)
classification_outputs_scores = tf.saved_model.utils.build_tensor_info(values)

classification_signature = (
    tf.saved_model.signature_def_utils.build_signature_def(
        inputs={
            tf.saved_model.signature_constants.CLASSIFY_INPUTS:
                classification_inputs
        },
        outputs={
            tf.saved_model.signature_constants.CLASSIFY_OUTPUT_CLASSES:
                classification_outputs_classes,
            tf.saved_model.signature_constants.CLASSIFY_OUTPUT_SCORES:
                classification_outputs_scores
        },
        method_name=tf.saved_model.signature_constants.CLASSIFY_METHOD_NAME)
        )
# *********** 2. 构建预测签名

tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)
prediction_signature = (
    tf.saved_model.signature_def_utils.build_signature_def(
        inputs={'images': tensor_info_x},
        outputs={'scores': tensor_info_y},
        method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
        )


# 3. 合并模型的签名

model_signature_def_map={
      'predict_images':
          prediction_signature,
      "serving_default":
          classification_signature,
  }

legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op')

builder.add_meta_graph_and_variables(
  sess, [tf.saved_model.tag_constants.SERVING],
  signature_def_map=model_signature_def_map,
  legacy_init_op=legacy_init_op
  )

builder.save()

asset_path_1 = tf.constant("./any_dir/")
tf.add_to_collection(tf.GraphKeys.ASSET_FILEPATHS, asset_path_1)

with tf.Session() as sess:
    sess.run()
    builder.add_meta_graph_and_variables(sess, ["tag1"],
    signature_def_map=...,
    assets_collection=tf.get_collection(tf.GraphKeys.ASSET_FILEPATHS),
    legacy_init_op=...
  )

#Example：
tags=["serve", "serve2","serve3"]
type(tags)
>>>list 

#tags输入list,list 里面是string

~/export_dir
|__assets/
|__assets.extra/
|__saved_model.pd
|__variables
    |__variables.index
    |__variables.data-00000-of-00001

estimator.export_saved_model(
    export_dir_base,
    serving_input_receiver_fn,
    assets_extra=None,
    as_text=False,
    checkpoint_path=None,
    experimental_mode=ModeKeys.PREDICT
)

type(serving_input_receiver_fn)
>>> function 

# 1. 直接通过实例化类定义
ServingInputReceiver=tf.estimator.export.ServingInputReceiver(features, receiver_tensors)
# feature,receiver_tensors 自定义

# 2. 通过函数1定义
ServingInputReceiver=tf.estimator.export.build_raw_serving_input_receiver_fn(features)()
# feature与receiver_tensors相同


# 3. 通过函数2定义
ServingInputReceiver=tf.estimator.export.build_parsing_serving_input_receiver_fn(
    feature_spec,
    default_batch_size=None
)()
# feature 自定义,receiver_tensors定死{'examples': <tf.Tensor 'input_example_tensor_2:0' shape=(?,) dtype=string>}

def serving_input_receiver_fn():
  """An input receiver that expects a serialized tf.Example."""
    # 1. 模型的输入数据 spec
    feature_spec = {
        'foo': tf.FixedLenFeature(...),
        'bar': tf.VarLenFeature(...)
                }

    # 2. 作为服务的模型接收的序列号 tensor
    serialized_tf_example = tf.placeholder(dtype=tf.string,
                                            shape=[default_batch_size],
                                            name='input_example_tensor')

    # 3. 说明数据解析的方式
    features = tf.parse_example(serialized_tf_example, feature_spec)
    # features={"foo":<tf.tensor..>}
    receiver_tensors = {'examples': serialized_tf_example}
    # receiver_tensors ={"examples":<tf.tensor..>}

    #4. 构建服务输入接收器
    ServingInputReceiver=tf.estimator.export.ServingInputReceiver(features, receiver_tensors)

    return ServingInputReceiver



MAX_SEQ_LEN = 128
def serving_input_receiver_fn():
    """An input receiver that expects a serialized tf.Example."""
    reciever_tensors = {
        "input_ids": tf.placeholder(dtype=tf.int64,
                                    shape=[1, MAX_SEQ_LEN])
    }
    features = {
        "input_ids": reciever_tensors['input_ids'],
        "input_mask": 1 - tf.cast(tf.equal(reciever_tensors['input_ids'], 0), dtype=tf.int64),
        "segment_ids": tf.zeros(dtype=tf.int64,
                                shape=[1, MAX_SEQ_LEN])
    }
    return tf.estimator.export.ServingInputReceiver(features, reciever_tensors)

estimator._export_to_tpu = False
estimator.export_savedmodel(dir_path, serving_input_receiver_fn)

def serving_input_fn():
  feature_spec = {
      "unique_ids": tf.FixedLenFeature([MAX_SEQ_LENGTH], tf.int64),
      "input_ids" : tf.FixedLenFeature([MAX_SEQ_LENGTH], tf.int64),
      "input_mask" : tf.FixedLenFeature([MAX_SEQ_LENGTH], tf.int64),
      "segment_ids" : tf.FixedLenFeature([MAX_SEQ_LENGTH], tf.int64),
      "label_ids" :  tf.FixedLenFeature([], tf.int64)

  }
  serialized_tf_example = tf.placeholder(dtype=tf.string,shape=[None],name='input_example_tensor')
  features = tf.parse_example(serialized_tf_example, feature_spec)
  return tf.estimator.export.build_raw_serving_input_receiver_fn(features)

_assets_extra={'my_asset_file.txt': '/path/to/my_asset_file.txt'}

./export_model
|_assets
| |_ my_asset_file.txt
|_varible
| |_...data
|_model.pd

checkpoint_str=estimator.latest_checkpoint()

saver = tf.train.import_meta_graph(checkpoint_str + '.meta', clear_devices=True)

with tf.Session() as sess:
  # 1.恢复图并得到数据
  saver.restore(sess, checkpoint_str) 
  # 2.build 
  builder.add_meta_graph_and_variables(sess, ["tag1"],
  signature_def_map=model_signature_def_map1,
  legacy_init_op=legacy_init_op)

with tf.Session() as sess:
  # 1.恢复图并得到数据
  saver.restore(sess, checkpoint_str) 
  # 2.build 
  builder.add_meta_graph_and_variables(sess, ["tag2"],
  signature_def_map=model_signature_def_map2,
  legacy_init_op=legacy_init_op)

builder.saver

tf.saved_model.simple_save(
    sess,
    export_path,
    inputs={'input_image': model.input},
    outputs={t.name:t for t in model.outputs}
    )

# model.input: tensor 
# model.outputs:list 
# t:tensor 

tf.keras.experimental.export_saved_model(
    model,
    saved_model_path,
    custom_objects=None,
    as_text=False,
    input_signature=None,
    serving_only=False
)


tf.keras.models.save_model(
    model,
    filepath,
    overwrite=True,
    include_optimizer=True,
    save_format=None, # "tf" Savedmodel
    signatures=None,
    options=None
)

bazel build - c opt //tensorflow serving / example: mnist_saved_model
bazel-bin / tensorflow_serving / example / mnist_saved_model/tmp/mnist_model 

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

def freeze_graph(input_checkpoint,output_graph):
    '''
    :param input_checkpoint:
    :param output_graph: PB模型保存路径
    :return:
    '''
    # checkpoint = tf.train.get_checkpoint_state(model_folder) #检查目录下ckpt文件状态是否可用
    # input_checkpoint = checkpoint.model_checkpoint_path #得ckpt文件路径

    # 指定输出的节点名称,该节点名称必须是原模型中存在的节点
    output_node_names = "InceptionV3/Logits/SpatialSqueeze"
    saver = tf.train.import_meta_graph(input_checkpoint + '.meta', clear_devices=True)

    with tf.Session() as sess:
        saver.restore(sess, input_checkpoint) #恢复图并得到数据
        output_graph_def = graph_util.convert_variables_to_constants(  # 模型持久化，将变量值固定
            sess=sess,
            input_graph_def=sess.graph_def,# 等于:sess.graph_def
            output_node_names=output_node_names.split(","))# 如果有多个输出节点，以逗号隔开

        with tf.gfile.GFile(output_graph, "wb") as f: #保存模型
            f.write(output_graph_def.SerializeToString()) #序列化输出
        print("%d ops in the final graph." % len(output_graph_def.node)) #得到

# 1 创建转换器实例Converter
converter=tf.lite.TocoConverter.from_saved_model(export_path)
# 2. 实例设置
converter.post_training_quantize=True
# 3. 生成模型
tflite_quantized_model=converter.convert()
# 4. 模型持久化
with open("./export_model/quantized_model.tflite", "wb") as f:
    f.write(tflite_quantized_model)

converter = tf.lite.TFLiteConverter.from_keras_model_file()
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

dir (tf.lite.TFLiteConverter)
>>>
 'from_frozen_graph',
 'from_keras_model_file',
 'from_saved_model',
 'from_session',
 ...

saver=tf.train.import_meta_graph("save/model.ckpt.meta")
with tf.Session() as sess:
  saver.restore(sess,"output/model.ckpt")
  sess.run()

tf.contrib.resampler()
saver=tf.train.import_meta_graph("save/model.ckpt.meta")
with tf.Session() as sess:
  saver.restore(sess,"save/model.ckpt")
  sess.run()

model_file=tf.train.latest_checkpoint(dir_path)

model_file
>>>  str
"output/model.ckpt"

export_dir = ...
...
with tf.Session(graph=tf.Graph()) as sess:
  tf.saved_model.loader.load(sess, [tag_constants.TRAINING], export_dir)
  ...

new_model = tf.keras.experimental.load_from_saved_model(path)
new_model.summary()

# 1. tf.io.gfile.GFile 打开pb文件
model_f = tf.io.gfile.GFile("./Test/model.pb", mode='rb')
# 2 创建一个空的graph_def 类
graph_def = tf.GraphDef()
# 3. 将 MetaGraph的二进制文件调入 空的graph_def，加载节点(Node)信息
graph_def.ParseFromString(model_f.read())  ##二进制调用实际上是 ParseFromString
# 4. 将graph_def调入到现在的graph 中 通过return_elements 确定返回的 op /tensor
tensor_c = tf.graph_util.import_graph_def(graph_def, return_elements=["add2:0"])

with tf.Session as sess:
  sess.run(tensor_c)

input_checkpoint="./model/model.ckpt-0"
output_graph="./model/saved_model.pd"

def freeze_graph(input_checkpoint,output_graph):
    '''
    Args:
      param input_checkpoint:
      param output_graph: PB模型保存路径
    Returns:
      None
    '''
    # checkpoint = tf.train.get_checkpoint_state(model_folder) #检查目录下ckpt文件状态是否可用
    # input_checkpoint = checkpoint.model_checkpoint_path #得ckpt文件路径

    # 指定输出的节点名称,该节点名称必须是原模型中存在的节点
    output_node_names = "InceptionV3/Logits/SpatialSqueeze"
    saver = tf.train.import_meta_graph(input_checkpoint + '.meta', clear_devices=True)

    with tf.Session() as sess:
        saver.restore(sess, input_checkpoint) #恢复图并得到数据
        output_graph_def = graph_util.convert_variables_to_constants(  # 模型持久化，将变量值固定
            sess=sess,
            input_graph_def=sess.graph_def,# 等于:sess.graph_def
            output_node_names=output_node_names.split(","))# 如果有多个输出节点，以逗号隔开

        with tf.gfile.GFile(output_graph, "wb") as f: #保存模型
            f.write(output_graph_def.SerializeToString()) #序列化输出
        print("%d ops in the final graph." % len(output_graph_def.node)) #得到当前图有几个操作节点

def freeze_session(session, keep_var_names=None, output_names=None, clear_devices=True):
    """
    Freezes the state of a session into a prunned computation graph.
Creates a new computation graph where variable nodes are replaced by
    constants taking their current value in the session. The new graph will be
    prunned so subgraphs that are not neccesary to compute the requested
    outputs are removed.
    @param session The TensorFlow session to be frozen.
    @param keep_var_names A list of variable names that should not be frozen,
                          or None to freeze all the variables in the graph.
    @param output_names Names of the relevant graph outputs.
    @param clear_devices Remove the device directives from the graph for better portability.
    @return The frozen graph definition.
    """
    from tensorflow.python.framework.graph_util import convert_variables_to_constants
    graph = session.graph
    with graph.as_default():
        freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference(keep_var_names or []))
        output_names = output_names or []
        output_names += [v.op.name for v in tf.global_variables()]
        input_graph_def = graph.as_graph_def()
        if clear_devices:
            for node in input_graph_def.node:
                node.device = ""
        frozen_graph = convert_variables_to_constants(session, input_graph_def,
                                                      output_names, freeze_var_names)
        return frozen_graph

input_fld = sys.path[0]
weight_file = 'vgg16_without_dropout.h5'
output_graph_name = 'vgg16_without_dropout.pb'
output_fld = input_fld + '/tensorflow_model/'
if not os.path.isdir(output_fld):
    os.mkdir(output_fld)
weight_file_path = osp.join(input_fld, weight_file)
K.set_learning_phase(0)
net_model = load_model(weight_file_path)
print('input is :', net_model.input.name)
print ('output is:', net_model.output.name)
sess = K.get_session()
frozen_graph = freeze_session(K.get_session(), output_names=[net_model.output.op.name])
from tensorflow.python.framework import graph_io
graph_io.write_graph(frozen_graph, output_fld, output_graph_name, as_text=False)
print('saved the constant graph (ready for inference) at: ', os.join(output_fld, output_graph_name))

full_model = tf.function(lambda x: model(x))
# full_model = tf.function(lambda Input: model(Input))
full_model = full_model.get_concrete_function(tf.TensorSpec(model.inputs[0].shape, model.inputs[0].dtype))

frozen_func = convert_variables_to_constants_v2(full_model)
frozen_func.graph.as_graph_def()

layers = [op.name for op in frozen_func.graph.get_operations()]
print("-" * 50)
print("Frozen model layers: ")
for layer in layers:
    print(layer)

print("-" * 50)
print("Frozen model inputs: ")
print(frozen_func.inputs)
print("Frozen model outputs: ")
print(frozen_func.outputs)

# Save frozen graph from frozen ConcreteFunction to hard drive
tf.io.write_graph(graph_or_graph_def=frozen_func.graph,
                  logdir="./model",
                  name="model.pb",
                  as_text=False)

import tensorflow as tf
from tensorflow.python.saved_model import signature_constants
from tensorflow.python.saved_model import tag_constants

export_dir = './saved'
graph_pb = 'my_quant_graph.pb'

builder = tf.saved_model.builder.SavedModelBuilder(export_dir)

with tf.gfile.GFile(graph_pb, "rb") as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())

sigs = {}

with tf.Session(graph=tf.Graph()) as sess:
    # name="" is important to ensure we don't get spurious prefixing
    tf.import_graph_def(graph_def, name="")
    g = tf.get_default_graph()
    inp = g.get_tensor_by_name("real_A_and_B_images:0")
    out = g.get_tensor_by_name("generator/Tanh:0")

    sigs[signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY] = \
        tf.saved_model.signature_def_utils.predict_signature_def(
            {"in": inp}, {"out": out})

    builder.add_meta_graph_and_variables(sess,
                                         [tag_constants.SERVING],
                                         signature_def_map=sigs)

builder.save()