Build Your Own Open-Source Logo Detector

We will use a pre-trained model to detect the Logo in two images of the above same brand.

This figure is showing two points (green and blue), the straight-line (Euclidean) distance between them, and then a “similarity score” that’s just a simple transform of that distance.

An Open-Source Stack for Logo ACR

In practice, many teams today use lightweight detectors such as YOLOv8-Nano and backbones like EfficientNet or Vision Transformers, all available as open-source implementations.

Core components

• Deep learning framework: PyTorch or TensorFlow/Keras; used to train and run the logo embedding model.
• Logo detector: Any open-source object detector (YOLO-style, SSD, RetinaNet, etc.) trained to find “logo-like” regions in a frame.
• Embedding model: A CNN or Vision Transformer backbone (ResNet, EfficientNet, ViT, …) with a metric-learning head that outputs unit-normalized vectors.
• Vector search engine: FAISS library, or a vector DB like Milvus / Qdrant / Weaviate to store millions of embeddings and answer “nearest neighbor” queries quickly.
• Logo data: Synthetic or in-house logo images, plus any public datasets that explicitly allow your intended use.

You can swap any component as long as it plays the same role in the pipeline.

Step 1: Finding Logos in the Wild

Before we can recognize a logo, we have to find it.

1. Sample frames

Processing every single frame in a 60 FPS stream is overkill. Instead:

• Sample 2 to 4 frames per second per stream.
• Treat each sampled frame as a still image to inspect.

This is usually enough for brand/sponsor analytics without breaking the compute budget.

2. Run a logo detector

On each sampled frame:

• Resize and normalize the image (standard pre-processing).
• Feed it into your object detector.
• Get back bounding boxes for regions that look like logos.

Each detection is:

(x_min, y_min, x_max, y_max, confidence_score)

You crop those regions out; each crop is a “logo candidate.”

3. Stabilize over time

Real-world video is messy: blur, motion, partial occlusion, multiple overlays.

Two easy tricks help:

• Temporal smoothing – combine detections across a short window (e.g., 1–2 seconds). If a logo appears in 5 consecutive frames and disappears in one, don’t panic.
• Confidence thresholds – discard detections below a minimum confidence to avoid obvious noise.

After this step, you have a stream of reasonably clean logo crops.

Step 2:  Logo Embeddings

Now that we can crop logos from frames, we need a way to compare them that’s smarter than raw pixels. That’s where embeddings come in.

An embedding is just a vector of numbers (for example, 256 or 512 values) that captures the “essence” of a logo. We train a deep neural network so that:

• Two images of the same logo map to vectors that are close together.
• Images of different logos map to vectors that are far apart.

A common way to train this is with a metric-learning loss such as ArcFace. You don’t need to remember the formula; the intuition is:

“Pull embeddings of the same brand together in the embedding space, and push embeddings of different brands apart.”

After training, the network behaves like a black box:

Below: Scatter plot showing a 2D projection of logo embeddings for three known brands/logos (A, B, C). Each point is one logo image, which is embedded from the same brand cluster tightly, showing clear separation between brands in the embedding space.

We can use a logo embedding model trained with the ArcFace-style (additive angular margin) loss to produce ℓ2-normalized 512-D vectors for each logo crop. There are many open-source ways to build a logo embedder. The simplest way is to load a general vision backbone (e.g., ResNet/EfficientNet/ViT) with an ArcFace-style (additive angular margin) head.

Let’s look at how this works in code-like form. We’ll assume:

• embedding_model(image) takes a logo crop and returns a unit-normalized embedding vector.
• detect_logos(frame) returns a list of logo crops for each frame.
• l2_distance(a, b) computes the Euclidean distance between two embeddings.

First, we build a small embedding database for our known brands:

embedding_model = load_embedding_model("arcface_logo_model.pt")  # PyTorch / TF model
brand_db = {}  # dict: brand_name -> list of embedding vectors
for brand_name in brands_list:
examples = []
for img_path in logo_images[brand_name]:  # paths to example images for this brand
img = load_image(img_path)
crop = preprocess(img)                # resize / normalize
emb = embedding_model(crop)           # unit-normalized logo embedding
examples.append(emb)
brand_db[brand_name] = examples

