def testReduceVar(self):
x = np.array([[0, 0, 0], [0, 0, 0]], "float32")
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x)), 0)
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x, axis=0)),
[0, 0, 0])
x = np.array([[0, 2, 1, 1], [1, 2, 0, 1]], "float32")
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x)), 0.5)
def testReduceVar(self):
x = np.array([[0, 0, 0], [0, 0, 0]], "float32")
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x)), 0)
self.assertAllClose(
self.evaluate(math_ops.reduce_variance(x, axis=0)), [0, 0, 0])
x = np.array([[0, 2, 1, 1], [1, 2, 0, 1]], "float32")
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x)), 0.5)
def _input_statistics_test_template(self,
stat_object,
num_features,
dtype,
warmup_iterations=0,
rtol=1e-6,
data_length=4):
graph = ops.Graph()
with graph.as_default():
data_length_range = math_ops.range(data_length, dtype=dtype)
num_features_range = math_ops.range(num_features, dtype=dtype)
times = 2 * data_length_range[None, :] - 3
values = (data_length_range[:, None] +
num_features_range[None, :])[None, ...]
features = {
TrainEvalFeatures.TIMES: times,
TrainEvalFeatures.VALUES: values,
}
statistics = stat_object.initialize_graph(features=features)
with self.session(graph=graph) as session:
variables.global_variables_initializer().run()
coordinator = coordinator_lib.Coordinator()
queue_runner_impl.start_queue_runners(session,
coord=coordinator)
for _ in range(warmup_iterations):
# A control dependency should ensure that, for queue-based statistics,
# a use of any statistic is preceded by an update of all adaptive
# statistics.
self.evaluate(statistics.total_observation_count)
self.assertAllClose(
range(num_features) +
math_ops.reduce_mean(data_length_range)[None],
self.evaluate(statistics.series_start_moments.mean),
rtol=rtol)
self.assertAllClose(
array_ops.tile(
math_ops.reduce_variance(data_length_range)[None],
[num_features]),
self.evaluate(statistics.series_start_moments.variance),
rtol=rtol)
self.assertAllClose(
math_ops.reduce_mean(values[0], axis=0),
self.evaluate(statistics.overall_feature_moments.mean),
rtol=rtol)
self.assertAllClose(
math_ops.reduce_variance(values[0], axis=0),
self.evaluate(statistics.overall_feature_moments.variance),
rtol=rtol)
self.assertAllClose(-3,
self.evaluate(statistics.start_time),
rtol=rtol)
self.assertAllClose(data_length,
self.evaluate(
statistics.total_observation_count),
rtol=rtol)
coordinator.request_stop()
coordinator.join()
def test_step(self, data):
if isinstance(data, tuple):
data = data[0]
features = self.srmConv2D(data)
z_mean, z_log_var, z = self.encoder(features)
reconstruction = self.decoder(z)
L2 = squared_difference(features, reconstruction)
error = tf.reduce_mean(L2, axis=-1)
threshold = otsu(error)
sigma = reduce_variance(error, axis=[1, 2])
mean_0, sigma_b = dicriminative_error(error, threshold)
reconstruction_loss = mean_0 + 5 * (1 - sigma_b / sigma)
reconstruction_loss = tf.reduce_mean(reconstruction_loss)
kl_loss = -0.5 * tf.reduce_mean(1 + z_log_var - tf.square(z_mean) -
tf.exp(z_log_var))
total_loss = reconstruction_loss + kl_loss
return {
"loss": total_loss,
"reconstruction_loss": reconstruction_loss,
"kl_loss": kl_loss,
}
def train_step(self, data):
with tf.GradientTape() as tape:
features = self.srmConv2D(data)
z_mean, z_log_var, z = self.encoder(features)
reconstruction = self.decoder(z)
L2 = squared_difference(features, reconstruction)
error = tf.reduce_mean(L2, axis=-1)
with tape.stop_recording():
threshold = otsu(error)
sigma = reduce_variance(error, axis=[1, 2])
mean_0, sigma_b = dicriminative_error(error, threshold)
reconstruction_loss = mean_0 + 5 * (1 - sigma_b / sigma)
reconstruction_loss = tf.reduce_mean(reconstruction_loss)
kl_loss = -0.5 * tf.reduce_mean(1 + z_log_var - tf.square(z_mean) -
tf.exp(z_log_var))
total_loss = reconstruction_loss + kl_loss
grads = tape.gradient(total_loss, self.trainable_weights)
self.optimizer.apply_gradients(zip(grads, self.trainable_weights))
return {
"loss": total_loss,
"reconstruction_loss": reconstruction_loss,
"kl_loss": kl_loss,
}
def testReduceVarComplex(self):
# Ensure that complex values are handled to be consistent with numpy
complex_ys = [([0 - 1j, 0 + 1j], dtypes.float64),
(np.array([0 - 1j, 0 + 1j], "complex64"), dtypes.float32),
(np.array([0 - 1j, 0 + 1j], "complex128"), dtypes.float64)]
for y, dtype in complex_ys:
y_result = math_ops.reduce_variance(y)
self.assertEqual(np.var(y), 1.0)
self.assertEqual(self.evaluate(y_result), 1.0)
self.assertEqual(y_result.dtype, dtype)
def testRandomNormalVariance(self):
for dtype in self._random_types() & self.float_types:
with self.session():
with self.test_scope():
normal = random_ops.random_normal([1024],
dtype=dtype,
mean=2.3,
stddev=2.0)
variance = math_ops.reduce_variance(normal)
x = self.evaluate(variance)
self.assertAllClose(x, 4.0, rtol=1e-1, atol=1e-1)
def testReduceVar(self):
x = np.array([[0, 0, 0], [0, 0, 0]], "float32")
self.assertAllClose(self.evaluate(math_ops.reduce_variance(x)), 0)
self.assertAllClose(
self.evaluate(math_ops.reduce_variance(x, axis=0)), [0, 0, 0])
x = [[1, 2, 1, 1], [1, 1, 0, 1]]
with self.assertRaisesRegexp(TypeError, "must be either real or complex"):
math_ops.reduce_variance(x)
x = [[1., 2., 1., 1.], [1., 1., 0., 1.]]
self.assertEqual(self.evaluate(math_ops.reduce_variance(x)), 0.25)
x_np = np.array(x)
self.assertEqual(np.var(x_np), 0.25)
self.assertEqual(self.evaluate(math_ops.reduce_variance(x_np)), 0.25)
