Delete recommender.py

recommender.py

@@ -1,641 +0,0 @@
-import pandas as pd
-import numpy as np
-from sklearn.neighbors import KNeighborsClassifier
-from sklearn.preprocessing import LabelEncoder, StandardScaler
-import joblib
-import json
-import os
-import requests
-
-class CourseRecommender:
-    def __init__(self, database_url="https://database-dhe2.onrender.com"):
-        self.model = None
-        self.label_encoders = {}
-        self.scaler = StandardScaler()
-        self.database_url = database_url
-        self.courses = self.get_courses()
-        self.training_data = self.get_training_data()
-        self.train_model()
-    
-    def get_courses(self):
-        """Get course data for the provided courses only"""
-        return {
-            # CASTECH
-            'BSA': 'Bachelor of Science in Agriculture',
-            'BSFish': 'Bachelor of Science in Fisheries',
-            'BSFoodTech': 'Bachelor of Science in Food Technology',
-            
-            # CFA
-            'BSFo': 'Bachelor of Science in Forestry',
-            'BSAgFo': 'Bachelor of Science in Agroforestry',
-            
-            # CBEE
-            'BSHM': 'Bachelor of Science in Hospitality Management',
-            'BSEntrep': 'Bachelor of Science in Entrepreneurship',
-            'BSAgribus': 'Bachelor of Science in Agriculture Business',
-            'BSAgEcon': 'Bachelor of Science in Agricultural Economics',
-            
-            # CAS
-            'BSBio': 'Bachelor of Science in Biology',
-            'BSMath': 'Bachelor of Science in Mathematics',
-            'BAELS': 'Bachelor of Arts in English Language Studies',
-            'BSDevComm': 'Bachelor of Science in Development Communication',
-            
-            # COECS
-            'BSABE': 'Bachelor of Science in Agricultural and Biosystems Engineering',
-            'BSGE': 'Bachelor of Science in Geodetic Engineering',
-            'BSCE': 'Bachelor of Science in Civil Engineering',
-            'BSCpE': 'Bachelor of Science in Computer Engineering',
-            'BSIT': 'Bachelor of Science in Information Technology',
-            
-            # COED
-            'BTLEd': 'Bachelor of Technology and Livelihood Education',
-            'BSED': 'Bachelor of Secondary Education',
-            'BEED': 'Bachelor of Elementary Education',
-            'BPE': 'Bachelor of Physical Education',
-            
-            # CVM
-            'DVM': 'Doctor of Veterinary Medicine'
-        }
-
-    def save_student_data(self, stanine, gwa, strand, course, rating, hobbies=None):
-        """Save student feedback (disabled - read-only mode)"""
-        print(f"Student feedback (read-only mode): Stanine={stanine}, GWA={gwa}, Strand={strand}, Course={course}, Rating={rating}, Hobbies={hobbies}")
-            return True
-
-    def get_training_data(self):
-        """Get training data from database, fallback to static data"""
-        try:
-            # Try to get data from database first
-            db_data = self.get_training_data_from_database()
-            if db_data is not None and not db_data.empty:
-                print(f"Loaded {len(db_data)} training records from database")
-                return db_data
-            else:
-                print("No database data available, using static training data")
-                return self.get_static_training_data()
-        except Exception as e:
-            print(f"Error loading database data: {e}, using static training data")
-            return self.get_static_training_data()
-
-    def get_training_data_from_database(self):
-        """Fetch training data from database using existing endpoints"""
-        try:
-            print(f"Attempting to fetch data from database: {self.database_url}/student_feedback_counts")
-            
-            # Try to get student feedback data from your existing endpoint
-            response = requests.get(f"{self.database_url}/student_feedback_counts", timeout=10)
-            
-            print(f"Database response status: {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"Response data keys: {list(data.keys())}")
-                
-                feedback_counts = data.get('feedback_counts', [])
-                print(f"Number of records in database: {len(feedback_counts)}")
-                
-                if not feedback_counts:
-                    print("No student feedback data found in database")
-                    return None
-                
-                # Convert database data to training format
-                training_data = []
-                valid_records = 0
-                
-                for i, record in enumerate(feedback_counts):
-                    print(f"Processing record {i+1}: {record}")
-                    
-                    # Check if record has the required fields
-                    if all(key in record for key in ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies']):
-                        training_data.append((
-                            int(record['stanine']),
-                            float(record['gwa']), 
-                            str(record['strand']),
-                            str(record['course']),
-                            int(record['rating']),
-                            str(record['hobbies'] or '')
-                        ))
-                        valid_records += 1
-                    else:
-                        missing_fields = [key for key in ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies'] if key not in record]
-                        print(f"Record {i+1} missing fields: {missing_fields}")
-                
-                print(f"Valid records processed: {valid_records}/{len(feedback_counts)}")
-                
-                if training_data:
-                    print(f"Successfully loaded {len(training_data)} records from database")
-                    return pd.DataFrame(training_data, columns=['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies'])
-                else:
-                    print("No valid training records found in database")
-                    return None
-            else:
-                print(f"Database endpoint returned status {response.status_code}")
-                print(f"Response text: {response.text}")
-                return None
-            
-        except requests.exceptions.ConnectionError:
-            print("Cannot connect to database - using static data")
-            return None
-        except Exception as e:
-            print(f"Error fetching training data from database: {e}")
-            import traceback
-            traceback.print_exc()
-            return None
-
-    def get_static_training_data(self):
-        """Get static training data for the provided courses only (including GAS, TVL)"""
-        training_data = [
-            # CASTECH - Agriculture Science and Technology
-            (8, 92, 'STEM', 'BSA', 5, 'farming, agriculture, plants, environment'),
-            (7, 88, 'STEM', 'BSFish', 4, 'fishing, marine life, aquaculture, water'),
-            (8, 90, 'STEM', 'BSFoodTech', 5, 'food processing, nutrition, cooking, science'),
-            (6, 80, 'STEM', 'BSA', 3, 'farming, plants, agriculture'),
-            (7, 85, 'STEM', 'BSFish', 3, 'fishing, marine, aquaculture'),
-            (8, 89, 'STEM', 'BSFoodTech', 4, 'food, nutrition, science'),
-            
-            # CFA - Forestry and Agroforestry
-            (7, 85, 'STEM', 'BSFo', 4, 'forests, trees, environment, conservation'),
-            (6, 82, 'STEM', 'BSAgFo', 3, 'forestry, agriculture, sustainable farming'),
-            (8, 88, 'STEM', 'BSFo', 4, 'forestry, environment, conservation'),
-            (7, 82, 'STEM', 'BSAgFo', 3, 'agroforestry, sustainable farming'),
-            
-            # CBEE - Business and Economics Education
-            (8, 89, 'ABM', 'BSHM', 5, 'hospitality, tourism, service, management'),
-            (7, 87, 'ABM', 'BSEntrep', 4, 'business, entrepreneurship, innovation, startups'),
-            (8, 91, 'ABM', 'BSAgribus', 5, 'agriculture business, farming, economics'),
-            (7, 86, 'ABM', 'BSAgEcon', 4, 'agriculture economics, farming, business'),
-            (7, 83, 'ABM', 'BSHM', 3, 'hospitality, service, tourism'),
-            (7, 84, 'ABM', 'BSEntrep', 3, 'business, entrepreneurship, innovation'),
-            (8, 86, 'ABM', 'BSAgribus', 4, 'agriculture business, farming'),
-            (8, 87, 'ABM', 'BSAgEcon', 4, 'agriculture economics, business'),
-            
-            # CAS - Arts and Sciences
-            (8, 93, 'STEM', 'BSBio', 5, 'biology, science, research, nature'),
-            (9, 95, 'STEM', 'BSMath', 5, 'mathematics, numbers, problem solving, logic'),
-            (7, 85, 'HUMSS', 'BAELS', 4, 'english, language, literature, communication'),
-            (7, 84, 'HUMSS', 'BSDevComm', 4, 'communication, media, development, social work'),
-            (8, 88, 'STEM', 'BSBio', 4, 'biology, science, research'),
-            (9, 94, 'STEM', 'BSMath', 4, 'mathematics, problem solving, logic'),
-            (7, 82, 'HUMSS', 'BAELS', 3, 'english, language, communication'),
-            (6, 80, 'HUMSS', 'BSDevComm', 3, 'communication, media, development'),
-            
-            # HUMSS students with programming interests
-            (8, 90, 'HUMSS', 'BSIT', 5, 'programming, computers, technology, coding'),
-            (7, 85, 'HUMSS', 'BSCpE', 4, 'programming, computer engineering, hardware'),
-            (8, 88, 'HUMSS', 'BSDevComm', 4, 'programming, media, communication, technology'),
-            (6, 80, 'HUMSS', 'BSIT', 3, 'programming, computers, ict'),
-
-            # GAS - General Academic Strand (broad interests)
-            (7, 85, 'GAS', 'BAELS', 4, 'communication, language, writing, literature'),
-            (7, 84, 'GAS', 'BSDevComm', 4, 'media, community, development, communication'),
-            (7, 83, 'GAS', 'BSHM', 3, 'hospitality, service, events'),
-            (7, 86, 'GAS', 'BSIT', 3, 'computers, technology, ict basics'),
-            
-            # COECS - Engineering and Computer Studies
-            (8, 92, 'STEM', 'BSABE', 5, 'engineering, agriculture, technology, machines'),
-            (7, 88, 'STEM', 'BSGE', 4, 'surveying, mapping, engineering, technology'),
-            (8, 90, 'STEM', 'BSCE', 5, 'civil engineering, construction, buildings, infrastructure'),
-            (9, 94, 'STEM', 'BSCpE', 5, 'computer engineering, programming, hardware, technology'),
-            (8, 91, 'STEM', 'BSIT', 5, 'information technology, computers, programming, software'),
-            (7, 83, 'STEM', 'BSABE', 3, 'agricultural engineering, technology'),
-            (7, 84, 'STEM', 'BSGE', 3, 'surveying, mapping, engineering'),
-            (8, 90, 'STEM', 'BSCE', 4, 'engineering, construction, buildings'),
-            (8, 88, 'STEM', 'BSCpE', 4, 'computer engineering, programming'),
-            (8, 87, 'STEM', 'BSIT', 4, 'computers, programming, technology'),
-            
-            # COED - Education
-            (7, 86, 'HUMSS', 'BTLEd', 4, 'teaching, technology, livelihood, education'),
-            (8, 89, 'HUMSS', 'BSED', 5, 'teaching, education, helping students, secondary'),
-            (7, 87, 'HUMSS', 'BEED', 4, 'teaching, elementary education, children, helping'),
-            (7, 85, 'HUMSS', 'BPE', 4, 'physical education, sports, fitness, teaching'),
-            (6, 79, 'HUMSS', 'BTLEd', 3, 'technology education, livelihood'),
-            (6, 79, 'HUMSS', 'BSED', 3, 'teaching, education, helping'),
-            (6, 81, 'HUMSS', 'BEED', 3, 'elementary education, teaching'),
-            (8, 89, 'HUMSS', 'BPE', 4, 'physical education, sports, fitness'),
-            
-            # CVM - Veterinary Medicine
-            (9, 96, 'STEM', 'DVM', 5, 'veterinary, animals, medicine, healthcare, pets'),
-            (8, 91, 'STEM', 'DVM', 4, 'veterinary medicine, animals, healthcare')
-
-            # TVL - Technical-Vocational-Livelihood (use hobbies to infer subtrack)
-            ,(7, 84, 'TVL', 'BSIT', 4, 'ict, computers, programming, networking')
-            ,(7, 83, 'TVL', 'BSCpE', 3, 'ict, hardware, electronics, robotics')
-            ,(7, 82, 'TVL', 'BSHM', 3, 'he, hospitality, cooking, baking, services')
-            ,(7, 82, 'TVL', 'BTLEd', 3, 'he, livelihood, crafts, home economics')
-            ,(7, 83, 'TVL', 'BSABE', 3, 'ia, industrial, mechanics, tools, machining')
-            ,(7, 83, 'TVL', 'BSCE', 3, 'ia, construction, drafting, carpentry, welding')
-            ,(7, 84, 'TVL', 'BSA', 3, 'agri-fishery, farming, crops, livestock')
-            ,(7, 84, 'TVL', 'BSFish', 3, 'agri-fishery, aquaculture, fishing')
-            ,(7, 83, 'TVL', 'BSAgFo', 3, 'agri-fishery, agroforestry, environment')
-        ]
-        
-        return pd.DataFrame(training_data, columns=['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies'])
-
-    def train_model(self):
-        """Train the recommendation model using the training data"""
-        try:
-            training_data = self.get_training_data()
-            
-            if training_data.empty:
-                print("No training data available - using default recommendations")
-                return
-            
-            # Prepare features (hobbies required)
-            feature_columns = ['stanine', 'gwa', 'strand', 'hobbies']
-            
-            # Create feature matrix
-            X = training_data[feature_columns].copy()
-            y = training_data['course']
-            
-            # Handle categorical variables
-            categorical_columns = ['strand', 'hobbies']
-            
-            # Refit encoders every training to incorporate new categories
-            for col in categorical_columns:
-                if col in X.columns:
-                    X[col] = X[col].fillna('unknown')
-                    self.label_encoders[col] = LabelEncoder()
-                    X[col] = self.label_encoders[col].fit_transform(X[col])
-            
-            # Scale numerical features
-            numerical_columns = ['stanine', 'gwa']
-            if not X[numerical_columns].empty:
-                X[numerical_columns] = self.scaler.fit_transform(X[numerical_columns])
-            
-            # Train KNN model
-            self.model = KNeighborsClassifier(n_neighbors=3, weights='distance')
-            self.model.fit(X, y)
-            
-            print("Model trained successfully")
-            print(f"Model classes: {self.model.classes_}")
-            print(f"Training data size: {len(training_data)} records")
-            
-        except Exception as e:
-            print(f"Error training model: {e}")
-            self.model = None
-
-    def refresh_training_data(self):
-        """Refresh training data from database (read-only mode)"""
-        try:
-            print("Refreshing training data from database...")
-            self.training_data = self.get_training_data()
-            self.train_model()
-            return True
-        except Exception as e:
-            print(f"Error refreshing training data: {e}")
-            return False
-
-    def test_database_connection(self):
-        """Test database connection and show detailed info"""
-        print("=== DATABASE CONNECTION TEST ===")
-        try:
-            response = requests.get(f"{self.database_url}/student_feedback_counts", timeout=10)
-            print(f"Database URL: {self.database_url}")
-            print(f"Response Status: {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"Response Keys: {list(data.keys())}")
-                
-                if 'feedback_counts' in data:
-                    records = data['feedback_counts']
-                    print(f"Number of Records: {len(records)}")
-                    
-                    if len(records) > 0:
-                        print(f"Sample Record: {records[0]}")
-                        
-                        # Check required fields
-                        required_fields = ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies']
-                        sample_record = records[0]
-                        missing_fields = [field for field in required_fields if field not in sample_record]
-                        
-                        if missing_fields:
-                            print(f"Missing Required Fields: {missing_fields}")
-                            print(f"Available Fields: {list(sample_record.keys())}")
-                        else:
-                            print("All required fields present")
-                    else:
-                        print("Database is empty")
-                else:
-                    print("'feedback_counts' key not found in response")
-            else:
-                print(f"Database Error: {response.status_code}")
-                print(f"Response: {response.text}")
-                
-        except Exception as e:
-            print(f"Connection Error: {e}")
-            import traceback
-            traceback.print_exc()
-
-    def get_default_recommendations(self, stanine, gwa, strand, hobbies: str = ""):
-        """Provide default recommendations based on basic rules when no training data is available"""
-        courses = self.courses
-        recommendations = []
-        hobbies_lc = (hobbies or "").lower()
-        
-        # Basic rules for recommendations based on strand and performance
-        if strand == 'STEM':
-            if stanine >= 8 and gwa >= 90:
-                priority_courses = ['DVM', 'BSMath', 'BSCpE', 'BSIT', 'BSBio']
-            elif stanine >= 6 and gwa >= 80:
-                priority_courses = ['BSIT', 'BSCE', 'BSABE', 'BSA', 'BSFoodTech']
-            else:
-                priority_courses = ['BSIT', 'BSGE', 'BSFish', 'BSFo', 'BSAgFo']
-        elif strand == 'ABM':
-            if stanine >= 8 and gwa >= 90:
-                priority_courses = ['BSAgribus', 'BSHM', 'BSEntrep', 'BSAgEcon']
-            else:
-                priority_courses = ['BSHM', 'BSEntrep', 'BSAgribus']
-        elif strand == 'HUMSS':
-            # HUMSS students with programming interests should get tech courses
-            if any(k in hobbies_lc for k in ['programming', 'computer', 'ict', 'tech', 'coding']):
-                priority_courses = ['BSIT', 'BSCpE', 'BSDevComm']
-            elif any(k in hobbies_lc for k in ['teaching', 'education', 'helping', 'children']):
-                priority_courses = ['BSED', 'BEED', 'BTLEd']
-            elif any(k in hobbies_lc for k in ['communication', 'media', 'writing', 'language']):
-                priority_courses = ['BAELS', 'BSDevComm', 'BSHM']
-            elif stanine >= 8 and gwa >= 90:
-                priority_courses = ['BSED', 'BEED', 'BAELS', 'BSDevComm', 'BPE']
-            else:
-                priority_courses = ['BSED', 'BEED', 'BAELS', 'BTLEd']
-        elif strand == 'GAS':
-            # Broad options leaning to comms/IT/hospitality based on hobbies
-            if any(k in hobbies_lc for k in ['ict', 'computer', 'programming', 'tech']):
-                priority_courses = ['BSIT', 'BSCpE', 'BSDevComm']
-            elif any(k in hobbies_lc for k in ['hospitality', 'events', 'service', 'tourism']):
-                priority_courses = ['BSHM', 'BSEntrep', 'BAELS']
-            else:
-                priority_courses = ['BAELS', 'BSDevComm', 'BSIT']
-        elif strand == 'TVL':
-            # Use hobbies to infer subtrack: ICT/HE/IA/Agri-Fishery
-            if any(k in hobbies_lc for k in ['ict', 'computer', 'network', 'programming', 'coding']):
-                priority_courses = ['BSIT', 'BSCpE']
-            elif any(k in hobbies_lc for k in ['he', 'cook', 'bake', 'hospitality', 'food']):
-                priority_courses = ['BSHM', 'BTLEd', 'BSFoodTech']
-            elif any(k in hobbies_lc for k in ['ia', 'industrial', 'mechanic', 'weld', 'draft']):
-                priority_courses = ['BSABE', 'BSCE', 'BTLEd']
-            elif any(k in hobbies_lc for k in ['agri', 'farm', 'fish', 'aquaculture', 'forestry']):
-                priority_courses = ['BSA', 'BSFish', 'BSAgFo']
-            else:
-                priority_courses = ['BSIT', 'BSHM', 'BSA']
-        else:
-            priority_courses = ['BSIT', 'BSHM', 'BSED', 'BSA']
-        
-        # Add courses with calculated ratings based on performance
-        for i, course in enumerate(priority_courses[:3]):  # Only take top 3
-            if course in courses:
-                # Calculate rating based on academic performance
-                base_rating = 60  # Base rating
-                stanine_bonus = (stanine - 5) * 5  # Bonus for stanine
-                gwa_bonus = (gwa - 80) * 0.5  # Bonus for GWA
-                final_rating = min(95, base_rating + stanine_bonus + gwa_bonus - (i * 10))
-                
-                recommendations.append({
-                    'code': course,
-                    'name': courses[course],
-                    'rating': round(max(10, final_rating), 1)  # Minimum 10% rating
-                })
-        
-        return recommendations
-
-    def recommend_courses(self, stanine, gwa, strand, hobbies=None, top_n=5):
-        """Recommend courses based on student profile"""
-        try:
-            if self.model is None:
-                return self.get_default_recommendations(stanine, gwa, strand, hobbies or "")
-            
-            # Prepare input features
-            input_data = pd.DataFrame([{
-                'stanine': stanine,
-                'gwa': gwa,
-                'strand': strand,
-                'hobbies': (hobbies or '').strip()
-            }])
-            
-            # Validate hobbies
-            if not input_data['hobbies'].iloc[0]:
-                raise ValueError('hobbies is required for recommendations')
-            
-            # Encode categorical variables
-            for col in ['strand', 'hobbies']:
-                if col in input_data.columns and col in self.label_encoders:
-                    value = input_data[col].iloc[0]
-                    if value not in self.label_encoders[col].classes_:
-                        # For hobbies, try to find a similar existing hobby
-                        if col == 'hobbies':
-                            similar_hobby = self._find_similar_hobby(value)
-                            if similar_hobby:
-                                print(f"Warning: Unseen hobby '{value}', using similar: '{similar_hobby}'")
-                                input_data[col] = self.label_encoders[col].transform([similar_hobby])[0]
-                            else:
-                                print(f"Warning: Unseen hobby '{value}', using default encoding")
-                                input_data[col] = 0
-                        else:
-                            print(f"Warning: Unseen value '{value}' in {col}, using default encoding")
-                            input_data[col] = 0
-                    else:
-                        input_data[col] = self.label_encoders[col].transform([value])[0]
-            
-            # Scale numerical features
-            numerical_columns = ['stanine', 'gwa']
-            if not input_data[numerical_columns].empty:
-                input_data[numerical_columns] = self.scaler.transform(input_data[numerical_columns])
-            
-            # Get predictions
-            predictions = self.model.predict_proba(input_data)
-            courses = self.model.classes_
-            
-            print(f"Prediction probabilities: {predictions[0]}")
-            print(f"Available courses: {courses}")
-            
-            # Get top recommendations with non-zero probabilities
-            top_indices = np.argsort(predictions[0])[-top_n:][::-1]
-            recommendations = []
-            
-            course_map = self.courses
-            for idx in top_indices:
-                code = courses[idx]
-                confidence = predictions[0][idx]
-                
-                # Only include courses with meaningful probabilities
-                if confidence > 0.01:  # Threshold for meaningful recommendations
-                recommendations.append({
-                    'code': code,
-                    'name': course_map.get(code, code),
-                    'rating': round(confidence * 100, 1)
-                })
-            
-            # If no meaningful recommendations, fall back to default
-            if not recommendations:
-                print("No meaningful predictions, using default recommendations")
-                return self.get_default_recommendations(stanine, gwa, strand, hobbies or "")
-            
-            return recommendations
-            
-        except Exception as e:
-            print(f"Error recommending courses: {e}")
-            return self.get_default_recommendations(stanine, gwa, strand, hobbies or "")
-
-    def _find_similar_hobby(self, hobby):
-        """Find a similar hobby from training data"""
-        hobby_lower = hobby.lower()
-        
-        # Define keyword mappings for similar hobbies
-        keyword_mappings = {
-            'programming': ['programming', 'computers', 'technology', 'coding', 'ict'],
-            'computers': ['programming', 'computers', 'technology', 'coding', 'ict'],
-            'technology': ['programming', 'computers', 'technology', 'coding', 'ict'],
-            'teaching': ['teaching', 'education', 'helping', 'children'],
-            'business': ['business', 'entrepreneurship', 'management', 'leadership'],
-            'hospitality': ['hospitality', 'tourism', 'service', 'events'],
-            'agriculture': ['farming', 'agriculture', 'plants', 'environment'],
-            'communication': ['communication', 'media', 'writing', 'language']
-        }
-        
-        # Check if any keyword matches
-        for key, keywords in keyword_mappings.items():
-            if any(keyword in hobby_lower for keyword in keywords):
-                # Find the most similar training hobby
-                training_hobbies = self.label_encoders['hobbies'].classes_
-                for training_hobby in training_hobbies:
-                    if any(keyword in training_hobby.lower() for keyword in keywords):
-                        return training_hobby
-        
-        return None
-
-    def _get_recommendation_reason(self, course, stanine, gwa, strand, hobbies, interests, personality_type, learning_style, career_goals):
-        """Generate personalized reason for recommendation"""
-        reasons = []
-        
-        # Academic performance reasons
-        if stanine >= 8:
-            reasons.append("Excellent academic performance")
-        elif stanine >= 6:
-            reasons.append("Good academic foundation")
-        
-        if gwa >= 85:
-            reasons.append("High academic achievement")
-        elif gwa >= 80:
-            reasons.append("Strong academic record")
-        
-        # Strand alignment
-        if strand == "STEM" and course in ["BSCS", "BSIT", "BSArch", "BSIE", "BSN"]:
-            reasons.append("Perfect match with your STEM background")
-        elif strand == "ABM" and course in ["BSBA", "BSA"]:
-            reasons.append("Excellent alignment with your ABM strand")
-        elif strand == "HUMSS" and course in ["BSED", "BSPsych"]:
-            reasons.append("Great fit with your HUMSS background")
-        
-        # Hobbies and interests alignment
-        if hobbies and any(hobby in hobbies.lower() for hobby in ["gaming", "programming", "technology", "computers"]):
-            if course in ["BSCS", "BSIT"]:
-                reasons.append("Matches your technology interests")
-        
-        if hobbies and any(hobby in hobbies.lower() for hobby in ["business", "leadership", "management"]):
-            if course in ["BSBA", "BSA"]:
-                reasons.append("Aligns with your business interests")
-        
-        if hobbies and any(hobby in hobbies.lower() for hobby in ["helping", "teaching", "caring"]):
-            if course in ["BSED", "BSN", "BSPsych"]:
-                reasons.append("Perfect for your helping nature")
-        
-        # Personality type alignment
-        if personality_type == "introvert" and course in ["BSCS", "BSA", "BSArch"]:
-            reasons.append("Suits your introverted personality")
-        elif personality_type == "extrovert" and course in ["BSBA", "BSED", "BSHM"]:
-            reasons.append("Great for your outgoing personality")
-        
-        # Learning style alignment
-        if learning_style == "hands-on" and course in ["BSIT", "BSHM", "BSAgri"]:
-            reasons.append("Matches your hands-on learning preference")
-        elif learning_style == "visual" and course in ["BSArch", "BSCS"]:
-            reasons.append("Perfect for your visual learning style")
-        
-        # Career goals alignment
-        if career_goals and any(goal in career_goals.lower() for goal in ["developer", "programmer", "software"]):
-            if course in ["BSCS", "BSIT"]:
-                reasons.append("Direct path to your career goals")
-        
-        if career_goals and any(goal in career_goals.lower() for goal in ["business", "entrepreneur", "manager"]):
-            if course in ["BSBA", "BSA"]:
-                reasons.append("Direct path to your business goals")
-        
-        # Default reason if no specific matches
-        if not reasons:
-            reasons.append("Good academic and personal fit")
-        
-        return " • ".join(reasons[:3])  # Limit to top 3 reasons
-
-    def save_model(self, model_path='course_recommender_model.joblib'):
-        """Save the trained model"""
-        if self.model is None:
-            raise Exception("No model to save!")
-            
-        model_data = {
-            'model': self.model,
-            'scaler': self.scaler,
-            'label_encoders': self.label_encoders
-        }
-        joblib.dump(model_data, model_path)
-    
-    def load_model(self, model_path='course_recommender_model.joblib'):
-        """Load a trained model"""
-        model_data = joblib.load(model_path)
-        self.model = model_data['model']
-        self.scaler = model_data['scaler']
-        self.label_encoders = model_data['label_encoders']
-
-
-# ===== UI helper for Hugging Face integration =====
-def get_course_recommendations_ui(recommender: "CourseRecommender", stanine, gwa, strand, hobbies) -> str:
-    if recommender is None:
-        return "Sorry, the recommendation system is not available at the moment. Please try again later."
-    try:
-        try:
-            stanine = int(stanine.strip()) if isinstance(stanine, str) else int(stanine)
-        except (ValueError, TypeError, AttributeError):
-            return "Stanine score must be a valid number between 1 and 9"
-        try:
-            gwa = float(gwa.strip()) if isinstance(gwa, str) else float(gwa)
-        except (ValueError, TypeError, AttributeError):
-            return "GWA must be a valid number between 75 and 100"
-        if not (1 <= stanine <= 9):
-            return "Stanine score must be between 1 and 9"
-        if not (75 <= gwa <= 100):
-            return "GWA must be between 75 and 100"
-        if not strand:
-            return "Please select a strand"
-        if not hobbies or not str(hobbies).strip():
-            return "Please enter your hobbies/interests"
-
-        recommendations = recommender.recommend_courses(
-            stanine=stanine,
-            gwa=gwa,
-            strand=strand,
-            hobbies=str(hobbies)
-        )
-        if not recommendations:
-            return "No recommendations available at the moment."
-        response = f"## Course Recommendations for You\n\n"
-        response += f"**Profile:** Stanine {stanine}, GWA {gwa}, {strand} Strand\n"
-        response += f"**Interests:** {hobbies}\n\n"
-        for i, rec in enumerate(recommendations, 1):
-            response += f"### {i}. {rec['code']} - {rec['name']}\n"
-            response += f"**Match Score:** {rec.get('rating', rec.get('probability', 0)):.1f}%\n\n"
-        return response
-    except Exception as e:
-        return f"Error getting recommendations: {str(e)}"
-
-# Example usage
-if __name__ == "__main__":
-    recommender = CourseRecommender()
-    
-    # Example recommendation
-    recommendations = recommender.recommend_courses(
-        stanine=8,
-        gwa=95,
-        strand='STEM',
-        hobbies='programming, gaming, technology'
-    )
-    print("Recommended courses:", json.dumps(recommendations, indent=2))