Spaces:

GGproject10
/

simplified_tree_AI

No application file

App Files Files Community

re-type commited on Jun 9, 2025

Commit

7d8c0b6

verified ·

1 Parent(s): 61b9191

Update app.py

Browse files

Files changed (1) hide show

app.py +103 -250

app.py CHANGED Viewed

@@ -1,4 +1,4 @@
-# app.py - Enhanced version with improved tree visualization
 import gradio as gr
 import torch
 import pickle
@@ -72,230 +72,93 @@ try:
 except Exception as e:
     logging.error(f"Failed to load Keras model from HF Hub: {e}")
-# --- Enhanced Tree Visualization Functions ---
-def create_fallback_tree_html(matched_ids, similarities, query_id="QUERY"):
-    """Create a simple fallback tree visualization using HTML/CSS/JS"""
-    # Generate tree data structure
-    tree_data = []
-    for i, (seq_id, similarity) in enumerate(zip(matched_ids, similarities)):
-        tree_data.append({
-            'id': seq_id,
-            'similarity': similarity,
-            'level': 1 if similarity > 90 else 2
-        })
-    # Add query sequence
-    tree_data.insert(0, {'id': query_id, 'similarity': 100.0, 'level': 0})
-    html_content = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>Phylogenetic Tree Visualization</title>
-        <style>
-            body {{
-                font-family: Arial, sans-serif;
-                margin: 20px;
-                background-color: #f5f5f5;
-            }}
-            .tree-container {{
-                background: white;
-                border-radius: 8px;
-                padding: 20px;
-                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            }}
-            .tree-title {{
-                font-size: 24px;
-                font-weight: bold;
-                margin-bottom: 20px;
-                text-align: center;
-                color: #2c3e50;
-            }}
-            .tree-node {{
-                display: flex;
-                align-items: center;
-                margin: 10px 0;
-                padding: 8px;
-                border-radius: 4px;
-                transition: background-color 0.3s;
-            }}
-            .tree-node:hover {{
-                background-color: #ecf0f1;
-            }}
-            .node-query {{
-                background-color: #e74c3c;
-                color: white;
-                font-weight: bold;
-            }}
-            .node-high {{
-                background-color: #27ae60;
-                color: white;
-            }}
-            .node-medium {{
-                background-color: #f39c12;
-                color: white;
-            }}
-            .node-line {{
-                width: 20px;
-                height: 2px;
-                background-color: #34495e;
-                margin-right: 10px;
-            }}
-            .node-info {{
-                display: flex;
-                justify-content: space-between;
-                width: 100%;
-            }}
-            .similarity-bar {{
-                width: 100px;
-                height: 20px;
-                background-color: #ecf0f1;
-                border-radius: 10px;
-                overflow: hidden;
-                margin-left: 10px;
-            }}
-            .similarity-fill {{
-                height: 100%;
-                background: linear-gradient(90deg, #e74c3c 0%, #f39c12 50%, #27ae60 100%);
-                transition: width 0.5s ease;
-            }}
-            .stats {{
-                margin-top: 20px;
-                padding: 15px;
-                background-color: #ecf0f1;
-                border-radius: 4px;
-            }}
-        </style>
-    </head>
-    <body>
-        <div class="tree-container">
-            <div class="tree-title">🌳 Phylogenetic Tree Analysis</div>
-            <div class="stats">
-                <strong>Analysis Summary:</strong><br>
-                • Total sequences analyzed: {len(tree_data)}<br>
-                • Similarity range: {min([d['similarity'] for d in tree_data[1:]]):.1f}% - {max([d['similarity'] for d in tree_data[1:]]):.1f}%<br>
-                • Average similarity: {np.mean([d['similarity'] for d in tree_data[1:]]):.1f}%
-            </div>
-            <div style="margin-top: 20px;">
-    """
-    for node in tree_data:
-        indent = "  " * node['level'] * 2
-        if node['id'] == query_id:
-            node_class = "node-query"
-        elif node['similarity'] > 90:
-            node_class = "node-high"
         else:
-            node_class = "node-medium"
-        html_content += f"""
-                <div class="tree-node {node_class}">
-                    <div style="margin-left: {node['level'] * 20}px;">
-                        <div class="node-line"></div>
-                    </div>
-                    <div class="node-info">
-                        <span>{node['id']}</span>
-                        <div style="display: flex; align-items: center;">
-                            <span>{node['similarity']:.1f}%</span>
-                            <div class="similarity-bar">
-                                <div class="similarity-fill" style="width: {node['similarity']}%;"></div>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-        """
-    html_content += """
-            </div>
-        </div>
-        <script>
-            // Add some interactivity
-            document.querySelectorAll('.tree-node').forEach(node => {
-                node.addEventListener('click', function() {
-                    this.style.transform = this.style.transform === 'scale(1.02)' ? 'scale(1)' : 'scale(1.02)';
-                });
-            });
-            // Animate similarity bars on load
-            window.addEventListener('load', function() {
-                document.querySelectorAll('.similarity-fill').forEach(fill => {
-                    const width = fill.style.width;
-                    fill.style.width = '0%';
-                    setTimeout(() => {
-                        fill.style.width = width;
-                    }, 100);
-                });
-            });
-        </script>
-    </body>
-    </html>
-    """
-    return html_content
-def safe_tree_creation(analyzer, matched_ids, perc):
-    """Safely create a tree with multiple fallback options"""
     try:
-        # First, try the original method
-        logging.info("Attempting original tree creation method...")
-        result = analyzer.create_interactive_tree(matched_ids, perc)
-        # Check if HTML file was created
-        possible_files = [
-            "phylogenetic_tree_normalized_horizontal.html",
-            "phylogenetic_tree_horizontal.html",
-            "phylogenetic_tree.html",
-            "tree.html",
-            "interactive_tree.html"
-        ]
-        for filename in possible_files:
-            if os.path.exists(filename):
-                with open(filename, "r", encoding='utf-8') as f:
-                    html_content = f.read()
-                return filename, html_content, f"✅ Tree created successfully using {filename}"
-        # If no file found, check if analyzer has HTML content
-        if hasattr(analyzer, 'last_generated_html') and analyzer.last_generated_html:
-            return None, analyzer.last_generated_html, "✅ Tree created (using analyzer HTML content)"
-    except Exception as e:
-        logging.error(f"Original tree creation failed: {e}")
-    try:
-        # Fallback: Create simple tree visualization
-        logging.info("Creating fallback tree visualization...")
-        # Get similarity data if available
-        similarities = []
-        if hasattr(analyzer, 'data') and analyzer.data is not None:
-            for seq_id in matched_ids:
-                if seq_id in analyzer.data.index:
-                    # Calculate similarity based on sequence comparison (simplified)
-                    similarities.append(np.random.uniform(perc-5, perc+5))  # Placeholder
-                else:
-                    similarities.append(perc)
-        else:
-            similarities = [perc] * len(matched_ids)
-        # Create fallback HTML
-        fallback_html = create_fallback_tree_html(matched_ids, similarities)
-        # Save fallback HTML
-        fallback_filename = "fallback_phylogenetic_tree.html"
-        with open(fallback_filename, "w", encoding='utf-8') as f:
-            f.write(fallback_html)
-        return fallback_filename, fallback_html, f"✅ Fallback tree created with {len(matched_ids)} sequences"
     except Exception as e:
-        logging.error(f"Fallback tree creation also failed: {e}")
-        return None, "<p>Tree visualization failed. Please check the logs for details.</p>", f"❌ Tree creation failed: {str(e)}"
 # --- Keras Prediction ---
 def predict_with_keras(sequence):
@@ -411,58 +274,48 @@ def run_pipeline(dna_input):
         # Skip MAFFT due to configuration issues in the container
         logging.info("Skipping MAFFT/IQ-TREE due to container configuration issues")
-        # Step 4: ML Simplified Tree (using the extracted F gene sequence) - ENHANCED
         html_file = None
         tree_html_content = "No tree generated"
         ml_output = ""
-        if os.path.exists(csv_path) and processed_sequence and len(processed_sequence) >= 10:
             try:
                 logging.info(f"Starting ML tree analysis with F gene sequence length: {len(processed_sequence)}")
-                analyzer = ml_simplified_tree.PhylogeneticTreeAnalyzer()
-                if analyzer.load_data(csv_path):
-                    logging.info("CSV data loaded successfully")
-                    # Use the extracted F gene sequence from boundary model
                     if analyzer.find_query_sequence(processed_sequence):
-                        logging.info("F gene sequence found in dataset")
-                        matched_ids, perc = analyzer.find_similar_sequences(analyzer.matching_percentage)
-                        # Enhanced tree creation with robust error handling
-                        try:
-                            logging.info(f"Creating tree with {len(matched_ids)} sequences at {perc:.1f}% similarity")
-                            # Use the safe tree creation function
-                            html_file, tree_html_content, status_message = safe_tree_creation(analyzer, matched_ids, perc)
-                            ml_output = status_message
-                            if html_file:
-                                logging.info(f"Tree HTML file created: {html_file}")
-                            else:
-                                logging.info("Tree HTML content generated in memory")
-                        except Exception as tree_error:
-                            ml_output = f"❌ Tree creation failed: {str(tree_error)}\n"
-                            ml_output += f"- Sequences available: {len(matched_ids)}\n"
-                            ml_output += f"- Similarity threshold: {perc:.1f}%"
-                            logging.error(f"Tree creation error: {tree_error}")
-                            import traceback
-                            logging.error(f"Full traceback: {traceback.format_exc()}")
-                    else:
-                        ml_output = f"❌ F gene sequence not found in dataset\n- Query length: {len(processed_sequence)} bp\n- Dataset contains {len(analyzer.data) if hasattr(analyzer, 'data') else 'unknown'} sequences"
-                        logging.warning(f"F gene sequence not found. Length: {len(processed_sequence)}")
                 else:
-                    ml_output = "❌ Failed to load CSV dataset"
-                    logging.error("Failed to load CSV dataset")
             except Exception as e:
                 ml_output = f"❌ ML Tree analysis failed: {str(e)}"
                 logging.error(f"ML Tree failed: {e}")
                 import traceback
                 logging.error(f"Full traceback: {traceback.format_exc()}")
-        elif not os.path.exists(csv_path):
-            ml_output = f"❌ CSV dataset not found at {csv_path}"
         elif not processed_sequence or len(processed_sequence) < 10:
             ml_output = f"❌ F gene sequence too short for analysis (length: {len(processed_sequence) if processed_sequence else 0})"
         else:

+# app.py
 import gradio as gr
 import torch
 import pickle
 except Exception as e:
     logging.error(f"Failed to load Keras model from HF Hub: {e}")
+# --- Initialize Tree Analyzer ---
+analyzer = None
+try:
+    analyzer = ml_simplified_tree.PhylogeneticTreeAnalyzer()
+    if os.path.exists(csv_path):
+        if analyzer.load_data(csv_path):
+            logging.info("Tree analyzer initialized successfully")
+            # Try to train AI model (optional)
+            try:
+                if not analyzer.train_ai_model():
+                    logging.warning("AI model training failed; proceeding with basic analysis.")
+            except Exception as e:
+                logging.warning(f"AI model training failed: {e}")
         else:
+            logging.error("Failed to load CSV data for tree analyzer")
+            analyzer = None
+    else:
+        logging.error(f"CSV file not found: {csv_path}")
+        analyzer = None
+except Exception as e:
+    logging.error(f"Failed to initialize tree analyzer: {e}")
+    analyzer = None
+# --- Tree Analysis Function (Based on old Gradio API) ---
+def analyze_sequence_for_tree(sequence: str, matching_percentage: float = 95.0) -> str:
+    """
+    Analyze sequence and create phylogenetic tree using the working Gradio API pattern
+    """
     try:
+        if not analyzer:
+            return "Error: Tree analyzer not initialized."
+        if not sequence:
+            return "Error: Please provide a sequence."
+        if not (1 <= matching_percentage <= 99):
+            return "Error: Matching percentage must be between 1 and 99."
+        # Find query sequence
+        if not analyzer.find_query_sequence(sequence):
+            return "Error: Invalid query sequence or sequence not found in dataset."
+        # Set matching percentage
+        analyzer.matching_percentage = matching_percentage
+        # Find similar sequences
+        matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
+        if not matched_ids:
+            return f"No similar sequences found at {matching_percentage}% similarity."
+        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.1f}% similarity")
+        # Build tree structure
+        tree_structure = analyzer.build_tree_structure(matched_ids)
+        if not tree_structure:
+            return "Error: Failed to build tree structure."
+        # Create interactive tree
+        fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
+        if not fig:
+            return "Error: Failed to create tree visualization."
+        # Generate HTML content
+        html_content = fig.to_html(full_html=True, include_plotlyjs='cdn')
+        # Save to output folder
+        output_dir = "output"
+        os.makedirs(output_dir, exist_ok=True)
+        # Create a safe filename
+        safe_seq_name = re.sub(r'[^a-zA-Z0-9]', '_', sequence[:20])
+        html_filename = os.path.join(output_dir, f"tree_{safe_seq_name}_{matching_percentage}.html")
+        with open(html_filename, "w", encoding='utf-8') as f:
+            f.write(html_content)
+        logging.info(f"Tree HTML saved to {html_filename}")
+        return html_content
     except Exception as e:
+        error_msg = f"Tree analysis error: {str(e)}"
+        logging.error(error_msg)
+        import traceback
+        logging.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg
 # --- Keras Prediction ---
 def predict_with_keras(sequence):
         # Skip MAFFT due to configuration issues in the container
         logging.info("Skipping MAFFT/IQ-TREE due to container configuration issues")
+        # Step 4: ML Simplified Tree (using the new approach)
         html_file = None
         tree_html_content = "No tree generated"
         ml_output = ""
+        if analyzer and processed_sequence and len(processed_sequence) >= 10:
             try:
                 logging.info(f"Starting ML tree analysis with F gene sequence length: {len(processed_sequence)}")
+                # Use the new tree analysis function
+                tree_result = analyze_sequence_for_tree(processed_sequence, matching_percentage=95.0)
+                if tree_result and not tree_result.startswith("Error:"):
+                    # Success - we have HTML content
+                    tree_html_content = tree_result
+                    ml_output = "✅ Phylogenetic tree generated successfully!"
+                    # Check if HTML file was created
+                    output_dir = "output"
+                    if os.path.exists(output_dir):
+                        html_files = [f for f in os.listdir(output_dir) if f.endswith('.html')]
+                        if html_files:
+                            html_file = os.path.join(output_dir, html_files[-1])  # Get the latest
+                            ml_output += f"\n- Tree file: {html_files[-1]}"
+                    # Count sequences analyzed
                     if analyzer.find_query_sequence(processed_sequence):
+                        matched_ids, perc = analyzer.find_similar_sequences(95.0)
+                        ml_output += f"\n- {len(matched_ids)} sequences analyzed"
+                        ml_output += f"\n- Similarity threshold: {perc:.1f}%"
                 else:
+                    # Error occurred
+                    ml_output = f"❌ Tree analysis failed: {tree_result}"
+                    logging.error(f"Tree analysis failed: {tree_result}")
             except Exception as e:
                 ml_output = f"❌ ML Tree analysis failed: {str(e)}"
                 logging.error(f"ML Tree failed: {e}")
                 import traceback
                 logging.error(f"Full traceback: {traceback.format_exc()}")
+        elif not analyzer:
+            ml_output = "❌ Tree analyzer not initialized"
         elif not processed_sequence or len(processed_sequence) < 10:
             ml_output = f"❌ F gene sequence too short for analysis (length: {len(processed_sequence) if processed_sequence else 0})"
         else: