DEV Community: Tejas Patil

⚡ Lightning-Fast Face Recognition with InsightFace + SORT + Qdrant

Tejas Patil — Mon, 10 Nov 2025 02:30:00 +0000

Most face-recognition systems fail in real life.
Why? Because they try to recognize faces every single frame — slow, unstable, and guaranteed to misidentify people the moment they move their head.

The solution is not “more detection.”
The solution is SORT.

🚀 Why SORT Changes Everything

SORT (Simple Online & Real-Time Tracking) gives you:

Persistent IDs across frames
No flickering names when a person turns their head
High FPS (because you don’t detect every frame)
Stable embeddings (recognize once → reuse for multiple frames)

Think of SORT as the glue that holds your face-recognition pipeline together.

🔥 The Recognition Pipeline (Super Simple)
1️⃣ Detect faces only every N frames

if frame_id % 3 == 0:
    faces = face_app.get(frame)

2️⃣ Use SORT to track faces between detections
tracked = tracker.update(detections)

3️⃣ Assign embeddings via IoU matching

for det_bbox, det_emb in last_face_map.items():
    if compute_iou(track_bbox, det_bbox) > 0.45:
        track_embeddings[track_id] = det_emb

4️⃣ Search identity from Qdrant

hits = client.search(collection_name="faces", query_vector=embedding.tolist(), limit=1)
if hits and hits[0].score > 0.75:
    name = hits[0].payload["name"]

5️⃣ Register new users instantly

if key=='r' and unknown_face:
    client.upsert("faces", [PointStruct(id=uuid4(), vector=emb.tolist(), payload={"name": name})])

🎯 Why This Works So Damn Well
Traditional Method Our SORT Method
Detect every frame → low FPS Detect periodically → high FPS
Identity flickers Consistent identity
CPU overload Efficient
Recompute embeddings repeatedly Compute once per track

SORT turns your pipeline from “weak and jittery” to smooth, stable, and lightning fast.

🧠 InsightFace for Embeddings

InsightFace gives crisp 512-dimensional embeddings:

emb = normalize(face.embedding)

These vectors go straight into Qdrant to enable fast similarity search.

🗂️ Qdrant as the Face Database

Qdrant stores embeddings like a search engine:

client.create_collection(
    collection_name="faces",
    vectors_config=VectorParams(size=512, distance=Distance.COSINE)
)

Querying is instant — even with tens of thousands of faces.

🔄 Putting It All Together

Your real-time loop becomes:

Detect → Track → Attach Embedding → Qdrant Search → Show Name

Instead of:

Detect → Recognize → Detect → Recognize → Detect → Recognize → (lag forever)

🏁 Final Takeaway

The winning formula is simple:

InsightFace → reliable embeddings
SORT → stable tracking
Qdrant → lightning-fast comparison

Together, they create a recognition system that actually works in the real world —
fast, smooth, accurate, and scalable.

Image blur detection using scipy

Tejas Patil — Mon, 13 Oct 2025 04:37:36 +0000

When you work with images — especially in real-time systems — one tiny issue can ruin your entire pipeline: blur.

A blurry image means unreliable results.
But how do you detect blur accurately without slowing everything down?

That’s exactly what I set out to solve — and after testing multiple approaches, I found that sometimes, you don’t need fancy methods.
Even simple ones can work surprisingly well if used right.

The Goal: Detect Blur Efficiently

In my project, I needed a blur detection method that could:

⚡ Work fast for real-time image capture

💻 Run on limited hardware (like Raspberry Pi)

🧩 Be lightweight and easy to integrate

Simple requirements — but meeting all three turned out to be a journey. 😅

⚙️ Attempt 1: Tenengrad (Using OpenCV)

I started with the Tenengrad method, a classic sharpness measure using Sobel gradients.

It’s accurate and mathematically solid — but there was a big catch:

💾 OpenCV’s footprint was heavy.

On resource-limited devices, the disk usage and installation size made it a deal-breaker.
So, I moved on.

🔍 Attempt 2: SciPy’s convolve2d

To keep things lightweight, I tried using SciPy’s convolve2d to apply Sobel filters manually.

It worked decently — small footprint, fast execution, and minimal dependencies.
But…

⚠️ Accuracy dropped for low-texture or unevenly lit images.
A few blurry images were being classified as “clear.”

⚡ Attempt 3: FFT-Based Blur Detection

Then came the FFT (Fast Fourier Transform) approach.

The idea is elegant — sharp images have more high-frequency content, while blurry ones don’t.

But in practice:

❌ Too slow
❌ Too complex for real-time use

FFT-based methods are great for research or offline analysis, but not for a live camera feed.

🤖 Attempt 4: PIQ (PyTorch Image Quality)

Next, I explored PIQ, a PyTorch-based library that measures perceptual quality — including blur.

It was extremely accurate, no doubt about that.

But…

⏳ Too slow on CPU
⚙️ Required CUDA for speed
🚫 Overkill for lightweight systems

So I had to drop it too.

🧩 The Winner: SciPy’s ndimage

After several trials, I circled back to something simple — scipy.ndimage.

It lets you compute Sobel gradients efficiently and measure how much variation exists in the gradient magnitudes — a direct indicator of image sharpness.

Here’s the magic in just a few lines 👇

#magnitude adjustment can be done based on your requirements
from scipy import ndimage
import numpy as np

def estimate_blur(image):
    gx = ndimage.sobel(image, axis=0)
    gy = ndimage.sobel(image, axis=1)
    magnitude = np.hypot(gx, gy)
    return magnitude.var()  # Higher variance = sharper image

That’s it.
No heavy libraries, no CUDA setup — and it just works.

✅ Why It Worked Best

🪶 Lightweight — no OpenCV dependency

⚡ Fast — great for real-time use

🎯 Accurate enough for production

🔧 Easy to integrate anywhere

💬 Why Not Always Go Fancy?

Sometimes, we chase fancy methods because they sound more “AI-powered” or “modern.”
But in real-world systems, especially those running on edge devices, simplicity wins.

You don’t always need deep learning or complex transforms — sometimes a clean, optimized classical method can outperform heavy models when implemented smartly.

💡 Final Thoughts

Finding the “best” blur detection method isn’t about using the most advanced algorithm — it’s about what fits your use case and environment.

For me, scipy.ndimage struck the perfect balance between speed, accuracy, and simplicity.

🚀 What’s Next

I plan to enhance this further by adding:

Edge density analysis

Variance normalization

Adaptive thresholding

to make it more robust under challenging lighting or texture variations.

🧾 Summary

👉 Tenengrad (OpenCV) — dropped due to heavy footprint
👉 SciPy’s convolve2d — fast but less accurate
👉 FFT — too slow for real-time
👉 PIQ — accurate but heavy
✅ SciPy’s ndimage — perfect balance

💭 Final Takeaway

Sometimes, the simplest approach — done right — beats the most complex one.
In engineering, elegance lies in simplicity. ✨

ESRGAN to boost image resolution

Tejas Patil — Mon, 29 Sep 2025 04:33:55 +0000

How I Used ESRGAN to Boost Image Resolution — From Blurry to Crystal Clear

Have you ever zoomed into an old photo only to be disappointed by a blocky, pixelated mess? That happened to me recently when I tried to restore some low-quality images. Traditional upscaling methods like bicubic interpolation just made the pictures bigger — not better. That’s when I turned to ESRGAN (Enhanced Super-Resolution Generative Adversarial Network), and the results were nothing short of magical.

In this blog, I’ll share how I used ESRGAN to improve image resolution, what worked well, and how it compares with other alternatives.

What is ESRGAN in Simple Terms?

Most image upscaling methods stretch pixels to make an image bigger, which often results in blurred edges. ESRGAN, however, takes a different approach.

It uses deep learning — specifically a Generative Adversarial Network (GAN) — to recreate missing details. Instead of just enlarging pixels, ESRGAN imagines finer textures and sharper edges, making the final image look much more realistic.

In short:

Old method: Bigger, blurrier images.

ESRGAN: Bigger, sharper, and more natural-looking images.

How I Implemented ESRGAN

I kept my workflow simple:

Set up the environment Installed dependencies in Python using PyTorch and cloned pretrained ESRGAN repo.

 git clone https://github.com/xinntao/ESRGAN
 cd ESRGAN
 pip install -r requirements.txt

Loaded the model
I used a pretrained ESRGAN model (RRDB_PSNR) since training from scratch requires a massive dataset and GPU resources.
Upscaled the images

import cv2
import torch
from RRDBNet_arch import RRDBNet

# Load pretrained model
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64,
                num_block=23, num_grow_ch=32, scale=4)
model.load_state_dict(torch.load('RRDB_ESRGAN_x4.pth'), strict=True)
model.eval()

# Load image
img = cv2.imread('low_res.png')[:, :, ::-1]  # BGR to RGB
img = torch.from_numpy(img).float().permute(2,0,1).unsqueeze(0) / 255.

# Run ESRGAN
with torch.no_grad():
    out = model(img).clamp(0, 1)

# Save result
out_img = (out.squeeze().permute(1,2,0).numpy() * 255).astype('uint8')
cv2.imwrite('upscaled.png', out_img[:, :, ::-1])

Compared the result The difference was instantly noticeable — textures looked more natural, and the image had much more detail.

Results & Observations

Here’s what I noticed after applying ESRGAN:
✅ Fine details like hair strands, text, and textures were restored.
✅ The upscaled image looked far more realistic than traditional methods.
✅ Performance was fairly fast with GPU acceleration.

However, ESRGAN isn’t perfect:
⚠️ On extremely noisy or compressed images, it sometimes “hallucinates” details that weren’t there originally.
⚠️ Running on CPU is slower, especially for larger images.

Alternatives I Considered

Bicubic Interpolation: Quick, but results were blurry and unimpressive.

SRCNN: Early deep learning model for super-resolution, but oversmoothed results.

SRGAN: Predecessor of ESRGAN; good but not as sharp.

Real-ESRGAN: A practical improvement that handles noisy, real-world images better.

For my case (relatively clean images), ESRGAN worked best since I wanted maximum detail recovery.

Why This Matters

Super-resolution isn’t just for making your selfies sharper. It has real-world applications in:

Medical imaging (clearer scans for diagnosis).
Satellite/drone imagery (better detail for mapping).
Gaming & media (upscaling old textures).
Historical photo restoration (bringing old memories back to life).

Conclusion

Using ESRGAN, I was able to transform low-resolution, pixelated images into sharp, high-resolution outputs that looked almost lifelike. The process was surprisingly straightforward with pretrained models, and the results were far superior to older methods.

If you’re struggling with blurry images, I highly recommend giving ESRGAN a try. And if you’re dealing with real-world noisy photos, check out Real-ESRGAN for even better results.

Logging with Loki, python and slack integration

Tejas Patil — Sun, 21 Sep 2025 12:48:30 +0000

Modern applications generate a lot of logs — from API response times to critical errors. Instead of tailing logs manually, I wanted a way to:

Collect logs in one place
Query them easily
Get notified in Slack when something breaks

For this, I set up Grafana Loki as my log store, integrated it with Python, and added Slack alerts for production errors.

In this post, I’ll walk through the full setup:

Setting up Loki
Configuring Python logging with Loki
Querying Loki using Python
Sending alerts to Slack if an error occurs

🔹 Step 1: Setting Up Loki

First, install Loki and Promtail (Promtail collects logs and ships them to Loki).
Using Docker Compose
Create a docker-compose.yml:

version: "3"

services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log
    command: -config.file=/etc/promtail/config.yml

Start Loki:

docker-compose up -d

Now Loki should be running at:
👉 http://localhost:3100

🔹 Step 2: Configure Promtail
Promtail’s job is to send your logs into Loki.
Example config.yml:

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*.log

This configuration ships logs from /var/log/*.log into Loki.

🔹 Step 3: Python Logging to Loki
Now let’s push Python application logs to Loki.
Install the Loki Python handler:
pip install logging-loki

Update your Python app (app.py):

import logging
from logging_loki import LokiHandler

# Loki URL (adjust to your setup)
LOKI_URL = "http://localhost:3100/loki/api/v1/push"

# Configure logger
logger = logging.getLogger("python-app")
logger.setLevel(logging.ERROR)

handler = LokiHandler(
    url=LOKI_URL,
    tags={"application": "my-python-app"},
    version="1",
)

logger.addHandler(handler)

# Example: simulate an error
try:
    1 / 0
except Exception as e:
    logger.error("🚨 Production error occurred", exc_info=True)

Now, whenever your app throws an error, it gets pushed directly into Loki with structured metadata.

🔹 Step 4: Querying Loki with Python
Sometimes, you may want to query Loki programmatically (e.g., check API response times or errors).

import requests

LOKI_QUERY_URL = "http://localhost:3100/loki/api/v1/query"
query = '{application="my-python-app"} |= "error"'

response = requests.get(LOKI_QUERY_URL, params={"query": query})
if response.status_code == 200:
    results = response.json()["data"]["result"]
    for log in results:
        print(log)

This lets you fetch error logs directly in Python.

🔹 Step 5: Slack Alerts for Errors
Finally, let’s notify Slack when something breaks.

Create a Slack Webhook

Go to Slack → Apps → Create App → Incoming Webhooks
Copy the Webhook URL

Python Code to Send Alerts

import requests
import json
import logging
from logging_loki import LokiHandler

# Slack webhook URL
SLACK_WEBHOOK_URL = "https://hooks.slack.com/services/XXX/YYY/ZZZ"

def send_slack_alert(message: str):
    payload = {"text": message}
    headers = {"Content-Type": "application/json"}
    res = requests.post(SLACK_WEBHOOK_URL, data=json.dumps(payload), headers=headers)
    if res.status_code != 200:
        print(f"Slack alert failed: {res.text}")

# Loki logger
LOKI_URL = "http://localhost:3100/loki/api/v1/push"
logger = logging.getLogger("python-app")
logger.setLevel(logging.ERROR)
logger.addHandler(LokiHandler(url=LOKI_URL, tags={"app": "python-app"}, version="1"))

# Example: simulate production error
try:
    result = 1 / 0
except Exception as e:
    error_message = f"🚨 Error in production: {str(e)}"
    logger.error(error_message, exc_info=True)  # send to Loki
    send_slack_alert(error_message)             # send to Slack

🎯 Final Workflow

Python app runs in production
Any error → Logged to Loki
Same error → Triggered as a Slack notification

This gives me two layers of monitoring:

A full log history in Loki (via Grafana dashboards)
Real-time notifications in Slack

✅ Conclusion
By combining Loki, Python, and Slack, I now have a centralized logging and alerting system:

Loki collects and indexes all logs
Python pushes structured errors directly
Slack instantly alerts the team when something breaks

This setup has already saved me debugging time and ensures I never miss a production issue.