Ejemplo n.º 1
0
def read_and_decode(filename, is_train):
    filename_queue = tf.train.string_input_producer([filename])
    reader = tf.TFRecordReader()
    _,serialized_example = reader.read(filename_queue)

    if is_train == True:
        features = tf.parse_single_example(serialized_example,
                                           features={
                                               "hat_label": tf.FixedLenFeature([], tf.int64),
                                               "hair_label": tf.FixedLenFeature([], tf.int64),
                                               "gender_label": tf.FixedLenFeature([], tf.int64),
                                               "top_label": tf.FixedLenFeature([], tf.int64),
                                               "down_label": tf.FixedLenFeature([], tf.int64),
                                               "shoes_label": tf.FixedLenFeature([], tf.int64),
                                               "bag_label": tf.FixedLenFeature([], tf.int64),
                                               "img_raw": tf.FixedLenFeature([], tf.string),
                                           })
        img = tf.decode_raw(features['img_raw'], tf.uint8)
        img = tf.reshape(img, [128, 256, 3])
	#image = Image.frombytes('RGB', (224, 224), img[0])
	img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
	#print(type(img))
	#img = np.asarray(img, dtype=np.uint8)
	#print(type(img))
	#tl.visualize.frame(I=img, second=5, saveable=False, name='frame', fig_idx=12836)

        hat_label = tf.cast(features['hat_label'], tf.int32)
        hair_label = tf.cast(features['hair_label'], tf.int32)
        gender_label = tf.cast(features['gender_label'], tf.int32)
        top_label = tf.cast(features['top_label'], tf.int32)
        down_label = tf.cast(features['down_label'], tf.int32)
        shoes_label = tf.cast(features['shoes_label'], tf.int32)
        bag_label = tf.cast(features['bag_label'], tf.int32)
        labels = {"hat":hat_label, "hair":hair_label, "gender":gender_label,
                  "top":top_label, "down":down_label, "shoes":shoes_label,
                  "bag":bag_label}

        return img, labels
    else:
        features = tf.parse_single_example(serialized_example,
                                           features={
                                               "img_raw": tf.FixedLenFeature([], tf.string),
                                           })
        img = tf.decode_raw(features['img_raw'], tf.uint8)
        img = tf.reshape(img, [128, 256, 3])
	img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
	#tl.visualize.frame(I=img, second=5, saveable=False, name='frame', fig_idx=12833)

        return img
Ejemplo n.º 2
0
def read_and_decode_single_example(filenames, image_shape, onlyDepth = False):
	# first construct a queue containing a list of filenames.
	# this lets a user split up there dataset in multiple files to keep
	# size down
	filename_queue = tf.train.string_input_producer(filenames,num_epochs=None)
	
	#symbolic reader to read one example at a time
	reader = tf.TFRecordReader()
	_, serialized_example = reader.read(filename_queue)
	features = tf.parse_single_example(
		serialized_example,
		# Defaults are not specified since both keys are required.
		features={
			'image': tf.FixedLenFeature([image_shape[0]*image_shape[1]*image_shape[2]], tf.float32),
			'label': tf.FixedLenFeature([], tf.int64),
		}
	)

	# Convert from a scalar list to a proper shaped tensor
	image = features['image']
	image = tf.reshape(image,image_shape)
	if onlyDepth:
		channels = tf.split(2,3,image)
		image = channels[2]
	label = features['label']
	
	return image,label
Ejemplo n.º 3
0
def read_and_decode(filename_queue):
  reader = tf.TFRecordReader()
  _, serialized_example = reader.read(filename_queue)
  features = tf.parse_single_example(
  serialized_example,
  # Defaults are not specified since both keys are required.
  features={
  'vector': tf.FixedLenFeature([], tf.string),
  'label': tf.FixedLenFeature([], tf.int64),
  })  
  
  
  
  # features = tf.parse_single_example(serialized_example, dense_keys=['vector', 'label'], dense_types=[tf.string, tf.int64])
  # Convert from a scalar string tensor (whose single string has
  # length tf_model.IMAGE_PIXELS) to a uint8 tensor with shape
  # [tf_model.IMAGE_PIXELS].
  image = tf.decode_raw(features['vector'], tf.float32)
  image.set_shape([FEATURE_DIMENSIONALITY])
  if FLAGS.transpose_input:
    image = tf.reshape(image, FEATURE_INPUT_SHAPE)
    image = tf.transpose(image, perm=[0,2,1])
    image = tf.reshape(image, [-1])

  # print("Image shape is %s" %(image.shape))
  # OPTIONAL: Could reshape into a 28x28 image and apply distortions
  # here.  Since we are not applying any distortions in this
  # example, and the next step expects the image to be flattened
  # into a vector, we don't bother.
  # Convert from [0, 255] -> [-0.5, 0.5] floats.
  # image = tf.cast(image, tf.float32) * (1. / 255) - 0.5
  # Convert label from a scalar uint8 tensor to an int32 scalar.
  label = tf.cast(features['label'], tf.int32)
  return image, label
Ejemplo n.º 4
0
    def __init__(self, input_files, num_epochs, batch_size):
        filename_queue = tf.train.string_input_producer(input_files, num_epochs=num_epochs)
        reader = tf.TFRecordReader()
        _, records = reader.read(filename_queue)
        decoded = tf.parse_single_example(records,
            dense_keys=['image', 'text', 'result', 'len'],
            dense_types=['float', 'int64', 'int64', 'int64'],
            dense_shapes=[(1, config.image_features_count),
                          (config.sents_per_sample, config.max_len),
                          (config.sents_per_sample, config.max_len),
                          (config.sents_per_sample, 1)])

        self.image, self.text, self.result, self.lens = \
            decoded['image'], decoded['text'], decoded['result'], decoded['len']
        self.image = tf.concat(0, [self.image] * config.sents_per_sample)

        # result requires one-hot encoding
        clamped_result = tf.minimum(self.result, config.output_words_count)
        sliced_result = [tf.squeeze(tensor, [0]) for tensor in tf.split(0, config.sents_per_sample, clamped_result)]
        sliced_categorical_result = [self.to_categorical(tensor) for tensor in sliced_result]
        self.categorical_result = tf.concat(0, [tf.expand_dims(tensor, 0) for tensor in sliced_categorical_result])

        self.image_input, self.text_input, self.result_input, self.lens_input = tf.train.shuffle_batch(
            [self.image, self.text, self.categorical_result, self.lens],
            batch_size=batch_size,
            capacity=256+config.batch_size,
            min_after_dequeue=128,
            enqueue_many=True)
Ejemplo n.º 5
0
    def read_from_tfrecord(tfrecord_path):
        with tf.Session() as sess:
            # create feature to hold data
            feature_dict = {
                'image/height': tf.FixedLenFeature([], tf.int64),
                'image/width': tf.FixedLenFeature([], tf.int64),
                'image/filename': tf.VarLenFeature(tf.string),
                'image/image': tf.FixedLenFeature([], tf.string),
                'image/panel/bbox/xmin': tf.FixedLenFeature([], tf.float32),
                'image/panel/bbox/ymin': tf.FixedLenFeature([], tf.float32),
                'image/panel/bbox/xmax': tf.FixedLenFeature([], tf.float32),
                'image/panel/bbox/ymax': tf.FixedLenFeature([], tf.float32),
                'image/label/bbox/xmin': tf.FixedLenFeature([], tf.float32),
                'image/label/bbox/ymin': tf.FixedLenFeature([], tf.float32),
                'image/label/bbox/xmax': tf.FixedLenFeature([], tf.float32),
                'image/label/bbox/ymax': tf.FixedLenFeature([], tf.float32),
                'image/panel/label/text': tf.FixedLenFeature([], tf.string),
                'image/panel/label/class': tf.FixedLenFeature([], tf.int64)
            }
            # create a list of tfrecord filenames and pass it to a queue
            filename_queue = tf.train.string_input_producer([tfrecord_path], num_epochs=1)

            # define a reader and read the next record
            reader = tf.TFRecordReader()
            _, serialized_example = reader.read(filename_queue)

            # decode the record read by the reader
            features = tf.parse_single_example(serialized_example, features=feature_dict)

            image_height = tf.case(features['image/height'], tf.int64)
            image_width = tf.case(features['image/width'], tf.int64)

            # convert the image data from string back to the numbers
            image = tf.decode_raw(features['image/image'], tf.uint8)
            image = tf.reshape(image, [image_height, image_width, 3])
Ejemplo n.º 6
0
def distorted_inputs (tfrecord_file_paths=[]):
    fqueue = tf.train.string_input_producer(tfrecord_file_paths)
    reader = tf.TFRecordReader()
    key, serialized_example = reader.read(fqueue)
    features = tf.parse_single_example(serialized_example, features={
        'label': tf.FixedLenFeature([], tf.int64),
        'image': tf.FixedLenFeature([], tf.string)
    })
    image = tf.image.decode_jpeg(features['image'], channels=size['depth'])
    image = tf.cast(image, tf.float32)
    image.set_shape([size['width'], size['height'], size['depth']])

    min_fraction_of_examples_in_queue = 0.4
    min_queue_examples = int(cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL * min_fraction_of_examples_in_queue)

    images, labels = tf.train.shuffle_batch(
        [tf.image.per_image_whitening(image), tf.cast(features['label'], tf.int32)],
        batch_size=BATCH_SIZE,
        capacity=min_queue_examples + 3 * BATCH_SIZE,
        min_after_dequeue=min_queue_examples
    )

    images = tf.image.resize_images(images, size['input_width'], size['input_height'])
    tf.image_summary('images', images)
    return images, labels
Ejemplo n.º 7
0
 def parse(example):
     para_limit = config.test_para_limit if is_test else config.para_limit
     ques_limit = config.test_ques_limit if is_test else config.ques_limit
     char_limit = config.char_limit
     features = tf.parse_single_example(example,
                                        features={
                                            "context_idxs": tf.FixedLenFeature([], tf.string),
                                            "ques_idxs": tf.FixedLenFeature([], tf.string),
                                            "context_char_idxs": tf.FixedLenFeature([], tf.string),
                                            "ques_char_idxs": tf.FixedLenFeature([], tf.string),
                                            "y1": tf.FixedLenFeature([], tf.string),
                                            "y2": tf.FixedLenFeature([], tf.string),
                                            "id": tf.FixedLenFeature([], tf.int64)
                                        })
     context_idxs = tf.reshape(tf.decode_raw(
         features["context_idxs"], tf.int32), [para_limit])
     ques_idxs = tf.reshape(tf.decode_raw(
         features["ques_idxs"], tf.int32), [ques_limit])
     context_char_idxs = tf.reshape(tf.decode_raw(
         features["context_char_idxs"], tf.int32), [para_limit, char_limit])
     ques_char_idxs = tf.reshape(tf.decode_raw(
         features["ques_char_idxs"], tf.int32), [ques_limit, char_limit])
     y1 = tf.reshape(tf.decode_raw(
         features["y1"], tf.float32), [para_limit])
     y2 = tf.reshape(tf.decode_raw(
         features["y2"], tf.float32), [para_limit])
     qa_id = features["id"]
     return context_idxs, ques_idxs, context_char_idxs, ques_char_idxs, y1, y2, qa_id
def read_and_decode(filename):
    # 根据文件名生成一个队列
    filename_queue = tf.train.string_input_producer([filename])
    reader = tf.TFRecordReader()
    # 返回文件名和文件
    _, serialized_example = reader.read(filename_queue)   
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'image' : tf.FixedLenFeature([], tf.string),
                                           'label0': tf.FixedLenFeature([], tf.int64),
                                           'label1': tf.FixedLenFeature([], tf.int64),
                                           'label2': tf.FixedLenFeature([], tf.int64),
                                           'label3': tf.FixedLenFeature([], tf.int64),
                                       })
    # 获取图片数据
    image = tf.decode_raw(features['image'], tf.uint8)
    # tf.train.shuffle_batch必须确定shape
    image = tf.reshape(image, [224, 224])
    # 图片预处理
    image = tf.cast(image, tf.float32) / 255.0
    image = tf.subtract(image, 0.5)
    image = tf.multiply(image, 2.0)
    # 获取label
    label0 = tf.cast(features['label0'], tf.int32)
    label1 = tf.cast(features['label1'], tf.int32)
    label2 = tf.cast(features['label2'], tf.int32)
    label3 = tf.cast(features['label3'], tf.int32)

    return image, label0, label1, label2, label3
Ejemplo n.º 9
0
  def _test(self, kwargs, expected_values=None, expected_err_re=None):
    with self.test_session() as sess:
      # Pull out some keys to check shape inference
      dense_keys = kwargs["dense_keys"] if "dense_keys" in kwargs else []
      sparse_keys = kwargs["sparse_keys"] if "sparse_keys" in kwargs else []
      dense_shapes = kwargs["dense_shapes"] if "dense_shapes" in kwargs else []

      # Returns dict w/ Tensors and SparseTensors
      out = tf.parse_single_example(**kwargs)

      # Check shapes
      self.assertEqual(len(dense_keys), len(dense_shapes))
      for (k, s) in zip(dense_keys, dense_shapes):
        self.assertEqual(tuple(out[k].get_shape()), s)
      for k in sparse_keys:
        self.assertEqual(tuple(out[k].indices.get_shape().as_list()), (None, 1))
        self.assertEqual(tuple(out[k].values.get_shape().as_list()), (None,))
        self.assertEqual(tuple(out[k].shape.get_shape().as_list()), (1,))

      # Check values
      result = flatten_values_tensors_or_sparse(out.values())  # flatten values
      if expected_err_re is None:
        tf_result = sess.run(result)
        _compare_output_to_expected(self, out, expected_values, tf_result)
      else:
        with self.assertRaisesOpError(expected_err_re):
          sess.run(result)
