Download scripts/app.py from LordofMonarchs/Intelligent-Candidate-Ranking-Model: direct link, hf CLI and curl.
- Browser
- Download file 26.8 kB
-
https://huggingface.co/LordofMonarchs/Intelligent-Candidate-Ranking-Model/resolve/c75414818fd574673bff3835aa0c080c4ffb5347/scripts/app.py
- Command line
-
hf download hf://LordofMonarchs/Intelligent-Candidate-Ranking-Model@c75414818fd574673bff3835aa0c080c4ffb5347/scripts/app.py
-
curl -L -o app.py https://huggingface.co/LordofMonarchs/Intelligent-Candidate-Ranking-Model/resolve/c75414818fd574673bff3835aa0c080c4ffb5347/scripts/app.py
26.8 kB
| from __future__ import annotations | |
| import io | |
| import json | |
| import logging | |
| import os | |
| import pickle | |
| import sys | |
| import time | |
| from typing import Dict, List, Optional | |
| import numpy as np | |
| import pandas as pd | |
| import streamlit as st | |
| from rank_bm25 import BM25Okapi | |
| st.set_page_config( | |
| page_title="Redrob Candidate Ranker", | |
| layout="wide", | |
| initial_sidebar_state="expanded", | |
| ) | |
| _SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__)) | |
| _PROJECT_ROOT = os.path.dirname(_SCRIPTS_DIR) | |
| _SRC_DIR = os.path.join(_PROJECT_ROOT, "src") | |
| for _p in [_SRC_DIR, _SCRIPTS_DIR, _PROJECT_ROOT]: | |
| if _p not in sys.path: | |
| sys.path.insert(0, _p) | |
| BASE_DIR = _PROJECT_ROOT | |
| PRECOMPUTED_DIR = os.path.join(BASE_DIR, "precomputed") | |
| DATA_DIR = os.path.join(BASE_DIR, "data") | |
| ALIASES_PATH = os.path.join(DATA_DIR, "skill_aliases.json") | |
| LITE_MODE_LIMIT = 10_000 # max cand. that can enter streamlit mode | |
| def load_jd_config(): | |
| from jd_parser import parse_jd | |
| return parse_jd(ALIASES_PATH) | |
| def load_bm25(): | |
| from retrieval import load_numpy_bm25_artifacts | |
| bm25 = load_numpy_bm25_artifacts(PRECOMPUTED_DIR) | |
| ids_path = os.path.join(PRECOMPUTED_DIR, "candidate_ids.pkl") | |
| if not os.path.isfile(ids_path): | |
| return None, None | |
| with open(ids_path, "rb") as f: | |
| candidate_ids = pickle.load(f) | |
| if bm25 is not None: | |
| return bm25, candidate_ids | |
| # Fallback to pickle | |
| bm25_path = os.path.join(PRECOMPUTED_DIR, "bm25_index.pkl") | |
| if not os.path.isfile(bm25_path): | |
| return None, None | |
| with open(bm25_path, "rb") as f: | |
| bm25 = pickle.load(f) | |
| return bm25, candidate_ids | |
| def load_model(): | |
| model_path = os.path.join(PRECOMPUTED_DIR, "lgbm_model.pkl") | |
| if not os.path.isfile(model_path): | |
| return None | |
| with open(model_path, "rb") as f: | |
| return pickle.load(f) | |
| def sort_with_secondary_tiebreak( | |
| final_scores: Dict[str, float], | |
| fv_cache: Dict[str, dict], | |
| logger, | |
| ) -> List[tuple]: | |
| """ | |
| Sort candidates by final_raw score (primary), then by hard_req_coverage | |
| and bm25_score (secondary, display-only tiebreaks) when scores are tied. | |
| This does NOT change the underlying score values or the model's | |
| predictions — only the display order and assigned rank numbers when | |
| raw_lgbm scores are identical, which happens on small batches because | |
| the trained model places very low weight on bm25_score (confirmed: | |
| bm25_score used in only 2 of ~12,600 possible tree splits). | |
| """ | |
| def sort_key(item): | |
| cid, score = item | |
| fv = fv_cache.get(cid, {}) | |
| hard_req = fv.get("hard_req_coverage", 0.0) | |
| bm25 = fv.get("bm25_score", 0.0) | |
| # Negative for descending order on all three keys | |
| return (-score, -hard_req, -bm25, cid) | |
| sorted_items = sorted(final_scores.items(), key=sort_key) | |
| # Reuse the existing normalization logic from rank.py, just on the | |
| # newly-ordered list — normalization math itself is unchanged. | |
| from rank import _normalize_scores | |
| ranked_top100 = _normalize_scores(sorted_items, logger) | |
| return ranked_top100 | |
| def rank_candidates_inline( | |
| candidates: List[dict], | |
| jd_config, | |
| bm25, | |
| candidate_ids: List[str], | |
| model, | |
| max_n: int = LITE_MODE_LIMIT, | |
| ) -> Optional[pd.DataFrame]: | |
| """Run the full ranking pipeline inline on a small candidate set.""" | |
| from retrieval import run_dual_pass_retrieval, tokenize_query | |
| from features import build_feature_vector, FEATURE_COLUMNS, consistency_score | |
| from reasoning import ReasoningCompiler | |
| from precompute import tokenize_candidate | |
| # this line allows a limited no of candidates for safety of memory | |
| if len(candidates) > max_n: | |
| st.warning( | |
| f"Lite mode: processing first {max_n} of {len(candidates)} candidates " | |
| f"to stay within 1GB RAM limit." | |
| ) | |
| candidates = candidates[:max_n] | |
| cids = [c.get("candidate_id", f"IDX_{i}") for i, c in enumerate(candidates)] | |
| uploaded_cid_set = set(cids) | |
| # Use the REAL precomputed 100K-corpus BM25 index, same as the production pipeline, | |
| # so bm25_score means the same thing here as it does in src/rank.py. | |
| bm25_scores = {} | |
| in_main_index_count = 0 | |
| fallback_count = 0 | |
| if bm25 is not None and candidate_ids: | |
| # Query the full 100K index with the same dual-pass logic as production | |
| full_stage1_ids, full_bm25_scores = run_dual_pass_retrieval(bm25, candidate_ids, jd_config) | |
| main_index_lookup = dict(zip(candidate_ids, range(len(candidate_ids)))) | |
| for cid in cids: | |
| if cid in full_bm25_scores: | |
| bm25_scores[cid] = full_bm25_scores[cid] | |
| in_main_index_count += 1 | |
| elif cid in main_index_lookup: | |
| # Candidate exists in the 100K corpus but wasn't in the dual-pass | |
| # retrieved subset — score them at 0, consistent with how the | |
| # production pipeline treats non-retrieved candidates. | |
| bm25_scores[cid] = 0.0 | |
| in_main_index_count += 1 | |
| else: | |
| fallback_count += 1 | |
| # Fallback: candidates genuinely NOT in the precomputed 100K corpus | |
| # (e.g. a judge uploads new/synthetic candidates never seen during precompute). | |
| # Build a small inline index ONLY for these, and warn the user explicitly | |
| # that their bm25_score uses small-corpus statistics. | |
| fallback_cids = [c.get("candidate_id", "") for c in candidates if c.get("candidate_id", "") not in bm25_scores] | |
| if fallback_cids: | |
| st.warning( | |
| f"{len(fallback_cids)} of {len(candidates)} uploaded candidates were not found " | |
| f"in the precomputed 100K corpus. Their BM25 scores are computed against a " | |
| f"small inline index built only from this upload, which uses different term " | |
| f"statistics than the production pipeline and may not be directly comparable " | |
| f"to scores for candidates found in the main corpus." | |
| ) | |
| fallback_candidates = [c for c in candidates if c.get("candidate_id", "") in fallback_cids] | |
| fallback_corpus = [tokenize_candidate(c) for c in fallback_candidates] | |
| if fallback_corpus: | |
| fallback_bm25 = BM25Okapi(fallback_corpus) | |
| fb_stage1_ids, fb_scores = run_dual_pass_retrieval(fallback_bm25, fallback_cids, jd_config) | |
| bm25_scores.update(fb_scores) | |
| median_bm25 = float(np.median(list(bm25_scores.values()))) if bm25_scores else 0.0 | |
| st.caption( | |
| f"BM25 scoring: {in_main_index_count} candidates scored against the real " | |
| f"100K-candidate corpus, {len(fallback_cids)} scored against a small inline " | |
| f"fallback corpus." | |
| ) | |
| feature_rows = [] | |
| valid_cids = [] | |
| consistency_map = {} | |
| fv_cache = {} | |
| for c in candidates: | |
| cid = c.get("candidate_id", "") | |
| bs = bm25_scores.get(cid, 0.0) | |
| try: | |
| fv = build_feature_vector(c, jd_config, bs, median_bm25) | |
| fv_cache[cid] = fv | |
| row = [fv[col] for col in FEATURE_COLUMNS] | |
| consistency_map[cid] = float(fv.get("consistency_score", 1.0)) | |
| except Exception: | |
| fv_cache[cid] = {col: 0.0 for col in FEATURE_COLUMNS} | |
| row = [bs] + [0.0] * 21 | |
| consistency_map[cid] = 1.0 | |
| feature_rows.append(row) | |
| valid_cids.append(cid) | |
| debug_targets = {"CAND_0000014", "CAND_0000043", "CAND_0000082"} | |
| for i, cid in enumerate(valid_cids): | |
| if cid in debug_targets: | |
| print(f"FEATURE VECTOR DEBUG | {cid} | row[0]={feature_rows[i][0]:.6f} (bm25) | full_row={feature_rows[i]}") | |
| print(f"FEATURE_COLUMNS[0] = {FEATURE_COLUMNS[0]}") | |
| X = np.array(feature_rows, dtype=np.float32) | |
| if model is not None: | |
| raw_scores = model.predict(X) | |
| else: | |
| raw_scores = np.array([bm25_scores.get(cid, 0.0) for cid in valid_cids]) | |
| # BUG 1: Apply consistency multiplier | |
| final_scores = {} | |
| for i, cid in enumerate(valid_cids): | |
| final_scores[cid] = float(raw_scores[i] * consistency_map.get(cid, 1.0)) | |
| # BUG 2: Reuse exact sorting and normalization from src/rank.py | |
| from rank import assert_monotonicity | |
| ranked_top100 = sort_with_secondary_tiebreak(final_scores, fv_cache, logging.getLogger("app")) | |
| try: | |
| assert_monotonicity(ranked_top100) | |
| except AssertionError as e: | |
| st.error(f"Monotonicity Assertion Failed: {e}") | |
| # DEBUG: Print top 10 raw scores for verification | |
| print("\n" + "="*50) | |
| print("TOP 10 RAW SCORES DEBUG (before normalization)") | |
| print("="*50) | |
| for cid, norm_score, rank_i in ranked_top100[:10]: | |
| idx = valid_cids.index(cid) | |
| raw = raw_scores[idx] | |
| cons = consistency_map.get(cid, 1.0) | |
| final = final_scores[cid] | |
| bs = bm25_scores.get(cid, 0.0) | |
| print(f"Rank {rank_i:02d} | {cid} | bm25: {bs:10.6f} | raw_lgbm: {raw:10.6f} | cons: {cons:4.2f} | final_raw: {final:10.6f} | norm: {norm_score:8.6f}") | |
| print("="*50 + "\n") | |
| print(f"BM25 scoping: in_main_index={in_main_index_count}, fallback={fallback_count}") | |
| all_lgbm_scores = [final_scores[cid] for cid, _, _ in ranked_top100] | |
| compiler = ReasoningCompiler(jd_config, all_scores=all_lgbm_scores) | |
| candidate_lookup = {c.get("candidate_id"): c for c in candidates} | |
| rows = [] | |
| for cid, norm_score, rank_i in ranked_top100: | |
| raw_score = final_scores.get(cid, 0.0) | |
| c = candidate_lookup.get(cid, {"candidate_id": cid}) | |
| fv = fv_cache.get(cid, {col: 0.0 for col in FEATURE_COLUMNS}) | |
| reasoning = compiler.compile(c, fv, raw_score, rank_i) | |
| rows.append({ | |
| "rank": rank_i, | |
| "candidate_id": cid, | |
| "score": round(norm_score, 6), | |
| "name": c.get("profile", {}).get("anonymized_name", ""), | |
| "title": c.get("profile", {}).get("current_title", ""), | |
| "company": c.get("profile", {}).get("current_company", ""), | |
| "yoe": c.get("profile", {}).get("years_of_experience", 0), | |
| "location": c.get("profile", {}).get("location", ""), | |
| "hard_req_coverage": round(fv.get("hard_req_coverage", 0), 3), | |
| "consistency_score": round(fv.get("consistency_score", 1), 3), | |
| "reasoning": reasoning, | |
| }) | |
| return pd.DataFrame(rows) | |
| def main(): | |
| st.title(" Redrob Candidate Ranker") | |
| st.caption( | |
| "Candidate ranking: Redrob hackathon submission. " | |
| "Lite mode (≤10K candidates, ≤1GB RAM)." | |
| ) | |
| with st.sidebar: | |
| st.header(" Pipeline status") | |
| jd_config = load_jd_config() | |
| st.success( | |
| f" JD Config loaded: {len(jd_config.hard_requirements)} hard reqs, " | |
| f"{len(jd_config.preferred_requirements)} preferred" | |
| ) | |
| bm25, candidate_ids = load_bm25() | |
| if bm25 is not None: | |
| st.success(f"BM25 Index: {len(candidate_ids):,} candidates indexed") | |
| else: | |
| st.warning("BM25 index not found — run precompute.py first") | |
| model = load_model() | |
| if model is not None: | |
| st.success("LightGBM model loaded") | |
| else: | |
| st.warning("LightGBM model not found — run precompute.py first") | |
| st.divider() | |
| st.header("JD Requirements") | |
| with st.expander("Hard Requirements"): | |
| for name in jd_config.hard_requirements: | |
| st.write(f"• {name.replace('_', ' ').title()}") | |
| with st.expander("Preferred Requirements"): | |
| for name in jd_config.preferred_requirements: | |
| st.write(f"• {name.replace('_', ' ').title()}") | |
| tab1, tab2, tab3 = st.tabs(["Upload & Rank", "Architecture", "Validate"]) | |
| with tab1: | |
| st.header("Upload Candidates & Run Ranking") | |
| col1, col2 = st.columns([2, 1]) | |
| with col1: | |
| uploaded_file = st.file_uploader( | |
| "Upload candidates JSONL file", | |
| type=["jsonl", "json", "txt"], | |
| help=f"Max {LITE_MODE_LIMIT:,} candidates processed in lite mode.", | |
| ) | |
| with col2: | |
| st.metric("RAM Limit", "1 GB") | |
| st.metric("Max Candidates", f"{LITE_MODE_LIMIT:,}") | |
| if model is not None: | |
| st.metric("Ranker", "LightGBM") | |
| else: | |
| st.metric("Ranker", "BM25 fallback") | |
| if uploaded_file is not None: | |
| # Parse JSONL | |
| candidates = [] | |
| malformed = 0 | |
| for line in uploaded_file: | |
| line = line.decode("utf-8", errors="ignore").strip() | |
| if not line: | |
| continue | |
| try: | |
| candidates.append(json.loads(line)) | |
| except json.JSONDecodeError: | |
| malformed += 1 | |
| if malformed > 0: | |
| st.warning(f" Skipped {malformed} malformed lines") | |
| st.info( | |
| f" Loaded {len(candidates):,} candidates from uploaded file" | |
| ) | |
| if len(candidates) == 0: | |
| st.error("No valid candidates found in uploaded file.") | |
| else: | |
| run_btn = st.button( | |
| " Run ranking pipeline", | |
| type="primary", | |
| use_container_width=True, | |
| ) | |
| if run_btn: | |
| with st.spinner("Running ranking pipeline..."): | |
| t0 = time.time() | |
| try: | |
| result_df = rank_candidates_inline( | |
| candidates, jd_config, bm25, candidate_ids, model | |
| ) | |
| elapsed = time.time() - t0 | |
| if result_df is not None and len(result_df) > 0: | |
| st.success( | |
| f" Ranked {len(result_df)} candidates in {elapsed:.1f}s" | |
| ) | |
| m1, m2, m3, m4, m5 = st.columns(5) | |
| m1.metric("Total Ranked", len(result_df)) | |
| m2.metric("Top Score", f"{result_df['score'].max():.4f}") | |
| m3.metric( | |
| "Avg Hard Req Coverage", | |
| f"{result_df['hard_req_coverage'].mean():.1%}" | |
| ) | |
| m4.metric("Wall-clock", f"{elapsed:.1f}s") | |
| low_cons_count = (result_df["consistency_score"] < 0.25).sum() | |
| m5.metric("Honeypots", f"{low_cons_count}/{len(result_df)} flagged", | |
| delta="PASS" if low_cons_count < 10 else "FAIL", delta_color="normal" if low_cons_count < 10 else "inverse") | |
| st.subheader("Top 100 Candidates") | |
| st.caption( | |
| "Note: candidates with identical model scores are ordered by hard " | |
| "requirement coverage, then BM25 relevance, for display purposes. " | |
| "The underlying model scores are unchanged." | |
| ) | |
| display_df = result_df[[ | |
| "rank", "candidate_id", "name", "title", | |
| "company", "yoe", "location", "score", | |
| "hard_req_coverage", "consistency_score" | |
| ]].copy() | |
| st.dataframe( | |
| display_df.style.background_gradient( | |
| subset=["score"], cmap="RdYlGn" | |
| ), | |
| use_container_width=True, | |
| height=500, | |
| ) | |
| st.subheader("Reasoning Explorer") | |
| selected_rank = st.slider( | |
| "Select candidate rank to view reasoning:", | |
| min_value=1, max_value=min(100, len(result_df)) | |
| ) | |
| selected_row = result_df[result_df["rank"] == selected_rank] | |
| if not selected_row.empty: | |
| row = selected_row.iloc[0] | |
| with st.expander( | |
| f"Rank {selected_rank}: {row['name']} — {row['title']} @ {row['company']}", | |
| expanded=True | |
| ): | |
| col_a, col_b = st.columns(2) | |
| col_a.metric("Score", f"{row['score']:.6f}") | |
| col_a.metric("Hard Req Coverage", f"{row['hard_req_coverage']:.1%}") | |
| col_b.metric("YoE", f"{row['yoe']}") | |
| col_b.metric("Consistency", f"{row['consistency_score']:.2f}") | |
| st.markdown(f"**Reasoning:** {row['reasoning']}") | |
| # BUG 3 & 4: Explicit CSV copy and index=False, utf-8 bytes (no BOM) | |
| export_df = result_df[["candidate_id", "rank", "score", "reasoning"]].copy() | |
| csv_bytes = export_df.to_csv(index=False).encode("utf-8") | |
| st.download_button( | |
| label=" Download submission.csv", | |
| data=csv_bytes, | |
| file_name="submission.csv", | |
| mime="text/csv", | |
| use_container_width=True, | |
| ) | |
| else: | |
| st.error("Ranking produced no results.") | |
| except Exception as e: | |
| st.error(f"Pipeline error: {e}") | |
| import traceback | |
| st.code(traceback.format_exc()) | |
| else: | |
| st.info( | |
| " Upload a JSONL file of candidate records to rank them. " | |
| "The file must match the Redrob candidate schema." | |
| ) | |
| # sample | |
| with st.expander("Expected JSONL format (one candidate per line)"): | |
| sample = { | |
| "candidate_id": "CAND_0000001", | |
| "profile": { | |
| "anonymized_name": "Alex Kumar", | |
| "headline": "ML Engineer | FAISS | BM25", | |
| "summary": "...", | |
| "location": "Pune", | |
| "country": "India", | |
| "years_of_experience": 5, | |
| "current_title": "Senior ML Engineer", | |
| "current_company": "TechCorp", | |
| "current_company_size": "201-500", | |
| "current_industry": "Technology" | |
| }, | |
| "...": "see candidate_schema.json for full structure" | |
| } | |
| st.json(sample) | |
| with tab2: | |
| st.header("Architecture Overview") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.subheader("Pipeline Stages") | |
| st.markdown(""" | |
| | Stage | Operation | Runtime | | |
| |-------|-----------|---------| | |
| | 1 | Load BM25 & Dual-Pass Retrieval | 1–2s | | |
| | 2 | Feature Extraction (22 features) | 15–25s | | |
| | 4 | LightGBM LambdaRank Inference | 1–3s | | |
| | 5 | Reasoning Compilation + Audits | 1–2s | | |
| | 6 | Monotonicity Assert + CSV Write | <1s | | |
| | **Total** | **End-to-End** | **3.55s** | | |
| """) | |
| with col2: | |
| st.subheader("Hardware Constraints") | |
| st.markdown(""" | |
| - **≤5 minutes** clock | |
| - **≤16 GB RAM** CPU only | |
| - **Zero** network calls during ranking | |
| - **≤5 GB** intermediate disk state | |
| - **Docker** `--network none` compatible | |
| """) | |
| st.subheader("22-Feature Matrix") | |
| features_df = pd.DataFrame([ | |
| {"#": 1, "Feature": "bm25_score", "Source": "BM25 retrieval"}, | |
| {"#": 2, "Feature": "yoe", "Source": "profile.years_of_experience"}, | |
| {"#": 3, "Feature": "Param_A_Systems_Depth", "Source": "career_history[].description + duration_months"}, | |
| {"#": 4, "Feature": "Param_B_Availability", "Source": "redrob_signals.recruiter_response_rate + last_active_date"}, | |
| {"#": 5, "Feature": "Param_C_Tenure", "Source": "career_history[].duration_months"}, | |
| {"#": 6, "Feature": "Param_D_Notice_Exp", "Source": "redrob_signals.notice_period_days"}, | |
| {"#": 7, "Feature": "Param_E_Credibility", "Source": "skills[].proficiency + skill_assessment_scores"}, | |
| {"#": 8, "Feature": "Param_F_Consulting", "Source": "career_history[].industry + duration_months"}, | |
| {"#": 9, "Feature": "Param_G_Location", "Source": "profile.location + country"}, | |
| {"#": 10, "Feature": "Param_H_GitHub", "Source": "redrob_signals.github_activity_score"}, | |
| {"#": 11, "Feature": "title_ai_fraction", "Source": "career_history[].title"}, | |
| {"#": 12, "Feature": "prod_signal_log", "Source": "career_history[].description"}, | |
| {"#": 13, "Feature": "consistency_score", "Source": "c1×c2×c3×c4×c5"}, | |
| {"#": 14, "Feature": "hard_req_coverage", "Source": "skills[].name vs JD aliases"}, | |
| {"#": 15, "Feature": "flag_consulting_only", "Source": "career_history[].industry"}, | |
| {"#": 16, "Feature": "flag_title_chaser", "Source": "career_history[].title + duration_months"}, | |
| {"#": 17, "Feature": "flag_langchain_dabbler", "Source": "skills[].name + duration_months"}, | |
| {"#": 18, "Feature": "flag_cv_specialist", "Source": "skills[].name + duration_months"}, | |
| {"#": 19, "Feature": "flag_title_desc_mismatch", "Source": "career_history[].title + description"}, | |
| {"#": 20, "Feature": "flag_template_desc", "Source": "career_history[].description"}, | |
| {"#": 21, "Feature": "interaction_req_x_consistency", "Source": "hard_req_coverage × consistency_score"}, | |
| {"#": 22, "Feature": "interaction_yoe_x_prod", "Source": "yoe × prod_signal_log"}, | |
| ]) | |
| st.dataframe(features_df, use_container_width=True, hide_index=True) | |
| with tab3: | |
| st.header("Validate Submission CSV") | |
| st.info( | |
| "Upload your submission.csv to run local format validation " | |
| "before spending one of 3 competition submissions." | |
| ) | |
| val_file = st.file_uploader( | |
| "Upload submission.csv", type=["csv"], key="val_uploader" | |
| ) | |
| if val_file is not None: | |
| try: | |
| df = pd.read_csv(val_file) | |
| errors = [] | |
| warnings_list = [] | |
| required_cols = {"candidate_id", "rank", "score", "reasoning"} | |
| missing_cols = required_cols - set(df.columns) | |
| if missing_cols: | |
| errors.append(f"Missing columns: {missing_cols}") | |
| if not errors: | |
| if len(df) != 100: | |
| errors.append(f"Expected 100 rows, got {len(df)}") | |
| if set(df["rank"].tolist()) != set(range(1, 101)): | |
| errors.append("Ranks must be exactly 1–100 with no gaps") | |
| df_sorted = df.sort_values("rank") | |
| scores = df_sorted["score"].values | |
| for i in range(1, len(scores)): | |
| if scores[i] > scores[i-1] + 1e-9: | |
| errors.append( | |
| f"Score not monotonically non-increasing at rank {i+1}: " | |
| f"{scores[i-1]:.6f} → {scores[i]:.6f}" | |
| ) | |
| break | |
| if df["score"].min() < 0 or df["score"].max() > 1: | |
| warnings_list.append( | |
| f"Scores outside [0,1]: min={df['score'].min():.4f}, " | |
| f"max={df['score'].max():.4f}" | |
| ) | |
| empty_reasoning = df["reasoning"].isna() | (df["reasoning"].str.strip() == "") | |
| if empty_reasoning.any(): | |
| errors.append( | |
| f"{empty_reasoning.sum()} rows have empty reasoning" | |
| ) | |
| if df["candidate_id"].duplicated().any(): | |
| errors.append("Duplicate candidate_ids found") | |
| if errors: | |
| st.error(f"Validation failed!!({len(errors)} errors):") | |
| for e in errors: | |
| st.write(f" • {e}") | |
| else: | |
| st.success("Validation paased!!") | |
| if warnings_list: | |
| for w in warnings_list: | |
| st.warning(f"warning {w}") | |
| col1, col2, col3 = st.columns(3) | |
| col1.metric("Rows", len(df)) | |
| col2.metric("Score Range", f"{df['score'].min():.4f}–{df['score'].max():.4f}") | |
| col3.metric("Reasoning Coverage", "100%") | |
| st.dataframe(df.head(10), use_container_width=True) | |
| except Exception as e: | |
| st.error(f"Failed to parse CSV: {e}") | |
| if __name__ == "__main__": | |
| main() | |