def test_eval_generator(self, reduction):
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
eval_result = model.evaluate_generator(custom_generator_multi_io(
sample_weights=[self.sample_weight_1, self.sample_weight_2]),
steps=2)
self.assertAllClose(eval_result, self.expected_batch_result[reduction])
def __init__(self,
visible_units,
hidden_units,
momentum=0.95,
k=1,
name='rbm'):
super(RBM, self).__init__(name=name)
self.w = self.add_weight(shape=(visible_units, hidden_units),
initializer='random_normal',
trainable=True,
name="w")
self.visible_units = visible_units
self.v = DenseRBM(visible_units)
self.h = DenseRBM(hidden_units)
self.k = k
self.momentum = momentum
self.dW = tf.Variable(tf.zeros((visible_units, hidden_units)),
dtype=tf.float32)
self.dVB = tf.Variable(tf.zeros((visible_units, )), dtype=tf.float32)
self.dHB = tf.Variable(tf.zeros((hidden_units, )), dtype=tf.float32)
self.mse = losses.MeanSquaredError()
def test_fit_generator(self, reduction):
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
history = model.fit_generator(custom_generator_multi_io(),
steps_per_epoch=2,
epochs=2)
for key, value in self.expected_fit_result[reduction].items():
self.assertAllClose(history.history[key], value)
def test_standalone_loss_without_loss_reduction(self, distribution):
with distribution.scope():
loss_object = losses.MeanSquaredError()
with self.assertRaisesRegexp(
ValueError, 'Please use `tf.keras.losses.Reduction.SUM` or '
'`tf.keras.losses.Reduction.NONE`'):
y = np.asarray([1, 0])
loss_object(y, y)
def get_loss_function(loss):
"""Returns the loss function corresponding to the given loss input."""
if loss is None or isinstance(loss, losses.Loss):
return loss
# TODO(psv): After we have added all V2 losses, update this function.
if loss in ['mse', 'MSE', 'mean_squared_error']:
return losses.MeanSquaredError()
return losses.get(loss)
def test_eval_generator(self, reduction):
if testing_utils.should_run_distributed():
self.skipTest('b/137397816')
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
eval_result = model.evaluate_generator(custom_generator_multi_io(
sample_weights=[self.sample_weight_1, self.sample_weight_2]),
steps=2)
self.assertAllClose(eval_result, self.expected_batch_result[reduction])
def test_eval(self, reduction):
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
eval_result = model.evaluate([self.x, self.x], [self.y1, self.y2],
batch_size=2,
sample_weight={
'output_1': self.sample_weight_1,
'output_2': self.sample_weight_2,
})
self.assertAllClose(eval_result, self.expected_batch_result[reduction])
def test_fit_generator(self, reduction):
if testing_utils.should_run_distributed():
self.skipTest('b/137397816')
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
history = model.fit_generator(custom_generator_multi_io(
sample_weights=[self.sample_weight_1, self.sample_weight_2]),
steps_per_epoch=2,
epochs=2)
for key, value in self.expected_fit_result[reduction].items():
self.assertAllClose(history.history[key], value)
def test_loss_class_as_metric_with_distribution(self):
distribution = one_device_strategy.OneDeviceStrategy('/device:CPU:0')
with distribution.scope():
metric_container = compile_utils.MetricsContainer(
losses_mod.MeanSquaredError())
y_t, y_p = array_ops.ones((10, 5)), array_ops.zeros((10, 5))
metric_container.update_state(y_t, y_p)
self.assertLen(metric_container.metrics, 1)
metric = metric_container.metrics[0]
self.assertEqual(metric.name, 'mean_squared_error')
self.assertEqual(metric.result().numpy(), 1.)
def test_test_on_batch(self, reduction):
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
result = model.test_on_batch([self.x, self.x], [self.y1, self.y2],
sample_weight={
'output_1': self.sample_weight_1,
'output_2': self.sample_weight_2,
})
expected_values = self.expected_batch_result[reduction]
if reduction == losses_utils.ReductionV2.SUM:
expected_values = self.expected_single_batch_result
self.assertAllClose(result, expected_values)
def test_fit(self, reduction):
model = self._get_compiled_multi_io_model(loss=losses.MeanSquaredError(
reduction=reduction))
history = model.fit([self.x, self.x], [self.y1, self.y2],
sample_weight={
'output_1': self.sample_weight_1,
'output_2': self.sample_weight_2,
},
batch_size=2,
epochs=2,
shuffle=False)
for key, value in self.expected_fit_result[reduction].items():
self.assertAllClose(history.history[key], value)
def test_test_on_batch(self, reduction):
model = self._get_compiled_multi_io_model(
loss=losses.MeanSquaredError(reduction=reduction))
result = model.test_on_batch([self.x, self.x], [self.y1, self.y2],
sample_weight={
'output_1': self.sample_weight_1,
'output_2': self.sample_weight_2,
})
expected_values = self.expected_batch_result[reduction]
if reduction == loss_reduction.ReductionV2.SUM:
# We are taking all the data as one batch, so undo the averaging here.
expected_values = [x * 2 for x in self.expected_batch_result[reduction]]
self.assertAllClose(result, expected_values)
def conf_loss(y_true, y_pred):
y_true = K.cast(y_true, dtype=tf.float32)
y_pred = K.cast(y_pred, dtype=tf.float32)
bboxes_true = y_true[..., :4]
bboxes_pred = y_pred[..., :4]
conf_true = y_true[..., 4]
conf_pred = y_pred[..., 4]
#print(bboxes_true)
#print(bboxes_true * K.expand_dims(conf_true))
mseFunc = losses.MeanSquaredError(reduction='sum_over_batch_size')
mse = mseFunc(bboxes_true * K.expand_dims(conf_true),
bboxes_pred * K.expand_dims(conf_true))
bceFunc = losses.BinaryCrossentropy(reduction='sum_over_batch_size')
bce = bceFunc(conf_true, conf_pred)
#print("MSE: ", mse)
#print("BCE: ", bce)
return 10 * mse + bce
def __init__(self, units, input_dim, alpha):
super(CenterLossLinear, self).__init__()
self.alpha = alpha
self.centers = tf.zeros(shape=[units, input_dim], dtype=tf.float32)
self.mse = losses.MeanSquaredError()()
self.fc = layers.Dense(units)