def from_tensorflow_frozen_model(frozen_file,
output_nodes=[],
preprocessor=None,
**kwargs):
"""
Converts a TensorFlow frozen graph to a UFF model.
Args:
frozen_file (str): The path to the frozen TensorFlow graph to convert.
output_nodes (list(str)): The names of the outputs of the graph. If not provided, graphsurgeon is used to automatically deduce output nodes.
output_filename (str): The UFF file to write.
preprocessor (str): The path to a preprocessing script that will be executed before the converter. This script should define a ``preprocess`` function which accepts a graphsurgeon DynamicGraph and modifies it in place.
write_preprocessed (bool): If set to True, the converter will write out the preprocessed graph as well as a TensorBoard visualization. Must be used in conjunction with output_filename.
text (bool): If set to True, the converter will also write out a human readable UFF file. Must be used in conjunction with output_filename.
quiet (bool): If set to True, suppresses informational messages. Errors may still be printed.
list_nodes (bool): If set to True, the converter displays a list of all nodes present in the graph.
debug_mode (bool): If set to True, the converter prints verbose debug messages.
return_graph_info (bool): If set to True, this function returns the graph input and output nodes in addition to the serialized UFF graph.
Returns:
serialized UFF MetaGraph (str)
OR, if return_graph_info is set to True,
serialized UFF MetaGraph (str), graph inputs (list(tensorflow.NodeDef)), graph outputs (list(tensorflow.NodeDef))
"""
graphdef = GraphDef()
with tf.io.gfile.GFile(frozen_file, "rb") as frozen_pb:
graphdef.ParseFromString(frozen_pb.read())
return from_tensorflow(graphdef, output_nodes, preprocessor, **kwargs)
def main(unused_args):
# params
in_path = FLAGS.input # type: str
in_is_text = FLAGS.text_proto # type: bool
out_path = FLAGS.output # type: str
skip = FLAGS.skip # type: list
output_nodes = FLAGS.output_node # type: list
# validate param
if in_path is None or len(in_path) == 0:
raise RuntimeError("in_path must be provided")
if out_path is None or len(out_path) == 0:
raise RuntimeError("output must be provided")
# read graph
in_graph = GraphDef()
if in_is_text:
with open(in_path, "r") as fp:
Parse(fp.read(), in_graph)
else:
with open(in_path, "rb") as fp:
in_graph.ParseFromString(fp.read())
# quantize
quantized = quantize_graph_def(in_graph, set(skip), output_nodes)
# write
with open(out_path, "wb") as fp:
fp.write(quantized.SerializeToString())
def load_graphdef_from_pb(pb_file):
graph = GraphDef()
with open(pb_file, 'rb') as f:
content = f.read()
try:
graph.ParseFromString(content)
except Exception as e:
raise IOError("Can't parse file {}: {}".format(pb_file, str(e)))
return graph
def do_quantize_training_on_graphdef(input_graph, num_bits):
from tensorflow.core.framework.graph_pb2 import GraphDef
from tensorflow.python.framework import errors
with errors.raise_exception_on_not_ok_status() as status:
graph = GraphDef()
graph.ParseFromString(
DoQuantizeTrainingOnGraphDefHelper(input_graph.SerializeToString(),
num_bits, status))
return graph
def merge_partitioned_graphs_from_pb(pb_files):
graphs = []
for pb_file in pb_files:
graph = GraphDef()
with open(pb_file, 'rb') as f:
content = f.read()
try:
graph.ParseFromString(content)
graphs.append(graph)
except Exception as e:
raise IOError("Can't parse file {}: {}.".format(pb_file, str(e)))
return merge_partitioned_graphs(graphs)
def __init__(self, pb_path):
"""
Creates tf function for neural network.
"""
with open(pb_path, "rb") as pb:
graph_def = GraphDef()
graph_def.ParseFromString(pb.read())
@tf.function
def network_function(I0, I1, I2, I3, I4):
inputs = {
"Placeholder:0": I0,
"Placeholder_1:0": I1,
"Placeholder_2:0": I2,
"Placeholder_3:0": I3,
"Placeholder_4:0": I4
}
alpha, background = tf.graph_util.import_graph_def(
graph_def, input_map=inputs, return_elements=OUTPUT_NAMES)
return alpha, background
self._network = network_function