DBSCAN Clustering — When Epsilon Silently Fails at Scale

Fraud detection systems, GPS trajectory analysis, astronomical survey pipelines, and urban traffic modeling all share one awkward truth: real-world data is messy, oddly shaped, and full of outliers that will corrupt any clustering result if you're not careful. K-Means assumes spherical clusters of equal size. Gaussian Mixture Models assume your data follows a smooth bell curve. Real data almost never cooperates with either assumption. That's the quiet crisis that DBSCAN was built to solve.

DBSCAN — Density-Based Spatial Clustering of Applications with Noise — finds clusters by looking for regions of high point density, connecting them into arbitrarily shaped blobs, and explicitly labeling low-density points as outliers rather than forcing them into a cluster they don't belong to. It needs no upfront cluster count, handles noise natively, and discovers clusters shaped like crescents, rings, or irregular coastlines with equal ease. The price you pay is sensitivity to two hyperparameters that, if mistuned, will silently collapse everything into one giant cluster or atomize every point into noise.

By the end of this article you'll understand exactly how DBSCAN's neighborhood expansion works at the algorithm level, why distance metrics and dimensionality interact in dangerous ways, how to tune epsilon systematically using a k-distance plot rather than guessing, how to scale DBSCAN to millions of points in production using spatial indexes, and how to spot the three most common mistakes that make DBSCAN results look completely wrong without throwing a single error.

What is DBSCAN Clustering?

DBSCAN doesn't care about the shape of your clusters. Circles, crescents, spirals — it finds them all by looking at one thing: density. A cluster is simply a region where points are packed tightly together, separated by regions where they aren't. That's the entire idea.

Here's how it decides, point by point: pick a point, look at its neighborhood within radius epsilon. If there are at least min_samples points in that neighborhood (including itself), it's a core point — the seed of a cluster. Keep expanding from every core point you find, adding any point within epsilon of an existing core point. Points that get pulled in but don't have enough neighbors themselves are border points. Everything left over is noise.

The trick that makes this work: the expansion happens through density-reachability. Point A connects to point B if there's a chain of core points from A to B where each step stays within epsilon. That's how DBSCAN finds arbitrarily shaped clusters — it follows the density, not a pre-defined shape.

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

def fit_dbscan(df, eps=0.5, min_samples=5):
    """
    Fit DBSCAN on a DataFrame with automatic scaling.
    
    The 1 rule: scale before you cluster. DBSCAN is not
    scale-invariant and Euclidean distance will dominate
    whichever feature has the largest magnitude.
    """
    scaler = StandardScaler()
    scaled = scaler.fit_transform(df)
    
    db = DBSCAN(eps=eps, min_samples=min_samples)
    labels = db.fit_predict(scaled)
    
    n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
    n_noise = list(labels).count(-1)
    
    print(f"Clusters found: {n_clusters}")
    print(f"Noise points: {n_noise} / {len(labels)}")
    
    return labels, db

Core Algorithm: How DBSCAN Expands Clusters

Let's walk through what actually happens when you call fit(). The algorithm does three passes over your data, and the order matters.

Pass one: for every point, count how many neighbors fall within epsilon. If that count >= min_samples, label it as a core point. This is the most expensive pass — it's an all-pairs distance computation unless you use a spatial index.

Pass two: connect the core points. Any two core points within epsilon of each other belong to the same cluster. This is done through union-find or BFS — the exact mechanism varies by implementation. In sklearn, it's a connected-components search on the core-point adjacency graph.

Pass three: assign border points and noise. Every non-core point gets checked against the core points. If it's within epsilon of any core point, it joins that cluster as a border point. If not, it's noise for life.

That's it. Three passes. The algorithm is deceptively simple. The complexity — and the source of most bugs — comes from the geometry, not the logic.

import numpy as np
from sklearn.neighbors import BallTree

