(FEAT): Adds educational interface for interactive learning system

Introduces a comprehensive educational interface for POLYMEROS, enabling interactive learning in polymer science and AI.

Implements features such as competency assessments, personalized learning paths, and a virtual laboratory, enhancing user engagement and adaptive learning capabilities.

Establishes session management to track user progress and preferences, allowing for tailored recommendations and analytics.

Improves overall learning experience by providing structured educational tools within a user-friendly environment.

pages/Educational_Interface.py

@@ -0,0 +1,405 @@
+"""
+Educational Interface Page for POLYMEROS
+Interactive learning system with adaptive progression and virtual laboratory
+"""
+
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import json
+from typing import Dict, List, Any
+
+# Import POLYMEROS educational components
+import sys
+import os
+
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "modules"))
+
+from modules.educational_framework import EducationalFramework
+
+
+def init_educational_session():
+    """Initialize educational session state"""
+    if "educational_framework" not in st.session_state:
+        st.session_state.educational_framework = EducationalFramework()
+
+    if "current_user_id" not in st.session_state:
+        st.session_state.current_user_id = "demo_user"
+
+    if "user_progress" not in st.session_state:
+        st.session_state.user_progress = (
+            st.session_state.educational_framework.initialize_user(
+                st.session_state.current_user_id
+            )
+        )
+
+
+def render_competency_assessment():
+    """Render interactive competency assessment"""
+    st.header("🧪 Knowledge Assessment")
+
+    domains = ["spectroscopy_basics", "polymer_aging", "ai_ml_concepts"]
+    selected_domain = st.selectbox(
+        "Select assessment domain:",
+        domains,
+        format_func=lambda x: x.replace("_", " ").title(),
+    )
+
+    framework = st.session_state.educational_framework
+    assessor = framework.competency_assessor
+
+    if selected_domain in assessor.assessment_tasks:
+        tasks = assessor.assessment_tasks[selected_domain]
+
+        st.subheader(f"Assessment: {selected_domain.replace('_', ' ').title()}")
+
+        responses = []
+        for i, task in enumerate(tasks):
+            st.write(f"**Question {i+1}:** {task['question']}")
+
+            response = st.radio(
+                f"Select answer for question {i+1}:",
+                options=range(len(task["options"])),
+                format_func=lambda x, task=task: task["options"][x],
+                key=f"q_{selected_domain}_{i}",
+                index=0,
+            )
+            responses.append(response)
+
+        if st.button("Submit Assessment", key=f"submit_{selected_domain}"):
+            results = framework.assess_user_competency(selected_domain, responses)
+
+            st.success(f"Assessment completed! Score: {results['score']:.1%}")
+            st.write(f"**Your level:** {results['level']}")
+
+            st.subheader("Detailed Feedback:")
+            for feedback in results["feedback"]:
+                st.write(feedback)
+
+            st.subheader("Recommendations:")
+            for rec in results["recommendations"]:
+                st.write(f"• {rec}")
+
+
+def render_learning_path():
+    """Render personalized learning path"""
+    st.header("🎯 Your Learning Path")
+
+    user_progress = st.session_state.user_progress
+    framework = st.session_state.educational_framework
+
+    # Display current progress
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.metric("Completed Objectives", len(user_progress.completed_objectives))
+
+    with col2:
+        avg_score = (
+            np.mean(list(user_progress.competency_scores.values()))
+            if user_progress.competency_scores
+            else 0
+        )
+        st.metric("Average Score", f"{avg_score:.1%}")
+
+    with col3:
+        st.metric("Current Level", user_progress.current_level.title())
+
+    # Learning style selection
+    st.subheader("Learning Preferences")
+    learning_styles = ["visual", "hands-on", "theoretical", "collaborative"]
+
+    current_style = user_progress.preferred_learning_style
+    new_style = st.selectbox(
+        "Preferred learning style:",
+        learning_styles,
+        index=(
+            learning_styles.index(current_style)
+            if current_style in learning_styles
+            else 0
+        ),
+    )
+
+    if new_style != current_style:
+        user_progress.preferred_learning_style = new_style
+        framework.save_user_progress()
+        st.success("Learning style updated!")
+
+    # Target competencies
+    st.subheader("Learning Goals")
+    target_competencies = st.multiselect(
+        "Select areas you want to focus on:",
+        ["spectroscopy", "polymer_science", "machine_learning", "data_analysis"],
+        default=["spectroscopy", "polymer_science"],
+    )
+
+    if st.button("Generate Learning Path"):
+        learning_path = framework.get_personalized_learning_path(target_competencies)
+
+        if learning_path:
+            st.subheader("Recommended Learning Path:")
+
+            for i, item in enumerate(learning_path):
+                objective = item["objective"]
+
+                with st.expander(
+                    f"{i+1}. {objective['title']} (Level {objective['difficulty_level']})"
+                ):
+                    st.write(f"**Description:** {objective['description']}")
+                    st.write(
+                        f"**Estimated time:** {objective['estimated_time']} minutes"
+                    )
+                    st.write(
+                        f"**Recommended approach:** {item['recommended_approach']}"
+                    )
+
+                    if item["priority_resources"]:
+                        st.write("**Priority resources:**")
+                        for resource in item["priority_resources"]:
+                            st.write(f"- {resource['type']}: {resource['url']}")
+        else:
+            st.info("Complete an assessment to get personalized recommendations!")
+
+
+def render_virtual_laboratory():
+    """Render virtual laboratory interface"""
+    st.header("🔬 Virtual Laboratory")
+
+    framework = st.session_state.educational_framework
+    virtual_lab = framework.virtual_lab
+
+    # Select experiment
+    experiments = list(virtual_lab.experiments.keys())
+    selected_experiment = st.selectbox(
+        "Select experiment:",
+        experiments,
+        format_func=lambda x: virtual_lab.experiments[x]["title"],
+    )
+
+    experiment_info = virtual_lab.experiments[selected_experiment]
+
+    st.subheader(experiment_info["title"])
+    st.write(f"**Description:** {experiment_info['description']}")
+    st.write(f"**Difficulty:** {experiment_info['difficulty']}/5")
+    st.write(f"**Estimated time:** {experiment_info['estimated_time']} minutes")
+
+    # Experiment-specific inputs
+    if selected_experiment == "polymer_identification":
+        st.subheader("Polymer Identification Challenge")
+        polymer_type = st.selectbox(
+            "Select polymer to analyze:", ["PE", "PP", "PS", "PVC"]
+        )
+
+        if st.button("Generate Spectrum"):
+            result = framework.run_virtual_experiment(
+                selected_experiment, {"polymer_type": polymer_type}
+            )
+
+            if result.get("success"):
+                # Plot the spectrum
+                fig, ax = plt.subplots(figsize=(10, 6))
+                ax.plot(result["wavenumbers"], result["spectrum"])
+                ax.set_xlabel("Wavenumber (cm⁻¹)")
+                ax.set_ylabel("Intensity")
+                ax.set_title(f"Unknown Polymer Spectrum")
+                ax.grid(True, alpha=0.3)
+                st.pyplot(fig)
+
+                st.subheader("Analysis Hints:")
+                for hint in result["hints"]:
+                    st.write(f"💡 {hint}")
+
+                # User identification
+                user_guess = st.selectbox(
+                    "Your identification:", ["PE", "PP", "PS", "PVC"]
+                )
+                if st.button("Submit Identification"):
+                    if user_guess == polymer_type:
+                        st.success("🎉 Correct! Well done!")
+                    else:
+                        st.error(f"❌ Incorrect. The correct answer is {polymer_type}")
+
+    elif selected_experiment == "aging_simulation":
+        st.subheader("Polymer Aging Simulation")
+        aging_time = st.slider("Aging time (hours):", 0, 200, 50)
+
+        if st.button("Run Aging Simulation"):
+            result = framework.run_virtual_experiment(
+                selected_experiment, {"aging_time": aging_time}
+            )
+
+            if result.get("success"):
+                # Plot comparison
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+
+                # Initial spectrum
+                ax1.plot(result["wavenumbers"], result["initial_spectrum"])
+                ax1.set_title("Initial Spectrum")
+                ax1.set_xlabel("Wavenumber (cm⁻¹)")
+                ax1.set_ylabel("Intensity")
+                ax1.grid(True, alpha=0.3)
+
+                # Aged spectrum
+                ax2.plot(result["wavenumbers"], result["aged_spectrum"])
+                ax2.set_title(f"After {aging_time} hours")
+                ax2.set_xlabel("Wavenumber (cm⁻¹)")
+                ax2.set_ylabel("Intensity")
+                ax2.grid(True, alpha=0.3)
+
+                plt.tight_layout()
+                st.pyplot(fig)
+
+                st.subheader("Observations:")
+                for obs in result["observations"]:
+                    st.write(f"📊 {obs}")
+
+    elif selected_experiment == "model_training":
+        st.subheader("Train Your Own Model")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            model_type = st.selectbox("Model type:", ["CNN", "ResNet", "Transformer"])
+        with col2:
+            epochs = st.slider("Training epochs:", 5, 50, 10)
+
+        if st.button("Start Training"):
+            with st.spinner("Training model..."):
+                result = framework.run_virtual_experiment(
+                    selected_experiment, {"model_type": model_type, "epochs": epochs}
+                )
+
+            if result.get("success"):
+                # Plot training metrics
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+
+                # Training loss
+                ax1.plot(result["train_losses"])
+                ax1.set_title("Training Loss")
+                ax1.set_xlabel("Epoch")
+                ax1.set_ylabel("Loss")
+                ax1.grid(True, alpha=0.3)
+
+                # Validation accuracy
+                ax2.plot(result["val_accuracies"])
+                ax2.set_title("Validation Accuracy")
+                ax2.set_xlabel("Epoch")
+                ax2.set_ylabel("Accuracy")
+                ax2.grid(True, alpha=0.3)
+
+                plt.tight_layout()
+                st.pyplot(fig)
+
+                st.success(
+                    f"Training completed! Final accuracy: {result['final_accuracy']:.3f}"
+                )
+
+                st.subheader("Training Insights:")
+                for insight in result["insights"]:
+                    st.write(f"🎯 {insight}")
+
+
+def render_progress_analytics():
+    """Render learning analytics dashboard"""
+    st.header("📊 Your Progress Analytics")
+
+    framework = st.session_state.educational_framework
+    analytics = framework.get_learning_analytics()
+
+    if analytics:
+        # Overview metrics
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            st.metric("Completed Objectives", analytics["completed_objectives"])
+
+        with col2:
+            st.metric("Study Time", f"{analytics['total_study_time']} min")
+
+        with col3:
+            st.metric("Current Level", analytics["current_level"].title())
+
+        with col4:
+            st.metric("Sessions", analytics["session_count"])
+
+        # Competency scores
+        if analytics["competency_scores"]:
+            st.subheader("Competency Scores")
+
+            domains = list(analytics["competency_scores"].keys())
+            scores = list(analytics["competency_scores"].values())
+
+            fig, ax = plt.subplots(figsize=(10, 6))
+            bars = ax.bar(domains, scores)
+            ax.set_ylabel("Score")
+            ax.set_title("Competency Assessment Results")
+            ax.set_ylim(0, 1)
+
+            # Color bars based on score
+            for bar, score in zip(bars, scores):
+                if score >= 0.8:
+                    bar.set_color("green")
+                elif score >= 0.6:
+                    bar.set_color("orange")
+                else:
+                    bar.set_color("red")
+
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            st.pyplot(fig)
+
+        # Learning style
+        st.subheader("Learning Profile")
+        st.write(f"**Preferred learning style:** {analytics['learning_style'].title()}")
+
+        # Recommendations
+        recommendations = framework.get_learning_recommendations()
+        if recommendations:
+            st.subheader("Next Steps")
+            for rec in recommendations:
+                st.write(f"• {rec}")
+    else:
+        st.info("Complete assessments to see your progress analytics!")
+
+
+def main():
+    """Main educational interface"""
+    st.set_page_config(
+        page_title="POLYMEROS Educational Interface", page_icon="🎓", layout="wide"
+    )
+
+    st.title("🎓 POLYMEROS Educational Interface")
+    st.markdown("**Interactive Learning System for Polymer Science and AI**")
+
+    # Initialize session
+    init_educational_session()
+
+    # Sidebar navigation
+    st.sidebar.title("📚 Learning Modules")
+    page = st.sidebar.selectbox(
+        "Select module:",
+        [
+            "Knowledge Assessment",
+            "Learning Path",
+            "Virtual Laboratory",
+            "Progress Analytics",
+        ],
+    )
+
+    # Render selected page
+    if page == "Knowledge Assessment":
+        render_competency_assessment()
+    elif page == "Learning Path":
+        render_learning_path()
+    elif page == "Virtual Laboratory":
+        render_virtual_laboratory()
+    elif page == "Progress Analytics":
+        render_progress_analytics()
+
+    # Footer
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("**POLYMEROS Educational Framework**")
+    st.sidebar.markdown("*Adaptive learning for polymer science*")
+
+
+if __name__ == "__main__":
+    main()