Upload ui.py

src/ui.py

@@ -0,0 +1,421 @@
+import streamlit as st
+import pickle
+import os
+import time
+import json
+
+# Import the optimizer and visualizer
+from curriculum_optimizer import HybridOptimizer, StudentProfile
+from interactive_visualizer import CurriculumVisualizer
+
+# --- Page Configuration ---
+st.set_page_config(page_title="Curriculum Optimizer", layout="wide", initial_sidebar_state="expanded")
+
+# Initialize session state
+if "display_plan" not in st.session_state:
+    st.session_state.display_plan = None
+if "metrics" not in st.session_state:
+    st.session_state.metrics = None
+if "reasoning" not in st.session_state:
+    st.session_state.reasoning = ""
+if "graph_data_loaded" not in st.session_state:
+    st.session_state.graph_data_loaded = False
+if "last_profile" not in st.session_state:
+    st.session_state.last_profile = None
+if "visualizer" not in st.session_state:
+    st.session_state.visualizer = None
+
+# Title
+st.title("🧑‍🎓 Next-Gen Curriculum Optimizer")
+
+# --- Caching and Initialization ---
+@st.cache_resource
+def get_optimizer():
+    """Loads and caches the main optimizer class and its models."""
+    try:
+        optimizer = HybridOptimizer()
+        optimizer.load_models()
+        return optimizer
+    except Exception as e:
+        st.error(f"Fatal error during model loading: {e}")
+        st.info("Please ensure you have the required libraries installed.")
+        st.stop()
+        return None
+
+optimizer = get_optimizer()
+
+# Create tabs
+tab1, tab2, tab3 = st.tabs(["📝 Plan Generator", "🗺️ Curriculum Map", "📊 Analytics"])
+
+# TAB 1: PLAN GENERATOR (Your existing code)
+with tab1:
+    # --- SIDEBAR FOR STUDENT PROFILE ---
+    with st.sidebar:
+        st.header("Student Profile")
+        name = st.text_input("Name", "Chaitanya Kharche")
+        gpa = st.slider("GPA", 0.0, 4.0, 3.5, 0.1)
+        career_goal = st.text_area("Career Goal", "AI Engineer specializing in Large Language Models")
+        interests = st.text_input("Interests (comma-separated)", "AI, Machine Learning, LLMs, Agentic AI")
+        learning_style = st.selectbox("Learning Style", ["Visual", "Hands-on", "Auditory"])
+        time_commit = st.number_input("Weekly Study Hours", 10, 60, 40, 5)
+        difficulty = st.selectbox("Preferred Difficulty", ["easy", "moderate", "challenging"])
+        completed_courses_input = st.text_area("Completed Courses (comma-separated)", "CS1800, CS2500")
+        
+        # Show profile impact
+        st.markdown("---")
+        st.markdown("**Profile Impact:**")
+        if time_commit < 20:
+            st.info("🕒 Part-time load (3 courses/semester)")
+        elif time_commit >= 40:
+            st.info("🔥 Intensive load (up to 5 courses/semester)")
+        else:
+            st.info("📚 Standard load (4 courses/semester)")
+        
+        if difficulty == "easy":
+            st.info("😌 Focuses on foundational courses")
+        elif difficulty == "challenging":
+            st.info("🚀 Includes advanced/specialized courses")
+        else:
+            st.info("⚖️ Balanced difficulty progression")
+    
+    # LOAD DATA
+    st.subheader("1. Load Curriculum Data")
+    uploaded_file = st.file_uploader("Upload `neu_graph_analyzed_clean.pkl`", type=["pkl"])
+    
+    if uploaded_file and not st.session_state.graph_data_loaded:
+        with st.spinner("Loading curriculum data and preparing embeddings..."):
+            try:
+                graph_data = pickle.load(uploaded_file)
+                optimizer.load_data(graph_data)
+                # Also create visualizer
+                st.session_state.visualizer = CurriculumVisualizer(graph_data)
+                st.session_state.graph_data = graph_data
+                st.session_state.graph_data_loaded = True
+                st.success(f"Successfully loaded and processed '{uploaded_file.name}'!")
+                time.sleep(1)
+                st.rerun()
+            except Exception as e:
+                st.error(f"Error processing .pkl file: {e}")
+                st.session_state.graph_data_loaded = False
+    elif st.session_state.graph_data_loaded:
+        st.success("Curriculum data is loaded and ready.")
+    
+    # GENERATE PLAN
+    st.subheader("2. Generate a Plan")
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load a curriculum file above to enable plan generation.")
+    else:
+        # Create student profile
+        profile = StudentProfile(
+            completed_courses=[c.strip().upper() for c in completed_courses_input.split(',') if c.strip()],
+            current_gpa=gpa, 
+            interests=[i.strip() for i in interests.split(',') if i.strip()],
+            career_goals=career_goal, 
+            learning_style=learning_style,
+            time_commitment=time_commit, 
+            preferred_difficulty=difficulty
+        )
+        
+        # Check if profile changed
+        profile_changed = st.session_state.last_profile != profile
+        if profile_changed:
+            st.session_state.last_profile = profile
+        
+        col1, col2, col3 = st.columns(3)
+        
+        if col1.button("🧠 AI-Optimized Plan", use_container_width=True, type="primary"):
+            with st.spinner("🚀 Using LLM for intelligent course selection..."):
+                start_time = time.time()
+                result = optimizer.generate_llm_plan(profile)
+                generation_time = time.time() - start_time
+                
+                plan_raw = result.get('pathway', {})
+                st.session_state.reasoning = plan_raw.get("reasoning", "")
+                st.session_state.metrics = plan_raw.get("complexity_analysis", {})
+                st.session_state.display_plan = plan_raw
+                st.session_state.plan_type = "AI-Optimized"
+                st.session_state.generation_time = generation_time
+                st.success(f"🎉 AI-optimized plan generated in {generation_time:.1f}s!")
+        
+        if col2.button("⚡ Smart Rule-Based Plan", use_container_width=True):
+            with st.spinner("Generating personalized rule-based plan..."):
+                start_time = time.time()
+                result = optimizer.generate_simple_plan(profile)
+                generation_time = time.time() - start_time
+                
+                plan_raw = result.get('pathway', {})
+                st.session_state.reasoning = plan_raw.get("reasoning", "")
+                st.session_state.metrics = plan_raw.get("complexity_analysis", {})
+                st.session_state.display_plan = plan_raw
+                st.session_state.plan_type = "Smart Rule-Based"
+                st.session_state.generation_time = generation_time
+                st.success(f"🎉 Smart rule-based plan generated in {generation_time:.1f}s!")
+        
+        if col3.button("🔄 Clear Plan", use_container_width=True):
+            st.session_state.display_plan = None
+            st.session_state.metrics = None
+            st.session_state.reasoning = ""
+            st.rerun()
+    
+    # Show profile change notification
+    if st.session_state.display_plan and profile_changed:
+        st.warning("⚠️ Student profile changed! Generate a new plan to see updated recommendations.")
+    
+    # DISPLAY RESULTS
+    if st.session_state.display_plan:
+        st.subheader(f"📚 {st.session_state.get('plan_type', 'Optimized')} Degree Plan")
+        
+        # Display generation info
+        col_info1, col_info2, col_info3 = st.columns(3)
+        with col_info1:
+            st.metric("Generation Time", f"{st.session_state.get('generation_time', 0):.1f}s")
+        with col_info2:
+            st.metric("Plan Type", st.session_state.get('plan_type', 'Unknown'))
+        with col_info3:
+            if time_commit < 20:
+                load_type = "Part-time"
+            elif time_commit >= 40:
+                load_type = "Intensive"
+            else:
+                load_type = "Standard"
+            st.metric("Course Load", load_type)
+        
+        # Display reasoning and metrics
+        if st.session_state.reasoning or st.session_state.metrics:
+            st.markdown("##### 📊 Plan Analysis")
+            
+            if st.session_state.reasoning:
+                st.info(f"**Strategy:** {st.session_state.reasoning}")
+            
+            if st.session_state.metrics:
+                m = st.session_state.metrics
+                c1, c2, c3, c4 = st.columns(4)
+                
+                c1.metric("Avg Complexity", f"{m.get('average_semester_complexity', 0):.1f}")
+                c2.metric("Peak Complexity", f"{m.get('peak_semester_complexity', 0):.1f}")
+                c3.metric("Total Complexity", f"{m.get('total_complexity', 0):.0f}")
+                c4.metric("Balance Score", f"{m.get('balance_score (std_dev)', 0):.2f}")
+            
+            st.divider()
+        
+        # Display the actual plan
+        plan = st.session_state.display_plan
+        total_courses = 0
+        
+        for year_num in range(1, 5):
+            year_key = f"year_{year_num}"
+            year_data = plan.get(year_key, {})
+            
+            st.markdown(f"### Year {year_num}")
+            col_fall, col_spring, col_summer = st.columns(3)
+            
+            # Fall semester
+            with col_fall:
+                fall_courses = year_data.get("fall", [])
+                st.markdown("**🍂 Fall Semester**")
+                if fall_courses:
+                    for course_id in fall_courses:
+                        if course_id in optimizer.courses:
+                            course_data = optimizer.courses[course_id]
+                            course_name = course_data.get("name", course_id)
+                            st.write(f"• **{course_id}**: {course_name}")
+                            total_courses += 1
+                        else:
+                            st.write(f"• {course_id}")
+                            total_courses += 1
+                else:
+                    st.write("*No courses scheduled*")
+            
+            # Spring semester
+            with col_spring:
+                spring_courses = year_data.get("spring", [])
+                st.markdown("**🌸 Spring Semester**")
+                if spring_courses:
+                    for course_id in spring_courses:
+                        if course_id in optimizer.courses:
+                            course_data = optimizer.courses[course_id]
+                            course_name = course_data.get("name", course_id)
+                            st.write(f"• **{course_id}**: {course_name}")
+                            total_courses += 1
+                        else:
+                            st.write(f"• {course_id}")
+                            total_courses += 1
+                else:
+                    st.write("*No courses scheduled*")
+            
+            # Summer
+            with col_summer:
+                summer = year_data.get("summer", [])
+                st.markdown("**☀️ Summer**")
+                if summer == "co-op":
+                    st.write("🏢 *Co-op Experience*")
+                elif summer:
+                    for course_id in summer:
+                        if course_id in optimizer.courses:
+                            course_data = optimizer.courses[course_id]
+                            course_name = course_data.get("name", course_id)
+                            st.write(f"• **{course_id}**: {course_name}")
+                        else:
+                            st.write(f"• {course_id}")
+                else:
+                    st.write("*Break*")
+        
+        # Summary and export
+        st.divider()
+        col_export1, col_export2 = st.columns(2)
+        
+        with col_export1:
+            st.metric("Total Courses", total_courses)
+        
+        with col_export2:
+            if st.button("📥 Export Plan as JSON", use_container_width=True):
+                export_data = {
+                    "student_profile": {
+                        "name": name,
+                        "gpa": gpa,
+                        "career_goals": career_goal,
+                        "interests": interests,
+                        "learning_style": learning_style,
+                        "time_commitment": time_commit,
+                        "preferred_difficulty": difficulty,
+                        "completed_courses": completed_courses_input
+                    },
+                    "plan": st.session_state.display_plan,
+                    "metrics": st.session_state.metrics,
+                    "generation_info": {
+                        "plan_type": st.session_state.get('plan_type', 'Unknown'),
+                        "generation_time": st.session_state.get('generation_time', 0)
+                    }
+                }
+                plan_json = json.dumps(export_data, indent=2)
+                st.download_button(
+                    label="Download Complete Plan Data",
+                    data=plan_json,
+                    file_name=f"curriculum_plan_{name.replace(' ', '_')}.json",
+                    mime="application/json"
+                )
+
+# TAB 2: CURRICULUM MAP
+with tab2:
+    st.subheader("🗺️ Interactive Curriculum Dependency Graph")
+    
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load curriculum data in the Plan Generator tab first.")
+    else:
+        # Controls
+        col1, col2 = st.columns([1, 3])
+        
+        with col1:
+            show_critical = st.checkbox("Show Critical Path", True)
+            if st.session_state.display_plan:
+                highlight_plan = st.checkbox("Highlight My Courses", False)
+        
+        # Create visualization
+        if st.session_state.visualizer:
+            critical_path = []
+            if show_critical:
+                critical_path = st.session_state.visualizer.find_critical_path()
+                if critical_path:
+                    st.info(f"Critical Path ({len(critical_path)} courses): {' → '.join(critical_path[:5])}...")
+            
+            # Create the plot
+            fig = st.session_state.visualizer.create_interactive_plot(critical_path)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Legend
+            with st.expander("📖 How to Read This Graph"):
+                st.markdown("""
+                **Node (Circle) Size**: Blocking factor - larger circles block more future courses  
+                **Node Color**: Complexity score - darker = more complex  
+                **Lines**: Prerequisite relationships  
+                **Red Path**: Critical path (longest chain)  
+                **Hover over nodes**: See detailed metrics for each course
+                
+                **Metrics Explained:**
+                - **Blocking Factor**: How many courses this prerequisite blocks
+                - **Delay Factor**: Length of longest path through this course
+                - **Centrality**: How important this course is in the curriculum network
+                - **Complexity**: Combined score (research by Prof. Lionelle)
+                """)
+
+# TAB 3: ANALYTICS
+with tab3:
+    st.subheader("📊 Curriculum Analytics Dashboard")
+    
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load curriculum data in the Plan Generator tab first.")
+    else:
+        # Overall metrics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        graph = st.session_state.graph_data
+        total_courses = graph.number_of_nodes()
+        total_prereqs = graph.number_of_edges()
+        
+        col1.metric("Total Courses", total_courses)
+        col2.metric("Total Prerequisites", total_prereqs)
+        col3.metric("Avg Prerequisites", f"{total_prereqs/total_courses:.1f}")
+        
+        # Calculate total curriculum complexity
+        if st.session_state.visualizer:
+            total_complexity = sum(
+                st.session_state.visualizer.calculate_metrics(n)['complexity']
+                for n in graph.nodes()
+            )
+            col4.metric("Curriculum Complexity", f"{total_complexity:,.0f}")
+        
+        st.divider()
+        
+        # Most complex courses
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Most Complex Courses")
+            
+            if st.session_state.visualizer:
+                complexities = []
+                for node in graph.nodes():
+                    metrics = st.session_state.visualizer.calculate_metrics(node)
+                    complexities.append({
+                        'course': node,
+                        'name': graph.nodes[node].get('name', ''),
+                        'complexity': metrics['complexity'],
+                        'blocking': metrics['blocking']
+                    })
+                
+                complexities.sort(key=lambda x: x['complexity'], reverse=True)
+                
+                for item in complexities[:10]:
+                    st.write(f"**{item['course']}**: {item['name']}")
+                    prog_col1, prog_col2 = st.columns([3, 1])
+                    with prog_col1:
+                        st.progress(min(item['complexity']/200, 1.0))
+                    with prog_col2:
+                        st.caption(f"Blocks: {item['blocking']}")
+        
+        with col2:
+            st.subheader("Bottleneck Courses")
+            st.caption("(High blocking factor)")
+            
+            if st.session_state.visualizer:
+                bottlenecks = sorted(complexities, key=lambda x: x['blocking'], reverse=True)
+                
+                for item in bottlenecks[:10]:
+                    st.write(f"**{item['course']}**: {item['name']}")
+                    st.info(f"Blocks {item['blocking']} future courses")
+        
+        # Export to CurricularAnalytics format
+        st.divider()
+        if st.button("📤 Export to CurricularAnalytics Format"):
+            if st.session_state.visualizer:
+                ca_format = st.session_state.visualizer.export_to_curricular_analytics_format({})
+                st.download_button(
+                    "Download CA Format JSON",
+                    json.dumps(ca_format, indent=2),
+                    "curriculum_analytics.json",
+                    "application/json"
+                )
+
+# Footer
+st.divider()
+st.caption("🚀 Powered by Students, For Students")