def __init__(self, X, KEEP, view, name, dir_path, node='logits:0', softmax=True): self.name = name self.view = view print dir_path paths = glob(os.path.join(dir_path, '*.meta')) print paths assert len(paths) == 1 path = os.path.splitext(paths[0])[0] mg = meta_graph.read_meta_graph_file(path + '.meta') if KEEP is None: fts, = tf.import_graph_def(mg.graph_def, name=name, input_map={'images:0': X}, return_elements=[node]) else: fts, = tf.import_graph_def(mg.graph_def, name=name, input_map={ 'images:0': X, 'keep:0': KEEP }, return_elements=[node]) if softmax: fts = logits2prob(fts) self.fts = fts self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path) pass
def initialize_variables(self, save_file=None): self.session.run(tf.global_variables_initializer()) if save_file is not None: try: self.saver.restore(self.session, save_file) except: # some wizardry here... basically, only restore variables # that are in the save file; otherwise, initialize them normally. from tensorflow.python.framework import meta_graph meta_graph_def = meta_graph.read_meta_graph_file(save_file + '.meta') stored_var_names = set([ n.name for n in meta_graph_def.graph_def.node if n.op == 'VariableV2' ]) print(stored_var_names) var_list = [ v for v in tf.global_variables() if v.op.name in stored_var_names ] # initialize all of the variables self.session.run(tf.global_variables_initializer()) # then overwrite the ones we have in the save file # by using a throwaway saver, saved models are automatically # "upgraded" to the latest graph definition. throwaway_saver = tf.train.Saver(var_list=var_list) throwaway_saver.restore(self.session, save_file)
def convert(load_file, dest_file): from tensorflow.python.framework import meta_graph features, labels = dual_net.get_inference_input() dual_net.model_fn(features, labels, tf.estimator.ModeKeys.PREDICT) sess = tf.Session() # retrieve the global step as a python value ckpt = tf.train.load_checkpoint(load_file) global_step_value = ckpt.get_tensor('global_step') # restore all saved weights, except global_step meta_graph_def = meta_graph.read_meta_graph_file(load_file + '.meta') stored_var_names = set([ n.name for n in meta_graph_def.graph_def.node if n.op == 'VariableV2' ]) stored_var_names.remove('global_step') var_list = [ v for v in tf.global_variables() if v.op.name in stored_var_names ] tf.train.Saver(var_list=var_list).restore(sess, load_file) # manually set the global step global_step_tensor = tf.train.get_or_create_global_step() assign_op = tf.assign(global_step_tensor, global_step_value) sess.run(assign_op) # export a new savedmodel that has the right global step type tf.train.Saver().save(sess, dest_file) sess.close() tf.reset_default_graph()
def test_save_variable_devices(self, save_devices, meta_graph_only): context._reset_context() cpus = context.context().list_physical_devices("CPU") if len(cpus) == 1: context.context().set_logical_device_configuration( cpus[0], [ context.LogicalDeviceConfiguration(), context.LogicalDeviceConfiguration() ]) context.ensure_initialized() root = tracking.AutoTrackable() with ops.device("CPU:0"): root.v0 = variables.Variable(1., name="v0") with ops.device("CPU:1"): root.v1 = variables.Variable(1., name="v1") options = save_options.SaveOptions( experimental_variable_policy=save_devices) file_name = os.path.join(self.get_temp_dir(), "saved_model") if meta_graph_only: save.export_meta_graph(obj=root, filename=file_name, options=options) else: save.save(obj=root, export_dir=file_name, options=options) meta = None if meta_graph_only: meta = meta_graph.read_meta_graph_file(file_name) else: meta = loader_impl.parse_saved_model(file_name).meta_graphs[0] # Check devices in meta graph nodes. graph_def = meta.graph_def v0 = next((n for n in graph_def.node if n.name == "v0"), None) v1 = next((n for n in graph_def.node if n.name == "v1"), None) self.assertIsNotNone(v0) self.assertIsNotNone(v1) if save_devices == save_options.VariablePolicy.SAVE_VARIABLE_DEVICES: self.assertIn("CPU:0", v0.device) self.assertIn("CPU:1", v1.device) else: self.assertEmpty(v0.device) self.assertEmpty(v1.device) # Check devices in object graph nodes. object_graph_def = meta.object_graph_def v0 = next((n.variable for n in object_graph_def.nodes if n.HasField("variable") and n.variable.name == "v0"), None) v1 = next((n.variable for n in object_graph_def.nodes if n.HasField("variable") and n.variable.name == "v1"), None) self.assertIsNotNone(v0) self.assertIsNotNone(v1) if save_devices == save_options.VariablePolicy.SAVE_VARIABLE_DEVICES: self.assertIn("CPU:0", v0.device) self.assertIn("CPU:1", v1.device) else: self.assertEmpty(v0.device) self.assertEmpty(v1.device)
def main (_): logging.basicConfig() X = tf.placeholder(tf.float32, shape=(None, None, None, 3)) mg = meta_graph.read_meta_graph_file(FLAGS.model + '.meta') Y, = tf.import_graph_def(mg.graph_def, name='enhance', input_map={'lo_res:0':X}, return_elements=['hi_res:0']) saver = tf.train.Saver(saver_def=mg.saver_def, name='enhance') init = tf.global_variables_initializer() sess_config = tf.ConfigProto() with tf.Session(config=sess_config) as sess: sess.run(init) saver.restore(sess, FLAGS.model) cap = cv2.VideoCapture(FLAGS.input) fourcc = cv2.cv.CV_FOURCC(*'XVID') out = cv2.VideoWriter(FLAGS.output, fourcc, 25, (640*2, 360)) C = 0 while cap.isOpened(): print('%f' % (C/25,)) ret, frame = cap.read() orig = frame.astype(np.float32) ks = FLAGS.blur * 2 + 1 frame = cv2.GaussianBlur(orig, (ks, ks), FLAGS.blur) frame = np.expand_dims(frame, 0) frame, = sess.run([Y], feed_dict={X: frame}) both = np.concatenate((orig, frame[0]), axis=1) out.write(both.astype(np.uint8)) C += 1 pass
def test_expand_distributed_variables(self, expand_strategy, policy): # 1. Create a context with both CPU:0 and CPU:1. context._reset_context() cpus = context.context().list_physical_devices("CPU") if len(cpus) == 1: context.context().set_logical_device_configuration( cpus[0], [ context.LogicalDeviceConfiguration(), context.LogicalDeviceConfiguration() ]) context.ensure_initialized() # 2. Create and save a model under a mirrored strategy. file_name = os.path.join(self.get_temp_dir(), "saved_model.pb") strategy = mirrored_strategy.MirroredStrategy(["CPU:0", "CPU:1"]) strategy.extended._use_var_policy = policy with strategy.scope(): root = tracking.AutoTrackable() root.v = variables.Variable([1., 1.], name="v") @def_function.function(input_signature=[]) def f(): root.v.assign([2., 2.]) root.f = f save.export_meta_graph( obj=root, filename=file_name, options=save_options.SaveOptions( experimental_variable_policy=expand_strategy)) # 3. Read the output file and test behavior. meta_graph_def = meta_graph.read_meta_graph_file(file_name) object_graph = meta_graph_def.object_graph_def graph_def = meta_graph_def.graph_def v = next((n.variable for n in object_graph.nodes if n.HasField("variable") and n.variable.name == "v"), None) saved_function = next((f for f in graph_def.library.function if "inference_f_" in f.signature.name), None) self.assertIsNotNone(saved_function) if (expand_strategy == save_options.VariablePolicy.EXPAND_DISTRIBUTED_VARIABLES): # experimental_save_variable_devices should have been automatically set. self.assertIn("CPU:0", v.device) components = v.experimental_distributed_variable_components self.assertLen(components, 2) v0 = next((x for x in components if x.name == "v"), None) v1 = next((x for x in components if x.name == "v/replica_1"), None) self.assertIsNotNone(v0) self.assertIsNotNone(v1) self.assertIn("CPU:0", v0.device) self.assertIn("CPU:1", v1.device) self.assertLen(saved_function.signature.input_arg, 2) else: self.assertEmpty(v.device) self.assertEmpty(v.experimental_distributed_variable_components) self.assertLen(saved_function.signature.input_arg, 1)
def main(): meta_graph.read_meta_graph_file("/tmp/tf_training/ckpt/rjmodel.ckpt.meta") g = tf.MetaGraphDef() g.ParseFromString( open("/tmp/tf_training/ckpt/rjmodel.ckpt.meta", "rb").read()) #print("GraphDef from meta_graph_file:", g.graph_def) g = tf.GraphDef() g.ParseFromString(open("/tmp/stylize_quantized.pb", "rb").read()) print("GraphDef: ", g) #[n for n in g.node if n.name.find("input") != -1] # same for output or any other node you want to make sure is ok saved_model = saved_model_pb2.SavedModel() saved_model.ParseFromString( open("/tmp/SavedModel/saved_model.pb", "rb").read()) print("saved_model parsed", saved_model.saved_model_schema_version, len(saved_model.meta_graphs)) print("GraphDef from SavedModel file:", saved_model.meta_graphs[0].graph_def)
def __init__(self, X, path, name): mg = meta_graph.read_meta_graph_file(path + '.meta') is_training = tf.constant(False) self.logits, = \ tf.import_graph_def(mg.graph_def, name=name, input_map={'images:0': X, 'is_training:0': is_training}, return_elements=['logits:0']) self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path) pass
def _load_saved_model_from_session_bundle_path(export_dir, target, config): """Load legacy TF Exporter/SessionBundle checkpoint. Args: export_dir: the directory that contains files exported by exporter. target: The execution engine to connect to. See target in tf.compat.v1.Session() config: A ConfigProto proto with configuration options. See config in tf.compat.v1.Session() Returns: session: a tensorflow session created from the variable files. metagraph_def: The `MetaGraphDef` protocol buffer loaded in the provided session. This can be used to further extract signature-defs, collection-defs, etc. This model is up-converted to SavedModel format. Specifically, metagraph_def SignatureDef field is populated with Signatures converted from legacy signatures contained within CollectionDef Raises: RuntimeError: If metagraph already contains signature_def and cannot be up-converted. """ meta_graph_filename = os.path.join( export_dir, legacy_constants.META_GRAPH_DEF_FILENAME) metagraph_def = meta_graph.read_meta_graph_file(meta_graph_filename) if metagraph_def.signature_def: raise RuntimeError("Legacy graph contains signature def, unable to " "up-convert.") # Add SignatureDef to metagraph. default_signature_def, named_signature_def = ( _convert_signatures_to_signature_defs(metagraph_def)) if default_signature_def: metagraph_def.signature_def[ signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY].CopyFrom( default_signature_def) if named_signature_def: signature_def_key = signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY if default_signature_def: signature_def_key += "_from_named" metagraph_def.signature_def[signature_def_key].CopyFrom( named_signature_def) # We cannot just output session we loaded with older metagraph_def and # up-converted metagraph definition because Session has an internal object of # type Graph which is populated from meta_graph_def. If we do not create # session with our new meta_graph_def, then Graph will be out of sync with # meta_graph_def. sess, metagraph_def = session_bundle.load_session_bundle_from_path( export_dir, target, config, meta_graph_def=metagraph_def) return sess, metagraph_def
def testConvertSignaturesToSignatureDefs(self): base_path = tf.test.test_src_dir_path(SESSION_BUNDLE_PATH) meta_graph_filename = os.path.join(base_path, constants.META_GRAPH_DEF_FILENAME) metagraph_def = meta_graph.read_meta_graph_file(meta_graph_filename) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(default_signature_def.method_name, signature_constants.REGRESS_METHOD_NAME) self.assertEqual(len(default_signature_def.inputs), 1) self.assertEqual(len(default_signature_def.outputs), 1) self.assertProtoEquals( default_signature_def.inputs[signature_constants.REGRESS_INPUTS], meta_graph_pb2.TensorInfo(name="tf_example:0")) self.assertProtoEquals( default_signature_def.outputs[signature_constants.REGRESS_OUTPUTS], meta_graph_pb2.TensorInfo(name="Identity:0")) self.assertEqual(named_signature_def.method_name, signature_constants.PREDICT_METHOD_NAME) self.assertEqual(len(named_signature_def.inputs), 1) self.assertEqual(len(named_signature_def.outputs), 1) self.assertProtoEquals( named_signature_def.inputs["x"], meta_graph_pb2.TensorInfo(name="x:0")) self.assertProtoEquals( named_signature_def.outputs["y"], meta_graph_pb2.TensorInfo(name="y:0")) # Now try default signature only collection_def = metagraph_def.collection_def signatures_proto = manifest_pb2.Signatures() signatures = collection_def[constants.SIGNATURES_KEY].any_list.value[0] signatures.Unpack(signatures_proto) named_only_signatures_proto = manifest_pb2.Signatures() named_only_signatures_proto.CopyFrom(signatures_proto) default_only_signatures_proto = manifest_pb2.Signatures() default_only_signatures_proto.CopyFrom(signatures_proto) default_only_signatures_proto.named_signatures.clear() default_only_signatures_proto.ClearField("named_signatures") metagraph_def.collection_def[constants.SIGNATURES_KEY].any_list.value[ 0].Pack(default_only_signatures_proto) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(default_signature_def.method_name, signature_constants.REGRESS_METHOD_NAME) self.assertEqual(named_signature_def, None) named_only_signatures_proto.ClearField("default_signature") metagraph_def.collection_def[constants.SIGNATURES_KEY].any_list.value[ 0].Pack(named_only_signatures_proto) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(named_signature_def.method_name, signature_constants.PREDICT_METHOD_NAME) self.assertEqual(default_signature_def, None)
def testConvertSignaturesToSignatureDefs(self): base_path = tf.test.test_src_dir_path(SESSION_BUNDLE_PATH) meta_graph_filename = os.path.join(base_path, constants.META_GRAPH_DEF_FILENAME) metagraph_def = meta_graph.read_meta_graph_file(meta_graph_filename) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(default_signature_def.method_name, signature_constants.REGRESS_METHOD_NAME) self.assertEqual(len(default_signature_def.inputs), 1) self.assertEqual(len(default_signature_def.outputs), 1) self.assertProtoEquals( default_signature_def.inputs[signature_constants.REGRESS_INPUTS], meta_graph_pb2.TensorInfo(name="tf_example:0")) self.assertProtoEquals( default_signature_def.outputs[signature_constants.REGRESS_OUTPUTS], meta_graph_pb2.TensorInfo(name="Identity:0")) self.assertEqual(named_signature_def.method_name, signature_constants.PREDICT_METHOD_NAME) self.assertEqual(len(named_signature_def.inputs), 1) self.assertEqual(len(named_signature_def.outputs), 1) self.assertProtoEquals(named_signature_def.inputs["x"], meta_graph_pb2.TensorInfo(name="x:0")) self.assertProtoEquals(named_signature_def.outputs["y"], meta_graph_pb2.TensorInfo(name="y:0")) # Now try default signature only collection_def = metagraph_def.collection_def signatures_proto = manifest_pb2.Signatures() signatures = collection_def[constants.SIGNATURES_KEY].any_list.value[0] signatures.Unpack(signatures_proto) named_only_signatures_proto = manifest_pb2.Signatures() named_only_signatures_proto.CopyFrom(signatures_proto) default_only_signatures_proto = manifest_pb2.Signatures() default_only_signatures_proto.CopyFrom(signatures_proto) default_only_signatures_proto.named_signatures.clear() default_only_signatures_proto.ClearField("named_signatures") metagraph_def.collection_def[constants.SIGNATURES_KEY].any_list.value[ 0].Pack(default_only_signatures_proto) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(default_signature_def.method_name, signature_constants.REGRESS_METHOD_NAME) self.assertEqual(named_signature_def, None) named_only_signatures_proto.ClearField("default_signature") metagraph_def.collection_def[constants.SIGNATURES_KEY].any_list.value[ 0].Pack(named_only_signatures_proto) default_signature_def, named_signature_def = ( bundle_shim._convert_signatures_to_signature_defs(metagraph_def)) self.assertEqual(named_signature_def.method_name, signature_constants.PREDICT_METHOD_NAME) self.assertEqual(default_signature_def, None)
def __init__(self, path, image_size, name='xxx'): images = tf.placeholder(tf.uint8, shape=(None, image_size, image_size, 3), name="images") batch = (tf.cast(images, tf.float32) - 127.5) / 128.0 self.images = images is_training = tf.constant(False) mg = meta_graph.read_meta_graph_file(path + '.meta') self.embeddings, = \ tf.import_graph_def(mg.graph_def, name=name, input_map={'image_batch:0': batch, 'phase_train': is_training}, return_elements=['embeddings:0']) self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path)
def _load_saved_model_from_session_bundle_path(export_dir, target, config): """Load legacy TF Exporter/SessionBundle checkpoint. Args: export_dir: the directory that contains files exported by exporter. target: The execution engine to connect to. See target in tf.compat.v1.Session() config: A ConfigProto proto with configuration options. See config in tf.compat.v1.Session() Returns: session: a tensorflow session created from the variable files. metagraph_def: The `MetaGraphDef` protocol buffer loaded in the provided session. This can be used to further extract signature-defs, collection-defs, etc. This model is up-converted to SavedModel format. Specifically, metagraph_def SignatureDef field is populated with Signatures converted from legacy signatures contained within CollectionDef Raises: RuntimeError: If metagraph already contains signature_def and cannot be up-converted. """ meta_graph_filename = os.path.join(export_dir, legacy_constants.META_GRAPH_DEF_FILENAME) metagraph_def = meta_graph.read_meta_graph_file(meta_graph_filename) if metagraph_def.signature_def: raise RuntimeError("Legacy graph contains signature def, unable to " "up-convert.") # Add SignatureDef to metagraph. default_signature_def, named_signature_def = ( _convert_signatures_to_signature_defs(metagraph_def)) if default_signature_def: metagraph_def.signature_def[ signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY].CopyFrom( default_signature_def) if named_signature_def: signature_def_key = signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY if default_signature_def: signature_def_key += "_from_named" metagraph_def.signature_def[signature_def_key].CopyFrom(named_signature_def) # We cannot just output session we loaded with older metagraph_def and # up-converted metagraph definition because Session has an internal object of # type Graph which is populated from meta_graph_def. If we do not create # session with our new meta_graph_def, then Graph will be out of sync with # meta_graph_def. sess, metagraph_def = session_bundle.load_session_bundle_from_path( export_dir, target, config, meta_graph_def=metagraph_def) return sess, metagraph_def
def __init__ (self, X, anchor_th, nms_max, nms_th, is_training, path, name): mg = meta_graph.read_meta_graph_file(path + '.meta') self.predictions = tf.import_graph_def(mg.graph_def, name=name, input_map={'images:0': X, 'anchor_th:0': anchor_th, 'nms_max:0': nms_max, 'nms_th:0': nms_th, 'is_training:0': is_training, }, return_elements=['rpn_probs:0', 'rpn_shapes:0', 'rpn_index:0']) self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path) pass
def _parse_input_graph_proto(input_graph, input_binary): """Parser input tensorflow graph into GraphDef proto.""" if not gfile.Exists(input_graph): print("Input graph file '" + input_graph + "' does not exist!") return -1 input_graph_def = meta_graph.read_meta_graph_file(input_graph).graph_def mode = "rb" if input_binary else "r" with gfile.FastGFile(input_graph, mode) as f: if input_binary: input_graph_def.ParseFromString(f.read()) else: text_format.Merge(f.read(), input_graph_def) return input_graph_def
def __init__(self, X, is_training, path, name): mg = meta_graph.read_meta_graph_file(path + '.meta') self.prob, self.offsets = tf.import_graph_def( mg.graph_def, name=name, input_map={ 'images:0': X, 'is_training:0': is_training }, return_elements=['prob:0', 'offsets:0']) self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path) pass
def main (_): assert FLAGS.db and os.path.exists(FLAGS.db) assert FLAGS.model and os.path.exists(FLAGS.model + '.meta') L = tf.placeholder(tf.float32, shape=(None, None, None, 1)) mg = meta_graph.read_meta_graph_file(FLAGS.model + '.meta') logits, = tf.import_graph_def(mg.graph_def, name='colorize', #input_map={'L:0':L}, input_map={'fifo_queue_Dequeue:0':L}, return_elements=['logits:0']) prob = tf.nn.softmax(logits) saver = tf.train.Saver(saver_def=mg.saver_def, name='colorize') picpac_config = dict(seed=2016, cache=False, max_size=200, min_size=192, crop_width=192, crop_height=192, shuffle=True, reshuffle=True, batch=1, round_div=FLAGS.stride, channels=3, stratify=False, channel_first=False # this is tensorflow specific # Caffe's dimension order is different. ) stream = picpac.ImageStream(FLAGS.db, perturb=False, loop=False, **picpac_config) with tf.Session() as sess: tf.global_variables_initializer().run() saver.restore(sess, FLAGS.model) gallery = Gallery(FLAGS.output, cols=2, header=['groundtruth', 'prediction']) c = 0 for images, _, _ in stream: if FLAGS.max and (c >= FLAGS.max): break l, ab, w = _pic2pic.encode_lab(images.copy(), FLAGS.downsize) ab_p, = sess.run([prob], feed_dict={L: l}) y_p = decode_lab(l, ab_p, T=FLAGS.T) cv2.imwrite(gallery.next(), images[0]) cv2.imwrite(gallery.next(), y_p[0]) c += 1 print('%d/%d' % (c, FLAGS.max)) pass gallery.flush() pass pass
def __init__ (self, X, is_training, path, name): mg = meta_graph.read_meta_graph_file(path + '.meta') self.logits, = tf.import_graph_def(mg.graph_def, name=name, input_map={'images:0': X, 'is_training:0': is_training}, return_elements=['logits:0']) if len(self.logits.get_shape()) == 4: # FCN self.is_fcn = True self.prob = tf.squeeze(tf.slice(tf.nn.softmax(self.logits), [0,0,0,1], [-1,-1,-1,1]), 3) else: # classification self.is_fcn = False self.prob = tf.nn.softmax(self.logits) self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.loader = lambda sess: self.saver.restore(sess, path) pass
def test_export_meta_graph(self): root = tracking.AutoTrackable() root.variable = resource_variable_ops.UninitializedVariable( name="some_variable", dtype=dtypes.float32) @def_function.function(input_signature=[tensor_spec.TensorSpec(None)]) def multiply_var(x): return root.variable * x @def_function.function(input_signature=[tensor_spec.TensorSpec([])]) def update(y): root.variable.assign_add(y) # TODO(b/150393409): All functions exported as signatures must have at # least one output. return 0 @def_function.function(input_signature=[]) def initialize(): root.variable.assign(1.0) # TODO(b/150393409): All functions exported as signatures must have at # least one output. return 0 save_path = os.path.join(self.get_temp_dir(), "meta_graph.pb") save.export_meta_graph(root, save_path, signatures={ "multiply_var": multiply_var, "initialize": initialize, "update": update }) with ops.Graph().as_default(), session_lib.Session() as session: saver.import_meta_graph(save_path) meta_graph_def = meta_graph.read_meta_graph_file(save_path) # Initialize variable to 1 _run_signature(session, meta_graph_def, {}, "initialize") out = _run_signature(session, meta_graph_def, {"x": 3}, "multiply_var") self.assertAllEqual(out, {"output_0": 3}) # Adds 2 to the variable. Variable is now 3 _run_signature(session, meta_graph_def, {"y": 2}, "update") out = _run_signature(session, meta_graph_def, {"x": 4}, "multiply_var") self.assertAllEqual(out, {"output_0": 12})
def test_expand_distributed_variables(self, expand_strategy): context._reset_context() cpus = context.context().list_physical_devices("CPU") if len(cpus) == 1: context.context().set_logical_device_configuration( cpus[0], [ context.LogicalDeviceConfiguration(), context.LogicalDeviceConfiguration() ]) context.ensure_initialized() file_name = os.path.join(self.get_temp_dir(), "saved_model.pb") with mirrored_strategy.MirroredStrategy(["CPU:0", "CPU:1"]).scope(): root = tracking.AutoTrackable() root.v = variables.Variable([1., 1.], name="v") @def_function.function(input_signature=[]) def f(): root.v.assign([2., 2.]) root.f = f save.export_meta_graph( obj=root, filename=file_name, options=save_options.SaveOptions( experimental_variable_policy=expand_strategy)) graph_def = meta_graph.read_meta_graph_file(file_name).graph_def v0 = next((n for n in graph_def.node if n.name == "v"), None) v1 = next((n for n in graph_def.node if n.name == "v/replica_1"), None) self.assertIsNotNone(v0) saved_function = next((f for f in graph_def.library.function if "inference_f_" in f.signature.name), None) self.assertIsNotNone(saved_function) if (expand_strategy == save_options.VariablePolicy.EXPAND_DISTRIBUTED_VARIABLES): self.assertIsNotNone(v1) # experimental_save_variable_devices should have been automatically set. self.assertIn("CPU:0", v0.device) self.assertIn("CPU:1", v1.device) self.assertLen(saved_function.signature.input_arg, 2) else: self.assertIsNone(v1) self.assertEmpty(v0.device) # TODO(b/159752793): There should be only one input here. self.assertLen(saved_function.signature.input_arg, 2)
def __init__(self, X, path, name, node='logits:0', softmax=True): """applying tensorflow image model. path -- path to model name -- output tensor name prob -- convert output (softmax) to probability """ mg = meta_graph.read_meta_graph_file(path + '.meta') output, = tf.import_graph_def(mg.graph_def, name=name, input_map={'images:0': X}, return_elements=[node]) if softmax: output = tf.nn.softmax(output) self.output = output self.saver = tf.train.Saver(saver_def=mg.saver_def, name=name) self.load = lambda sess: self.saver.restore(sess, path) pass
def initialize_variables(self, save_file=None): self.session.run(tf.global_variables_initializer()) if save_file is not None: try: self.saver.restore(self.session, save_file) except: # some wizardry here... basically, only restore variables # that are in the save file; otherwise, initialize them normally. from tensorflow.python.framework import meta_graph meta_graph_def = meta_graph.read_meta_graph_file(save_file + '.meta') stored_var_names = set([n.name for n in meta_graph_def.graph_def.node if n.op == 'VariableV2']) print(stored_var_names) var_list = [v for v in tf.global_variables() if v.op.name in stored_var_names] # initialize all of the variables self.session.run(tf.global_variables_initializer()) # then overwrite the ones we have in the save file # by using a throwaway saver, saved models are automatically # "upgraded" to the latest graph definition. throwaway_saver = tf.train.Saver(var_list=var_list) throwaway_saver.restore(self.session, save_file)
def swa(): path_base = fsdb.models_dir() model_names = [ "000393-lincoln", "000390-indus", "000404-hannibal", "000447-hawke", "000426-grief", "000431-lion", "000428-invincible", "000303-olympus", "000291-superb", "000454-victorious", ] model_names = model_names[:FLAGS.count] model_paths = [os.path.join(path_base, m) for m in model_names] # construct the graph features, labels = dual_net.get_inference_input() dual_net.model_fn(features, labels, tf.estimator.ModeKeys.PREDICT) # restore all saved weights meta_graph_def = meta_graph.read_meta_graph_file(model_paths[0] + '.meta') stored_var_names = set([ n.name for n in meta_graph_def.graph_def.node if n.op == 'VariableV2' ]) var_list = [ v for v in tf.global_variables() if v.op.name in stored_var_names ] var_list.sort(key=lambda v: v.op.name) print(stored_var_names) print(len(stored_var_names), len(var_list)) sessions = [tf.Session() for _ in model_paths] saver = tf.train.Saver() for sess, model_path in zip(sessions, model_paths): saver.restore(sess, model_path) # Load all VariableV2s for each model. values = [sess.run(var_list) for sess in sessions] # Iterate over all variables average values from all models. all_assign = [] for var, vals in zip(var_list, zip(*values)): print("{}x {}".format(len(vals), var)) if var.name == "global_step:0": avg = vals[0] for val in vals: avg = tf.maximum(avg, val) else: avg = tf.add_n(vals) / len(vals) continue all_assign.append(tf.assign(var, avg)) # Run all asign ops on an existing model (which has other ops and graph). sess = sessions[0] sess.run(all_assign) # Export a new saved model. ensure_dir_exists(FLAGS.data_dir) dest_path = os.path.join(FLAGS.data_dir, "swa-" + str(FLAGS.count)) saver.save(sess, dest_path)
def main (_): assert FLAGS.db and os.path.exists(FLAGS.db) assert FLAGS.model and os.path.exists(FLAGS.model + '.meta') GRAY = tf.placeholder(tf.float32, shape=(None, None, None, 1)) mg = meta_graph.read_meta_graph_file(FLAGS.model + '.meta') COLOR, = tf.import_graph_def(mg.graph_def, name='colorize', #input_map={'L:0':L}, input_map={'gray:0':GRAY}, return_elements=['color:0']) #prob = tf.nn.softmax(logits) saver = tf.train.Saver(saver_def=mg.saver_def, name='colorize') picpac_config = dict(seed=2016, cache=False, max_size=200, min_size=192, crop_width=192, crop_height=192, shuffle=True, #reshuffle=True, batch=1, round_div=FLAGS.stride, channels=3, stratify=False, channel_first=False # this is tensorflow specific # Caffe's dimension order is different. ) stream = picpac.ImageStream(FLAGS.db, perturb=False, loop=False, **picpac_config) with tf.Session() as sess: tf.global_variables_initializer().run() saver.restore(sess, FLAGS.model) gallery = Gallery(FLAGS.output, cols=2, header=['groundtruth', 'prediction']) c = 0 for images, _, _ in stream: if FLAGS.max and (c >= FLAGS.max): break gray, _, _ = _pic2pic.encode_bgr(images.copy(), FLAGS.downsize) #l, ab, w = _pic2pic.encode_lab(images.copy(), FLAGS.downsize) # color, = sess.run([COLOR], feed_dict={GRAY: gray}) cv2.imwrite(gallery.next(), gray[0]) full = np.zeros(images.shape, dtype=np.float32) color /= 255.0 gray /= 255.0 _, H, W, _ = images.shape for i in range(images.shape[0]): lab = cv2.cvtColor(cv2.cvtColor(gray[i], cv2.COLOR_GRAY2BGR), cv2.COLOR_BGR2LAB) print(lab.shape) full[i, :, :, :1] = lab[:, :, :1] one = cv2.resize(color[i], (W, H)) lab = cv2.cvtColor(one, cv2.COLOR_BGR2LAB) full[i, :, :, 1:] = lab[:, :, 1:] cv2.cvtColor(full[i], cv2.COLOR_LAB2BGR, full[i]) if FLAGS.s_add and FLAGS.s_mul: hsv = cv2.cvtColor(full[i], cv2.COLOR_BGR2HSV) h, s, v = cv2.split(hsv) s *= FLAGS.s_mul s += FLAGS.s_add hsv = cv2.merge([h, s, v]) cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR, full[i]) pass full *= 255 cv2.imwrite(gallery.next(), full[0]) #y_p = decode_lab(l, ab_p, T=FLAGS.T) c += 1 print('%d/%d' % (c, FLAGS.max)) pass gallery.flush() pass pass
import tensorflow as tf # import dual_net path = '/srv/2-lkeb-17-dl01/syousefi/TestCode/EsophagusProject/sythesize_code/debug_Log/synth-5-shark/train/' path = '/srv/2-lkeb-17-dl01/syousefi/TestCode/EsophagusProject/sythesize_code/debug_Log/synth-5-shark/unet_checkpoints/' save_file = path + 'unet_inter_epoch0_point100.ckpt-100' dest_file = path + 'saved' # features, labels = dual_net.get_inference_input() # dual_net.model_fn(features, labels, tf.estimator.ModeKeys.PREDICT, dual_net.get_default_hyperparams()) sess = tf.Session() # retrieve the global step as a python value ckpt = tf.train.load_checkpoint(save_file) global_step_value = ckpt.get_tensor('avegare_perfusion') # restore all saved weights, except global_step from tensorflow.python.framework import meta_graph meta_graph_def = meta_graph.read_meta_graph_file(save_file + '.meta') stored_var_names = set( [n.name for n in meta_graph_def.graph_def.node if n.op == 'VariableV2']) print(stored_var_names) stored_var_names.remove('global_step') var_list = [v for v in tf.global_variables() if v.op.name in stored_var_names] tf.train.Saver(var_list=var_list).restore(sess, save_file) # manually set the global step global_step_tensor = tf.train.get_or_create_global_step() assign_op = tf.assign(global_step_tensor, global_step_value) sess.run(assign_op) # export a new savedmodel that has the right global step type tf.train.Saver().save(sess, dest_file)
def freeze_graph_with_def_protos(input_graph_def, input_saver_def, input_checkpoint, output_node_names, restore_op_name, filename_tensor_name, output_graph, clear_devices, initializer_nodes, variable_names_blacklist="", input_meta_graph_def=None, input_saved_model_dir=None, saved_model_tags=None): """Converts all variables in a graph and checkpoint into constants.""" del restore_op_name, filename_tensor_name # Unused by updated loading code. # 'input_checkpoint' may be a prefix if we're using Saver V2 format if (not input_saved_model_dir and not saver_lib.checkpoint_exists(input_checkpoint)): print("Input checkpoint '" + input_checkpoint + "' doesn't exist!") return -1 if not output_node_names: print("You need to supply the name of a node to --output_node_names.") return -1 # Remove all the explicit device specifications for this node. This helps to # make the graph more portable. # if clear_devices: # if input_meta_graph_def: # for node in input_meta_graph_def.graph_def.node: # node.device = "" # elif input_graph_def: # for node in input_graph_def.node: # node.device = "" # use meta data input_graph_def = meta_graph.read_meta_graph_file(input_graph).graph_def if input_graph_def: _ = importer.import_graph_def(input_graph_def, name="") with session.Session() as sess: if input_saver_def: saver = saver_lib.Saver(saver_def=input_saver_def) saver.restore(sess, input_checkpoint) elif input_meta_graph_def: restorer = saver_lib.import_meta_graph(input_meta_graph_def, clear_devices=True) restorer.restore(sess, input_checkpoint) if initializer_nodes: sess.run(initializer_nodes.split(",")) elif input_saved_model_dir: if saved_model_tags is None: saved_model_tags = [] loader.load(sess, saved_model_tags, input_saved_model_dir) else: var_list = {} reader = pywrap_tensorflow.NewCheckpointReader(input_checkpoint) var_to_shape_map = reader.get_variable_to_shape_map() for key in var_to_shape_map: try: tensor = sess.graph.get_tensor_by_name(key + ":0") except KeyError: # This tensor doesn't exist in the graph (for example it's # 'global_step' or a similar housekeeping element) so skip it. continue var_list[key] = tensor saver = saver_lib.Saver(var_list=var_list) saver.restore(sess, input_checkpoint) if initializer_nodes: sess.run(initializer_nodes.split(",")) variable_names_blacklist = (variable_names_blacklist.split(",") if variable_names_blacklist else None) if input_meta_graph_def: output_graph_def = graph_util.convert_variables_to_constants( sess, input_meta_graph_def.graph_def, output_node_names.split(","), variable_names_blacklist=variable_names_blacklist) else: output_graph_def = graph_util.convert_variables_to_constants( sess, input_graph_def, output_node_names.split(","), variable_names_blacklist=variable_names_blacklist) # Write GraphDef to file if output path has been given. if output_graph: with gfile.GFile(output_graph, "wb") as f: f.write(output_graph_def.SerializeToString()) return output_graph_def
#!/usr/bin/env python import tensorflow as tf from tensorflow.python.framework import meta_graph import numpy as np import pkgutil import cv2 import sys fold = sys.argv[1] size = 224 X = tf.placeholder(tf.float32, shape=(None, None, None, 2), name="images") mg = meta_graph.read_meta_graph_file('model/' + fold + '.meta') logits = tf.import_graph_def(mg.graph_def, name='xxx', input_map={'images:0': X}, return_elements=['logits:0']) prob = tf.nn.softmax(logits) saver = tf.train.Saver(saver_def=mg.saver_def, name='xxx') with tf.Session() as sess: saver.restore(sess, 'model/' + fold) tmp_input = np.zeros((1, 224, 224, 2)) TEST = open('list_test', 'r') PRED = open('pred.txt', 'w') for line in TEST: table = line.split('\t') img = np.load(table[0]) img = cv2.resize(img, (224, 224))
h.update(**blobs) elif args.output_path.endswith('.npy') or args.output_path.endswith('.npz'): (np.savez if args.output_path[-1] == 'z' else numpy.save)(args.output_path, **blobs) elif args.output_path.endswith('.pt'): import torch torch.save( { k: (torch.as_tensor(blob) if not np.isscalar(blob) else torch.tensor(blob)) if isinstance(blob, np.ndarray) else blob for k, blob in blobs.items() }, args.output_path) if args.onnx or args.tensorboard or args.graph: meta_graph_file = glob.glob(os.path.join(checkpoint_dir, '*.meta'))[0] graph_def = meta_graph.read_meta_graph_file(meta_graph_file).graph_def if args.graph or (not args.input_name) or (args.onnx and not args.output_name): print('\n'.join( sorted(f'{v.name} <- {v.op}(' + ', '.join(v.input) for v in graph_def.node)) + ')', file=None if not args.graph else open(args.graph, 'w')) sys.exit(0) for v in graph_def.node: if any(name in v.name for name in args.identityop): v.op = 'Identity' for a in set(v.attr.keys()) - set(['T']): del v.attr[a]