TensorFlow 生成 .ckpt 和 .pb

From what I‘ve gathered so far, there are several different ways of dumping a TensorFlow graph
into a file and then loading it into another program, but I haven‘t been able to find clear examples/information on how they work. What I already know is this:

1. Save the model‘s variables into a checkpoint file (.ckpt) using a tf.train.Saver() and restore them later (source)
2. Save a model into a .pb file and load it back in using tf.import_graph_def() (source)
3. Load in a model from a .pb file, retrain it, and dump it into a new .pb file using Bazel (source)
4. Freeze the graph to save the graph and weights together (source)
5. Use as_graph_def() to save the model, and for weights/variables, map them into constants (source)

However, I haven‘t been able to clear up several questions regarding these different methods:

1. Regarding checkpoint files, do they only save the trained weights of a model? Could checkpoint files be loaded into a new program, and be used to run the model, or do they simply serve as ways to save the weights in a model at a certain time/stage?
2. Regarding Regarding
Bazel, can it only save into/load from .pb files for retraining? Is
there a simple Bazel command just to dump a graph into a .pb?
3. Regarding freezing, can a frozen graph be loaded in using The
Android demo for TensorFlow loads in Google‘s Inception model from a
.pb file. If I wanted to substitute my own .pb file, how would I go
about doing that? Would I need to change
any native code/methods?
4. In general, what exactly is the difference between all these methods? Or more broadly, what is the difference between 
In short, what I‘m looking for is a method to save both a graph (as in,
the various operations and such) and its weights/variables into a file,
which can then be used to load the graph and weights into another
program, for use (not necessarily continuing/retraining).

   Documentation about this topic isn‘t very straightforward, so any answers/information would be greatly appreciated.

There are many ways to approach the problem of saving a model in TensorFlow, which can make it a bit confusing. The documentation on this topic is taking shape, but doesn‘t cover all of the details in your question. Taking each of your sub-questions in turn:

1. The checkpoint files (produced e.g. by calling saver.save() on a tf.train.Saver object) contain only the weights, and any other variables defined in the same program. To use them in another program, you must re-create the associated graph structure (e.g. by running code to build it again, or calling saver.save() also produces a file containing athe
tutorial for more details.

   


2. tf.train.write_graph() only writes the graph structure; not the weights.

3. Bazel is unrelated to reading or writing TensorFlow graphs. (Perhaps I misunderstand your question: feel free to clarify it in a comment.)
4. A frozen graph can be loaded using

   
The main change would be to update the names of the tensor(s) that are
fed into the model, and the names of the tensor(s) that are fetched from
the model. In the TensorFlow Android demo, this would correspond to the outputName strings
that are passed to 

   
The GraphDef is
the program structure, which typically does not change through the
training process. The checkpoint is a snapshot of the state of a
training process, which typically changes at every step of the training
process. As a result, TensorFlow uses different storage
formats for these types of data, and the low-level API provides
different ways to save and load them. Higher-level libraries, such as
the Keras,
and skflow build on these mechanisms to provide
more convenient ways to save and restore an entire model.