Ejemplo n.º 10
0
  def _input_fn():
    with tf.name_scope('input'):
        filename_queue = tf.train.string_input_producer(
            filenames, num_epochs=num_epochs)

        reader = tf.TFRecordReader()
        _, serialized_example = reader.read_up_to(filename_queue)

        features = tf.parse_single_example(
            serialized_examples,
            {
                'words': tf.VarLenFeature(tf.string),
                'subreddit': tf.FixedLenFeature([1], tf.int64)
            }
        )
        padded_words = tf.sparse_to_dense(
            features['words'].indices,
            [sentence_length],
            features['words'].values,
            default_value='UNK'
        )
        word_indices = tf.string_to_hash_bucket_fast(
            padded_words,
            vocab_size)

        sentences, subreddits = tf.train.shuffle_batch(
            [word_indices, features['subreddit']],
            batch_size,
            capacity=1000 + 3 * batch_size,
            min_after_dequeue=1000,
            enqueue_many=False
        )
    return sentences, subreddits
Ejemplo n.º 11
0
def read_and_decode(filename_queue):
	reader = tf.TFRecordReader()
	_, serialized_example = reader.read(filename_queue)
	features = tf.parse_single_example(
		serialized_example,
		# Defaults are not specified since both keys are required.
		features={
			'image_raw': tf.FixedLenFeature([], tf.string),
			'label':     tf.FixedLenFeature([], tf.int64),
		})
	
	# Convert from a scalar string tensor (whose single string has
	# length mnist.IMAGE_PIXELS) to a uint8 tensor with shape
	# [mnist.IMAGE_PIXELS].
	image = tf.decode_raw(features['image_raw'], tf.uint8)
	image.set_shape([57600])

	# OPTIONAL: Could reshape into a 28x28 image and apply distortions
	# here.  Since we are not applying any distortions in this
	# example, and the next step expects the image to be flattened
	# into a vector, we don't bother.

	# Convert from [0, 255] -> [-0.5, 0.5] floats.
	image = tf.cast(image, tf.float32) * (1. / 255) - 0.5

	# Convert label from a scalar uint8 tensor to an int32 scalar.
	#label = tf.cast(features['label'], tf.int32) <-- placeholder instead

	return tf.reshape(image, [160, 120, 3]), tf.placeholder(tf.int32) # TODO doublecheck this
Ejemplo n.º 12
0
def _parse_example_proto(example_serialized):
  """Parses an Example proto containing a training example of an image.

  The dataset contains serialized Example protocol buffers.
  The Example proto is expected to contain features named
  image/encoded (a JPEG-encoded string) and image/class/label (int)

  Args:
    example_serialized: scalar Tensor tf.string containing a serialized
      Example protocol buffer.

  Returns:
    image_buffer: Tensor tf.string containing the contents of a JPEG file.
    label: Tensor tf.int64 containing the label.
  """
  # Dense features in Example proto.
  feature_map = {
      'image/encoded': tf.FixedLenFeature([], dtype=tf.string,
                                          default_value=''),
      'image/class/label': tf.FixedLenFeature([1], dtype=tf.int64,
                                              default_value=-1)
  }

  features = tf.parse_single_example(example_serialized, feature_map)

  return features['image/encoded'], features['image/class/label']
Ejemplo n.º 13
0
def parse_labeled_example(
    example_proto, view_index, preprocess_fn, image_attr_keys, label_attr_keys):
  """Parses a labeled test example from a specified view.

  Args:
    example_proto: A scalar string Tensor.
    view_index: Int, index on which view to parse.
    preprocess_fn: A function with the signature (raw_images, is_training) ->
      preprocessed_images, where raw_images is a 4-D float32 image `Tensor`
      of raw images, is_training is a Boolean describing if we're in training,
      and preprocessed_images is a 4-D float32 image `Tensor` holding
      preprocessed images.
    image_attr_keys: List of Strings, names for image keys.
    label_attr_keys: List of Strings, names for label attributes.
  Returns:
    data: A tuple of images, attributes and tasks `Tensors`.
  """
  features = {}
  for attr_key in image_attr_keys:
    features[attr_key] = tf.FixedLenFeature((), tf.string)
  for attr_key in label_attr_keys:
    features[attr_key] = tf.FixedLenFeature((), tf.int64)
  parsed_features = tf.parse_single_example(example_proto, features)
  image_only_keys = [i for i in image_attr_keys if 'image' in i]
  view_image_key = image_only_keys[view_index]
  image = preprocessing.decode_image(parsed_features[view_image_key])
  preprocessed = preprocess_fn(image, is_training=False)
  attributes = [parsed_features[k] for k in label_attr_keys]
  task = parsed_features['task']
  return tuple([preprocessed] + attributes + [task])
Ejemplo n.º 14
0
def read_and_decode(filename_queue):
  reader = tf.TFRecordReader()
  _, serialized_example = reader.read(filename_queue)
  features = tf.parse_single_example(
      serialized_example,
      dense_keys=['image_raw', 'label'],
      # Defaults are not specified since both keys are required.
      dense_types=[tf.string, tf.int64])

  # Convert from a scalar string tensor (whose single string has
  # length mnist.IMAGE_PIXELS) to a uint8 tensor with shape
  # [mnist.IMAGE_PIXELS].
  image = tf.decode_raw(features['image_raw'], tf.uint8)
  image.set_shape([mnist.IMAGE_PIXELS])

  # OPTIONAL: Could reshape into a 28x28 image and apply distortions
  # here.  Since we are not applying any distortions in this
  # example, and the next step expects the image to be flattened
  # into a vector, we don't bother.

  # Convert from [0, 255] -> [-0.5, 0.5] floats.
  image = tf.cast(image, tf.float32) * (1. / 255) - 0.5

  # Convert label from a scalar uint8 tensor to an int32 scalar.
  label = tf.cast(features['label'], tf.int32)

  return image, label
Ejemplo n.º 15
0
def getImage(filenames):
	# convert filenames to a queue for an input pipeline.
	filenameQ = tf.train.string_input_producer(filenames,num_epochs=None)

	# object to read records
	recordReader = tf.TFRecordReader()

	# read the full set of features for a single example
	key, fullExample = recordReader.read(filenameQ)

	# parse the full example into its' component features.
	features = tf.parse_single_example(
        fullExample,
        features={
            'image/height': tf.FixedLenFeature([], tf.int64),
            'image/width': tf.FixedLenFeature([], tf.int64),
            'image/depth': tf.FixedLenFeature([], tf.int64),
            'image/class/label': tf.FixedLenFeature([],tf.int64),
            'image/class/text': tf.FixedLenFeature([], dtype=tf.string,default_value=''),
            'image/filename': tf.FixedLenFeature([], dtype=tf.string,default_value=''),
            'image/encoded': tf.FixedLenFeature([], dtype=tf.string, default_value='')
        })

	label = features['image/class/label']
	image_buffer = features['image/encoded']

	image = tf.decode_raw(image_buffer, tf.float32)
	image = tf.reshape(image, tf.stack([FLAGS.width*FLAGS.height*FLAGS.depth]))

	label=tf.stack(tf.one_hot(label-1, nLabel))
	return label, image
Ejemplo n.º 16
0
  def dataset_parser(self, value):
    """Parse an ImageNet record from a serialized string Tensor."""
    keys_to_features = {
        'image/encoded': tf.FixedLenFeature((), tf.string, ''),
        'image/format': tf.FixedLenFeature((), tf.string, 'jpeg'),
        'image/class/label': tf.FixedLenFeature([], tf.int64, -1),
        'image/class/text': tf.FixedLenFeature([], tf.string, ''),
        'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32),
        'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32),
        'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32),
        'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32),
        'image/object/class/label': tf.VarLenFeature(dtype=tf.int64),
    }

    parsed = tf.parse_single_example(value, keys_to_features)
    image_bytes = tf.reshape(parsed['image/encoded'], shape=[])

    image = self.image_preprocessing_fn(
        image_bytes=image_bytes,
        is_training=self.is_training,
        image_size=self.image_size,
        use_bfloat16=self.use_bfloat16)

    # Subtract one so that labels are in [0, 1000).
    label = tf.cast(
        tf.reshape(parsed['image/class/label'], shape=[]), dtype=tf.int32) - 1

    return image, label
Ejemplo n.º 17
0
def tfrecord_to_graph_ops(filenames, num_epochs):
    file_queue = tf.train.string_input_producer(
        filenames, name='file_queue', num_epochs=num_epochs
    )
    reader = tf.TFRecordReader(
        options=tf.python_io.TFRecordOptions(
            compression_type=tf.python_io.TFRecordCompressionType.GZIP
        )
    )
    _, tfrecord = reader.read(file_queue)

    tfrecord_features = tf.parse_single_example(
        tfrecord,
        features={
            'images': tf.FixedLenFeature([], tf.string),
            'labels': tf.FixedLenFeature([], tf.string),
        },
        name='data'
    )
    tfeat = tf.decode_raw(tfrecord_features['images'], tf.uint8)
    # note, 'NCHW' is only supported on GPUs, so use 'NHWC'...
    tfeat = tf.reshape(tfeat, [-1, 28, 28, 1])
    ttarg = tf.decode_raw(tfrecord_features['labels'], tf.uint8)
    ttarg = tf.one_hot(indices=ttarg, depth=10, on_value=1, off_value=0)
    return tfeat, ttarg
Ejemplo n.º 18
0
  def _parser(serialized_example):
    """Parses a single tf.Example into image and label tensors."""
    features = tf.parse_single_example(
        serialized_example,
        features={
            "image": tf.FixedLenFeature([], tf.string),
            "label": tf.FixedLenFeature([], tf.int64),
        })
    image = tf.decode_raw(features["image"], tf.uint8)
    # Initially reshaping to [H, W, C] does not work
    image = tf.reshape(image, [NUM_CHANNEL, IMAGE_HEIGHT, IMAGE_WIDTH])
    # This is needed for `tf.image.resize_image_with_crop_or_pad`
    image = tf.transpose(image, [1, 2, 0])

    image = tf.cast(image, dtype)
    label = tf.cast(features["label"], tf.int32)

    if data_aug:
      image = tf.image.resize_image_with_crop_or_pad(image, IMAGE_HEIGHT + 4,
                                                     IMAGE_WIDTH + 4)
      image = tf.random_crop(image, [IMAGE_HEIGHT, IMAGE_WIDTH, NUM_CHANNEL])
      image = tf.image.random_flip_left_right(image)

    if data_format == "channels_first":
      image = tf.transpose(image, [2, 0, 1])

    if div255:
      image /= 255.

    return image, label
Ejemplo n.º 19
0
  def read_and_preprocess(example_data):
    """parses tfrecord and returns image, label.

    Args:
      example_data (str): tfrecord
    Returns:
      img, label
    """
    height = width = PATCH_SIZE(params)
    parsed = tf.parse_single_example(
        example_data, {
            'ref': tf.VarLenFeature(tf.float32),
            'ltg': tf.VarLenFeature(tf.float32),
            'has_ltg': tf.FixedLenFeature([], tf.int64, 1),
        })
    parsed['ref'] = _sparse_to_dense(parsed['ref'], height * width)
    parsed['ltg'] = _sparse_to_dense(parsed['ltg'], height * width)

    # keras wants labels to be float32
    label = tf.cast(
      tf.reshape(parsed['has_ltg'], shape=[]),
      dtype=tf.float32)
    print('shape of label {}'.format(label.shape))

    img = reshape_into_image(parsed, params)
    return img, label
Ejemplo n.º 20
0
def read_cifar10(filename_queue):
  """Reads and parses examples from CIFAR10 data files.

  Recommendation: if you want N-way read parallelism, call this function
  N times.  This will give you N independent Readers reading different
  files & positions within those files, which will give better mixing of
  examples.

  Args:
    filename_queue: A queue of strings with the filenames to read from.

  Returns:
    An object representing a single example, with the following fields:
      height: number of rows in the result (32)
      width: number of columns in the result (32)
      depth: number of color channels in the result (3)
      key: a scalar string Tensor describing the filename & record number
        for this example.
      label: an int32 Tensor with the label in the range 0..9.
      uint8image: a [height, width, depth] uint8 Tensor with the image data
  """

  class CIFAR10Record(object):
    pass
  result = CIFAR10Record()

  # Dimensions of the images in the CIFAR-10 dataset.
  # See http://www.cs.toronto.edu/~kriz/cifar.html for a description of the
  # input format.
  label_bytes = 1  # 2 for CIFAR-100
  result.height = 256
  result.width = 256
  result.depth = 3
  image_bytes = result.height * result.width * result.depth
  # Every record consists of a label followed by the image, with a
  # fixed number of bytes for each.
  record_bytes = label_bytes + image_bytes

  # Read a record, getting filenames from the filename_queue.  No
  # header or footer in the CIFAR-10 format, so we leave header_bytes
  # and footer_bytes at their default of 0.
  reader = tf.TFRecordReader()
  _, serialized_example = reader.read(filename_queue)
  features = tf.parse_single_example(
      serialized_example,
      # Defaults are not specified since both keys are required.
      features={
          'image_raw': tf.FixedLenFeature([], tf.string),
          'label': tf.FixedLenFeature([], tf.int64),
      })

  record_bytes = tf.decode_raw(features['image_raw'], tf.uint8)
  # depth_major = tf.reshape(record_bytes, [result.depth, result.height, result.width])
  # Convert from [depth, height, width] to [height, width, depth].
  result.uint8image =  tf.reshape(record_bytes, [result.height, result.width, result.depth])

  # The first bytes represent the label, which we convert from uint8->int32.
  result.label = tf.cast(features['label'], tf.int32)

  return result
