added vector_from_image_singlelabel

from argparse import ArgumentParser

import tensorflow as tf

import numpy as np

import pickle

def load_graph(model_file):

  graph = tf.Graph()

  graph_def = tf.GraphDef()

  with open(model_file, "rb") as f:

    graph_def.ParseFromString(f.read())

  with graph.as_default():

    tf.import_graph_def(graph_def)

  return graph

def read_tensor_from_image_file(file_name,

                                input_height=299,

                                input_width=299,

                                input_mean=0,

                                input_std=255):

  input_name = "file_reader"

  output_name = "normalized"

  file_reader = tf.read_file(file_name, input_name)

  if file_name.endswith(".png"):

    image_reader = tf.image.decode_png(

        file_reader, channels=3, name="png_reader")

  elif file_name.endswith(".gif"):

    image_reader = tf.squeeze(

        tf.image.decode_gif(file_reader, name="gif_reader"))

  elif file_name.endswith(".bmp"):

    image_reader = tf.image.decode_bmp(file_reader, name="bmp_reader")

  else:

    image_reader = tf.image.decode_jpeg(

        file_reader, channels=3, name="jpeg_reader")

  float_caster = tf.cast(image_reader, tf.float32)

  dims_expander = tf.expand_dims(float_caster, 0)

  resized = tf.image.resize_bilinear(dims_expander, [input_height, input_width])

  normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std])

  sess = tf.Session()

  result = sess.run(normalized)

  return result

def main():

    parser = ArgumentParser(

        description=''

    )

    parser.add_argument(

        '-g', '--graph', required=True, help='path to graph'

        )

    parser.add_argument(

        '-i', '--image', required=True, help='path to image')

    args = parser.parse_args()

    graph = args.graph

    img = args.image

    model_file = graph

    input_layer = 'Placeholder'

    output_layer= 'module_apply_default/hub_output/feature_vector/SpatialSqueeze'

    input_name = "import/" + input_layer

    output_name = "import/" + output_layer

    graph = load_graph(model_file)

    input_operation = graph.get_operation_by_name(input_name)

    output_operation = graph.get_operation_by_name(output_name)

    interface = []

    t = read_tensor_from_image_file(

        img)

    with tf.Session(graph=graph) as sess:

        results = sess.run(output_operation.outputs[0], {

            input_operation.outputs[0]: t

        })

    d = dict()

    d['file_name'] = img

    d['vector'] = np.squeeze(results)

    interface.append(d)

    output_file = 'single_picture_singlelabel.pickle'

    with open(output_file, 'wb') as handle:

        pickle.dump(interface, handle, protocol=pickle.HIGHEST_PROTOCOL)

if __name__ == '__main__':

    main()