update

app.py

@@ -62,7 +62,7 @@ def generate_predictions(
         semester: Target semester (1 = Ganjil/Odd, 2 = Genap/Even)
 
     Returns:
-        Tuple of (summary_text, recommendations_df, all_predictions_df)
+        Tuple of (summary_text, all_predictions_df, comparison_df)
     """
     global \
         _processor, \
@@ -74,7 +74,11 @@ def generate_predictions(
 
     try:
         if semester not in [1, 2]:
-            return "❌ Error: Semester must be 1 (Ganjil) or 2 (Genap)", None, None
+            return (
+                "❌ Error: Semester must be 1 (Ganjil) or 2 (Genap)",
+                None,
+                None,
+            )
 
         if year < 2020 or year > 2030:
             return "❌ Error: Year must be between 2020 and 2030", None, None
@@ -97,6 +101,21 @@ def generate_predictions(
         _config.prediction.PREDICT_YEAR = year
         _config.prediction.PREDICT_SEMESTER = semester
 
+        # Check if actual data exists for this year/semester
+        actual_data = _df_enrollment[
+            (_df_enrollment["thn"] == year) & (_df_enrollment["smt"] == semester)
+        ]
+        has_actual_data = len(actual_data) > 0
+
+        if has_actual_data:
+            logger.info(
+                f"✓ Found actual enrollment data for {year} Semester {semester} - will compare predictions vs actual"
+            )
+        else:
+            logger.info(
+                f"ℹ No actual data for {year} Semester {semester} - generating future predictions"
+            )
+
         if _backtest_metrics is None:
             logger.info("Running backtest for the first time...")
             evaluator = Evaluator(_config)
@@ -123,65 +142,119 @@ def generate_predictions(
             semester,
         )
 
-        recommended = predictions[predictions["recommendation"] == "BUKA"].copy()
-
         semester_name = "Ganjil (Odd)" if semester == 1 else "Genap (Even)"
-        summary = f"""
-## 📊 Prediction Summary for {year} Semester {semester_name}
+        total_to_open = len(predictions[predictions["recommendation"] == "BUKA"])
+        total_seats = (
+            int(
+                predictions[predictions["recommendation"] == "BUKA"][
+                    "recommended_quota"
+                ].sum()
+            )
+            if total_to_open > 0
+            else 0
+        )
 
-### Model Performance (Backtest)
-- **Mean Absolute Error (MAE)**: {metrics["mae"]:.2f} students
-- **Root Mean Squared Error (RMSE)**: {metrics["rmse"]:.2f} students
+        # Build summary with actual vs prediction comparison if data exists
+        if has_actual_data:
+            # Merge predictions with actual data
+            comparison = predictions.merge(
+                actual_data[["kode_mk", "enrollment"]], on="kode_mk", how="left"
+            )
+            comparison = comparison.rename(columns={"enrollment": "actual_enrollment"})
 
-### Recommendations
-- **Courses to Open**: {len(recommended)}
-- **Total Seats Needed**: {int(recommended["recommended_quota"].sum()) if not recommended.empty else 0}
-- **Estimated Students**: {int(recommended["predicted_enrollment"].sum()) if not recommended.empty else 0}
+            # Calculate comparison metrics only for courses with actual data
+            courses_with_actual = comparison[
+                comparison["actual_enrollment"].notna()
+            ].copy()
 
-### Top Course
+            if len(courses_with_actual) > 0:
+                comparison_mae = abs(
+                    courses_with_actual["predicted_enrollment"]
+                    - courses_with_actual["actual_enrollment"]
+                ).mean()
+                comparison_rmse = (
+                    (
+                        courses_with_actual["predicted_enrollment"]
+                        - courses_with_actual["actual_enrollment"]
+                    )
+                    ** 2
+                ).mean() ** 0.5
+                total_actual = courses_with_actual["actual_enrollment"].sum()
+                total_predicted = courses_with_actual["predicted_enrollment"].sum()
+
+                summary = f"""## 📊 {year} Semester {semester_name} - Validation Against Actual Data
+
+<div style='background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; border-radius: 10px; color: white; margin-bottom: 20px;'>
+<h3 style='margin-top: 0; color: white;'>✅ Historical Validation</h3>
+<p style='margin-bottom: 5px;'><strong>Status:</strong> Comparing predictions against actual enrollment data</p>
+<p style='margin-bottom: 0;'><strong>Courses Validated:</strong> {len(courses_with_actual)} courses</p>
+</div>
+
+### 📈 Prediction Accuracy
+| Metric | Value |
+|--------|-------|
+| **Prediction MAE** | {comparison_mae:.2f} students |
+| **Prediction RMSE** | {comparison_rmse:.2f} students |
+| **Overall Accuracy** | {(1 - abs(total_predicted - total_actual) / total_actual) * 100:.1f}% |
+
+### 📊 Enrollment Summary
+| Category | Actual | Predicted | Difference |
+|----------|--------|-----------|------------|
+| **Total Students** | {int(total_actual)} | {int(total_predicted)} | {int(total_predicted - total_actual):+d} |
+| **Courses Analyzed** | {len(courses_with_actual)} | {len(courses_with_actual)} | - |
+
+### 🎯 Model Baseline (Cross-Validation)
+- **Backtest MAE**: {metrics["mae"]:.2f} students
+- **Backtest RMSE**: {metrics["rmse"]:.2f} students
+
+### 💡 Recommendation Summary
+- **Courses Recommended to Open**: {total_to_open}
+- **Total Quota Needed**: {total_seats} seats
+
+---
+💡 **Tip:** Scroll down to see the detailed comparison table showing prediction accuracy for each course.
 """
+            else:
+                summary = f"""## 📊 {year} Semester {semester_name}
 
-        if not recommended.empty:
-            top_course = recommended.iloc[0]
-            summary += f"- **{top_course['nama_mk']}** ({top_course['kode_mk']})\n"
-            summary += (
-                f"  - Predicted: {top_course['predicted_enrollment']:.0f} students\n"
-            )
-            summary += (
-                f"  - Recommended Quota: {top_course['recommended_quota']:.0f} seats"
-            )
-        else:
-            summary += "- No courses recommended to open"
-
-        if not recommended.empty:
-            recommended_display = recommended[
-                [
-                    "kode_mk",
-                    "nama_mk",
-                    "predicted_enrollment",
-                    "recommended_quota",
-                    "strategy",
-                ]
-            ].copy()
-            recommended_display.columns = [
-                "Course Code",
-                "Course Name",
-                "Predicted Students",
-                "Recommended Quota",
-                "Prediction Strategy",
-            ]
-            recommended_display["Predicted Students"] = recommended_display[
-                "Predicted Students"
-            ].round(1)
-            recommended_display["Recommended Quota"] = recommended_display[
-                "Recommended Quota"
-            ].astype(int)
-            recommended_display = recommended_display.sort_values(
-                "Predicted Students", ascending=False
-            )
+<div style='background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); padding: 20px; border-radius: 10px; color: white; margin-bottom: 20px;'>
+<h3 style='margin-top: 0; color: white;'>⚠️ Limited Validation Data</h3>
+<p style='margin-bottom: 0;'>Actual semester data exists, but no matching elective courses found for comparison</p>
+</div>
+
+### 🎯 Model Performance (Backtest)
+- **MAE**: {metrics["mae"]:.2f} students
+- **RMSE**: {metrics["rmse"]:.2f} students
+
+### 💡 Recommendations
+- **Courses to Open**: {total_to_open}
+| **Total Seats** | {total_seats} |
+| **Estimated Total Students** | {int(predictions["predicted_enrollment"].sum())} |
+"""
         else:
-            recommended_display = pd.DataFrame()
+            summary = f"""## 📊 {year} Semester {semester_name} - Future Prediction
+
+<div style='background: linear-gradient(135deg, #fa709a 0%, #fee140 100%); padding: 20px; border-radius: 10px; color: white; margin-bottom: 20px;'>
+<h3 style='margin-top: 0; color: white;'>🔮 Forward-Looking Forecast</h3>
+<p style='margin-bottom: 5px;'><strong>Status:</strong> No actual enrollment data available</p>
+<p style='margin-bottom: 0;'><strong>Type:</strong> Predictive forecast based on historical trends</p>
+</div>
+
+### 🎯 Model Performance (Historical Backtest)
+| Metric | Value |
+|--------|-------|
+| **MAE** | {metrics["mae"]:.2f} students |
+| **RMSE** | {metrics["rmse"]:.2f} students |
+
+### 📋 Forecast Summary
+| Category | Value |
+|----------|-------|
+| **Courses to Open** | {total_to_open} |
+| **Total Seats** | {total_seats} |
+| **Estimated Total Students** | {int(predictions["predicted_enrollment"].sum())} |
+"""
 
+        # Prepare all predictions display
         # All predictions
         all_predictions_display = predictions[
             [
@@ -190,29 +263,125 @@ def generate_predictions(
                 "predicted_enrollment",
                 "recommended_quota",
                 "recommendation",
+                "confidence",
                 "strategy",
             ]
         ].copy()
         all_predictions_display.columns = [
             "Course Code",
             "Course Name",
-            "Predicted Students",
-            "Recommended Quota",
-            "Recommendation",
+            "Predicted",
+            "Quota",
+            "Status",
+            "Confidence",
             "Strategy",
         ]
-        all_predictions_display["Predicted Students"] = all_predictions_display[
-            "Predicted Students"
+        all_predictions_display["Predicted"] = all_predictions_display[
+            "Predicted"
         ].round(1)
-        all_predictions_display["Recommended Quota"] = all_predictions_display[
-            "Recommended Quota"
-        ].astype(int)
+        all_predictions_display["Quota"] = all_predictions_display["Quota"].astype(int)
+
+        # Add status emoji
+        all_predictions_display["Status"] = all_predictions_display["Status"].map(
+            {"BUKA": "✅ OPEN", "TUTUP": "❌ CLOSE"}
+        )
+
         all_predictions_display = all_predictions_display.sort_values(
-            "Predicted Students", ascending=False
+            "Predicted", ascending=False
         )
 
-        logger.info("✓ Predictions generated successfully")
-        return summary, recommended_display, all_predictions_display
+        # Prepare comparison table if actual data exists
+        comparison_display = None
+        if has_actual_data:
+            logger.info(
+                f"Building comparison table - Actual data has {len(actual_data)} courses"
+            )
+            logger.info(f"Predictions has {len(predictions)} courses")
+
+            comparison = predictions.merge(
+                actual_data[["kode_mk", "enrollment"]], on="kode_mk", how="left"
+            )
+            comparison = comparison.rename(columns={"enrollment": "actual_enrollment"})
+
+            # Filter to courses with actual data and calculate error
+            courses_with_actual = comparison[
+                comparison["actual_enrollment"].notna()
+            ].copy()
+
+            logger.info(
+                f"Courses with matching actual data: {len(courses_with_actual)}"
+            )
+            if len(courses_with_actual) > 0:
+                logger.info(
+                    f"Matching courses: {courses_with_actual['kode_mk'].tolist()}"
+                )
+
+            if len(courses_with_actual) > 0:
+                courses_with_actual["error"] = (
+                    courses_with_actual["predicted_enrollment"]
+                    - courses_with_actual["actual_enrollment"]
+                )
+                courses_with_actual["abs_error"] = abs(courses_with_actual["error"])
+                courses_with_actual["accuracy_%"] = 100 * (
+                    1
+                    - courses_with_actual["abs_error"]
+                    / courses_with_actual["actual_enrollment"].replace(0, 1)
+                )
+
+                comparison_display = courses_with_actual[
+                    [
+                        "kode_mk",
+                        "nama_mk",
+                        "actual_enrollment",
+                        "predicted_enrollment",
+                        "error",
+                        "abs_error",
+                        "accuracy_%",
+                        "strategy",
+                    ]
+                ].copy()
+
+                comparison_display.columns = [
+                    "Course Code",
+                    "Course Name",
+                    "Actual",
+                    "Predicted",
+                    "Error",
+                    "Abs Error",
+                    "Accuracy %",
+                    "Strategy",
+                ]
+
+                comparison_display["Actual"] = comparison_display["Actual"].astype(int)
+                comparison_display["Predicted"] = comparison_display["Predicted"].round(
+                    1
+                )
+                comparison_display["Error"] = comparison_display["Error"].round(1)
+                comparison_display["Abs Error"] = comparison_display["Abs Error"].round(
+                    1
+                )
+                comparison_display["Accuracy %"] = comparison_display[
+                    "Accuracy %"
+                ].round(1)
+
+                comparison_display = comparison_display.sort_values(
+                    "Abs Error", ascending=False
+                )
+
+                logger.info(
+                    f"✓ Comparison table created with {len(comparison_display)} courses"
+                )
+            else:
+                logger.warning(
+                    "⚠️ Actual data exists but no matching courses found for comparison"
+                )
+                logger.warning(f"Predicted courses: {predictions['kode_mk'].tolist()}")
+                logger.warning(f"Actual courses: {actual_data['kode_mk'].tolist()}")
+
+        logger.info(
+            f"✓ Predictions generated successfully (comparison_display: {comparison_display is not None})"
+        )
+        return summary, all_predictions_display, comparison_display
 
     except Exception as e:
         error_msg = f"❌ Error generating predictions: {str(e)}"
@@ -291,79 +460,161 @@ with gr.Blocks(title="SKS Enrollment Predictor") as demo:
             sanitize_html=False,
         )
 
+    # Header
+    gr.Markdown(
+        """
+        # 🎓 SKS Course Enrollment Prediction System
+        ### Intelligent forecasting for elective course planning
+        """
+    )
+
     with gr.Tabs():
-        with gr.Tab("Generate Predictions"):
+        with gr.Tab("📊 Predictions", id="predictions"):
             with gr.Row():
-                with gr.Column(scale=1):
+                with gr.Column(scale=1, min_width=300):
+                    gr.Markdown("### 🎯 Select Target Semester")
+
                     year_input = gr.Number(
-                        label="Target Year",
+                        label="Year",
                         value=2025,
                         precision=0,
                         minimum=2020,
                         maximum=2030,
-                        info="Masukkan tahun yang ingin diprediksi",
                     )
 
                     semester_input = gr.Radio(
                         choices=[1, 2],
                         label="Semester",
                         value=2,
-                        info="1 = Ganjil, 2 = Genap",
+                        info="1 = Ganjil (Odd) | 2 = Genap (Even)",
                     )
 
                     predict_btn = gr.Button(
-                        "Generate Predictions", variant="primary", size="lg"
+                        "🚀 Generate Predictions",
+                        variant="primary",
+                        size="lg",
+                        scale=1,
+                    )
+
+                    gr.Markdown(
+                        """
+                        ---
+                        **💡 Tips:**
+                        - Historical semesters show validation results
+                        - Future semesters show forecasts
+                        - Use filters in tables to find specific courses
+                        """
                     )
 
                 with gr.Column(scale=2):
                     summary_output = gr.Markdown(
-                        label="Summary", value="Click 'Generate Predictions' to start"
+                        value="""
+                        <div style='text-align: center; padding: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; color: white;'>
+                        <h2 style='color: white; margin-top: 0;'>👈 Select Parameters</h2>
+                        <p style='margin-bottom: 0;'>Choose a year and semester, then click "Generate Predictions"</p>
+                        </div>
+                        """
                     )
 
-            gr.Markdown("### Recommended Courses to Open")
-            recommended_output = gr.Dataframe(
-                label="Courses Recommended to Open", wrap=True, interactive=False
-            )
+            gr.Markdown("---")
 
-            with gr.Accordion("View All Predictions", open=False):
-                all_predictions_output = gr.Dataframe(
-                    label="All Elective Courses", wrap=True, interactive=False
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 📋 All Course Predictions")
+                    gr.Markdown(
+                        "*Complete list of all elective courses with recommendations*"
+                    )
+                    all_predictions_output = gr.Dataframe(
+                        label="Predictions",
+                        wrap=True,
+                        interactive=False,
+                    )
+
+            gr.Markdown("---")
+
+            with gr.Accordion(
+                "📈 Prediction vs Actual Comparison", open=False
+            ) as comparison_accordion:
+                comparison_info = gr.Markdown(
+                    value="*This section will show validation data when actual enrollment is available*",
+                )
+                comparison_output = gr.Dataframe(
+                    label="Detailed Comparison",
+                    wrap=True,
+                    interactive=False,
                 )
 
-        with gr.Tab("Data Information"):
-            gr.Markdown()
+        with gr.Tab("ℹ️ Data Info", id="info"):
+            gr.Markdown("### 📁 Dataset Information")
 
-            data_info_btn = gr.Button("Refresh Data Info", variant="secondary")
+            data_info_btn = gr.Button("🔄 Refresh Data Info", variant="secondary")
             data_info_output = gr.Markdown()
 
             data_info_btn.click(fn=get_data_info, inputs=[], outputs=data_info_output)
-
             demo.load(fn=get_data_info, inputs=[], outputs=data_info_output)
 
+    def update_ui_with_predictions(year, semester):
+        """Wrapper to handle UI updates based on whether comparison data exists."""
+        summary, all_predictions, comparison = generate_predictions(year, semester)
+
+        logger.info(
+            f"UI Update: comparison is None: {comparison is None}, empty: {comparison.empty if comparison is not None else 'N/A'}"
+        )
+
+        if comparison is not None and not comparison.empty:
+            logger.info(f"Showing comparison table with {len(comparison)} rows")
+            return (
+                summary,
+                all_predictions,
+                gr.update(open=True),  # Open accordion
+                gr.update(
+                    value=f"**✅ Validated against {len(comparison)} courses with actual enrollment data**\n\nThe table below shows prediction accuracy for each course:",
+                ),
+                gr.update(value=comparison),
+            )
+        else:
+            logger.info("Hiding comparison table - no data available")
+            return (
+                summary,
+                all_predictions,
+                gr.update(open=False),  # Keep accordion closed
+                gr.update(
+                    value="*No actual enrollment data available for this semester (future prediction)*",
+                ),
+                gr.update(value=None),
+            )
+
     predict_btn.click(
-        fn=generate_predictions,
+        fn=update_ui_with_predictions,
         inputs=[year_input, semester_input],
-        outputs=[summary_output, recommended_output, all_predictions_output],
+        outputs=[
+            summary_output,
+            all_predictions_output,
+            comparison_accordion,
+            comparison_info,
+            comparison_output,
+        ],
     )
 
     # Footer
+    gr.Markdown("---")
     if os.getenv("DEMO_MODE", "false").lower() == "true":
         gr.Markdown(
             """
-            ---
-            <div style='text-align: center; color: #666; font-size: 0.9em;'>
-            📊 Demo Version with Anonymized Data | For Educational Purposes
+            <div style='text-align: center; padding: 20px; background: #f8f9fa; border-radius: 10px;'>
+            <p style='margin: 0; color: #666;'>📊 <strong>Demo Version</strong> with Anonymized Data | For Educational Purposes</p>
             </div>
-            """
+            """,
+            sanitize_html=False,
         )
     else:
         gr.Markdown(
             """
-            ---
-            <div style='text-align: center; color: #666; font-size: 0.9em;'>
-            🔒 Private & Confidential | For Authorized Use Only
+            <div style='text-align: center; padding: 20px; background: #f8f9fa; border-radius: 10px;'>
+            <p style='margin: 0; color: #666;'>🔒 <strong>Private & Confidential</strong> | For Authorized Use Only</p>
             </div>
-            """
+            """,
+            sanitize_html=False,
         )
 
 # Launch the app