Version 1.0.0

.gitattributes

@@ -1,2 +1,3 @@
 *.csv filter=lfs diff=lfs merge=lfs -text
 *.smi filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -3,9 +3,15 @@ license: mit
 ---
 
 ## 〰️ AMAX: A Benchmark Dataset for UV-Vis Lambda Max Prediction in LC-MS
-
+  
 AMAX is an open source dataset designed to assist machine learning models in small molecule UV-Vis absorption maxima (λ<sub>max</sub>) prediction and LC-MS compound characterization workflows.
 
+Current Version: **1.0.0**
+
+Available models trained on the AMAX dataset are available at this [Hugging Face Repository](https://huggingface.co/natelgrw/AMAX-Models).
+
+Source code for the AMAX model collection is available at this [Github Repository](https://github.com/natelgrw/amax_models).
+
 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.
 
 AMAX is designed for use in:
@@ -20,9 +26,9 @@ The AMAX dataset contains:
 
 - 40,013 unique molecule–environment combinations, the largest singular LC-MS retention time dataset of its kind to date
 - Experimentally measured λ<sub>max</sub> values in nm, curated from public datasets, benchmark papers, and literature
-- 160 calculated chemical descriptors for 22,415 unique compounds and 356 unique solvents
+- 157 calculated chemical descriptors for 22,415 unique compounds and 356 unique solvents
 
-Additionally, the AMAX dataset is divided into training, validation, and testing subsets in an 80:10:10 split. 
+Additionally, the AMAX dataset is divided into different scaffold, cluster, and solvent splits for model evaluation. 
 
 ## 📋 Data Sources Used
 
@@ -33,7 +39,7 @@ Detailed information on the data sources comprising AMAX-1 can be found in the d
 If you use this code in a project, please cite the following:
 
 ```
-@dataset{natelgrwamax1dataset,
+@dataset{natelgrwamaxdataset,
   title={AMAX: A Benchmark Dataset for UV-Vis Lambda Max Prediction in LC-MS},
   author={Leung, Nathan},
   institution={Coley Research Group @ MIT}

data/{testing/amax_testing.csv → cluster_split/cluster_1.csv}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:77e5dc8879575ef4c1707149fc3c9309ee9216c95c3423e362dfd13cd3e76810
-size 353520
+oid sha256:b2358204b90177b151f65f96cd0bd21f12acf457693c93c5583976d890e6b991
+size 524145

data/{training/amax_training.csv → cluster_split/cluster_2.csv}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eff44a87e6557a5455a96e970fbf3d0df8b6adeb1dfc15839577a0a4ab156957
-size 2840619
+oid sha256:3090a2022f3202178720fe0c04293dbdfef15a097bc619ee0f764455ec82be0c
+size 1416404

data/{validation/amax_validation.csv → cluster_split/cluster_3.csv}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f0b237eb2b0d6b8f8f39942edbea9c47070612b22fce29949acbb3775b724673
-size 353594
+oid sha256:8862bbc7bcdffdd4d2a1c9f02cd1c27a48ddb6745511ae0b8929dd25e5995e00
+size 426057

data/cluster_split/cluster_4.csv

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

data/cluster_split/cluster_5.csv

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

data/cluster_split/figures/cluster_assignments.csv

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

data/compounds/README.md

@@ -1,6 +1,6 @@
 # 🔬 AMAX Compound Desciptors
 
-The AMAX 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 AMAX 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 AMAX dataset is accompanied with 160 descriptors for each compound, capturin
 | 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_descriptors.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:522aefb71e6a19f242966624bc0d9cb08f1acfc96b4ee0d5426a9914e06606c2
-size 75216122
+oid sha256:6fc2cdc42d04799170971745c51284edadced7b9d2703bffe2f4b0756a76b9d2
+size 73813553

data/scaffold_split/figures/scaffold_assignments.csv

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

data/scaffold_split/fold_1.csv

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

data/scaffold_split/fold_2.csv

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

data/scaffold_split/fold_3.csv

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

data/scaffold_split/fold_4.csv

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

data/scaffold_split/fold_5.csv

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

data/scripts/cluster_split.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+cluster_split.py
+
+Author: natelgrw
+Last Edited: 11/07/2025
+
+Performs spatial KMeans cluster splitting for the AMAX dataset directly on 
+2D UMAP coordinates. This ensures visual consistency between the UMAP 
+visualization and the actual fold assignments, and creates realistic chemical 
+neighborhoods for evaluation.
+"""
+
+import os
+import random
+import numpy as np
+import pandas as pd
+from collections import defaultdict
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from sklearn.cluster import KMeans
+import matplotlib.pyplot as plt
+import seaborn as sns
+import umap
+
+
+# ===== Configuration ===== #
+
+
+INPUT_CSV = "../amax_dataset.csv"
+OUTPUT_DIR = "../cluster_split"
+N_REGIONS = 5
+RANDOM_SEED = 42
+
+random.seed(RANDOM_SEED)
+np.random.seed(RANDOM_SEED)
+
+
+# ===== Helper Functions ===== #
+
+
+def compute_fingerprints(df, smiles_column="compound"):
+    """
+    Compute Morgan fingerprints for all SMILES.
+    Returns array of fingerprints and list of valid indices.
+    """
+    fps, valid_idx = [], []
+    print("Computing Morgan fingerprints (radius=2, nBits=2048)...")
+    for i, smi in enumerate(df[smiles_column]):
+        mol = Chem.MolFromSmiles(smi)
+        if mol is None:
+            continue
+        fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=2048)
+        fps.append(fp)
+        valid_idx.append(i)
+    fps_array = np.array([list(fp) for fp in fps], dtype=np.float32)
+    print(f"Valid compounds: {len(fps_array):,}")
+    return fps_array, valid_idx
+
+
+def compute_umap_embedding(fps_array):
+    """
+    Compute 2D UMAP embedding of fingerprints using Jaccard metric.
+    Returns 2D coordinates for spatial clustering.
+    """
+    print("\nComputing 2D UMAP embedding (Jaccard/Tanimoto metric)...")
+    fps_bin = (fps_array > 0).astype(float)
+    reducer = umap.UMAP(
+        n_neighbors=25,
+        min_dist=0.1,
+        metric="jaccard",
+        random_state=RANDOM_SEED,
+    )
+    emb = reducer.fit_transform(fps_bin)
+    print(f"  UMAP embedding computed: {emb.shape}")
+    return emb
+
+
+def spatial_cluster_split(df, umap_coords, valid_indices, n_regions):
+    """
+    Performs spatial KMeans clustering directly on UMAP 2D coordinates.
+    Each KMeans cluster becomes one fold - simple 1:1 mapping.
+    Creates visually consistent and chemically meaningful regions.
+    """
+    print("=" * 65)
+    print("Performing Spatial KMeans Clustering on 2D UMAP Coordinates")
+    print("=" * 65)
+    
+    print(f"\nRunning KMeans with k={n_regions} on 2D UMAP coordinates...")
+    km = KMeans(n_clusters=n_regions, random_state=RANDOM_SEED, n_init=20)
+    labels = km.fit_predict(umap_coords)
+    
+    print(f"\nCluster centroids in 2D UMAP space:")
+    for i, centroid in enumerate(km.cluster_centers_):
+        print(f"  Region {i+1}: ({centroid[0]:.2f}, {centroid[1]:.2f})")
+    
+    folds = defaultdict(list)
+    for local_idx, global_idx in enumerate(valid_indices):
+        region = labels[local_idx]
+        folds[region].append(global_idx)
+    
+    total = len(df)
+    print("\nRegion Summary:")
+    for r in sorted(folds.keys()):
+        n = len(folds[r])
+        p = 100 * n / total
+        print(f"Region {r+1}: {n:,} compounds ({p:.2f}%)")
+    
+    return folds, labels
+
+
+def save_cluster_assignments(df, folds, cluster_labels, umap_coords, valid_idx, output_dir):
+    """
+    Saves cluster assignments with UMAP coordinates to CSV.
+    Format: compound,cluster,fold,umap_x,umap_y
+    """
+    print("\nSaving cluster assignments...")
+    fig_dir = os.path.join(output_dir, "figures")
+    os.makedirs(fig_dir, exist_ok=True)
+    
+    assignments = []
+    for fold_id, indices in folds.items():
+        for global_idx in indices:
+            if global_idx in valid_idx:
+                local_idx = valid_idx.index(global_idx)
+                compound_smiles = df.loc[global_idx, 'compound']
+                cluster = int(cluster_labels[local_idx])
+                fold = fold_id + 1
+                umap_x = umap_coords[local_idx, 0]
+                umap_y = umap_coords[local_idx, 1]
+                
+                assignments.append({
+                    'compound': compound_smiles,
+                    'cluster': cluster,
+                    'fold': fold,
+                    'umap_x': umap_x,
+                    'umap_y': umap_y
+                })
+    
+    assignments_df = pd.DataFrame(assignments)
+    output_file = os.path.join(fig_dir, "cluster_assignments.csv")
+    assignments_df.to_csv(output_file, index=False)
+    print(f"Saved figures/cluster_assignments.csv: {len(assignments_df):,} entries")
+
+
+def visualize_lambda_max(df, folds, output_dir):
+    """
+    Plots λmax distributions across regions.
+    """
+    if "lambda_max" not in df.columns:
+        return
+    print("\nGenerating λmax distribution plot...")
+    os.makedirs(output_dir, exist_ok=True)
+
+    fig_dir = os.path.join(output_dir, "figures")
+    os.makedirs(fig_dir, exist_ok=True)
+
+    plt.figure(figsize=(12, 6))
+    colors = sns.color_palette("husl", len(folds))
+
+    for i, (r, idxs) in enumerate(sorted(folds.items())):
+        region_df = df.loc[idxs]
+        sns.kdeplot(
+            data=region_df,
+            x="lambda_max",
+            label=f"Cluster {r+1} (n={len(region_df):,})",
+            linewidth=2.2,
+            color=colors[i],
+        )
+
+    sns.kdeplot(
+        data=df,
+        x="lambda_max",
+        label=f"Overall (n={len(df):,})",
+        linewidth=2.0,
+        linestyle="--",
+        color="black",
+        alpha=0.7,
+    )
+
+    plt.title("Lambda Max Distribution Across Cluster Splits", fontsize=14, fontweight="bold")
+    plt.xlabel("λmax (nm)", fontsize=12, fontweight="bold")
+    plt.ylabel("Density", fontsize=12, fontweight="bold")
+    plt.legend(frameon=True, shadow=True)
+    plt.tight_layout()
+    plt.savefig(os.path.join(fig_dir, "cluster_lmax.png"), dpi=300)
+    plt.close()
+    print("Saved figures/cluster_lmax.png")
+
+
+def visualize_umap(umap_coords, valid_idx, folds, output_dir):
+    """
+    Generates 2D UMAP of chemical space colored by region.
+    """
+    print("\nGenerating UMAP visualization...")
+    os.makedirs(output_dir, exist_ok=True)
+
+    colors = sns.color_palette("husl", len(folds))
+    plt.figure(figsize=(12, 10))
+    for i, (r, idxs) in enumerate(sorted(folds.items())):
+        local_idx = [j for j, g in enumerate(valid_idx) if g in idxs]
+        label = f"Cluster {r+1} (n={len(local_idx):,})"
+        plt.scatter(
+            umap_coords[local_idx, 0],
+            umap_coords[local_idx, 1],
+            s=10,
+            alpha=0.6,
+            label=label,
+            color=colors[i],
+        )
+
+    plt.title(
+        "UMAP Projection of Compound Space (Colored by Cluster Split)",
+        fontsize=14,
+        fontweight="bold",
+    )
+
+
+    plt.legend(markerscale=2, frameon=True, loc='best')
+    plt.tight_layout()
+    os.makedirs(os.path.join(output_dir, "figures"), exist_ok=True)
+    plt.savefig(os.path.join(output_dir, "figures/cluster_umap.png"), dpi=300)
+    plt.close()
+    print("Saved figures/cluster_umap.png")
+
+
+# ===== Main ===== #
+
+
+def main():
+    """
+    Main function to perform spatial cluster splitting.
+    """
+    print("=" * 65)
+    print("SPATIAL CLUSTER SPLITTING PIPELINE")
+    print("=" * 65)
+    print(f"Configuration:")
+    print(f"- Number of regions: {N_REGIONS}")
+    print(f"- Clustering dimension: 2D (UMAP coordinates)")
+    print(f"- Random seed: {RANDOM_SEED}")
+    print(f"- Input: {INPUT_CSV}")
+    print(f"- Output: {OUTPUT_DIR}")
+    print()
+    
+    print("Loading dataset...")
+    df = pd.read_csv(INPUT_CSV)
+    print(f"Loaded {len(df):,} rows.")
+    
+    fps_array, valid_idx = compute_fingerprints(df)
+    
+    umap_coords = compute_umap_embedding(fps_array)
+    
+    folds, cluster_labels = spatial_cluster_split(
+        df, umap_coords, valid_idx, N_REGIONS
+    )
+    
+    print("\nSaving cluster CSV files...")
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    for r, idxs in folds.items():
+        output_path = os.path.join(OUTPUT_DIR, f"cluster_{r+1}.csv")
+        df.loc[idxs].to_csv(output_path, index=False)
+        print(f"  Saved cluster_{r+1}.csv")
+    
+    save_cluster_assignments(df, folds, cluster_labels, umap_coords, valid_idx, OUTPUT_DIR)
+    
+    visualize_lambda_max(df, folds, OUTPUT_DIR)
+    visualize_umap(umap_coords, valid_idx, folds, OUTPUT_DIR)
+    
+    print("\n" + "=" * 65)
+    print("CLUSTERING COMPLETE!")
+    print("=" * 65)
+    print(f"Output directory: {OUTPUT_DIR}")
+    print(f"- {len(folds)} region CSV files")
+    print(f"- figures/cluster_assignments.csv")
+    print(f"- figures/cluster_lmax.png")
+    print(f"- figures/cluster_umap.png")
+    print()
+    print("Note: Clustering performed in 2D UMAP space for visual consistency")
+
+
+if __name__ == "__main__":
+    main()

data/scripts/scaffold_split.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+scaffold_split.py
+
+Author: natelgrw
+Last Edited: 11/01/2025
+
+Computes Bemis-Murcko scaffolds for the AMAX dataset using RDKit 
+and splits scaffolds into 5 distinct folds with approximately balanced 
+compound counts across folds. Computes UMAP, scaffold assignments, and
+lambda max distributions for visualizing scaffold splits.
+"""
+
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem.Scaffolds import MurckoScaffold
+from rdkit.Chem import AllChem
+import random
+import os
+from collections import defaultdict
+import matplotlib.pyplot as plt
+import seaborn as sns
+import umap
+
+
+# ===== Configuration ===== #
+
+
+INPUT_CSV = "../amax_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.
+    
+    Returns:
+        str: Scaffold SMILES string, or "INVALID" if molecule is invalid,
+             or "NO_SCAFFOLD" if scaffold cannot be computed
+    """
+    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:
+        print(f"Warning: Error processing SMILES '{smiles}': {e}")
+        return "INVALID"
+
+
+def analyze_dataset(df):
+    """
+    Print dataset statistics.
+    """
+    print("=" * 60)
+    print("Dataset Analysis")
+    print("=" * 60)
+    print(f"Total rows: {len(df):,}")
+    print(f"Columns: {df.columns.tolist()}")
+    print(f"\nUnique compounds: {df['compound'].nunique():,}")
+    if 'solvent' in df.columns:
+        print(f"Unique solvents: {df['solvent'].nunique():,}")
+    if 'lambda_max' in df.columns:
+        print(f"\nLambda_max statistics:")
+        print(f"  Min: {df['lambda_max'].min():.2f}")
+        print(f"  Max: {df['lambda_max'].max():.2f}")
+        print(f"  Mean: {df['lambda_max'].mean():.2f}")
+        print(f"  Median: {df['lambda_max'].median():.2f}")
+    print()
+
+
+def assign_scaffolds_to_folds(scaffold_sizes, n_folds, total_rows):
+    """
+    Assign scaffolds to folds using a greedy algorithm to balance compound counts.
+    
+    Args:
+        scaffold_sizes: dict mapping scaffold SMILES to number of compounds
+        n_folds: number of folds
+        total_rows: total number of rows in dataset
+    
+    Returns:
+        dict mapping fold_id (0 to n_folds-1) to list of scaffold SMILES
+    """
+    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
+
+
+def create_visualizations(df, scaffold_sizes, fold_assignments, fold_counts, fold_dataframes, output_dir_path):
+    """
+    Create visualizations for scaffold split analysis.
+    
+    Generates:
+    1. Lambda_max distribution across folds (KDE plot)
+    2. UMAP 2D visualization of scaffold assignments
+    """
+    print("\nGenerating visualizations...")
+    
+    sns.set_style("whitegrid")
+    plt.rcParams['figure.dpi'] = 100
+    plt.rcParams['savefig.dpi'] = 300
+    
+    # create figures directory
+    fig_dir = os.path.join(output_dir_path, "figures")
+    os.makedirs(fig_dir, exist_ok=True)
+    
+    colors = sns.color_palette("husl", len(fold_counts))
+    
+    # lambda max distribution across folds
+    if 'lambda_max' in df.columns:
+        print("Creating lambda_max distribution plot...")
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        for fold_id in range(len(fold_dataframes)):
+            fold_df = fold_dataframes[fold_id]
+            fold_label = f"Fold {fold_id + 1} (n={len(fold_df):,})"
+            sns.kdeplot(data=fold_df, x='lambda_max', label=fold_label, 
+                       ax=ax, linewidth=2.5)
+        
+        sns.kdeplot(data=df, x='lambda_max', label=f'Overall (n={len(df):,})', 
+                   ax=ax, linewidth=2, linestyle='--', color='black', alpha=0.7)
+        
+        ax.set_xlabel('Lambda Max (nm)', fontsize=12, fontweight='bold')
+        ax.set_ylabel('Density', fontsize=12, fontweight='bold')
+        ax.set_title('Lambda Max Distribution Across Scaffold Splits', fontsize=14, fontweight='bold')
+        ax.legend(loc='best', frameon=True, fancybox=True, shadow=True)
+        ax.grid(alpha=0.3)
+        
+        plt.tight_layout()
+        plt.savefig(os.path.join(fig_dir, 'scaffold_lmax.png'), bbox_inches='tight')
+        print(f"Saved: figures/scaffold_lmax.png")
+        plt.close()
+
+    # umap visualization
+    print("\nComputing UMAP embedding (this may take a few minutes)...")
+    
+    scaffold_to_fold = {}
+    for fold_id in range(len(fold_assignments)):
+        for scaffold in fold_assignments[fold_id]:
+            scaffold_to_fold[scaffold] = fold_id
+    
+    df_with_fold = df.copy()
+    df_with_fold['fold'] = df_with_fold['scaffold'].map(scaffold_to_fold)
+    
+    valid_mask = (~df_with_fold['scaffold'].isin(['INVALID', 'NO_SCAFFOLD'])) & (df_with_fold['fold'].notna())
+    compounds_for_umap = df_with_fold[valid_mask].copy()
+    
+    print(f"Computing fingerprints for {len(compounds_for_umap):,} data points...")
+    
+    unique_compounds = compounds_for_umap['compound'].unique()
+    print(f"  ({len(unique_compounds):,} unique compounds)")
+    
+    compound_to_fp = {}
+    for smiles in unique_compounds:
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol is not None:
+                fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=2048)
+                compound_to_fp[smiles] = fp.ToBitString()
+        except Exception:
+            continue
+    
+    fps = []
+    valid_indices = []
+    for idx, row in compounds_for_umap.iterrows():
+        smiles = row['compound']
+        if smiles in compound_to_fp:
+            fps.append(compound_to_fp[smiles])
+            valid_indices.append(idx)
+    
+    if len(fps) < 100:
+        print("Warning: Too few valid compounds for UMAP. Skipping UMAP visualization.")
+    else:
+        fps_array = np.array([[int(bit) for bit in fp] for fp in fps])
+        
+        print(f"Fitting UMAP (n={len(fps_array):,} data points, dim={fps_array.shape[1]})...")
+        
+        reducer = umap.UMAP(n_components=2, random_state=RANDOM_SEED, 
+                            n_neighbors=15, min_dist=0.1, metric='jaccard', verbose=False)
+        embedding = reducer.fit_transform(fps_array)
+        
+        valid_compounds_df = compounds_for_umap.loc[valid_indices].copy()
+        valid_compounds_df['umap_x'] = embedding[:, 0]
+        valid_compounds_df['umap_y'] = embedding[:, 1]
+        
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        for fold_id in range(len(fold_assignments)):
+            fold_data = valid_compounds_df[valid_compounds_df['fold'] == fold_id]
+            if len(fold_data) > 0:
+                ax.scatter(fold_data['umap_x'], fold_data['umap_y'], 
+                            label=f'Fold {fold_id + 1} (n={len(fold_data):,})',
+                            alpha=0.6, s=20, c=[colors[fold_id]])
+
+        ax.set_title('UMAP Projection of All Data Points (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()
+        plt.savefig(os.path.join(fig_dir, 'scaffold_umap.png'), bbox_inches='tight')
+        print(f"Saved: figures/scaffold_umap.png")
+        plt.close()
+    
+    print(f"\nAll visualizations saved to: {os.path.join(output_dir_path, 'figures')}")
+
+
+# ===== Main ===== #
+
+def main():
+    """
+    Main function to perform scaffold splitting pipeline.
+    """
+    print("Loading dataset...")
+    input_path = os.path.join(os.path.dirname(__file__), INPUT_CSV)
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+    
+    df = pd.read_csv(input_path)
+    
+    if 'compound' not in df.columns:
+        raise ValueError("Dataset must contain 'compound' column")
+    
+    analyze_dataset(df)
+    
+    print("Computing Bemis-Murcko scaffolds...")
+    df['scaffold'] = df['compound'].apply(get_murcko_scaffold)
+    
+    invalid_count = (df['scaffold'] == "INVALID").sum()
+    no_scaffold_count = (df['scaffold'] == "NO_SCAFFOLD").sum()
+    
+    if invalid_count > 0:
+        print(f"Warning: {invalid_count:,} compounds have invalid SMILES")
+    if no_scaffold_count > 0:
+        print(f"Info: {no_scaffold_count:,} compounds have no scaffold (single atoms)")
+    
+    scaffold_groups = df.groupby('scaffold')
+    scaffold_sizes = scaffold_groups.size().to_dict()
+    
+    print(f"\nScaffold Statistics:")
+    print(f"Unique scaffolds: {len(scaffold_sizes):,}")
+    print(f"Scaffolds with 1 compound: {(np.array(list(scaffold_sizes.values())) == 1).sum():,}")
+    print(f"Scaffolds with >10 compounds: {(np.array(list(scaffold_sizes.values())) > 10).sum():,}")
+    print(f"Scaffolds with >100 compounds: {(np.array(list(scaffold_sizes.values())) > 100).sum():,}")
+    
+    print(f"\nAssigning scaffolds to {N_FOLDS} folds...")
+    fold_assignments, fold_counts = assign_scaffolds_to_folds(
+        scaffold_sizes, N_FOLDS, len(df)
+    )
+    
+    print("\nFold Statistics:")
+    print("-" * 60)
+    for fold_id in range(N_FOLDS):
+        scaffolds = fold_assignments[fold_id]
+        count = fold_counts[fold_id]
+        percentage = 100 * count / len(df)
+        print(f"Fold {fold_id + 1}: {count:,} compounds ({percentage:.2f}%) | "
+              f"{len(scaffolds):,} scaffolds")
+    print("-" * 60)
+    print(f"Total: {sum(fold_counts):,} compounds")
+    
+    output_dir_path = os.path.join(os.path.dirname(__file__), OUTPUT_DIR)
+    os.makedirs(output_dir_path, exist_ok=True)
+    
+    # saving data
+    print(f"\nSaving folds to '{OUTPUT_DIR}' directory...")
+    fold_dataframes = {}
+    
+    for fold_id in range(N_FOLDS):
+        scaffolds_in_fold = set(fold_assignments[fold_id])
+        fold_mask = df['scaffold'].isin(scaffolds_in_fold)
+        fold_df = df[fold_mask].copy()
+        
+        fold_df_output = fold_df.drop(columns=['scaffold'])
+        
+        output_file = os.path.join(output_dir_path, 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_FOLDS):
+        for scaffold in fold_assignments[fold_id]:
+            scaffold_assignments_data.append({
+                'scaffold': scaffold,
+                'fold': fold_id + 1,
+                'compound_count': scaffold_sizes[scaffold]
+            })
+    
+    scaffold_assignments_df = pd.DataFrame(scaffold_assignments_data)
+    scaffold_assignments_df = scaffold_assignments_df.sort_values(['fold', 'compound_count'], 
+                                                                   ascending=[True, False])
+    
+    print(f"\nSaved scaffold assignments to: scaffold_assignments.csv")
+    print(f"Total scaffolds: {len(scaffold_assignments_df):,}")
+    print(f"Columns: scaffold, fold, compound_count")
+    
+    # create visualizations
+    create_visualizations(df, scaffold_sizes, fold_assignments, fold_counts, 
+                         fold_dataframes, output_dir_path)
+
+    scaffold_assignments_file = os.path.join(output_dir_path, "scaffold_assignments.csv")
+    scaffold_assignments_df.to_csv(scaffold_assignments_file, index=False)
+    
+    print("\nVerifying scaffold separation...")
+    all_fold_scaffolds = [set(fold_assignments[i]) for i in range(N_FOLDS)]
+    for i in range(N_FOLDS):
+        for j in range(i + 1, N_FOLDS):
+            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")
+            else:
+                print(f"No overlap between fold {i+1} and fold {j+1}")
+    
+    all_assigned = set()
+    for fold_id in range(N_FOLDS):
+        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")
+    
+    print("\n" + "=" * 60)
+    print("5-fold scaffold split completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
+

data/scripts/solvent_split.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+solvent_split.py
+
+Author: natelgrw
+Last Edited: 11/05/2025
+
+Performs spatial KMeans cluster splitting on AMAX solvent chemical space.
+Clusters solvents in 5 groups by similarity using UMAP + KMeans, then assigns compounds
+to folds based on their solvent's cluster membership.
+
+This ensures compounds are split by solvent similarity rather than 
+individual solvent identity.
+"""
+
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import random
+import os
+from collections import defaultdict
+import matplotlib.pyplot as plt
+import seaborn as sns
+import umap
+from sklearn.cluster import KMeans
+
+
+# ===== Configuration ===== #
+
+
+INPUT_CSV = "../amax_dataset.csv"
+OUTPUT_DIR = "../solvent_split"
+N_SOLVENT_CLUSTERS = 5
+RANDOM_SEED = 42
+
+random.seed(RANDOM_SEED)
+np.random.seed(RANDOM_SEED)
+
+
+# ===== Helper Functions ===== #
+
+
+def compute_solvent_fingerprints(unique_solvents):
+    """
+    Compute Morgan fingerprints for unique solvents.
+    """
+    fps = []
+    valid_solvents = []
+    
+    for solvent in unique_solvents:
+        try:
+            mol = Chem.MolFromSmiles(solvent)
+            if mol is not None:
+                fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+                fps.append(fp)
+                valid_solvents.append(solvent)
+        except Exception:
+            print(f"Warning: Could not process solvent {solvent}")
+            continue
+    
+    fps_array = np.array([list(fp) for fp in fps], dtype=np.float32)
+    solvent_to_idx = {solv: idx for idx, solv in enumerate(valid_solvents)}
+    
+    print(f"Valid solvents: {len(fps_array)}")
+    print(f"Fingerprint dimension: {fps_array.shape[1]}")
+    
+    return fps_array, valid_solvents, solvent_to_idx
+
+
+def compute_solvent_umap(solvent_fps):
+    """
+    Compute 2D UMAP embedding of solvent fingerprints using Jaccard metric.
+    Returns 2D coordinates for spatial clustering.
+    """
+    print("\nComputing 2D UMAP embedding of solvent space...")
+    fps_bin = (solvent_fps > 0).astype(float)
+    reducer = umap.UMAP(
+        n_neighbors=min(15, len(solvent_fps) - 1),
+        min_dist=0.1,
+        metric="jaccard",
+        random_state=RANDOM_SEED,
+    )
+    emb = reducer.fit_transform(fps_bin)
+    print(f"UMAP embedding computed: {emb.shape}")
+    return emb
+
+
+def cluster_solvents(solvent_umap_coords, valid_solvents, n_clusters):
+    """
+    Performs spatial KMeans clustering directly on solvent UMAP 2D coordinates.
+    """
+    print("\n" + "=" * 65)
+    print("Performing Spatial KMeans Clustering on Solvent UMAP Coordinates")
+    print("=" * 65)
+    
+    print(f"\nRunning KMeans with k={n_clusters} on solvent 2D UMAP coordinates...")
+    km = KMeans(n_clusters=n_clusters, random_state=RANDOM_SEED, n_init=20)
+    labels = km.fit_predict(solvent_umap_coords)
+    
+    print(f"\nSolvent cluster centroids:")
+    for i, centroid in enumerate(km.cluster_centers_):
+        print(f"  Cluster {i+1}: ({centroid[0]:.2f}, {centroid[1]:.2f})")
+    
+    solvent_to_cluster = {solvent: int(labels[idx]) 
+                          for idx, solvent in enumerate(valid_solvents)}
+    
+    print(f"\nSolvent cluster assignments:")
+    clusters = defaultdict(list)
+    for solvent, cluster in solvent_to_cluster.items():
+        clusters[cluster].append(solvent)
+    
+    for cluster_id in sorted(clusters.keys()):
+        solvents_in_cluster = clusters[cluster_id]
+        print(f"Cluster {cluster_id+1}: {len(solvents_in_cluster)} solvents")
+        for solv in sorted(solvents_in_cluster):
+            print(f"- {solv}")
+    
+    return solvent_to_cluster, labels, km
+
+
+def create_visualizations(df, cluster_folds, solvent_umap_coords, valid_solvents, 
+                         solvent_cluster_labels, solvent_to_cluster, output_dir_path):
+    """
+    Create visualizations for solvent cluster split analysis.
+    """
+    print("\n" + "=" * 65)
+    print("Generating Visualizations")
+    print("=" * 65)
+    
+    sns.set_style("whitegrid")
+    plt.rcParams['figure.dpi'] = 100
+    plt.rcParams['savefig.dpi'] = 300
+    
+    fig_dir = os.path.join(output_dir_path, "figures")
+    os.makedirs(fig_dir, exist_ok=True)
+    
+    n_clusters = len(cluster_folds)
+    colors = sns.color_palette("husl", n_clusters)
+    
+    if 'lambda_max' in df.columns:
+        print("\n1. Creating lambda_max distribution plot...")
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        for cluster_id in sorted(cluster_folds.keys()):
+            group_df = cluster_folds[cluster_id]
+            fold_label = f"Cluster {cluster_id+1} (n={len(group_df):,})"
+            sns.kdeplot(data=group_df, x='lambda_max', label=fold_label, 
+                       ax=ax, linewidth=2.5, color=colors[cluster_id])
+        
+        sns.kdeplot(data=df, x='lambda_max', label=f'Overall (n={len(df):,})', 
+                   ax=ax, linewidth=2, linestyle='--', color='black', alpha=0.7)
+        
+        ax.set_xlabel('λmax (nm)', fontsize=12, fontweight='bold')
+        ax.set_ylabel('Density', fontsize=12, fontweight='bold')
+        ax.set_title('Lambda Max Distribution Across Solvent Splits', 
+                    fontsize=14, fontweight='bold')
+        ax.legend(loc='best', frameon=True, shadow=True)
+        ax.grid(alpha=0.3)
+        
+        plt.tight_layout()
+        plt.savefig(os.path.join(fig_dir, 'solvent_lmax.png'), bbox_inches='tight')
+        print(f"Saved: figures/solvent_lmax.png")
+        plt.close()
+    
+    print("\n2. Creating solvent space UMAP visualization...")
+    
+    solvent_counts = df['solvent'].value_counts().to_dict()
+    
+    fig, ax = plt.subplots(figsize=(14, 10))
+    
+    for cluster_id in range(n_clusters):
+        cluster_solvents = [solv for solv, cid in solvent_to_cluster.items() if cid == cluster_id]
+        
+        cluster_indices = [valid_solvents.index(solv) for solv in cluster_solvents if solv in valid_solvents]
+        
+        if len(cluster_indices) > 0:
+            cluster_coords = solvent_umap_coords[cluster_indices]
+            
+            sizes = [np.log10(solvent_counts.get(valid_solvents[idx], 1) + 1) * 50 for idx in cluster_indices]
+            
+            ax.scatter(cluster_coords[:, 0], cluster_coords[:, 1],
+                      label=f'Cluster {cluster_id+1} ({len(cluster_solvents)} solvents)',
+                      alpha=0.7, s=sizes, color=colors[cluster_id], edgecolors='black', linewidth=0.5)
+    
+    ax.set_title('UMAP Projection of Chemical Solvent Space (Colored by Solvent Split)', 
+                fontsize=14, fontweight='bold')
+    ax.legend(loc='best', frameon=True, shadow=True, fontsize=10)
+    ax.grid(alpha=0.3)
+    
+    plt.tight_layout()
+    plt.savefig(os.path.join(fig_dir, 'solvent_umap.png'), bbox_inches='tight')
+    print(f"Saved: figures/solvent_umap.png")
+    plt.close()
+    
+    print(f"\nAll visualizations saved to: {os.path.join(output_dir_path, 'figures')}")
+
+
+# ===== Main ===== #
+
+
+def main():
+    """
+    Main function to perform spatial solvent cluster splitting.
+    """
+    print("=" * 65)
+    print("SPATIAL SOLVENT CLUSTER SPLITTING PIPELINE")
+    print("=" * 65)
+    print(f"Configuration:")
+    print(f"- Number of solvent clusters: {N_SOLVENT_CLUSTERS}")
+    print(f"- Random seed: {RANDOM_SEED}")
+    print(f"- Input: {INPUT_CSV}")
+    print(f"- Output: {OUTPUT_DIR}")
+    print()
+    
+    print("Step 1: Loading dataset...")
+    input_path = os.path.join(os.path.dirname(__file__), INPUT_CSV)
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+    
+    df = pd.read_csv(input_path)
+    
+    if 'solvent' not in df.columns:
+        raise ValueError("Dataset must contain 'solvent' column")
+    
+    print(f"Total compounds: {len(df):,}")
+    print(f"Columns: {df.columns.tolist()}")
+    
+    print(f"\nStep 2: Analyzing solvent distribution...")
+    solvent_counts = df['solvent'].value_counts()
+    print(f"Unique solvents: {len(solvent_counts):,}")
+    
+    distribution_data = []
+    for solvent, count in solvent_counts.items():
+        distribution_data.append({
+            'solvent': solvent,
+            'count': int(count),
+            'percentage': 100 * count / len(df)
+        })
+    
+    distribution_df = pd.DataFrame(distribution_data)
+    distribution_df = distribution_df.sort_values('count', ascending=False)
+    
+    print(f"\nTop 10 solvents by occurrence:")
+    for idx, row in distribution_df.head(10).iterrows():
+        print(f"{row['solvent']}: {row['count']:,} ({row['percentage']:.2f}%)")
+    
+    unique_solvents = df['solvent'].unique().tolist()
+    solvent_fps, valid_solvents, solvent_to_idx = compute_solvent_fingerprints(unique_solvents)
+    
+    print(f"\nStep 3: Computing UMAP on solvent space...")
+    solvent_umap_coords = compute_solvent_umap(solvent_fps)
+    
+    print(f"\nStep 4: Clustering solvents...")
+    solvent_to_cluster, solvent_cluster_labels, km = cluster_solvents(
+        solvent_umap_coords, valid_solvents, N_SOLVENT_CLUSTERS
+    )
+    
+    print(f"\nStep 5: Assigning compounds to solvent clusters...")
+    cluster_folds = defaultdict(list)
+    
+    for idx, row in df.iterrows():
+        solvent = row['solvent']
+        if solvent in solvent_to_cluster:
+            cluster_id = solvent_to_cluster[solvent]
+            cluster_folds[cluster_id].append(idx)
+        else:
+            print(f"Warning: Solvent '{solvent}' not found in valid solvents")
+    
+    cluster_dataframes = {}
+    for cluster_id, indices in cluster_folds.items():
+        cluster_dataframes[cluster_id] = df.loc[indices].copy()
+    
+    print(f"\nCluster summary:")
+    for cluster_id in sorted(cluster_dataframes.keys()):
+        n = len(cluster_dataframes[cluster_id])
+        p = 100 * n / len(df)
+        print(f"Cluster {cluster_id+1}: {n:,} compounds ({p:.2f}%)")
+    
+    output_dir_path = os.path.join(os.path.dirname(__file__), OUTPUT_DIR)
+    os.makedirs(output_dir_path, exist_ok=True)
+    
+    print(f"\nStep 6: Saving solvent cluster CSV files to '{OUTPUT_DIR}'...")
+    for cluster_id in sorted(cluster_dataframes.keys()):
+        output_file = os.path.join(output_dir_path, f"solvents_{cluster_id+1}.csv")
+        cluster_dataframes[cluster_id].to_csv(output_file, index=False)
+        print(f"Saved solvents_{cluster_id+1}.csv: {len(cluster_dataframes[cluster_id]):,} compounds")
+    
+    fig_dir = os.path.join(output_dir_path, "figures")
+    os.makedirs(fig_dir, exist_ok=True)
+    
+    print(f"\nStep 7: Creating enhanced solvent_distribution.csv...")
+
+    distribution_df['solvent_cluster'] = distribution_df['solvent'].map(
+        lambda s: solvent_to_cluster.get(s, -1)
+    )
+    distribution_df['solvent_cluster'] = distribution_df['solvent_cluster'].apply(
+        lambda c: f"Cluster {c+1}" if c >= 0 else "Unknown"
+    )
+    
+    distribution_file = os.path.join(fig_dir, "solvent_distribution.csv")
+    distribution_df.to_csv(distribution_file, index=False)
+    print(f"Saved figures/solvent_distribution.csv: {len(distribution_df):,} entries")
+    
+    print(f"\nStep 8: Creating visualizations...")
+    create_visualizations(
+        df, cluster_dataframes, solvent_umap_coords, valid_solvents, 
+        solvent_cluster_labels, solvent_to_cluster, output_dir_path
+    )
+    
+    print("\n" + "=" * 65)
+    print("SOLVENT CLUSTERING COMPLETE!")
+    print("=" * 65)
+    print(f"Output directory: {OUTPUT_DIR}")
+    print(f"- {len(cluster_dataframes)} solvent cluster CSV files (solvents_1.csv, solvents_2.csv, etc.)")
+    print(f"- figures/solvent_distribution.csv")
+    print(f"- figures/solvent_lmax.png")
+    print(f"- figures/solvent_umap.png (shows solvent chemical space)")
+
+
+if __name__ == "__main__":
+    main()
+

data/solvent_split/figures/solvent_distribution.csv

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

data/solvent_split/solvents_1.csv

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

data/solvent_split/solvents_2.csv

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

data/solvent_split/solvents_3.csv

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

data/solvent_split/solvents_4.csv

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

data/solvent_split/solvents_5.csv

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

data/solvents/README.md

@@ -1,6 +1,6 @@
 # 🧪 AMAX 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_descriptors.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:039a6b443b641b5b7874ac425922a548a49a597ed4f0630089cabf186b1922e3
-size 1091020
+oid sha256:e1b723c797883beef1b2d1735547dfede8363984a93824aa1ef6713569816756
+size 1066550