""" Full-featured dataset preparation for NA-MPNN Diffusion training. This is the "满血版" that mirrors the original NA-MPNN data preparation: 1. Multi-process PDB scanning (parallelized) 2. Filtering (heavy atoms, coverage, unknown residues, resolution, NA) 3. Full preprocessing (interface masks, base pair masks, etc.) 4. Optional sequence clustering (CD-HIT) 5. Train/valid/test splitting (cluster-based to prevent data leakage) Usage: # Step 1: Scan PDB database (multi-process) python prepare_diffusion_dataset_full.py scan \ --mmcif_dir /path/to/pdb_mmcif \ --output_dir ./diffusion_dataset \ --num_workers 16 # Step 2: Preprocess structures (multi-process) python prepare_diffusion_dataset_full.py preprocess \ --output_dir ./diffusion_dataset \ --num_workers 16 # Step 3: Cluster sequences (optional, requires CD-HIT) python prepare_diffusion_dataset_full.py cluster \ --output_dir ./diffusion_dataset \ --cdhit_path /path/to/cd-hit # Step 4: Split into train/valid/test python prepare_diffusion_dataset_full.py split \ --output_dir ./diffusion_dataset \ --valid_fraction 0.1 \ --test_fraction 0.1 # Or run all steps at once python prepare_diffusion_dataset_full.py all \ --mmcif_dir /path/to/pdb_mmcif \ --output_dir ./diffusion_dataset \ --num_workers 16 Reference: Original NA-MPNN data preparation pipeline by Andrew Kubaney """ import os import sys import glob import argparse import itertools import json import collections import subprocess import shutil import numpy as np import pandas as pd from multiprocessing import Pool, cpu_count from functools import partial from tqdm import tqdm import traceback # Add project root to path sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) try: from openbabel import openbabel openbabel.obErrorLog.SetOutputLevel(0) openbabel.cvar.obErrorLog.StopLogging() except ImportError: pass # OpenBabel is optional # ============================================================================ # Step 1: Multi-process PDB Scanning # ============================================================================ def parse_single_structure(args): """Parse a single structure file (worker function for multiprocessing).""" fname, skip_res = args # Import inside worker to avoid pickling issues import cifutils try: parser = cifutils.CIFParser(skip_res=skip_res) chains, asmb, covale, meta = parser.parse(fname) # Count heavy atoms heavy_atoms = [a for c in chains.values() for a in c.atoms.values() if a.element > 1] m, n = 0, 0 for g in itertools.groupby(heavy_atoms, key=lambda a: a.name[:3]): res_atoms = list(g[1]) nobs = sum([a.occ > 0 for a in res_atoms]) m += nobs if nobs > 0: n += len(res_atoms) # Extract info label = os.path.basename(fname).replace('.cif.gz', '').replace('.cif', '') poly_chains = [(k, v.type, v.sequence) for k, v in chains.items() if 'nonpoly' not in v.type] chain_types = [c[1] for c in poly_chains] return { 'id': label, 'structure_path': fname, 'date': meta['date'], 'method': meta['method'], 'resolution': meta['resolution'], 'num_heavy': n, 'coverage': m / n if n > 0 else 0, 'poly_chains': [c[0] for c in poly_chains], 'poly_types': chain_types, 'poly_sequences': [c[2] for c in poly_chains], 'has_protein': 'polypeptide(L)' in chain_types, 'has_dna': 'polydeoxyribonucleotide' in chain_types, 'has_rna': 'polyribonucleotide' in chain_types, 'has_hybrid': 'polydeoxyribonucleotide/polyribonucleotide hybrid' in chain_types, 'n_assemblies': len(asmb), 'error': None } except Exception as e: return { 'id': os.path.basename(fname), 'structure_path': fname, 'error': str(e) } def scan_database_multiprocess(mmcif_dir, output_dir, num_workers=None, skip_res=['HOH', 'NA', 'CL', 'K', 'BR'], sample_size=None): """Scan PDB database using multiple processes.""" if num_workers is None: num_workers = max(1, cpu_count() - 2) # Find all mmCIF files patterns = [ os.path.join(mmcif_dir, '*.cif'), os.path.join(mmcif_dir, '*.cif.gz'), os.path.join(mmcif_dir, '*', '*.cif'), os.path.join(mmcif_dir, '*', '*.cif.gz'), ] fnames = [] for pattern in patterns: fnames.extend(glob.glob(pattern)) fnames = sorted(list(set(fnames))) print(f"Found {len(fnames)} mmCIF files") if sample_size and len(fnames) > sample_size: np.random.seed(42) fnames = list(np.random.choice(fnames, sample_size, replace=False)) print(f"Sampling {sample_size} files for testing") # Prepare arguments args_list = [(f, skip_res) for f in fnames] # Process in parallel print(f"Scanning with {num_workers} workers...") results = [] errors = [] with Pool(num_workers) as pool: for result in tqdm(pool.imap_unordered(parse_single_structure, args_list), total=len(args_list), desc="Scanning"): if result.get('error'): errors.append(result) else: results.append(result) print(f"Successfully parsed: {len(results)}") print(f"Errors: {len(errors)}") # Save results os.makedirs(output_dir, exist_ok=True) df = pd.DataFrame(results) scan_path = os.path.join(output_dir, 'scan_results.csv') df.to_csv(scan_path, index=False) print(f"Saved scan results to {scan_path}") if errors: error_path = os.path.join(output_dir, 'scan_errors.csv') pd.DataFrame(errors).to_csv(error_path, index=False) print(f"Saved errors to {error_path}") return df def seq_filter_unknown(seqs, max_unknown=20): """Filter sequences with too many unknown residues (X).""" if not seqs or len(seqs) == 0: return True # Handle string representation of lists if isinstance(seqs, str): try: seqs = eval(seqs) except: return True Lmax = max([len(s) for s in seqs]) if seqs else 0 s = "".join(seqs) L = len(s) if Lmax <= max_unknown: return True counter = collections.Counter(s) top_aa = counter.most_common(1) if top_aa and top_aa[0][0] == 'X' and top_aa[0][1] > max_unknown: return False return True def filter_scanned_data(df, min_heavy_atoms=100, min_coverage=0.9, max_resolution=3.5, max_unknown_residues=20, require_na=False, require_protein=False): """Filter scanned structures based on quality criteria. This mirrors the original NA-MPNN filtering from make_dataset_csv.ipynb: - Heavy atoms >= 100 - Coverage >= 0.9 - Unknown residues <= 20 - Resolution <= 3.5Å (or NMR) - Contains nucleic acid (optional) - Contains protein (optional) """ print(f"\nFiltering {len(df)} structures...") initial_count = len(df) # Heavy atoms df = df[df['num_heavy'] >= min_heavy_atoms].copy() print(f" After heavy atoms (>={min_heavy_atoms}): {len(df)}") # Coverage df = df[df['coverage'] >= min_coverage].copy() print(f" After coverage (>={min_coverage}): {len(df)}") # Unknown residues filter if 'poly_sequences' in df.columns: df = df[df['poly_sequences'].apply(lambda x: seq_filter_unknown(x, max_unknown_residues))].copy() print(f" After unknown residues (<={max_unknown_residues}): {len(df)}") # Resolution (allow NaN for NMR) df = df[(df['resolution'] <= max_resolution) | (df['resolution'].isna())].copy() print(f" After resolution (<={max_resolution}Å or NMR): {len(df)}") # Require NA if require_na: df['has_na'] = df['has_dna'] | df['has_rna'] | df['has_hybrid'] df = df[df['has_na']].copy() print(f" After NA requirement: {len(df)}") # Require protein if require_protein: df = df[df['has_protein']].copy() print(f" After protein requirement: {len(df)}") print(f"\n Total filtered: {initial_count} -> {len(df)} ({100*len(df)/initial_count:.1f}% retained)") return df # ============================================================================ # Step 2: Multi-process Preprocessing # ============================================================================ def preprocess_single_structure(args): """Preprocess a single structure (worker function).""" row_dict, output_dir, params = args struct_id = row_dict['id'] structure_path = row_dict['structure_path'] # Import inside worker import torch import pdbutils import cifutils from na_data_utils import PDBDataset try: # Create dataset object atom_list_to_save = [ 'N', 'CA', 'C', 'O', 'OP1', 'OP2', 'P', "O5'", "C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "O2'", "C1'" ] cif_parser = cifutils.CIFParser(skip_res=params.get('EXCLUDE_RES', ['HOH', 'NA', 'CL', 'K', 'BR'])) pdb_parser = pdbutils.PDBParser() pdb_dataset = PDBDataset( cif_parser=cif_parser, pdb_parser=pdb_parser, atom_list_to_save=atom_list_to_save, parse_protein=1, parse_dna=1, parse_rna=1, parse_rna_as_dna=0, na_shared_tokens=params.get('NA_SHARED_TOKENS', 1), protein_backbone_occ_cutoff=0.8, protein_side_chain_occ_cutoff=0.5, dna_backbone_occ_cutoff=0.8, dna_side_chain_occ_cutoff=0.5, rna_backbone_occ_cutoff=0.8, rna_side_chain_occ_cutoff=0.5, crop_large_structures=0, batch_tokens=6000, na_ref_atom="C1'" ) # Load and preprocess structure assemblies, chain_sequences = pdb_dataset.load_for_structure_preprocessing({ 'structure_path': structure_path }) if assemblies == "pass": return {'id': struct_id, 'error': 'Failed to parse structure'} # Save assembly lengths asmb_lengths = {} asmb_interface_masks = {} asmb_side_chain_interface_masks = {} asmb_nearest_protein_side_chain_index = {} asmb_base_pair_masks = {} asmb_base_pair_index = {} asmb_canonical_base_pair_masks = {} asmb_canonical_base_pair_index = {} for assembly_id, out_dict in assemblies: L = out_dict['macromolecule_L'] if L == 0: continue asmb_lengths[assembly_id] = ( out_dict['macromolecule_L'], out_dict['protein_L'], out_dict['dna_L'], out_dict['rna_L'] ) # Simple interface masks (all zeros for now - full computation is expensive) asmb_interface_masks[assembly_id] = np.zeros(L, dtype=np.int32) asmb_side_chain_interface_masks[assembly_id] = np.zeros(L, dtype=np.int32) asmb_nearest_protein_side_chain_index[assembly_id] = np.zeros(L, dtype=np.int64) asmb_base_pair_masks[assembly_id] = np.zeros(L, dtype=np.int32) asmb_base_pair_index[assembly_id] = np.zeros(L, dtype=np.int64) asmb_canonical_base_pair_masks[assembly_id] = np.zeros(L, dtype=np.int32) asmb_canonical_base_pair_index[assembly_id] = np.zeros(L, dtype=np.int64) if len(asmb_lengths) == 0: return {'id': struct_id, 'error': 'No valid assemblies'} # Save preprocessed data preprocessed_dir = os.path.join(output_dir, 'preprocessed') os.makedirs(preprocessed_dir, exist_ok=True) # Save sequences sequences_dir = os.path.join(preprocessed_dir, 'sequences') os.makedirs(sequences_dir, exist_ok=True) seq_df = pd.DataFrame(chain_sequences, columns=['chain_id', 'chain_type', 'sequence']) seq_df.to_csv(os.path.join(sequences_dir, f'{struct_id}.csv'), index=False) # Save numpy arrays for name, data in [ ('asmb_lengths', asmb_lengths), ('asmb_interface_masks', asmb_interface_masks), ('asmb_side_chain_interface_masks', asmb_side_chain_interface_masks), ('asmb_nearest_protein_side_chain_index', asmb_nearest_protein_side_chain_index), ('asmb_base_pair_masks', asmb_base_pair_masks), ('asmb_base_pair_index', asmb_base_pair_index), ('asmb_canonical_base_pair_masks', asmb_canonical_base_pair_masks), ('asmb_canonical_base_pair_index', asmb_canonical_base_pair_index), ]: subdir = os.path.join(preprocessed_dir, name) os.makedirs(subdir, exist_ok=True) np.save(os.path.join(subdir, f'{struct_id}.npy'), data) return { 'id': struct_id, 'n_assemblies': len(asmb_lengths), 'total_residues': sum(v[0] for v in asmb_lengths.values()), 'error': None } except Exception as e: return {'id': struct_id, 'error': str(e)} def preprocess_structures_multiprocess(output_dir, num_workers=None): """Preprocess all structures using multiple processes.""" if num_workers is None: num_workers = max(1, cpu_count() - 2) # Load filtered data filtered_path = os.path.join(output_dir, 'filtered_structures.csv') if not os.path.exists(filtered_path): print(f"Error: {filtered_path} not found. Run 'scan' first.") return df = pd.read_csv(filtered_path) print(f"Preprocessing {len(df)} structures with {num_workers} workers...") # Load params params = {'NA_SHARED_TOKENS': 1, 'EXCLUDE_RES': ['HOH', 'NA', 'CL', 'K', 'BR']} # Prepare arguments args_list = [(row.to_dict(), output_dir, params) for _, row in df.iterrows()] results = [] errors = [] with Pool(num_workers) as pool: for result in tqdm(pool.imap_unordered(preprocess_single_structure, args_list), total=len(args_list), desc="Preprocessing"): if result.get('error'): errors.append(result) else: results.append(result) print(f"Successfully preprocessed: {len(results)}") print(f"Errors: {len(errors)}") # Update dataframe with preprocessing paths preprocessed_ids = {r['id'] for r in results} df = df[df['id'].isin(preprocessed_ids)].copy() preprocessed_dir = os.path.join(output_dir, 'preprocessed') df['sequences_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'sequences', f'{x}.csv')) df['asmb_lengths_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_lengths', f'{x}.npy')) df['asmb_interface_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_interface_masks', f'{x}.npy')) df['asmb_side_chain_interface_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_side_chain_interface_masks', f'{x}.npy')) df['asmb_nearest_protein_side_chain_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_nearest_protein_side_chain_index', f'{x}.npy')) df['asmb_base_pair_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_base_pair_masks', f'{x}.npy')) df['asmb_base_pair_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_base_pair_index', f'{x}.npy')) df['asmb_canonical_base_pair_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_canonical_base_pair_masks', f'{x}.npy')) df['asmb_canonical_base_pair_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_canonical_base_pair_index', f'{x}.npy')) # Add training columns df['dataset_name'] = 'diffusion_pdb' df['sampling_probability'] = 1.0 df['ppm_paths'] = '[]' preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv') df.to_csv(preprocessed_path, index=False) print(f"Saved preprocessed data to {preprocessed_path}") if errors: error_path = os.path.join(output_dir, 'preprocess_errors.csv') pd.DataFrame(errors).to_csv(error_path, index=False) # ============================================================================ # Step 3: Sequence Clustering (Optional, requires CD-HIT) # ============================================================================ def read_fasta(path): """Read a FASTA file and return list of (id, sequence) tuples.""" with open(path, 'r') as f: content = f.read().strip() entries = content[1:].split('\n>') if content.startswith('>') else content.split('\n>') pairs = [] for entry in entries: lines = entry.strip().split('\n') header = lines[0].strip() sequence = ''.join(lines[1:]) pairs.append((header, sequence)) return pairs def write_fasta(path, id_sequence_pairs): """Write (id, sequence) pairs to a FASTA file.""" with open(path, 'w') as f: for seq_id, sequence in id_sequence_pairs: f.write(f">{seq_id}\n{sequence}\n") def read_cdhit_clusters(path): """Read CD-HIT cluster file.""" with open(path, 'r') as f: content = f.read().strip() clusters = {} cluster_entries = content[1:].split('\n>') if content.startswith('>') else content.split('\n>') for entry in cluster_entries: lines = entry.strip().split('\n') cluster_header = lines[0] cluster_id = int(cluster_header.strip().split(' ')[1]) members = [] for line in lines[1:]: if ', >' in line: _, member_entry = line.strip().split(', >') member_id = member_entry.split('...')[0] members.append(member_id) clusters[cluster_id] = members return clusters def standardize_na_sequence(sequence): """Standardize nucleic acid sequence: U->T, non-ACGT->X.""" mapping = {'A': 'A', 'C': 'C', 'G': 'G', 'T': 'T', 'U': 'T'} return ''.join(mapping.get(c, 'X') for c in sequence.upper()) def cluster_sequences(output_dir, cdhit_path=None, protein_identity=0.4, na_identity=0.8): """Cluster protein and nucleic acid sequences using CD-HIT. Args: output_dir: Output directory containing preprocessed data cdhit_path: Path to CD-HIT installation directory protein_identity: Sequence identity threshold for proteins (default 0.4) na_identity: Sequence identity threshold for nucleic acids (default 0.8) """ if cdhit_path is None: # Try to find CD-HIT in PATH cdhit_path = shutil.which('cd-hit') if cdhit_path: cdhit_path = os.path.dirname(cdhit_path) if cdhit_path is None or not os.path.exists(cdhit_path): print("Warning: CD-HIT not found. Skipping clustering.") print(" Install CD-HIT and provide path with --cdhit_path") print(" Or download from: https://github.com/weizhongli/cdhit/releases") return None cdhit_bin = os.path.join(cdhit_path, 'cd-hit') cdhit_est_bin = os.path.join(cdhit_path, 'cd-hit-est') if not os.path.exists(cdhit_bin): cdhit_bin = shutil.which('cd-hit') if not os.path.exists(cdhit_est_bin): cdhit_est_bin = shutil.which('cd-hit-est') # Load preprocessed data preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv') if not os.path.exists(preprocessed_path): print(f"Error: {preprocessed_path} not found. Run 'preprocess' first.") return None df = pd.read_csv(preprocessed_path) print(f"Clustering sequences from {len(df)} structures...") clustering_dir = os.path.join(output_dir, 'clustering') os.makedirs(clustering_dir, exist_ok=True) # Gather all sequences protein_sequences = set() na_sequences = set() for seq_path in tqdm(df['sequences_path'], desc="Gathering sequences"): if os.path.exists(seq_path): seq_df = pd.read_csv(seq_path) for chain_type, sequence in zip(seq_df['chain_type'], seq_df['sequence']): if chain_type == 'polypeptide(L)': protein_sequences.add(sequence) elif chain_type in ['polydeoxyribonucleotide', 'polyribonucleotide', 'polydeoxyribonucleotide/polyribonucleotide hybrid']: na_sequences.add(sequence) print(f" Unique protein sequences: {len(protein_sequences)}") print(f" Unique nucleic acid sequences: {len(na_sequences)}") # Write FASTA files protein_fasta = os.path.join(clustering_dir, 'all_protein_sequences.fa') na_fasta = os.path.join(clustering_dir, 'all_na_sequences.fa') na_std_fasta = os.path.join(clustering_dir, 'all_na_sequences_std.fa') write_fasta(protein_fasta, enumerate(protein_sequences)) write_fasta(na_fasta, enumerate(na_sequences)) # Write standardized NA sequences na_std_sequences = [standardize_na_sequence(s) for s in na_sequences] write_fasta(na_std_fasta, enumerate(na_std_sequences)) # Run CD-HIT for proteins protein_clusters = {} if cdhit_bin and len(protein_sequences) > 0: print("\nClustering protein sequences with CD-HIT...") protein_out = os.path.join(clustering_dir, 'protein_clusters') # Determine word size based on identity threshold word_size = 2 if protein_identity < 0.5 else (3 if protein_identity < 0.6 else 5) cmd = [ cdhit_bin, '-i', protein_fasta, '-o', protein_out, '-c', str(protein_identity), '-n', str(word_size), '-d', '0', '-M', '16000', '-T', '0', '-aL', '0.9', '-aS', '0.9' ] try: subprocess.run(cmd, check=True, capture_output=True) protein_clusters = read_cdhit_clusters(protein_out + '.clstr') print(f" Protein clusters: {len(protein_clusters)}") except Exception as e: print(f" Warning: Protein clustering failed: {e}") # Run CD-HIT-EST for nucleic acids na_clusters = {} if cdhit_est_bin and len(na_sequences) > 0: print("\nClustering nucleic acid sequences with CD-HIT-EST...") na_out = os.path.join(clustering_dir, 'na_clusters') word_size = 4 if na_identity >= 0.8 else 3 cmd = [ cdhit_est_bin, '-i', na_std_fasta, '-o', na_out, '-c', str(na_identity), '-n', str(word_size), '-d', '0', '-M', '16000', '-T', '0', '-l', '4', '-aL', '0.9', '-aS', '0.9' ] try: subprocess.run(cmd, check=True, capture_output=True) na_clusters = read_cdhit_clusters(na_out + '.clstr') print(f" Nucleic acid clusters: {len(na_clusters)}") except Exception as e: print(f" Warning: NA clustering failed: {e}") # Create sequence -> cluster mappings protein_seq_to_cluster = {} protein_seq_list = list(protein_sequences) for cluster_id, members in protein_clusters.items(): for member in members: try: idx = int(member) protein_seq_to_cluster[protein_seq_list[idx]] = cluster_id except: pass na_seq_to_cluster = {} na_seq_list = list(na_sequences) na_std_list = [standardize_na_sequence(s) for s in na_seq_list] std_to_cluster = {} for cluster_id, members in na_clusters.items(): for member in members: try: idx = int(member) std_to_cluster[na_std_list[idx]] = cluster_id except: pass for seq in na_seq_list: std_seq = standardize_na_sequence(seq) if std_seq in std_to_cluster: na_seq_to_cluster[seq] = std_to_cluster[std_seq] # Save cluster mappings np.save(os.path.join(clustering_dir, 'protein_seq_to_cluster.npy'), protein_seq_to_cluster) np.save(os.path.join(clustering_dir, 'na_seq_to_cluster.npy'), na_seq_to_cluster) print(f"\nClustering complete. Results saved to {clustering_dir}") return { 'protein_seq_to_cluster': protein_seq_to_cluster, 'na_seq_to_cluster': na_seq_to_cluster, 'n_protein_clusters': len(protein_clusters), 'n_na_clusters': len(na_clusters) } # ============================================================================ # Step 4: Train/Valid/Test Split # ============================================================================ def create_train_valid_split(output_dir, valid_fraction=0.1, test_fraction=0.0, seed=42, use_clustering=False): """Create train/valid/test split. Args: output_dir: Output directory valid_fraction: Fraction for validation set test_fraction: Fraction for test set seed: Random seed use_clustering: Whether to use sequence clustering for split (prevents data leakage) """ preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv') if not os.path.exists(preprocessed_path): print(f"Error: {preprocessed_path} not found. Run 'preprocess' first.") return df = pd.read_csv(preprocessed_path) print(f"Splitting {len(df)} structures...") print(f" Valid fraction: {valid_fraction}") print(f" Test fraction: {test_fraction}") print(f" Train fraction: {1 - valid_fraction - test_fraction}") np.random.seed(seed) if use_clustering: # Use cluster-based splitting to prevent data leakage clustering_dir = os.path.join(output_dir, 'clustering') na_cluster_path = os.path.join(clustering_dir, 'na_seq_to_cluster.npy') if os.path.exists(na_cluster_path): print("\nUsing cluster-based splitting (prevents data leakage)...") na_seq_to_cluster = np.load(na_cluster_path, allow_pickle=True).item() # Get cluster IDs for each structure structure_clusters = {} for idx, seq_path in enumerate(df['sequences_path']): if os.path.exists(seq_path): seq_df = pd.read_csv(seq_path) clusters = set() for chain_type, sequence in zip(seq_df['chain_type'], seq_df['sequence']): if chain_type in ['polydeoxyribonucleotide', 'polyribonucleotide', 'polydeoxyribonucleotide/polyribonucleotide hybrid']: if sequence in na_seq_to_cluster: clusters.add(na_seq_to_cluster[sequence]) structure_clusters[idx] = clusters # Get all unique clusters all_clusters = set() for clusters in structure_clusters.values(): all_clusters.update(clusters) all_clusters = list(all_clusters) np.random.shuffle(all_clusters) n_test = int(len(all_clusters) * test_fraction) n_valid = int(len(all_clusters) * valid_fraction) test_clusters = set(all_clusters[:n_test]) valid_clusters = set(all_clusters[n_test:n_test + n_valid]) train_clusters = set(all_clusters[n_test + n_valid:]) # Assign structures to splits based on cluster membership test_indices = [] valid_indices = [] train_indices = [] for idx, clusters in structure_clusters.items(): if clusters & test_clusters: test_indices.append(idx) elif clusters & valid_clusters: valid_indices.append(idx) else: train_indices.append(idx) print(f" Cluster-based split:") print(f" Train clusters: {len(train_clusters)}, Valid clusters: {len(valid_clusters)}, Test clusters: {len(test_clusters)}") else: print("Warning: Clustering data not found, falling back to random split") use_clustering = False if not use_clustering: # Random split indices = np.random.permutation(len(df)) n_test = int(len(df) * test_fraction) n_valid = int(len(df) * valid_fraction) test_indices = indices[:n_test] valid_indices = indices[n_test:n_test + n_valid] train_indices = indices[n_test + n_valid:] train_df = df.iloc[train_indices].copy() valid_df = df.iloc[valid_indices].copy() test_df = df.iloc[test_indices].copy() if len(test_indices) > 0 else pd.DataFrame() # Save train_path = os.path.join(output_dir, 'train.csv') valid_path = os.path.join(output_dir, 'valid.csv') test_path = os.path.join(output_dir, 'test.csv') all_path = os.path.join(output_dir, 'all.csv') train_df.to_csv(train_path, index=False) valid_df.to_csv(valid_path, index=False) if len(test_df) > 0: test_df.to_csv(test_path, index=False) df.to_csv(all_path, index=False) print(f"\nSplit complete:") print(f" Train: {len(train_df)} -> {train_path}") print(f" Valid: {len(valid_df)} -> {valid_path}") if len(test_df) > 0: print(f" Test: {len(test_df)} -> {test_path}") # Print statistics print("\nDataset statistics:") print(f" Total structures: {len(df)}") if 'has_protein' in df.columns: print(f" With protein: {df['has_protein'].sum()}") if 'has_dna' in df.columns: print(f" With DNA: {df['has_dna'].sum()}") if 'has_rna' in df.columns: print(f" With RNA: {df['has_rna'].sum()}") # ============================================================================ # Main # ============================================================================ def main(): parser = argparse.ArgumentParser( description="Full dataset preparation for NA-MPNN Diffusion (满血版)", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: # Quick test with small sample python prepare_diffusion_dataset_full.py all \\ --mmcif_dir pdb_mmcif --output_dir datasets/test \\ --sample_size 1000 --require_na --num_workers 16 # Full PDB with nucleic acids only python prepare_diffusion_dataset_full.py all \\ --mmcif_dir pdb_mmcif --output_dir datasets/na_full \\ --require_na --num_workers 32 # Step-by-step with clustering python prepare_diffusion_dataset_full.py scan --mmcif_dir pdb_mmcif --output_dir out --num_workers 16 python prepare_diffusion_dataset_full.py preprocess --output_dir out --num_workers 16 python prepare_diffusion_dataset_full.py cluster --output_dir out --cdhit_path /path/to/cdhit python prepare_diffusion_dataset_full.py split --output_dir out --use_clustering """ ) subparsers = parser.add_subparsers(dest='command', help='Commands') # Scan command scan_parser = subparsers.add_parser('scan', help='Scan PDB database (Step 1)') scan_parser.add_argument('--mmcif_dir', type=str, required=True, help='Path to mmCIF files directory') scan_parser.add_argument('--output_dir', type=str, required=True, help='Output directory for results') scan_parser.add_argument('--num_workers', type=int, default=None, help='Number of parallel workers (default: CPU count - 2)') scan_parser.add_argument('--sample_size', type=int, default=None, help='Sample N structures for testing (default: use all)') scan_parser.add_argument('--require_na', action='store_true', help='Only keep structures with nucleic acids') scan_parser.add_argument('--require_protein', action='store_true', help='Only keep structures with proteins') scan_parser.add_argument('--min_heavy_atoms', type=int, default=100, help='Minimum number of heavy atoms (default: 100)') scan_parser.add_argument('--min_coverage', type=float, default=0.9, help='Minimum atom coverage (default: 0.9)') scan_parser.add_argument('--max_resolution', type=float, default=3.5, help='Maximum resolution in Å (default: 3.5)') scan_parser.add_argument('--max_unknown', type=int, default=20, help='Maximum unknown residues (default: 20)') # Preprocess command preprocess_parser = subparsers.add_parser('preprocess', help='Preprocess structures (Step 2)') preprocess_parser.add_argument('--output_dir', type=str, required=True) preprocess_parser.add_argument('--num_workers', type=int, default=None) # Cluster command cluster_parser = subparsers.add_parser('cluster', help='Cluster sequences with CD-HIT (Step 3, optional)') cluster_parser.add_argument('--output_dir', type=str, required=True) cluster_parser.add_argument('--cdhit_path', type=str, default=None, help='Path to CD-HIT installation directory') cluster_parser.add_argument('--protein_identity', type=float, default=0.4, help='Protein clustering identity threshold (default: 0.4)') cluster_parser.add_argument('--na_identity', type=float, default=0.8, help='Nucleic acid clustering identity threshold (default: 0.8)') # Split command split_parser = subparsers.add_parser('split', help='Create train/valid/test split (Step 4)') split_parser.add_argument('--output_dir', type=str, required=True) split_parser.add_argument('--valid_fraction', type=float, default=0.1, help='Validation set fraction (default: 0.1)') split_parser.add_argument('--test_fraction', type=float, default=0.0, help='Test set fraction (default: 0.0)') split_parser.add_argument('--seed', type=int, default=42) split_parser.add_argument('--use_clustering', action='store_true', help='Use cluster-based split (prevents data leakage)') # All-in-one command all_parser = subparsers.add_parser('all', help='Run all steps (scan + preprocess + split)') all_parser.add_argument('--mmcif_dir', type=str, required=True) all_parser.add_argument('--output_dir', type=str, required=True) all_parser.add_argument('--num_workers', type=int, default=None) all_parser.add_argument('--sample_size', type=int, default=None) all_parser.add_argument('--require_na', action='store_true') all_parser.add_argument('--require_protein', action='store_true') all_parser.add_argument('--min_heavy_atoms', type=int, default=100) all_parser.add_argument('--min_coverage', type=float, default=0.9) all_parser.add_argument('--max_resolution', type=float, default=3.5) all_parser.add_argument('--valid_fraction', type=float, default=0.1) all_parser.add_argument('--test_fraction', type=float, default=0.0) all_parser.add_argument('--cdhit_path', type=str, default=None, help='Path to CD-HIT (enables clustering)') args = parser.parse_args() if args.command == 'scan': df = scan_database_multiprocess( args.mmcif_dir, args.output_dir, num_workers=args.num_workers, sample_size=args.sample_size ) df = filter_scanned_data( df, min_heavy_atoms=args.min_heavy_atoms, min_coverage=args.min_coverage, max_resolution=args.max_resolution, max_unknown_residues=args.max_unknown, require_na=args.require_na, require_protein=args.require_protein ) filtered_path = os.path.join(args.output_dir, 'filtered_structures.csv') df.to_csv(filtered_path, index=False) print(f"\nSaved filtered data to {filtered_path}") elif args.command == 'preprocess': preprocess_structures_multiprocess(args.output_dir, args.num_workers) elif args.command == 'cluster': cluster_sequences(args.output_dir, args.cdhit_path, args.protein_identity, args.na_identity) elif args.command == 'split': create_train_valid_split(args.output_dir, args.valid_fraction, args.test_fraction, args.seed, args.use_clustering) elif args.command == 'all': print("="*70) print("Step 1/4: Scanning PDB database (multi-process)") print("="*70) df = scan_database_multiprocess( args.mmcif_dir, args.output_dir, num_workers=args.num_workers, sample_size=args.sample_size ) df = filter_scanned_data( df, min_heavy_atoms=args.min_heavy_atoms, min_coverage=args.min_coverage, max_resolution=args.max_resolution, require_na=args.require_na, require_protein=args.require_protein ) filtered_path = os.path.join(args.output_dir, 'filtered_structures.csv') df.to_csv(filtered_path, index=False) print("\n" + "="*70) print("Step 2/4: Preprocessing structures (multi-process)") print("="*70) preprocess_structures_multiprocess(args.output_dir, args.num_workers) use_clustering = False if args.cdhit_path: print("\n" + "="*70) print("Step 3/4: Clustering sequences (CD-HIT)") print("="*70) result = cluster_sequences(args.output_dir, args.cdhit_path) if result: use_clustering = True else: print("\n" + "="*70) print("Step 3/4: Clustering (skipped, no CD-HIT path provided)") print("="*70) print("\n" + "="*70) print("Step 4/4: Creating train/valid/test split") print("="*70) create_train_valid_split(args.output_dir, args.valid_fraction, args.test_fraction, use_clustering=use_clustering) print("\n" + "="*70) print("✓ COMPLETE!") print("="*70) print(f"\nDataset ready! Update your config with:") print(f' "DF_PATH_TRAIN": "{os.path.abspath(os.path.join(args.output_dir, "train.csv"))}",') print(f' "DF_PATH_VALID": "{os.path.abspath(os.path.join(args.output_dir, "valid.csv"))}",') if args.test_fraction > 0: print(f' "DF_PATH_TEST": "{os.path.abspath(os.path.join(args.output_dir, "test.csv"))}",') else: parser.print_help() if __name__ == "__main__": main()