已知类别点群的密度计算方法及Python库咨询

Hey there! Since you already have pre-labeled red and green clusters, you don’t need to run DBSCAN for clustering—you just need to compute density metrics for each existing group. Let’s break down the most practical approaches, required libraries, and example code tailored to your data:

Here are three reliable metrics you can use, depending on your analysis goals:

• Kernel Density Estimation (KDE)：Generates a smooth, continuous density surface for your cluster. Great for visualizing density distribution or comparing relative density between clusters.
• Point Density: A simple, intuitive metric that counts the number of points per unit area. Perfect for quick quantitative comparisons.
• DBSCAN-Style Local Density: Uses the number of neighboring points within a fixed radius (ε, just like DBSCAN) to measure local crowding. Useful if you want to align with clustering logic or analyze dense sub-regions within a cluster.

You’ll only need a few standard data science libraries:

• numpy: For handling your 2D point arrays efficiently.
• scikit-learn: Provides out-of-the-box implementations for KDE and nearest-neighbor searches (critical for local density).
• matplotlib (optional): To visualize density distributions alongside your points.

Let’s walk through code using your sample data structure. First, we’ll simulate labeled clusters matching your input, then compute each density metric:

import numpy as np
from sklearn.neighbors import KernelDensity, NearestNeighbors
import matplotlib.pyplot as plt

# Simulate your data: 2D points + labels (0 = red cluster, 1 = green cluster)
red_points = np.array([[-3.90611544e+00, -5.47953465e-01], 
                       [-5.22999684e+00, 5.56145331e-01],
                       [-4.5, -0.2], [-5.0, 0.3]])
green_points = np.array([[1.2, 3.4], [0.8, 2.9], 
                         [1.5, 3.1], [0.9, 2.7]])

1. Kernel Density Estimation (KDE) #

This creates a smooth density map you can visualize or use to calculate density at specific points:

def calculate_kde_density(points, bandwidth=0.5):
    # Initialize and fit KDE model
    kde = KernelDensity(bandwidth=bandwidth, kernel='gaussian')
    kde.fit(points)
    
    # Create a grid to compute density values on
    x_min, x_max = points[:, 0].min() - 1, points[:, 0].max() + 1
    y_min, y_max = points[:, 1].min() - 1, points[:, 1].max() + 1
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), 
                         np.linspace(y_min, y_max, 100))
    grid_points = np.vstack([xx.ravel(), yy.ravel()]).T
    
    # Calculate density (convert log-density to actual density)
    log_density = kde.score_samples(grid_points)
    density = np.exp(log_density)
    
    return density.reshape(xx.shape), xx, yy

# Compute KDE for both clusters
red_density, xx_red, yy_red = calculate_kde_density(red_points)
green_density, xx_green, yy_green = calculate_kde_density(green_points)

# Visualize results
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.contourf(xx_red, yy_red, red_density, cmap='Reds', alpha=0.6)
plt.scatter(red_points[:, 0], red_points[:, 1], c='darkred', s=50)
plt.title("Red Cluster KDE Density")

plt.subplot(1, 2, 2)
plt.contourf(xx_green, yy_green, green_density, cmap='Greens', alpha=0.6)
plt.scatter(green_points[:, 0], green_points[:, 1], c='darkgreen', s=50)
plt.title("Green Cluster KDE Density")
plt.tight_layout()
plt.show()

2. Point Density (Points per Unit Area) #

A straightforward metric for comparing overall cluster density:

def calculate_point_density(points):
    # Calculate the bounding box area of the cluster
    x_range = points[:, 0].max() - points[:, 0].min()
    y_range = points[:, 1].max() - points[:, 1].min()
    area = x_range * y_range
    
    # Handle edge case where all points are identical
    if area == 0:
        return np.inf
    
    return len(points) / area

# Compute and print results
red_point_density = calculate_point_density(red_points)
green_point_density = calculate_point_density(green_points)
print(f"Red Cluster Point Density: {red_point_density:.2f} points/unit area")
print(f"Green Cluster Point Density: {green_point_density:.2f} points/unit area")

3. DBSCAN-Style Local Density #

Measures how many neighbors each point has within a radius eps (adjust based on your data scale):

def calculate_dbscan_local_density(points, eps=0.8):
    # Fit nearest neighbors model
    nn = NearestNeighbors(radius=eps)
    nn.fit(points)
    
    # Count neighbors for each point (including the point itself)
    neighbor_counts = nn.radius_neighbors(points, return_distance=False)
    local_densities = np.array([len(count) for count in neighbor_counts])
    
    # Return per-point local densities and the average density of the cluster
    return local_densities, local_densities.mean()

# Compute and print results
red_local_densities, red_avg_density = calculate_dbscan_local_density(red_points)
green_local_densities, green_avg_density = calculate_dbscan_local_density(green_points)
print(f"Red Cluster Average Local Density (ε=0.8): {red_avg_density:.2f} neighbors/point")
print(f"Green Cluster Average Local Density (ε=0.8): {green_avg_density:.2f} neighbors/point")

• For KDE, adjust the bandwidth parameter to control smoothness: smaller values follow data more closely, larger values create smoother distributions. You can use GridSearchCV from scikit-learn to optimize it.
• For local density, choose eps based on your data’s scale—plotting neighbor distances can help pick a reasonable value.
• If you need to compare densities across clusters, make sure to use consistent parameters (same bandwidth/eps) for both groups.

内容的提问来源于stack exchange，提问作者mxrdck