feat: data-driven admission probability + projected profile mode

## Core changes

### P0: LR-driven Reach/Target/Safety classification
- Add `core/lr_predictor.py`: loads trained logistic regression models and
  provides `predict_prob(program_id, gpa, gre)` → P(admission)
- Modify `core/school_ranker.py`: classification now uses LR probability
  thresholds (≥70% Safety / 40-70% Target / <40% Reach) instead of
  heuristic GPA rules; falls back to heuristics when no model exists
- `quantpath list` already displayed P(Admit); classification now matches

### P1: Projected evaluation mode
- Add `planned_coursework` field to `UserProfile` (core/models.py)
- Parse `planned_courses:` YAML block in `core/data_loader.py`
- `evaluate(projected=True)` in `core/profile_evaluator.py` merges planned
  courses (assumed grade A) for applicant-time profile scoring
- CLI: `--projected` flag on `evaluate` and `list` commands; `evaluate`
  shows a Current vs Projected comparison table

## Data pipeline
- `tools/collect_data.py`, `tools/parse_admissions.py`: multi-source
  admission data collectors (QuantNet / GradCafe / Chinese forums)
- `tools/scrape_gradcafe.py`: pure-rules GradCafe scraper (no API needed)
- `tools/clean_data.py`: dedup + pollution fix (9,724 → 6,984 records)
- `tools/train_model.py`: per-program logistic regression on GPA+GRE;
  trains 21 programs, saves to `data/models/admission_models.json`
- `data/admissions/collected.csv`: 6,984 cleaned admission records
  (QuantNet 6,723 + GradCafe 234 + manual 27), seasons 2008–2026

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: YichengYang-Ethan

cli/main.py

@@ -21,6 +21,7 @@
     load_questions,
 )
 from core.list_builder import build_school_list
+from core.lr_predictor import predict_prob, get_model_stats
 from core.prerequisite_matcher import match_prerequisites
 from core.profile_evaluator import evaluate as evaluate_profile
 from core.roi_calculator import calculate_roi
@@ -41,12 +42,13 @@ def cmd_evaluate(args: argparse.Namespace) -> None:
     """Evaluate a user profile against MFE programs."""
     profile = load_profile(args.profile)
     programs = load_all_programs()
-    result = evaluate_profile(profile)
+    projected = getattr(args, "projected", False)
+    result = evaluate_profile(profile, projected=projected)
 
     # PDF output path requested
     output_path = getattr(args, "output", None)
     if output_path and output_path.endswith(".pdf"):
-        rankings = rank_schools(profile, programs, result)
+        rankings = rank_schools(profile, programs, result, projected=projected)
         gap_recs = analyze_gaps(result.gaps) if result.gaps else []
 
         from core.report_generator import generate_report
@@ -61,12 +63,14 @@ def cmd_evaluate(args: argparse.Namespace) -> None:
         console.print(f"[green]PDF report saved to:[/green] {path}")
         return
 
+    mode_label = " [bold yellow](Projected — including planned courses)[/bold yellow]" if projected else ""
     # Header
     console.print()
     console.print(
         Panel(
             f"[bold]{profile.name}[/bold] | {profile.university} | "
-            f"GPA {profile.gpa} | {'International' if profile.is_international else 'Domestic'}",
+            f"GPA {profile.gpa} | {'International' if profile.is_international else 'Domestic'}"
+            + mode_label,
             title="QuantPath Profile Evaluation",
             border_style="cyan",
         )
@@ -116,20 +120,71 @@ def cmd_evaluate(args: argparse.Namespace) -> None:
     )
     console.print()
 
-    # School recommendations
-    rankings = rank_schools(profile, programs, result)
+    # School recommendations (use projected mode if flag set)
+    rankings = rank_schools(profile, programs, result, projected=projected)
 
     if rankings.get("reach"):
         reach_names = ", ".join(r["name"] for r in rankings["reach"])
-        console.print(f"  🎯 [bold]Reach:[/bold]   {reach_names}")
+        console.print(f"  Reach:   {reach_names}")
     if rankings.get("target"):
         target_names = ", ".join(r["name"] for r in rankings["target"])
-        console.print(f"  🎯 [bold]Target:[/bold]  {target_names}")
+        console.print(f"  Target:  {target_names}")
     if rankings.get("safety"):
         safety_names = ", ".join(r["name"] for r in rankings["safety"])
-        console.print(f"  🎯 [bold]Safety:[/bold]  {safety_names}")
+        console.print(f"  Safety:  {safety_names}")
     console.print()
 
