Version 1.0.0

README.md

@@ -4,12 +4,12 @@ license: mit
 
 ## ⚗️ ReTiNA: A Benchmark Dataset for LC-MS Retention Time Modeling
 
+Current Version: **1.0.0**
+
 ReTiNA is a large open-source dataset for training machine learning models to predict small molecule retention times in LC-MS workflows.
 
 This dataset is actively expanding with new experimental retention time values from the Coley Research Group at MIT, ensuring it remains a growing resource for optical property prediction.
 
-Additionally, ReTiNA includes ```.smi``` lists of 641,651 unique compounds and 6 unique solvents in the dataset for chemical descriptor calculations.
-
 ReTiNA is designed for use in:
 
 - Estimating retention times for new compound–environment combinations
@@ -20,11 +20,11 @@ ReTiNA is designed for use in:
 
 The ReTiNA dataset contains:
 
-- 4,358,475 unique molecule–environment combinations, the largest singular LC-MS retention time dataset of its kind to date
+- 119,039 unique molecule–environment combinations, the largest singular LC-MS retention time dataset of its kind to date
 - Experimentally measured retention times, in seconds, curated from public datasets, benchmark papers, and literature
-- 160 calculated chemical descriptors for 641,647 unique compounds and 6 unique solvents
+- Chemical descriptors for 105,809 unique compounds, 6 unique solvents, and 8 unique additives
 
-80 distinct LC-MS setup environments are used in ReTiNA. Each environment consists of:
+73 distinct LC-MS setup environments are used in ReTiNA. Each environment consists of:
 
 - Solvent mixtures A and B, consisting of solvents and solvent additives contributing to pH
 - The mobile phase gradient used, defined by the percentage of solvent mixture B over time (min)
@@ -33,7 +33,7 @@ The ReTiNA dataset contains:
 - The mobile phase flow rate, measured in mL/min
 - The column temperature, measured in degrees Celsius
 
-Additionally, the ReTiNA dataset is divided into training, validation, and testing subsets in an 80:10:10 split.
+The ReTiNA dataset is divided into different scaffold, cluster, and method splits, which can be accessed in the `data` directory and are using in model evaluation.
 
 ## 📋 Data Sources Used
 

data/README.md

@@ -63,10 +63,3 @@ Each data entry in the ReTiNA-1 dataset is comprised of 7 columns. Examples and
 - 2,252 compound-environment combinations
 - 2,178 unique compounds
 - 2 unique LC-MS setup environments
