Spaces:
Running
Running
| """Human-calibrated interview scores. | |
| Models trained to predict the ratings that panels of human raters gave to 138 real mock | |
| interviews (MIT Interview Dataset, ~9 raters per interview). The same feature extractor | |
| is used for training and at runtime, so the model sees identical inputs in both places. | |
| """ | |
| import os | |
| import re | |
| from typing import Dict, List, Optional | |
| import joblib | |
| import librosa | |
| import numpy as np | |
| HERE = os.path.dirname(os.path.abspath(__file__)) | |
| MODEL_PATH = os.path.join(HERE, "assets", "models", "calibrated_scores.joblib") | |
| # --------------------------------------------------------------------------------------- | |
| # Text features (from the candidate's words) | |
| # --------------------------------------------------------------------------------------- | |
| FILLERS = re.compile(r"\b(um+|uh+|uhm+|er+|ah+|hmm+|like|you know|i mean|kind of|sort of|basically|actually)\b") | |
| POS = set("good great love enjoy excited happy interesting passion passionate fun amazing excellent best success " | |
| "successful proud glad".split()) | |
| NEG = set("bad hard difficult problem problems stress stressed worried hate fail failed failure wrong sorry " | |
| "unfortunately".split()) | |
| TENTATIVE = set("maybe perhaps guess probably possibly somewhat seems".split()) | |
| WE = {"we", "us", "our", "team", "together"} | |
| I_WORDS = {"i", "me", "my", "i'm", "i've", "myself"} | |
| def text_features(turns: List[str]) -> Dict[str, float]: | |
| text = " ".join(turns).lower() | |
| words = re.findall(r"[a-z']+", text) | |
| n = max(len(words), 1) | |
| sents = [s for s in re.split(r"[.!?]+", text) if s.strip()] | |
| return { | |
| "txt_words": len(words), | |
| "txt_words_per_turn": len(words) / max(len(turns), 1), | |
| "txt_type_token": len(set(words)) / n, | |
| "txt_filler_rate": len(FILLERS.findall(text)) / n, | |
| "txt_i_rate": sum(w in I_WORDS for w in words) / n, | |
| "txt_we_rate": sum(w in WE for w in words) / n, | |
| "txt_pos_rate": sum(w in POS for w in words) / n, | |
| "txt_neg_rate": sum(w in NEG for w in words) / n, | |
| "txt_tentative_rate": sum(w in TENTATIVE for w in words) / n, | |
| "txt_number_rate": len(re.findall(r"\b\d+\b|\b(one|two|three|four|five|ten|hundred|percent)\b", text)) / n, | |
| "txt_avg_word_len": float(np.mean([len(w) for w in words])) if words else 0.0, | |
| "txt_avg_sentence_len": len(words) / max(len(sents), 1), | |
| "txt_long_word_rate": sum(len(w) >= 7 for w in words) / n, | |
| "txt_because_rate": len(re.findall(r"\b(because|so that|therefore|which meant|as a result)\b", text)) / n, | |
| } | |
| # --------------------------------------------------------------------------------------- | |
| # Voice features (from the candidate's audio segments) | |
| # --------------------------------------------------------------------------------------- | |
| def _sample_segments(segments: List[np.ndarray], sr: int, max_seconds: float = 90.0) -> List[np.ndarray]: | |
| """Evenly sample segments so pitch tracking stays fast on long interviews.""" | |
| total = sum(len(s) for s in segments) / sr | |
| if total <= max_seconds: | |
| return segments | |
| step = total / max_seconds | |
| out, acc, nxt = [], 0.0, 0.0 | |
| for s in segments: | |
| if acc >= nxt: | |
| out.append(s) | |
| nxt += step * len(s) / sr | |
| acc += len(s) / sr | |
| return out | |
| def voice_features(y: np.ndarray, sr: int, utterances: List[Dict]) -> Dict[str, float]: | |
| cand = [u for u in utterances if u["role"] == "Interviewee"] | |
| other = [u for u in utterances if u["role"] != "Interviewee"] | |
| seg = lambda u: y[int(u["start"] * sr / 1000): int(u["end"] * sr / 1000)] | |
| segs = [s for s in (seg(u) for u in cand) if len(s) > sr // 5] | |
| cand_time = sum((u["end"] - u["start"]) / 1000 for u in cand) | |
| other_time = sum((u["end"] - u["start"]) / 1000 for u in other) | |
| f = { | |
| "voc_talk_share": cand_time / max(cand_time + other_time, 1e-6), | |
| "voc_turn_len_mean": cand_time / max(len(cand), 1), | |
| "voc_turns_per_min": len(cand) / max((cand_time + other_time) / 60, 1e-6), | |
| } | |
| if not segs: | |
| return f | |
| # pauses inside the candidate's speech | |
| speech, pauses = 0.0, [] | |
| for s in segs: | |
| iv = librosa.effects.split(s, top_db=32, frame_length=1024, hop_length=256) | |
| speech += sum(e - b for b, e in iv) / sr | |
| pauses += [(b2 - e1) / sr for (_, e1), (b2, _) in zip(iv[:-1], iv[1:]) if (b2 - e1) / sr >= 0.25] | |
| f.update({ | |
| "voc_speech_ratio": speech / max(cand_time, 1e-6), | |
| "voc_pauses_per_min": len(pauses) / max(cand_time / 60, 1e-6), | |
| "voc_pause_mean": float(np.mean(pauses)) if pauses else 0.0, | |
| "voc_long_pause_rate": sum(p >= 1.0 for p in pauses) / max(cand_time / 60, 1e-6), | |
| }) | |
| # loudness dynamics | |
| rms = np.concatenate([librosa.feature.rms(y=s, frame_length=1024, hop_length=256)[0] for s in segs]) | |
| rms_db = 20 * np.log10(rms + 1e-5) | |
| voiced_db = rms_db[rms_db > np.percentile(rms_db, 30)] | |
| f.update({ | |
| "voc_loud_std_db": float(voiced_db.std()), | |
| "voc_loud_range_db": float(np.percentile(voiced_db, 95) - np.percentile(voiced_db, 10)), | |
| "voc_shimmer": float(np.mean(np.abs(np.diff(rms))) / (rms.mean() + 1e-9)), | |
| }) | |
| # spectral brightness | |
| cent = np.concatenate([librosa.feature.spectral_centroid(y=s, sr=sr, n_fft=1024, hop_length=512)[0] for s in segs]) | |
| f["voc_centroid_mean"] = float(cent.mean()) | |
| f["voc_centroid_std"] = float(cent.std()) | |
| # pitch (pYIN on an even sample of up to 90 s) | |
| pitches = [] | |
| for s in _sample_segments(segs, sr): | |
| f0, voiced, _ = librosa.pyin(s, fmin=70, fmax=400, sr=sr, frame_length=1024, hop_length=256) | |
| pitches.append(f0[voiced & ~np.isnan(f0)]) | |
| p = np.concatenate(pitches) if pitches else np.array([]) | |
| if len(p) > 10: | |
| semis = 12 * np.log2(p / np.median(p)) | |
| f.update({ | |
| "voc_pitch_median": float(np.median(p)), | |
| "voc_pitch_semitone_std": float(semis.std()), | |
| "voc_pitch_range_semis": float(np.percentile(semis, 95) - np.percentile(semis, 5)), | |
| "voc_jitter": float(np.mean(np.abs(np.diff(p))) / p.mean()), | |
| "voc_voiced_ratio": len(p) / max(sum(len(s) for s in _sample_segments(segs, sr)) / 256, 1), | |
| }) | |
| return f | |
| def extract_features(y: np.ndarray, sr: int, utterances: List[Dict], candidate_texts: List[str]) -> Dict[str, float]: | |
| f = voice_features(y, sr, utterances) | |
| t = text_features(candidate_texts) | |
| cand_time = sum((u["end"] - u["start"]) / 1000 for u in utterances if u["role"] == "Interviewee") | |
| f["voc_speaking_rate"] = t["txt_words"] / max(cand_time, 1e-6) | |
| f.update(t) | |
| return f | |
| # --------------------------------------------------------------------------------------- | |
| # Prediction | |
| # --------------------------------------------------------------------------------------- | |
| TRAIT_LABELS = { | |
| "en": {"Overall": "Overall impression", "RecommendHiring": "Hiring recommendation", "Excited": "Enthusiasm", | |
| "EngagingTone": "Engaging tone", "Friendly": "Friendliness", "NoFillers": "Few filler words", | |
| "StructuredAnswers": "Structured answers", "Calm": "Calmness", "Focused": "Focus", | |
| "Engaged": "Engagement", "Paused": "Good use of pauses", "NotAwkward": "Ease / not awkward", | |
| "Colleague": "Would be a good colleague", "Authentic": "Authenticity", "NotStressed": "Not stressed", | |
| "Smiled": "Smiling (heard in the voice)", "EyeContact": "Eye contact", "SpeakingRate": "Speaking pace"}, | |
| "ar": {"Overall": "الانطباع العام", "RecommendHiring": "التوصية بالتعيين", "Excited": "الحماس", | |
| "EngagingTone": "نبرة جذابة", "Friendly": "الود", "NoFillers": "قلة كلمات الحشو", | |
| "StructuredAnswers": "تنظيم الإجابات", "Calm": "الهدوء", "Focused": "التركيز", | |
| "Engaged": "التفاعل", "Paused": "حسن استخدام التوقف", "NotAwkward": "الأريحية", | |
| "Colleague": "زميل عمل جيد", "Authentic": "المصداقية", "NotStressed": "عدم التوتر", | |
| "Smiled": "الابتسام (من نبرة الصوت)", "EyeContact": "التواصل البصري", "SpeakingRate": "سرعة الكلام"}, | |
| } | |
| _bundle = None | |
| def _load(): | |
| global _bundle | |
| if _bundle is None and os.path.exists(MODEL_PATH): | |
| _bundle = joblib.load(MODEL_PATH) | |
| return _bundle | |
| def available() -> bool: | |
| return _load() is not None | |
| def predict(features: Dict[str, float], lang: str = "en") -> Optional[Dict]: | |
| """Predict human-panel ratings (1-7 scale) and place them against the 138 reference interviews.""" | |
| b = _load() | |
| if b is None: | |
| return None | |
| from math import erf, sqrt | |
| x = np.array([[features.get(c, np.nan) for c in b["feature_names"]]], dtype=float) | |
| if "feature_bounds" in b: # keep inputs inside the range seen in training (no wild extrapolation) | |
| lo, hi = np.array(b["feature_bounds"][0]), np.array(b["feature_bounds"][1]) | |
| x = np.where(np.isnan(x), x, np.clip(x, lo, hi)) | |
| labels = TRAIT_LABELS.get(lang, TRAIT_LABELS["en"]) | |
| traits = [] | |
| for name, m in b["models"].items(): | |
| pred = float(np.clip(m["model"].predict(x)[0], 1, 7)) | |
| z = (pred - m["ref_mean"]) / (m["ref_std"] + 1e-9) | |
| pct = 50 * (1 + erf(z / sqrt(2))) | |
| traits.append({"trait": name, "label": labels.get(name, name), "score_1_7": round(pred, 2), | |
| "percentile": int(round(pct)), "model_r": round(m["cv_r"], 2), | |
| "human_r": round(m.get("human_r", float("nan")), 2)}) | |
| order = b.get("display_order", [t["trait"] for t in traits]) | |
| traits.sort(key=lambda t: order.index(t["trait"]) if t["trait"] in order else 99) | |
| return {"traits": traits, "reference": b["reference"], "version": b["version"]} | |
| def model_card(lang: str = "en") -> Optional[Dict]: | |
| """Validation results of the shipped models, for the public 'science' section.""" | |
| b = _load() | |
| if b is None: | |
| return None | |
| labels = TRAIT_LABELS.get(lang, TRAIT_LABELS["en"]) | |
| order = b.get("display_order", list(b["models"])) | |
| traits = sorted(b["models"].items(), key=lambda kv: order.index(kv[0]) if kv[0] in order else 99) | |
| return {"reference": b["reference"], "version": b["version"], | |
| "traits": [{"trait": k, "label": labels.get(k, k), "model_r": round(m["cv_r"], 2), | |
| "human_r": round(m.get("human_r", 0), 2)} for k, m in traits]} | |