Upload 4 files

ai_chatbot.py

@@ -0,0 +1,100 @@
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from typing import List, Dict, Tuple
+import re
+
+class AIChatbot:
+    def __init__(self):
+        # Load the pre-trained model (can use a smaller model for more speed)
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        # Warm up the model to avoid first-request slowness
+        _ = self.model.encode(["Hello, world!"])
+        self.faq_embeddings = None
+        self.faqs = None
+        self.load_faqs()
+    
+    def load_faqs(self):
+        """Disable FAQs entirely; operate as a general-conversation bot."""
+        self.faqs = []
+        self.faq_embeddings = None
+    
+    def save_unanswered_question(self, question):
+        """Log unanswered questions to console (can be extended to save to file)"""
+        print(f"Unanswered question logged: {question}")
+        # In a real implementation, you could save this to a file or send to an admin
+
+    def _tokenize(self, text: str):
+        if not text:
+            return []
+        return [t for t in re.findall(r"[a-z0-9]+", text.lower()) if len(t) > 2]
+
+    def _overlap_ratio(self, q_tokens, faq_tokens):
+        if not q_tokens or not faq_tokens:
+            return 0.0
+        q_set = set(q_tokens)
+        f_set = set(faq_tokens)
+        inter = len(q_set & f_set)
+        denom = max(len(q_set), 1)
+        return inter / denom
+
+    def _wh_class(self, text: str) -> str:
+        if not text:
+            return ''
+        s = text.strip().lower()
+        # simple heuristic classification by leading wh-word
+        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
+            if s.startswith(key + ' ') or s.startswith(key + "?"):
+                return key
+        # also check presence if not leading
+        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
+            if f' {key} ' in f' {s} ':
+                return key
+        return ''
+
+    def find_best_match(self, question: str, threshold: float = 0.7) -> Tuple[str, float]:
+        print(f"find_best_match called with: {question}")  # Debug print
+        # Always act as a general-conversation bot
+        return self._generate_general_response(question)
+    
+    def _generate_general_response(self, question: str) -> Tuple[str, float]:
+        """Generate general conversation responses for non-FAQ questions"""
+        question_lower = question.lower().strip()
+        
+        # Greeting responses
+        if any(greeting in question_lower for greeting in ['hello', 'hi', 'hey', 'good morning', 'good afternoon', 'good evening']):
+            return "Hello! I'm the PSAU AI assistant. I'm here to help you with questions about university admissions, courses, and general information about Pangasinan State University. How can I assist you today?", 0.8
+        
+        # Thank you responses
+        if any(thanks in question_lower for thanks in ['thank you', 'thanks', 'thank', 'appreciate']):
+            return "You're very welcome! I'm happy to help. Is there anything else you'd like to know about PSAU or university admissions?", 0.9
+        
+        # Goodbye responses
+        if any(goodbye in question_lower for goodbye in ['bye', 'goodbye', 'see you', 'farewell']):
+            return "Goodbye! It was nice chatting with you. Feel free to come back anytime if you have more questions about PSAU. Good luck with your academic journey!", 0.9
+        
+        # How are you responses
+        if any(how in question_lower for how in ['how are you', 'how do you do', 'how is it going']):
+            return "I'm doing great, thank you for asking! I'm here and ready to help you with any questions about PSAU admissions, courses, or university life. What would you like to know?", 0.8
+        
+        # What can you do responses
+        if any(what in question_lower for what in ['what can you do', 'what do you do', 'what are your capabilities']):
+            return "I can help you with:\n• University admission requirements and procedures\n• Course information and recommendations\n• General questions about PSAU\n• Academic guidance and support\n• Information about campus life\n\nWhat specific information are you looking for?", 0.9
+        
+        # About PSAU responses
+        if any(about in question_lower for about in ['about psa', 'about psu', 'about pangasinan state', 'tell me about']):
+            return "Pangasinan State University (PSAU) is a premier state university in the Philippines offering quality education across various fields. We provide undergraduate and graduate programs in areas like Computer Science, Business, Education, Nursing, and more. We're committed to academic excellence and student success. What would you like to know more about?", 0.8
+        
+        # Help responses
+        if any(help in question_lower for help in ['help', 'assist', 'support']):
+            return "I'm here to help! I can assist you with:\n• Admission requirements and deadlines\n• Course information and recommendations\n• Academic programs and majors\n• Campus facilities and services\n• General university information\n\nJust ask me any question and I'll do my best to help you!", 0.9
+        
+        # Default general response
+        return "I understand you're asking about something, but I'm specifically designed to help with PSAU-related questions like admissions, courses, and university information. Could you rephrase your question to be more specific about what you'd like to know about Pangasinan State University? I'm here to help with academic guidance and university-related inquiries!", 0.6
+    
+    def get_suggested_questions(self, question: str, num_suggestions: int = 3) -> List[str]:
+        """No suggestions when FAQs are disabled."""
+        return []
+    
+    def add_faq(self, question: str, answer: str) -> bool:
+        """No-op when FAQs are disabled."""
+        return False