-
-[RTPred](https://doi.org/10.1016/j.chroma.2025.465816) (rtpred): A Web Server for Accurate, Customized Liquid Chromatography Retention Time Prediction of Chemicals
-
-- Data sourced from 33 individual RTPred datasets
-- 5,996,830 compound-environment combinations
-- 535,847 unique compounds
-- 11 unique LC-MS setup environments

data/additives/README.md

@@ -0,0 +1,10 @@
+# 🧪 ReTiNA Table of Additive Desciptors
+
+The ReTiNA dataset is accompanied with Morgan fingerprints for each additive in the
+dataset, capturing features for model training. Descriptors were computed using RDKit.
+
+## Topological Descriptors
+
+| Descriptor | Summary | Software Used |
+|------------|---------|---------------|
+| Morgan_Fingerprint | Circular fingerprints encoding molecular substructures up to a given radius, used for similarity and machine learning | RDKit |

data/{setups/lcms_setups.csv → additives/add.smi}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:502796d200955043c309b4b322525d23f066aa3a605fca47f1c9c50ea398b546
-size 9958
+oid sha256:863d1d1cb4f713ade2ddaa442a8086043e179d009da7f0cffc53c939de2f1fe2
+size 167

data/{testing/retina_testing.csv → additives/add_descriptors.csv}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ae8e23ee6695667c1604061dbbd481583a24253e898a36621711df4109c98fd0
-size 140796588
+oid sha256:3cbd8ed99eb4d1706acf8c4eadc1aee7e9a6920ec2665549cded4a411d9f7fbc
+size 16545

data/{validation/retina_validation.csv → cluster_split/cluster_1.csv}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:325e0753a4f56a41ae3002dc8cbfa541781637b6143c4cb876d35083c13dc890
-size 140737596
+oid sha256:c444f4d4e8d1212ddcab8f66af02c785e24a1bda9c12683d8349a2bbdf5e5794
+size 15137399

data/cluster_split/cluster_2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad0e96a5e25e8c2c10ce3a4f30a846e1a1cfa068dc00c89cc71c80e36df80bf0
+size 6286181

data/cluster_split/cluster_3.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:187a59054c2dd03fa523c4f8d4d90f6606d03f3d32a1a13daefbcebe51b0460e
+size 4165851

data/cluster_split/cluster_4.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:022197af27f1ba2a362eed6ad1b79e70f0e30556b9a4f341bd47985a72119a69
+size 3627182

data/cluster_split/cluster_5.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6642e32fbc5c52f18fcb17c79bbb672ad3f8f5de40b628b801cd8fb6a6c7c432
+size 4341002

data/cluster_split/figures/cluster_assignments.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:739cd0035dbb30b1111a20e055c0da7aef04d2f1d39489837091e7d652f75ec0
+size 7695580

data/compounds/README.md

@@ -1,6 +1,6 @@
 # ⚛️ ReTiNA Table of Compound Desciptors
 
-The ReTiNA dataset is accompanied with 160 descriptors for each compound, capturing detailed structural, electronic, and topological features for model training. Descriptors were computed using RDKit.
+The ReTiNA dataset is accompanied with 157 descriptors for each compound, capturing detailed structural, electronic, and topological features for model training. Descriptors were computed using RDKit.
 
 ## Topological Descriptors
 
@@ -9,16 +9,13 @@ The ReTiNA dataset is accompanied with 160 descriptors for each compound, captur
 | BalabanJ | Quantifies molecular complexity based on average distance connectivity and graph branching | RDKit |
 | BertzCT | Calculates molecular complexity based on graph connectivity and atomic contributions | RDKit |
 | Chi (0-1), Chi_n (0-4) Chi_v (0-4)  | Connectivity indices reflecting molecular topology, branching, and size | RDKit |
-| Ipc  | Information content index representing structural complexity | RDKit |
 | Kappa (1-3) | Shape indices describing molecular flexibility and overall geometry | RDKit |
 
 ## Electronic Descriptors
 
 | Descriptor | Summary | Software Used |
 |------------|---------|---------------|
-| MaxAbsPartialCharge | Maximum absolute atomic partial charge | RDKit |
 | MaxEStateIndex | Maximum E-state value in the molecule | RDKit |
-| MaxPartialCharge | Highest partial charge in the molecule | RDKit |
 | NumValenceElectrons | Total number of valence electrons in the molecule | RDKit |
 | NumRadicalElectrons | Total number of unpaired electrons (radicals) | RDKit |
 | HallKierAlpha | Atom-type electrotopological descriptor modeling polarity and hybridization | RDKit |

data/compounds/comp.smi

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f279160d87eb247adde07696ae6a5d90b040d445987e2d86ba9297a7c15f124a
-size 71460772
+oid sha256:bd2147571bca5f201ba48e1a3384d1e0c86f959b5e0678185e06d2b4a71c6f10
+size 6091768

data/compounds/comp_descriptors.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26d523156d754e5a2a141107ca6daddde58c484f64d683392e49a2d4a723ee2a
+size 348748041

data/lcms_methods.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cdc220e7e4f4e8fe03d184520977930afc848a5e959335cadb9f464cd170ae8
+size 16640

data/method_split/methods_1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00cfc646462c23f9fb06166c4d4c06fe611b86a1e539827f39d7b5f3fd12168f
+size 1313997

data/method_split/methods_2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f941df201fb4c5906a21be42835004aeee26b6b0c5406493087b8cfdfa66a8e
+size 1315427

data/method_split/methods_3.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07372d721e5463008f23a65650b6820a28d76b6161a8aff2129d194019b8ba95
+size 1089765

data/method_split/methods_4.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f7f062ae5c2a76d605a5a1fca71bf1cf605c8e85b4e910265c422d9803bd11b
+size 6077386

data/method_split/methods_5.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31b7a01d172ad706d0c1113a64a730346d8fda02db897c1d6691c7cd82a48dc1
+size 19186922

data/retina_dataset.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acac7b2363b4bcec2d899887839b5100a9232e0bd29bceeee5de3d1edb58a803
+size 28866318

data/scaffold_split/figures/scaffold_assignments.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5e9b851080bdf12f85936ddc736be108b9a01a1cd61a94013505ad91fa5368b
+size 2028108

data/scaffold_split/fold_1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:844bf2bb7d44aa9678931de4ccf8a2c69ff47501e5d41c7f2943c81d3d412017
+size 5897260

data/scaffold_split/fold_2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f39d4adac0d2ef0d304f48e86ea9654dee12c91a471897e9451d12e65358a3e
+size 5770319

data/scaffold_split/fold_3.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c33ab689ee68c0aac7e510df4b254a37ece1d11ec3c3ee7ae9ae2c53ce0d49b
+size 5699489

data/scaffold_split/fold_4.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0daeb1563bd6ca770d03b3aef42b19ef9b5580e489d70f7ec4a5d02bc313d4b
+size 5720713

data/scaffold_split/fold_5.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:808d6c9b2fd9735bb6a49821b0be0522d96bd8f2afcb51350c58b92a788428cb
+size 5759302

data/scripts/cluster_split.py

@@ -0,0 +1,395 @@
+#!/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()
+

data/scripts/method_split.py

@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+"""
+method_split.py
+
+Author: natelgrw
+Last Edited: 11/04/2025
+
+Splits the ReTiNA dataset into 5 folds based on LC-MS setup configurations 
+(e.g., solvents, gradient, column, temperature, flow rate).
+Each setup group is assigned to a single fold to avoid data leakage 
+across similar chromatographic conditions.
+"""
+
+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
+import umap
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.cluster import KMeans
+from ast import literal_eval
+
+
+# ===== Configuration ===== #
+
+
+INPUT_CSV = "../retina_dataset.csv"
+METHOD_CSV = "../lcms_methods.csv"
+OUTPUT_DIR = "../method_split"
+N_FOLDS = 5
+RANDOM_SEED = 42
+
+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")
+    if 'method_number' in df.columns:
+        print(f"Unique methods: {df['method_number'].nunique():,}")
+    print()
+
+
+def assign_methods_to_folds(method_sizes, n_folds, method_features=None, method_ids=None):
+    """
+    Assigns methods to folds using KMeans clustering on UMAP coordinates.
+    This creates compact, spatially-separated regions in the UMAP visualization.
+    """
+    fold_assignments = defaultdict(list)
+    fold_counts = [0] * n_folds
+
+    if method_features is not None and method_ids is not None:
+        print(f"\nUsing KMeans to create {n_folds} spatially-separated regions...")
+        
+        kmeans = KMeans(n_clusters=n_folds, random_state=RANDOM_SEED, n_init=20)
+        cluster_labels = kmeans.fit_predict(method_features)
+        
+        cluster_to_methods = defaultdict(list)
+        for method_id, cluster_id in zip(method_ids, cluster_labels):
+            cluster_to_methods[cluster_id].append(method_id)
+        
+        cluster_sizes = {}
+        for cluster_id, methods in cluster_to_methods.items():
+            cluster_sizes[cluster_id] = sum(method_sizes[m] for m in methods)
+        
+        total_size = sum(method_sizes.values())
+        avg_size = total_size / n_folds
+        
+        print(f"Target size per fold: {avg_size:,.0f} datapoints")
+        
+        for cluster_id, methods in cluster_to_methods.items():
+            cluster_size = cluster_sizes[cluster_id]
+            method_size_list = [(m, method_sizes[m]) for m in methods]
+            method_size_list.sort(key=lambda x: x[1], reverse=True)
+            
+            if len(method_size_list) > 0:
+                largest_method, largest_size = method_size_list[0]
+                if largest_size > cluster_size * 0.6 and largest_size > avg_size * 0.5:
+                    print(f"Warning: Method {largest_method} has {largest_size:,} datapoints "
+                          f"({100*largest_size/total_size:.1f}% of total dataset)")
+        
+        for cluster_id in range(n_folds):
+            methods = cluster_to_methods[cluster_id]
+            for method in methods:
+                fold_assignments[cluster_id].append(method)
+                fold_counts[cluster_id] += method_sizes[method]
+        
+        print("\nSpatial assignment complete!")
+        print(f"Largest fold: {max(fold_counts):,} datapoints")
+        print(f"Smallest fold: {min(fold_counts):,} datapoints")
+        print(f"Fold size ratio: {max(fold_counts)/min(fold_counts):.2f}x")
+        
+    else:
+        print("\nWarning: No method features provided, using greedy assignment")
+        sorted_methods = sorted(method_sizes.items(), key=lambda x: x[1], reverse=True)
+        for method, size in sorted_methods:
+            min_fold = min(range(n_folds), key=lambda i: fold_counts[i])
+            fold_assignments[min_fold].append(method)
+            fold_counts[min_fold] += size
+
+    return fold_assignments, fold_counts
+
+
+# ===== Analyzer Class ===== #
+
+
+class MethodAnalyzer:
+    """
+    Analyzer for LC-MS setup-based splitting.
+    """
+
+    def __init__(self, data_path, method_path, output_dir):
+        self.data_path = Path(data_path)
+        self.method_path = Path(method_path)
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True, parents=True)
+        self.df = None
+        self.methods = None
+
+    def load_data(self):
+        """
+        Loads the datasets.
+        """
+        print("\nLOADING RETINA + METHOD DATA")
+        self.df = pd.read_csv(self.data_path)
+        self.methods = pd.read_csv(self.method_path)
+
+        for col in ["gradient", "column"]:
+            if col in self.methods.columns:
+                self.methods[col] = self.methods[col].apply(lambda x: literal_eval(x) if isinstance(x, str) else x)
+        print(f"Loaded {len(self.df):,} datapoints and {len(self.methods):,} methods.")
+
+    def extract_method_features(self):
+        """
+        Converts LC-MS setups into numerical feature vectors.
+        """
+        if hasattr(self, 'method_features_X'):
+            return self.method_features_X
+            
+        df = self.methods.copy()
+        df["phase"] = df["column"].apply(lambda x: x[0] if isinstance(x, list) else "UNK")
+        df["col_diam"] = df["column"].apply(lambda x: float(x[1]) if isinstance(x, list) else 0)
+        df["col_len"] = df["column"].apply(lambda x: float(x[2]) if isinstance(x, list) else 0)
+        df["col_part"] = df["column"].apply(lambda x: float(x[3]) if isinstance(x, list) else 0)
+        df["grad_len"] = df["gradient"].apply(lambda x: x[-1][0] if isinstance(x, list) and len(x) > 0 else 0)
+        df["grad_range"] = df["gradient"].apply(
+            lambda x: max([p[1] for p in x]) - min([p[1] for p in x]) if isinstance(x, list) and len(x) > 0 else 0
+        )
+
+        feat_cols = ["phase", "col_diam", "col_len", "col_part", "grad_len", "grad_range", "flow_rate", "temp"]
+        cat_cols = ["phase"]
+        num_cols = [c for c in feat_cols if c not in cat_cols]
+
+        preprocessor = ColumnTransformer([
+            ("cat", OneHotEncoder(), cat_cols),
+            ("num", StandardScaler(), num_cols)
+        ])
+
+        X = preprocessor.fit_transform(df[feat_cols])
+        df["vector"] = list(X.toarray() if hasattr(X, "toarray") else X)
+        print(f"Extracted {X.shape[1]} features per method.")
+        self.methods = df
+        self.method_features_X = X
+        return X
+
+    def create_method_splits(self, n_splits=5):
+        """
+        Splits the dataset by LC-MS setup groups into folds.
+        """
+        print("\nCREATING METHOD SPLITS")
+        print("=" * 60)
+
+        print("Extracting method features and computing UMAP...")
+        X = self.extract_method_features()
+        
+        # compute UMAP embedding
+        reducer = umap.UMAP(
+            n_neighbors=8,
+            min_dist=0.1,
+            metric="euclidean",
+            random_state=RANDOM_SEED
+        )
+        umap_embedding = reducer.fit_transform(X)
+        self.methods["umap_x"], self.methods["umap_y"] = umap_embedding[:, 0], umap_embedding[:, 1]
+        print("UMAP embedding computed.")
+        
+        method_ids = self.methods["method_number"].values
+        
+        method_sizes = self.df["method_number"].value_counts().to_dict()
+        print(f"{len(method_sizes):,} unique methods in dataset.")
+
+        fold_assignments, fold_counts = assign_methods_to_folds(
+            method_sizes, n_splits, 
+            method_features=umap_embedding,
+            method_ids=method_ids
+        )
+        
+        print("\nFold balance summary:")
+        for i, count in enumerate(fold_counts):
+            print(f"  Fold {i+1}: {count:,} datapoints ({100*count/len(self.df):.2f}%)")
+
+        method_to_fold = {}
+        for i, methods in fold_assignments.items():
+            for m in methods:
+                method_to_fold[m] = i + 1
+
+        self.df["fold"] = self.df["method_number"].map(method_to_fold)
+        
+        self.methods["fold"] = self.methods["method_number"].map(method_to_fold)
+
+        fold_dataframes = {}
+        for i in range(n_splits):
+            fold_df = self.df[self.df["fold"] == i + 1].copy()
+            out_file = self.output_dir / f"methods_{i+1}.csv"
+            fold_df.to_csv(out_file, index=False)
+            fold_dataframes[i] = fold_df
+            print(f"Saved setup_{i+1}.csv ({len(fold_df):,} rows)")
+
+        return fold_dataframes
+
+    def visualize_rt_distributions(self, fold_dataframes):
+        """
+        Generates a KDE plot of the RT distribution per setup 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"Setup {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 Method 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 / "methods_rt.png", dpi=300, bbox_inches="tight")
+        plt.close()
+        print(f"Saved RT KDE plot to figures/method_rt.png")
+
+    def generate_umap_plot(self):
+        """
+        Generates a UMAP visualization plot (embedding already computed).
+        """
+        print("\nGENERATING UMAP VISUALIZATION")
+        
+        if "umap_x" not in self.methods.columns or "umap_y" not in self.methods.columns:
+            print("Warning: UMAP coordinates not found, computing now...")
+            X = self.extract_method_features()
+            reducer = umap.UMAP(
+                n_neighbors=8,
+                min_dist=0.1,
+                metric="euclidean",
+                random_state=RANDOM_SEED
+            )
+            embedding = reducer.fit_transform(X)
+            self.methods["umap_x"], self.methods["umap_y"] = embedding[:, 0], embedding[:, 1]
+        
+        plt.figure(figsize=(10, 7))
+        
+        if "fold" in self.methods.columns:
+            colors = sns.color_palette("husl", N_FOLDS)
+            for fold_num in sorted(self.methods["fold"].dropna().unique()):
+                fold_data = self.methods[self.methods["fold"] == fold_num]
+                n_methods = len(fold_data)
+                plt.scatter(
+                    fold_data["umap_x"], fold_data["umap_y"],
+                    label=f"Cluster {int(fold_num)} (n={n_methods} methods)",
+                    s=100, alpha=0.7, edgecolor="k", linewidth=0.5,
+                    color=colors[int(fold_num) - 1]
+                )
+            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10)
+            plt.title("UMAP Projection of LC-MS Method Space (Colored by Method Split)", fontsize=14, pad=15, fontweight='bold')
+        else:
+            sns.scatterplot(
+                x="umap_x", y="umap_y", data=self.methods,
+                s=70, color="steelblue", edgecolor="k"
+            )
+            plt.title("2D UMAP Visualization of LC-MS Method Space", fontsize=14, pad=15)
+
+        plt.tight_layout()
+
+        fig_dir = self.output_dir / "figures"
+        fig_dir.mkdir(exist_ok=True)
+        plt.savefig(fig_dir / "methods_umap.png", dpi=300, bbox_inches="tight")
+        plt.close()
+        print(f"Saved UMAP plot to figures/method_umap.png")
+
+
+# ===== Main ===== #
+
+
+def main():
+    """
+    Main execution function.
+    """
+    print("\n" + "=" * 80)
+    print(" " * 30 + "METHOD SPLIT PIPELINE")
+    print("=" * 80)
+
+    analyzer = MethodAnalyzer(INPUT_CSV, METHOD_CSV, OUTPUT_DIR)
+    analyzer.load_data()
+    analyze_dataset(analyzer.df)
+    
+    fold_dataframes = analyzer.create_method_splits(n_splits=N_FOLDS)
+    
+    analyzer.generate_umap_plot()
+    
+    analyzer.visualize_rt_distributions(fold_dataframes)
+
+    print("\n" + "=" * 80)
+    print(" " * 30 + "METHOD SPLIT COMPLETE!")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()

data/scripts/scaffold_split.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""
+scaffold_split.py
+
+Author: natelgrw
+Last Edited: 11/02/2025
+
+Computes Bemis-Murcko scaffolds for the retina dataset using RDKit 
+and splits scaffolds into 5 distinct folds with approximately balanced 
+compound counts across folds. Computes UMAP, scaffold assignments, and
+method length distributions for visualizing scaffold splits.
+"""
+
+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, Counter
+import random
+from tqdm import tqdm
+from rdkit import Chem
+from rdkit.Chem.Scaffolds import MurckoScaffold
+from rdkit.Chem import AllChem
+import umap
+
+
+# ===== Configuration ===== #
+
+
+INPUT_CSV = "../retina_dataset.csv"
+OUTPUT_DIR = "../scaffold_split"
+N_FOLDS = 5
+RANDOM_SEED = 42
+
+random.seed(RANDOM_SEED)
+np.random.seed(RANDOM_SEED)
+
+
+# ===== Helper Functions ===== #
+
+
+def get_murcko_scaffold(smiles):
+    """
+    Compute Bemis-Murcko scaffold from SMILES string.
+    """
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return "INVALID"
+        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol)
+        return scaffold if scaffold else "NO_SCAFFOLD"
+    except Exception as e:
+        return "INVALID"
+
+
+def analyze_dataset(df):
+    """
+    Prints dataset statistics.
+    """
+    print("=" * 70)
+    print("Dataset Analysis")
+    print("=" * 70)
+    print(f"Total rows: {len(df):,}")
+    print(f"Columns: {df.columns.tolist()}")
+    print(f"\nUnique compounds: {df['compound'].nunique():,}")
+    if 'rt' in df.columns:
+        print(f"\nRetention time statistics:")
+        print(f"Min: {df['rt'].min():.2f} min")
+        print(f"Max: {df['rt'].max():.2f} min")
+        print(f"Mean: {df['rt'].mean():.2f} min")
+        print(f"Median: {df['rt'].median():.2f} min")
+    print()
+
+
+def assign_scaffolds_to_folds(scaffold_sizes, n_folds):
+    """
+    Assign scaffolds to folds using a greedy algorithm to balance compound counts.
+    """
+    fold_assignments = defaultdict(list)
+    fold_counts = [0] * n_folds
+    
+    sorted_scaffolds = sorted(scaffold_sizes.items(), key=lambda x: x[1], reverse=True)
+    
+    # greedy scaffold assignment
+    for scaffold, size in sorted_scaffolds:
+        min_fold = min(range(n_folds), key=lambda i: fold_counts[i])
+        fold_assignments[min_fold].append(scaffold)
+        fold_counts[min_fold] += size
+    
+    return fold_assignments, fold_counts
+
+
+# ===== Analyzer Class ===== #
+
+
+class ScaffoldAnalyzer:
+    """
+    Analyzer for scaffold splitting and visualization.
+    """
+    
+    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.scaffold_dict = {}
+        self.scaffold_to_compounds = defaultdict(list)
+        
+    def load_data(self, sample_size=None):
+        """
+        Loads the retina dataset.
+        """
+        print("\n" + "=" * 70)
+        print("LOADING DATA")
+        print("=" * 70)
+        
+        if sample_size:
+            print(f"Loading {sample_size:,} rows (sample)...")
+            self.df = pd.read_csv(self.data_path, nrows=sample_size)
+        else:
+            print(f"Loading full dataset from {self.data_path}...")
+            chunks = []
+            chunk_size = 100000
+            for chunk in tqdm(pd.read_csv(self.data_path, chunksize=chunk_size), 
+                            desc="Reading chunks"):
+                chunks.append(chunk)
+            self.df = pd.concat(chunks, ignore_index=True)
+        
+        print(f"  Loaded {len(self.df):,} data points")
+        print(f"  Columns: {list(self.df.columns)}")
+        return self.df
+    
+    def extract_scaffolds(self):
+        """
+        Extracts Bemis-Murcko scaffolds from SMILES.
+        """
+        print("\n" + "=" * 70)
+        print("EXTRACTING BEMIS-MURCKO SCAFFOLDS")
+        print("=" * 70)
+        
+        print("Computing scaffolds for all compounds...")
+        self.df['scaffold'] = self.df['compound'].apply(get_murcko_scaffold)
+        
+        invalid_count = (self.df['scaffold'] == "INVALID").sum()
+        no_scaffold_count = (self.df['scaffold'] == "NO_SCAFFOLD").sum()
+        valid_count = len(self.df) - invalid_count - no_scaffold_count
+        
+        if invalid_count > 0:
+            print(f"Warning: {invalid_count:,} rows have invalid SMILES")
+        if no_scaffold_count > 0:
+            print(f"Info: {no_scaffold_count:,} rows have no scaffold (single atoms)")
+        
+        print(f"Successfully extracted scaffolds for {valid_count:,} rows")
+        
+        scaffold_groups = self.df.groupby('scaffold')
+        scaffold_sizes = scaffold_groups.size().to_dict()
+        
+        n_unique_scaffolds = len(scaffold_sizes)
+        sizes_array = np.array(list(scaffold_sizes.values()))
+        
+        print(f"\nScaffold Statistics:")
+        print(f"Unique scaffolds: {n_unique_scaffolds:,}")
+        print(f"Scaffolds with 1 data point: {(sizes_array == 1).sum():,}")
+        print(f"Scaffolds with >10 data points: {(sizes_array > 10).sum():,}")
+        print(f"Scaffolds with >100 data points: {(sizes_array > 100).sum():,}")
+        print(f"Mean data points per scaffold: {sizes_array.mean():.2f}")
+        print(f"Median data points per scaffold: {np.median(sizes_array):.0f}")
+        print(f"Max data points in a scaffold: {sizes_array.max():,}")
+        
+        return scaffold_sizes
+
+    def create_scaffold_splits(self, scaffold_sizes, n_splits=5):
+        """
+        Creates scaffold-based cross-validation splits.
+        
+        Splits are created by grouping scaffolds to balance the number of data points
+        in each fold while ensuring no scaffold appears in multiple folds.
+        """
+        print("\n" + "=" * 70)
+        print(f"CREATING {n_splits}-FOLD SCAFFOLD SPLITS")
+        print("=" * 70)
+        
+        print(f"Assigning {len(scaffold_sizes):,} scaffolds to {n_splits} folds...")
+        fold_assignments, fold_counts = assign_scaffolds_to_folds(scaffold_sizes, n_splits)
+        
+        print("\nFold Statistics:")
+        print("-" * 70)
+        for fold_id in range(n_splits):
+            scaffolds = fold_assignments[fold_id]
+            count = fold_counts[fold_id]
+            percentage = 100 * count / len(self.df)
+            print(f"Fold {fold_id + 1}: {count:,} data points ({percentage:.2f}%) | "
+                  f"{len(scaffolds):,} scaffolds")
+        print("-" * 70)
+        print(f"Total: {sum(fold_counts):,} data points")
+        
+        scaffold_to_fold = {}
+        for fold_idx in range(n_splits):
+            for scaffold in fold_assignments[fold_idx]:
+                scaffold_to_fold[scaffold] = fold_idx + 1
+        
+        self.df['fold'] = self.df['scaffold'].map(scaffold_to_fold)
+        
+        print(f"\nSaving fold CSV files...")
+        fold_dataframes = {}
+        
+        for fold_id in range(n_splits):
+            fold_df = self.df[self.df['fold'] == fold_id + 1].copy()
+            fold_df_output = fold_df.drop(columns=['scaffold', 'fold'])
+            
+            output_file = self.output_dir / f"fold_{fold_id + 1}.csv"
+            fold_df_output.to_csv(output_file, index=False)
+            fold_dataframes[fold_id] = fold_df
+            
+            print(f"Saved fold_{fold_id + 1}.csv: {len(fold_df):,} rows")
+        
+        scaffold_assignments_data = []
+        for fold_id in range(n_splits):
+            for scaffold in fold_assignments[fold_id]:
+                scaffold_assignments_data.append({
+                    'scaffold': scaffold,
+                    'fold': fold_id + 1,
+                    'datapoint_count': scaffold_sizes[scaffold]
+                })
+        
+        scaffold_assignments_df = pd.DataFrame(scaffold_assignments_data)
+        scaffold_assignments_df = scaffold_assignments_df.sort_values(
+            ['fold', 'datapoint_count'], ascending=[True, False]
+        )
+        
+        scaffold_assignments_file = self.output_dir / "figures/scaffold_assignments.csv"
+        scaffold_assignments_df.to_csv(scaffold_assignments_file, index=False)
+        print(f"\nSaved scaffold assignments to: scaffold_assignments.csv")
+        print(f"Total scaffolds: {len(scaffold_assignments_df):,}")
+        print(f"Columns: scaffold, fold, datapoint_count")
+        
+        print("\nVerifying scaffold separation...")
+        all_fold_scaffolds = [set(fold_assignments[i]) for i in range(n_splits)]
+        has_overlap = False
+        for i in range(n_splits):
+            for j in range(i + 1, n_splits):
+                overlap = all_fold_scaffolds[i] & all_fold_scaffolds[j]
+                if overlap:
+                    print(f"ERROR: Overlap between fold {i+1} and fold {j+1}: {len(overlap)} scaffolds")
+                    has_overlap = True
+        
+        if not has_overlap:
+            print(f"No overlap - all scaffolds are uniquely assigned")
+        
+        all_assigned = set()
+        for fold_id in range(n_splits):
+            all_assigned.update(fold_assignments[fold_id])
+        
+        if len(all_assigned) == len(scaffold_sizes):
+            print(f"All {len(scaffold_sizes):,} scaffolds assigned to folds")
+        else:
+            missing = set(scaffold_sizes.keys()) - all_assigned
+            print(f"WARNING: {len(missing)} scaffolds not assigned to any fold")
+        
+        return fold_assignments, scaffold_to_fold, fold_dataframes
+    
+    def visualize_rt_distributions(self, fold_dataframes):
+        """
+        Generates an RT (retention time) KDE plot across folds.
+        """
+        print("\n" + "=" * 70)
+        print("GENERATING RT DISTRIBUTION VISUALIZATION")
+        print("=" * 70)
+        
+        # converting RT from seconds to minutes
+        valid_rt = self.df['rt'].dropna() / 60.0
+        print(f"Data points with valid RT: {len(valid_rt):,}")
+
+        print(f"\nRT Statistics (in minutes):")
+        print(f"  Mean: {valid_rt.mean():.2f} minutes")
+        print(f"  Median: {valid_rt.median():.2f} minutes")
+        print(f"  Min: {valid_rt.min():.2f} minutes")
+        print(f"  Max: {valid_rt.max():.2f} minutes")
+        print(f"  Std: {valid_rt.std():.2f} minutes")
+        
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        if fold_dataframes:
+            colors = sns.color_palette("husl", len(fold_dataframes))
+            
+            for fold_id in range(len(fold_dataframes)):
+                fold_df = fold_dataframes[fold_id]
+                fold_rt = fold_df['rt'].dropna() / 60.0
+                
+                if len(fold_rt) > 0:
+                    sns.kdeplot(data=fold_rt, ax=ax,
+                               label=f'Fold {fold_id + 1} (n={len(fold_rt):,})',
+                               linewidth=2.5, color=colors[fold_id])
+            
+            sns.kdeplot(data=valid_rt, ax=ax,
+                       label=f'Overall (n={len(valid_rt):,})',
+                       linewidth=2, linestyle='--', color='black', alpha=0.7)
+        else:
+            sns.kdeplot(data=valid_rt, ax=ax, linewidth=2.5, color='blue')
+        
+        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 Scaffold Splits', fontsize=14, fontweight='bold')
+        ax.set_xlim(0, 135)
+        ax.legend(loc='best', frameon=True, fancybox=True, shadow=True)
+        ax.grid(alpha=0.3)
+        
+        plt.tight_layout()
+        
+        # creating figures subdirectory
+        figures_dir = self.output_dir / 'figures'
+        figures_dir.mkdir(exist_ok=True)
+        
+        output_file = figures_dir / 'scaffold_rt.png'
+        plt.savefig(output_file, dpi=300, bbox_inches='tight')
+        print(f"\nSaved RT distribution visualization to figures/scaffold_rt.png")
+        plt.close()
+    
+    def generate_umap(self, n_samples=None):
+        """
+        Generates a UMAP visualization of chemical space.
+        Uses Morgan fingerprints for molecular representation.
+        """
+        print("\n" + "=" * 70)
+        print("GENERATING UMAP VISUALIZATION")
+        print("=" * 70)
+        
+        if n_samples is not None and len(self.df) > n_samples:
+            print(f"Sampling {n_samples:,} datapoints for UMAP...")
+            df_sample = self.df.sample(n=n_samples, random_state=42)
+        else:
+            print(f"Using all {len(self.df):,} datapoints for UMAP...")
+            df_sample = self.df
+        
+        print(f"Generating Morgan fingerprints for {len(df_sample):,} datapoints...")
+        
+        fps = []
+        valid_indices = []
+        
+        for idx, smiles in tqdm(enumerate(df_sample['compound']), 
+                               total=len(df_sample),
+                               desc="Generating fingerprints"):
+            try:
+                mol = Chem.MolFromSmiles(smiles)
+                if mol is not None:
+                    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=2048)
+                    fps.append(fp)
+                    valid_indices.append(idx)
+            except:
+                pass
+        
+        print(f"Generated {len(fps):,} valid fingerprints")
+        
+        fp_array = np.array([list(fp) for fp in fps])
+        df_valid = df_sample.iloc[valid_indices].reset_index(drop=True)
+        
+        print(f"\nFitting UMAP (this may take a while)...")
+        print(f"n_samples: {len(fp_array):,}")
+        print(f"n_features: {fp_array.shape[1]}")
+        
+        reducer = umap.UMAP(
+            n_neighbors=15,
+            min_dist=0.1,
+            n_components=2,
+            metric='jaccard',
+            random_state=42,
+            verbose=True
+        )
+        
+        embedding = reducer.fit_transform(fp_array)
+        print(f"UMAP embedding complete")
+        
+        # create umap visualization
+        print("\nGenerating UMAP visualization...")
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        if 'fold' in df_valid.columns:
+            colors = sns.color_palette("husl", df_valid['fold'].nunique())
+            
+            for fold_id in sorted(df_valid['fold'].unique()):
+                mask = df_valid['fold'] == fold_id
+                fold_data = embedding[mask]
+                n_compounds = mask.sum()
+                
+                ax.scatter(fold_data[:, 0], fold_data[:, 1],
+                          label=f'Fold {int(fold_id)} (n={n_compounds:,})',
+                          alpha=0.6, s=20, c=[colors[int(fold_id)-1]])
+        else:
+            ax.scatter(embedding[:, 0], embedding[:, 1], 
+                      alpha=0.6, s=20, color='blue')
+        
+        ax.set_title('UMAP Projection of Compound Space (Colored by Scaffold Split)', 
+                    fontsize=14, fontweight='bold')
+        ax.legend(loc='best', frameon=True, fancybox=True, shadow=True, fontsize=10)
+        ax.grid(alpha=0.3)
+        
+        plt.tight_layout()
+        
+        # saving results to figures subdirectory
+        figures_dir = self.output_dir / 'figures'
+        figures_dir.mkdir(exist_ok=True)
+        
+        output_file = figures_dir / 'scaffold_umap.png'
+        plt.savefig(output_file, dpi=300, bbox_inches='tight')
+        print(f"Saved UMAP visualization to figures/scaffold_umap.png")
+        plt.close()
+
+        return embedding, df_valid
+
+
+# ===== Main ===== #
+
+
+def main():
+    """
+    Main execution function.
+    """
+    print("\n" + "=" * 80)
+    print(" " * 20 + "BEMIS-MURCKO SCAFFOLD SPLIT")
+    print(" " * 25 + "Retina Dataset Analysis")
+    print("=" * 80)
+    
+    script_dir = Path(__file__).parent
+    data_path = script_dir / INPUT_CSV
+    output_dir = script_dir / OUTPUT_DIR
+    
+    print(f"\nConfiguration:")
+    print(f"Script location: {script_dir}")
+    print(f"Data path: {data_path}")
+    print(f"Output directory: {output_dir}")
+    print(f"Number of folds: {N_FOLDS}")
+    print(f"Random seed: {RANDOM_SEED}")
+    
+    if not data_path.exists():
+        raise FileNotFoundError(f"Input file not found: {data_path}")
+    
+    analyzer = ScaffoldAnalyzer(data_path, output_dir)
+    
+    print("\nLoading dataset...")
+    analyzer.load_data(sample_size=None)
+    
+    analyze_dataset(analyzer.df)
+    
+    scaffold_sizes = analyzer.extract_scaffolds()
+    
+    fold_assignments, scaffold_to_fold, fold_dataframes = analyzer.create_scaffold_splits(
+        scaffold_sizes, n_splits=N_FOLDS
+    )
+
+    analyzer.visualize_rt_distributions(fold_dataframes)
+    
+    analyzer.generate_umap(n_samples=None)  # Use all datapoints
+    
+    print("\n" + "=" * 80)
+    print(" " * 25 + "5-FOLD SCAFFOLD SPLIT COMPLETE!")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()
+