Ejemplo n.º 21
0
def parser(example):
    features = {
                'xywhc': tf.FixedLenFeature([150], tf.float32),
                'img': tf.FixedLenFeature((), tf.string)}
    feats = tf.parse_single_example(example, features)
    coord = feats['xywhc']
    coord = tf.reshape(coord, [30, 5])

    img = tf.decode_raw(feats['img'], tf.float32)
    img = tf.reshape(img, [416, 416, 3])
    img = tf.image.resize_images(img, [cfg.train.image_resized, cfg.train.image_resized])
    rnd = tf.less(tf.random_uniform(shape=[], minval=0, maxval=2), 1)

    def flip_img_coord(_img, _coord):
        zeros = tf.constant([[0, 0, 0, 0, 0]]*30, tf.float32)
        img_flipped = tf.image.flip_left_right(_img)
        idx_invalid = tf.reduce_all(tf.equal(coord, 0), axis=-1)
        coord_temp = tf.concat([tf.minimum(tf.maximum(1 - _coord[:, :1], 0), 1),
                               _coord[:, 1:]], axis=-1)
        coord_flipped = tf.where(idx_invalid, zeros, coord_temp)
        return img_flipped, coord_flipped

    img, coord = tf.cond(rnd, lambda: (tf.identity(img), tf.identity(coord)), lambda: flip_img_coord(img, coord))

    img = tf.image.random_hue(img, max_delta=0.1)
    img = tf.image.random_contrast(img, lower=0.8, upper=1.2)
    img = tf.image.random_brightness(img, max_delta=0.1)
    img = tf.image.random_saturation(img, lower=0.8, upper=1.2)
    img = tf.minimum(img, 1.0)
    img = tf.maximum(img, 0.0)
    return img, coord
Ejemplo n.º 22
0
  def deserialize(examples_serialized):
    """Called by Dataset.map() to convert batches of records to tensors."""
    features = tf.parse_single_example(examples_serialized, feature_map)
    users = tf.reshape(tf.decode_raw(
        features[movielens.USER_COLUMN], tf.int32), (batch_size,))
    items = tf.reshape(tf.decode_raw(
        features[movielens.ITEM_COLUMN], tf.uint16), (batch_size,))

    if params["use_tpu"] or params["use_xla_for_gpu"]:
      items = tf.cast(items, tf.int32)  # TPU and XLA disallows uint16 infeed.

    if not training:
      dupe_mask = tf.reshape(tf.cast(tf.decode_raw(
          features[rconst.DUPLICATE_MASK], tf.int8), tf.bool), (batch_size,))
      return {
          movielens.USER_COLUMN: users,
          movielens.ITEM_COLUMN: items,
          rconst.DUPLICATE_MASK: dupe_mask,
      }

    labels = tf.reshape(tf.cast(tf.decode_raw(
        features["labels"], tf.int8), tf.bool), (batch_size,))

    return {
        movielens.USER_COLUMN: users,
        movielens.ITEM_COLUMN: items,
    }, labels
Ejemplo n.º 23
0
def build_input(tfrecord_paths):
  """Builds the graph's input.

  Args:
    tfrecord_paths: List of paths to the input TFRecords

  Returns:
    serialized_example_tensor: The next serialized example. String scalar Tensor
    image_tensor: The decoded image of the example. Uint8 tensor,
        shape=[1, None, None,3]
  """
  filename_queue = tf.train.string_input_producer(
      tfrecord_paths, shuffle=False, num_epochs=1)

  tf_record_reader = tf.TFRecordReader()
  _, serialized_example_tensor = tf_record_reader.read(filename_queue)
  features = tf.parse_single_example(
      serialized_example_tensor,
      features={
          standard_fields.TfExampleFields.image_encoded:
              tf.FixedLenFeature([], tf.string),
      })
  encoded_image = features[standard_fields.TfExampleFields.image_encoded]
  image_tensor = tf.image.decode_image(encoded_image, channels=3)
  image_tensor.set_shape([None, None, 3])
  image_tensor = tf.expand_dims(image_tensor, 0)

  return serialized_example_tensor, image_tensor
Ejemplo n.º 24
0
def read_and_decode(filename_queue):
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(
        serialized_example,
        # Defaults are not specified since both keys are required.
        features={
            'image_raw': tf.FixedLenFeature([], tf.string),
            'label': tf.FixedLenFeature([], tf.int64),
            'height': tf.FixedLenFeature([], tf.int64),
            'width': tf.FixedLenFeature([], tf.int64),
            'depth': tf.FixedLenFeature([], tf.int64)
        })

    image = tf.decode_raw(features['image_raw'], tf.uint8)
    img_height = tf.cast(features['height'], tf.int32)
    img_width = tf.cast(features['width'], tf.int32)
    img_depth = tf.cast(features['depth'], tf.int32)
    # Convert label from a scalar uint8 tensor to an int32 scalar.
    label = tf.cast(features['label'], tf.int32)

    image.set_shape([IMG_PIXELS])
    image = tf.reshape(image, [IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS])

    # Convert from [0, 255] -> [-0.5, 0.5] floats.
    image = tf.cast(image, tf.float32) * (1. / 255) - 0.5

    return image, label
Ejemplo n.º 25
0
def load_records_file(matcher):
    filename_queue = tf.train.string_input_producer(
        tf.train.match_filenames_once(".%s/*.tfrecords" % matcher))
    reader = tf.TFRecordReader()
    _, serialized = reader.read(filename_queue)

    features = tf.parse_single_example(
        serialized,
        features={
            'label': tf.FixedLenFeature([], tf.string),
            'image': tf.FixedLenFeature([], tf.string),
        })

    record_image = tf.decode_raw(features['image'], tf.uint8)

    # Changing the image into this shape helps train and visualize the
    # output by converting it to be organized like an image.
    image = tf.reshape(record_image, [250, 151, 1])
    label = tf.cast(features['label'], tf.string)

    min_after_dequeue = 10
    batch_size = 3
    capacity = min_after_dequeue + 3 * batch_size
    image_batch, label_batch = tf.train.shuffle_batch(
        [image, label],
        batch_size=batch_size,
        capacity=capacity,
        min_after_dequeue=min_after_dequeue)
    return image_batch, label_batch
Ejemplo n.º 26
0
def record_parser_fn(value, is_training):
    """Parse an image record from `value`."""
    keys_to_features = {
          'width': tf.FixedLenFeature([], dtype=tf.int64, default_value=0),
          'height': tf.FixedLenFeature([], dtype=tf.int64, default_value=0),
          'image': tf.FixedLenFeature([], dtype=tf.string, default_value=''),
          'label': tf.FixedLenFeature([], dtype=tf.int64, default_value=-1),
          'name': tf.FixedLenFeature([], dtype=tf.string, default_value='')
    }

    parsed = tf.parse_single_example(value, keys_to_features)

    image = tf.image.decode_image(tf.reshape(parsed['image'], shape=[]),
      FLAGS.image_channels)
    image = tf.image.convert_image_dtype(image, dtype=tf.float32)
    
    bbox = tf.concat(axis=0, values=[ [[]], [[]], [[]], [[]] ])
    bbox = tf.transpose(tf.expand_dims(bbox, 0), [0, 2, 1])
    image = image_preprocess.preprocess_image(
        image=image,
        output_height=FLAGS.image_size,
        output_width=FLAGS.image_size,
        object_cover=0.0, 
        area_cover=0.05,
        is_training=is_training,
        bbox=bbox)

    label = tf.cast(tf.reshape(parsed['label'], shape=[]),dtype=tf.int32)
    label = tf.one_hot(label, FLAGS.class_num)    

    return image, label
def get_Image(nameOFfile):
    filename_queue = tf.train.string_input_producer([nameOFfile], num_epochs = 10)

    reader = tf.TFRecordReader()

    key, image = reader.read(nameOFfile)

    features = tf.parse_single_example(image, features={
        'image/height': tf.FixedLenFeature([], tf.int64),
        'image/width': tf.FixedLenFeature([],tf.int64),
        'image/colorspace': tf.FixedLenFeature([],dtype=tf.string, default_value = ''),
        'image/channels': tf.FixedLenFeature([], tf.int64),
        'image/class/label': tf.FixedLenFeature([], tf.int64),
        'image/class/text': tf.FixedLenFeature([], dtype=tf.string, default_value = ''),
        'image/format': tf.FixedLenFeature([], dtype=tf.string, default_value = ''),
        'image/format': tf.FixedLenFeature([],dtype=tf.string, default_value=''),
        'image/filename': tf.FixedLenFeature([], dtype=tf.string,default_value=''),
        'image/encoded': tf.FixedLenFeature([], dtype=tf.string, default_value='')
        })

    labe = features['image/class/label']
    _buffer = features['image/encoded']

    with tf.name_scope('decode_jpeg', [_buffer], None):
        pic = tf.image.decode_jpeg(_buffer, channels=3)

        pic = tf.image.convert_image_dtype(pic, dtype=tf.float32)

        pic = tf.reshape(1-tf.image.rgb_to_grayscale(image), [height*width])

        labe = tf.stack(tf.one_hot(labe-1, nClass))

        return labe, pic
Ejemplo n.º 28
0
  def get_example(self, batch_size):
    """Get a single example from the tfrecord file.

    Args:
      batch_size: Int, minibatch size.

    Returns:
      tf.Example protobuf parsed from tfrecord.
    """
    reader = tf.TFRecordReader()
    num_epochs = None if self.is_training else 1
    capacity = batch_size
    path_queue = tf.train.input_producer(
        [self.record_path],
        num_epochs=num_epochs,
        shuffle=self.is_training,
        capacity=capacity)
    unused_key, serialized_example = reader.read(path_queue)
    features = {
        "note_str": tf.FixedLenFeature([], dtype=tf.string),
        "pitch": tf.FixedLenFeature([1], dtype=tf.int64),
        "velocity": tf.FixedLenFeature([1], dtype=tf.int64),
        "audio": tf.FixedLenFeature([64000], dtype=tf.float32),
        "qualities": tf.FixedLenFeature([10], dtype=tf.int64),
        "instrument_source": tf.FixedLenFeature([1], dtype=tf.int64),
        "instrument_family": tf.FixedLenFeature([1], dtype=tf.int64),
    }
    example = tf.parse_single_example(serialized_example, features)
    return example
Ejemplo n.º 29
0
def read_image(file_queue):
	reader = tf.TFRecordReader()
	# key, value = reader.read(file_queue)
	_, serialized_example = reader.read(file_queue)
	features = tf.parse_single_example(
		serialized_example,
		features={
			'label': tf.FixedLenFeature([], tf.string),
			'image_raw': tf.FixedLenFeature([], tf.string)
			})

	image = tf.decode_raw(features['image_raw'], tf.uint8)
	# print('image ' + str(image))
	image = tf.reshape(image, [INPUT_IMG_WIDE, INPUT_IMG_HEIGHT, INPUT_IMG_CHANNEL])
	# image = tf.image.convert_image_dtype(image, dtype=tf.float32)
	# image = tf.image.resize_images(image, (IMG_HEIGHT, IMG_WIDE))
	# image = tf.cast(image, tf.float32) * (1. / 255) - 0.5

	label = tf.decode_raw(features['label'], tf.uint8)
	# label = tf.cast(label, tf.int64)
	label = tf.reshape(label, [OUTPUT_IMG_WIDE, OUTPUT_IMG_HEIGHT])
	# label = tf.decode_raw(features['image_raw'], tf.uint8)
	# print(label)
	# label = tf.reshape(label, shape=[1, 4])
	return image, label
Ejemplo n.º 30
0
def run():
    with tf.Session() as sess:
        print("start")
        feature = {'image': tf.FixedLenFeature([], tf.string),
                   'label': tf.FixedLenFeature([], tf.int64)}
        # Create a list of filenames and pass it to a queue
        print(data_path)
        filename_queue = tf.train.string_input_producer(data_path, num_epochs=1)
        # Define a reader and read the next record
        reader = tf.TFRecordReader()
        _, serialized_example = reader.read(filename_queue)
        # Decode the record read by the reader
        features = tf.parse_single_example(serialized_example, features=feature)
        # Convert the image data from string back to the numbers
        image = tf.decode_raw(features['image'], tf.uint8)
        # image = tf.cast(image, tf.int32)

        # Cast label data into int32
        label = tf.cast(features['label'], tf.int32)
        # Reshape image data into the original shape
        init_op = [tf.global_variables_initializer(), tf.local_variables_initializer()]
        sess.run(init_op)

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(coord=coord)
        train_list = []
        for i in range(1000):
            example, l = sess.run([image, label])
            train_list.append((example,l))
            # print (example, l)
        coord.request_stop()
        coord.join(threads)
        return train_list