app_hf.py

@@ -0,0 +1,240 @@
+import os
+import gradio as gr
+import pandas as pd
+import numpy as np
+from ai_chatbot import AIChatbot
+from database_recommender import CourseRecommender
+import warnings
+import logging
+
+# Suppress warnings
+warnings.filterwarnings('ignore')
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+# Initialize components
+try:
+    chatbot = AIChatbot()
+    print("✅ Chatbot initialized successfully")
+except Exception as e:
+    print(f"⚠️  Warning: Could not initialize chatbot: {e}")
+    chatbot = None
+
+try:
+    recommender = CourseRecommender()
+    print("✅ Recommender initialized successfully")
+except Exception as e:
+    print(f"⚠️  Warning: Could not initialize recommender: {e}")
+    recommender = None
+
+def chat_with_bot(message, history):
+    """Handle chatbot interactions"""
+    if chatbot is None:
+        return "Sorry, the chatbot is not available at the moment. Please try again later."
+    
+    if not message.strip():
+        return "Please enter a message to start the conversation."
+    
+    # Get answer from chatbot
+    answer, confidence = chatbot.find_best_match(message)
+    
+    # For general conversation, just return the answer
+    # For FAQ questions, include suggested questions
+    if confidence > 0.7:  # High confidence FAQ match
+        suggested_questions = chatbot.get_suggested_questions(message)
+        if suggested_questions:
+            response = f"{answer}\n\n**Related Questions:**\n"
+            for i, q in enumerate(suggested_questions, 1):
+                response += f"{i}. {q}\n"
+            return response
+    
+    # For general conversation or low confidence, just return the answer
+    return answer
+
+def get_course_recommendations(stanine, gwa, strand, hobbies):
+    """Get course recommendations"""
+    if recommender is None:
+        return "Sorry, the recommendation system is not available at the moment. Please try again later."
+    
+    try:
+        # Validate and convert inputs
+        try:
+            stanine = int(stanine.strip()) if stanine else 0
+        except (ValueError, AttributeError):
+            return "❌ Stanine score must be a valid number between 1 and 9"
+        
+        try:
+            gwa = float(gwa.strip()) if gwa else 0
+        except (ValueError, AttributeError):
+            return "❌ GWA must be a valid number between 75 and 100"
+        
+        # Validate ranges
+        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 hobbies.strip():
+            return "❌ Please enter your hobbies/interests"
+        
+        # Get recommendations
+        recommendations = recommender.recommend_courses(
+            stanine=stanine,
+            gwa=gwa,
+            strand=strand,
+            hobbies=hobbies
+        )
+        
+        if not recommendations:
+            return "No recommendations available at the moment."
+        
+        # Format recommendations
+        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)}"
+
+def get_faqs():
+    """Get available FAQs"""
+    if chatbot and chatbot.faqs:
+        faq_text = "## 📚 Frequently Asked Questions\n\n"
+        for i, faq in enumerate(chatbot.faqs, 1):
+            faq_text += f"**{i}. {faq['question']}**\n"
+            faq_text += f"{faq['answer']}\n\n"
+        return faq_text
+    return "No FAQs available at the moment."
+
+def get_available_courses():
+    """Get available courses"""
+    if recommender and recommender.courses:
+        course_text = "## 🎓 Available Courses\n\n"
+        for code, name in recommender.courses.items():
+            course_text += f"**{code}** - {name}\n"
+        return course_text
+    return "No courses available at the moment."
+
+# Create Gradio interface
+with gr.Blocks(title="PSAU AI Chatbot & Course Recommender", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🤖 PSAU AI Chatbot & Course Recommender
+        
+        Welcome to the Pangasinan State University AI-powered admission assistant! 
+        Get instant answers to your questions and receive personalized course recommendations.
+        """
+    )
+    
+    with gr.Tabs():
+        # Chatbot Tab
+        with gr.Tab("🤖 AI Chatbot"):
+            gr.Markdown("""
+            **Chat with the PSAU AI Assistant!**
+            
+            I can help you with:
+            • University admission questions
+            • Course information and guidance  
+            • General conversation
+            • Academic support
+            
+            Just type your message below and I'll respond naturally!
+            """)
+            
+            chatbot_interface = gr.ChatInterface(
+                fn=chat_with_bot,
+                title="PSAU AI Assistant",
+                description="Chat with me about university admissions, courses, or just say hello!",
+                examples=[
+                    "Hello!",
+                    "What are the admission requirements?",
+                    "How are you?",
+                    "What courses are available?",
+                    "Tell me about PSAU",
+                    "What can you help me with?",
+                    "Thank you",
+                    "Goodbye"
+                ],
+                cache_examples=True
+            )
+        
+        # Course Recommender Tab
+        with gr.Tab("🎯 Course Recommender"):
+            gr.Markdown("""
+            Get personalized course recommendations based on your academic profile and interests!
+            
+            **Input Guidelines:**
+            - **Stanine Score**: Enter a number between 1-9 (from your entrance exam)
+            - **GWA**: Enter your General Weighted Average (75-100)
+            - **Strand**: Select your senior high school strand
+            - **Hobbies**: Describe your interests and hobbies in detail
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    stanine_input = gr.Textbox(
+                        label="Stanine Score (1-9)",
+                        placeholder="Enter your stanine score (1-9)",
+                        info="Your stanine score from entrance examination",
+                        value="7"
+                    )
+                    gwa_input = gr.Textbox(
+                        label="GWA (75-100)",
+                        placeholder="Enter your GWA (75-100)",
+                        info="Your General Weighted Average",
+                        value="85.0"
+                    )
+                    strand_input = gr.Dropdown(
+                        choices=["STEM", "ABM", "HUMSS"],
+                        value="STEM",
+                        label="High School Strand",
+                        info="Your senior high school strand"
+                    )
+                    hobbies_input = gr.Textbox(
+                        label="Hobbies & Interests",
+                        placeholder="e.g., programming, gaming, business, teaching, healthcare...",
+                        info="Describe your interests and hobbies"
+                    )
+                    
+                    recommend_btn = gr.Button("Get Recommendations", variant="primary")
+                
+                with gr.Column():
+                    recommendations_output = gr.Markdown()
+            
+            recommend_btn.click(
+                fn=get_course_recommendations,
+                inputs=[stanine_input, gwa_input, strand_input, hobbies_input],
+                outputs=recommendations_output
+            )
+        
+        # Information Tab
+        with gr.Tab("📚 Information"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### FAQ Section")
+                    faq_btn = gr.Button("Show FAQs")
+                    faq_output = gr.Markdown()
+                    faq_btn.click(fn=get_faqs, outputs=faq_output)
+                
+                with gr.Column():
+                    gr.Markdown("### Available Courses")
+                    courses_btn = gr.Button("Show Courses")
+                    courses_output = gr.Markdown()
+                    courses_btn.click(fn=get_available_courses, outputs=courses_output)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

database_recommender.py

@@ -0,0 +1,293 @@
+import pandas as pd
+import numpy as np
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+import joblib
+import json
+
+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']
+
+# 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)) 

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+numpy
+pandas
+scikit-learn
+joblib
+sentence-transformers
+torch