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.)