# run()
    def load_from_tfRecord(self, filename_queue, resize_size=None):

        reader = tf.TFRecordReader()
        _, serialized_example = reader.read(filename_queue)

        features = tf.parse_single_example(serialized_example,
                                           features={
                                               'image_raw':
                                               tf.FixedLenFeature([],
                                                                  tf.string),
                                               'width':
                                               tf.FixedLenFeature([],
                                                                  tf.int64),
                                               'height':
                                               tf.FixedLenFeature([], tf.int64)
                                           })

        image = tf.decode_raw(features['image_raw'], tf.float32)
        orig_height = tf.cast(features['height'], tf.int32)
        orig_width = tf.cast(features['width'], tf.int32)

        image_shape = tf.pack([orig_height, orig_width, 3])
        image_tf = tf.reshape(image, image_shape)
        print image_shape
        resized_image = tf.image.resize_image_with_crop_or_pad(
            image_tf,
            target_height=resize_size[1],
            target_width=resize_size[0])

        images = tf.train.shuffle_batch([resized_image],
                                        batch_size=self.batch_size,
                                        num_threads=1,
                                        capacity=50,
                                        min_after_dequeue=10)

        return images
Ejemplo n.º 32
0
def read_and_decode_from_tfrecord(filename):
    # 创建文件队列,不限读取的数量
    filename_queue = tf.train.string_input_producer([filename])
    # create a reader from file queue
    reader = tf.TFRecordReader()
    # reader从文件队列中读入一个序列化的样本
    _, serialized_example = reader.read(filename_queue)
    # get feature from serialized example
    # 解析符号化的样本
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'label':
                                           tf.FixedLenFeature([], tf.int64),
                                           'img_raw':
                                           tf.FixedLenFeature([], tf.string),
                                       })

    img = tf.decode_raw(features['img_raw'], tf.uint8)
    img = tf.reshape(img, [224, 224, 3])  #[W,H,C]
    # Normalize the values of the image from the range [0, 255] to [-0.5, 0.5]
    #     image = tf.cast(img, tf.float32) / 255 - 0.5
    img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
    label = tf.cast(features['label'], tf.int32)
    return img, label
Ejemplo n.º 33
0
def get_split(config,
              split_name,
              dataset_dir,
              batch_size,
              file_pattern=None,
              reader=None):
    """Gets a dataset tuple with instructions for reading flowers.
  Args:
    split_name: A train/validation split name.
    dataset_dir: The base directory of the dataset sources.
    file_pattern: The file pattern to use when matching the dataset sources.
      It is assumed that the pattern contains a '%s' string so that the split
      name can be inserted.
    reader: The TensorFlow reader type.
  Returns:
    A `Dataset` namedtuple.
  Raises:
    ValueError: if `split_name` is not a valid train/validation split.
  """
    all_file = []
    reader = tf.TFRecordReader()
    batch_size = config.batch_size
    data_splitnum = config.data_split_num
    file_pattern = _FILE_PATTERN

    if split_name == 'train':
        num_epochs = None
        for i in range(data_splitnum):
            all_file.append(
                os.path.join(dataset_dir, 'mnist_fashion/',
                             file_pattern % (split_name, i)))
    elif split_name == 'test':
        num_epochs, batch_size = 1, 1
        all_file.append(
            os.path.join(dataset_dir, 'mnist_fashion/',
                         file_pattern % (split_name, 0)))
    elif split_name not in SPLITS_TO_SIZES:
        raise ValueError('split name %s was not recognized.' % split_name)

    filename_queue = tf.train.string_input_producer(all_file,
                                                    num_epochs=num_epochs,
                                                    shuffle=False)

    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'height':
                                           tf.FixedLenFeature([], tf.int64),
                                           'width':
                                           tf.FixedLenFeature([], tf.int64),
                                           'image_string':
                                           tf.FixedLenFeature([], tf.string),
                                           'label':
                                           tf.FixedLenFeature([], tf.float32)
                                       })

    image = tf.decode_raw(features['image_string'], tf.uint8)
    label = tf.cast(features['label'], tf.float32)
    height = tf.cast(features['height'], tf.int32)
    width = tf.cast(features['width'], tf.int32)

    image = tf.reshape(image, [height, width, 1])
    resized_image = tf.image.resize_images(images=image,
                                           size=[IMAGE_HEIGHT, IMAGE_WIDTH])

    min_after_dequeue = 10000
    capacity = min_after_dequeue + 3 * batch_size

    images, labels = tf.train.shuffle_batch(
        [resized_image, label],
        batch_size=batch_size,
        capacity=capacity,
        num_threads=1,
        min_after_dequeue=min_after_dequeue,
        seed=config.random_seed)

    return images, labels, SPLITS_TO_SIZES[split_name]
Ejemplo n.º 34
0
 def parse_record(example_proto):
     parsed_example = tf.parse_single_example(example_proto, tf_record_dict)
     for key in tf_record_dict.keys():
         parsed_example[key] = tf.reshape(parsed_example[key], ())
     label = parsed_example.pop('label')
     return parsed_example, label
Ejemplo n.º 35
0
    def decode(self, data, items):
        """Decodes the data to return the tensors specified by the list of
        items with numpy support.

        Args:
            data: The TFRecord data(serialized example) to decode.
            items: A list of strings, each of which is the name of the resulting
                tensors to retrieve.

        Returns:
            A list of tensors, each of which corresponds to each item.
        """
        # pylint: disable=too-many-branches
        feature_description = dict()
        for key, value in self._feature_original_types.items():
            shape = []  ###debug
            if len(value) == 3:
                if isinstance(value[-1], int):
                    shape = [value[-1]]
                elif isinstance(value[-1], list):
                    shape = value
            if len(value) < 2 or value[1] == 'FixedLenFeature':
                feature_description.update({
                    key:
                    tf.FixedLenFeature(shape, dtypes.get_tf_dtype(value[0]))
                })
            elif value[1] == 'VarLenFeature':
                feature_description.update(
                    {key: tf.VarLenFeature(dtypes.get_tf_dtype(value[0]))})
            else:
                shape = []
        decoded_data = tf.parse_single_example(data, feature_description)

        # Handle TFRecord containing images
        if isinstance(self._image_options, dict):
            self._decode_image_str_byte(self._image_options, decoded_data)
        elif isinstance(self._image_options, HParams):
            self._decode_image_str_byte(self._image_options.todict(),
                                        decoded_data)
        elif isinstance(self._image_options, list):
            _ = list(
                map(lambda x: self._decode_image_str_byte(x, decoded_data),
                    self._image_options))

        # Handle TFRecord containing numpy.ndarray
        if isinstance(self._numpy_options, dict):
            self._decode_numpy_ndarray_str_byte(self._numpy_options,
                                                decoded_data)
        elif isinstance(self._numpy_options, HParams):
            self._decode_numpy_ndarray_str_byte(self._numpy_options.todict(),
                                                decoded_data)

        # Convert Dtypes
        for key, value in self._feature_convert_types.items():
            from_type = decoded_data[key].dtype
            to_type = dtypes.get_tf_dtype(value)
            if from_type is to_type:
                continue
            elif to_type is tf.string:
                decoded_data[key] = tf.dtypes.as_string(decoded_data[key])
            elif from_type is tf.string:
                decoded_data[key] = tf.string_to_number(
                    decoded_data[key], to_type)
            else:
                decoded_data[key] = tf.cast(decoded_data[key], to_type)
        outputs = decoded_data
        return [outputs[item] for item in items]
Ejemplo n.º 36
0
def parse_tfrecord_tf(record):
    features = tf.parse_single_example(record, features={
        'shape': tf.FixedLenFeature([3], tf.int64),
        'data': tf.FixedLenFeature([], tf.string)})
    data = tf.decode_raw(features['data'], tf.uint8)
    return tf.reshape(data, features['shape'])
Ejemplo n.º 37
0
        f = file(output_file, 'rb')
        records_done = pkl.load(f)
        f.close()
    else:
        records_done = {}

    if record in records_done:
        print(record + ' : Skipped')
        print(len(records_done) / float(len(records_todo)))
        continue

    filepaths_queue = tf.train.string_input_producer([input_dir + record],
                                                     num_epochs=1)
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filepaths_queue)
    features = tf.parse_single_example(serialized_example,
                                       features=features_format)

    new_filepath = output_dir + record
    writer = tf.python_io.TFRecordWriter(new_filepath)

    with tf.Session() as sess:
        init_op = tf.group(tf.global_variables_initializer(),
                           tf.local_variables_initializer())
        sess.run(init_op)
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(coord=coord)
        counter = 0
        try:
            while True:
                proc_features, = sess.run([features])
                counter += 1
Ejemplo n.º 38
0
import tensorflow as tf
reader = tf.TFRecordReader()
filename_queue = tf.train.string_input_producer(["output.tfrecords"])
_, serialized_example = reader.read(filename_queue)  #返回文件名和文件
features = tf.parse_single_example(serialized_example,
                                   features={
                                       'image_raw':
                                       tf.FixedLenFeature([], tf.string),
                                       'pixels':
                                       tf.FixedLenFeature([], tf.int64),
                                       'label':
                                       tf.FixedLenFeature([], tf.int64)
                                   })  #取出包含image和label的feature对象
images = tf.decode_raw(features['image_raw'], tf.uint8)
labels = tf.cast(features['label'], tf.int32)
pixels = tf.cast(features['pixels'], tf.int32)

sess = tf.Session()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(10):
    image, label, pixel = sess.run([images, labels, pixels])
    print(pixel)
Ejemplo n.º 39
0
def predict(file_name):

    num = []

    cap = cv2.VideoCapture(file_name)

    file_name = (file_name.split(".mp4"))[0]
    ## Creating folder to save all the 100 frames from the video
    try:
        os.makedirs("ImageData/testingData/" + file_name)
    except OSError:
        print("Error: Creating directory of data")

    ## Setting the frame limit to 100
    cap.set(cv2.CAP_PROP_FRAME_COUNT, 101)
    length = 101
    count = 0
    ## Running a loop to each frame and saving it in the created folder
    while cap.isOpened():
        count += 1
        if length == count:
            break
        _, frame = cap.read()
        if frame is None:
            continue

        ## Resizing it to 256*256 to save the disk space and fit into the model
        frame = cv2.resize(frame, (256, 256), interpolation=cv2.INTER_CUBIC)
        # Saves image of the current frame in jpg file
        name = ("ImageData/testingData/" + str(file_name) + "/frame" +
                str(count) + ".jpg")
        cv2.imwrite(name, frame)

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

    addrs = []

    def load_image(addr):
        img = np.array(Image.open(addr).resize((224, 224), Image.ANTIALIAS))
        img = img.astype(np.uint8)
        return img

    def _float_feature(value):
        return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))

    def _bytes_feature(value):
        return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

    addrs = []

    filelist = glob.glob("ImageData/testingData/" + str(file_name) + "/*.jpg")
    addrs += filelist

    train_addrs = addrs
    train_filename = "test.tfrecords"  # address to save the TFRecords file
    writer = tf.python_io.TFRecordWriter(train_filename)
    for i in range(len(train_addrs)):
        # Load the image
        img = load_image(train_addrs[i])
        feature = {
            "test/image": _bytes_feature(tf.compat.as_bytes(img.tostring()))
        }
        # Create an example protocol buffer
        example = tf.train.Example(features=tf.train.Features(feature=feature))

        # Serialize to string and write on the file
        writer.write(example.SerializeToString())

    writer.close()
    sys.stdout.flush()

    BATCH_SIZE = 20
    REG_PENALTY = 0
    NUM_IMAGES = 100
    N_EPOCHS = 1

    imgs = tf.placeholder("float", [None, 224, 224, 3],
                          name="image_placeholder")
    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8,
                                allow_growth=True)
    config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)

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

        model = DAN(imgs, REG_PENALTY=REG_PENALTY, preprocess="vggface")
        tr_reader = tf.TFRecordReader()
        tr_filename_queue = tf.train.string_input_producer(["test.tfrecords"],
                                                           num_epochs=N_EPOCHS)
        _, tr_serialized_example = tr_reader.read(tr_filename_queue)
        tr_feature = {"test/image": tf.FixedLenFeature([], tf.string)}
        tr_features = tf.parse_single_example(tr_serialized_example,
                                              features=tr_feature)

        tr_image = tf.decode_raw(tr_features["test/image"], tf.uint8)
        tr_image = tf.reshape(tr_image, [224, 224, 3])
        tr_images = tf.train.shuffle_batch(
            [tr_image],
            batch_size=BATCH_SIZE,
            capacity=100,
            min_after_dequeue=BATCH_SIZE,
            allow_smaller_final_batch=True,
        )
        init_op = tf.group(tf.global_variables_initializer(),
                           tf.local_variables_initializer())
        sess.run(init_op)

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(coord=coord)
        file_list = ["param1.pkl", "param2.pkl"]
        epoch = 0
        for pickle_file in file_list:
            error = 0
            model.load_trained_model(pickle_file, sess)
            i = 0
            while i < NUM_IMAGES:
                i += BATCH_SIZE
                try:
                    epoch_x = sess.run(tr_images)
                except:
                    if error >= 5:
                        break
                    error += 1
                    continue
                output = sess.run([model.output],
                                  feed_dict={imgs: epoch_x.astype(np.float32)})
                num.append(output[0])
            epoch += 1
        coord.request_stop()
        # Wait for threads to stop
        coord.join(threads)
    a = np.round(np.mean(np.concatenate(num), axis=0), 3)
    a_json = {
        "Extraversion": a[0],
        "Neuroticism": a[1],
        "Agreeableness": a[2],
        "Conscientiousness": a[3],
        "Openness": a[4],
    }
    return a_json