+    # If projected mode, show comparison: current vs projected
+    if projected and profile.planned_coursework:
+        current_result = evaluate_profile(profile, projected=False)
+        curr_overall = current_result.overall_score
+        proj_overall = result.overall_score
+        diff = proj_overall - curr_overall
+        diff_color = "green" if diff > 0 else "red"
+
+        compare_table = Table(
+            title="[bold]Current vs Projected Profile[/bold]",
+            border_style="yellow",
+            show_lines=True,
+        )
+        compare_table.add_column("Dimension", style="bold", width=16)
+        compare_table.add_column("Current", justify="right", width=10)
+        compare_table.add_column("Projected", justify="right", width=10)
+        compare_table.add_column("Change", justify="right", width=10)
+
+        dim_labels_compare = {
+            "math": "Math",
+            "statistics": "Statistics",
+            "cs": "CS",
+            "finance_econ": "Finance/Econ",
+            "gpa": "GPA",
+        }
+        for dim_id, label in dim_labels_compare.items():
+            curr_s = current_result.dimension_scores.get(dim_id, 0)
+            proj_s = result.dimension_scores.get(dim_id, 0)
+            delta = proj_s - curr_s
+            d_color = "green" if delta > 0.1 else "dim" if abs(delta) <= 0.1 else "red"
+            compare_table.add_row(
+                label,
+                f"{curr_s:.1f}",
+                f"[bold]{proj_s:.1f}[/bold]",
+                f"[{d_color}]{delta:+.1f}[/{d_color}]",
+            )
+        compare_table.add_row(
+            "[bold]OVERALL[/bold]",
+            f"{curr_overall:.1f}",
+            f"[bold]{proj_overall:.1f}[/bold]",
+            f"[{diff_color}]{diff:+.1f}[/{diff_color}]",
+        )
+        console.print(compare_table)
+        n_planned = len(profile.planned_coursework)
+        console.print(
+            f"  [dim]({n_planned} planned courses included: "
+            + ", ".join(c.code for c in profile.planned_coursework[:5])
+            + ("..." if n_planned > 5 else "") + ")[/dim]"
+        )
+        console.print()
+
     # Gaps
     if result.gaps:
         console.print("  [bold red]⚠️  Gaps Found:[/bold red]")
@@ -563,9 +618,14 @@ def cmd_list(args: argparse.Namespace) -> None:
     """Build and display an optimised school application list."""
     profile = load_profile(args.profile)
     programs = load_all_programs()
-    evaluation = evaluate_profile(profile)
+    projected = getattr(args, "projected", False)
+    evaluation = evaluate_profile(profile, projected=projected)
     school_list = build_school_list(profile, programs, evaluation)
 
