Initial upload: RNA-small molecule interaction prediction dataset with three evaluation scenarios

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+compound_ood/train_text.csv filter=lfs diff=lfs merge=lfs -text
+in_distribution/train_text.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,81 @@
+# DrugRNA Dataset
+
+This repository contains the RNA-small molecule interaction prediction dataset used in the paper "LLM Agents Enable RNA–Small Molecule Interaction Prediction at Performance Comparable to Human-Designed Models".
+
+## Dataset Description
+
+The dataset is derived from the RNAInter repository and contains experimentally validated RNA-compound interactions. It includes 45,049 RNA–compound pairs spanning 3,258 unique RNAs and 345 unique compounds, with a 1:4 positive/negative ratio.
+
+## Data Splits
+
+The dataset is organized into three evaluation scenarios:
+
+### 1. In-Distribution Split (`in_distribution/`)
+- **Purpose**: Standard 80/10/10 train/validation/test split for head-to-head performance comparison
+- **Characteristics**: Complete entity overlap, testing interpolation within known molecular space
+- **Files**:
+  - `train_text.csv` (36,040 samples, 20.0% positive)
+  - `val_text.csv` (4,504 samples, 19.8% positive)
+  - `test_text.csv` (4,505 samples, 20.2% positive)
+- **Total**: 45,049 samples with 3,258 unique RNAs and 345 unique compounds
+
+### 2. Full Out-of-Domain Split (`full_ood/`)
+- **Purpose**: Cold-start prediction with entirely novel entities
+- **Characteristics**: Zero overlap for both RNAs and compounds between training and test sets
+- **Files**:
+  - `train_text.csv` (21,794 samples, 18.4% positive)
+  - `val_text.csv` (1,081 samples, 22.1% positive)
+  - `test_text.csv` (1,020 samples, 24.2% positive)
+  - `DATASET_REPORT.md` (detailed statistics and construction methodology)
+- **Total**: 23,895 samples with 3,142 unique RNAs and 363 unique compounds
+
+### 3. Compound Out-of-Domain Split (`compound_ood/`)
+- **Purpose**: Virtual screening of novel compounds against known RNA targets
+- **Characteristics**: Zero compound overlap, complete RNA reuse (86% of training RNAs appear in test)
+- **Files**:
+  - `train_text.csv` (31,576 samples, 21.0% positive)
+  - `val_text.csv` (6,694 samples, 20.1% positive)
+  - `test_text.csv` (6,779 samples, 15.2% positive)
+  - `DATASET_REPORT.md` (detailed statistics and construction methodology)
+- **Total**: 45,049 samples with 3,258 unique RNAs and 345 unique compounds
+
+## Data Format
+
+Each CSV file contains the following columns:
+- `rna_id`: RNA identifier
+- `compound_id`: Compound identifier (PubChem CID)
+- `rna_sequence`: RNA nucleotide sequence (A, U, G, C)
+- `compound_smiles`: SMILES string representation of the compound
+- `label`: Binary interaction label (1 = interaction, 0 = no interaction)
+
+## Scripts
+
+The `scripts/` folder contains:
+- `create_disjoint_splits.py`: Script used to generate the out-of-domain splits with strict entity disjointness
+
+## Data Sources
+
+- **RNAs**: Mapped from NCBI, Ensembl, miRBase, and circBase
+- **Compounds**: Mapped from PubChem
+- **Interactions**: Curated from RNAInter repository with experimental evidence
+
+## Citation
+
+If you use this dataset in your research, please cite:
+
+```bibtex
+@article{drugrna2025,
+  title={LLM Agents Enable RNA–Small Molecule Interaction Prediction at Performance Comparable to Human-Designed Models},
+  author={...},
+  journal={...},
+  year={2025}
+}
+```
+
+## License
+
+This dataset is provided for research purposes. Please refer to the original data sources for specific licensing information.
+
+## Contact
+
+For questions or issues, please open an issue on the GitHub repository or contact the authors.