Ejemplo n.º 40
0
    def parse_example_proto(
            self, example_serialized):  #TODO(lowres check this mainly)
        # Dense features in Example proto.
        feature_map = {
            'image/encoded':
            tf.VarLenFeature(dtype=tf.string),
            'image/speeds':
            tf.VarLenFeature(dtype=tf.float32),
            'image/class/video_name':
            tf.FixedLenFeature([1], dtype=tf.string, default_value=''),
        }
        if FLAGS.only_seg == 1:
            feature_map.update({
                'image/segmentation':
                tf.VarLenFeature(dtype=tf.string),
                'image/context':
                tf.VarLenFeature(dtype=tf.string)
            })

        if FLAGS.use_speed_yaw:
            feature_map.update({
                'sensor/yaw_imu':
                tf.VarLenFeature(dtype=tf.float32),
                'sensor/speed_steer':
                tf.VarLenFeature(dtype=tf.float32)
            })

        features = tf.parse_single_example(example_serialized, feature_map)

        # if the data is downsampled by a temporal factor, the starting point should be random, such that we could use
        # all the data
        if FLAGS.non_random_temporal_downsample:
            tstart = 0
        else:
            tstart = tf.random_uniform([],
                                       minval=0,
                                       maxval=FLAGS.temporal_downsample_factor,
                                       dtype=tf.int32)
        len_downsampled = FLAGS.FRAMES_IN_SEG // FLAGS.temporal_downsample_factor
        if FLAGS.only_seg == 1:
            seg = features['image/segmentation'].values[:]
            seg.set_shape([len_downsampled])
            ctx = features['image/context'].values[:]
            ctx.set_shape([len_downsampled])

        name = features['image/class/video_name']

        encoded = features['image/encoded'].values[:FLAGS.FRAMES_IN_SEG]
        encoded_sub = encoded[tstart::FLAGS.temporal_downsample_factor]
        encoded_sub.set_shape([len_downsampled])
        if FLAGS.no_image_input:
            # no image input is used, but the previous steps is done because
            # we assume we have an list of empty image inputs
            decoded = tf.zeros([
                len_downsampled,
                FLAGS.IM_HEIGHT / FLAGS.decode_downsample_factor,
                FLAGS.IM_WIDTH / FLAGS.decode_downsample_factor, 3
            ], tf.uint8)
        else:
            decoded = self.decode_jpeg(encoded_sub)
            if FLAGS.only_seg == 1:
                seg_decoded = self.decode_png(seg)
                ctx_decoded = tf.py_func(self.read_array, [ctx],
                                         [tf.float32])[0]
                ctx_decoded.set_shape(
                    [len_downsampled, ctx_channel, ctx_height, ctx_width])

        decoded_raw = decoded
        if FLAGS.resize_images != "":
            # should have format: new_height, new_width
            sp_size = FLAGS.resize_images.split(",")
            assert (len(sp_size) == 2)
            new_size = (int(sp_size[0]), int(sp_size[1]))
            decoded = tf.image.resize_bilinear(decoded, new_size)
            #decoded = tf.image.resize_nearest_neighbor(decoded, new_size)
            decoded = tf.cast(decoded, tf.uint8)

        speed = features['image/speeds'].values
        speed = tf.reshape(speed, [-1, 2])
        speed = speed[:FLAGS.FRAMES_IN_SEG, :]
        speed = speed[tstart::FLAGS.temporal_downsample_factor, :]
        speed.set_shape([len_downsampled, 2])

        # from speed to stop labels
        stop_label = tf.py_func(
            self.speed_to_future_has_stop,
            [speed, FLAGS.stop_future_frames, FLAGS.speed_limit_as_stop],
            [tf.int32])[0]  #TODO(lowres: length of smoothed time)
        stop_label.set_shape([len_downsampled])

        # Note that the turning heuristic is tuned for 3Hz video and urban area
        # Note also that stop_future_frames is reused for the turn
        turn = tf.py_func(
            self.turn_future_smooth,
            [speed, FLAGS.stop_future_frames, FLAGS.speed_limit_as_stop],
            [tf.float32])[0]  #TODO(lowres)
        turn.set_shape([len_downsampled, self.naction])

        if FLAGS.use_speed_yaw:
            yaw = features['sensor/yaw_imu'].values
            spd = features['sensor/speed_steer'].values
            ys = tf.pack([yaw, spd], axis=1, name="stack_yaw_speed")
            # Now the shape is N*2
            ys = ys[
                tstart:FLAGS.FRAMES_IN_SEG:FLAGS.temporal_downsample_factor, :]
            ys.set_shape([len_downsampled, 2])

            # compute locs from ys
            ys = tf.pad(ys, [[0, FLAGS.stop_future_frames], [0, 0]],
                        mode="SYMMETRIC",
                        name="pad_afterwards")
            ys = ys[FLAGS.stop_future_frames:, :]
            ys.set_shape([len_downsampled, 2])
            locs = ys
            print("data loader is using raw yaw and speed")
        else:
            # get the relative future location
            # Note that we again abuse the notation a little bit, reusing stop_future_frames
            # TODO: normalize the course and speed by time
            locs = tf.py_func(self.relative_future_course_speed, [
                speed, FLAGS.stop_future_frames,
                FLAGS.frame_rate / FLAGS.temporal_downsample_factor
            ], [tf.float32])[0]
            locs.set_shape([len_downsampled, 2])

        # batching one 10 second segments into several smaller segments
        batching_inputs = [decoded, speed, stop_label, turn, locs]
        if FLAGS.only_seg == 1:
            batching_inputs += [seg_decoded, ctx_decoded]
            decoded_raw_loc = 7
        else:
            decoded_raw_loc = 5
        batching_inputs += [decoded_raw]
        batched = [self.batching(x, len_downsampled) for x in batching_inputs]

        name = tf.tile(name, [batched[0].get_shape()[0].value])

        ins = batched[0:2] + [name]
        outs = batched[2:5]
        if FLAGS.city_data:
            # city batch means how many batch does each video sequence forms
            FLAGS.city_batch = len_downsampled // FLAGS.n_sub_frame

            # here we want to read in the cityscape data and downsample in the loop
            city_im_queue, city_seg_queue = self.queue_cityscape(
                FLAGS.city_image_list, FLAGS.city_label_list)

            global city_pointer
            city_pointer = 0
            read_n = city_frames * FLAGS.city_batch
            city_im, city_seg = tf.py_func(
                self.read_cityscape, [city_im_queue, city_seg_queue, read_n],
                [tf.float32, tf.int32])

            city_im = tf.reshape(city_im, [
                FLAGS.city_batch, city_frames, FLAGS.IM_HEIGHT, FLAGS.IM_WIDTH,
                city_im_channel
            ])
            city_seg = tf.reshape(city_seg, [
                FLAGS.city_batch, city_frames, FLAGS.IM_HEIGHT, FLAGS.IM_WIDTH,
                city_seg_channel
            ])

            if FLAGS.resize_images != "":
                # should have format: new_height, new_width
                sp_size = FLAGS.resize_images.split(",")
                assert (len(sp_size) == 2)
                new_size = (int(sp_size[0]), int(sp_size[1]))
                city_im = tf.reshape(city_im, [
                    FLAGS.city_batch * city_frames, FLAGS.IM_HEIGHT,
                    FLAGS.IM_WIDTH, city_im_channel
                ])
                city_seg = tf.reshape(city_seg, [
                    FLAGS.city_batch * city_frames, FLAGS.IM_HEIGHT,
                    FLAGS.IM_WIDTH, city_seg_channel
                ])
                city_im = tf.image.resize_bilinear(city_im, new_size)
                city_seg = tf.image.resize_nearest_neighbor(city_seg, new_size)
                city_im = tf.reshape(city_im, [
                    FLAGS.city_batch, city_frames, new_size[0], new_size[1],
                    city_im_channel
                ])
                city_seg = tf.reshape(city_seg, [
                    FLAGS.city_batch, city_frames, new_size[0], new_size[1],
                    city_seg_channel
                ])
            ins += [city_im]
            outs += [city_seg]
        if FLAGS.only_seg == 1:
            ins = ins + batched[5:7]
            outs = outs

        # adding the raw images
        ins += batched[decoded_raw_loc:(decoded_raw_loc + 1)]

        # dropout non-stop videos
        if FLAGS.balance_drop_prob > 0:
            retained = tf.py_func(self.no_stop_dropout_valid,
                                  [outs[0], FLAGS.balance_drop_prob],
                                  [tf.bool])[0]
            retained.set_shape([outs[0].get_shape()[0].value])

            select = lambda tensors, valid: [
                util.bool_select(x, valid) for x in tensors
            ]
            ins = select(ins, retained)
            outs = select(outs, retained)
        return ins, outs
Ejemplo n.º 41
0
def evaluate():
    graph = tf.Graph()
    batch_size = 50
    locs = './data/'
    with graph.as_default():
        data_path = [
            locs + 'valid_' + str(i) + '.tfrecords' for i in range(2)
        ]  # address to save the hdf5 file

        feature = {
            'image': tf.FixedLenFeature([], tf.string),
            'label': tf.FixedLenFeature([], tf.int64)
        }
        # Create a list of filenames and pass it to a queue
        filename_queue = tf.train.string_input_producer(data_path,
                                                        num_epochs=None)
        # Define a reader and read the next record
        reader = tf.TFRecordReader()
        _, serialized_example = reader.read(filename_queue)
        # Decode the record read by the reader
        features = tf.parse_single_example(serialized_example,
                                           features=feature)
        # Convert the image data from string back to the numbers
        image = tf.decode_raw(features['image'], tf.float32)
        image = tf.reshape(image, [28, 28, 1])

        # Cast label data into int32
        label = tf.cast(features['label'], tf.int32)
        # Reshape image data into the original shape


        image_valid, label_valid = tf.train.batch([image, label], batch_size=batch_size,\
        num_threads=2, capacity=5000, enqueue_many=False)
        logits = cnn.inference(image_valid, training=False)

        val_prediction = tf.nn.softmax(logits)
        correct_prediction = tf.equal(
            tf.cast(tf.argmax(val_prediction, 1), tf.int32), label_valid)
        valid_accuracy = tf.reduce_mean(tf.cast(correct_prediction,
                                                tf.float32))

    eval_times = 100
    with tf.Session(graph=graph) as sess:
        tf.global_variables_initializer().run()
        print('Initialized')
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        saver = tf.train.Saver()
        if tf.train.checkpoint_exists('./logs/model2.ckpt'):
            saver.restore(sess, './logs/model2.ckpt')
            print('model resored from saved version')
        valid_accuracies = []
        for eval_cnt in range(eval_times):
            valid_accuracy_val = sess.run([valid_accuracy])
            valid_accuracies += valid_accuracy_val
            #print('set %d, accuracy = %f' %(eval_cnt, valid_accuracy_val[0]))
        print('average accuracy over %d batches are %f' %
              (eval_times, np.mean(valid_accuracies)))
        coord.request_stop()
        coord.join(threads)
        print('Finished validation')
Ejemplo n.º 42
0
 def _parse_function(example_proto):
     features = {
         "image_string": tf.FixedLenFeature((), tf.string, default_value="")
     }
     parsed_features = tf.parse_single_example(example_proto, features)
     return parsed_features