+    # Determine GRE Quant score for LR prediction
+    gre_quant = profile.test_scores.gre_quant
+    gpa = profile.gpa
+
     console.print()
     console.print(
         Panel(
@@ -591,14 +651,22 @@ def cmd_list(args: argparse.Namespace) -> None:
         table.add_column("University", min_width=18)
         table.add_column("Fit", justify="right", width=6)
         table.add_column("Prereq", justify="right", width=7)
-        table.add_column("Reason", min_width=30)
+        table.add_column("P(Admit)", justify="right", width=9)
+        table.add_column("Reason", min_width=28)
 
         for e in entries:
+            prob = predict_prob(e.program_id, gpa, gre_quant)
+            if prob is not None:
+                pcolor = "green" if prob >= 0.6 else "yellow" if prob >= 0.35 else "red"
+                prob_str = f"[{pcolor}]{prob:.0%}[/{pcolor}]"
+            else:
+                prob_str = "[dim]N/A[/dim]"
             table.add_row(
                 e.name,
                 e.university,
                 f"{e.fit_score:.1f}",
                 f"{e.prereq_match_score:.0%}",
+                prob_str,
                 e.reason,
             )
         console.print(table)
@@ -1018,6 +1086,11 @@ def main() -> None:
         "-o",
         help="Output file path (use .pdf extension for PDF report)",
     )
+    p_eval.add_argument(
+        "--projected",
+        action="store_true",
+        help="Include planned_courses from profile YAML (shows profile at application time)",
+    )
 
     # match
     p_match = subparsers.add_parser("match", help="Match prerequisites")
@@ -1114,6 +1187,11 @@ def main() -> None:
     # list
     p_list = subparsers.add_parser("list", help="Build optimised school application list")
     p_list.add_argument("--profile", "-p", required=True, help="Path to profile YAML")
+    p_list.add_argument(
+        "--projected",
+        action="store_true",
+        help="Include planned courses (shows school list at application time)",
+    )
 
     args = parser.parse_args()
 

core/data_loader.py

@@ -234,9 +234,13 @@ def load_profile(path: str) -> UserProfile:
     # Courses — support both "courses" and "coursework" keys
     raw_courses = raw.get("courses", raw.get("coursework", []))
 
+    # Planned future courses (for projected evaluation mode)
+    raw_planned = raw.get("planned_courses", [])
+
     return UserProfile(
         name=personal.get("name", raw.get("name", "")),
         coursework=[_parse_course(c) for c in raw_courses],
+        planned_coursework=[_parse_course(c) for c in raw_planned],
         gpa=float(personal.get("gpa", raw.get("gpa", 0.0))),
         gpa_quant=float(raw.get("gpa_quant", 0.0)),
         university=personal.get("university", raw.get("university", "")),

core/lr_predictor.py

@@ -0,0 +1,68 @@
+"""Logistic regression admission probability predictor.
+
+Loads pre-trained per-program models from data/models/admission_models.json
+and provides P(admission) predictions given GPA and GRE Quant.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Optional
+
+_MODEL_PATH = Path(__file__).parent.parent / "data" / "models" / "admission_models.json"
+_models: dict | None = None
+
+
+def _load_models() -> dict:
+    global _models
+    if _models is None:
+        if _MODEL_PATH.exists():
+            with _MODEL_PATH.open(encoding="utf-8") as f:
+                _models = json.load(f)
+        else:
+            _models = {}
+    return _models
+
+
+def predict_prob(
+    program_id: str,
+    gpa: Optional[float],
+    gre: Optional[float],
+) -> Optional[float]:
+    """Return P(admission) for a given program, GPA (4-scale), and GRE Quant.
+
+    Returns None if the program has no trained model or inputs are missing.
+    """
+    models = _load_models()
+    m = models.get(program_id)
+    if not m:
+        return None
+    if gpa is None and gre is None:
+        return None
+
+    means = m["means"]
+    stds = m["stds"]
+    coef = m["coef"]
+    intercept = m["intercept"]
+
+    # Use model mean as fallback for missing values
+    gpa_val = gpa if gpa is not None else means[0]
+    gre_val = gre if gre is not None else means[1]
+
+    z_gpa = (gpa_val - means[0]) / stds[0]
+    z_gre = (gre_val - means[1]) / stds[1]
+
+    logit = coef[0] * z_gpa + coef[1] * z_gre + intercept
+    prob = 1.0 / (1.0 + math.exp(-logit))
+    return round(prob, 4)
+
+
+def get_model_stats(program_id: str) -> Optional[dict]:
+    """Return model stats (n, accept_rate, AUC, GPA/GRE percentiles) for a program."""
+    return _load_models().get(program_id)
+
+
+def has_model(program_id: str) -> bool:
+    return program_id in _load_models()

core/models.py

@@ -116,6 +116,9 @@ class UserProfile:
     # Tests
     test_scores: TestScores = field(default_factory=TestScores)
 
+    # Planned future courses (for projected evaluation mode)
+    planned_coursework: list[Course] = field(default_factory=list)
+
     # Experience
     work_experience: list[dict[str, Any]] = field(default_factory=list)
     projects: list[dict[str, Any]] = field(default_factory=list)

core/profile_evaluator.py

@@ -461,20 +461,17 @@ def _weighted_result(
 _STRENGTH_THRESHOLD = 9.0  # factors at or above this are strengths
 
 
-def evaluate(profile: UserProfile) -> EvaluationResult:
+def evaluate(profile: UserProfile, projected: bool = False) -> EvaluationResult:
     """Run the full 5-dimension evaluation on *profile*.
 
-    Steps:
-        1. Score every factor within each dimension.
-        2. Compute each dimension's weighted score.
-        3. Compute the overall score (weighted across dimensions).
-        4. Identify gaps (score 0 or below 6).
-        5. Identify strengths (score >= 9).
-
     Parameters
     ----------
     profile:
         A fully-populated :class:`UserProfile`.
+    projected:
+        If True, merge ``profile.planned_coursework`` into the evaluation,
+        assuming all planned courses will be completed with an A grade.
+        Use this to see what the profile will look like at application time.
 
     Returns
     -------
@@ -483,6 +480,19 @@ def evaluate(profile: UserProfile) -> EvaluationResult:
         ``strengths``, and an empty ``school_recommendations`` dict
         (filled later by the school ranker).
     """
+    if projected and profile.planned_coursework:
+        # Merge planned courses in with grade "A" (assumed successful completion)
+        import copy
+        profile = copy.copy(profile)
+        extra = []
+        for c in profile.planned_coursework:
+            pc = copy.copy(c)
+            if not pc.grade or pc.grade in ("TBD", ""):
+                pc.grade = "A"
+            extra.append(pc)
+        profile = copy.copy(profile)
+        profile.coursework = list(profile.coursework) + extra
+
     scorers: dict[str, Any] = {
         "math": _score_math,
         "statistics": _score_statistics,