update

.gitignore

@@ -11,3 +11,4 @@ optimize_data.py
 WORKFLOW.md
 data/
 hf_cache/
+MODEL_WORKFLOW.md

app.py

@@ -1,11 +1,9 @@
 import logging
 import os
-import sys
-from pathlib import Path
+from typing import Optional, Tuple
 
 import gradio as gr
 import pandas as pd
-from typing import Optional, Tuple
 
 from config import Config
 from data_processor import DataProcessor
@@ -26,7 +24,13 @@ _backtest_metrics: Optional[dict] = None
 
 def initialize_system():
     """Initialize the prediction system (called once at startup)."""
-    global _processor, _predictor, _config, _df_enrollment, _elective_codes, _backtest_metrics
+    global \
+        _processor, \
+        _predictor, \
+        _config, \
+        _df_enrollment, \
+        _elective_codes, \
+        _backtest_metrics
 
     try:
         logger.info("Initializing prediction system...")
@@ -47,7 +51,9 @@ def initialize_system():
         return False
 
 
-def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.DataFrame], Optional[pd.DataFrame]]:
+def generate_predictions(
+    year: int, semester: int
+) -> Tuple[str, Optional[pd.DataFrame], Optional[pd.DataFrame]]:
     """
     Generate enrollment predictions for a given year and semester.
 
@@ -58,7 +64,13 @@ def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.Dat
     Returns:
         Tuple of (summary_text, recommendations_df, all_predictions_df)
     """
-    global _processor, _predictor, _config, _df_enrollment, _elective_codes, _backtest_metrics
+    global \
+        _processor, \
+        _predictor, \
+        _config, \
+        _df_enrollment, \
+        _elective_codes, \
+        _backtest_metrics
 
     try:
         if semester not in [1, 2]:
@@ -67,8 +79,18 @@ def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.Dat
         if year < 2020 or year > 2030:
             return "❌ Error: Year must be between 2020 and 2030", None, None
 
-        if _config is None or _predictor is None or _processor is None or _df_enrollment is None or _elective_codes is None:
-            return "❌ Error: System not initialized. Please restart the app.", None, None
+        if (
+            _config is None
+            or _predictor is None
+            or _processor is None
+            or _df_enrollment is None
+            or _elective_codes is None
+        ):
+            return (
+                "❌ Error: System not initialized. Please restart the app.",
+                None,
+                None,
+            )
 
         logger.info(f"Generating predictions for {year} Semester {semester}...")
 
@@ -82,12 +104,12 @@ def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.Dat
 
             if backtest_results is None or len(backtest_results) == 0:
                 logger.warning("Backtest returned no results, using defaults")
-                _backtest_metrics = {'mae': 0, 'rmse': 0}
+                _backtest_metrics = {"mae": 0, "rmse": 0}
             else:
                 _backtest_metrics = evaluator.generate_metrics(backtest_results)
                 if _backtest_metrics is None:
                     logger.warning("Metrics calculation failed, using defaults")
-                    _backtest_metrics = {'mae': 0, 'rmse': 0}
+                    _backtest_metrics = {"mae": 0, "rmse": 0}
         else:
             logger.info("Using cached backtest metrics")
 
@@ -108,13 +130,13 @@ def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.Dat
 ## 📊 Prediction Summary for {year} Semester {semester_name}
 
 ### Model Performance (Backtest)
-- **Mean Absolute Error (MAE)**: {metrics['mae']:.2f} students
-- **Root Mean Squared Error (RMSE)**: {metrics['rmse']:.2f} students
+- **Mean Absolute Error (MAE)**: {metrics["mae"]:.2f} students
+- **Root Mean Squared Error (RMSE)**: {metrics["rmse"]:.2f} students
 
 ### 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}