Ejemplo n.º 43
0
def read_and_decode(filename):
    filename_queue = tf.train.string_input_producer([filename], shuffle=True)

    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(
        serialized_example,
        features={
            'label': tf.FixedLenFeature([], tf.int64),
            'img_raw': tf.FixedLenFeature([], tf.string),
            ####
            'img_raw1': tf.FixedLenFeature([], tf.string),
            'img_raw2': tf.FixedLenFeature([], tf.string),
            'img_raw3': tf.FixedLenFeature([], tf.string),
            'img_raw4': tf.FixedLenFeature([], tf.string),
            'img_raw5': tf.FixedLenFeature([], tf.string),
            'img_raw6': tf.FixedLenFeature([], tf.string),
            'img_raw7': tf.FixedLenFeature([], tf.string),
            'img_raw8': tf.FixedLenFeature([], tf.string),
            'img_raw9': tf.FixedLenFeature([], tf.string),
            'img_raw10': tf.FixedLenFeature([], tf.string),
            'img_raw11': tf.FixedLenFeature([], tf.string),
            'img_raw12': tf.FixedLenFeature([], tf.string),
            ####
        })

    img = tf.decode_raw(features['img_raw'], tf.uint8)
    ###
    img1 = tf.decode_raw(features['img_raw1'], tf.uint8)
    img2 = tf.decode_raw(features['img_raw2'], tf.uint8)
    img3 = tf.decode_raw(features['img_raw3'], tf.uint8)
    img4 = tf.decode_raw(features['img_raw4'], tf.uint8)
    img5 = tf.decode_raw(features['img_raw5'], tf.uint8)
    img6 = tf.decode_raw(features['img_raw6'], tf.uint8)
    img7 = tf.decode_raw(features['img_raw7'], tf.uint8)
    img8 = tf.decode_raw(features['img_raw8'], tf.uint8)
    img9 = tf.decode_raw(features['img_raw9'], tf.uint8)
    img10 = tf.decode_raw(features['img_raw10'], tf.uint8)
    img11 = tf.decode_raw(features['img_raw11'], tf.uint8)
    img12 = tf.decode_raw(features['img_raw12'], tf.uint8)
    ###
    img = tf.reshape(img, [128, 128, 3])
    img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
    #####
    img1 = tf.reshape(img1, [128, 128, 3])
    img1 = tf.cast(img1, tf.float32) * (1. / 255) - 0.5
    img2 = tf.reshape(img2, [128, 128, 3])
    img2 = tf.cast(img2, tf.float32) * (1. / 255) - 0.5
    img3 = tf.reshape(img3, [128, 128, 3])
    img3 = tf.cast(img3, tf.float32) * (1. / 255) - 0.5
    img4 = tf.cast(img4, tf.float32) * (1. / 255) - 0.5
    img4 = tf.reshape(img4, [128, 128, 3])
    img5 = tf.cast(img5, tf.float32) * (1. / 255) - 0.5
    img5 = tf.reshape(img5, [128, 128, 3])
    img6 = tf.cast(img6, tf.float32) * (1. / 255) - 0.5
    img6 = tf.reshape(img6, [128, 128, 3])
    img7 = tf.cast(img7, tf.float32) * (1. / 255) - 0.5
    img7 = tf.reshape(img7, [128, 128, 3])
    img8 = tf.reshape(img8, [128, 128, 3])
    img8 = tf.cast(img8, tf.float32) * (1. / 255) - 0.5
    img9 = tf.reshape(img9, [128, 128, 3])
    img9 = tf.cast(img9, tf.float32) * (1. / 255) - 0.5
    img10 = tf.reshape(img10, [128, 128, 3])
    img10 = tf.cast(img10, tf.float32) * (1. / 255) - 0.5
    img11 = tf.reshape(img11, [128, 128, 3])
    img11 = tf.cast(img11, tf.float32) * (1. / 255) - 0.5
    img12 = tf.reshape(img12, [128, 128, 3])
    img12 = tf.cast(img12, tf.float32) * (1. / 255) - 0.5
    #####
    label = tf.cast(features['label'], tf.int32)

    print(label)
    return img, label, img1, img2, img3, img4, img5, img6, img7, img8, img9, img10, img11, img12
Ejemplo n.º 44
0
def style_image_inputs(style_dataset_file,
                       batch_size=None,
                       image_size=None,
                       square_crop=False,
                       shuffle=True):
    """Loads a style image at random.

  Args:
    style_dataset_file: str, path to the tfrecord dataset of style files.
        The dataset is produced via the create_style_dataset.py script and is
        made of Example protobufs with the following features:
        * 'image_raw': byte encoding of the JPEG string of the style image.
        * 'label': integer identifier of the style image in [0, N - 1], where
              N is the number of examples in the dataset.
        * 'vgg_16/<LAYER_NAME>': Gram matrix at layer <LAYER_NAME> of the VGG-16
              network (<LAYER_NAME> in {conv,pool}{1,2,3,4,5}) for the style
              image.
    batch_size: int. If provided, batches style images. Defaults to None.
    image_size: int. The images will be resized bilinearly so that the smallest
        side has size image_size. Defaults to None.
    square_crop: bool. If True, square-crops to [image_size, image_size].
        Defaults to False.
    shuffle: bool, whether to shuffle style files at random. Defaults to True.

  Returns:
    If batch_size is defined, a 4-D tensor of shape [batch_size, ?, ?, 3] with
    values in [0, 1] for the style image, and 1-D tensor for the style label.

  Raises:
    ValueError: if center cropping is requested but no image size is provided,
        or if batch size is specified but center-cropping is not requested.
  """
    vgg_layers = [
        'vgg_16/conv1', 'vgg_16/pool1', 'vgg_16/conv2', 'vgg_16/pool2',
        'vgg_16/conv3', 'vgg_16/pool3', 'vgg_16/conv4', 'vgg_16/pool4',
        'vgg_16/conv5', 'vgg_16/pool5'
    ]

    if square_crop and image_size is None:
        raise ValueError('center-cropping requires specifying the image size.')
    if batch_size is not None and not square_crop:
        raise ValueError('batching requires center-cropping.')

    with tf.name_scope('style_image_processing'):
        filename_queue = tf.train.string_input_producer([style_dataset_file],
                                                        shuffle=False,
                                                        capacity=1,
                                                        name='filename_queue')
        if shuffle:
            examples_queue = tf.RandomShuffleQueue(
                capacity=64,
                min_after_dequeue=32,
                dtypes=[tf.string],
                name='random_examples_queue')
        else:
            examples_queue = tf.FIFOQueue(capacity=64,
                                          dtypes=[tf.string],
                                          name='fifo_examples_queue')
        reader = tf.TFRecordReader()
        _, value = reader.read(filename_queue)
        enqueue_ops = [examples_queue.enqueue([value])]
        tf.train.queue_runner.add_queue_runner(
            tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops))
        example_serialized = examples_queue.dequeue()
        features = tf.parse_single_example(
            example_serialized,
            features={
                'label': tf.FixedLenFeature([], tf.int64),
                'image_raw': tf.FixedLenFeature([], tf.string),
                'vgg_16/conv1': tf.FixedLenFeature([64, 64], tf.float32),
                'vgg_16/pool1': tf.FixedLenFeature([64, 64], tf.float32),
                'vgg_16/conv2': tf.FixedLenFeature([128, 128], tf.float32),
                'vgg_16/pool2': tf.FixedLenFeature([128, 128], tf.float32),
                'vgg_16/conv3': tf.FixedLenFeature([256, 256], tf.float32),
                'vgg_16/pool3': tf.FixedLenFeature([256, 256], tf.float32),
                'vgg_16/conv4': tf.FixedLenFeature([512, 512], tf.float32),
                'vgg_16/pool4': tf.FixedLenFeature([512, 512], tf.float32),
                'vgg_16/conv5': tf.FixedLenFeature([512, 512], tf.float32),
                'vgg_16/pool5': tf.FixedLenFeature([512, 512], tf.float32)
            })
        image = tf.image.decode_jpeg(features['image_raw'])
        label = features['label']
        gram_matrices = [features[vgg_layer] for vgg_layer in vgg_layers]
        image.set_shape([None, None, 3])

        if image_size:
            if square_crop:
                image = _aspect_preserving_resize(image, image_size + 2)
                image = _central_crop([image], image_size, image_size)[0]
                image.set_shape([image_size, image_size, 3])
            else:
                image = _aspect_preserving_resize(image, image_size)

        image = tf.to_float(image) / 255.0

        if batch_size is None:
            image = tf.expand_dims(image, 0)
        else:
            image_label_gram_matrices = tf.train.batch([image, label] +
                                                       gram_matrices,
                                                       batch_size=batch_size)
            image, label = image_label_gram_matrices[:2]
            gram_matrices = image_label_gram_matrices[2:]

        gram_matrices = dict([
            (vgg_layer, gram_matrix)
            for vgg_layer, gram_matrix in zip(vgg_layers, gram_matrices)
        ])
        return image, label, gram_matrices
Ejemplo n.º 45
0
# 有提供训练数据的TFRcord文件
files = tf.train.match_filenames_once(
    "/home/shenxj/tf-work/datasets/file_pattern-*")
filename_queue = tf.train.string_input_producer(files, shuffle=False)

# 使用类似7.1节中结婚嫂的方法解析TFRecord文件里的数据。这里假设image中存储的是图像
# 的原始数据,label为该样例所对应的标签。height,width和channels给出了图像的维度。
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_single_example(serialized_example,
                                   features={
                                       'image':
                                       tf.FixedLenFeature([], tf.string),
                                       'label':
                                       tf.FixedLenFeature([], tf.int64),
                                       'height':
                                       tf.FixedLenFeature([], tf.int64),
                                       'weigth':
                                       tf.FixedLenFeature([], tf.int64),
                                       'channels':
                                       tf.FixedLenFeature([], tf.int64),
                                   })
image, label = features['image'], features['label']
height, width = features['height'], features['wigth']
channels = features['channels']

# 从原始图像数据解析出像素矩阵,并根据图像尺寸还原图像
decoded_image = tf.decode_raw(image, tf.uint8)
decoded_image.set_shape([height, width, channels])
# 定义神经网络输入层图片的大小。
image_size = 299
Ejemplo n.º 46
0
  def dataset_parser(self, value):
    """Parse an ImageNet record from a serialized string Tensor."""
    if self.is_training:
        keys_to_features = {
            'image':
                tf.FixedLenFeature((), tf.string),
            'label':
                tf.FixedLenFeature([], tf.int64),
            'heatmap':
                tf.FixedLenFeature([], tf.string, default_value=''),
            'click_count':
                tf.FixedLenFeature([], tf.int64),
            'bbox':
                tf.FixedLenFeature(
                    [4], dtype=tf.int64, default_value=[0, 0, 0, 0])
        }
        parsed = tf.parse_single_example(value, keys_to_features)
        ccount = tf.cast(
            tf.reshape(parsed['click_count'], shape=[]), dtype=tf.int32)
        image_bytes = tf.reshape(parsed['image'], shape=[])
        hm_bytes = tf.reshape(parsed['heatmap'], shape=[])
        bbox = tf.cast(tf.reshape(parsed['bbox'], shape=[4]), tf.int64)
        image, hm, bbox = self.image_preprocessing_fn(
            image_bytes=image_bytes,
            hm_bytes=hm_bytes,
            bbox=bbox,
            is_training=self.is_training,
        )
        if self.use_bfloat:
            image = tf.cast(image, tf.bfloat16)
            hm = tf.cast(hm, tf.bfloat16)
            bbox = tf.cast(bbox, tf.bfloat16)
        image = {'image': image, 'hm': hm, 'bbox': bbox, 'ccount': ccount}
    else:
        keys_to_features = {
            'image':
                tf.FixedLenFeature((), tf.string),
            'label':
                tf.FixedLenFeature([], tf.int64),
            # 'heatmap':
            #     tf.FixedLenFeature([], tf.string),
            #  'bbox':
            #     tf.FixedLenFeature([4], dtype=tf.int64)
        }
        parsed = tf.parse_single_example(value, keys_to_features)
        image_bytes = tf.reshape(parsed['image'], shape=[])
        # hm_bytes = tf.reshape(parsed['heatmap'], shape=[])
        # bbox = tf.reshape(parsed['bbox'], shape=[4])
        image = self.image_preprocessing_fn(
            image_bytes=image_bytes,
            hm_bytes=None,
            bbox=None,
            is_training=self.is_training,
        )
        if self.use_bfloat:
            image = tf.cast(image, tf.bfloat16)

    # Subtract one so that labels are in [0, 1000).
    label = tf.cast(
        tf.reshape(parsed['label'], shape=[]), dtype=tf.int32)

    return image, label
                                                         'image/width': tf.FixedLenFeature((), tf.int64),
                                                         'image/filename': tf.FixedLenFeature((), tf.string),
                                                         'image/source_id': tf.FixedLenFeature((), tf.string),
                                                         'image/encoded': tf.FixedLenFeature((), tf.string),
                                                         'image/format': tf.FixedLenFeature((), tf.string),
                                                         'image/object/bbox/xmin': tf.VarLenFeature(tf.float32),
                                                         'image/object/bbox/xmax': tf.VarLenFeature(tf.float32),
                                                         'image/object/bbox/ymin': tf.VarLenFeature(tf.float32),
                                                         'image/object/bbox/ymax': tf.VarLenFeature(tf.float32),
                                                         'image/object/class/text': tf.VarLenFeature(tf.string),
                                                         'image/object/class/label': tf.VarLenFeature(tf.int64),
                                                         })



41     features=tf.parse_single_example(example,features={'image_raw':#解码
42             tf.FixedLenFeature([],tf.string),
43             'label':tf.FixedLenFeature([34,1],tf.int64)})
44     image=tf.decode_raw(features['image_raw'],tf.uint8)
45     image.set_shape(rows*cols)
46     image=tf.cast(image,tf.float32)*(1./255)-0.5
47     label=tf.cast(features['label'],tf.int32)
48     return image,label
49     