def dbscan_internals(X, eps, min_samples):
    """
    Minimal DBSCAN implementation to show the three passes.
    Uses BallTree for O(n log n) neighbor search instead of
    the naive O(n^2). In production, sklearn's C-optimized
    version is ~50x faster than this Python version.
    """
    tree = BallTree(X, leaf_size=40)
    n = X.shape[0]
    labels = np.full(n, -1, dtype=int)
    
    # Pass 1: find core points
    core = np.zeros(n, dtype=bool)
    for i in range(n):
        neighbors = tree.query_radius(X[i].reshape(1, -1), r=eps)[0]
        core[i] = len(neighbors) >= min_samples
    
    # Pass 2: connect core points via BFS
    cluster_id = 0
    for i in range(n):
        if not core[i] or labels[i] != -1:
            continue
        neighbors = tree.query_radius(X[i].reshape(1, -1), r=eps)[0]
        labels[i] = cluster_id
        stack = [n for n in neighbors if core[n] and labels[n] == -1]
        while stack:
            j = stack.pop()
            if labels[j] != -1:
                continue
            labels[j] = cluster_id
            j_neighbors = tree.query_radius(X[j].reshape(1, -1), r=eps)[0]
            extended = [n for n in j_neighbors if core[n] and labels[n] == -1]
            stack.extend(extended)
        cluster_id += 1
    
    # Pass 3: border points
    for i in range(n):
        if labels[i] != -1 or core[i]:
            continue
        neighbors = tree.query_radius(X[i].reshape(1, -1), r=eps)[0]
        core_nbrs = [n for n in neighbors if core[n]]
        if core_nbrs:
            labels[i] = labels[core_nbrs[0]]
    
    return labels

Epsilon and min_samples: The Two Levers That Control Everything

DBSCAN has exactly two knobs. Every production failure I've seen with DBSCAN traces back to one of them being set wrong — usually epsilon.

Epsilon (eps) is the radius of the neighborhood. Too small and every point becomes noise. Too large and everything merges into one blob. The right value depends entirely on the scale of your data, which is why you must scale your features first and then set epsilon relative to the scaled space.

Min_samples is the minimum number of points required to form a dense neighborhood. The default of 5 works surprisingly well for low-dimensional data, but the rule of thumb is: set it to at least dims + 1, and preferably dims × 2. In high dimensions (20+), you need more points to get a reliable density estimate, which means min_samples should go up.

The two interact in a way most tutorials gloss over: increasing min_samples makes it harder to become a core point, which fragments clusters and increases noise. Decreasing epsilon does the same thing. You can trade one against the other, but they're not symmetric — epsilon changes the geometry, min_samples changes the threshold.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
from sklearn.cluster import DBSCAN

def tune_dbscan(X_scaled, min_samples_range=(3, 10), eps_range=(0.1, 2.0, 20)):
    """
    Grid search over min_samples and epsilon.
    Returns the combination that maximizes silhouette score
    while keeping noise ratio below 30%.
    
    Production note: silhouette score assumes convex clusters.
    For non-convex clusters, use Davies-Bouldin instead.
    """
    from sklearn.metrics import silhouette_score, davies_bouldin_score
    
    eps_values = np.linspace(*eps_range)
    best_score = -1
    best_params = {}
    
    for ms in range(min_samples_range[0], min_samples_range[1] + 1):
        for eps in eps_values:
            db = DBSCAN(eps=eps, min_samples=ms)
            labels = db.fit_predict(X_scaled)
            
            if len(set(labels)) < 2 or (labels == -1).sum() / len(labels) > 0.3:
                continue
                
            score = silhouette_score(X_scaled, labels)
            if score > best_score:
                best_score = score
                best_params = {'eps': eps, 'min_samples': ms}
    
    return best_params

Distance Metrics and the Curse of Dimensionality

Here's the uncomfortable truth about DBSCAN: it relies entirely on distance to define density, and distance stops being meaningful in high dimensions. This isn't a DBSCAN problem — it's a geometry problem. Every distance-based algorithm hits this wall.

In low dimensions (2-10), points cluster nicely. The ratio between the nearest and farthest neighbor distances is small enough that epsilon can cleanly separate dense from sparse regions. But as dimensions increase, the volume of space grows exponentially, and points become approximately equidistant from each other. By the time you reach 50 dimensions, the concept of "nearest neighbor" loses meaning — everything is equally far from everything else.

The practical impact: your k-distance plot flattens. There's no elbow anymore. Epsilon tuning becomes a guessing game because the density gradient has disappeared.

The fix is not to tune harder. The fix is to reduce dimensions before clustering. PCA, t-SNE, UMAP — pick one and project down to 10-20 dimensions before running DBSCAN. If you can't reduce dimensions, switch to a clustering algorithm that doesn't rely on distance, like spectral clustering or a Gaussian mixture model.

import numpy as np
from sklearn.decomposition import PCA
from sklearn.cluster import DBSCAN