+- **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}
 
 ### Top Course
 """
@@ -122,40 +144,74 @@ def generate_predictions(year: int, semester: int) -> Tuple[str, Optional[pd.Dat
         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"
+            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 = recommended[
+                [
+                    "kode_mk",
+                    "nama_mk",
+                    "predicted_enrollment",
+                    "recommended_quota",
+                    "strategy",
+                ]
+            ].copy()
             recommended_display.columns = [
-                'Course Code', 'Course Name', 'Predicted Students',
-                'Recommended Quota', 'Prediction Strategy'
+                "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)
+            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
+            )
         else:
             recommended_display = pd.DataFrame()
 
         # All predictions
-        all_predictions_display = predictions[[
-            'kode_mk', 'nama_mk', 'predicted_enrollment',
-            'recommended_quota', 'recommendation', 'strategy'
-        ]].copy()
+        all_predictions_display = predictions[
+            [
+                "kode_mk",
+                "nama_mk",
+                "predicted_enrollment",
+                "recommended_quota",
+                "recommendation",
+                "strategy",
+            ]
+        ].copy()
         all_predictions_display.columns = [
-            'Course Code', 'Course Name', 'Predicted Students',
-            'Recommended Quota', 'Recommendation', 'Strategy'
+            "Course Code",
+            "Course Name",
+            "Predicted Students",
+            "Recommended Quota",
+            "Recommendation",
+            "Strategy",
         ]
-        all_predictions_display['Predicted Students'] = all_predictions_display['Predicted Students'].round(1)
-        all_predictions_display['Recommended Quota'] = all_predictions_display['Recommended Quota'].astype(int)
-        all_predictions_display = all_predictions_display.sort_values('Predicted Students', ascending=False)
+        all_predictions_display["Predicted Students"] = all_predictions_display[
+            "Predicted Students"
+        ].round(1)
+        all_predictions_display["Recommended Quota"] = all_predictions_display[
+            "Recommended Quota"
+        ].astype(int)
+        all_predictions_display = all_predictions_display.sort_values(
+            "Predicted Students", ascending=False
+        )
 
-        logger.info(f"✓ Predictions generated successfully")
+        logger.info("✓ Predictions generated successfully")
         return summary, recommended_display, all_predictions_display
 
     except Exception as e:
@@ -190,7 +246,7 @@ def get_data_info() -> str:
 - **Mandatory Courses**: {len(courses) - len(elective_courses)}
 
 ### Student Population
-- **Years Available**: {students['thn'].min()} - {students['thn'].max()}
+- **Years Available**: {students["thn"].min()} - {students["thn"].max()}
 - **Total Records**: {len(students)}
 
 ### Data Source
@@ -212,7 +268,6 @@ if not init_success:
 
 # Create Gradio Interface
 with gr.Blocks(title="SKS Enrollment Predictor") as demo:
-
     # Show disclaimer banner if using demo data
     if os.getenv("DEMO_MODE", "false").lower() == "true":
         gr.Markdown(
@@ -233,12 +288,11 @@ with gr.Blocks(title="SKS Enrollment Predictor") as demo:
             </details>
             </div>
             """,
-            sanitize_html=False
+            sanitize_html=False,
         )
 
     with gr.Tabs():
         with gr.Tab("Generate Predictions"):
-
             with gr.Row():
                 with gr.Column(scale=1):
                     year_input = gr.Number(
@@ -247,62 +301,49 @@ with gr.Blocks(title="SKS Enrollment Predictor") as demo:
                         precision=0,
                         minimum=2020,
                         maximum=2030,
-                        info="Masukkan tahun yang ingin diprediksi"
+                        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, 2 = Genap",
                     )
 
                     predict_btn = gr.Button(
-                        "Generate Predictions",
-                        variant="primary",
-                        size="lg"
+                        "Generate Predictions", variant="primary", size="lg"
                     )
 
                 with gr.Column(scale=2):
                     summary_output = gr.Markdown(
-                        label="Summary",
-                        value="Click 'Generate Predictions' to start"
+                        label="Summary", value="Click 'Generate Predictions' to start"
                     )
 
             gr.Markdown("### Recommended Courses to Open")
             recommended_output = gr.Dataframe(
-                label="Courses Recommended to Open",
-                wrap=True,
-                interactive=False
+                label="Courses Recommended to Open", wrap=True, interactive=False
             )
 
             with gr.Accordion("View All Predictions", open=False):
                 all_predictions_output = gr.Dataframe(
-                    label="All Elective Courses",
-                    wrap=True,
-                    interactive=False
+                    label="All Elective Courses", wrap=True, interactive=False
                 )
 
         with gr.Tab("Data Information"):
-            gr.Markdown(
-            )
+            gr.Markdown()
 
             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
-            )
+            data_info_btn.click(fn=get_data_info, inputs=[], outputs=data_info_output)
 
             demo.load(fn=get_data_info, inputs=[], outputs=data_info_output)
 
-
     predict_btn.click(
         fn=generate_predictions,
         inputs=[year_input, semester_input],
-        outputs=[summary_output, recommended_output, all_predictions_output]
+        outputs=[summary_output, recommended_output, all_predictions_output],
     )
 
     # Footer
@@ -327,9 +368,4 @@ with gr.Blocks(title="SKS Enrollment Predictor") as demo:
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)

evaluator.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from pathlib import Path
 
 import matplotlib.pyplot as plt
@@ -81,10 +80,7 @@ class Evaluator:
 
         self._plot_results(results)
 
-        return {
-            'mae': mae,
-            'rmse': rmse
-        }
+        return {"mae": mae, "rmse": rmse}
 
     def _plot_results(self, df):
         """Generate simple Actual vs Predicted scatter plot."""