Upload curriculum_optimizer.py

src/curriculum_optimizer.py

@@ -0,0 +1,716 @@
+"""
+Fixed Hybrid Curriculum Optimizer
+Actually personalizes plans based on student profile
+WITH MUTUAL EXCLUSION AND SEQUENCE VALIDATION
+"""
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from sentence_transformers import SentenceTransformer, util
+import networkx as nx
+import numpy as np
+from typing import Dict, List, Set, Tuple, Optional
+from dataclasses import dataclass
+import re
+import json
+import random
+from datetime import datetime
+
+@dataclass
+class StudentProfile:
+    completed_courses: List[str]
+    time_commitment: int
+    preferred_difficulty: str
+    career_goals: str
+    interests: List[str]
+    current_gpa: float = 3.5
+    learning_style: str = "Visual"
+
+class HybridOptimizer:
+    """
+    Fixed optimizer with proper course sequencing and mutual exclusion
+    """
+    
+    # COURSE TRACKS - Mutually exclusive sequences
+    COURSE_TRACKS = {
+        "physics": {
+            "engineering": ["PHYS1151", "PHYS1155"],
+            "science": ["PHYS1161", "PHYS1165"], 
+            "life_sciences": ["PHYS1145", "PHYS1147"]
+        },
+        "calculus": {
+            "standard": ["MATH1341", "MATH1342"],
+            "computational": ["MATH156", "MATH256"]
+        }
+    }
+    
+    # CONCENTRATION REQUIREMENTS - Structured with pick lists
+    CONCENTRATION_REQUIREMENTS = {
+        "ai_ml": {
+            "foundations": {
+                "required": ["CS1800", "CS2500", "CS2510", "CS2800"]
+            },
+            "core": {
+                "required": ["CS3000", "CS3500"],
+                "pick_1_from": ["CS3200", "CS3650", "CS3700"]
+            },
+            "concentration_specific": {
+                "required": ["CS4100", "DS4400"],
+                "pick_2_from": ["CS4120", "CS4180", "DS4420", "DS4440"],
+                "pick_1_systems": ["CS4730", "CS4700", "CS4750"]
+            },
+            "math": {
+                "required": ["MATH1341", "MATH1342"],
+                "pick_1_from": ["MATH2331", "MATH3081", "STAT315"]
+            }
+        },
+        "systems": {
+            "foundations": {
+                "required": ["CS1800", "CS2500", "CS2510", "CS2800"]
+            },
+            "core": {
+                "required": ["CS3000", "CS3500", "CS3650"],
+                "pick_1_from": ["CS3700", "CS3200"]
+            },
+            "concentration_specific": {
+                "required": ["CS4700"],
+                "pick_2_from": ["CS4730", "CS4750", "CS4770"],
+                "pick_1_from": ["CS4400", "CS4500", "CS4520"]
+            },
+            "math": {
+                "required": ["MATH1341", "MATH1342"]
+            }
+        },
+        "security": {
+            "foundations": {
+                "required": ["CS1800", "CS2500", "CS2510", "CS2800"]
+            },
+            "core": {
+                "required": ["CS3000", "CS3650", "CY2550"],
+                "pick_1_from": ["CS3700", "CS3500"]
+            },
+            "concentration_specific": {
+                "required": ["CY3740"],
+                "pick_2_from": ["CY4740", "CY4760", "CY4770"],
+                "pick_1_from": ["CS4700", "CS4730"]
+            },
+            "math": {
+                "required": ["MATH1342"],
+                "pick_1_from": ["MATH3527", "MATH3081"]
+            }
+        }
+    }
+    
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Use smaller model for efficiency
+        self.model_name = "meta-llama/Llama-3.1-8B-Instruct"
+        self.embedding_model_name = 'BAAI/bge-large-en-v1.5'
+        
+        self.llm = None
+        self.tokenizer = None
+        self.embedding_model = None
+        self.curriculum_graph = None
+        self.courses = {}
+        
+    def load_models(self):
+        """Load embedding model and optionally LLM"""
+        print("Loading embedding model...")
+        self.embedding_model = SentenceTransformer(self.embedding_model_name, device=self.device)
+        
+    def load_llm(self):
+        """Load LLM separately for when needed"""
+        if self.device.type == 'cuda' and self.llm is None:
+            print("Loading LLM for intelligent planning...")
+            quant_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                quantization_config=quant_config,
+                device_map="auto"
+            )
+        
+    def load_data(self, graph: nx.DiGraph):
+        """Load and preprocess curriculum data"""
+        self.curriculum_graph = graph
+        self.courses = dict(graph.nodes(data=True))
+        
+        # Filter valid courses
+        self.valid_courses = []
+        course_texts = []
+        
+        for cid, data in self.courses.items():
+            # Skip labs/recitations
+            name = data.get('name', '')
+            if any(skip in name for skip in ['Lab', 'Recitation', 'Seminar', 'Practicum']):
+                continue
+                
+            # Skip grad level
+            if self._get_level(cid) >= 5000:
+                continue
+                
+            self.valid_courses.append(cid)
+            course_texts.append(f"{name} {data.get('description', '')}")
+        
+        # Precompute embeddings
+        print(f"Computing embeddings for {len(self.valid_courses)} courses...")
+        self.course_embeddings = self.embedding_model.encode(
+            course_texts, 
+            convert_to_tensor=True,
+            show_progress_bar=True
+        )
+    
+    def _get_track_commitment(self, completed: Set[str], track_type: str) -> Optional[str]:
+        """Once a student takes one course in a track, commit to that track"""
+        tracks = self.COURSE_TRACKS.get(track_type, {})
+        for track_name, courses in tracks.items():
+            if any(c in completed for c in courses):
+                return track_name
+        return None
+    
+    def _validate_sequence(self, selected: List[str], candidate: str) -> bool:
+        """Ensure course sequences stay consistent - no mixing tracks"""
+        for track_type, tracks in self.COURSE_TRACKS.items():
+            for track_name, sequence in tracks.items():
+                if candidate in sequence:
+                    # Check if any course from different track already selected
+                    for other_track, other_seq in tracks.items():
+                        if other_track != track_name:
+                            if any(c in selected for c in other_seq):
+                                return False  # Don't mix sequences
+        return True
+    
+    def validate_plan(self, plan: Dict) -> Dict[str, List[str]]:
+        """Validate a plan for consistency and requirements"""
+        issues = {
+            "errors": [],
+            "warnings": [],
+            "info": []
+        }
+        
+        all_courses = []
+        for year_key, year_data in plan.items():
+            if isinstance(year_data, dict) and year_key.startswith("year_"):
+                all_courses.extend(year_data.get("fall", []))
+                all_courses.extend(year_data.get("spring", []))
+        
+        # Check for sequence mixing
+        for track_type, tracks in self.COURSE_TRACKS.items():
+            tracks_used = set()
+            for track_name, courses in tracks.items():
+                if any(c in all_courses for c in courses):
+                    tracks_used.add(track_name)
+            
+            if len(tracks_used) > 1:
+                issues["errors"].append(
+                    f"Mixed {track_type} tracks: {', '.join(tracks_used)}. Must choose one sequence."
+                )
+        
+        # Check prerequisites are satisfied
+        completed = set()
+        for year in range(1, 5):
+            for sem in ["fall", "spring"]:
+                year_key = f"year_{year}"
+                if year_key in plan:
+                    courses = plan[year_key].get(sem, [])
+                    for course in courses:
+                        if course in self.curriculum_graph:
+                            prereqs = set(self.curriculum_graph.predecessors(course))
+                            missing = prereqs - completed
+                            if missing:
+                                issues["errors"].append(
+                                    f"{course} in Year {year} {sem} missing prereqs: {', '.join(missing)}"
+                                )
+                    completed.update(courses)
+        
+        return issues
+    
+    def generate_llm_plan(self, student: StudentProfile) -> Dict:
+        """Generate AI-powered plan with LLM course selection"""
+        print("--- Generating AI-Optimized Plan ---")
+        
+        # Ensure LLM is loaded
+        self.load_llm()
+        
+        if not self.llm:
+            print("LLM not available, falling back to enhanced rule-based plan")
+            return self.generate_enhanced_rule_plan(student)
+        
+        # Step 1: Identify track
+        track = self._identify_track(student)
+        print(f"Identified track: {track}")
+        
+        # Step 2: Get LLM-suggested courses
+        llm_suggestions = self._get_llm_course_suggestions(student, track)
+        
+        # Step 3: Build plan using LLM suggestions + rules
+        plan = self._build_structured_plan(student, track, llm_suggestions)
+        
+        # Step 4: Validate plan
+        validation = self.validate_plan(plan)
+        if validation["errors"]:
+            print(f"Plan validation errors: {validation['errors']}")
+            # Try to fix errors
+            plan = self._fix_plan_errors(plan, validation, student)
+        
+        # Step 5: Generate explanation
+        explanation = self._generate_explanation(student, plan, track, "AI-optimized")
+        
+        return self._finalize_plan(plan, explanation, validation)
+    
+    def generate_simple_plan(self, student: StudentProfile) -> Dict:
+        """Generate rule-based plan that considers student preferences"""
+        print("--- Generating Enhanced Rule-Based Plan ---")
+        return self.generate_enhanced_rule_plan(student)
+    
+    def generate_enhanced_rule_plan(self, student: StudentProfile) -> Dict:
+        """Enhanced rule-based plan with proper sequencing"""
+        
+        # Step 1: Identify track
+        track = self._identify_track(student)
+        
+        # Step 2: Build structured plan
+        plan = self._build_structured_plan(student, track, None)
+        
+        # Step 3: Validate
+        validation = self.validate_plan(plan)
+        if validation["errors"]:
+            plan = self._fix_plan_errors(plan, validation, student)
+            validation = self.validate_plan(plan)  # Re-validate
+        
+        # Step 4: Generate explanation
+        difficulty_level = self._map_difficulty(student.preferred_difficulty)
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        explanation = f"Personalized {track} track ({difficulty_level} difficulty, {courses_per_semester} courses/semester)"
+        
+        return self._finalize_plan(plan, explanation, validation)
+    
+    def _build_structured_plan(
+        self, 
+        student: StudentProfile,
+        track: str,
+        llm_suggestions: Optional[List[str]] = None
+    ) -> Dict:
+        """Build plan using structured concentration requirements"""
+        
+        completed = set(student.completed_courses)
+        plan = {}
+        requirements = self.CONCENTRATION_REQUIREMENTS.get(track, self.CONCENTRATION_REQUIREMENTS["ai_ml"])
+        
+        # Determine course load
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        
+        # Track which requirements have been satisfied
+        required_queue = []
+        pick_lists = []
+        
+        # Build queue of required courses
+        for category, reqs in requirements.items():
+            if "required" in reqs:
+                required_queue.extend(reqs["required"])
+            
+            # Handle pick lists
+            for key, courses in reqs.items():
+                if key.startswith("pick_"):
+                    num_to_pick = int(re.search(r'\d+', key).group()) if re.search(r'\d+', key) else 1
+                    pick_lists.append({
+                        "courses": courses,
+                        "num_to_pick": num_to_pick,
+                        "category": category
+                    })
+        
+        # Handle course track commitments (physics/calculus)
+        physics_track = self._get_track_commitment(completed, "physics")
+        calc_track = self._get_track_commitment(completed, "calculus")
+        
+        # Build semesters
+        for sem_num in range(1, 9):
+            year = ((sem_num - 1) // 2) + 1
+            is_fall = (sem_num % 2) == 1
+            
+            available = self._get_available_courses(completed, year)
+            selected = []
+            
+            # Apply track commitments
+            if not physics_track and year <= 2:
+                # Choose physics track based on difficulty preference
+                if student.preferred_difficulty == "challenging":
+                    physics_track = "engineering"
+                else:
+                    physics_track = "science"
+            
+            # Priority 1: Required courses
+            for course in required_queue[:]:
+                if course in available and len(selected) < courses_per_semester:
+                    if self._validate_sequence(selected, course):
+                        selected.append(course)
+                        required_queue.remove(course)
+                        available.remove(course)
+            
+            # Priority 2: Handle pick lists
+            for pick_list in pick_lists:
+                if len(selected) >= courses_per_semester:
+                    break
+                    
+                # Filter available courses from this pick list
+                available_from_list = [c for c in pick_list["courses"] if c in available]
+                
+                # Use LLM suggestions if available
+                if llm_suggestions:
+                    # Prioritize LLM-suggested courses
+                    for suggested in llm_suggestions:
+                        if suggested in available_from_list and pick_list["num_to_pick"] > 0:
+                            if self._validate_sequence(selected, suggested):
+                                selected.append(suggested)
+                                available.remove(suggested)
+                                pick_list["num_to_pick"] -= 1
+                
+                # Fill remaining slots
+                for course in available_from_list[:pick_list["num_to_pick"]]:
+                    if len(selected) < courses_per_semester and course in available:
+                        if self._validate_sequence(selected, course):
+                            selected.append(course)
+                            available.remove(course)
+                            pick_list["num_to_pick"] -= 1
+            
+            # Priority 3: Track-specific courses (physics/calc)
+            if physics_track and year <= 2:
+                physics_courses = self.COURSE_TRACKS["physics"].get(physics_track, [])
+                for course in physics_courses:
+                    if course in available and len(selected) < courses_per_semester:
+                        selected.append(course)
+                        available.remove(course)
+            
+            # Priority 4: Fill with electives
+            if len(selected) < courses_per_semester and available:
+                semantic_scores = self._compute_semantic_scores(student)
+                electives = sorted(
+                    available,
+                    key=lambda c: self._score_elective(c, semantic_scores, completed),
+                    reverse=True
+                )
+                
+                for elective in electives:
+                    if len(selected) >= courses_per_semester:
+                        break
+                    if self._validate_sequence(selected, elective):
+                        selected.append(elective)
+            
+            # Add to plan
+            if selected:
+                year_key = f"year_{year}"
+                if year_key not in plan:
+                    plan[year_key] = {}
+                
+                sem_type = 'fall' if is_fall else 'spring'
+                plan[year_key][sem_type] = selected[:courses_per_semester]
+                completed.update(selected)
+        
+        return plan
+    
+    def _fix_plan_errors(self, plan: Dict, validation: Dict, student: StudentProfile) -> Dict:
+        """Attempt to fix validation errors in a plan"""
+        
+        # For now, if there are sequence mixing errors, rebuild with enforced consistency
+        if any("Mixed" in error for error in validation["errors"]):
+            print("Fixing sequence mixing errors...")
+            
+            # Find which tracks were mixed and pick the first one
+            for error in validation["errors"]:
+                if "Mixed physics" in error:
+                    # Force engineering track (most common)
+                    self.COURSE_TRACKS["physics"] = {"engineering": ["PHYS1151", "PHYS1155"]}
+                elif "Mixed calculus" in error:
+                    # Force standard calc
+                    self.COURSE_TRACKS["calculus"] = {"standard": ["MATH1341", "MATH1342"]}
+            
+            # Rebuild plan with enforced tracks
+            return self._build_structured_plan(student, self._identify_track(student), None)
+        
+        return plan
+    
+    def _get_llm_course_suggestions(self, student: StudentProfile, track: str) -> List[str]:
+        """Use LLM to suggest personalized course priorities"""
+        
+        requirements = self.CONCENTRATION_REQUIREMENTS.get(track, self.CONCENTRATION_REQUIREMENTS["ai_ml"])
+        
+        # Gather all elective options from pick lists
+        all_options = []
+        for category, reqs in requirements.items():
+            for key, courses in reqs.items():
+                if key.startswith("pick_"):
+                    all_options.extend(courses)
+        
+        # Create course options text
+        course_options = []
+        for cid in all_options[:10]:  # Limit to avoid token limits
+            if cid in self.courses:
+                name = self.courses[cid].get('name', cid)
+                desc = self.courses[cid].get('description', '')[:100]
+                course_options.append(f"{cid}: {name} - {desc}")
+        
+        prompt = f"""You are a curriculum advisor. Given this student profile, rank the TOP 5 most relevant courses from the options below.
+
+Student Profile:
+- Career Goal: {student.career_goals}
+- Interests: {', '.join(student.interests)}
+- Time Commitment: {student.time_commitment} hours/week
+- Preferred Difficulty: {student.preferred_difficulty}
+- Current GPA: {student.current_gpa}
+
+Available Courses:
+{chr(10).join(course_options)}
+
+Return ONLY the top 5 course IDs in order of priority, one per line. Example:
+CS4100
+DS4400
+CS4120
+CS4180
+DS4440"""
+
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.llm.generate(
+                    **inputs,
+                    max_new_tokens=100,
+                    temperature=0.3,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+            
+            # Extract course IDs
+            suggested_courses = []
+            for line in response.strip().split('\n'):
+                line = line.strip()
+                match = re.search(r'([A-Z]{2,4}\d{4})', line)
+                if match:
+                    suggested_courses.append(match.group(1))
+            
+            return suggested_courses[:5]
+            
+        except Exception as e:
+            print(f"LLM suggestion failed: {e}")
+            return all_options[:5]  # Fallback
+    
+    def _map_difficulty(self, preferred_difficulty: str) -> str:
+        """Map UI difficulty to internal levels"""
+        mapping = {
+            "easy": "easy",
+            "moderate": "medium", 
+            "challenging": "hard"
+        }
+        return mapping.get(preferred_difficulty.lower(), "medium")
+    
+    def _calculate_course_load(self, time_commitment: int) -> int:
+        """Calculate courses per semester based on time commitment"""
+        if time_commitment < 20:
+            return 3  # Part-time
+        elif time_commitment < 30:
+            return 4  # Standard
+        elif time_commitment < 40:
+            return 4  # Standard-heavy
+        else:
+            return 4  # Max (prerequisites limit anyway)
+    
+    def _identify_track(self, student: StudentProfile) -> str:
+        """Use embeddings to identify best track"""
+        
+        profile_text = f"{student.career_goals} {' '.join(student.interests)}"
+        profile_emb = self.embedding_model.encode(profile_text, convert_to_tensor=True)
+        
+        track_descriptions = {
+            "ai_ml": "artificial intelligence machine learning deep learning neural networks data science NLP computer vision LLM",
+            "systems": "operating systems distributed systems networks compilers databases performance optimization backend",
+            "security": "cybersecurity cryptography penetration testing security vulnerabilities network security ethical hacking"
+        }
+        
+        best_track = "ai_ml"
+        best_score = -1
+        
+        for track, description in track_descriptions.items():
+            track_emb = self.embedding_model.encode(description, convert_to_tensor=True)
+            score = float(util.cos_sim(profile_emb, track_emb))
+            if score > best_score:
+                best_score = score
+                best_track = track
+        
+        return best_track
+    
+    def _compute_semantic_scores(self, student: StudentProfile) -> Dict[str, float]:
+        """Compute semantic alignment for all courses"""
+        
+        query_text = f"{student.career_goals} {' '.join(student.interests)}"
+        query_emb = self.embedding_model.encode(query_text, convert_to_tensor=True)
+        
+        similarities = util.cos_sim(query_emb, self.course_embeddings)[0]
+        
+        scores = {}
+        for idx, cid in enumerate(self.valid_courses):
+            scores[cid] = float(similarities[idx])
+            
+        return scores
+    
+    def _get_available_courses(self, completed: Set[str], year: int) -> List[str]:
+        """Get schedulable courses with year restrictions"""
+        
+        available = []
+        max_level = 2999 if year == 1 else 3999 if year == 2 else 9999
+        
+        for cid in self.valid_courses:
+            if cid in completed:
+                continue
+                
+            if self._get_level(cid) > max_level:
+                continue
+                
+            # Check prerequisites
+            if cid in self.curriculum_graph:
+                prereqs = set(self.curriculum_graph.predecessors(cid))
+                if not prereqs.issubset(completed):
+                    continue
+            
+            available.append(cid)
+            
+        return available
+    
+    def _score_elective(
+        self,
+        course_id: str,
+        semantic_scores: Dict[str, float],
+        completed: Set[str]
+    ) -> float:
+        """Basic elective scoring"""
+        
+        score = 0.0
+        
+        # Semantic alignment (50%)
+        score += semantic_scores.get(course_id, 0) * 0.5
+        
+        # Unlocks future courses (30%)
+        if course_id in self.curriculum_graph:
+            unlocks = len(list(self.curriculum_graph.successors(course_id)))
+            score += min(unlocks / 5, 1.0) * 0.3
+        
+        # Subject relevance (20%)
+        subject = self.courses.get(course_id, {}).get('subject', '')
+        subject_scores = {"CS": 1.0, "DS": 0.9, "IS": 0.6, "MATH": 0.7, "CY": 0.8}
+        score += subject_scores.get(subject, 0.3) * 0.2
+        
+        return score
+    
+    def _generate_explanation(self, student: StudentProfile, plan: Dict, track: str, plan_type: str) -> str:
+        """Generate explanation using LLM if available"""
+        
+        if not self.llm:
+            return f"{plan_type} {track} track plan for {student.career_goals}"
+        
+        # Count courses
+        total_courses = sum(
+            len(plan.get(f"year_{y}", {}).get(sem, []))
+            for y in range(1, 5)
+            for sem in ["fall", "spring"]
+        )
+        
+        prompt = f"""Explain this curriculum plan in 1-2 sentences:
+Plan Type: {plan_type}
+Track: {track}
+Student Goal: {student.career_goals}
+Interests: {', '.join(student.interests[:2])}
+Difficulty: {student.preferred_difficulty}
+Time Commitment: {student.time_commitment}h/week
+Total Courses: {total_courses}
+
+Be specific about how the plan matches their preferences."""
+
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.llm.generate(
+                    **inputs,
+                    max_new_tokens=150,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            explanation = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+            return explanation.strip()
+            
+        except Exception as e:
+            print(f"Explanation generation failed: {e}")
+            return f"{plan_type} {track} track plan optimized for {student.career_goals}"
+    
+    def _get_level(self, course_id: str) -> int:
+        """Extract course level"""
+        match = re.search(r'\d+', course_id)
+        return int(match.group()) if match else 9999
+    
+    def _finalize_plan(self, plan: Dict, explanation: str, validation: Dict = None) -> Dict:
+        """Add structure, metrics, and validation to plan"""
+        
+        structured = {
+            "reasoning": explanation,
+            "validation": validation if validation else {"errors": [], "warnings": [], "info": []}
+        }
+        
+        # Ensure all years present
+        for year in range(1, 5):
+            year_key = f"year_{year}"
+            if year_key not in plan:
+                plan[year_key] = {}
+            
+            structured[year_key] = {
+                "fall": plan[year_key].get("fall", []),
+                "spring": plan[year_key].get("spring", []),
+                "summer": "co-op" if year in [2, 3] else []
+            }
+        
+        # Calculate complexity metrics
+        complexities = []
+        for year_key in structured:
+            if year_key.startswith("year_"):
+                for sem in ["fall", "spring"]:
+                    courses = structured[year_key].get(sem, [])
+                    if courses:
+                        sem_complexity = sum(
+                            self.courses.get(c, {}).get('complexity', 50)
+                            for c in courses
+                        )
+                        complexities.append(sem_complexity)
+        
+        structured["complexity_analysis"] = {
+            "average_semester_complexity": float(np.mean(complexities)) if complexities else 0,
+            "peak_semester_complexity": float(np.max(complexities)) if complexities else 0,
+            "total_complexity": float(np.sum(complexities)) if complexities else 0,
+            "balance_score (std_dev)": float(np.std(complexities)) if complexities else 0
+        }
+        
+        # Add metadata
+        structured["metadata"] = {
+            "generated": datetime.now().isoformat(),
+            "valid": len(validation.get("errors", [])) == 0 if validation else True,
+            "has_warnings": len(validation.get("warnings", [])) > 0 if validation else False
+        }
+        
+        return {"pathway": structured}
+
+# Backward compatibility wrapper
+class CurriculumOptimizer(HybridOptimizer):
+    """Compatibility wrapper"""
+    
+    def __init__(self):
+        super().__init__()
+    
+    def generate_plan(self, student: StudentProfile) -> Dict:
+        """Default plan generation - uses enhanced rules"""
+        return self.generate_enhanced_rule_plan(student)