示例#1
0
    def testBatch(self):
        # Build an arbitrary RGB image
        np.random.seed(7)
        batch_size = 5
        shape = (batch_size, 2, 7, 3)

        for nptype in self.float_types:
            inp = GenerateNumpyRandomRGB(shape).astype(nptype)

            # Convert to HSV and back, as a batch and individually
            with self.session() as sess:
                batch0 = array_ops.placeholder(nptype, shape=shape)
                with self.test_scope():
                    batch1 = image_ops.rgb_to_hsv(batch0)
                    batch2 = image_ops.hsv_to_rgb(batch1)
                split0 = array_ops.unstack(batch0)
                with self.test_scope():
                    split1 = list(map(image_ops.rgb_to_hsv, split0))
                    split2 = list(map(image_ops.hsv_to_rgb, split1))
                join1 = array_ops.stack(split1)
                join2 = array_ops.stack(split2)
                batch1, batch2, join1, join2 = sess.run(
                    [batch1, batch2, join1, join2], {batch0: inp})

            # Verify that processing batch elements together is the same as separate
            self.assertAllCloseAccordingToType(batch1,
                                               join1,
                                               half_rtol=0.000002)
            self.assertAllCloseAccordingToType(batch2,
                                               join2,
                                               half_rtol=0.000002)
            self.assertAllCloseAccordingToType(batch2,
                                               inp,
                                               bfloat16_atol=0.03,
                                               half_rtol=0.02)
  def testBatch(self):
    # Build an arbitrary RGB image
    np.random.seed(7)
    batch_size = 5
    shape = (batch_size, 2, 7, 3)

    for nptype in self.float_types:
      inp = GenerateNumpyRandomRGB(shape).astype(nptype)

      # Convert to HSV and back, as a batch and individually
      with self.test_session() as sess:
        batch0 = array_ops.placeholder(nptype, shape=shape)
        with self.test_scope():
          batch1 = image_ops.rgb_to_hsv(batch0)
          batch2 = image_ops.hsv_to_rgb(batch1)
        split0 = array_ops.unstack(batch0)
        with self.test_scope():
          split1 = list(map(image_ops.rgb_to_hsv, split0))
          split2 = list(map(image_ops.hsv_to_rgb, split1))
        join1 = array_ops.stack(split1)
        join2 = array_ops.stack(split2)
        batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2],
                                                {batch0: inp})

      # Verify that processing batch elements together is the same as separate
      self.assertAllClose(batch1, join1)
      self.assertAllClose(batch2, join2)
      self.assertAllCloseAccordingToType(
          batch2, inp, bfloat16_atol=0.03, half_rtol=0.02)
示例#3
0
 def testRGBToHSVRoundTrip(self):
     data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
     rgb_np = np.array(data, dtype=np.float32).reshape([2, 2, 3]) / 255.
     for use_gpu in [True, False]:
         with self.test_session(use_gpu=use_gpu):
             hsv = image_ops.rgb_to_hsv(rgb_np)
             rgb = image_ops.hsv_to_rgb(hsv)
             rgb_tf = rgb.eval()
     self.assertAllClose(rgb_tf, rgb_np)
示例#4
0
 def testRGBToHSVRoundTrip(self):
   data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
   rgb_np = np.array(data, dtype=np.float32).reshape([2, 2, 3]) / 255.
   for use_gpu in [True, False]:
     with self.test_session(use_gpu=use_gpu):
       hsv = image_ops.rgb_to_hsv(rgb_np)
       rgb = image_ops.hsv_to_rgb(hsv)
       rgb_tf = rgb.eval()
   self.assertAllClose(rgb_tf, rgb_np)
 def testRGBToHSVRoundTrip(self):
   data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
   for nptype in self.float_types:
     rgb_np = np.array(data, dtype=nptype).reshape([2, 2, 3]) / 255.
     with self.test_session():
       placeholder = array_ops.placeholder(nptype)
       with self.test_scope():
         hsv = image_ops.rgb_to_hsv(placeholder)
         rgb = image_ops.hsv_to_rgb(hsv)
       rgb_tf = rgb.eval(feed_dict={placeholder: rgb_np})
     self.assertAllCloseAccordingToType(rgb_tf, rgb_np, bfloat16_atol=0.03)
示例#6
0
 def testRGBToHSVRoundTrip(self):
     data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1]
     for nptype in self.float_types:
         rgb_np = np.array(data, dtype=nptype).reshape([2, 2, 3]) / 255.
         with self.test_session():
             placeholder = array_ops.placeholder(nptype)
             with self.test_scope():
                 hsv = image_ops.rgb_to_hsv(placeholder)
                 rgb = image_ops.hsv_to_rgb(hsv)
             rgb_tf = rgb.eval(feed_dict={placeholder: rgb_np})
         self.assertAllClose(rgb_tf, rgb_np)
示例#7
0
 def testRGBToHSVNumpy(self):
   """Tests the RGB to HSV conversion matches a reference implementation."""
   for nptype in self.float_types:
     rgb_flat = np.random.random(64 * 3).reshape((64, 3)).astype(nptype)
     rgb_np = rgb_flat.reshape(4, 4, 4, 3)
     hsv_np = np.array([colorsys.rgb_to_hsv(r, g, b) for r, g, b in rgb_flat])
     hsv_np = hsv_np.reshape(4, 4, 4, 3)
     with self.test_session():
       placeholder = array_ops.placeholder(nptype)
       with self.test_scope():
         hsv_op = image_ops.rgb_to_hsv(placeholder)
       hsv_tf = hsv_op.eval(feed_dict={placeholder: rgb_np})
     self.assertAllClose(hsv_tf, hsv_np)
