Upload 2 files

create_diffusion_dataset.py

@@ -0,0 +1,436 @@
+import pandas as pd
+import numpy as np
+import networkx as nx
+from typing import List, Dict, Tuple, Set
+import json
+import random
+from collections import defaultdict, Counter
+
+class ProteinNetworkConversationDataset:
+    def __init__(self, filename: str):
+        """
+        Create conversational dataset for protein network prediction using diffusion models
+        """
+        self.filename = filename
+        self.df = None
+        self.graph = nx.Graph()
+        self.protein_to_id = {}
+        self.id_to_protein = {}
+        self.interactions_by_protein = defaultdict(list)
+        
+    def load_and_parse_biogrid(self):
+        """Load and parse BioGRID data"""
+        print("Loading BioGRID data...")
+        self.df = pd.read_csv(
+            self.filename, 
+            sep='\t', 
+            comment='#',
+            low_memory=False,
+            dtype=str
+        )
+        
+        # Based on your sample output - adjust column indices as needed
+        protein_a_col = 7  # MAP2K4, MYPN, etc.
+        protein_b_col = 8  # FLNC, etc.
+        interaction_type_col = 11  # "Two-hybrid", "physical", etc.
+        
+        interactions = []
+        protein_set = set()
+        
+        for idx, row in self.df.iterrows():
+            try:
+                protein_a = str(row.iloc[protein_a_col]).strip()
+                protein_b = str(row.iloc[protein_b_col]).strip()
+                interaction_type = str(row.iloc[interaction_type_col]).strip()
+                
+                if protein_a in ['-', 'nan', ''] or protein_b in ['-', 'nan', '']:
+                    continue
+                    
+                protein_set.add(protein_a)
+                protein_set.add(protein_b)
+                
+                interaction = {
+                    'protein_a': protein_a,
+                    'protein_b': protein_b,
+                    'interaction_type': interaction_type
+                }
+                interactions.append(interaction)
+                
+                # Build protein interaction index
+                self.interactions_by_protein[protein_a].append(interaction)
+                self.interactions_by_protein[protein_b].append(interaction)
+                
+            except Exception:
+                continue
+        
+        print(f"Extracted {len(interactions)} valid interactions")
+        print(f"Found {len(protein_set)} unique proteins")
+        
+        return interactions, sorted(list(protein_set))
+    
+    def build_network_neighborhoods(self, interactions, proteins, min_connections=3, max_connections=15):
+        """
+        Build subnetworks around high-degree proteins for training examples
+        """
+        # Count protein degrees
+        protein_degrees = Counter()
+        for interaction in interactions:
+            protein_degrees[interaction['protein_a']] += 1
+            protein_degrees[interaction['protein_b']] += 1
+        
+        # Find proteins with moderate connectivity (good for examples)
+        candidate_proteins = [
+            protein for protein, degree in protein_degrees.items()
+            if min_connections <= degree <= max_connections
+        ]
+        
+        print(f"Found {len(candidate_proteins)} proteins with degree {min_connections}-{max_connections}")
+        
+        neighborhoods = []
+        for protein in candidate_proteins[:500]:  # Limit for processing
+            neighborhood = self.extract_neighborhood(protein, interactions, max_size=10)
+            if len(neighborhood['proteins']) >= 3:  # Minimum viable network
+                neighborhoods.append(neighborhood)
+        
+        return neighborhoods
+    
+    def extract_neighborhood(self, center_protein, interactions, max_size=10):
+        """
+        Extract neighborhood around a protein
+        """
+        # Get direct neighbors
+        neighbors = set()
+        relevant_interactions = []
+        
+        for interaction in self.interactions_by_protein[center_protein]:
+            other_protein = (interaction['protein_b'] if interaction['protein_a'] == center_protein 
+                           else interaction['protein_a'])
+            neighbors.add(other_protein)
+            relevant_interactions.append(interaction)
+        
+        # Limit neighborhood size
+        if len(neighbors) > max_size - 1:
+            neighbors = set(random.sample(list(neighbors), max_size - 1))
+        
+        # Get all interactions within this neighborhood
+        neighborhood_proteins = {center_protein} | neighbors
+        neighborhood_interactions = []
+        
+        for interaction in interactions:
+            if (interaction['protein_a'] in neighborhood_proteins and 
+                interaction['protein_b'] in neighborhood_proteins):
+                neighborhood_interactions.append(interaction)
+        
+        return {
+            'center_protein': center_protein,
+            'proteins': sorted(list(neighborhood_proteins)),
+            'interactions': neighborhood_interactions
+        }
+    
+    def create_conversation_examples(self, neighborhoods):
+        """
+        Create different types of conversation examples for diffusion training
+        """
+        conversations = []
+        
+        for neighborhood in neighborhoods:
+            # Task 1: Complete protein network given protein list
+            conversations.extend(self.create_protein_list_to_network_examples(neighborhood))
+            
+            # Task 2: Predict interactions for new protein
+            conversations.extend(self.create_new_protein_prediction_examples(neighborhood))
+            
+            # Task 3: Complete partial network
+            conversations.extend(self.create_partial_network_completion_examples(neighborhood))
+            
+            # Task 4: Network property prediction
+            conversations.extend(self.create_network_property_examples(neighborhood))
+        
+        return conversations
+    
+    def create_protein_list_to_network_examples(self, neighborhood):
+        """
+        Context: List of proteins
+        Generation: Complete interaction network
+        """
+        examples = []
+        proteins = neighborhood['proteins']
+        interactions = neighborhood['interactions']
+        
+        # Create network representation
+        network_text = self.format_network_as_text(proteins, interactions)
+        
+        system_msg = {
+            "role": "system",
+            "content": "You are a protein interaction prediction system. Given a list of proteins, predict all likely interactions between them based on biological knowledge."
+        }
+        
+        user_msg = {
+            "role": "user", 
+            "content": f"Predict the protein interaction network for these proteins: {', '.join(proteins)}"
+        }
+        
+        assistant_msg = {
+            "role": "assistant",
+            "content": network_text
+        }
+        
+        conversation = [system_msg, user_msg, assistant_msg]
+        examples.append({"updated": conversation})
+        
+        return examples
+    
+    def create_new_protein_prediction_examples(self, neighborhood):
+        """
+        Context: Known network + new protein
+        Generation: Interactions for the new protein
+        """
+        examples = []
+        if len(neighborhood['proteins']) < 4:
+            return examples
+            
+        proteins = neighborhood['proteins']
+        interactions = neighborhood['interactions']
+        
+        # Remove one protein and its interactions for prediction
+        target_protein = random.choice(proteins)
+        remaining_proteins = [p for p in proteins if p != target_protein]
+        
+        # Known network (without target protein)
+        known_interactions = [
+            i for i in interactions 
+            if target_protein not in [i['protein_a'], i['protein_b']]
+        ]
+        
+        # Target interactions (what we want to predict)
+        target_interactions = [
+            i for i in interactions
+            if target_protein in [i['protein_a'], i['protein_b']]
+        ]
+        
+        if not target_interactions:
+            return examples
+        
+        known_network_text = self.format_network_as_text(remaining_proteins, known_interactions)
+        target_network_text = self.format_interactions_as_text(target_interactions)
+        
+        system_msg = {
+            "role": "system",
+            "content": "You are a protein interaction prediction system. Given a known protein network and a new protein, predict which proteins in the network the new protein will interact with."
+        }
+        
+        user_msg = {
+            "role": "user",
+            "content": f"Known protein network:\n{known_network_text}\n\nNew protein to integrate: {target_protein}\n\nPredict the interactions for {target_protein}:"
+        }
+        
+        assistant_msg = {
+            "role": "assistant", 
+            "content": target_network_text
+        }
+        
+        conversation = [system_msg, user_msg, assistant_msg]
+        examples.append({"updated": conversation})
+        
+        return examples
+    
+    def create_partial_network_completion_examples(self, neighborhood):
+        """
+        Context: Partial network with some missing interactions
+        Generation: Complete network
+        """
+        examples = []
+        proteins = neighborhood['proteins']
+        interactions = neighborhood['interactions']
+        
+        if len(interactions) < 3:
+            return examples
+        
+        # Randomly hide some interactions
+        n_hidden = max(1, len(interactions) // 3)
+        hidden_interactions = random.sample(interactions, n_hidden)
+        visible_interactions = [i for i in interactions if i not in hidden_interactions]
+        
+        partial_network_text = self.format_network_as_text(proteins, visible_interactions)
+        complete_network_text = self.format_network_as_text(proteins, interactions)
+        
+        system_msg = {
+            "role": "system",
+            "content": "You are a protein interaction prediction system. Given a partial protein network, predict the complete network including missing interactions."
+        }
+        
+        user_msg = {
+            "role": "user",
+            "content": f"Complete this partial protein network:\n{partial_network_text}"
+        }
+        
+        assistant_msg = {
+            "role": "assistant",
+            "content": complete_network_text
+        }
+        
+        conversation = [system_msg, user_msg, assistant_msg]
+        examples.append({"updated": conversation})
+        
+        return examples
+    
+    def create_network_property_examples(self, neighborhood):
+        """
+        Context: Network properties and constraints
+        Generation: Network that satisfies those properties
+        """
+        examples = []
+        proteins = neighborhood['proteins']
+        interactions = neighborhood['interactions']
+        
+        # Calculate network properties
+        n_proteins = len(proteins)
+        n_interactions = len(interactions)
+        density = (2 * n_interactions) / (n_proteins * (n_proteins - 1)) if n_proteins > 1 else 0
+        
+        # Find hub proteins (high degree)
+        protein_degrees = Counter()
+        for interaction in interactions:
+            protein_degrees[interaction['protein_a']] += 1
+            protein_degrees[interaction['protein_b']] += 1
+        
+        hub_proteins = [p for p, degree in protein_degrees.most_common(2)]
+        
+        network_text = self.format_network_as_text(proteins, interactions)
+        
+        system_msg = {
+            "role": "system",
+            "content": "You are a protein interaction network generator. Given network constraints and properties, generate a biologically plausible protein network."
+        }
+        
+        properties_text = (f"Generate a protein network with the following properties:\n"
+                         f"- Proteins: {', '.join(proteins)}\n"
+                         f"- Network density: approximately {density:.2f}\n"
+                         f"- Hub proteins (highly connected): {', '.join(hub_proteins)}\n"
+                         f"- Total interactions: approximately {n_interactions}")
+        
+        user_msg = {
+            "role": "user",
+            "content": properties_text
+        }
+        
+        assistant_msg = {
+            "role": "assistant",
+            "content": network_text
+        }
+        
+        conversation = [system_msg, user_msg, assistant_msg]
+        examples.append({"updated": conversation})
+        
+        return examples
+    
+    def format_network_as_text(self, proteins, interactions):
+        """
+        Format network as structured text for the model to predict
+        """
+        # Sort for consistency
+        proteins = sorted(proteins)
+        
+        # Group interactions by type
+        interactions_by_type = defaultdict(list)
+        for interaction in interactions:
+            int_type = interaction.get('interaction_type', 'physical')
+            # Ensure consistent ordering
+            p1, p2 = sorted([interaction['protein_a'], interaction['protein_b']])
+            interactions_by_type[int_type].append(f"{p1}--{p2}")
+        
+        result = f"PROTEINS: {', '.join(proteins)}\n\n"
+        
+        for int_type, edges in interactions_by_type.items():
+            if edges:
+                result += f"{int_type.upper()} INTERACTIONS:\n"
+                for edge in sorted(edges):
+                    result += f"  {edge}\n"
+                result += "\n"
+        
+        result += f"NETWORK SUMMARY: {len(proteins)} proteins, {len(interactions)} interactions"
+        return result.strip()
+    
+    def format_interactions_as_text(self, interactions):
+        """
+        Format just interactions as text
+        """
+        if not interactions:
+            return "No interactions predicted."
+        
+        interactions_by_type = defaultdict(list)
+        for interaction in interactions:
+            int_type = interaction.get('interaction_type', 'physical')
+            p1, p2 = sorted([interaction['protein_a'], interaction['protein_b']])
+            interactions_by_type[int_type].append(f"{p1}--{p2}")
+        
+        result = ""
+        for int_type, edges in interactions_by_type.items():
+            if edges:
+                result += f"{int_type.upper()} INTERACTIONS:\n"
+                for edge in sorted(edges):
+                    result += f"  {edge}\n"
+                result += "\n"
+        
+        return result.strip()
+    
+    def save_conversation_dataset(self, output_file="processed_dataset.json"):
+        """
+        Create and save the full conversation dataset
+        """
+        # Load and process data
+        interactions, proteins = self.load_and_parse_biogrid()
+        neighborhoods = self.build_network_neighborhoods(interactions, proteins)
+        
+        print(f"Built {len(neighborhoods)} protein neighborhoods")
+        
+        # Create conversation examples
+        conversations = self.create_conversation_examples(neighborhoods)
+        
+        print(f"Created {len(conversations)} conversation examples")
+        
+        # Shuffle the dataset
+        random.shuffle(conversations)
+        
+        # Save dataset
+        with open(output_file, 'w') as f:
+            json.dump(conversations, f, indent=2)
+        
+        print(f"Saved dataset to {output_file}")
+        
+        # Show examples
+        print("\n=== Example Conversations ===")
+        for i, conv in enumerate(conversations[:3]):
+            print(f"\n--- Example {i+1} ---")
+            for msg in conv["updated"]:
+                print(f"{msg['role'].upper()}: {msg['content'][:200]}...")
+        
+        return conversations
+
+# Usage
+if __name__ == "__main__":
+    creator = ProteinNetworkConversationDataset(
+        "./unzipped/BIOGRID-ALL-4.4.246.tab3/BIOGRID-ALL-4.4.246.tab3.txt"
+    )
+    
+    conversations = creator.save_conversation_dataset("processed_dataset.json")
+    
+    print(f"\n=== Dataset Summary ===")
+    print(f"Total conversations: {len(conversations)}")
+    
+    # Count conversation types by system message content
+    task_types = Counter()
+    for conv in conversations:
+        system_content = conv["updated"][0]["content"]
+        if "list of proteins" in system_content:
+            task_types["protein_list_to_network"] += 1
+        elif "new protein" in system_content:
+            task_types["new_protein_integration"] += 1
+        elif "partial" in system_content:
+            task_types["partial_completion"] += 1
+        elif "properties" in system_content:
+            task_types["property_based_generation"] += 1
+    
+    print("\nTask distribution:")
+    for task, count in task_types.items():
+        print(f"  {task}: {count}")