def dbscan_with_pca(X, n_components=None, eps=0.5, min_samples=5):
    """
    Reduce dimensionality with PCA before DBSCAN.
    
    The rule: if you have more than 20 features, you MUST
    reduce dimensions before density-based clustering.
    Euclidean distance becomes noise beyond 20D.
    """
    n_features = X.shape[1]
    
    if n_features <= 20:
        # Low dimensions — cluster directly
        return DBSCAN(eps=eps, min_samples=min_samples).fit_predict(X)
    
    # High dimensions — reduce first
    if n_components is None:
        # Retain 95% variance
        pca = PCA(n_components=0.95)
    else:
        pca = PCA(n_components=n_components)
    
    X_reduced = pca.fit_transform(X)
    
    print(f"Reduced from {n_features} to {X_reduced.shape[1]} dimensions")
    print(f"Explained variance: {pca.explained_variance_ratio_.sum():.2%}")
    
    labels = DBSCAN(eps=eps, min_samples=min_samples).fit_predict(X_reduced)
    
    return labels

Tuning DBSCAN with k-Distance Plots

The k-distance plot is the single most important diagnostic tool for DBSCAN. It tells you exactly where to set epsilon — assuming your data has a density structure worth finding.

Here's how it works: for every point in your dataset, compute the distance to its k-th nearest neighbor (where k = min_samples). Sort these distances in ascending order and plot them. The resulting curve shows you the density distribution of your data.

Points in dense regions have small k-th neighbor distances — they cluster near the left side of the plot. Points in sparse regions have larger distances and sit further right. The elbow of the curve — where the slope shifts from shallow to steep — is the boundary between dense and sparse regions. That's your epsilon.

But here's the catch: the elbow only exists if your data actually has clusters. If the plot is a smooth curve with no clear inflection point, your data is either uniformly dense (everything clusters together) or uniformly sparse (everything is noise). In either case, DBSCAN is the wrong algorithm.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import StandardScaler

def k_distance_plot(X, min_samples=5, scale=True):
    """
    Generate a k-distance plot to find the optimal epsilon.
    
    The elbow of this curve is your epsilon value.
    Points in dense regions = left side (small distances).
    Points in sparse regions = right side (large distances).
    The elbow = the transition between them = your epsilon.
    
    Production rule: if there is no elbow, do not use DBSCAN.
    """
    if scale:
        X = StandardScaler().fit_transform(X)
    
    nbrs = NearestNeighbors(n_neighbors=min_samples).fit(X)
    distances, _ = nbrs.kneighbors(X)
    
    # Distance to the k-th nearest neighbor (last column)
    k_dist = np.sort(distances[:, -1])
    
    plt.figure(figsize=(10, 6))
    plt.plot(k_dist)
    plt.xlabel('Points sorted by distance')
    plt.ylabel(f'{min_samples}-th nearest neighbor distance')
    plt.title('k-Distance Plot — Find the Elbow for Epsilon')
    plt.grid(True, alpha=0.3)
    plt.show()
    
    return k_dist

Scaling DBSCAN to Production Datasets

DBSCAN's reputation as unscalable is only half true. Yes, the naive implementation is O(n²). Yes, running it on a million points without a spatial index will crash your container. But with the right indexing strategy and some pragmatic trade-offs, DBSCAN handles hundreds of thousands of points in production every day.

Sklearn's DBSCAN gives you four algorithm options: auto, ball_tree, kd_tree, and brute. Auto picks KD-tree for low dimensions (<= 20) and brute for high dimensions — which is useless because brute is O(n²). Always set it explicitly. For most production use cases, ball_tree with leaf_size between 30-50 gives the best performance across both low and moderate dimensions.

Beyond 500k points, even BallTree starts to struggle. The practical solution is sampling. Take a random sample of 100k points, run DBSCAN on the sample, then use a nearest-neighbor classifier to assign the remaining points to their nearest cluster — or label them as noise if they're too far from any core point. This gives you ~95% of the clustering quality at 10% of the compute cost.

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import StandardScaler

def dbscan_predict(dbscan_model, X_new, eps):
    """
    Assign new points to DBSCAN clusters using nearest-neighbor.
    
    DBSCAN itself has no predict() method. This implementation
    assigns a new point to the cluster of its nearest neighbor
    — but only if within epsilon. Otherwise it's noise.
    """
    nbrs = NearestNeighbors(n_neighbors=1, radius=eps).fit(dbscan_model.components_)
    distances, indices = nbrs.kneighbors(X_new)
    labels = dbscan_model.labels_[indices.flatten()]
    labels[distances.flatten() > eps] = -1
    return labels

