def test_accuracy(self):
acc_obj = metrics.Accuracy(name='my acc')
# check config
self.assertEqual(acc_obj.name, 'my acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, dtypes.float32)
self.evaluate(variables.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([[1], [2], [3], [4]],
[[1], [2], [3], [4]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# Check save and restore config
a2 = metrics.Accuracy.from_config(acc_obj.get_config())
self.assertEqual(a2.name, 'my acc')
self.assertTrue(a2.stateful)
self.assertEqual(len(a2.variables), 2)
self.assertEqual(a2.dtype, dtypes.float32)
# check with sample_weight
result_t = acc_obj([[2], [1]], [[2], [0]],
sample_weight=[[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.96, 2) # 4.5/4.7
def metrics(self, regularization_losses=None):
"""Creates metrics. See `base_head.Head` for details."""
keys = metric_keys.MetricKeys
with ops.name_scope('metrics', values=(regularization_losses,)):
# Mean metric.
eval_metrics = {}
eval_metrics[self._loss_mean_key] = metrics.Mean(name=keys.LOSS_MEAN)
eval_metrics[self._accuracy_key] = metrics.Accuracy(name=keys.ACCURACY)
eval_metrics[self._precision_key] = metrics.Precision(name=keys.PRECISION)
eval_metrics[self._recall_key] = metrics.Recall(name=keys.RECALL)
eval_metrics[self._prediction_mean_key] = metrics.Mean(
name=keys.PREDICTION_MEAN)
eval_metrics[self._label_mean_key] = metrics.Mean(name=keys.LABEL_MEAN)
eval_metrics[self._accuracy_baseline_key] = (
metrics.Mean(name=keys.ACCURACY_BASELINE))
# The default summation_method is "interpolation" in the AUC metric.
eval_metrics[self._auc_key] = metrics.AUC(name=keys.AUC)
eval_metrics[self._auc_pr_key] = metrics.AUC(curve='PR', name=keys.AUC_PR)
if regularization_losses is not None:
eval_metrics[self._loss_regularization_key] = metrics.Mean(
name=keys.LOSS_REGULARIZATION)
for i, threshold in enumerate(self._thresholds):
eval_metrics[self._accuracy_keys[i]] = metrics.BinaryAccuracy(
name=self._accuracy_keys[i], threshold=threshold)
eval_metrics[self._precision_keys[i]] = metrics.Precision(
name=self._precision_keys[i], thresholds=threshold)
eval_metrics[self._recall_keys[i]] = metrics.Recall(
name=self._recall_keys[i], thresholds=threshold)
return eval_metrics
def testEvaluatePerfectModel(self):
checkpoint_dir = os.path.join(self.get_temp_dir(),
'evaluate_perfect_model_once')
# Train a Model to completion:
self._train_model(checkpoint_dir, num_steps=300)
# Run
inputs = constant_op.constant(self._inputs, dtype=dtypes.float32)
labels = constant_op.constant(self._labels, dtype=dtypes.float32)
logits = logistic_classifier(inputs)
predictions = math_ops.round(logits)
accuracy = metrics_module.Accuracy()
update_op = accuracy.update_state(labels, predictions)
checkpoint_path = saver.latest_checkpoint(checkpoint_dir)
final_ops_values = evaluation._evaluate_once(
checkpoint_path=checkpoint_path,
eval_ops=update_op,
final_ops={'accuracy': (accuracy.result(), update_op)},
hooks=[
evaluation._StopAfterNEvalsHook(1),
])
self.assertTrue(final_ops_values['accuracy'] > .99)
def metrics(self, regularization_losses=None):
"""Creates metrics. See `base_head.Head` for details."""
keys = metric_keys.MetricKeys
with ops.name_scope('metrics', values=(regularization_losses,)):
# Mean metric.
eval_metrics = {}
eval_metrics[self._loss_mean_key] = metrics.Mean(name=keys.LOSS_MEAN)
if regularization_losses is not None:
eval_metrics[self._loss_regularization_key] = metrics.Mean(
name=keys.LOSS_REGULARIZATION)
# Accuracy metric.
eval_metrics[self._accuracy_key] = metrics.Accuracy(name=keys.ACCURACY)
return eval_metrics
def testEvaluateWithFiniteInputs(self):
checkpoint_dir = os.path.join(self.get_temp_dir(),
'evaluate_with_finite_inputs')
# Train a Model to completion:
self._train_model(checkpoint_dir, num_steps=300)
# Run evaluation. Inputs are fed through input producer for one epoch.
all_inputs = constant_op.constant(self._inputs, dtype=dtypes.float32)
all_labels = constant_op.constant(self._labels, dtype=dtypes.float32)
single_input, single_label = training.slice_input_producer(
[all_inputs, all_labels], num_epochs=1)
inputs, labels = training.batch([single_input, single_label],
batch_size=6,
allow_smaller_final_batch=True)
logits = logistic_classifier(inputs)
predictions = math_ops.round(logits)
accuracy = metrics_module.Accuracy()
update_op = accuracy.update_state(labels, predictions)
checkpoint_path = saver.latest_checkpoint(checkpoint_dir)
final_ops_values = evaluation._evaluate_once(
checkpoint_path=checkpoint_path,
eval_ops=update_op,
final_ops={
'accuracy': (accuracy.result(), update_op),
'eval_steps': evaluation._get_or_create_eval_step()
},
hooks=[
evaluation._StopAfterNEvalsHook(None),
])
self.assertTrue(final_ops_values['accuracy'] > .99)
# Runs evaluation for 4 iterations. First 2 evaluate full batch of 6 inputs
# each; the 3rd iter evaluates the remaining 4 inputs, and the last one
# triggers an error which stops evaluation.
self.assertEqual(final_ops_values['eval_steps'], 4)
train_dataset = tf.data.Dataset.from_tensor_slices((scaled_images, rotations))
train_dataset = train_dataset.shuffle(buffer_size=524)
valid_dataset = tf.data.Dataset.from_tensor_slices(
(scaled_images_valid, rotations_valid))
valid_dataset = train_dataset.shuffle(buffer_size=524)
model = ConvModel()
#loss_object = tf.keras.losses.binary_crossentropy()
optimizer = tf.keras.optimizers.Adam()
#track the evolution
# Loss
train_loss = metrics.Mean(name='train_loss')
valid_loss = metrics.Mean(name='valid_loss')
# Accuracy
train_accuracy = metrics.Accuracy(name='train_accuracy')
valid_accuracy = metrics.Accuracy(name='valid_accuracy')
@tf.function
def train_step(image, rotations):
# permet de surveiller les opérations réalisé afin de calculer le gradient
with tf.GradientTape() as tape:
# fait une prediction
predictions = model(image)
print("rotations shape after creation model", rotations)
print("prediction shape after creation model", predictions)
# calcul de l'erreur en fonction de la prediction et des targets
loss = keras.losses.mean_squared_error(rotations, predictions)
print("calcul loss", loss)
# calcul du gradient en fonction du loss
