def test_loss_acurrancy(self):
# =============Accuracy============= #
y_pred = tf.constant([[1., 0., 0.], [1., 0., 0.]])
y_true = tf.constant([[1., MAGIC_NUMBER, 1.], [0., MAGIC_NUMBER, 1.]])
npt.assert_array_equal(categorical_accuracy(y_true, y_pred).numpy(), [1., 0.])
npt.assert_almost_equal(binary_accuracy(y_true, y_pred).numpy(), [1. / 2., 0.])
def compile(self, optimizer=None, loss=None, metrics=None, loss_weights=None, sample_weight_mode=None):
if optimizer is not None:
self.optimizer = optimizer
elif self.optimizer is None or self.optimizer == 'adam':
self.optimizer = Adam(lr=self.lr, beta_1=self.beta_1, beta_2=self.beta_2, epsilon=self.optimizer_epsilon,
decay=0.0)
if self.task == 'regression':
self._last_layer_activation = 'linear'
loss_func = mean_squared_error
if self.metrics is None:
self.metrics = [mean_absolute_error, mean_error]
elif self.task == 'classification':
self._last_layer_activation = 'softmax'
loss_func = categorical_crossentropy
if self.metrics is None:
self.metrics = [categorical_accuracy]
elif self.task == 'binary_classification':
self._last_layer_activation = 'sigmoid'
loss_func = binary_crossentropy
if self.metrics is None:
self.metrics = [binary_accuracy(from_logits=False)]
else:
raise RuntimeError('Only "regression", "classification" and "binary_classification" are supported')
self.keras_model = self.model()
self.keras_model.compile(loss=loss_func, optimizer=self.optimizer, metrics=self.metrics, loss_weights=None)
return None
def test_loss_acurrancy(self):
# =============Accuracy============= #
y_pred = tf.constant([[1., 0., 0.], [1., 0., 0.]])
y_true = tf.constant([[1., MAGIC_NUMBER, 1.], [0., MAGIC_NUMBER, 1.]])
npt.assert_array_equal(categorical_accuracy(y_true, y_pred).eval(session=get_session()), [1., 0.])
npt.assert_almost_equal(binary_accuracy(from_logits=False)(y_true, y_pred).eval(session=get_session()),
[1. / 2., 0.])
def test_loss_acurrancy(self):
# =============Accuracy============= #
with tf.device("/cpu:0"), context.eager_mode():
y_pred = tf.constant([[1., 0., 0.], [1., 0., 0.]])
y_true = tf.constant([[1., MAGIC_NUMBER, 1.],
[0., MAGIC_NUMBER, 1.]])
npt.assert_array_equal(
categorical_accuracy(y_true, y_pred).numpy(), [1., 0.])
npt.assert_almost_equal(
binary_accuracy(y_true, y_pred).numpy(), [1. / 2., 0.])
def compile(self, optimizer=None,
loss=None,
metrics=None,
weighted_metrics=None,
loss_weights=None,
sample_weight_mode=None):
if optimizer is not None:
self.optimizer = optimizer
elif self.optimizer is None or self.optimizer == 'adam':
self.optimizer = Adam(lr=self.lr, beta_1=self.beta_1, beta_2=self.beta_2, epsilon=self.optimizer_epsilon,
decay=0.0)
if self.task == 'regression':
if self._last_layer_activation is None:
self._last_layer_activation = 'linear'
elif self.task == 'classification':
if self._last_layer_activation is None:
self._last_layer_activation = 'softmax'
elif self.task == 'binary_classification':
if self._last_layer_activation is None:
self._last_layer_activation = 'sigmoid'
else:
raise RuntimeError('Only "regression", "classification" and "binary_classification" are supported')
self.keras_model, self.keras_model_predict, output_loss, variance_loss = self.model()
if self.task == 'regression':
self.metrics = [mean_absolute_error, mean_error] if not (metrics and self.metrics) else metrics
self.keras_model.compile(loss={'output': output_loss, 'variance_output': variance_loss},
optimizer=self.optimizer,
metrics={'output': self.metrics},
weighted_metrics=weighted_metrics,
loss_weights={'output': .5,
'variance_output': .5} if not loss_weights else loss_weights,
sample_weight_mode=sample_weight_mode)
elif self.task == 'classification':
self.metrics = [categorical_accuracy] if not (metrics and self.metrics) else metrics
self.keras_model.compile(loss={'output': output_loss, 'variance_output': variance_loss},
optimizer=self.optimizer,
metrics={'output': self.metrics},
weighted_metrics=weighted_metrics,
loss_weights={'output': .5,
'variance_output': .5} if not loss_weights else loss_weights,
sample_weight_mode=sample_weight_mode)
elif self.task == 'binary_classification':
self.metrics = [binary_accuracy(from_logits=True)] if not (metrics and self.metrics) else metrics
self.keras_model.compile(loss={'output': output_loss, 'variance_output': variance_loss},
optimizer=self.optimizer,
metrics={'output': self.metrics},
weighted_metrics=weighted_metrics,
loss_weights={'output': .5,
'variance_output': .5} if not loss_weights else loss_weights,
sample_weight_mode=sample_weight_mode)
return None
def test_loss_func(self):
# make sure custom reduce_var works
var_array = [1, 2, 3, 4, 5]
self.assertEqual(reduce_var(tf.Variable(var_array)).eval(session=get_session()), np.var(var_array))
# =============Magic correction term============= #
y_true = tf.Variable([[2., MAGIC_NUMBER, MAGIC_NUMBER], [2., MAGIC_NUMBER, 4.]])
npt.assert_array_equal(magic_correction_term(y_true).eval(session=get_session()), [3., 1.5])
# =============MSE/MAE============= #
y_pred = tf.Variable([[2., 3., 4.], [2., 3., 7.]])
y_pred_2 = tf.Variable([[2., 9., 4.], [2., 0., 7.]])
y_true = tf.Variable([[2., MAGIC_NUMBER, 4.], [2., MAGIC_NUMBER, 4.]])
npt.assert_almost_equal(mean_absolute_error(y_true, y_pred).eval(session=get_session()), [0., 3. / 2.])
npt.assert_almost_equal(mean_squared_error(y_true, y_pred).eval(session=get_session()), [0., 9. / 2])
# make sure neural network prediction won't matter for magic number term
npt.assert_almost_equal(mean_absolute_error(y_true, y_pred).eval(session=get_session()),
mean_absolute_error(y_true, y_pred_2).eval(session=get_session()))
npt.assert_almost_equal(mean_squared_error(y_true, y_pred).eval(session=get_session()),
mean_squared_error(y_true, y_pred_2).eval(session=get_session()))
# =============Mean Error============= #
y_pred = tf.Variable([[1., 3., 4.], [2., 3., 7.]])
y_true = tf.Variable([[2., MAGIC_NUMBER, 3.], [2., MAGIC_NUMBER, 7.]])
npt.assert_almost_equal(mean_error(y_true, y_pred).eval(session=get_session()), [0., 0.])
# =============Accuracy============= #
y_pred = tf.Variable([[1., 0., 0.], [1., 0., 0.]])
y_true = tf.Variable([[1., MAGIC_NUMBER, 1.], [0., MAGIC_NUMBER, 1.]])
npt.assert_array_equal(categorical_accuracy(y_true, y_pred).eval(session=get_session()), [1., 0.])
npt.assert_almost_equal(binary_accuracy(from_logits=False)(y_true, y_pred).eval(session=get_session()),
[1. / 2., 0.])
# =============Abs Percentage Accuracy============= #
y_pred = tf.Variable([[1., 0., 0.], [1., 0., 0.]])
y_pred_2 = tf.Variable([[1., 9., 0.], [1., -1., 0.]])
y_true = tf.Variable([[1., MAGIC_NUMBER, 1.], [1., MAGIC_NUMBER, 1.]])
npt.assert_array_almost_equal(mean_absolute_percentage_error(y_true, y_pred).eval(session=get_session()),
[50., 50.], decimal=3)
# make sure neural network prediction won't matter for magic number term
npt.assert_array_almost_equal(mean_absolute_percentage_error(y_true, y_pred).eval(session=get_session()),
mean_absolute_percentage_error(y_true, y_pred_2).eval(session=get_session()),
decimal=3)
# =============Percentage Accuracy============= #
y_pred = tf.Variable([[1., 0., 0.], [1., 0., 0.]])
y_pred_2 = tf.Variable([[1., 9., 0.], [1., -1., 0.]])
y_true = tf.Variable([[1., MAGIC_NUMBER, 1.], [1., MAGIC_NUMBER, 1.]])
npt.assert_array_almost_equal(mean_percentage_error(y_true, y_pred).eval(session=get_session()),
[50., 50.], decimal=3)
# make sure neural network prediction won't matter for magic number term
npt.assert_array_almost_equal(mean_percentage_error(y_true, y_pred).eval(session=get_session()),
mean_percentage_error(y_true, y_pred_2).eval(session=get_session()),
decimal=3)
# =============Mean Squared Log Error============= #
y_pred = tf.Variable([[1., 0., 0.], [1., 0., 0.]])
y_pred_2 = tf.Variable([[1., 9., 0.], [1., -1., 0.]])
y_true = tf.Variable([[1., MAGIC_NUMBER, 1.], [1., MAGIC_NUMBER, 1.]])
npt.assert_array_almost_equal(mean_squared_logarithmic_error(y_true, y_pred).eval(session=get_session()),
[0.24, 0.24], decimal=3)
# make sure neural network prediction won't matter for magic number term
npt.assert_array_almost_equal(mean_squared_logarithmic_error(y_true, y_pred).eval(session=get_session()),
mean_squared_logarithmic_error(y_true, y_pred_2).eval(session=get_session()),
decimal=3)
# =============Zeros Loss============= #
y_pred = tf.Variable([[1., 0., 0.], [5., -9., 2.]])
y_true = tf.Variable([[1., MAGIC_NUMBER, 1.], [1., MAGIC_NUMBER, 1.]])
npt.assert_array_almost_equal(zeros_loss(y_true, y_pred).eval(session=get_session()), [0., 0.])