#定义解析数据函数
#入参example_proto也就是tf_serialized
def pares_tf(example_proto):
    #定义解析的字典
    dics = {}
    dics['label'] = tf.FixedLenFeature(shape=[],dtype=tf.int64)
Ejemplo n.º 48
0
def _parse_function(example_proto):
    features = {'adjs': tf.FixedLenFeature((), tf.string)}
    parsed_features = tf.parse_single_example(example_proto, features)
    data = tf.decode_raw(parsed_features['adjs'], tf.int32)
    return data
# 创建一个 reader 来读取 TFRecord 文件中的样例
reader = tf.TFRecordReader()
# 创建一个队列来维护输入文件列表,在7.3.2小节中将更加详细的介绍
# tf.train.string_input_producer 函数
filename_queue = tf.train.string_input_producer(["build/output.tfrecords"])
# 从文件中读出一个样例。也可以使用 read_up_to 函数一次性读取多个样例
_, serialized_example = reader.read(filename_queue)

# 解析读取的样例。如果需要解析多个样例,可以用 parse_example 函数
features = tf.parse_single_example(
    serialized_example,
    features={
        # TensorFlow 提供两种不同属性解析方法。一种是方法是 tf.FixedLenFeature,
        # 这种方法解析的结果为一个 Tensor。另一种方法是 tf.VarLenFeature,这种方法
        # 得到的解析结果为 SparseTensor,用于处理稀疏数据。这里解析数据的格式需要和
        # 上面程序写入数据的格式一致
        'image_raw': tf.FixedLenFeature([], tf.string),
        'pixels': tf.FixedLenFeature([], tf.int64),
        'label': tf.FixedLenFeature([], tf.int64)
    })

# tf.decode_raw 可以将字符串解析成图像对应的像素数组
images = tf.decode_raw(features['image_raw'], tf.uint8)
labels = tf.cast(features['label'], tf.int32)
pixels = tf.cast(features['pixels'], tf.int32)

sess = tf.Session()

# 启动多线程处理输入数据,7.3节将更加详细地介绍 TensorFlow 多线程处理
coord = tf.train.Coordinator()
Ejemplo n.º 50
0
 def _parse_dtype(self, serialized):
     sample = tf.parse_single_example(serialized,
                                      features=self._get_dtype_features())
     return sample
Ejemplo n.º 51
0
import tensorflow as tf

# 使用tf.train.match_filenames_once函数获取文件列表
files = tf.train.match_filenames_once('./data.tfrecords-*')

# 通过tf.train.string_input_producer函数创建输入队列,输入队列中的文件列表为
# tf.train.match_filenames_once函数获取的文件列表。这里将shuffle参数设为False
# 来避免随机打乱读文件的顺序。但一般在解决真实问题时,会将shuffle参数设置为True
filename_queue = tf.train.string_input_producer(files, shuffle=False)

# 如前面所示读取并解析一个样本
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_single_example(serialized_example,
                                   features={
                                       'i': tf.FixedLenFeature([], tf.int64),
                                       'j': tf.FixedLenFeature([], tf.int64),
                                   })

# 使用前面的方法读取并解析得到的样例。这里假设Example结构中i表示一个样例的特征向量
# 比如一张图像的像素矩阵。而j表示该样例对应的标签。
example, label = features['i'], features['j']

# 一个batch中样例的个数。
batch_size = 3
# 组合样例的队列中最多可以存储的样例个数。这个队列如果太大,那么需要占用很多内存资源;
# 如果太小,那么出队操作可能会因为没有数据而被阻碍(block),从而导致训练效率降低。
# 一般来说这个队列的大小会和每一个batch的大小相关,下面一行代码给出了设置队列大小的一种方式。
capacity = 1000 + 3 * batch_size

# 使用tf.train.batch函数来组合样例。[example, label]参数给出了需要组合的元素,
Ejemplo n.º 52
0
def test():

    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(
        filename_queue)  # return file_name and file

    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'label':
                                           tf.FixedLenFeature([], tf.int64),
                                           'img':
                                           tf.FixedLenFeature([], tf.string),
                                           'width':
                                           tf.FixedLenFeature([], tf.int64),
                                           'height':
                                           tf.FixedLenFeature([], tf.int64),
                                           'channels':
                                           tf.FixedLenFeature([], tf.int64)
                                       })  # return image and label

    label = tf.cast(features['label'], tf.float32)  # throw label tensor
    # height = tf.cast(features['height'],tf.int32)
    height = features['height']
    width = tf.cast(features['width'], tf.int32)
    channels = tf.cast(features['channels'], tf.int32)

    img = tf.decode_raw(features['img'], tf.uint8)
    print(type(height))
    img = tf.reshape(img, [227, 227, 3])

    img_batch, label_batch = tf.train.shuffle_batch([img, label],
                                                    batch_size=1000,
                                                    capacity=5173,
                                                    min_after_dequeue=5172,
                                                    num_threads=4)

    x = tf.placeholder(tf.float32, [
        None, train_net.IMAGE_SIZE, train_net.IMAGE_SIZE,
        train_net.NUM_CHANNELS
    ],
                       name='x-input')
    y_ = tf.placeholder(tf.int64, [None], name='y-input')

    # validata_feed = {x: reshape_xs, y_: mnist.validation.labels}

    y = inference.alex_net(X=x,
                           output=2,
                           dropout=train_net.DROPOUT,
                           regularizer=None)
    #tf.argmax()返回向量中最大值位置,tf.equal()返回两个向量对应位置比较结果 返回值为布尔类型

    correct_prediction = tf.equal(tf.argmax(y, 1), y_)
    #数据类型转换
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # variable_averages = tf.train.ExponentialMovingAverage(train_net.MOVING_AVERAGE_DECAY)
    # #加载变量的滑动平均值
    # saver = tf.train.Saver(variable_averages.variables_to_restore())

    #加载保存模型的变量

    saver = tf.train.Saver()

    with tf.Session() as sess:
        #返回模型变量取值的路径
        tf.global_variables_initializer().run()
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        xs, ys = sess.run([img_batch, label_batch])
        ckpt = tf.train.get_checkpoint_state(train_net.MODEL_SAVE_PATH)
        if ckpt and ckpt.model_checkpoint_path:
            #ckpt.model_checkpoint_path返回最新的模型变量取值的路径
            saver.restore(sess, ckpt.model_checkpoint_path)

            global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
                '-')[-1]

            print('test accuracy is %g' %
                  (sess.run(accuracy, feed_dict={
                      x: xs,
                      y_: ys
                  })))
        else:
            print('NO checkpoint file found')
            return
Ejemplo n.º 53
0
def parse_tf_example(serialized, stage=""):
    """Parses a tensorflow.SequenceExample into an image and caption.

  Args:
    serialized: A scalar string Tensor; a single serialized TF Example.
    stage; If "tps_points", return a different set of variables.
  Returns:
    encoded_image: A scalar string Tensor containing a JPEG encoded image.
    encoded_prod_image: A JPEG encoded image string of the product image.
    body_segment: A h X w [0,1] Tensor indicating the body part.
    product_segment: A h X w [0,1] Tensor indicating the clothing part.
    skin_segment: A h X w Tensor indicating the skin part.
    pose_map: A 256 X 256 * 18 Tensor indicating pose.
  """
    features = tf.parse_single_example(serialized,
                                       features={
                                           "image_id":
                                           tf.FixedLenFeature([], tf.string),
                                           "height":
                                           tf.FixedLenFeature([], tf.int64),
                                           "width":
                                           tf.FixedLenFeature([], tf.int64),
                                           "image":
                                           tf.FixedLenFeature([], tf.string),
                                           "product_image":
                                           tf.FixedLenFeature([], tf.string),
                                           "pose_map":
                                           tf.FixedLenFeature([], tf.string),
                                           "segment_map":
                                           tf.FixedLenFeature([], tf.string),
                                           "tps_control_points":
                                           tf.VarLenFeature(tf.float32),
                                           "num_keypoints":
                                           tf.FixedLenFeature([], tf.int64),
                                           "keypoints":
                                           tf.VarLenFeature(tf.float32),
                                           "prod_keypoints":
                                           tf.VarLenFeature(tf.float32),
                                       })
    encoded_product_image = features["product_image"]
    encoded_image = features["image"]

    height = tf.cast(features["height"], tf.int32)
    width = tf.cast(features["width"], tf.int32)
    pose_map = tf.decode_raw(features["pose_map"], tf.uint8)
    pose_map = tf.cast(pose_map, tf.float32)
    pose_map = tf.reshape(pose_map, tf.stack([256, 192, 18]))
    segment_map = tf.decode_raw(features["segment_map"], tf.uint8)
    segment_map = tf.reshape(segment_map, tf.stack([height, width]))
    body_segment, prod_segment, skin_segment = extract_segmentation(
        segment_map)

    if stage != "tps_points":
        return (encoded_image, encoded_product_image, body_segment,
                prod_segment, skin_segment, pose_map, features["image_id"])

    # TPS control points reshape
    tps_points = features["tps_control_points"]
    tps_points = tf.sparse_tensor_to_dense(tps_points, default_value=0.)
    tps_points = tf.reshape(tps_points, tf.stack([2, 10, 10]))
    tps_points = tf.transpose(tf.reshape(tps_points, tf.stack([2, 100
                                                               ]))) * 2 - 1
    return (encoded_image, encoded_product_image, body_segment, prod_segment,
            skin_segment, pose_map, features["image_id"], tps_points)
Ejemplo n.º 54
0
 def decode(elem):
   model_features = tf.parse_single_example(elem, features=feature_spec)
   model_labels = tf.stack([model_features.pop(label) for label in labels])
   return model_features, model_labels
Ejemplo n.º 55
0
def read_tfrecord(record_file):
    reader = tf.TFRecordReader()
    _, example = reader.read(record_file)
    features = tf.parse_single_example(
        example, features={'image': tf.FixedLenFeature([], tf.string)})
Ejemplo n.º 56
0
def read_data(filename_queue, is_train):
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'name':
                                           tf.FixedLenFeature([], tf.string),
                                           'm':
                                           tf.FixedLenFeature([], tf.int64),
                                           'n':
                                           tf.FixedLenFeature([], tf.int64),
                                           'query':
                                           tf.FixedLenFeature([], tf.string),
                                           'align':
                                           tf.FixedLenFeature([], tf.string),
                                           'y':
                                           tf.FixedLenFeature([], tf.string),
                                           'mask':
                                           tf.FixedLenFeature([], tf.string),
                                           'gap':
                                           tf.VarLenFeature(tf.float32),
                                           'identity':
                                           tf.VarLenFeature(tf.float32),
                                           'identity_cons':
                                           tf.VarLenFeature(tf.float32),
                                           'ss_dssp':
                                           tf.FixedLenFeature([], tf.string),
                                           'asa_num':
                                           tf.VarLenFeature(tf.int64),
                                       })
    name = features["name"]
    m = tf.cast(features["m"], tf.int32)
    n = tf.cast(features["n"], tf.int32)
    align = tf.reshape(tf.decode_raw(features["align"], tf.uint8),
                       tf.stack([m, n]))
    query = tf.decode_raw(features["query"], tf.uint8)
    y = tf.reshape(tf.decode_raw(features["y"], tf.uint8), tf.stack([n, n]))
    mask = tf.reshape(tf.decode_raw(features["mask"], tf.uint8),
                      tf.stack([n, n]))
    gap = features["gap"].values
    identity = features["identity"].values
    identity_cons = features["identity_cons"].values
    ss_dssp = tf.decode_raw(features["ss_dssp"], tf.uint8)
    asa_num = tf.cast(features["asa_num"].values, tf.int32)
    gap = features["gap"].values
    identity = features["identity"].values
    identity_cons = features["identity_cons"].values

    # clip
    def clipping(align, query, ss_dssp, asa_num, y, mask):
        begin = tf.random_uniform([],
                                  maxval=tf.shape(align)[1] - n_clip,
                                  dtype=tf.int32)
        align = align[:, begin:begin + n_clip]
        query = query[begin:begin + n_clip]
        ss_dssp = ss_dssp[begin:begin + n_clip]
        asa_num = asa_num[begin:begin + n_clip]
        y = y[begin:begin + n_clip, begin:begin + n_clip]
        mask = mask[begin:begin + n_clip, begin:begin + n_clip]
        return align, query, ss_dssp, asa_num, y, mask

    align, query, ss_dssp, asa_num, y, mask = tf.cond(
        (n > n_clip) & (is_train),
        lambda: clipping(align, query, ss_dssp, asa_num, y, mask), lambda:
        (align, query, ss_dssp, asa_num, y, mask))

    # sampling
    def sampling(align, gap, identity, identity_cons):
        idx = tf.random_uniform([n_alignment], maxval=m, dtype=tf.int32)
        align = tf.gather_nd(align, tf.expand_dims(idx, 1))
        gap = tf.gather_nd(gap, tf.expand_dims(idx, 1))
        identity = tf.gather_nd(identity, tf.expand_dims(idx, 1))
        identity_cons = tf.gather_nd(identity_cons, tf.expand_dims(idx, 1))
        return align, gap, identity, identity_cons

    align, gap, identity, identity_cons = tf.cond(
        (m > n_alignment) & (is_train),
        lambda: sampling(align, gap, identity, identity_cons), lambda:
        (align, gap, identity, identity_cons))

    return name, align, query, y, mask, gap, identity, identity_cons, ss_dssp, asa_num