def dbscan_with_sampling(X, sample_size=100000, eps=0.5, min_samples=5):
    """
    Fit DBSCAN on a sample, then propagate labels.
    
    For datasets > 500k rows, this is the only practical way
    to use DBSCAN without burning through memory.
    Expect ~95% agreement with full-dataset DBSCAN.
    """
    if len(X) <= sample_size:
        return DBSCAN(eps=eps, min_samples=min_samples, algorithm='ball_tree').fit_predict(X)
    
    idx = np.random.choice(len(X), sample_size, replace=False)
    X_sample = X[idx]
    
    db = DBSCAN(eps=eps, min_samples=min_samples, algorithm='ball_tree')
    sample_labels = db.fit_predict(X_sample)
    
    return dbscan_predict(db, X, eps)

Common DBSCAN Pitfalls and How to Spot Them

DBSCAN fails silently. That's its most dangerous quality. K-Means throws an error if you set k to 100 and your data only has 3 clusters. DBSCAN just gives you 3 clusters and labels the rest as noise — with no warning, no metric, no signal that something is wrong.

Pitfall one: forgetting that DBSCAN doesn't scale features. This is the most common production bug. If your features have different units (meters, dollars, counts), the distance is dominated by the largest-magnitude feature. StandardScaler is not optional — it's a prerequisite.

Pitfall two: using DBSCAN on data with no clusters. The k-distance plot will show no elbow, but you won't know unless you look. DBSCAN will still assign labels — they're just meaningless. Always inspect the k-distance plot before trusting the output.

Pitfall three: assuming DBSCAN can separate clusters of different densities. It can't. If your data has a dense cluster and a sparse cluster, DBSCAN will either see the sparse one as noise (if epsilon is small) or merge both into one (if epsilon is large). HDBSCAN exists for this exact scenario.

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

def dbscan_production_check(X, eps, min_samples):
    """
    Run pre-checks before fitting DBSCAN in production.
    Returns a dict of warnings if something is wrong.
    """
    warnings = {}
    n, d = X.shape
    
    # Check 1: feature scale variance
    scales = X.std(axis=0)
    if scales.max() / (scales.min() + 1e-10) > 10:
        warnings['scale_mismatch'] = (
            f'Feature scales vary by {scales.max()/scales.min():.1f}x. '
            'Use StandardScaler before clustering.'
        )
    
    # Check 2: dimensionality
    if d > 20:
        warnings['high_dimensions'] = (
            f'Data has {d} dimensions. Euclidean distance may be '
            'meaningless. Consider PCA first.'
        )
    
    # Check 3: noise ratio after fitting
    labels = DBSCAN(eps=eps, min_samples=min_samples, algorithm='ball_tree').fit_predict(X)
    noise_ratio = (labels == -1).sum() / n
    if noise_ratio > 0.5:
        warnings['high_noise'] = (
            f'{noise_ratio:.0%} of points are noise. '
            'Increase epsilon or check feature scales.'
        )
    
    return warnings

When DBSCAN Beats K-Means (And When It Blew Up In My Face)

K-Means assumes clusters are spherical and roughly equal in size. That's fine for toy datasets. In production, I've seen customer-segmentation pipelines where K-Means lumped together two completely distinct user behaviors because they happened to straddle a centroid boundary. DBSCAN doesn't care about centroids. It finds dense neighborhoods, so it handles crescent moons, rings, and any other non-convex shape the real world throws at you.

But here's the trade-off you need to burn into memory: DBSCAN falls apart when cluster densities vary wildly. If you have one dense cluster next to a sparse one, epsilon is a global parameter. Set it for the dense cluster and the sparse one gets chewed into noise. Set it for the sparse one and the dense cluster merges everything into one blob. I've seen this fail on geolocation data where a downtown core had 1000 points per square km and suburbs had 10. K-Means, ironically, handled that scenario better because it could adjust centroids independently.

Use DBSCAN when you suspect arbitrary shapes and have uniform density across clusters. Use K-Means when clusters are globular or densities are non-uniform. Don't cargo-cult either one.

Implementation: From Jupyter Notebook to Production Pipeline

Scikit-learn's DBSCAN is the go-to, but its memory complexity O(n^2) will murder your RAM if you naively toss a million-row dataset at it with a large epsilon. The default 'auto' algorithm tries ball-tree first, which helps for moderate cardinality. For production, you precompute a nearest-neighbors index once and pass the distance matrix. That decouples the expensive neighbor-search from the clustering logic.

