我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.import_graph_def()。
def create_inception_graph(): """"Creates a graph from saved GraphDef file and returns a Graph object. Returns: Graph holding the trained Inception network, and various tensors we'll be manipulating. """ with tf.Session() as sess: model_filename = os.path.join( FLAGS.model_dir, 'classify_image_graph_def.pb') with gfile.FastGFile(model_filename, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = ( tf.import_graph_def(graph_def, name='', return_elements=[ BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME, RESIZED_INPUT_TENSOR_NAME])) return sess.graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor
def build_from_pb(self): with tf.gfile.FastGFile(self.FLAGS.pbLoad, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) tf.import_graph_def( graph_def, name="" ) with open(self.FLAGS.metaLoad, 'r') as fp: self.meta = json.load(fp) self.framework = create_framework(self.meta, self.FLAGS) # Placeholders self.inp = tf.get_default_graph().get_tensor_by_name('input:0') self.feed = dict() # other placeholders self.out = tf.get_default_graph().get_tensor_by_name('output:0') self.setup_meta_ops()
def load_model(model): # Check if the model is a model directory (containing a metagraph and a checkpoint file) # or if it is a protobuf file with a frozen graph model_exp = os.path.expanduser(model) if (os.path.isfile(model_exp)): print('Model filename: %s' % model_exp) with gfile.FastGFile(model_exp,'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) tf.import_graph_def(graph_def, name='') else: print('Model directory: %s' % model_exp) meta_file, ckpt_file = get_model_filenames(model_exp) print('Metagraph file: %s' % meta_file) print('Checkpoint file: %s' % ckpt_file) saver = tf.train.import_meta_graph(os.path.join(model_exp, meta_file)) saver.restore(tf.get_default_session(), os.path.join(model_exp, ckpt_file))
def load_graph(frozen_graph_filename): # We load the protobuf file from the disk and parse it to retrieve the # unserialized graph_def with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph
def __init__(self, config, graph, model_scope, model_dir, model_file): self.config = config frozen_model = os.path.join(model_dir, model_file) with tf.gfile.GFile(frozen_model, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # This model_scope adds a prefix to all the nodes in the graph tf.import_graph_def(graph_def, input_map=None, return_elements=None, name="{}/".format(model_scope)) # Uncomment the two lines below to look for the names of all the operations in the graph # for op in graph.get_operations(): # print(op.name) # Using the lines commented above to look for the tensor name of the input node # Or you can figure it out in your original model, if you explicitly named it. self.input_tensor = graph.get_tensor_by_name("{}/input_1:0".format(model_scope)) self.output_tensor = graph.get_tensor_by_name("{}/s1_output0:0".format(model_scope))
def load_frozen_graph(graph_dir, fix_nodes=True, entry=None, output=None): with gfile.FastGFile(graph_dir, "rb") as file: graph_def = tf.GraphDef() graph_def.ParseFromString(file.read()) if fix_nodes: for node in graph_def.node: if node.op == 'RefSwitch': node.op = 'Switch' for index in range(len(node.input)): if 'moving_' in node.input[index]: node.input[index] = node.input[index] + '/read' elif node.op == 'AssignSub': node.op = 'Sub' if 'use_locking' in node.attr: del node.attr['use_locking'] tf.import_graph_def(graph_def, name="") if entry is not None: entry = tf.get_default_graph().get_tensor_by_name(entry) if output is not None: output = tf.get_default_graph().get_tensor_by_name(output) return entry, output
def create_inception_graph(): """"Creates a graph from saved GraphDef file and returns a Graph object. Returns: Graph holding the trained Inception network, and various tensors we'll be manipulating. """ with tf.Graph().as_default() as graph: model_filename = os.path.join( FLAGS.model_dir, 'classify_image_graph_def.pb') with gfile.FastGFile(model_filename, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = ( tf.import_graph_def(graph_def, name='', return_elements=[ BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME, RESIZED_INPUT_TENSOR_NAME])) return graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor
def inference(): graph = tf.Graph() with graph.as_default(): with tf.gfile.FastGFile(FLAGS.input, 'rb') as f: image_data = f.read() input_image = tf.image.decode_jpeg(image_data, channels=3) input_image = tf.image.resize_images(input_image, size=(FLAGS.image_size, FLAGS.image_size)) input_image = utils.convert2float(input_image) input_image.set_shape([FLAGS.image_size, FLAGS.image_size, 3]) with tf.gfile.FastGFile(FLAGS.model, 'rb') as model_file: graph_def = tf.GraphDef() graph_def.ParseFromString(model_file.read()) [output_image] = tf.import_graph_def(graph_def, input_map={'input_image': input_image}, return_elements=['output_image:0'], name='output') with tf.Session(graph=graph) as sess: generated = output_image.eval() with open(FLAGS.output, 'wb') as f: f.write(generated)
def Get_Pre_Trained_Weights(input_vars,name): with open("vgg16.tfmodel", mode='rb') as f: fileContent = f.read() graph_def = tf.GraphDef() graph_def.ParseFromString(fileContent) images = tf.placeholder(tf.float32,shape = (None, 64, 64, 3),name=name) tf.import_graph_def(graph_def, input_map={ "images": images }) print "graph loaded from disk" graph = tf.get_default_graph() with tf.Session() as sess: init = tf.initialize_all_variables() sess.run(init) #batch = np.reshape(input_vars,(-1, 224, 224, 3)) n_timewin = 7 convnets = [] for i in xrange(n_timewin): feed_dict = { images:input_vars[:,i,:,:,:] } pool_tensor = graph.get_tensor_by_name("import/pool5:0") pool_tensor = sess.run(pool_tensor, feed_dict=feed_dict) convnets.append(tf.contrib.layers.flatten(pool_tensor)) convpool = tf.pack(convnets, axis = 1) return convpool
def _transform(self, dataset): graph_def = self._optimize_for_inference() input_mapping = self.getInputMapping() output_mapping = self.getOutputMapping() graph = tf.Graph() with tf.Session(graph=graph): analyzed_df = tfs.analyze(dataset) out_tnsr_op_names = [tfx.op_name(tnsr_name) for tnsr_name, _ in output_mapping] # Load graph tf.import_graph_def(graph_def=graph_def, name='', return_elements=out_tnsr_op_names) # Feed dict maps from placeholder name to DF column name feed_dict = {self._getSparkDlOpName( tnsr_name): col_name for col_name, tnsr_name in input_mapping} fetches = [tfx.get_tensor(tnsr_name, graph) for tnsr_name in out_tnsr_op_names] out_df = tfs.map_blocks(fetches, analyzed_df, feed_dict=feed_dict) # We still have to rename output columns for tnsr_name, new_colname in output_mapping: old_colname = tfx.op_name(tnsr_name, graph) if old_colname != new_colname: out_df = out_df.withColumnRenamed(old_colname, new_colname) return out_df
def fromGraphDef(cls, graph_def, feed_names, fetch_names): """ Construct a TFInputGraph from a tf.GraphDef object. :param graph_def: :py:class:`tf.GraphDef`, a serializable object containing the topology and computation units of the TensorFlow graph. :param feed_names: list, names of the input tensors. :param fetch_names: list, names of the output tensors. """ assert isinstance(graph_def, tf.GraphDef), \ ('expect tf.GraphDef type but got', type(graph_def)) graph = tf.Graph() with tf.Session(graph=graph) as sess: tf.import_graph_def(graph_def, name='') return _build_with_feeds_fetches(sess=sess, graph=graph, feed_names=feed_names, fetch_names=fetch_names)
def _check_output(gin, tf_input, expected): """ Takes a TFInputGraph object (assumed to have the input and outputs of the given names above) and compares the outcome against some expected outcome. """ graph = tf.Graph() graph_def = gin.graph_def with tf.Session(graph=graph) as sess: tf.import_graph_def(graph_def, name="") tgt_feed = tfx.get_tensor(_tensor_input_name, graph) tgt_fetch = tfx.get_tensor(_tensor_output_name, graph) # Run on the testing target tgt_out = sess.run(tgt_fetch, feed_dict={tgt_feed: tf_input}) # Working on integers, the calculation should be exact assert np.all(tgt_out == expected), (tgt_out, expected) # TODO: we could factorize with _check_output, but this is not worth the time doing it.
def _check_output_2(gin, tf_input1, tf_input2, expected): """ Takes a TFInputGraph object (assumed to have the input and outputs of the given names above) and compares the outcome against some expected outcome. """ graph = tf.Graph() graph_def = gin.graph_def with tf.Session(graph=graph) as sess: tf.import_graph_def(graph_def, name="") tgt_feed1 = tfx.get_tensor(_tensor_input_name, graph) tgt_feed2 = tfx.get_tensor(_tensor_input_name_2, graph) tgt_fetch = tfx.get_tensor(_tensor_output_name, graph) # Run on the testing target tgt_out = sess.run(tgt_fetch, feed_dict={tgt_feed1: tf_input1, tgt_feed2: tf_input2}) # Working on integers, the calculation should be exact assert np.all(tgt_out == expected), (tgt_out, expected)
def load_model(sess, model_path): if os.path.isfile(model_path): # A protobuf file with a frozen graph print('Model filename: %s' % model_path) with gfile.FastGFile(model_path, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) tf.import_graph_def(graph_def, name='') else: # A directory containing a metagraph file and a checkpoint file print('Model directory: %s' % model_path) meta_file, ckpt_file = get_model_filenames(model_path) print('Metagraph file: %s' % meta_file) print('Checkpoint file: %s' % ckpt_file) saver = tf.train.import_meta_graph(os.path.join(model_path, meta_file), clear_devices=True) saver.restore(sess, os.path.join(model_path, ckpt_file))
def create_inception_graph(): """" Brief: Creates a graph from saved GraphDef file and returns a Graph object. Returns: Graph holding the trained Inception network, and various tensors we'll be manipulating. """ with tf.Graph().as_default() as graph: model_filename = os.path.join(FLAGS.model_dir, 'classify_image_graph_def.pb') with gfile.FastGFile(model_filename, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = ( tf.import_graph_def(graph_def, name='', return_elements=[ BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME, RESIZED_INPUT_TENSOR_NAME])) return graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor
def __init__(self, name, input, i, j, k): """ :param input: A 4D-tensor of shape [batchSize, 224, 224, 3] [0:i, :, :, :] holds i style images, [i:i+j, :, :, :] holds j content images, [i+j:i+j+k, :, :, :] holds k synthesized images """ self.name = name self.num_style = i self.num_content = j self.num_synthesized = k with open("models/vgg16.tfmodel", mode='rb') as f: file_content = f.read() graph_def = tf.GraphDef() graph_def.ParseFromString(file_content) tf.import_graph_def(graph_def, input_map={"images": input}, name=self.name)
def load_graph(frozen_graph_filename): """ Load graph/model to be used """ logging.info('Loading frozen model-graph: ' + frozen_graph_filename) # We load the protobuf file from the disk and parse it to retrieve the # unserialized graph_def logging.debug('Reading model file') with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # Then, we can use again a convenient built-in function to import a graph_def into the # current default Graph logging.debug('Importing graph') with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph
def load_frozen_graph(frozen_graph): with tf.gfile.GFile(frozen_graph, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) try: with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name='model', op_dict=None, producer_op_list=None ) return graph except Exception as e: print(e.message)
def run_image_classifier(tensor, graph_def, input_tensor, output_tensor, scope='RunClassifier'): """Runs a network from a frozen graph. Args: tensor: An Input tensor. graph_def: A GraphDef proto. input_tensor: Name of input tensor in graph def. output_tensor: Name of output tensor in graph def. scope: Name scope for classifier. Returns: Classifier output. Shape depends on the classifier used, but is often [batch, classes]. Raises: ValueError: If `image_size` is not `None`, and `tensor` are not the correct size. """ input_map = {input_tensor: tensor} return_elements = [output_tensor] classifier_output = tf.import_graph_def( graph_def, input_map, return_elements, name=scope)[0] return classifier_output
def create_model_graph(model_info): """"Creates a graph from saved GraphDef file and returns a Graph object. Args: model_info: Dictionary containing information about the model architecture. Returns: Graph holding the trained Inception network, and various tensors we'll be manipulating. """ with tf.Graph().as_default() as graph: model_path = os.path.join(FLAGS.model_dir, model_info['model_file_name']) with gfile.FastGFile(model_path, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) bottleneck_tensor, resized_input_tensor = (tf.import_graph_def( graph_def, name='', return_elements=[ model_info['bottleneck_tensor_name'], model_info['resized_input_tensor_name'], ])) return graph, bottleneck_tensor, resized_input_tensor
def load_graph(frozen_graph_filename): # We parse the graph_def file with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # We load the graph_def in the default graph with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph
def __init__(self, graph_file_path, initializer_node_name, input_node_name, output_node_name): self.graph = tf.Graph() self.session = tf.Session(graph=self.graph) graph_def = tf.GraphDef() graph_def.ParseFromString(open(graph_file_path, 'rb').read()) with self.graph.as_default(): tf.import_graph_def(graph_def) if initializer_node_name: self.initializer = self.graph.get_operation_by_name('import/' + initializer_node_name) self.input = self.graph.get_tensor_by_name('import/%s:0' % input_node_name) self.output = self.graph.get_tensor_by_name('import/%s:0' % output_node_name) if initializer_node_name: self.session.run(self.initializer)
def _rewrite_graph(self, transform): input_map = {k.name: v for k, v in transform.items()} # Modify the input dictionary to replace variables which have been # superseded with the use of combinators for k, v in self._silently_replace.items(): input_map[k.name] = self._observed[v] with self.session.graph.as_default(): try: tf.import_graph_def( self._model_graph.as_graph_def(), input_map=input_map, name='added', ) except ValueError: # Ignore errors that ocour when the input_map tries to # rewrite a variable that isn't present in the graph pass
def load_graph(frozen_graph_filename): # We load the protobuf file from the disk and parse it to retrieve the # unserialized graph_def with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # Then, we can use again a convenient built-in function to import a graph_def into the # current default Graph with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph # make the raw data acceptable for the model
def load_graph(frozen_graph_filename): """load the protobuf file from the disk and parse it to retrieve the unserialized graph_def""" with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # Then, we can use again a convenient built-in function to import a graph_def into the # current default Graph with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph
def predict(self, img): if self.use_log: output_name = 'InceptionV3/Predictions/Softmax:0' else: output_name = 'InceptionV3/Predictions/Reshape:0' # scaled = (0.5+tf.reshape(img,((299,299,3))))*255 # scaled = (0.5+img)*255 if img.shape.as_list()[0]: # check if a shape has been specified explicitly shape = (int(img.shape[0]), 1001) softmax_tensor = tf.import_graph_def( self.sess.graph.as_graph_def(), input_map={'input:0': img, 'InceptionV3/Predictions/Shape:0': shape}, return_elements=[output_name]) else: # placeholder shape softmax_tensor = tf.import_graph_def( self.sess.graph.as_graph_def(), input_map={'input:0': img}, return_elements=[output_name]) return softmax_tensor[0]
def __init__(self, alpha=0.9, graph_path='', checkpoint_path='', metagraph_path=''): if graph_path: assert os.path.isfile(graph_path) else: assert os.path.isfile(checkpoint_path) and os.path.isfile(metagraph_path) self.graph = tf.Graph() with self.graph.as_default(): if graph_path: # load a graph with weights frozen as constants graph_def = tf.GraphDef() with open(graph_path, "rb") as f: graph_def.ParseFromString(f.read()) _ = tf.import_graph_def(graph_def, name="") self.session = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) else: # load a meta-graph and initialize variables form checkpoint saver = tf.train.import_meta_graph(metagraph_path) self.session = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) saver.restore(self.session, checkpoint_path) self.model_input = self.session.graph.get_tensor_by_name("input_placeholder:0") self.model_output = self.session.graph.get_tensor_by_name("output_steer:0") self.last_steering_angle = 0 # None self.alpha = alpha
def extract_fc7_features(image_path, model_path): vgg_file = open(model_path) vgg16raw = vgg_file.read() vgg_file.close() graph_def = tf.GraphDef() graph_def.ParseFromString(vgg16raw) images = tf.placeholder("float32", [None, 224, 224, 3]) tf.import_graph_def(graph_def, input_map={ "images": images }) graph = tf.get_default_graph() sess = tf.Session() image_array = load_image_array(image_path) image_feed = np.ndarray((1,224,224,3)) image_feed[0:,:,:] = image_array feed_dict = { images : image_feed } fc7_tensor = graph.get_tensor_by_name("import/Relu_1:0") fc7_features = sess.run(fc7_tensor, feed_dict = feed_dict) sess.close() return fc7_features
def load_model(frozen_graph_filename): # First we need to load the protobuf file from the disk and parse it to retrieve the # Unserialized graph_def with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) # Then, we can use again a convenient built-in function to import a graph_def into the # current default Graph with tf.Graph().as_default() as graph: tf.import_graph_def( graph_def, input_map=None, return_elements=None, name="prefix", op_dict=None, producer_op_list=None ) return graph
def loadpb(filename, model_name='dcgan'): """Loads pretrained graph from ProtoBuf file Arguments: filename - path to ProtoBuf graph definition model_name - prefix to assign to loaded graph node names Returns: graph, graph_def - as per Tensorflow definitions """ with tf.gfile.GFile(filename, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) with tf.Graph().as_default() as graph: tf.import_graph_def(graph_def, input_map=None, return_elements=None, op_dict=None, producer_op_list=None, name=model_name) return graph, graph_def
