Introduction

Contrastive loss and triplet loss are standard tools in metric learning. Instead of predicting a class directly, the model learns an embedding space where similar examples land close together and dissimilar examples land farther apart. In TensorFlow, the core implementation is straightforward once the model emits embeddings and you define the right pairwise distance calculation.

Build an Embedding Model First

Both losses operate on embeddings, not raw logits. A simple Keras model can map each input into a low-dimensional vector and normalize it so distance calculations stay stable.

1import tensorflow as tf
2
3def build_encoder(embedding_dim=32):
4    inputs = tf.keras.Input(shape=(28, 28, 1))
5    x = tf.keras.layers.Conv2D(32, 3, activation="relu")(inputs)
6    x = tf.keras.layers.MaxPool2D()(x)
7    x = tf.keras.layers.Conv2D(64, 3, activation="relu")(x)
8    x = tf.keras.layers.GlobalAveragePooling2D()(x)
9    x = tf.keras.layers.Dense(embedding_dim)(x)
10    outputs = tf.math.l2_normalize(x, axis=1)
11    return tf.keras.Model(inputs, outputs)
12
13encoder = build_encoder()

L2 normalization is common because it keeps embedding magnitudes under control and makes distance comparisons easier to interpret.

Contrastive Loss Works on Pairs

For contrastive loss, each training example is a pair of inputs plus a binary label:

• '1 means the pair should be close'
• '0 means the pair should be at least a margin apart'

1import tensorflow as tf
2
3def contrastive_loss(y_true, distances, margin=1.0):
4    y_true = tf.cast(y_true, tf.float32)
5    positive = y_true * tf.square(distances)
6    negative = (1.0 - y_true) * tf.square(tf.maximum(margin - distances, 0.0))
7    return tf.reduce_mean(positive + negative)
8
9def pairwise_distance(left, right):
10    return tf.norm(left - right, axis=1)

You can wrap that around a Siamese model:

1left_input = tf.keras.Input(shape=(28, 28, 1))
2right_input = tf.keras.Input(shape=(28, 28, 1))
3
4left_embedding = encoder(left_input)
5right_embedding = encoder(right_input)
6
7distance = tf.keras.layers.Lambda(
8    lambda tensors: pairwise_distance(tensors[0], tensors[1])
9)([left_embedding, right_embedding])
10
11siamese_model = tf.keras.Model([left_input, right_input], distance)

Training then uses pair labels and the custom loss.

Triplet Loss Works on Anchor, Positive, and Negative

Triplet loss uses three inputs:

• an anchor example
• a positive example from the same class
• a negative example from a different class

The goal is to make the anchor closer to the positive than to the negative by at least a margin.

1import tensorflow as tf
2
3def triplet_loss(anchor, positive, negative, margin=0.2):
4    pos_dist = tf.reduce_sum(tf.square(anchor - positive), axis=1)
5    neg_dist = tf.reduce_sum(tf.square(anchor - negative), axis=1)
6    losses = tf.maximum(pos_dist - neg_dist + margin, 0.0)
7    return tf.reduce_mean(losses)

A triplet model can share the same encoder across all three inputs:

1anchor_input = tf.keras.Input(shape=(28, 28, 1))
2positive_input = tf.keras.Input(shape=(28, 28, 1))
3negative_input = tf.keras.Input(shape=(28, 28, 1))
4
5anchor_embedding = encoder(anchor_input)
6positive_embedding = encoder(positive_input)
7negative_embedding = encoder(negative_input)
8
9triplet_model = tf.keras.Model(
10    [anchor_input, positive_input, negative_input],
11    [anchor_embedding, positive_embedding, negative_embedding],
12)

This setup is often trained with a custom train_step because the loss depends on multiple outputs at once.

Example Custom Training Step

1class TripletTrainer(tf.keras.Model):
2    def __init__(self, triplet_model, margin=0.2):
3        super().__init__()
4        self.triplet_model = triplet_model
5        self.margin = margin
6
7    def train_step(self, data):
8        anchor, positive, negative = data
9        with tf.GradientTape() as tape:
10            a, p, n = self.triplet_model([anchor, positive, negative], training=True)
11            loss = triplet_loss(a, p, n, margin=self.margin)
12
13        gradients = tape.gradient(loss, self.triplet_model.trainable_variables)
14        self.optimizer.apply_gradients(zip(gradients, self.triplet_model.trainable_variables))
15        return {"loss": loss}

This is a clean way to keep the training loop close to the mathematics of the triplet objective.

Common Pitfalls

The biggest mistake is feeding raw class labels into contrastive or triplet code without building the required pair or triplet sampling pipeline. These losses depend heavily on how examples are grouped.

Another issue is skipping embedding normalization and then struggling with unstable distance scales. The model can still train without normalization, but the geometry is harder to control.

Margin choice is another source of problems. If the margin is too small, the model may learn weak separation. If it is too large, optimization can become unnecessarily hard.

Finally, data mining matters. Easy pairs and easy triplets quickly stop providing useful gradients. In real systems, careful sampling or hard-negative mining often matters as much as the loss formula itself.

Summary

• Contrastive loss learns from labeled pairs, while triplet loss learns from anchor-positive-negative triples.
• Both losses require an encoder that outputs embeddings rather than class logits.
• L2-normalized embeddings are a common and practical choice.
• In TensorFlow, the loss formulas are short; building the right data pipeline is the harder part.
• Margin selection and triplet or pair sampling strongly affect training quality.