示例#8
0
 def testRGBToHSVNumpy(self):
     """Tests the RGB to HSV conversion matches a reference implementation."""
     for nptype in self.float_types:
         rgb_flat = np.random.random(64 * 3).reshape((64, 3)).astype(nptype)
         rgb_np = rgb_flat.reshape(4, 4, 4, 3)
         hsv_np = np.array(
             [colorsys.rgb_to_hsv(r, g, b) for r, g, b in rgb_flat])
         hsv_np = hsv_np.reshape(4, 4, 4, 3)
         with self.test_session():
             placeholder = array_ops.placeholder(nptype)
             with self.test_scope():
                 hsv_op = image_ops.rgb_to_hsv(placeholder)
             hsv_tf = hsv_op.eval(feed_dict={placeholder: rgb_np})
         self.assertAllClose(hsv_tf, hsv_np)
    def SSIM_Loss(self, y_true, y_pred):
        y_pred_hsv = rgb_to_hsv(y_pred)

        # mae_loss
        mae = K.mean(K.abs(y_pred - y_true), axis=-1)

        # tv_loss
        shape = tf.shape(y_pred)
        height, width = shape[1], shape[2]
        y = tf.slice(y_pred, [0, 0, 0, 0],
                     tf.stack([-1, height - 1, -1, -1])) - tf.slice(
                         y_pred, [0, 1, 0, 0], [-1, -1, -1, -1])
        x = tf.slice(y_pred, [0, 0, 0, 0],
                     tf.stack([-1, -1, width - 1, -1])) - tf.slice(
                         y_pred, [0, 0, 1, 0], [-1, -1, -1, -1])
        tv_loss = tf.nn.l2_loss(x) / tf.to_float(
            tf.size(x)) + tf.nn.l2_loss(y) / tf.to_float(tf.size(y))

        # ssim_loss
        c1 = 0.01**2
        c2 = 0.03**2
        y_true = tf.transpose(y_true, [0, 2, 3, 1])
        y_pred = tf.transpose(y_pred, [0, 2, 3, 1])
        patches_true = tf.extract_image_patches(y_true, [1, 8, 8, 1],
                                                [1, 2, 2, 1], [1, 1, 1, 1],
                                                "SAME")
        patches_pred = tf.extract_image_patches(y_pred, [1, 8, 8, 1],
                                                [1, 2, 2, 1], [1, 1, 1, 1],
                                                "SAME")
        # Get mean
        u_true = K.mean(patches_true, axis=-1)
        u_pred = K.mean(patches_pred, axis=-1)
        # Get variance
        var_true = K.var(patches_true, axis=-1)
        var_pred = K.var(patches_pred, axis=-1)
        # Get std dev
        std_true = K.sqrt(var_true)
        std_pred = K.sqrt(var_pred)
        covar_true_pred = std_pred * std_true
        ssim = (2 * u_true * u_pred + c1) * (2 * covar_true_pred + c2)
        denom = (K.square(u_true) + K.square(u_pred) + c1) * (var_pred +
                                                              var_true + c2)
        ssim /= denom

        size = tf.size(y_pred_hsv)
        light_loss = tf.nn.l2_loss(y_pred_hsv[:, :, :, 2]) / tf.to_float(size)

        total_loss = -0.07 * light_loss + 1.0 * mae - 0.0005 * tv_loss
        return total_loss
示例#10
0
  def testBatch(self):
    # Build an arbitrary RGB image
    np.random.seed(7)
    batch_size = 5
    shape = (batch_size, 2, 7, 3)
    inp = np.random.rand(*shape).astype(np.float32)

    # Convert to HSV and back, as a batch and individually
    with self.test_session() as sess:
      batch0 = constant_op.constant(inp)
      batch1 = image_ops.rgb_to_hsv(batch0)
      batch2 = image_ops.hsv_to_rgb(batch1)
      split0 = array_ops.unpack(batch0)
      split1 = map(image_ops.rgb_to_hsv, split0)
      split2 = map(image_ops.hsv_to_rgb, split1)
      join1 = array_ops.pack(split1)
      join2 = array_ops.pack(split2)
      batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2])

    # Verify that processing batch elements together is the same as separate
    self.assertAllClose(batch1, join1)
    self.assertAllClose(batch2, join2)
    self.assertAllClose(batch2, inp)
示例#11
0
  def testBatch(self):
    # Build an arbitrary RGB image
    np.random.seed(7)
    batch_size = 5
    shape = (batch_size, 2, 7, 3)
    inp = np.random.rand(*shape).astype(np.float32)

    # Convert to HSV and back, as a batch and individually
    with self.test_session() as sess:
      batch0 = constant_op.constant(inp)
      batch1 = image_ops.rgb_to_hsv(batch0)
      batch2 = image_ops.hsv_to_rgb(batch1)
      split0 = array_ops.unpack(batch0)
      split1 = list(map(image_ops.rgb_to_hsv, split0))
      split2 = list(map(image_ops.hsv_to_rgb, split1))
      join1 = array_ops.pack(split1)
      join2 = array_ops.pack(split2)
      batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2])

    # Verify that processing batch elements together is the same as separate
    self.assertAllClose(batch1, join1)
    self.assertAllClose(batch2, join2)
    self.assertAllClose(batch2, inp)