simulations till good scores

This commit is contained in:
Roshan Sanjeev 2025-05-18 17:11:52 -07:00
parent 86af643d8e
commit a71e977c91

View file

@ -0,0 +1,330 @@
#!/usr/bin/env python3
"""
ExamCraft: Enhanced Adaptive Teacher - Trains students to mastery!
This version continues teaching until the student reaches high proficiency in ALL topics,
demonstrating persistent adaptive teaching behavior.
"""
import os
import json
import random
from typing import Dict, List, Any, Tuple, Optional
class EnhancedExamCraftDemo:
"""
Enhanced ExamCraft that teaches until student reaches mastery in all topics.
Perfect for demonstrating adaptive teaching to completion!
"""
def __init__(self, profile_path: str = "example_profile.json"):
# Load student profile
if os.path.exists(profile_path):
with open(profile_path, 'r') as file:
self.profile = json.load(file)
else:
self.profile = self._create_default_profile()
# Mastery threshold - student needs to reach this in ALL topics
self.mastery_threshold = 0.85 # 85% proficiency
# Initialize student metrics
self.reset_student()
# Track teaching session
self.question_count = 0
self.session_history = []
def _create_default_profile(self) -> Dict[str, Any]:
"""Create default student profile."""
return {
"student_id": "adaptive_learner_001",
"target_grade": "11th grade",
"learning_goal": "Master all linear algebra concepts",
"topics": [
{"name": "vectors", "proficiency": 0.45},
{"name": "matrices", "proficiency": 0.30},
{"name": "linear_systems", "proficiency": 0.25},
{"name": "eigenvalues_eigenvectors", "proficiency": 0.20}
],
"preferred_learning_style": "visual"
}
def reset_student(self):
"""Reset student to initial proficiency levels."""
self.student_metrics = {}
for topic in self.profile["topics"]:
self.student_metrics[topic["name"]] = topic["proficiency"]
self.question_count = 0
self.session_history = []
def check_mastery(self) -> Tuple[bool, Dict[str, float]]:
"""Check if student has reached mastery in all topics."""
topic_status = {}
all_mastered = True
for topic, proficiency in self.student_metrics.items():
is_mastered = proficiency >= self.mastery_threshold
topic_status[topic] = proficiency
if not is_mastered:
all_mastered = False
return all_mastered, topic_status
def get_weakest_topic(self) -> str:
"""Find the topic where student is struggling most."""
return min(self.student_metrics.items(), key=lambda x: x[1])[0]
def simulate_teaching_session(self) -> Dict[str, Any]:
"""
Simulate a complete teaching session until mastery.
This is what you'll demo in your video!
"""
print("🎓 ExamCraft: Teaching to Mastery Demo")
print("=" * 50)
# Show initial state
print("\n📊 Initial Student Proficiency:")
for topic, prof in self.student_metrics.items():
print(f" {topic}: {prof:.1%}")
print(f"\n🎯 Goal: Reach {self.mastery_threshold:.0%} proficiency in ALL topics")
print("🚀 Starting adaptive teaching session...\n")
session_results = []
round_num = 1
# Keep teaching until mastery achieved
while True:
print(f"--- Round {round_num} ---")
# Check current status
all_mastered, topic_status = self.check_mastery()
if all_mastered:
print("\n🎉 CONGRATULATIONS! Student has achieved mastery in ALL topics!")
break
# Find weakest topic and generate question
target_topic = self.get_weakest_topic()
current_prof = self.student_metrics[target_topic]
# Determine appropriate difficulty
if current_prof < 0.4:
difficulty = "easy"
elif current_prof < 0.7:
difficulty = "medium"
else:
difficulty = "hard"
print(f"🎯 Targeting weakest topic: {target_topic} ({current_prof:.1%})")
print(f"📝 Generating {difficulty} question...")
# Simulate question and answer
question_result = self._simulate_question_answer(target_topic, difficulty)
# Update student learning
self._update_student_learning(target_topic, question_result["is_correct"])
# Track progress
self.question_count += 1
self.session_history.append(question_result)
session_results.append(question_result)
# Show immediate feedback
result_icon = "" if question_result["is_correct"] else ""
new_prof = self.student_metrics[target_topic]
improvement = new_prof - current_prof
print(f"{result_icon} Student answered: {'Correct' if question_result['is_correct'] else 'Incorrect'}")
print(f"📈 {target_topic}: {current_prof:.1%}{new_prof:.1%} (+{improvement:.1%})")
# Show overall progress every 5 questions
if self.question_count % 5 == 0:
print("\n📊 Current Progress:")
for topic, prof in self.student_metrics.items():
status = "✅ Mastered" if prof >= self.mastery_threshold else f"{prof:.1%}"
print(f" {topic}: {status}")
print()
round_num += 1
# Safety limit (prevent infinite loop in demo)
if round_num > 30:
print(f"\n⏰ Demo limit reached ({round_num-1} rounds)")
break
# Final summary
print("\n" + "=" * 50)
print("📋 TEACHING SESSION COMPLETE!")
print(f"✨ Total questions asked: {self.question_count}")
print(f"🎯 Rounds of teaching: {round_num - 1}")
# Final proficiency
print("\n🏆 Final Student Proficiency:")
all_mastered, final_status = self.check_mastery()
for topic, prof in final_status.items():
status = "🎉 MASTERED" if prof >= self.mastery_threshold else f"{prof:.1%}"
print(f" {topic}: {status}")
if all_mastered:
print("\n🎊 MISSION ACCOMPLISHED: Student has mastered all topics!")
else:
print(f"\n📈 Progress made! Continue teaching to reach {self.mastery_threshold:.0%} in all topics.")
return {
"total_questions": self.question_count,
"rounds": round_num - 1,
"final_proficiencies": dict(self.student_metrics),
"all_mastered": all_mastered,
"session_history": session_results
}
def _simulate_question_answer(self, topic: str, difficulty: str) -> Dict[str, Any]:
"""Simulate a question and student's answer."""
# Get student's current proficiency
proficiency = self.student_metrics[topic]
# Adjust success probability based on difficulty
difficulty_modifiers = {
"easy": 0.3,
"medium": 0.0,
"hard": -0.2
}
modifier = difficulty_modifiers.get(difficulty, 0.0)
# Calculate success probability
success_prob = max(0.15, min(0.95, proficiency + modifier))
# Add momentum from recent performance
if len(self.session_history) >= 2:
recent_correct = sum(1 for item in self.session_history[-2:]
if item["is_correct"])
momentum = (recent_correct - 1) * 0.1
success_prob = max(0.15, min(0.95, success_prob + momentum))
# Determine if answer is correct
is_correct = random.random() < success_prob
# Sample questions for demo
sample_questions = {
"vectors": {
"easy": "What is the result of adding two vectors?",
"medium": "How do you calculate the dot product of two vectors?",
"hard": "Prove that the dot product is commutative."
},
"matrices": {
"easy": "What is a matrix?",
"medium": "How do you multiply two matrices?",
"hard": "When does a matrix inverse exist?"
},
"linear_systems": {
"easy": "What is a system of linear equations?",
"medium": "How does Gaussian elimination work?",
"hard": "Analyze the conditions for system solvability."
},
"eigenvalues_eigenvectors": {
"easy": "What is an eigenvalue?",
"medium": "How do you find eigenvalues of a 2x2 matrix?",
"hard": "Prove the relationship between trace and eigenvalues."
}
}
question = sample_questions.get(topic, {}).get(difficulty, f"Sample {difficulty} question about {topic}")
return {
"topic": topic,
"difficulty": difficulty,
"question": question,
"is_correct": is_correct,
"success_probability": success_prob,
"proficiency_before": proficiency
}
def _update_student_learning(self, topic: str, is_correct: bool):
"""Update student's proficiency based on learning."""
current_prof = self.student_metrics[topic]
if is_correct:
# Successful answer - moderate improvement
improvement = 0.05 + random.uniform(0, 0.03)
else:
# Failed answer but learned from explanation - smaller improvement
improvement = 0.02 + random.uniform(0, 0.02)
# Diminishing returns as proficiency increases
diminishing_factor = (1.0 - current_prof) * 0.8 + 0.2
improvement *= diminishing_factor
# Update proficiency
new_prof = min(1.0, current_prof + improvement)
self.student_metrics[topic] = new_prof
def run_quick_demo(self):
"""Run a quick 3-round demo for video purposes."""
print("🎓 ExamCraft: Quick Demo - Teaching to Mastery")
print("=" * 45)
# Show initial state
print("\n📊 Student Starting Proficiency:")
for topic, prof in self.student_metrics.items():
print(f" {topic}: {prof:.1%}")
# Set a lower threshold for demo
original_threshold = self.mastery_threshold
self.mastery_threshold = 0.65 # Lower for demo
print(f"\n🎯 Demo Goal: Reach {self.mastery_threshold:.0%} in all topics")
print("🚀 Let's see adaptive teaching in action!\n")
for round_num in range(1, 4): # Just 3 rounds for demo
print(f"--- Round {round_num} ---")
# Find and target weakest topic
target_topic = self.get_weakest_topic()
current_prof = self.student_metrics[target_topic]
print(f"🎯 Focusing on: {target_topic} ({current_prof:.1%})")
# Simulate teaching
question_result = self._simulate_question_answer(target_topic, "medium")
self._update_student_learning(target_topic, question_result["is_correct"])
new_prof = self.student_metrics[target_topic]
result_icon = "" if question_result["is_correct"] else ""
print(f"{result_icon} Result: {new_prof:.1%} ({new_prof-current_prof:+.1%})")
self.question_count += 1
# Reset threshold
self.mastery_threshold = original_threshold
print("\n📈 Final Progress:")
for topic, prof in self.student_metrics.items():
print(f" {topic}: {prof:.1%}")
print("\n✨ This is how ExamCraft adapts teaching until mastery!")
def main():
"""Demo the enhanced ExamCraft environment."""
demo = EnhancedExamCraftDemo()
print("Choose demo type:")
print("1. Quick demo (for video recording)")
print("2. Full teaching session (until mastery)")
choice = input("\nEnter choice (1 or 2): ").strip()
if choice == "1":
demo.run_quick_demo()
else:
demo.simulate_teaching_session()
print("\n🎬 Perfect for demo video! Shows adaptive teaching to mastery.")
if __name__ == "__main__":
main()