data/scripts/cluster_split.py

#!/usr/bin/env python3
"""
cluster_split.py

Author: natelgrw
Created: 11/05/2025

Splits dataset into folds based on compound structural clustering using
Morgan fingerprints. Uses UMAP for dimensionality reduction and clustering
in a higher-dimensional space to preserve chemical similarity while enabling
spatial separation.
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pathlib import Path
from collections import defaultdict
import random
from tqdm import tqdm
import umap
from sklearn.cluster import KMeans
from rdkit import Chem
from rdkit.Chem import AllChem, DataStructs


# ===== Configuration ===== #


INPUT_CSV = "../retina_dataset.csv"
OUTPUT_DIR = "../cluster_split"
N_FOLDS = 5
RANDOM_SEED = 42

UMAP_NEIGHBORS = 15
UMAP_MIN_DIST = 0.1
UMAP_VIZ_DIM = 2

FP_RADIUS = 2
FP_N_BITS = 2048

random.seed(RANDOM_SEED)
np.random.seed(RANDOM_SEED)


# ===== Helper Functions ===== #


def analyze_dataset(df):
    """
    Prints dataset statistics.
    """
    print("=" * 70)
    print("Dataset Analysis")
    print("=" * 70)
    print(f"Total rows: {len(df):,}")
    if "compound" in df.columns:
        print(f"Unique compounds: {df['compound'].nunique():,}")
    if 'rt' in df.columns:
        print(f"\nRetention Time Stats:")
        print(f"Mean: {df['rt'].mean():.2f} s | Median: {df['rt'].median():.2f} s")
    print()


def assign_clusters_to_folds(compound_sizes, n_folds, cluster_assignments):
    """
    Assign compound clusters to folds with balancing.
    """
    fold_assignments = defaultdict(list)
    fold_counts = [0] * n_folds
    
    cluster_to_compounds = defaultdict(list)
    for compound, cluster_id in cluster_assignments.items():
        cluster_to_compounds[cluster_id].append(compound)
    
    cluster_info = []
    for cluster_id, compounds in cluster_to_compounds.items():
        size = sum(compound_sizes.get(c, 0) for c in compounds)
        cluster_info.append((cluster_id, size, compounds))
    
    cluster_info.sort(key=lambda x: x[1], reverse=True)
    
    total_size = sum(compound_sizes.values())
    target_size = total_size / n_folds
    
    print(f"\nAssigning {len(cluster_info)} clusters to {n_folds} folds...")
    print(f"Target size per fold: {target_size:,.0f} datapoints")
    
    for cluster_id, size, compounds in cluster_info:
        min_fold = min(range(n_folds), key=lambda i: fold_counts[i])
        
        for compound in compounds:
            fold_assignments[min_fold].append(compound)
            fold_counts[min_fold] += compound_sizes.get(compound, 0)
    
    print("\nFold balance:")
    for i, count in enumerate(fold_counts):
        print(f"Fold {i+1}: {count:,} datapoints ({100*count/total_size:.2f}%)")
    print(f"Balance ratio: {max(fold_counts)/min(fold_counts):.2f}x")
    
    return fold_assignments, fold_counts


# ===== Analyzer Class ===== #


class ClusterAnalyzer:
    """
    Analyzer for compound clustering-based splitting.
    """

    def __init__(self, data_path, output_dir):
        self.data_path = Path(data_path)
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True, parents=True)
        self.df = None
        self.compounds_df = None
        
    def load_data(self):
        """Load dataset."""
        print("\nLOADING RETINA DATASET")
        self.df = pd.read_csv(self.data_path)
        
        unique_compounds = self.df['compound'].unique()
        self.compounds_df = pd.DataFrame({'compound': unique_compounds})
        print(f"Loaded {len(self.df):,} datapoints with {len(unique_compounds):,} unique compounds.")
    
    def compute_morgan_fingerprints(self):
        """Compute Morgan fingerprints for all compounds."""
        print("\nCOMPUTING MORGAN FINGERPRINTS")
        fingerprints = []
        valid_compounds = []
        
        for smiles in tqdm(self.compounds_df['compound'], desc="Computing fingerprints"):
            mol = Chem.MolFromSmiles(smiles)
            if mol is not None:
                fp = AllChem.GetMorganFingerprintAsBitVect(
                    mol, FP_RADIUS, nBits=FP_N_BITS
                )
                arr = np.zeros((FP_N_BITS,), dtype=np.int8)
                DataStructs.ConvertToNumpyArray(fp, arr)
                fingerprints.append(arr)
                valid_compounds.append(smiles)
            else:
                print(f"Warning: Could not parse SMILES: {smiles}")
        
        fingerprints = np.array(fingerprints)
        self.compounds_df = self.compounds_df[self.compounds_df['compound'].isin(valid_compounds)].copy()
        
        print(f"Computed {len(fingerprints)} fingerprints of dimension {FP_N_BITS}")
        return fingerprints
    
    def compute_umap_embedding(self, fingerprints):
        """
        Compute 2D UMAP embedding for clustering and visualization.
        Clustering will be done directly on these 2D coordinates.
        """
        print(f"\nCOMPUTING 2D UMAP EMBEDDING")
        print("(Clustering will be done on 2D UMAP coordinates)")
        
        # 2d embedding for visualization only
        reducer_viz = umap.UMAP(
            n_neighbors=UMAP_NEIGHBORS,
            min_dist=UMAP_MIN_DIST,
            n_components=UMAP_VIZ_DIM,
            metric='jaccard',
            random_state=RANDOM_SEED,
            verbose=False
        )
        embedding_viz = reducer_viz.fit_transform(fingerprints)
        print(f"2D UMAP computed: {embedding_viz.shape}")
        
        return embedding_viz
    
    def cluster_compounds(self, embedding, n_clusters):
        """
        Cluster compounds using KMeans in 2D UMAP space.
        This creates spatially-separated, visually distinct regions.
        """
        print(f"\nCLUSTERING COMPOUNDS IN 2D UMAP SPACE")
        print(f"Using KMeans with k={n_clusters} clusters...")
        print(f"Input shape: {embedding.shape}")
        
        kmeans = KMeans(
            n_clusters=n_clusters,
            random_state=RANDOM_SEED,
            n_init=20,
            max_iter=300,
            verbose=0
        )
        cluster_labels = kmeans.fit_predict(embedding)
        
        self.compounds_df['cluster'] = cluster_labels
        
        # print cluster distribution
        cluster_counts = pd.Series(cluster_labels).value_counts().sort_index()
        print(f"\nCluster distribution:")
        for cluster_id, count in cluster_counts.items():
            print(f"Cluster {cluster_id}: {count:,} compounds")
        
        return cluster_labels
    
    def create_cluster_splits(self, n_splits=5):
        """
        Create folds based on compound clusters in 2D UMAP space.
        """
        print("\nCREATING CLUSTER SPLITS")
        print("=" * 60)
        print("\nStrategy: Cluster in 2D UMAP space for spatial separation")
        
        fingerprints = self.compute_morgan_fingerprints()
        
        embedding_viz = self.compute_umap_embedding(fingerprints)
        
        self.compounds_df['umap_x'] = embedding_viz[:, 0]
        self.compounds_df['umap_y'] = embedding_viz[:, 1]
        
        cluster_labels = self.cluster_compounds(embedding_viz, n_clusters=n_splits)
        
        cluster_assignments = dict(zip(
            self.compounds_df['compound'],
            self.compounds_df['cluster']
        ))
        
        compound_sizes = self.df['compound'].value_counts().to_dict()
        print(f"\n{len(compound_sizes):,} unique compounds in dataset.")
        
        fold_assignments = defaultdict(list)
        for cluster_id in range(n_splits):
            cluster_compounds = self.compounds_df[self.compounds_df['cluster'] == cluster_id]['compound'].tolist()
            fold_assignments[cluster_id] = cluster_compounds
        
        fold_counts = [sum(compound_sizes.get(c, 0) for c in compounds) 
                      for compounds in fold_assignments.values()]
        
        total_size = sum(compound_sizes.values())
        print("\nFold balance (direct 1:1 cluster-to-fold mapping):")
        for i, count in enumerate(fold_counts):
            print(f"Fold {i+1}: {count:,} datapoints ({100*count/total_size:.2f}%)")
        print(f"Balance ratio: {max(fold_counts)/min(fold_counts):.2f}x")
        
        compound_to_fold = {}
        for fold_idx, compounds in fold_assignments.items():
            for compound in compounds:
                compound_to_fold[compound] = fold_idx + 1
        
        self.df['fold'] = self.df['compound'].map(compound_to_fold)
        self.compounds_df['fold'] = self.compounds_df['compound'].map(compound_to_fold)
        
        compound_to_umap = dict(zip(
            self.compounds_df['compound'],
            zip(self.compounds_df['umap_x'], self.compounds_df['umap_y'])
        ))
        self.df['umap_x'] = self.df['compound'].map(lambda c: compound_to_umap.get(c, (None, None))[0])
        self.df['umap_y'] = self.df['compound'].map(lambda c: compound_to_umap.get(c, (None, None))[1])
        
        fold_dataframes = {}
        for i in range(n_splits):
            fold_df = self.df[self.df['fold'] == i + 1].copy()
            out_file = self.output_dir / f"cluster_{i+1}.csv"
            fold_df.to_csv(out_file, index=False)
            fold_dataframes[i] = fold_df
            print(f"Saved cluster_{i+1}.csv ({len(fold_df):,} rows, {fold_df['compound'].nunique():,} compounds)")
        
        cluster_file = self.output_dir / "figures" / "cluster_assignments.csv"
        cluster_file.parent.mkdir(exist_ok=True, parents=True)
        self.compounds_df[['compound', 'cluster', 'fold', 'umap_x', 'umap_y']].to_csv(
            cluster_file, index=False
        )
        print(f"\nSaved cluster assignments to figures/cluster_assignments.csv")
        
        return fold_dataframes
    
    def visualize_rt_distributions(self, fold_dataframes):
        """
        Generates a KDE plot of the RT distribution per cluster split.
        """
        print("\nPLOTTING RETENTION TIME DISTRIBUTIONS")
        fig, ax = plt.subplots(figsize=(14, 6))
        colors = sns.color_palette("husl", len(fold_dataframes))

        if "rt" in self.df.columns:
            overall_rt = self.df["rt"].dropna() / 60.0
            if len(overall_rt) > 0:
                sns.kdeplot(
                    overall_rt, ax=ax,
                    color='black', linewidth=2.5,
                    linestyle='--',
                    label=f"Overall (n={len(overall_rt):,})"
                )

        for i, fold_df in fold_dataframes.items():
            if "rt" not in fold_df.columns:
                continue
            rt_min = fold_df["rt"].dropna() / 60.0
            if len(rt_min) > 0:
                sns.kdeplot(
                    rt_min, ax=ax,
                    label=f"Cluster {i+1} (n={len(rt_min):,})",
                    color=colors[i],
                    linewidth=2.5
                )

        ax.set_xlabel("Retention Time (min)", fontsize=12, fontweight='bold')
        ax.set_ylabel("Density", fontsize=12, fontweight='bold')
        ax.set_title("Retention Time Distribution Across Cluster Splits", fontsize=14, fontweight='bold')
        ax.legend(fontsize=10, framealpha=0.9)
        ax.grid(alpha=0.3, linestyle=':', linewidth=0.5)
        ax.set_xlim(left=0)

        fig_dir = self.output_dir / "figures"
        fig_dir.mkdir(exist_ok=True)
        plt.savefig(fig_dir / "cluster_rt.png", dpi=300, bbox_inches="tight")
        plt.close()
        print(f"Saved RT KDE plot to figures/cluster_rt.png")
    
    def generate_umap_plot(self):
        """
        Generates a UMAP visualization colored by fold, showing all datapoints.
        """
        print("\nGENERATING UMAP VISUALIZATION")
        print(f"Plotting all {len(self.df):,} datapoints (including duplicates)")
        
        plt.figure(figsize=(10, 7))
        
        if "fold" in self.df.columns and "umap_x" in self.df.columns:
            colors = sns.color_palette("husl", N_FOLDS)
            
            for fold_num in sorted(self.df["fold"].dropna().unique()):
                fold_data = self.df[self.df["fold"] == fold_num]
                n_datapoints = len(fold_data)
                plt.scatter(
                    fold_data["umap_x"], fold_data["umap_y"],
                    label=f"Cluster {int(fold_num)} (n={n_datapoints:,})",
                    s=5, alpha=0.5, edgecolor='none',
                    color=colors[int(fold_num) - 1]
                )
            
            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10)
            plt.title("UMAP Projection of Compound Space (Colored by Cluster Split)", fontsize=14, fontweight='bold', pad=15)

        else:
            plt.scatter(
                self.df["umap_x"], self.df["umap_y"],
                s=5, alpha=0.5, color="steelblue", edgecolor='none'
            )

        plt.tight_layout()

        fig_dir = self.output_dir / "figures"
        fig_dir.mkdir(exist_ok=True)
        plt.savefig(fig_dir / "cluster_umap.png", dpi=300, bbox_inches="tight")
        plt.close()
        print(f"Saved UMAP plot to figures/cluster_umap.png")


# ===== Main ===== #


def main():
    """
    Main execution function.
    """
    print("\n" + "=" * 80)
    print(" " * 30 + "CLUSTER SPLIT PIPELINE")
    print(f"=" * 80)
    print(f"1. Compute 2D UMAP embedding from 2048D fingerprints")
    print(f"2. Cluster directly in 2D UMAP space (k={N_FOLDS})")
    print(f"3. Assign clusters to folds (1:1 mapping)")
    print(f"4. Result: Spatially-separated regions in UMAP visualization")
    print(f"=" * 80)

    analyzer = ClusterAnalyzer(INPUT_CSV, OUTPUT_DIR)
    analyzer.load_data()
    analyze_dataset(analyzer.df)
    
    fold_dataframes = analyzer.create_cluster_splits(n_splits=N_FOLDS)
    
    analyzer.generate_umap_plot()
    analyzer.visualize_rt_distributions(fold_dataframes)

    print("\n" + "=" * 80)
    print(" " * 30 + "CLUSTER SPLIT COMPLETE!")
    print("=" * 80)
    print(f"\nOutputs in: {OUTPUT_DIR}/")
    print(f"- cluster_1.csv through cluster_{N_FOLDS}.csv")
    print(f"- figures/cluster_umap.png")
    print(f"- figures/cluster_rt.png")
    print(f"- figures/cluster_assignments.csv")


if __name__ == "__main__":
    main()