Upload app.py for CPU-based Protein Structure Predictor

app.py

@@ -32,6 +32,449 @@ import warnings
 warnings.filterwarnings('ignore')
 
 
+class AEGISLearningSystem:
+    """Continuous learning system for AEGIS protein prediction model."""
+    
+    def __init__(self):
+        self.learning_dir = Path("./aegis_learning")
+        self.learning_dir.mkdir(exist_ok=True)
+        
+        # Learning data storage
+        self.training_log = self.learning_dir / "training_log.json"
+        self.feedback_db = self.learning_dir / "feedback_database.json"
+        self.model_versions = self.learning_dir / "model_versions"
+        self.model_versions.mkdir(exist_ok=True)
+        
+        # Performance tracking
+        self.performance_log = self.learning_dir / "performance_log.json"
+        
+        # Initialize learning data structures
+        self.initialize_learning_data()
+        
+    def initialize_learning_data(self):
+        """Initialize learning data structures if they don't exist."""
+        
+        # Training log structure
+        if not self.training_log.exists():
+            initial_log = {
+                "version": "1.0",
+                "created": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "total_predictions": 0,
+                "successful_validations": 0,
+                "learning_sessions": 0,
+                "model_updates": 0,
+                "last_update": None
+            }
+            self._save_json(self.training_log, initial_log)
+        
+        # Feedback database structure
+        if not self.feedback_db.exists():
+            initial_feedback = {
+                "predictions": [],
+                "validations": [],
+                "user_corrections": [],
+                "pdb_matches": [],
+                "performance_metrics": []
+            }
+            self._save_json(self.feedback_db, initial_feedback)
+        
+        # Performance log structure
+        if not self.performance_log.exists():
+            initial_performance = {
+                "accuracy_over_time": [],
+                "pdb_validation_success_rate": [],
+                "prediction_confidence_correlation": [],
+                "learning_curve": []
+            }
+            self._save_json(self.performance_log, initial_performance)
+    
+    def _save_json(self, filepath, data):
+        """Save data to JSON file."""
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(data, f, indent=2, default=str)
+        except Exception as e:
+            print(f"Error saving JSON to {filepath}: {str(e)}")
+    
+    def _load_json(self, filepath):
+        """Load data from JSON file."""
+        try:
+            with open(filepath, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading JSON from {filepath}: {str(e)}")
+            return {}
+    
+    def record_prediction(self, sequence, prediction_result, pdb_validation=None, user_feedback=None):
+        """Record a prediction for learning purposes."""
+        
+        # Load current feedback database
+        feedback_data = self._load_json(self.feedback_db)
+        
+        # Create prediction record
+        prediction_record = {
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "sequence": sequence,
+            "sequence_length": len(sequence),
+            "prediction": {
+                "secondary_structure": prediction_result.get('secondary_structure', ''),
+                "confidence": prediction_result.get('confidence', 0.0),
+                "properties": prediction_result.get('properties', {}),
+                "method": prediction_result.get('method', 'Unknown')
+            },
+            "pdb_validation": pdb_validation,
+            "user_feedback": user_feedback,
+            "learning_value": self._calculate_learning_value(prediction_result, pdb_validation, user_feedback)
+        }
+        
+        # Add to feedback database
+        feedback_data["predictions"].append(prediction_record)
+        
+        # Update training log
+        training_log = self._load_json(self.training_log)
+        training_log["total_predictions"] += 1
+        
+        if pdb_validation and pdb_validation.get('validation_status') in ['KNOWN_SEQUENCE', 'HIGHLY_SIMILAR']:
+            training_log["successful_validations"] += 1
+        
+        # Save updated data
+        self._save_json(self.feedback_db, feedback_data)
+        self._save_json(self.training_log, training_log)
+        
+        # Check if we should trigger learning
+        self._check_learning_trigger()
+        
+        return prediction_record
+    
+    def _calculate_learning_value(self, prediction_result, pdb_validation, user_feedback):
+        """Calculate the learning value of a prediction."""
+        learning_value = 0.0
+        
+        # Base value from prediction confidence
+        confidence = prediction_result.get('confidence', 0.0)
+        learning_value += confidence * 0.3
+        
+        # Value from PDB validation
+        if pdb_validation:
+            status = pdb_validation.get('validation_status', 'NOVEL_SEQUENCE')
+            status_values = {
+                'KNOWN_SEQUENCE': 1.0,
+                'HIGHLY_SIMILAR': 0.8,
+                'MODERATELY_SIMILAR': 0.6,
+                'DISTANTLY_RELATED': 0.4,
+                'NOVEL_SEQUENCE': 0.2
+            }
+            learning_value += status_values.get(status, 0.2) * 0.4
+        
+        # Value from user feedback
+        if user_feedback:
+            feedback_score = user_feedback.get('accuracy_rating', 0.5)  # 0-1 scale
+            learning_value += feedback_score * 0.3
+        
+        return min(1.0, learning_value)  # Cap at 1.0
+    
+    def _check_learning_trigger(self):
+        """Check if we should trigger a learning session."""
+        training_log = self._load_json(self.training_log)
+        feedback_data = self._load_json(self.feedback_db)
+        
+        # Trigger learning every 50 predictions or when we have high-value data
+        predictions_count = len(feedback_data.get("predictions", []))
+        
+        should_learn = False
+        
+        # Regular learning trigger
+        if predictions_count > 0 and predictions_count % 50 == 0:
+            should_learn = True
+            
+        # High-value data trigger
+        recent_predictions = feedback_data.get("predictions", [])[-10:]  # Last 10 predictions
+        high_value_count = sum(1 for p in recent_predictions if p.get('learning_value', 0) > 0.8)
+        
+        if high_value_count >= 5:  # 5 high-value predictions in last 10
+            should_learn = True
+        
+        if should_learn:
+            print("AEGIS Learning Trigger: Initiating continuous learning session...")
+            self.perform_learning_session()
+    
+    def perform_learning_session(self):
+        """Perform a continuous learning session."""
+        try:
+            print("AEGIS Learning: Starting learning session...")
+            
+            # Load learning data
+            feedback_data = self._load_json(self.feedback_db)
+            predictions = feedback_data.get("predictions", [])
+            
+            if len(predictions) < 10:  # Need minimum data
+                print("AEGIS Learning: Insufficient data for learning session")
+                return
+            
+            # Prepare training data from successful predictions
+            training_features, training_labels = self._prepare_training_data(predictions)
+            
+            if len(training_features) == 0:
+                print("AEGIS Learning: No suitable training data found")
+                return
+            
+            # Update model with new data
+            self._update_model_with_feedback(training_features, training_labels)
+            
+            # Update performance metrics
+            self._update_performance_metrics(predictions)
+            
+            # Update training log
+            training_log = self._load_json(self.training_log)
+            training_log["learning_sessions"] += 1
+            training_log["model_updates"] += 1
+            training_log["last_update"] = time.strftime("%Y-%m-%d %H:%M:%S")
+            self._save_json(self.training_log, training_log)
+            
+            print("AEGIS Learning: Learning session completed successfully!")
+            
+        except Exception as e:
+            print(f"AEGIS Learning Error: {str(e)}")
+    
+    def _prepare_training_data(self, predictions):
+        """Prepare training data from prediction history."""
+        features = []
+        labels = []
+        
+        for pred in predictions:
+            # Only use high-quality predictions for training
+            if pred.get('learning_value', 0) < 0.6:
+                continue
+            
+            sequence = pred.get('sequence', '')
+            if len(sequence) < 10:  # Skip very short sequences
+                continue
+            
+            # Extract features from sequence
+            seq_features = self._extract_sequence_features(sequence)
+            
+            # Get target labels from PDB validation or user feedback
+            target_labels = self._extract_target_labels(pred)
+            
+            if seq_features is not None and target_labels is not None:
+                features.append(seq_features)
+                labels.append(target_labels)
+        
+        return np.array(features) if features else np.array([]), np.array(labels) if labels else np.array([])
+    
+    def _extract_sequence_features(self, sequence):
+        """Extract features from protein sequence for learning."""
+        try:
+            # Basic sequence features
+            length = len(sequence)
+            
+            # Amino acid composition
+            aa_counts = {}
+            for aa in 'ACDEFGHIKLMNPQRSTVWYUOJBZX':
+                aa_counts[aa] = sequence.count(aa) / length if length > 0 else 0
+            
+            # Secondary structure propensities (simplified)
+            helix_propensity = sum(sequence.count(aa) for aa in 'AEHKQR') / length if length > 0 else 0
+            sheet_propensity = sum(sequence.count(aa) for aa in 'VIFYW') / length if length > 0 else 0
+            coil_propensity = 1.0 - helix_propensity - sheet_propensity
+            
+            # Physicochemical properties
+            hydrophobic_count = sum(sequence.count(aa) for aa in 'AILMFPWV') / length if length > 0 else 0
+            charged_count = sum(sequence.count(aa) for aa in 'DEKR') / length if length > 0 else 0
+            polar_count = sum(sequence.count(aa) for aa in 'NQSTY') / length if length > 0 else 0
+            
+            # Extended amino acids
+            extended_count = sum(sequence.count(aa) for aa in 'UOJBZX') / length if length > 0 else 0
+            
+            # Combine features
+            features = [
+                length / 1000.0,  # Normalized length
+                helix_propensity,
+                sheet_propensity,
+                coil_propensity,
+                hydrophobic_count,
+                charged_count,
+                polar_count,
+                extended_count
+            ]
+            
+            # Add amino acid composition
+            features.extend([aa_counts[aa] for aa in 'ACDEFGHIKLMNPQRSTVWYUOJBZX'])
+            
+            return np.array(features)
+            
+        except Exception as e:
+            print(f"Feature extraction error: {str(e)}")
+            return None
+    
+    def _extract_target_labels(self, prediction_record):
+        """Extract target labels from prediction record."""
+        try:
+            # Get secondary structure from PDB validation if available
+            pdb_validation = prediction_record.get('pdb_validation')
+            
+            if pdb_validation and pdb_validation.get('best_match'):
+                # Use PDB validation as ground truth
+                validation_status = pdb_validation.get('validation_status', 'NOVEL_SEQUENCE')
+                
+                # Convert validation status to numerical target
+                status_mapping = {
+                    'KNOWN_SEQUENCE': 1.0,
+                    'HIGHLY_SIMILAR': 0.8,
+                    'MODERATELY_SIMILAR': 0.6,
+                    'DISTANTLY_RELATED': 0.4,
+                    'NOVEL_SEQUENCE': 0.2
+                }
+                
+                confidence_target = status_mapping.get(validation_status, 0.2)
+                
+                return np.array([confidence_target])
+            
+            # Fallback to user feedback
+            user_feedback = prediction_record.get('user_feedback')
+            if user_feedback:
+                accuracy_rating = user_feedback.get('accuracy_rating', 0.5)
+                return np.array([accuracy_rating])
+            
+            return None
+            
+        except Exception as e:
+            print(f"Target extraction error: {str(e)}")
+            return None
+    
+    def _update_model_with_feedback(self, features, labels):
+        """Update the model with new training data."""
+        try:
+            # For now, we'll update a simple confidence predictor
+            # In a full implementation, this would update the main prediction model
+            
+            from sklearn.linear_model import SGDRegressor
+            
+            # Load or create confidence predictor
+            confidence_model_path = self.model_versions / "confidence_predictor.pkl"
+            
+            if confidence_model_path.exists():
+                with open(confidence_model_path, 'rb') as f:
+                    confidence_model = pickle.load(f)
+            else:
+                confidence_model = SGDRegressor(random_state=42)
+                # Initial fit with dummy data if no previous model
+                dummy_features = np.random.randn(10, features.shape[1])
+                dummy_labels = np.random.rand(10)
+                confidence_model.fit(dummy_features, dummy_labels)
+            
+            # Partial fit with new data (online learning)
+            confidence_model.partial_fit(features, labels.ravel())
+            
+            # Save updated model
+            with open(confidence_model_path, 'wb') as f:
+                pickle.dump(confidence_model, f)
+            
+            print(f"AEGIS Learning: Updated confidence model with {len(features)} new samples")
+            
+        except Exception as e:
+            print(f"Model update error: {str(e)}")
+    
+    def _update_performance_metrics(self, predictions):
+        """Update performance tracking metrics."""
+        try:
+            performance_data = self._load_json(self.performance_log)
+            
+            # Calculate recent accuracy
+            recent_predictions = predictions[-50:]  # Last 50 predictions
+            
+            if recent_predictions:
+                # PDB validation success rate
+                pdb_successes = sum(1 for p in recent_predictions 
+                                  if p.get('pdb_validation', {}).get('validation_status') in 
+                                  ['KNOWN_SEQUENCE', 'HIGHLY_SIMILAR'])
+                pdb_success_rate = pdb_successes / len(recent_predictions)
+                
+                # Average learning value (proxy for quality)
+                avg_learning_value = np.mean([p.get('learning_value', 0) for p in recent_predictions])
+                
+                # Add to performance log
+                performance_entry = {
+                    "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                    "total_predictions": len(predictions),
+                    "pdb_success_rate": pdb_success_rate,
+                    "avg_learning_value": avg_learning_value,
+                    "recent_sample_size": len(recent_predictions)
+                }
+                
+                performance_data["accuracy_over_time"].append(performance_entry)
+                performance_data["pdb_validation_success_rate"].append(pdb_success_rate)
+                
+                # Keep only last 100 entries
+                for key in ["accuracy_over_time", "pdb_validation_success_rate"]:
+                    if len(performance_data[key]) > 100:
+                        performance_data[key] = performance_data[key][-100:]
+                
+                self._save_json(self.performance_log, performance_data)
+                
+                print(f"AEGIS Learning: Updated performance metrics - PDB Success: {pdb_success_rate:.2%}")
+            
+        except Exception as e:
+            print(f"Performance metrics update error: {str(e)}")
+    
+    def get_learning_stats(self):
+        """Get current learning statistics."""
+        try:
+            training_log = self._load_json(self.training_log)
+            performance_data = self._load_json(self.performance_log)
+            feedback_data = self._load_json(self.feedback_db)
+            
+            # Calculate recent performance
+            recent_performance = performance_data.get("accuracy_over_time", [])
+            current_pdb_success = recent_performance[-1].get("pdb_success_rate", 0) if recent_performance else 0
+            
+            stats = {
+                "total_predictions": training_log.get("total_predictions", 0),
+                "successful_validations": training_log.get("successful_validations", 0),
+                "learning_sessions": training_log.get("learning_sessions", 0),
+                "model_updates": training_log.get("model_updates", 0),
+                "last_update": training_log.get("last_update", "Never"),
+                "current_pdb_success_rate": current_pdb_success,
+                "total_feedback_records": len(feedback_data.get("predictions", [])),
+                "learning_system_status": "Active" if training_log.get("model_updates", 0) > 0 else "Initializing"
+            }
+            
+            return stats
+            
+        except Exception as e:
+            print(f"Error getting learning stats: {str(e)}")
+            return {"error": str(e)}
+    
+    def add_user_feedback(self, sequence, prediction_result, accuracy_rating, comments=""):
+        """Add user feedback for a prediction."""
+        try:
+            feedback_data = self._load_json(self.feedback_db)
+            
+            user_feedback = {
+                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "sequence": sequence,
+                "accuracy_rating": accuracy_rating,  # 0.0 to 1.0
+                "comments": comments,
+                "prediction_confidence": prediction_result.get('confidence', 0.0)
+            }
+            
+            feedback_data["user_corrections"].append(user_feedback)
+            self._save_json(self.feedback_db, feedback_data)
+            
+            print(f"AEGIS Learning: User feedback recorded (Rating: {accuracy_rating:.2f})")
+            
+            # Trigger learning if we have enough feedback
+            if len(feedback_data["user_corrections"]) % 10 == 0:
+                self.perform_learning_session()
+            
+        except Exception as e:
+            print(f"Error adding user feedback: {str(e)}")
+
+
+# Initialize learning system
+aegis_learning = AEGISLearningSystem()
+
+
 class PDBValidator:
     """Validates protein sequences against RCSB PDB database using REST API."""
     
@@ -1175,7 +1618,7 @@ protein_predictor = ProteinStructurePredictor()
 
 
 def load_model_interface():
-    """Load model interface for Gradio with external dataset info."""
+    """Load model interface for Gradio with external dataset info and learning stats."""
     success, message = protein_predictor.load_model()
     
     # Add external dataset information
@@ -1183,10 +1626,22 @@ def load_model_interface():
     
     dataset_status = "\n\nExternal Dataset Status:\n"
     for key, info in dataset_info.items():
-        status_icon = "Available" if info['status'] == 'Available' else "Warning"
-        dataset_status += f"- {status_icon}: {info['description']}: {info['status']}\n"
+        status_icon = "✓" if info['status'] == 'Available' else "⚠"
+        dataset_status += f"{status_icon} {info['description']}: {info['status']}\n"
     
-    return message + dataset_status
+    # Add learning system statistics
+    learning_stats = aegis_learning.get_learning_stats()
+    
+    learning_status = f"\n\nAEGIS Continuous Learning System:\n"
+    learning_status += f"📊 Total Predictions: {learning_stats.get('total_predictions', 0)}\n"
+    learning_status += f"✅ Successful Validations: {learning_stats.get('successful_validations', 0)}\n"
+    learning_status += f"🧠 Learning Sessions: {learning_stats.get('learning_sessions', 0)}\n"
+    learning_status += f"🔄 Model Updates: {learning_stats.get('model_updates', 0)}\n"
+    learning_status += f"📈 PDB Success Rate: {learning_stats.get('current_pdb_success_rate', 0):.1%}\n"
+    learning_status += f"🕒 Last Update: {learning_stats.get('last_update', 'Never')}\n"
+    learning_status += f"🎯 Status: {learning_stats.get('learning_system_status', 'Unknown')}\n"
+    
+    return message + dataset_status + learning_status
 
 
 # Fix the problematic SMILES analysis section (around line 1170)
@@ -1372,6 +1827,15 @@ Gaston Software Solutions Tec | Tel: +256755274944
     pdb_validation = pdb_validator.validate_sequence(protein_seq, job_name)
     pdb_report = pdb_validator.format_validation_report(pdb_validation)
     
+    # AEGIS LEARNING: Record prediction for continuous learning
+    print(f"AEGIS Learning: Recording prediction for continuous learning...")
+    learning_record = aegis_learning.record_prediction(
+        sequence=protein_seq,
+        prediction_result=result,
+        pdb_validation=pdb_validation,
+        user_feedback=None  # Will be added later if user provides feedback
+    )
+    
     # Format enhanced results with external data
     ss_stats = {
         'H': result['secondary_structure'].count('H'),
@@ -1470,6 +1934,81 @@ REMARK 999 EXTERNAL DATASET REFERENCES:
     
     return summary, pdb_analysis, pdb_content
 
+def predict_interface_with_feedback_storage(sequence, job_name="protein_prediction"):
+    """Enhanced prediction interface with feedback data storage."""
+    global current_prediction_data
+    
+    # Call the main prediction function
+    summary, pdb_analysis, pdb_content = predict_interface(sequence, job_name)
+    
+    # Store current prediction data for feedback
+    current_prediction_data["sequence"] = sequence
+    current_prediction_data["job_name"] = job_name
+    
+    return summary, pdb_analysis, pdb_content, sequence  # Return sequence for feedback form
+
+def submit_user_feedback(sequence, rating, comments, current_prediction_result=None):
+    """Submit user feedback for continuous learning."""
+    try:
+        if not sequence.strip():
+            return "Please make a prediction first to provide feedback"
+        
+        # Add user feedback to learning system
+        aegis_learning.add_user_feedback(
+            sequence=sequence,
+            prediction_result=current_prediction_result or {},
+            accuracy_rating=rating,
+            comments=comments
+        )
+        
+        return f"✅ Feedback submitted! Rating: {rating:.1f}/1.0 - Thank you for helping AEGIS learn!"
+        
+    except Exception as e:
+        return f"❌ Error submitting feedback: {str(e)}"
+
+def get_learning_statistics():
+    """Get current learning statistics for display."""
+    try:
+        stats = aegis_learning.get_learning_stats()
+        
+        if "error" in stats:
+            return f"❌ Error loading stats: {stats['error']}"
+        
+        stats_display = f"""
+## 🧠 AEGIS Continuous Learning Statistics
+
+### 📊 **Prediction Activity**
+- **Total Predictions:** {stats.get('total_predictions', 0):,}
+- **Successful PDB Validations:** {stats.get('successful_validations', 0):,}
+- **Current PDB Success Rate:** {stats.get('current_pdb_success_rate', 0):.1%}
+
+### 🔄 **Learning Progress**
+- **Learning Sessions Completed:** {stats.get('learning_sessions', 0):,}
+- **Model Updates:** {stats.get('model_updates', 0):,}
+- **Last Model Update:** {stats.get('last_update', 'Never')}
+
+### 🎯 **System Status**
+- **Learning System:** {stats.get('learning_system_status', 'Unknown')}
+- **Total Feedback Records:** {stats.get('total_feedback_records', 0):,}
+
+### 📈 **Performance Insights**
+- The system automatically learns from PDB validation results
+- High-confidence predictions with PDB matches improve the model
+- User feedback accelerates learning and fine-tunes accuracy
+- Learning sessions trigger every 50 predictions or with high-value data
+
+---
+*AEGIS learns continuously to provide better predictions over time!*
+"""
+        
+        return stats_display
+        
+    except Exception as e:
+        return f"❌ Error getting learning statistics: {str(e)}"
+
+# Global variable to store current prediction for feedback
+current_prediction_data = {"sequence": "", "result": None}
+
 def create_gradio_interface():
     """Create the Gradio interface."""
     
@@ -1601,15 +2140,69 @@ def create_gradio_interface():
                     interactive=False
                 )
         
+        # User Feedback Section for Continuous Learning
+        gr.HTML("<hr>")
+        gr.HTML("""
+        <div class="info-box">
+            <h3>🧠 AEGIS Continuous Learning - User Feedback</h3>
+            <p>Help AEGIS learn and improve by providing feedback on prediction accuracy!</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML("<h4>Prediction Feedback</h4>")
+                
+                feedback_sequence = gr.Textbox(
+                    label="Sequence (auto-filled from last prediction)",
+                    placeholder="Sequence will be auto-filled...",
+                    interactive=False
+                )
+                
+                accuracy_rating = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.5,
+                    step=0.1,
+                    label="Accuracy Rating (0.0 = Poor, 1.0 = Excellent)",
+                    info="Rate how accurate you think the prediction was"
+                )
+                
+                feedback_comments = gr.Textbox(
+                    label="Comments (Optional)",
+                    placeholder="Any specific observations about the prediction...",
+                    lines=3
+                )
+                
+                submit_feedback_btn = gr.Button("Submit Feedback", variant="secondary")
+                feedback_status = gr.Textbox(
+                    label="Feedback Status",
+                    value="No feedback submitted yet",
+                    interactive=False
+                )
+            
+            with gr.Column(scale=1):
+                gr.HTML("<h4>Learning Statistics</h4>")
+                
+                learning_stats_display = gr.Markdown(
+                    value="Click 'Refresh Stats' to see current learning statistics",
+                    label="AEGIS Learning Stats"
+                )
+                
+                refresh_stats_btn = gr.Button("Refresh Learning Stats", variant="secondary")
+        
         # Information section
         gr.HTML("<hr>")
         gr.HTML("""
         <div class="info-box">
-            <h3>About AEGIS Enhanced System with External Dataset Integration + PDB Validation</h3>
+            <h3>About AEGIS Enhanced System with Continuous Learning</h3>
             <ul>
                 <li><strong>Input Types:</strong> Protein sequences, DNA, RNA, SMILES (auto-detection)</li>
                 <li><strong>External Datasets:</strong> SandboxAQ/SAIR, ZINC-canonicalized, Essential genes</li>
                 <li><strong>PDB Validation:</strong> Cross-references sequences against RCSB PDB database</li>
+                <li><strong>Continuous Learning:</strong> Model improves from PDB validation and user feedback</li>
+                <li><strong>Learning Triggers:</strong> Auto-learning every 50 predictions or high-value data</li>
+                <li><strong>Performance Tracking:</strong> Monitors accuracy and success rates over time</li>
                 <li><strong>Sequence Search:</strong> Identifies similar known protein structures</li>
                 <li><strong>Validation Status:</strong> KNOWN, HIGHLY_SIMILAR, MODERATELY_SIMILAR, NOVEL</li>
                 <li><strong>Enhanced Analysis:</strong> Searches external HF datasets for similar sequences</li>
@@ -1618,8 +2211,8 @@ def create_gradio_interface():
                 <li><strong>Extended Amino Acids:</strong> Supports U (selenocysteine), O (pyrrolysine), ambiguous codes</li>
                 <li><strong>Translation:</strong> Automatic DNA/RNA to protein translation (all reading frames)</li>
                 <li><strong>Drug Discovery:</strong> SMILES analysis with protein-drug interaction prediction</li>
-                <li><strong>Method:</strong> CPU-based ML + External Dataset + PDB Strategic Precognition</li>
-                <li><strong>Performance:</strong> Enhanced accuracy through reference data integration</li>
+                <li><strong>Method:</strong> CPU-based ML + External Dataset + PDB + Continuous Learning</li>
+                <li><strong>Performance:</strong> Enhanced accuracy through reference data integration + learning</li>
                 <li><strong>Libraries:</strong> BioPython, scikit-learn, HuggingFace Hub, RCSB PDB API</li>
             </ul>
         </div>
@@ -1632,14 +2225,25 @@ def create_gradio_interface():
         )
         
         predict_btn.click(
-            fn=predict_interface,
+            fn=predict_interface_with_feedback_storage,
             inputs=[sequence_input, job_name_input],
-            outputs=[prediction_summary, pdb_analysis, pdb_content]
+            outputs=[prediction_summary, pdb_analysis, pdb_content, feedback_sequence]
+        )
+        
+        submit_feedback_btn.click(
+            fn=submit_user_feedback,
+            inputs=[feedback_sequence, accuracy_rating, feedback_comments],
+            outputs=feedback_status
+        )
+        
+        refresh_stats_btn.click(
+            fn=get_learning_statistics,
+            outputs=learning_stats_display
         )
         
         clear_btn.click(
-            fn=lambda: ("", "protein_prediction", "Results will appear here after prediction...", "", ""),
-            outputs=[sequence_input, job_name_input, prediction_summary, pdb_analysis, pdb_content]
+            fn=lambda: ("", "protein_prediction", "Results will appear here after prediction...", "", "", "", 0.5, "", "No feedback submitted yet"),
+            outputs=[sequence_input, job_name_input, prediction_summary, pdb_analysis, pdb_content, feedback_sequence, accuracy_rating, feedback_comments, feedback_status]
         )
     
     return interface