compound_ood/DATASET_REPORT.md

@@ -0,0 +1,47 @@
+# rna_inter_disjoint_compound Dataset Report
+
+## Overview
+Disjoint splits created from rna_inter (public RNA-compound interaction dataset).
+
+## Split Statistics
+
+### Sample Counts
+- Train: 31,576 samples (21.0% positive)
+- Val: 6,694 samples (20.1% positive)
+- Test: 6,779 samples (15.2% positive)
+- Total: 45,049 samples
+
+### Unique Entities
+
+#### Compounds
+- Train: 238
+- Val: 52
+- Test: 55
+
+#### RNAs
+- Train: 2,784
+- Val: 2,390
+- Test: 2,403
+
+## Disjointness Properties
+
+### Compound Disjointness
+- Train-Val compound overlap: 0
+- Train-Test compound overlap: 0
+- Val-Test compound overlap: 0
+
+### RNA Disjointness
+- Train-Val RNA overlap: 2390
+- Train-Test RNA overlap: 2403
+- Val-Test RNA overlap: 2065
+
+## Output Format
+Same as rna_inter:
+- Columns: RNA_ID, Compound_ID, RNA_seq, SMILES, text, label
+- Files: train_text.csv, val_text.csv, test_text.csv
+
+## Use Case
+This split tests the model's ability to generalize to:
+- New RNAs
+
+Date: 2025-10-27 16:16:05

compound_ood/train_text.csv

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

full_ood/DATASET_REPORT.md

@@ -0,0 +1,47 @@
+# rna_inter_disjoint Dataset Report
+
+## Overview
+Disjoint splits created from rna_inter (public RNA-compound interaction dataset).
+
+## Split Statistics
+
+### Sample Counts
+- Train: 21,794 samples (18.4% positive)
+- Val: 1,081 samples (22.1% positive)
+- Test: 1,020 samples (24.2% positive)
+- Total: 23,895 samples
+
+### Unique Entities
+
+#### Compounds
+- Train: 241
+- Val: 51
+- Test: 53
+
+#### RNAs
+- Train: 1,948
+- Val: 368
+- Test: 371
+
+## Disjointness Properties
+
+### Compound Disjointness
+- Train-Val compound overlap: 0
+- Train-Test compound overlap: 0
+- Val-Test compound overlap: 0
+
+### RNA Disjointness
+- Train-Val RNA overlap: 0
+- Train-Test RNA overlap: 0
+- Val-Test RNA overlap: 0
+
+## Output Format
+Same as rna_inter:
+- Columns: RNA_ID, Compound_ID, RNA_seq, SMILES, text, label
+- Files: train_text.csv, val_text.csv, test_text.csv
+
+## Use Case
+This split tests the model's ability to generalize to:
+- New RNAs
+
+Date: 2025-10-27 16:16:04

in_distribution/train_text.csv

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

scripts/create_disjoint_splits.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""
+Create disjoint splits from drug_rna_cds_sampled_11 dataset.
+
+Creates three datasets:
+1. drug_rna_cds_disjoint (fully disjoint if possible)
+2. drug_rna_cds_disjoint_rna (RNA-disjoint)
+3. drug_rna_cds_disjoint_compound (compound-disjoint)
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from collections import defaultdict
+import argparse
+
+
+def analyze_disjoint_feasibility(df):
+    """Analyze if fully disjoint split is feasible."""
+    print("=" * 80)
+    print("ANALYZING DISJOINT SPLIT FEASIBILITY")
+    print("=" * 80)
+
+    n_compounds = df['SMILES'].nunique()
+    n_rnas = df['RNA_seq'].nunique()
+    n_samples = len(df)
+
+    print(f"\nDataset statistics:")
+    print(f"  Total samples: {n_samples:,}")
+    print(f"  Unique compounds: {n_compounds:,}")
+    print(f"  Unique RNAs: {n_rnas:,}")
+
+    # Analyze compound-RNA pairs
+    pairs = df.groupby(['SMILES', 'RNA_seq']).size().reset_index(name='count')
+    print(f"  Unique (compound, RNA) pairs: {len(pairs):,}")
+
+    # Check samples per entity
+    samples_per_compound = df.groupby('SMILES').size()
+    samples_per_rna = df.groupby('RNA_seq').size()
+
+    print(f"\n  Samples per compound: mean={samples_per_compound.mean():.1f}, median={samples_per_compound.median():.1f}")
+    print(f"  Samples per RNA: mean={samples_per_rna.mean():.1f}, median={samples_per_rna.median():.1f}")
+
+    # Estimate fully disjoint feasibility
+    # For fully disjoint: need non-overlapping sets of (compound, RNA) pairs
+    # This is only possible if we can partition compounds and RNAs
+
+    # Simple heuristic: check if we have enough samples
+    min_samples_needed = int(0.15 * n_samples)  # For test set (15%)
+
+    print(f"\n  Minimum samples needed for test (15%): {min_samples_needed:,}")
+
+    # Check if we can allocate compounds/RNAs
+    n_compounds_test = int(0.15 * n_compounds)
+    n_rnas_test = int(0.15 * n_rnas)
+
+    print(f"  If we allocate 15% of compounds: {n_compounds_test} compounds")
+    print(f"  If we allocate 15% of RNAs: {n_rnas_test} RNAs")
+    print(f"  Max possible samples (all pairs): {n_compounds_test * n_rnas_test:,}")
+
+    # Check actual connectivity
+    compound_to_rnas = df.groupby('SMILES')['RNA_seq'].apply(set).to_dict()
+    rna_to_compounds = df.groupby('RNA_seq')['SMILES'].apply(set).to_dict()
+
+    # Calculate how connected the graph is
+    avg_rnas_per_compound = df.groupby('SMILES')['RNA_seq'].nunique().mean()
+    avg_compounds_per_rna = df.groupby('RNA_seq')['SMILES'].nunique().mean()
+
+    print(f"\n  Connectivity:")
+    print(f"    Avg RNAs per compound: {avg_rnas_per_compound:.1f}")
+    print(f"    Avg compounds per RNA: {avg_compounds_per_rna:.1f}")
+
+    # Determine feasibility
+    fully_disjoint_feasible = (n_compounds_test * n_rnas_test >= min_samples_needed)
+
+    print(f"\n  Fully disjoint split feasible: {'YES' if fully_disjoint_feasible else 'NO'}")
+
+    return fully_disjoint_feasible
+
+
+def create_fully_disjoint_split(df, train_ratio=0.7, val_ratio=0.15, seed=42):
+    """Create fully disjoint split (compounds AND RNAs don't overlap)."""
+    print("\n" + "=" * 80)
+    print("CREATING FULLY DISJOINT SPLIT")
+    print("=" * 80)
+
+    np.random.seed(seed)
+
+    # Get unique entities
+    compounds = df['SMILES'].unique()
+    rnas = df['RNA_seq'].unique()
+
+    # Shuffle
+    np.random.shuffle(compounds)
+    np.random.shuffle(rnas)
+
+    # Split compounds
+    n_compounds = len(compounds)
+    n_train_comp = int(train_ratio * n_compounds)
+    n_val_comp = int(val_ratio * n_compounds)
+
+    train_compounds = set(compounds[:n_train_comp])
+    val_compounds = set(compounds[n_train_comp:n_train_comp + n_val_comp])
+    test_compounds = set(compounds[n_train_comp + n_val_comp:])
+
+    # Split RNAs
+    n_rnas = len(rnas)
+    n_train_rna = int(train_ratio * n_rnas)
+    n_val_rna = int(val_ratio * n_rnas)
+
+    train_rnas = set(rnas[:n_train_rna])
+    val_rnas = set(rnas[n_train_rna:n_train_rna + n_val_rna])
+    test_rnas = set(rnas[n_train_rna + n_val_rna:])
+
+    # Assign samples based on BOTH compound and RNA membership
+    train_df = df[(df['SMILES'].isin(train_compounds)) & (df['RNA_seq'].isin(train_rnas))].copy()
+    val_df = df[(df['SMILES'].isin(val_compounds)) & (df['RNA_seq'].isin(val_rnas))].copy()
+    test_df = df[(df['SMILES'].isin(test_compounds)) & (df['RNA_seq'].isin(test_rnas))].copy()
+
+    print(f"\n  Allocated:")
+    print(f"    Train: {len(train_compounds)} compounds, {len(train_rnas)} RNAs → {len(train_df)} samples")
+    print(f"    Val:   {len(val_compounds)} compounds, {len(val_rnas)} RNAs → {len(val_df)} samples")
+    print(f"    Test:  {len(test_compounds)} compounds, {len(test_rnas)} RNAs → {len(test_df)} samples")
+
+    total_samples = len(train_df) + len(val_df) + len(test_df)
+    print(f"\n  Total samples retained: {total_samples:,} / {len(df):,} ({100*total_samples/len(df):.1f}%)")
+
+    if total_samples < 0.5 * len(df):
+        print(f"\n  ⚠️  Warning: Lost {100*(1-total_samples/len(df)):.1f}% of samples")
+        print(f"      Fully disjoint split may not be practical for this dataset")
+        return None
+
+    return train_df, val_df, test_df
+
+
+def create_rna_disjoint_split(df, train_ratio=0.7, val_ratio=0.15, seed=42):
+    """Create RNA-disjoint split (RNAs don't overlap across splits)."""
+    print("\n" + "=" * 80)
+    print("CREATING RNA-DISJOINT SPLIT (Target: 70:15:15)")
+    print("=" * 80)
+
+    np.random.seed(seed)
+
+    # Get RNAs with their sample counts
+    rna_counts = df.groupby('RNA_seq').size().reset_index(name='count')
+    rna_counts = rna_counts.sample(frac=1, random_state=seed).reset_index(drop=True)  # Shuffle
+
+    # Target sample counts
+    total_samples = len(df)
+    target_train = int(train_ratio * total_samples)
+    target_val = int(val_ratio * total_samples)
+    target_test = total_samples - target_train - target_val
+
+    print(f"\n  Target sample distribution:")
+    print(f"    Train: {target_train:,} ({train_ratio*100:.0f}%)")
+    print(f"    Val:   {target_val:,} ({val_ratio*100:.0f}%)")
+    print(f"    Test:  {target_test:,} ({(1-train_ratio-val_ratio)*100:.0f}%)")
+
+    # Greedy assignment: assign RNAs to splits to match target ratios
+    train_rnas = []
+    val_rnas = []
+    test_rnas = []
+
+    train_count = 0
+    val_count = 0
+    test_count = 0
+
+    for _, row in rna_counts.iterrows():
+        rna = row['RNA_seq']
+        count = row['count']
+
+        # Assign to the split that needs samples most
+        train_deficit = target_train - train_count
+        val_deficit = target_val - val_count
+        test_deficit = target_test - test_count
+
+        if train_deficit >= val_deficit and train_deficit >= test_deficit:
+            train_rnas.append(rna)
+            train_count += count
+        elif val_deficit >= test_deficit:
+            val_rnas.append(rna)
+            val_count += count
+        else:
+            test_rnas.append(rna)
+            test_count += count
+
+    train_rnas = set(train_rnas)
+    val_rnas = set(val_rnas)
+    test_rnas = set(test_rnas)
+
+    # Assign samples based on RNA
+    train_df = df[df['RNA_seq'].isin(train_rnas)].copy()
+    val_df = df[df['RNA_seq'].isin(val_rnas)].copy()
+    test_df = df[df['RNA_seq'].isin(test_rnas)].copy()
+
+    print(f"\n  Split RNAs:")
+    print(f"    Train: {len(train_rnas)} RNAs ({len(train_df):,} samples, {100*len(train_df)/len(df):.1f}%)")
+    print(f"    Val:   {len(val_rnas)} RNAs ({len(val_df):,} samples, {100*len(val_df)/len(df):.1f}%)")
+    print(f"    Test:  {len(test_rnas)} RNAs ({len(test_df):,} samples, {100*len(test_df)/len(df):.1f}%)")
+
+    # Verify disjointness
+    assert len(train_rnas & val_rnas) == 0, "Train and val RNAs overlap!"
+    assert len(train_rnas & test_rnas) == 0, "Train and test RNAs overlap!"
+    assert len(val_rnas & test_rnas) == 0, "Val and test RNAs overlap!"
+
+    print(f"\n  ✓ RNA-disjoint verified: no RNA overlap across splits")
+
+    # Check compound overlap (expected)
+    train_compounds = set(train_df['SMILES'].unique())
+    val_compounds = set(val_df['SMILES'].unique())
+    test_compounds = set(test_df['SMILES'].unique())
+
+    overlap_train_val = len(train_compounds & val_compounds)
+    overlap_train_test = len(train_compounds & test_compounds)
+
+    print(f"\n  Compound overlap (expected):")
+    print(f"    Train-Val: {overlap_train_val} compounds")
+    print(f"    Train-Test: {overlap_train_test} compounds")
+
+    return train_df, val_df, test_df
+
+
+def create_compound_disjoint_split(df, train_ratio=0.7, val_ratio=0.15, seed=42):
+    """Create compound-disjoint split (compounds don't overlap across splits)."""
+    print("\n" + "=" * 80)
+    print("CREATING COMPOUND-DISJOINT SPLIT (Target: 70:15:15)")
+    print("=" * 80)
+
+    np.random.seed(seed)
+
+    # Get compounds with their sample counts
+    compound_counts = df.groupby('SMILES').size().reset_index(name='count')
+    compound_counts = compound_counts.sample(frac=1, random_state=seed).reset_index(drop=True)  # Shuffle
+
+    # Target sample counts
+    total_samples = len(df)
+    target_train = int(train_ratio * total_samples)
+    target_val = int(val_ratio * total_samples)
+    target_test = total_samples - target_train - target_val
+
+    print(f"\n  Target sample distribution:")
+    print(f"    Train: {target_train:,} ({train_ratio*100:.0f}%)")
+    print(f"    Val:   {target_val:,} ({val_ratio*100:.0f}%)")
+    print(f"    Test:  {target_test:,} ({(1-train_ratio-val_ratio)*100:.0f}%)")
+
+    # Greedy assignment: assign compounds to splits to match target ratios
+    train_compounds = []
+    val_compounds = []
+    test_compounds = []
+
+    train_count = 0
+    val_count = 0
+    test_count = 0
+
+    for _, row in compound_counts.iterrows():
+        compound = row['SMILES']
+        count = row['count']
+
+        # Assign to the split that needs samples most
+        train_deficit = target_train - train_count
+        val_deficit = target_val - val_count
+        test_deficit = target_test - test_count
+
+        if train_deficit >= val_deficit and train_deficit >= test_deficit:
+            train_compounds.append(compound)
+            train_count += count
+        elif val_deficit >= test_deficit:
+            val_compounds.append(compound)
+            val_count += count
+        else:
+            test_compounds.append(compound)
+            test_count += count
+
+    train_compounds = set(train_compounds)
+    val_compounds = set(val_compounds)
+    test_compounds = set(test_compounds)
+
+    # Assign samples based on compound
+    train_df = df[df['SMILES'].isin(train_compounds)].copy()
+    val_df = df[df['SMILES'].isin(val_compounds)].copy()
+    test_df = df[df['SMILES'].isin(test_compounds)].copy()
+
+    print(f"\n  Split compounds:")
+    print(f"    Train: {len(train_compounds)} compounds ({len(train_df):,} samples, {100*len(train_df)/len(df):.1f}%)")
+    print(f"    Val:   {len(val_compounds)} compounds ({len(val_df):,} samples, {100*len(val_df)/len(df):.1f}%)")
+    print(f"    Test:  {len(test_compounds)} compounds ({len(test_df):,} samples, {100*len(test_df)/len(df):.1f}%)")
+
+    # Verify disjointness
+    assert len(train_compounds & val_compounds) == 0, "Train and val compounds overlap!"
+    assert len(train_compounds & test_compounds) == 0, "Train and test compounds overlap!"
+    assert len(val_compounds & test_compounds) == 0, "Val and test compounds overlap!"
+
+    print(f"\n  ✓ Compound-disjoint verified: no compound overlap across splits")
+
+    # Check RNA overlap (expected)
+    train_rnas = set(train_df['RNA_seq'].unique())
+    val_rnas = set(val_df['RNA_seq'].unique())
+    test_rnas = set(test_df['RNA_seq'].unique())
+
+    overlap_train_val = len(train_rnas & val_rnas)
+    overlap_train_test = len(train_rnas & test_rnas)
+
+    print(f"\n  RNA overlap (expected):")
+    print(f"    Train-Val: {overlap_train_val} RNAs")
+    print(f"    Train-Test: {overlap_train_test} RNAs")
+
+    return train_df, val_df, test_df
+
+
+def save_splits(train_df, val_df, test_df, output_dir, dataset_name):
+    """Save splits to files."""
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # Save CSV files
+    train_df.to_csv(output_path / 'train_text.csv', index=False)
+    val_df.to_csv(output_path / 'val_text.csv', index=False)
+    test_df.to_csv(output_path / 'test_text.csv', index=False)
+
+    # Create report
+    report = f"""# {dataset_name} Dataset Report
+
+## Overview
+Disjoint splits created from drug_rna_cds_sampled_11 dataset.
+
+## Split Statistics
+
+### Sample Counts
+- Train: {len(train_df):,} samples ({100*train_df['label'].mean():.1f}% positive)
+- Val: {len(val_df):,} samples ({100*val_df['label'].mean():.1f}% positive)
+- Test: {len(test_df):,} samples ({100*test_df['label'].mean():.1f}% positive)
+- Total: {len(train_df) + len(val_df) + len(test_df):,} samples
+
+### Unique Entities
+
+#### Compounds
+- Train: {train_df['SMILES'].nunique():,}
+- Val: {val_df['SMILES'].nunique():,}
+- Test: {test_df['SMILES'].nunique():,}
+
+#### RNAs
+- Train: {train_df['RNA_seq'].nunique():,}
+- Val: {val_df['RNA_seq'].nunique():,}
+- Test: {test_df['RNA_seq'].nunique():,}
+
+## Disjointness Properties
+
+### Compound Disjointness
+- Train-Val compound overlap: {len(set(train_df['SMILES'].unique()) & set(val_df['SMILES'].unique()))}
+- Train-Test compound overlap: {len(set(train_df['SMILES'].unique()) & set(test_df['SMILES'].unique()))}
+- Val-Test compound overlap: {len(set(val_df['SMILES'].unique()) & set(test_df['SMILES'].unique()))}
+
+### RNA Disjointness
+- Train-Val RNA overlap: {len(set(train_df['RNA_seq'].unique()) & set(val_df['RNA_seq'].unique()))}
+- Train-Test RNA overlap: {len(set(train_df['RNA_seq'].unique()) & set(test_df['RNA_seq'].unique()))}
+- Val-Test RNA overlap: {len(set(val_df['RNA_seq'].unique()) & set(test_df['RNA_seq'].unique()))}
+
+## Output Format
+Same as drug_rna_cds_sampled_11:
+- Columns: RNA_ID, Compound_ID, RNA_seq, SMILES, text, label
+- Files: train_text.csv, val_text.csv, test_text.csv
+
+## Use Case
+This split tests the model's ability to generalize to:
+- {'New compounds AND new RNAs' if 'disjoint' in dataset_name and 'rna' not in dataset_name and 'compound' not in dataset_name else 'New RNAs' if 'rna' in dataset_name else 'New compounds' if 'compound' in dataset_name else 'New samples'}
+
+Date: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+
+    with open(output_path / 'DATASET_REPORT.md', 'w') as f:
+        f.write(report)
+
+    print(f"\n  Saved to: {output_path}")
+    print(f"    - train_text.csv")
+    print(f"    - val_text.csv")
+    print(f"    - test_text.csv")
+    print(f"    - DATASET_REPORT.md")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create disjoint splits from drug_rna_cds_sampled_11"
+    )
+    parser.add_argument(
+        '--input',
+        default='datasets/drug_rna_cds_sampled_11',
+        help='Input dataset directory'
+    )
+    parser.add_argument(
+        '--seed',
+        type=int,
+        default=42,
+        help='Random seed'
+    )
+
+    args = parser.parse_args()
+
+    print("=" * 80)
+    print("CREATING DISJOINT SPLITS FROM drug_rna_cds_sampled_11")
+    print("=" * 80)
+
+    # Load data
+    input_path = Path(args.input)
+
+    # Combine all splits from source
+    dfs = []
+    for split in ['train', 'val', 'test']:
+        csv_path = input_path / f'{split}_text.csv'
+        if csv_path.exists():
+            dfs.append(pd.read_csv(csv_path))
+
+    df = pd.concat(dfs, ignore_index=True)
+    print(f"\nLoaded {len(df):,} samples from {input_path}")
+
+    # Analyze feasibility
+    fully_disjoint_feasible = analyze_disjoint_feasibility(df)
+
+    # 1. Try fully disjoint
+    if fully_disjoint_feasible:
+        print("\n" + "#" * 80)
+        print("# CREATING: drug_rna_cds_disjoint (FULLY DISJOINT)")
+        print("#" * 80)
+
+        result = create_fully_disjoint_split(df, seed=args.seed)
+        if result is not None:
+            train_df, val_df, test_df = result
+            save_splits(
+                train_df, val_df, test_df,
+                'datasets/drug_rna_cds_disjoint',
+                'drug_rna_cds_disjoint'
+            )
+        else:
+            print("\n  ⚠️  Skipping fully disjoint split - not practical for this dataset")
+    else:
+        print("\n  ⚠️  Skipping fully disjoint split - not enough samples")
+
+    # 2. Create RNA-disjoint
+    print("\n" + "#" * 80)
+    print("# CREATING: drug_rna_cds_disjoint_rna (RNA-DISJOINT)")
+    print("#" * 80)
+
+    train_df, val_df, test_df = create_rna_disjoint_split(df, seed=args.seed)
+    save_splits(
+        train_df, val_df, test_df,
+        'datasets/drug_rna_cds_disjoint_rna',
+        'drug_rna_cds_disjoint_rna'
+    )
+
+    # 3. Create compound-disjoint
+    print("\n" + "#" * 80)
+    print("# CREATING: drug_rna_cds_disjoint_compound (COMPOUND-DISJOINT)")
+    print("#" * 80)
+
+    train_df, val_df, test_df = create_compound_disjoint_split(df, seed=args.seed)
+    save_splits(
+        train_df, val_df, test_df,
+        'datasets/drug_rna_cds_disjoint_compound',
+        'drug_rna_cds_disjoint_compound'
+    )
+
+    print("\n" + "=" * 80)
+    print("ALL DISJOINT SPLITS CREATED SUCCESSFULLY")
+    print("=" * 80)
+    print("\nCreated datasets:")
+    if fully_disjoint_feasible:
+        print("  1. drug_rna_cds_disjoint - Fully disjoint (compounds AND RNAs)")
+    print("  2. drug_rna_cds_disjoint_rna - RNA-disjoint")
+    print("  3. drug_rna_cds_disjoint_compound - Compound-disjoint")
+
+
+if __name__ == "__main__":
+    main()