data/solvents/README.md

@@ -1,6 +1,6 @@
 # 🥽 ReTiNA Table of Solvent Desciptors
 
-The ReTiNA dataset is accompanied with 160 descriptors for each solvent, capturing detailed structural, electronic, and topological features for model training. Descriptors were computed using RDKit.
+The ReTiNA dataset is accompanied with 157 descriptors for each solvent, capturing detailed structural, electronic, and topological features for model training. Descriptors were computed using RDKit.
 
 ## Topological Descriptors
 
@@ -9,16 +9,13 @@ The ReTiNA dataset is accompanied with 160 descriptors for each solvent, capturi
 | BalabanJ | Quantifies molecular complexity based on average distance connectivity and graph branching | RDKit |
 | BertzCT | Calculates molecular complexity based on graph connectivity and atomic contributions | RDKit |
 | Chi (0-1), Chi_n (0-4) Chi_v (0-4)  | Connectivity indices reflecting molecular topology, branching, and size | RDKit |
-| Ipc  | Information content index representing structural complexity | RDKit |
 | Kappa (1-3) | Shape indices describing molecular flexibility and overall geometry | RDKit |
 
 ## Electronic Descriptors
 
 | Descriptor | Summary | Software Used |
 |------------|---------|---------------|
-| MaxAbsPartialCharge | Maximum absolute atomic partial charge | RDKit |
 | MaxEStateIndex | Maximum E-state value in the molecule | RDKit |
-| MaxPartialCharge | Highest partial charge in the molecule | RDKit |
 | NumValenceElectrons | Total number of valence electrons in the molecule | RDKit |
 | NumRadicalElectrons | Total number of unpaired electrons (radicals) | RDKit |
 | HallKierAlpha | Atom-type electrotopological descriptor modeling polarity and hybridization | RDKit |

data/solvents/solv.smi

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:04c1b7b8afb3b7495a5f0287a623782e7525c2fd6e43d3c778b57309193a683f
-size 62
+oid sha256:5f451c636378e59fdb245e7f16fab89a55abc927fbb285a5dda79df0a1058167
+size 61

data/solvents/solv_descriptors.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:47539bd1f9e4e25f66295a79796e5b24d01f6dcc58c208d9264a0c3360d9cb71
-size 19135
+oid sha256:eefce3ea7ad3e74e4ecd496fe0dad84e534dd4c8255c7880283f5815e2fbbe28
+size 18660