Ejemplo n.º 57
0
def _parse_example_proto(example_serialized):
    """Parses an Example proto containing a training example of an image.

  The output of the build_image_data.py image preprocessing script is a dataset
  containing serialized Example protocol buffers. Each Example proto contains
  the following fields:

    image/height: 462
    image/width: 581
    image/colorspace: 'RGB'
    image/channels: 3
    image/class/label: 615
    image/class/synset: 'n03623198'
    image/class/text: 'knee pad'
    image/object/bbox/xmin: 0.1
    image/object/bbox/xmax: 0.9
    image/object/bbox/ymin: 0.2
    image/object/bbox/ymax: 0.6
    image/object/bbox/label: 615
    image/format: 'JPEG'
    image/filename: 'ILSVRC2012_val_00041207.JPEG'
    image/encoded: <JPEG encoded string>

  Args:
    example_serialized: scalar Tensor tf.string containing a serialized
      Example protocol buffer.

  Returns:
    image_buffer: Tensor tf.string containing the contents of a JPEG file.
    label: Tensor tf.int32 containing the label.
    bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords]
      where each coordinate is [0, 1) and the coordinates are arranged as
      [ymin, xmin, ymax, xmax].
    text: Tensor tf.string containing the human-readable label.
  """
    # Dense features in Example proto.
    feature_map = {
        'image/encoded':
        tf.FixedLenFeature([], dtype=tf.string, default_value=''),
        'image/class/label':
        tf.FixedLenFeature([1], dtype=tf.int64, default_value=-1),
        'image/class/text':
        tf.FixedLenFeature([], dtype=tf.string, default_value=''),
    }
    sparse_float32 = tf.VarLenFeature(dtype=tf.float32)
    # Sparse features in Example proto.
    feature_map.update({
        k: sparse_float32
        for k in [
            'image/object/bbox/xmin', 'image/object/bbox/ymin',
            'image/object/bbox/xmax', 'image/object/bbox/ymax'
        ]
    })

    features = tf.parse_single_example(example_serialized, feature_map)
    label = tf.cast(features['image/class/label'], dtype=tf.int32)

    xmin = tf.expand_dims(features['image/object/bbox/xmin'].values, 0)
    ymin = tf.expand_dims(features['image/object/bbox/ymin'].values, 0)
    xmax = tf.expand_dims(features['image/object/bbox/xmax'].values, 0)
    ymax = tf.expand_dims(features['image/object/bbox/ymax'].values, 0)

    # Note that we impose an ordering of (y, x) just to make life difficult.
    bbox = tf.concat_v2([ymin, xmin, ymax, xmax], 0)

    # Force the variable number of bounding boxes into the shape
    # [1, num_boxes, coords].
    bbox = tf.expand_dims(bbox, 0)
    bbox = tf.transpose(bbox, [0, 2, 1])

    return features['image/encoded'], label, bbox, features['image/class/text']
Ejemplo n.º 58
0
def predictor2(image_tru, num_face):

    # image = align_face(image_tru)
    image = image_tru

    ######**********************************************************#####
    # Encode
    data_file = 'tmp_aug.tfrecords'
    writer = tf.python_io.TFRecordWriter(data_file)
    # image = load_image('./')
    gender = np.array([0])
    race = np.array([0])
    age = np.array([0])
    addrs = ['0']
    feature = {
        'val/gender': _int64_feature(gender.astype(np.int8)),
        'val/race': _int64_feature(race.astype(np.int8)),
        'val/age': _int64_feature(age.astype(np.int8)),
        'val/image': _bytes_feature(tf.compat.as_bytes(image.tostring())),
        'val/address': _bytes_feature(os.path.basename(addrs[0].encode()))
    }
    example = tf.train.Example(features=tf.train.Features(feature=feature))
    writer.write(example.SerializeToString())
    writer.close()
    sys.stdout.flush()
    # decode
    tf.reset_default_graph()
    filename_queue = tf.train.string_input_producer([data_file])
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)

    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'val/gender':
                                           tf.FixedLenFeature([], tf.int64),
                                           'val/race':
                                           tf.FixedLenFeature([], tf.int64),
                                           'val/age':
                                           tf.FixedLenFeature([], tf.int64),
                                           'val/image':
                                           tf.FixedLenFeature([], tf.string),
                                           'val/address':
                                           tf.FixedLenFeature([], tf.string)
                                       })

    image = tf.decode_raw(features['val/image'], tf.float32)
    image = tf.cast(image, tf.uint8)
    image.set_shape([200 * 200 * 3])
    image = tf.reshape(image, [200, 200, 3])
    # image = tf.reverse_v2(image, [-1])
    image = tf.image.per_image_standardization(image)

    images = tf.train.shuffle_batch([image],
                                    batch_size=1,
                                    capacity=256,
                                    num_threads=2,
                                    min_after_dequeue=32)

    train_mode = tf.placeholder(tf.bool)
    logits_gender, logits_race, logits_age, end_points, _ = build_model(
        images, train_mode)

    end_points['Predictions/gender'] = tf.nn.softmax(logits_gender,
                                                     name='Predictions/gender')
    end_points['Predictions/race'] = tf.nn.softmax(logits_race,
                                                   name='Predictions/race')
    end_points['Predictions/age'] = tf.nn.softmax(logits_age,
                                                  name='Predictions/age')
    predictions1 = tf.argmax(end_points['Predictions/gender'], -1)
    predictions2 = tf.argmax(end_points['Predictions/race'], -1)
    predictions3 = tf.argmax(end_points['Predictions/age'], -1)

    pr1 = tf.to_float(tf.to_int32(predictions1))
    pr2 = tf.to_float(tf.to_int32(predictions2))
    pr3 = tf.to_float(tf.to_int32(predictions3))

    with tf.Session() as sess:
        #
        # init_op = tf.group(tf.local_variables_initializer())
        # sess.run(init_op)

        saver = tf.train.Saver(max_to_keep=100)
        ckpt = tf.train.get_checkpoint_state(model_dir)

        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)
            print("restore and start evaluation!")

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        # writer = tf.summary.FileWriter(log_dir, graph=tf.get_default_graph())

        pred1, pred2 = [], []

        # for step in range(num_steps_per_epoch):

        acc1, acc2, acc3 = sess.run([pr1, pr2, pr3], {train_mode: False})

        print(acc1, acc2, acc3)

        # Log some information
        # logging.info('Step %s: gender Accuracy: %.4f race Accuracy: %.4f loss: %.4f  (%.2f sec/step)'step, acc1, acc2, l, time_elapsed)

        # writer.add_summary(curr_summary, step)

        # pred1.append(acc1)
        # pred2.append(acc2)

        # coord.request_stop()
        # coord.join(threads)

        # saver.save(sess, final_checkpoint_file)
        sess.close()

        # average_acc1 = np.mean(accuracies1)
        # average_acc2 = np.mean(accuracies2)
        # average_loss = np.mean(loss_list)

        gender = int(acc1)
        race = int(acc2)
        age = int(acc3)
        global Result
        Result = [gender, race, age, num_face]
Ejemplo n.º 59
0
def get_split(dataset_dir,
              is_training,
              split_name,
              batch_size,
              seq_length,
              buffer_size,
              subset=None):
    root_path = Path(dataset_dir) / split_name
    if subset is None:
        paths = [str(x) for x in root_path.glob('*.tfrecords')]
    else:
        paths = [str(x) for x in root_path.glob('*.tfrecords')]

    if split_name == "test":
        dataset = tf.data.TFRecordDataset(paths)
        dataset = dataset.map(lambda x: tf.parse_single_example(
            x,
            features={
                'sample_id':
                tf.FixedLenFeature([], tf.int64),
                'subject_id':
                tf.FixedLenFeature([], tf.int64),
                'gs_label':
                tf.FixedLenFeature([], tf.string),
                'gs_label_shape':
                tf.FixedLenFeature([], tf.string),
                'raw_audio':
                tf.FixedLenFeature([], tf.string),
                'raw_audio_shape':
                tf.FixedLenFeature([], tf.string),
                'audio_features':
                tf.FixedLenFeature([], tf.string),
                'audio_features_shape':
                tf.FixedLenFeature([], tf.string),
                'image_features_appearance':
                tf.FixedLenFeature([], tf.string),
                'image_features_appearance_shape':
                tf.FixedLenFeature([], tf.string),
                'image_features_geometric':
                tf.FixedLenFeature([], tf.string),
                'image_features_geometric_shape':
                tf.FixedLenFeature([], tf.string),
            }))

        dataset = dataset.map(
            lambda x: {
                'sample_id':
                tf.reshape(x['sample_id'], (1, )),
                'subject_id':
                tf.reshape(x['subject_id'], (1, )),
                'gs_label':
                tf.reshape(tf.decode_raw(x['gs_label'], tf.float32), (2, )),
                'gs_label_shape':
                tf.reshape(tf.decode_raw(x['gs_label_shape'], tf.float32),
                           (2, )),
                'raw_audio':
                tf.reshape(tf.decode_raw(x['raw_audio'], tf.float32), (640, )),
                'raw_audio_shape':
                tf.reshape(tf.decode_raw(x['raw_audio_shape'], tf.float32),
                           (2, )),
                'audio_features':
                tf.reshape(tf.decode_raw(x['audio_features'], tf.float32),
                           (534, )),  # 178, 534
                'audio_features_shape':
                tf.reshape(
                    tf.decode_raw(x['audio_features_shape'], tf.float32),
                    (2, )),
                'image_features_appearance':
                tf.reshape(
                    tf.decode_raw(x['image_features_appearance'], tf.float32),
                    (1014, )),  # 338, 1014
                'image_features_appearance_shape':
                tf.reshape(
                    tf.decode_raw(x['image_features_appearance_shape'], tf.
                                  float32), (2, )),
                'image_features_geometric':
                tf.reshape(
                    tf.decode_raw(x['image_features_geometric'], tf.float32),
                    (3798, )),  # 1266, 3798
                'image_features_geometric_shape':
                tf.reshape(
                    tf.decode_raw(x['image_features_geometric_shape'], tf.
                                  float32), (2, ))
            })
    else:
        dataset = tf.data.TFRecordDataset(paths)
        dataset = dataset.map(lambda x: tf.parse_single_example(
            x,
            features={
                'sample_id':
                tf.FixedLenFeature([], tf.int64),
                'subject_id':
                tf.FixedLenFeature([], tf.int64),
                'label':
                tf.FixedLenFeature([], tf.string),
                'label_shape':
                tf.FixedLenFeature([], tf.string),
                'raw_audio':
                tf.FixedLenFeature([], tf.string),
                'raw_audio_shape':
                tf.FixedLenFeature([], tf.string),
                'audio_features':
                tf.FixedLenFeature([], tf.string),
                'audio_features_shape':
                tf.FixedLenFeature([], tf.string),
                'image_features_appearance':
                tf.FixedLenFeature([], tf.string),
                'image_features_appearance_shape':
                tf.FixedLenFeature([], tf.string),
                'image_features_geometric':
                tf.FixedLenFeature([], tf.string),
                'image_features_geometric_shape':
                tf.FixedLenFeature([], tf.string),
            }))

        dataset = dataset.map(
            lambda x: {
                'sample_id':
                tf.reshape(x['sample_id'], (1, )),
                'subject_id':
                tf.reshape(x['subject_id'], (1, )),
                'label':
                tf.reshape(tf.decode_raw(x['label'], tf.float32), (12, )),
                'label_shape':
                tf.reshape(tf.decode_raw(x['label_shape'], tf.float32), (2, )),
                'raw_audio':
                tf.reshape(tf.decode_raw(x['raw_audio'], tf.float32), (640, )),
                'raw_audio_shape':
                tf.reshape(tf.decode_raw(x['raw_audio_shape'], tf.float32),
                           (2, )),
                'audio_features':
                tf.reshape(tf.decode_raw(x['audio_features'], tf.float32),
                           (534, )),  # 178, 534
                'audio_features_shape':
                tf.reshape(
                    tf.decode_raw(x['audio_features_shape'], tf.float32),
                    (2, )),
                'image_features_appearance':
                tf.reshape(
                    tf.decode_raw(x['image_features_appearance'], tf.float32),
                    (1014, )),  # 338, 1014
                'image_features_appearance_shape':
                tf.reshape(
                    tf.decode_raw(x['image_features_appearance_shape'], tf.
                                  float32), (2, )),
                'image_features_geometric':
                tf.reshape(
                    tf.decode_raw(x['image_features_geometric'], tf.float32),
                    (3798, )),  # 1266, 3798
                'image_features_geometric_shape':
                tf.reshape(
                    tf.decode_raw(x['image_features_geometric_shape'], tf.
                                  float32), (2, ))
            })

    dataset = dataset.repeat()
    dataset = dataset.batch(seq_length)
    if is_training:
        dataset = dataset.shuffle(buffer_size=buffer_size)
    dataset = dataset.batch(batch_size)

    return dataset
Ejemplo n.º 60
0
 def decode_tfrecord(datum):
     return tf.parse_single_example(datum, features=feature_def)