Delete database_recommender.py

database_recommender.py

@@ -1,336 +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):
-        self.model = None
-        self.label_encoders = {}
-        self.scaler = StandardScaler()
-        self.courses = self.get_courses()
-        self.training_data = self.get_training_data()
-        self.train_model()
-    
-    def get_courses(self):
-        """Get static course data"""
-        return {
-            'BSCS': 'Bachelor of Science in Computer Science',
-            'BSIT': 'Bachelor of Science in Information Technology',
-            'BSBA': 'Bachelor of Science in Business Administration',
-            'BSED': 'Bachelor of Science in Education',
-            'BSN': 'Bachelor of Science in Nursing',
-            'BSArch': 'Bachelor of Science in Architecture',
-            'BSIE': 'Bachelor of Science in Industrial Engineering',
-            'BSHM': 'Bachelor of Science in Hospitality Management',
-            'BSA': 'Bachelor of Science in Accountancy',
-            'BSPsych': 'Bachelor of Science in Psychology',
-            'BSAgri': 'Bachelor of Science in Agriculture'
-        }
-
-    def save_student_data(self, stanine, gwa, strand, course, rating, hobbies=None):
-        """Save student feedback to in-memory storage (for demonstration purposes)"""
-        try:
-            # In a real implementation, you could save this to a file or external storage
-            print(f"Student feedback saved: Stanine={stanine}, GWA={gwa}, Strand={strand}, Course={course}, Rating={rating}, Hobbies={hobbies}")
-            return True
-        except Exception as e:
-            print(f"Error saving student feedback: {e}")
-            return False
-
-    def get_training_data(self):
-        """Get static training data for demonstration purposes"""
-        # Sample training data to demonstrate the recommender system
-        training_data = [
-            # STEM students
-            (8, 95, 'STEM', 'BSCS', 5, 'programming, gaming, technology'),
-            (7, 90, 'STEM', 'BSIT', 4, 'computers, software, coding'),
-            (9, 98, 'STEM', 'BSCS', 5, 'programming, algorithms, math'),
-            (6, 85, 'STEM', 'BSIT', 3, 'technology, computers'),
-            (8, 92, 'STEM', 'BSArch', 4, 'design, drawing, creativity'),
-            (7, 88, 'STEM', 'BSIE', 4, 'engineering, problem solving'),
-            
-            # ABM students
-            (8, 90, 'ABM', 'BSBA', 5, 'business, management, leadership'),
-            (7, 85, 'ABM', 'BSA', 4, 'accounting, numbers, finance'),
-            (6, 82, 'ABM', 'BSBA', 3, 'business, marketing'),
-            (9, 95, 'ABM', 'BSA', 5, 'accounting, finance, analysis'),
-            
-            # HUMSS students
-            (8, 88, 'HUMSS', 'BSED', 5, 'teaching, helping, education'),
-            (7, 85, 'HUMSS', 'BSPsych', 4, 'psychology, helping, people'),
-            (6, 80, 'HUMSS', 'BSED', 3, 'teaching, children'),
-            (9, 92, 'HUMSS', 'BSPsych', 5, 'psychology, counseling, people'),
-            
-            # General interests
-            (7, 87, 'STEM', 'BSN', 4, 'helping, healthcare, caring'),
-            (8, 89, 'ABM', 'BSHM', 4, 'hospitality, service, management'),
-            (6, 83, 'HUMSS', 'BSAgri', 3, 'agriculture, environment, nature'),
-        ]
-        
-        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 (hobbies required and encoded)")
-            
-        except Exception as e:
-            print(f"Error training model: {e}")
-            self.model = None
-
-    def get_default_recommendations(self, stanine, gwa, strand):
-        """Provide default recommendations based on basic rules when no training data is available"""
-        courses = self.courses
-        recommendations = []
-        
-        # Basic rules for recommendations
-        if strand == 'STEM':
-            if stanine >= 8 and gwa >= 90:
-                priority_courses = ['BSCS', 'BSIT']
-            else:
-                priority_courses = ['BSIT', 'BSCS']
-        elif strand == 'ABM':
-            priority_courses = ['BSBA']
-        elif strand == 'HUMSS':
-            priority_courses = ['BSED']
-        else:
-            priority_courses = list(courses.keys())
-        
-        # Add courses with default probabilities
-        for i, course in enumerate(priority_courses[:2]):  # Only take top 2
-            if course in courses:
-                recommendations.append({
-                    'code': course,
-                    'name': courses[course],
-                    'probability': 1.0 - (i * 0.2)  # Decreasing probability for each course
-                })
-        
-        return recommendations
-
-    def recommend_courses(self, stanine, gwa, strand, hobbies=None, top_n=5):
-        """Recommend courses based on student profile (hobbies required)"""
-        try:
-            if self.model is None:
-                return self.get_default_recommendations(stanine, gwa, strand)
-            
-            # 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_:
-                        # Extend encoder classes to include unseen value at inference
-                        self.label_encoders[col].classes_ = np.append(self.label_encoders[col].classes_, value)
-                    input_data[col] = self.label_encoders[col].transform(input_data[col])
-            
-            # 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_
-            
-            # Get top recommendations
-            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]
-                recommendations.append({
-                    'code': code,
-                    'name': course_map.get(code, code),
-                    'rating': round(confidence * 100, 1)
-                })
-            
-            return recommendations
-            
-        except Exception as e:
-            print(f"Error recommending courses: {e}")
-            return self.get_default_recommendations(stanine, gwa, strand)
-
-    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))