Here's the minimal working pattern: scale your features first — DBSCAN is distance-based, so a column with range [0, 1000] dominates one with range [0, 1]. Use StandardScaler or RobustScaler if you have outliers (which you will). Then tune epsilon via a k-distance plot (covered in the existing sections). Run DBSCAN, extract labels, and always check np.unique(labels) — -1 means noise, and if that's more than 20% of points, your epsilon is too tight.

This snippet shows the production pattern: scaling, fitting, and a quick sanity check on cluster distribution.

// io.thecodeforge — ml-ai tutorial

import numpy as np
import pandas as pd
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import NearestNeighbors

# Load and scale your data
customer_features = pd.read_csv("customer_behavior_2024.csv")
features = ['avg_session_min', 'purchase_frequency', 'cart_abandon_rate']
X = StandardScaler().fit_transform(customer_features[features])

# Fit DBSCAN with epsilon from k-distance knee (say 0.5)
db = DBSCAN(eps=0.5, min_samples=5, metric='euclidean', n_jobs=-1)
labels = db.fit_predict(X)

# Sanity check: how much noise?
unique, counts = np.unique(labels, return_counts=True)
print("Cluster distribution:", dict(zip(unique, counts)))

# Flag if too much noise
noise_ratio = np.sum(labels == -1) / len(labels)
if noise_ratio > 0.2:
    print(f"WARNING: {noise_ratio:.0%} noise points — consider increasing epsilon")

The DBSCAN Algorithm Step-by-Step: What the Documentation Doesn't Tell You

Scikit-learn's docs tell you about core points, border points, and noise. They don't tell you that the implementation's worst-case memory is O(n^2) when epsilon is large. Here's what actually happens under the hood, and where the bottlenecks hide.

Step 1: Build the neighbor graph. For each point, find all points within epsilon radius. This is the killer — scaling O(n^2) naively, or O(n log n) with a ball-tree if dimensionality is low (< 20). At 100 dimensions, ball-tree degrades to O(n^2) anyway. That's the curse of dimensionality in action.

Step 2: Label core points. Any point with >= min_samples neighbors (including itself) is a core point. This is a cheap filter on the neighbor counts.

Step 3: Expand clusters via transitive closure. Pick a core point, assign cluster ID, add all its neighbors (core or border) to same cluster. Recurse through their neighbors. This is a graph traversal — BFS or DFS. The stack depth can blow if your epsilon is too large and all points are core. I've seen recursion limit errors in Python. Wrap fit_predict in a try-except if your data is untested.

Step 4: Mark the leftovers as noise (-1). Border points get the cluster of their nearest core. Noise points have no core within epsilon.

The critical insight: DBSCAN's cluster count is determined solely by step 3's traversal order. It's deterministic (same order yields same clusters), but the number of clusters is sensitive to epsilon. A 1% change can collapse 5 clusters into 1.

Why OPTICS Beats DBSCAN When Epsilon Becomes a Lie

DBSCAN's fatal flaw: a single global epsilon that must work across all densities. Real data isn't that polite. OPTICS (Ordering Points To Identify Clustering Structure) throws epsilon away and instead builds a reachability plot — a sorted fingerprint of your data's density landscape. No more guessing one magic radius.

Here's the production truth: I run OPTICS instead of DBSCAN on any dataset where cluster density varies by more than 2x. The algorithm generates an augmented ordering of points where neighboring clusters with different densities snap into view. The trade-off: OPTICS is slower. O(n log n) per run, not DBSCAN's O(n log n) with a simpler distance matrix. But the reachability plot tells you exactly where to cut — no k-distance guesswork. You extract clusters by scanning the plot for valleys. That's it.

If you're tuning DBSCAN for the third time and your epsilon is still wrong, stop. Switch to OPTICS. It's one import away in sklearn.

// io.thecodeforge — ml-ai tutorial

from sklearn.cluster import OPTICS
from sklearn.datasets import make_blobs
import numpy as np

// Two clusters: one dense, one sparse
X, _ = make_blobs(n_samples=300, centers=2,
                  cluster_std=[0.5, 2.5], random_state=42)

optics = OPTICS(min_samples=10, xi=0.05, min_cluster_size=0.1)
optics.fit(X)

print("Reachability distances (first 5):",
      np.round(optics.reachability_[optics.ordering_][:5], 3))
print("Labels (noise=-1):", np.unique(optics.labels_))

The Hard Limit of DBSCAN — When to Ditch It for Alternatives

