def _UniformKeypoints(self, num_keypoints, output_min=_DEFAULT_OUTPUT_MIN, output_max=_DEFAULT_OUTPUT_MAX): return keypoints_initialization.uniform_keypoints_for_signal( num_keypoints=num_keypoints, input_min=array_ops.constant(0.0, dtype=dtypes.float32), input_max=array_ops.constant(1.0, dtype=dtypes.float32), output_min=output_min, output_max=output_max, dtype=dtypes.float32)
def testMonotonicity(self): # Create a monotonic calibration, then set it in a non-monotonic way and # check that it is projected back to monotonicity. with ops.Graph().as_default(): num_keypoints = 5 keypoints_init = keypoints_initialization.uniform_keypoints_for_signal( num_keypoints=num_keypoints, input_min=array_ops.constant(0.0, dtype=dtypes.float32), input_max=array_ops.constant(1.0, dtype=dtypes.float32), output_min=0., output_max=1., dtype=dtypes.float32) uncalibrated = array_ops.placeholder( shape=tensor_shape.unknown_shape(ndims=1), dtype=dtypes.float32) with variable_scope.variable_scope('test_monotonicity'): _, projection, regularization = ( pwl_calibration_layers.one_dimensional_calibration_layer( uncalibrated, num_keypoints=num_keypoints, monotonic=1, signal_name='monotonic_x', keypoints_initializers=keypoints_init)) self.assertTrue(projection is not None) self.assertEqual(regularization, None) with self.test_session() as sess: # First initialize keypoints (and all variables) sess.run(variables.global_variables_initializer()) kp_out = _get_variable_by_name( 'test_monotonicity/pwl_calibration/monotonic_x_keypoints_outputs:0' ) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, [0.0, 0.25, 0.5, 0.75, 1.0]) # Assign non_monotonic calibration. non_monotonic = [4., 5., 0., 4., -3.] sess.run( state_ops.assign( kp_out, array_ops.constant(non_monotonic, dtype=dtypes.float32))) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, non_monotonic) # Execute projection. sess.run(projection) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, [2., 2., 2., 2., 2.])
def testBoundness(self): # Create a bound calibration, then set it outside the bounds and check # that it is projected back to the bounds. with ops.Graph().as_default(): num_keypoints = 3 keypoints_init = keypoints_initialization.uniform_keypoints_for_signal( num_keypoints=num_keypoints, input_min=array_ops.constant(0.0, dtype=dtypes.float32), input_max=array_ops.constant(1.0, dtype=dtypes.float32), output_min=0., output_max=1., dtype=dtypes.float32) uncalibrated = array_ops.placeholder( shape=tensor_shape.unknown_shape(ndims=1), dtype=dtypes.float32) with variable_scope.variable_scope('test_boundness'): _, projection, regularization = ( pwl_calibration_layers.one_dimensional_calibration_layer( uncalibrated, num_keypoints=num_keypoints, bound=True, signal_name='bounded_x', keypoints_initializers=keypoints_init)) self.assertTrue(projection is not None) self.assertEqual(regularization, None) with self.test_session() as sess: # First initialize keypoints (and all variables) sess.run(variables.global_variables_initializer()) kp_out = _get_variable_by_name( 'test_boundness/pwl_calibration/bounded_x_keypoints_outputs:0' ) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, [0.0, 0.5, 1.0]) # Assign values to variable beyond bounds. out_of_bounds = [-0.1, 1.2, 0.9] sess.run( state_ops.assign( kp_out, array_ops.constant(out_of_bounds, dtype=dtypes.float32))) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, out_of_bounds) # Execute projection. sess.run(projection) kp_out_values = sess.run(kp_out) self.assertAllClose(kp_out_values, [0.0, 1.0, 0.9])
def _calibration_layer(input_tensor, input_dim, input_min, input_max, num_keypoints, output_min, output_max): """Create an intermediate calibration layer.""" init_keypoints = keypoints_initialization.uniform_keypoints_for_signal( num_keypoints=num_keypoints, input_min=input_min, input_max=input_max, output_min=output_min, output_max=output_max, dtype=input_tensor.dtype) packed_results = pwl_calibration_layers.calibration_layer( input_tensor, num_keypoints=num_keypoints, keypoints_initializers=[init_keypoints] * input_dim, bound=True, monotonic=+1) (calibrated_input_tensor, projection_ops, _) = packed_results return (calibrated_input_tensor, projection_ops)
def testUniformKeypointsForSignal(self): # New graph is needed because default graph is changed by save # keypoints, and self.test_session() will by default try to reuse a cached # session, with a different graph. with ops.Graph().as_default() as g: keypoints_init = keypoints_initialization.uniform_keypoints_for_signal( num_keypoints=5, input_min=array_ops.constant(0.0, dtype=dtypes.float64), input_max=array_ops.constant(1.0, dtype=dtypes.float64), output_min=10, output_max=100, dtype=dtypes.float64) self.assertEqual(keypoints_init[0].dtype, dtypes.float64) self.assertEqual(keypoints_init[1].dtype, dtypes.float64) with self.test_session(graph=g) as sess: keypoints_init = sess.run(keypoints_init) self.assertAllClose(keypoints_init[0], [0., 0.25, 0.5, 0.75, 1.]) self.assertAllClose(keypoints_init[1], [10., 32.5, 55., 77.5, 100.])
def init_fn(): return keypoints_initialization.uniform_keypoints_for_signal( 2, 0., 1., 0., 1.)
def init_fn(): return keypoints_initialization.uniform_keypoints_for_signal( _NUM_KEYPOINTS, -1., 1., 0., 1.)