Gower's Distance #34240

I do not think scikit-learn has a built-in Gower distance implementation at the moment.

AgglomerativeClustering is a clustering algorithm, not a distance metric. It can use different metrics, and in some cases it can work with a precomputed distance matrix, but it does not compute Gower distance for you.

So the usual workaround is:

1. compute the Gower distance matrix separately
2. pass it into an estimator that supports precomputed distances

For example, conceptually:

D = gower_distance_matrix(X)
clustering = AgglomerativeClustering(
    metric="precomputed",
    linkage="average",
).fit(D)

You would need to be careful with linkage choice. Some linkage methods have restrictions on which metrics/precomputed distances they support, while average/complete are usually the more natural choices for arbitrary dissimilarity matrices.

So the short answer is: no, AgglomerativeClustering is not Gower distance. It can consume a Gower distance matrix if you compute one yourself, but scikit-learn does not appear to provide the Gower metric directly.

Hi! Great question — Gower's distance is not natively implemented in scikit-learn as a built-in metric, but there are excellent ways to use it in your workflows.

Current Status in scikit-learn

scikit-learn's distance metrics (in sklearn.metrics.pairwise) and clustering algorithms like AgglomerativeClustering do not include Gower's distance out of the box. AgglomerativeClustering supports Euclidean, Manhattan, cosine, and precomputed distance matrices — but not Gower directly.

What is Gower's Distance?

Gower's distance (Gower, 1971) is specifically designed for mixed-type data (numerical + categorical + binary features). For each feature pair, it computes:

• Numerical features: Normalized absolute difference (range-scaled)
• Categorical features: Simple matching (0 if same, 1 if different)
• Binary features: Jaccard-like matching

The final distance is a weighted average across all features.

How to Use It with scikit-learn

Option 1: gower package + precomputed matrix (Recommended)

import numpy as np
import pandas as pd
import gower
from sklearn.cluster import AgglomerativeClustering

# Example mixed-type DataFrame
df = pd.DataFrame({
    'age': [25, 30, 35, 40, 45],
    'income': [50000, 60000, 55000, 70000, 65000],
    'education': ['BSc', 'MSc', 'PhD', 'BSc', 'MSc'],
    'married': [True, False, True, True, False]
})

# Compute the Gower distance matrix
distance_matrix = gower.gower_matrix(df)

# Use with AgglomerativeClustering via precomputed distances
clustering = AgglomerativeClustering(
    n_clusters=2,
    metric='precomputed',
    linkage='average'  # 'average' or 'complete' work with precomputed
)
labels = clustering.fit_predict(distance_matrix)
print("Cluster labels:", labels)

Install with: pip install gower

Option 2: Manual implementation with sklearn.metrics.pairwise_distances

from sklearn.metrics import pairwise_distances

def gower_distance(X):
    """Compute Gower distance for a DataFrame with mixed types."""
    n = len(X)
    ranges = X.select_dtypes(include='number').max() - X.select_dtypes(include='number').min()
    ranges[ranges == 0] = 1  # avoid division by zero
    
    D = np.zeros((n, n))
    for i in range(n):
        for j in range(i + 1, n):
            dists = []
            for col in X.columns:
                if X[col].dtype in ['float64', 'int64']:
                    d = abs(X[col].iloc[i] - X[col].iloc[j]) / ranges[col]
                else:
                    d = 0.0 if X[col].iloc[i] == X[col].iloc[j] else 1.0
                dists.append(d)
            D[i, j] = D[j, i] = np.mean(dists)
    return D

Option 3: DBSCAN / KMedoids with precomputed Gower

from sklearn.cluster import DBSCAN

dbscan = DBSCAN(metric='precomputed', eps=0.3, min_samples=2)
labels = dbscan.fit_predict(distance_matrix)

Summary

The gower package with metric='precomputed' is the standard approach used by the community. Hope this helps!

scikit-learn does not currently provide Gower distance as a built-in metric, and AgglomerativeClustering is the clustering algorithm rather than the distance implementation.

A common pattern is to compute the mixed-type distance matrix separately and pass it as precomputed:

D = gower.gower_matrix(X)
model = AgglomerativeClustering(
n_clusters=3,
metric="precomputed",
linkage="average",
)
labels = model.fit_predict(D)

The linkage matters: Ward requires Euclidean features, so it cannot be used with a precomputed Gower matrix. Also validate how the chosen Gower implementation handles missing values and feature weights for your dataset.