import torch from torch.utils.data import Dataset import os import glob from pathlib import Path from sklearn.model_selection import train_test_split from tools.subgraph_sampler import ProteinSubgraphSampler from .pdb_processor import PDBProcessor from .cache_manager import CacheManager import random import threading from collections import OrderedDict class ProteinDataset(Dataset): def __init__(self, train=True, data_path=None, pdb_path=None, cache_path=None, transform=None, **kwargs): self.train = train self.data_path = data_path self.pdb_path = pdb_path or "dataset/rcsb/human" # Default PDB path self.cache_path = cache_path or "dataset/protein_cache" # Default cache path self.transform = transform # New parameters for on-the-fly processing self.enable_pdb_processing = kwargs.get('enable_pdb_processing', True) self.force_pdb_processing = kwargs.get('force_pdb_processing', False) # Force PDB processing even if .pt files exist # Subgraph sampling parameters self.min_nodes = kwargs.get('min_nodes', 10) self.max_nodes = kwargs.get('max_nodes', 100) # Initialize components self.subgraph_sampler = ProteinSubgraphSampler( min_nodes=self.min_nodes, max_nodes=self.max_nodes ) # Initialize PDB processor and cache manager self.pdb_processor = None # Lazy initialization self.cache_manager = CacheManager(self.cache_path) # Determine data source and index files self._determine_data_source() self.file_paths = self._get_file_paths() self.protein_ids = self._generate_protein_ids() # Split the dataset self.seed = kwargs.get('seed', 42) self._create_data_splits() # Improved memory management for multiprocessing self.cache_size = kwargs.get('cache_size', 512) # Reduced default for multiprocessing self.enable_cache = kwargs.get('enable_cache', True) self.preload_cache = kwargs.get('preload_cache', False) # Thread-safe cache using OrderedDict (LRU) self._cache_lock = threading.Lock() self._cache = OrderedDict() # Worker-specific settings self._worker_id = None self._is_main_process = True # Statistics self._pdb_processed_count = 0 self._cache_hit_count = 0 self._pt_file_count = 0 self._failed_files = set() # Track files that failed to process self._valid_files = None # Cache of validated files # Error handling options self.skip_invalid_files = kwargs.get('skip_invalid_files', True) self.validate_on_init = kwargs.get('validate_on_init', False) # Pre-validate files during init self.max_retry_attempts = kwargs.get('max_retry_attempts', 1) # ESM-C configuration self.esm_use_cpu = kwargs.get('esm_use_cpu', False) if self.esm_use_cpu: os.environ['ESM_USE_CPU'] = 'true' print("Dataset: Configured ESM-C to use CPU only") # Pre-validate files if requested if self.validate_on_init and self.use_pdb_files: self._validate_pdb_files() def __getstate__(self): """Custom pickling - exclude locks and worker-specific state.""" state = self.__dict__.copy() # Remove unpickleable entries del state['_cache_lock'] # Reset worker-specific state for new process state['_worker_id'] = None state['_is_main_process'] = False # Workers are not main process return state def __setstate__(self, state): """Custom unpickling - restore state and create new lock.""" self.__dict__.update(state) # Create new lock in worker process self._cache_lock = threading.Lock() # Worker will determine its own ID later def _determine_data_source(self): """Determine whether to use preprocessed .pt files or PDB files.""" self.use_pdb_files = False self.data_source_type = "unknown" # Check if we should force PDB processing if self.force_pdb_processing: if os.path.exists(self.pdb_path): self.use_pdb_files = True self.data_source_type = "pdb_forced" print(f"Dataset: Forced PDB processing from {self.pdb_path}") else: raise ValueError(f"PDB path not found: {self.pdb_path}") # Check for preprocessed .pt files first (backward compatibility) elif self.data_path and os.path.exists(self.data_path): pt_files = glob.glob(os.path.join(self.data_path, "*.pt")) if pt_files: self.use_pdb_files = False self.data_source_type = "preprocessed" print(f"Dataset: Using preprocessed .pt files from {self.data_path}") return # Fall back to PDB files if enabled if self.enable_pdb_processing and os.path.exists(self.pdb_path): pdb_files = glob.glob(os.path.join(self.pdb_path, "*.pdb")) if pdb_files: self.use_pdb_files = True self.data_source_type = "pdb_fallback" print(f"Dataset: Using PDB files from {self.pdb_path} (no preprocessed files found)") else: raise ValueError(f"No PDB files found in {self.pdb_path}") else: if not self.enable_pdb_processing: raise ValueError(f"No preprocessed files found in {self.data_path} and PDB processing is disabled") else: raise ValueError(f"No data files found in {self.data_path} or {self.pdb_path}") def _get_file_paths(self): """Get all protein file paths based on determined data source.""" file_paths = [] if self.use_pdb_files: # Use PDB files if os.path.exists(self.pdb_path): pattern = '*.pdb' file_paths.extend(glob.glob(os.path.join(self.pdb_path, pattern))) else: # Use preprocessed .pt files if self.data_path and os.path.exists(self.data_path): pattern = '*.pt' file_paths.extend(glob.glob(os.path.join(self.data_path, pattern))) # Sort for consistent ordering file_paths.sort() print(f"Dataset: Found {len(file_paths)} files ({self.data_source_type})") return file_paths def _generate_protein_ids(self): """Generate protein IDs from file names""" protein_ids = [] for file_path in self.file_paths: filename = Path(file_path).stem # Get filename without extension # Handle different filename patterns if self.use_pdb_files: # For PDB files, use the filename directly protein_ids.append(filename) else: # For .pt files, remove 'pytorch_graph_' prefix if present if filename.startswith('pytorch_graph_'): protein_id = filename[len('pytorch_graph_'):] else: protein_id = filename protein_ids.append(protein_id) return protein_ids def _create_data_splits(self): """Create train/test splits and select files based on self.train""" if not hasattr(self, 'file_paths') or not self.file_paths: raise ValueError("File paths are not initialized. Please check data_path.") # Split the dataset into train and test sets train_files, test_files = train_test_split( self.file_paths, test_size=0.1, random_state=self.seed) # if self.train: # self.file_paths = train_files # else: # self.file_paths = test_files # Regenerate protein IDs after split self.protein_ids = self._generate_protein_ids() def _validate_pdb_files(self): """Pre-validate PDB files to identify problematic ones.""" if not self.use_pdb_files: return print(f"Dataset: Pre-validating {len(self.file_paths)} PDB files...") valid_files = [] failed_files = [] for i, file_path in enumerate(self.file_paths): if i % 50 == 0: print(f"Dataset: Validation progress: {i}/{len(self.file_paths)}") try: if self._is_pdb_file_valid(file_path): valid_files.append(file_path) else: failed_files.append(file_path) self._failed_files.add(file_path) except Exception as e: print(f"Dataset: Validation failed for {file_path}: {e}") failed_files.append(file_path) self._failed_files.add(file_path) print(f"Dataset: Validation complete - Valid: {len(valid_files)}, Failed: {len(failed_files)}") if failed_files: print(f"Dataset: Failed files: {[Path(f).name for f in failed_files[:10]]}" + (f" (and {len(failed_files)-10} more)" if len(failed_files) > 10 else "")) # Update file paths to only include valid files if self.skip_invalid_files: self.file_paths = valid_files self.protein_ids = self._generate_protein_ids() print(f"Dataset: Using {len(self.file_paths)} valid files after filtering") def _is_pdb_file_valid(self, pdb_file_path): """Quick validation check for PDB file without full processing.""" try: from Bio.PDB import PDBParser import numpy as np parser = PDBParser(QUIET=True) structure = parser.get_structure("test", pdb_file_path) # Check if we have any valid chains with coordinates valid_residues = 0 for model in structure: for chain in model: for residue in chain: if residue.has_id("CA"): ca_atom = residue["CA"] coords = ca_atom.get_coord() # Check for NaN or infinite coordinates if np.any(np.isnan(coords)) or np.any(np.isinf(coords)): print(f"Dataset: Invalid coordinates in {pdb_file_path}: {coords}") return False valid_residues += 1 # Early exit if we have enough valid residues if valid_residues >= self.min_nodes: return True if valid_residues < self.min_nodes: print(f"Dataset: Too few valid residues in {pdb_file_path}: {valid_residues} < {self.min_nodes}") return False return True except Exception as e: print(f"Dataset: Validation error for {pdb_file_path}: {e}") return False def _get_worker_info(self): """Get current worker information for multiprocessing awareness""" try: import torch.utils.data as data worker_info = data.get_worker_info() if worker_info is not None: self._worker_id = worker_info.id self._is_main_process = False # Adjust cache size per worker self.cache_size = max(32, self.cache_size // worker_info.num_workers) return worker_info except: return None def _get_pdb_processor(self): """Get PDB processor with lazy initialization.""" if self.pdb_processor is None: self.pdb_processor = PDBProcessor() return self.pdb_processor def _load_single_graph(self, file_path): """Load a single protein graph with improved thread-safe caching""" if not self.enable_cache: return self._load_from_disk(file_path) # Get worker info on first access if self._worker_id is None: self._get_worker_info() # Thread-safe cache access with self._cache_lock: # Check cache first if file_path in self._cache: # Move to end (most recently used) graph_data = self._cache.pop(file_path) self._cache[file_path] = graph_data return graph_data # Load from disk if not in cache graph_data = self._load_from_disk(file_path) if graph_data is not None and self.enable_cache: self._add_to_cache(file_path, graph_data) return graph_data def _load_from_disk(self, file_path): """Load graph data from disk or process PDB file on-demand.""" try: if self.use_pdb_files: return self._load_from_pdb(file_path) else: return self._load_from_pt_file(file_path) except Exception as e: print(f"Error loading {file_path}: {e}") return None def _load_from_pt_file(self, file_path): """Load graph data from preprocessed .pt file.""" try: graph_data = torch.load(file_path, map_location='cpu') self._pt_file_count += 1 return graph_data except Exception as e: print(f"Error loading .pt file {file_path}: {e}") return None def _load_from_pdb(self, pdb_file_path): """Load graph data from PDB file with persistent caching.""" try: # Check persistent cache first if self.cache_manager.exists(pdb_file_path): graph_data = self.cache_manager.load(pdb_file_path) if graph_data is not None: self._cache_hit_count += 1 return graph_data # Process PDB file on-the-fly print(f"Processing PDB file on-the-fly: {pdb_file_path}") processor = self._get_pdb_processor() graph_data = processor.process_pdb_file(pdb_file_path) if graph_data is not None: # Save to persistent cache self.cache_manager.save(pdb_file_path, graph_data) self._pdb_processed_count += 1 return graph_data else: print(f"Failed to process PDB file: {pdb_file_path}") return None except Exception as e: print(f"Error processing PDB file {pdb_file_path}: {e}") return None def _add_to_cache(self, file_path, graph_data): """Add graph to cache with thread-safe LRU eviction""" if self.cache_size <= 0: # Cache is disabled return with self._cache_lock: # Remove oldest items if cache is full while len(self._cache) >= self.cache_size: if self._cache: # Check if cache is not empty before popitem self._cache.popitem(last=False) # Remove oldest (FIFO) else: break # Exit if cache becomes empty # Add new item (will be most recent) self._cache[file_path] = graph_data def clear_cache(self): """Clear the cache to free memory""" with self._cache_lock: self._cache.clear() def get_cache_info(self): """Get cache statistics""" with self._cache_lock: basic_info = { 'cache_size': len(self._cache), 'max_cache_size': self.cache_size, 'worker_id': self._worker_id, 'is_main_process': self._is_main_process, 'cache_enabled': self.enable_cache, 'data_source_type': self.data_source_type, 'use_pdb_files': self.use_pdb_files, 'pdb_processed_count': self._pdb_processed_count, 'cache_hit_count': self._cache_hit_count, 'pt_file_count': self._pt_file_count } # Add persistent cache info if using PDB files if self.use_pdb_files: persistent_cache_info = self.cache_manager.get_cache_stats() basic_info.update({ 'persistent_cache': persistent_cache_info }) return basic_info def get_processing_stats(self): """Get detailed processing statistics.""" return { 'data_source': self.data_source_type, 'total_files': len(self.file_paths), 'failed_files_count': len(self._failed_files), 'failed_files': [Path(f).name for f in list(self._failed_files)[:10]], # Show first 10 'pdb_processed_on_fly': self._pdb_processed_count, 'persistent_cache_hits': self._cache_hit_count, 'pt_files_loaded': self._pt_file_count, 'success_rate': (len(self.file_paths) - len(self._failed_files)) / len(self.file_paths) if len(self.file_paths) > 0 else 0, 'cache_manager_stats': self.cache_manager.get_cache_stats() if self.use_pdb_files else None } def get_failed_files(self): """Get list of files that failed to process.""" return list(self._failed_files) def clear_failed_files(self): """Clear the list of failed files (useful for retrying).""" self._failed_files.clear() print("Dataset: Cleared failed files list") def warm_cache(self, num_samples=None): """Pre-load a subset of the dataset into cache""" if not self.enable_cache or not self._is_main_process: return num_samples = num_samples or min(self.cache_size, len(self.file_paths)) print(f"Warming cache with {num_samples} samples...") # Load a random subset for better distribution indices = random.sample(range(len(self.file_paths)), num_samples) for i, idx in enumerate(indices): file_path = self.file_paths[idx] self._load_single_graph(file_path) if (i + 1) % 50 == 0: print(f"Cache warming progress: {i + 1}/{num_samples}") print(f"Cache warmed. Current cache info: {self.get_cache_info()}") def __len__(self): # Return dataset size return len(self.file_paths) def _data_to_dict(self, data_obj): """Convert PyTorch Geometric Data object to dictionary format for subgraph sampler.""" from torch_geometric.data import Data if isinstance(data_obj, Data): return { 'node_features': data_obj.x, 'edge_index': data_obj.edge_index, 'edge_attr': data_obj.edge_attr, 'node_pos': data_obj.pos, 'num_nodes': data_obj.x.shape[0] if data_obj.x is not None else 0 } else: # Already dictionary format return data_obj def _dict_to_data(self, dict_obj): """Convert dictionary format back to PyTorch Geometric Data object.""" from torch_geometric.data import Data if isinstance(dict_obj, dict): return Data( x=dict_obj['node_features'], edge_index=dict_obj['edge_index'], edge_attr=dict_obj['edge_attr'], pos=dict_obj['node_pos'] ) else: # Already Data object return dict_obj def _get_num_nodes(self, graph_obj): """Get number of nodes from either Data object or dictionary.""" from torch_geometric.data import Data if isinstance(graph_obj, Data): return graph_obj.x.shape[0] if graph_obj.x is not None else 0 else: return graph_obj.get('num_nodes', graph_obj['node_features'].shape[0]) def __getitem__(self, idx): """Load protein graph on-demand and generate two contrastive views with robust error handling.""" max_attempts = len(self.file_paths) # Maximum attempts to find a valid sample attempt = 0 while attempt < max_attempts: try: # Get current file (with wraparound if we've tried many times) current_idx = (idx + attempt) % len(self.file_paths) file_path = self.file_paths[current_idx] protein_id = self.protein_ids[current_idx] # Skip files that we know have failed before if self.skip_invalid_files and file_path in self._failed_files: attempt += 1 continue # Check graph file existence, skip to debug pt_file_path = '/'.join(file_path.split('/')[:-2]) + '/graph_cache/protein_pdb_files/' + 'pytorch_graph_' + protein_id + '.pt' if os.path.exists(pt_file_path) and not self.force_pdb_processing: return { 'load_error': False } # Load graph data protein_graph = self._load_single_graph(file_path) if protein_graph is None: # Mark this file as failed and try next self._failed_files.add(file_path) print(f"Dataset: Marking {Path(file_path).name} as failed, trying next file...") attempt += 1 continue # Validate graph data if not self._validate_graph_data(protein_graph): self._failed_files.add(file_path) print(f"Dataset: Graph validation failed for {Path(file_path).name}, trying next file...") attempt += 1 continue # Check if graph is large enough for subgraph sampling num_nodes = self._get_num_nodes(protein_graph) if num_nodes < self.min_nodes: self._failed_files.add(file_path) print(f"Dataset: Graph too small for {Path(file_path).name} ({num_nodes} < {self.min_nodes}), trying next file...") attempt += 1 continue # Generate two contrastive views view1, view2, sampling_strategy, noise_applied = self._generate_contrastive_views(protein_graph) # Validate views if view1 is None or view2 is None: print(f"Dataset: Failed to generate views for {Path(file_path).name}, trying next file...") attempt += 1 continue # Successfully created a valid sample return { 'protein_graph': protein_graph, 'protein_id': protein_id, 'idx': current_idx, 'file_path': file_path, 'load_error': False, 'view1': view1, 'view2': view2, 'sampling_strategy': sampling_strategy, 'noise_applied': noise_applied, 'attempts_needed': attempt + 1 } except Exception as e: print(f"Dataset: Unexpected error processing {self.file_paths[(idx + attempt) % len(self.file_paths)]}: {e}") attempt += 1 continue # If we get here, we couldn't find any valid sample after many attempts print(f"Dataset: Could not find valid sample after {max_attempts} attempts starting from idx {idx}") # Return a dummy sample to prevent DataLoader from crashing return self._create_dummy_sample(idx) def _validate_graph_data(self, graph_data): """Validate that graph data is complete and has no NaN/infinite values.""" try: if graph_data is None: return False # Check for NaN or infinite values import torch # Check node features if torch.any(torch.isnan(graph_data.x)) or torch.any(torch.isinf(graph_data.x)): print("Dataset: NaN/Inf found in node_features") return False # Check node positions if torch.any(torch.isnan(graph_data.pos)) or torch.any(torch.isinf(graph_data.pos)): print("Dataset: NaN/Inf found in node_pos") return False # Check edge attributes if present if graph_data.edge_attr is not None: if torch.any(torch.isnan(graph_data.edge_attr)) or torch.any(torch.isinf(graph_data.edge_attr)): print("Dataset: NaN/Inf found in edge_attr") return False # Check tensor shapes are consistent num_nodes = graph_data.x.shape[0] if graph_data.pos.shape[0] != num_nodes: print(f"Dataset: Inconsistent shapes - features: {graph_data.x.shape}, pos: {graph_data.pos.shape}") return False return True except Exception as e: print(f"Dataset: Error validating graph data: {e}") return False def _generate_contrastive_views(self, protein_graph): """Generate two contrastive views with error handling.""" try: num_nodes = protein_graph.x.shape[0] can_sample_subgraph = num_nodes >= self.min_nodes # Generate two contrastive views with sampling probabilities a = getattr(self, 'complete_graph_percent', 0) complete_prob = a / 100.0 seq_prob = (50 - 0.5 * a) / 100.0 dist_prob = seq_prob rand_val = random.random() # Convert Data object to dictionary for subgraph sampler compatibility protein_graph_dict = self._data_to_dict(protein_graph) if not can_sample_subgraph or rand_val < complete_prob: # Use complete graph for both views view1_dict = self.subgraph_sampler.apply_noise(protein_graph_dict, "identity") view2_dict = self.subgraph_sampler.apply_noise(protein_graph_dict, "identity") sampling_strategy = 'complete' if can_sample_subgraph else 'complete_forced' elif rand_val < complete_prob + seq_prob: # Sequential sampling for both views view1_dict = self.subgraph_sampler.sample_sequential_subgraph(protein_graph_dict) view2_dict = self.subgraph_sampler.sample_sequential_subgraph(protein_graph_dict) sampling_strategy = 'sequential' else: # Distance-based sampling for both views view1_dict = self.subgraph_sampler.sample_distance_subgraph(protein_graph_dict) view2_dict = self.subgraph_sampler.sample_distance_subgraph(protein_graph_dict) sampling_strategy = 'distance' # Convert back to Data objects view1 = self._dict_to_data(view1_dict) view2 = self._dict_to_data(view2_dict) # Validate views before applying noise if not self._validate_graph_data(view1) or not self._validate_graph_data(view2): print("Dataset: Invalid views generated during subgraph sampling") return None, None, sampling_strategy, 'none' # Apply noise transformations apply_masking = random.random() < 0.5 if apply_masking: view1_dict = self._data_to_dict(view1) view2_dict = self._data_to_dict(view2) view1_dict = self.subgraph_sampler.apply_noise(view1_dict, "random_edge_masking", edge_mask_prob=0.15) view2_dict = self.subgraph_sampler.apply_noise(view2_dict, "random_edge_masking", edge_mask_prob=0.15) view1 = self._dict_to_data(view1_dict) view2 = self._dict_to_data(view2_dict) noise_applied = 'masking' else: view1_dict = self._data_to_dict(view1) view2_dict = self._data_to_dict(view2) view1_dict = self.subgraph_sampler.apply_noise(view1_dict, "identity") view2_dict = self.subgraph_sampler.apply_noise(view2_dict, "identity") view1 = self._dict_to_data(view1_dict) view2 = self._dict_to_data(view2_dict) noise_applied = 'identity' # Final validation of views if not self._validate_graph_data(view1) or not self._validate_graph_data(view2): print("Dataset: Invalid views after noise application") return None, None, sampling_strategy, noise_applied return view1, view2, sampling_strategy, noise_applied except Exception as e: print(f"Dataset: Error generating contrastive views: {e}") return None, None, 'error', 'none' def _create_dummy_sample(self, idx): """Create a dummy sample when all else fails to prevent DataLoader crashes.""" return { 'protein_graph': None, 'protein_id': f'dummy_{idx}', 'idx': idx, 'file_path': 'dummy', 'load_error': True, 'view1': None, 'view2': None, 'sampling_strategy': 'dummy', 'noise_applied': 'none', 'attempts_needed': -1 }