Update course_recommender.py

course_recommender.py

@@ -17,6 +17,10 @@ class CourseRecommender:
         self.scaler = StandardScaler()
         self.db_connection = DatabaseConnection()
         self.is_trained = False
+        self._available_courses = None  # Cache for available courses
+        self._last_data_count = 0  # Track data count for auto-retraining
+        self._auto_retrain_threshold = 5  # Retrain every 5 new feedbacks
+        self._min_samples_for_training = 10  # Minimum samples needed to train
         
     def preprocess_data(self, df: pd.DataFrame) -> pd.DataFrame:
         """Preprocess the data for training"""
@@ -85,23 +89,96 @@ class CourseRecommender:
         
         return df_features
     
+    def get_available_courses(self):
+        """Get available courses with caching"""
+        if self._available_courses is None:
+            # Try to get courses from /courses endpoint first
+            courses = self.db_connection.get_available_courses()
+            if not courses:
+                print("No courses found in /courses endpoint. Using courses from student feedback data...")
+                # Get courses from student feedback data
+                df_temp = self.db_connection.get_student_feedback_counts()
+                if df_temp.empty:
+                    raise ValueError("No courses available in /courses endpoint and no student feedback data found.")
+                courses = df_temp['course'].unique().tolist()
+                print(f"Using courses from student feedback: {courses}")
+            
+            self._available_courses = courses
+            print(f"Available courses cached: {len(courses)} courses")
+        
+        return self._available_courses
+    
+    def refresh_courses_cache(self):
+        """Refresh the available courses cache"""
+        self._available_courses = None
+        return self.get_available_courses()
+    
+    def get_current_data_count(self):
+        """Get current number of feedback records in database"""
+        try:
+            df = self.db_connection.get_student_feedback_counts()
+            return len(df) if not df.empty else 0
+        except:
+            return 0
+    
+    def check_and_auto_retrain(self):
+        """Check if enough new data exists and auto-retrain if needed"""
+        current_count = self.get_current_data_count()
+        
+        if current_count < self._min_samples_for_training:
+            print(f"Not enough data for training: {current_count} < {self._min_samples_for_training}")
+            return False
+        
+        if current_count - self._last_data_count >= self._auto_retrain_threshold:
+            print(f"Auto-retraining triggered: {current_count - self._last_data_count} new feedbacks")
+            try:
+                accuracy = self.train_model(use_database=True)
+                self._last_data_count = current_count
+                print(f"Auto-retraining completed with accuracy: {accuracy:.3f}")
+                return True
+            except Exception as e:
+                print(f"Auto-retraining failed: {e}")
+                return False
+        
+        return False
+    
+    def add_feedback_with_learning(self, course: str, stanine: int, gwa: float, strand: str, 
+                                 rating: int, hobbies: str) -> bool:
+        """Add feedback to database and trigger auto-learning if needed"""
+        # Add feedback to database
+        success = self.db_connection.add_feedback(course, stanine, gwa, strand, rating, hobbies)
+        
+        if success:
+            print(f"Feedback added for course: {course}")
+            # Check if we should auto-retrain
+            self.check_and_auto_retrain()
+        
+        return success
+    
+    def configure_auto_learning(self, retrain_threshold=5, min_samples=10):
+        """Configure auto-learning parameters"""
+        self._auto_retrain_threshold = retrain_threshold
+        self._min_samples_for_training = min_samples
+        print(f"Auto-learning configured: retrain every {retrain_threshold} new feedbacks, minimum {min_samples} samples")
+    
+    def get_learning_status(self):
+        """Get current learning status"""
+        current_count = self.get_current_data_count()
+        return {
+            'current_data_count': current_count,
+            'last_trained_count': self._last_data_count,
+            'new_feedbacks': current_count - self._last_data_count,
+            'retrain_threshold': self._auto_retrain_threshold,
+            'min_samples': self._min_samples_for_training,
+            'ready_for_retrain': (current_count - self._last_data_count) >= self._auto_retrain_threshold
+        }
+    
     def train_model(self, use_database: bool = True):
         """Train the recommendation model using student feedback data"""
         print("Loading training data from student feedback...")
         
-        # Get available courses from /courses endpoint
-        available_courses = self.db_connection.get_available_courses()
-        if not available_courses:
-            print("No courses found in /courses endpoint. Using courses from student feedback data...")
-            # Get courses from student feedback data
-            df_temp = self.db_connection.get_student_feedback_counts()
-            if df_temp.empty:
-                raise ValueError("No courses available in /courses endpoint and no student feedback data found.")
-            available_courses = df_temp['course'].unique().tolist()
-            print(f"Using courses from student feedback: {available_courses}")
-        
-        print(f"Available courses from /courses: {len(available_courses)}")
-        print(f"Available courses: {available_courses}")
+        # Get available courses with caching
+        available_courses = self.get_available_courses()
         
         # Get training data from student feedback
         df = self.db_connection.get_student_feedback_counts()
@@ -170,6 +247,9 @@ class CourseRecommender:
         # Save model
         self.save_model()
         
+        # Update data count tracking
+        self._last_data_count = len(df_clean)
+        
         return accuracy
     
     def predict_course(self, stanine: int, gwa: float, strand: str, hobbies: str) -> List[Tuple[str, float]]:
@@ -179,16 +259,8 @@ class CourseRecommender:
             if not self.is_trained:
                 raise ValueError("Model not trained. Please train the model first.")
         
-        # Get available courses from /courses endpoint
-        available_courses = self.db_connection.get_available_courses()
-        if not available_courses:
-            print("No courses found in /courses endpoint. Using courses from student feedback data...")
-            # Get courses from student feedback data
-            df_temp = self.db_connection.get_student_feedback_counts()
-            if df_temp.empty:
-                raise ValueError("No courses available in /courses endpoint and no student feedback data found.")
-            available_courses = df_temp['course'].unique().tolist()
-            print(f"Using courses from student feedback: {available_courses}")
+        # Get available courses with caching
+        available_courses = self.get_available_courses()
         
         # Create input data
         input_data = pd.DataFrame({
@@ -243,6 +315,10 @@ class CourseRecommender:
             self.label_encoders = joblib.load('models/label_encoders.pkl')
             self.scaler = joblib.load('models/scaler.pkl')
             self.is_trained = True
+            
+            # Initialize data count tracking
+            self._last_data_count = self.get_current_data_count()
+            
             print("Model loaded successfully")
         except FileNotFoundError:
             print("No saved model found. Please train the model first.")