At runtime, we recognize logos in a new frame like this:

def recognize_logos_in_frame(frame, threshold):
crops = detect_logos(frame)   # logo detector returns candidate crops
results = []

for crop in crops:
query_emb = embedding_model(crop)

best_brand = None
best_dist = float("inf")

# find the closest brand in the database
for brand_name, emb_list in brand_db.items():
# distance to the closest example for this brand
dist_to_brand = min(l2_distance(query_emb, e) for e in emb_list)
if dist_to_brand < best_dist:
best_dist = dist_to_brand
best_brand = brand_name

if best_dist < threshold:
results.append({
"brand": best_brand,
"distance": best_dist,
# you would also include bounding box from the detector
})
else:
results.append({
"brand": None,  # unknown / not in catalog
"distance": best_dist,
})

return results

In a real system, you wouldn’t loop over every embedding in Python. You’d drop the same idea into a vector index such as FAISS, Milvus, or Qdrant, which are open-source engines designed to handle nearest-neighbor search over millions of embeddings efficiently. But the core logic is exactly what this pseudocode shows:

• Embed the query logo,
• Find the closest known logo in the database,
• Check if the distance is below a threshold to decide if it’s a match.

Euclidean Distance for Logo Matching

We can now express logos as numerical vectors, but how do we compare them? Embeddings have a few common similarity measures, and Euclidean distance and cosine similarity are the most used. Because our logo embeddings are ℓ2-normalized (ArcFace-style), cosine similarity and Euclidean distance give the same ranking (one can be derived from the other). Our distance measure will be Euclidean distance (L2 norm).

Euclidean distance between two feature vectors (x) and (y) (each of length (d), here (d = 512)) is defined as: distance=√(Σ(xi​−yi​)²)

After the square root, this is the straight-line distance between the two points in 512-D space. A smaller distance means the points are closer, which—by how we trained the model—indicates the logos are more likely to be the same brand. If the distance is large, they are different brands. Using Euclidean distance on the embeddings turns matching into a nearest-neighbor search in feature space. It’s effectively a K-Nearest Neighbors approach with K=1 (find the single closest match) plus a threshold to decide if that match is confident enough.

Nearest-Neighbor Matching

Using Euclidean distance as our similarity measure is straightforward to implement. We calculate the distance between a query logo’s embedding and each stored brand embedding in our database, then take the minimum. The brand corresponding to that minimum distance is our best match. This method finds the nearest neighbor in embedding space—if that nearest neighbor is still fairly far (distance larger than a threshold), we conclude the query logo is “unknown” (i.e., not one of our known brands). The threshold is important to avoid false positives and should be tuned on validation data.

To summarize, Euclidean distance in our context means: the closer (in Euclidean distance) a query embedding is to a stored embedding, the more similar the logos, and hence the more likely the same brand. We will use this principle for matching.

Step-by-Step Model Pipeline (Logo ACR)

Let’s break down the entire pipeline of our logo detection ACR system into clear steps:

1. Data Preparation

Collect images of known brands’ logos (official artwork + “in-the-wild” shots). Organize by brand (folder per brand or (brand, image_path) list). For in-scene images, run a logo detector to crop each logo region; apply light normalization (resize, padding/letterbox, optional contrast/perspective fix).

2. Embedding Database Creation

Use a logo embedder (ArcFace-style/additive-angular-margin head on a vision backbone) to compute a 256–512D vector for every logo crop. Store as a mapping brand → [embeddings] (e.g., a Python dict or a vector index with metadata).

3. Normalization

Ensure all embeddings are ℓ2-normalized (unit length). Many models output unit vectors; if not, normalize so distance comparisons are consistent.

4. New Image / Stream Query

For each incoming image/frame, run the logo detector to get candidate boxes. For each box, crop and preprocess exactly as in training, then compute the logo embedding.

5. Distance Calculation

Compare the query embedding to the stored catalog using Euclidean (L2) or cosine (equivalent for unit vectors). For large catalogs or real-time streams, use an ANN index (e.g., FAISS HNSW/IVF) instead of brute force.

6. Find Nearest Match

Take the nearest neighbor in embedding space. If you keep multiple exemplars per brand, use the best score per brand (max cosine / min L2) and pick the top brand.

7. Threshold Check (Open-set)

Compare the best score to a tuned threshold.

• Score passes → recognize the logo as that brand.
• Score fails → unknown (not in catalog).
Thresholds are calibrated on validation pairs to balance false positives vs. misses; optionally apply temporal smoothing across frames.

8. Output Result

Return brand id, bounding box, and similarity/distance. If unknown, handle per policy (e.g., “No match in catalog” or route for review). Optionally log matches for auditing and model improvement.

Visualizing Similarity and Matching

The similarity scores (or distances) are often handy to visualize the way the system is making decisions. As an example, provided with a query image, we can examine the calculated distance to every candidate in the database. Ideally, the right identity will be far less than others and will establish a distinct separation between the closest one and the rest.

The chart below illustrates an example. We had a query image of Logo C, and we computed its Euclidean distance to the embeddings of five candidate Logos (LogoA through LogoE) in our database. We then plotted those distances:

In this example, the clear separation between the genuine match (LogoC) and the others makes it easy to choose a threshold. In practice, distances will vary depending on the pair of images. Two Logos of the same brand might sometimes yield a distance slightly higher, especially if the Logos are very different, and two different brand Logos can occasionally have a surprisingly low distance if they look alike. That’s why threshold tuning is needed using a validation set.

Accuracy and Threshold Tuning

To measure system accuracy, we may run the system on a test set of logo images (where there is known identity, but not in the database) and count the number of times the system identifies the brands correctly. We would vary the distance threshold and observe the trade-off between false positives, or the detection of a known logo of a brand as another one, and false negatives, or the failure to detect a known logo because the distance is larger than the threshold. In order to pick a good value, a plot of the ROC curve or simply a calculation of precision/recall at different thresholds can be relevant.

How to tune the threshold (simple, repeatable):

• Build pairs.
  – Genuine pairs: embeddings from the same brand (different files/angles/colors).
  – Impostor pairs: embeddings from different brands (include look-alike marks, color-inverted versions).
• Score pairs. Compute Euclidean (L2) or cosine (on unit vectors, they rank identically).
• Plot histograms. You should see two distributions: same-brand distances clustered low and different-brand distances higher.
• Choose a threshold. Pick the value that best separates the two distributions for your target risk (e.g., the distance where FAR = 1%, or the argmax of F1).
• Open set check. Add non-logo crops and unknown brands to your negatives; verify the threshold still controls false accepts

Below: Histogram of Euclidean distances for same-brand (genuine) vs different-brand (impostor) logo pairs. The dashed line shows the selected threshold separating most genuine from impostor matches.

In summary, to achieve good accuracy:

• Use multiple logos per brand if possible, when building the database, or use augmentation, so the model has a better chance of getting a representative embedding
• Evaluate distances on known validation pairs to understand the range of same-brand vs different-brand distances.
• Set the threshold to balance missed recognitions vs false alarms based on those distributions. You can start with commonly used values (like 0.6 for 128-D embeddings or around 1.24 for 512-D threshold), then adjust.
• Fine-tune as needed: If the system is making mistakes, analyze them. Are the false positives coming from specific look-alike logos? Are the false negatives coming from low-quality images? This analysis can guide adjustments (maybe a lower threshold, or adding more reference images for certain logos, etc.).

Conclusion

In this article, we built a simplified Automatic Content Recognition system for identifying brand logos in images using deep logo embeddings and Euclidean distance. We introduced ACR and its use cases, assembled an open-licensed logo dataset, and used an ArcFace-style embedding model (for logos) to convert cropped logos into a numerical representation. By comparing these embeddings with a Euclidean distance measure, the system can automatically recognize a new logo by finding the nearest match in a database of known brands. We demonstrated how the pipeline works with code snippets and visualized how a decision threshold can be applied to improve accuracy.