Example #1
0
    def test_image_decoder(self):
        # Make random image.
        image_size = 84
        image = np.random.randint(low=0,
                                  high=255,
                                  size=[image_size, image_size,
                                        3]).astype(np.ubyte)

        # Encode
        image_bytes = dataset_to_records.encode_image(image,
                                                      image_format='PNG')
        label = np.zeros(1).astype(np.int64)
        image_example = dataset_to_records.make_example(image_bytes,
                                                        label,
                                                        input_key='image',
                                                        label_key='label')

        # Decode
        image_decoder = decoder.ImageDecoder(image_size=image_size)
        image_decoded = image_decoder(image_example)
        # Assert perfect reconstruction.
        with self.session(use_gpu=False) as sess:
            image_rec_numpy = sess.run(image_decoded)
        self.assertAllClose(2 * (image.astype(np.float32) / 255.0 - 0.5),
                            image_rec_numpy)
Example #2
0
def write_feature_records(features, label, output_path):
    """Creates a record file from features and labels.

  Args:
    features: An [n, m] numpy array of features.
    label: An integer, the label common to all records.
    output_path: A string specifying the location of the record.
  """
    writer = tf.python_io.TFRecordWriter(output_path)
    for feat in list(features):
        # Write the example.
        serialized_example = dataset_to_records.make_example([
            ('image/embedding', 'float32', feat.tolist()),
            ('image/class/label', 'int64', [label])
        ])
        writer.write(serialized_example)
    writer.close()
Example #3
0
    def test_feature_decoder(self):
        # Make random feature.
        feat_size = 64
        feat = np.random.randn(feat_size).astype(np.float32)
        label = np.zeros(1).astype(np.int64)

        # Encode
        feat_example = dataset_to_records.make_example([
            ('image/embedding', 'float32', feat),
            ('image/class/label', 'int64', [label]),
        ])

        # Decode
        feat_decoder = decoder.FeatureDecoder(feat_len=feat_size)
        feat_decoded = feat_decoder(feat_example)

        # Assert perfect reconstruction.
        with self.session(use_gpu=False) as sess:
            feat_rec_numpy = sess.run(feat_decoded)
        self.assertAllEqual(feat_rec_numpy, feat)
Example #4
0
    def test_feature_decoder(self):
        # Make random feature.
        feat_size = 64
        feat = np.random.randn(feat_size).astype(np.float32)
        label = np.zeros(1).astype(np.int64)
        with self.session(use_gpu=False) as sess:
            feat_serial = sess.run(tf.io.serialize_tensor(feat))

        # Encode
        feat_example = dataset_to_records.make_example(
            feat_serial,
            label,
            input_key='image/embedding',
            label_key='image/class/label')

        # Decode
        feat_decoder = decoder.FeatureDecoder()
        feat_decoded = feat_decoder(feat_example)

        # Assert perfect reconstruction.
        with self.session(use_gpu=False) as sess:
            feat_rec_numpy = sess.run(feat_decoded)
        self.assertAllEqual(feat_rec_numpy, feat)
Example #5
0
    def test_string_decoder(self):
        # Make random image.
        image_size = 32
        image = np.random.randint(low=0,
                                  high=255,
                                  size=[image_size, image_size,
                                        3]).astype(np.ubyte)

        # Encode
        image_bytes = dataset_to_records.encode_image(image,
                                                      image_format='PNG')
        label = np.zeros(1).astype(np.int64)
        image_example = dataset_to_records.make_example([
            ('image', 'bytes', [image_bytes]), ('label', 'int64', [label])
        ])

        # Decode
        string_decoder = decoder.StringDecoder()
        image_string = string_decoder(image_example)
        decoded_image = tf.image.decode_image(image_string)
        # Assert perfect reconstruction.
        with self.session(use_gpu=False) as sess:
            image_decoded = sess.run(decoded_image)
        self.assertAllClose(image, image_decoded)