DBSCAN isn't a universal clustering hammer. It has three hard walls you'll hit in production. First, high-dimensional data kills it. Beyond 10-15 dimensions, distance metrics become meaningless (curse of dimensionality). Second, varying density across your dataset means one epsilon can't work — no matter how fancy your k-distance plot looks. Third, DBSCAN can't handle categorical data. Period. Euclidean distance on one-hot vectors is garbage.

When you hit these walls: for high dimensions, switch to HDBSCAN (hierarchical variant, handles noise better) or spectral clustering. For mixed data types, use k-prototypes (k-means hybrid for categoricals). For non-globular shapes in 2D-3D, DBSCAN is still king. For anything else, you're forcing it. I've seen teams spend three sprints tuning epsilon on 50-dimensional customer data when they should have used PCA + GMM from day one.

The production rule: if your silhouette score is below 0.4 after two tuning rounds, DBSCAN is the wrong tool. Move on.

// io.thecodeforge — ml-ai tutorial

from sklearn.cluster import DBSCAN
from sklearn.metrics import silhouette_score
import numpy as np

// High-dimensional synthetic data (50 features, 2 clusters)
np.random.seed(42)
X = np.random.randn(500, 50)
X[:250] += 0.5  // shift half the points

db = DBSCAN(eps=0.8, min_samples=5).fit(X)
labels = db.labels_

// Silhouette fails when most points become noise
n_noise = np.sum(labels == -1)
try:
    score = silhouette_score(X[labels != -1], labels[labels != -1])
except ValueError:
    score = -1.0

print(f"Clusters found: {len(set(labels)) - (1 if -1 in labels else 0)}")
print(f"Noise points: {n_noise} ({100*n_noise/len(X):.1f}%)")
print(f"Silhouette (non-noise): {score:.3f}")

Unsupervised Learning in Python — Why DBSCAN Lives There

DBSCAN is not a magic wand; it is a clustering algorithm designed for unsupervised learning. Unsupervised means you have no labels, no ground truth, and no validation set telling you which cluster is correct. That changes everything. In supervised learning, you optimize for accuracy. In unsupervised clustering, you optimize for structure — density-connected regions that make physical or business sense. DBSCAN thrives here because it does not force every point into a cluster. It labels noise as -1. That is a killer feature when your data has outliers, fraud, or sensor errors. Start by loading your data with pandas into a NumPy array. Then call DBSCAN from sklearn.cluster. That is it. The fit method runs the entire algorithm in one line. But the real work is before that line: scaling features, choosing epsilon from a k-distance plot, and understanding that min_samples sets the minimum density to form a cluster. DBSCAN does not guess; it reveals what the data already says.

// io.thecodeforge — ml-ai tutorial

import numpy as np
import pandas as pd
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

data = pd.read_csv('customers.csv')
X = data[['income', 'spend_score']].values
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

db = DBSCAN(eps=0.5, min_samples=5)
db.fit(X_scaled)

data['cluster'] = db.labels_
print(data['cluster'].value_counts())

Visual Comparison — See DBSCAN vs K-Means Before You Code

A picture beats a paragraph every time. DBSCAN and K-Means produce radically different cluster shapes. Run a visual comparison on two synthetic datasets: circular moons and anisotropic blobs. K-Means draws straight Voronoi boundaries — it fails on moons because it assumes spherical clusters. DBSCAN wraps around the moon shape because it follows density. On anisotropic blobs (stretched ellipses), K-Means still draws circles; DBSCAN captures the stretched shape if epsilon is small enough. Use matplotlib to plot both side by side. Color each cluster, mark noise as black. The output is immediate: K-Means forces every point into a cluster (even noise gets assigned), DBSCAN leaves outliers uncolored. That single visual tells you when to use each. If your data has holes, crescents, or sparse regions, DBSCAN wins. If your clusters are tight spheres and you need speed (O(n) vs O(n log n) with a spatial index), K-Means wins. Do not guess — plot.

// io.thecodeforge — ml-ai tutorial

import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.cluster import DBSCAN, KMeans

X, _ = make_moons(n_samples=300, noise=0.05)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
kmeans = KMeans(n_clusters=2, n_init=10).fit(X)
ax1.scatter(X[:,0], X[:,1], c=kmeans.labels_, cmap='viridis')
ax1.set_title('K-Means')

db = DBSCAN(eps=0.3, min_samples=5).fit(X)
ax2.scatter(X[:,0], X[:,1], c=db.labels_, cmap='viridis')
ax2.set_title('DBSCAN')
plt.show()