Model Evaluation and Quality Assessment Questions

Covers evaluation methods, metrics, and quality assessment approaches for machine learning models including both predictive models and generative models. Topics include selecting appropriate metrics such as accuracy, precision, recall, F one score, area under curve for ranking, root mean square error and mean absolute percentage error for regression, and the rationale for using multiple metrics and baselines. For generative and large language models, covers automatic metrics such as BLEU, ROUGE, METEOR, semantic similarity scores, LLM based evaluation techniques, human evaluation frameworks, factuality and hallucination checking, adversarial and stress testing, error analysis, and designing scalable, cost effective evaluation pipelines and quality assurance processes.

EasyTechnical

78 practiced

Implement precision, recall, and F1 in Python without external libraries. Signature: def precision_recall_f1(y_true, y_pred): -> (precision, recall, f1). Both inputs are iterables of 0/1. The implementation should run in O(n) time and handle edge cases like zero positive predictions.

Sample Answer

Approach: iterate once over y_true and y_pred in parallel, count true positives (TP), false positives (FP), and false negatives (FN). Compute precision = TP / (TP+FP) if denominator > 0 else 0.0. Recall = TP / (TP+FN) if denom > 0 else 0.0. F1 = 2 * precision * recall / (precision + recall) if (precision+recall) > 0 else 0.0. This is O(n) time and O(1) extra space.

python

def precision_recall_f1(y_true, y_pred):
    """
    Compute precision, recall, and F1 for binary labels (0/1) without external libs.
    Returns (precision, recall, f1) as floats.
    """
    # Allow arbitrary iterables; iterate once
    it_true = iter(y_true)
    it_pred = iter(y_pred)

    tp = fp = fn = 0
    length = 0
    while True:
        try:
            t = next(it_true)
            p = next(it_pred)
        except StopIteration:
            # Ensure both iterables had the same length
            try:
                next(it_true)
                raise ValueError("y_true and y_pred have different lengths")
            except StopIteration:
                try:
                    next(it_pred)
                    raise ValueError("y_true and y_pred have different lengths")
                except StopIteration:
                    break
        length += 1
        if p not in (0, 1) or t not in (0, 1):
            raise ValueError("Labels must be 0 or 1")
        if p == 1 and t == 1:
            tp += 1
        elif p == 1 and t == 0:
            fp += 1
        elif p == 0 and t == 1:
            fn += 1

    # Edge cases handled by returning 0.0 when denominator is zero
    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
    f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0

    return precision, recall, f1

Key points:- Single pass over data: O(n) time, O(1) extra space.- Handles zero positive predictions (precision defined as 0.0) and zero true positives (F1 = 0.0).- Validates equal lengths and binary labels.- Example: y_true=[1,0,1], y_pred=[1,1,0] -> TP=1, FP=1, FN=1 -> precision=0.5, recall=0.5, f1=0.5.

HardTechnical

67 practiced

Describe how metric gaming (Goodhart's law) happens when teams optimize proxies instead of true business objectives. Propose an evaluation regime to detect and mitigate gaming including adversarial holdout sets, randomized audits, long-term business metrics, cross-team guardrails, and continuous monitoring for suspicious improvements that don't correlate with business outcomes.

Sample Answer

When teams optimize proxies (e.g., click-through rate, predicted relevance score) instead of the true objective (e.g., lifetime value, user retention), Goodhart’s law kicks in: the proxy ceases to be informative because models and people learn to exploit quirks of the proxy rather than driving real value. In AI systems this appears as reward-hacking (models generating superficially high-scoring outputs), dataset-specialization, or surface-level UI changes that boost metrics but harm retention.

Evaluation regime to detect & mitigate gaming:

1. Define hierarchical objectives- Primary business KPIs: retention, LTV, revenue per user, safety incidents.- Secondary proxies: CTR, predicted relevance — explicitly tagged as proxies.

2. Adversarial holdout sets- Maintain holdout sets crafted adversarially (edge cases, manipulated inputs, distribution shifts).- Periodically evaluate new models on these sets to reveal brittle optimizations.

3. Randomized audits- Run randomized, blind human audits across outputs (A/B tests with hidden evaluation teams).- Include synthetic adversarial prompts designed to reveal overfitting to proxies.

4. Long-term business metrics & cohort analysis- Measure downstream outcomes (30/90-day retention, churn, refund rates) per experiment cohort.- Use uplift modeling to attribute long-term impact vs short-term proxy gains.

5. Cross-team guardrails & incentives- Align incentives: tie engineering/product goals partly to long-term KPIs.- Require evaluation checklists and sign-offs from analytics, trust/safety, and business stakeholders.

6. Continuous monitoring and anomaly detection- Instrument metric correlations: monitor cases where proxy improves but business KPIs stagnate or decline.- Build automated detectors for suspicious patterns (sudden localized improvements, distributional changes, surge in edge-case failures) and trigger rollback/hold.- Use feature-importance drift, calibration checks, and distributional tests (KS, population stability index).

7. Investigations & remediation workflow- On anomaly: run forensic tests (batch vs online, example-level inspection, adversarial inputs), freeze rollout if confirmed, and deploy fixes (regularization, adversarial training, reward reshaping, or revised proxy).

Example: A reranker increases CTR by 15% but cohort retention drops. Investigation reveals click-bait snippets; mitigation included adding a downstream retention objective to training, adversarial holdout of click-bait examples, and human audits—restoring aligned improvements.

This regime blends offline adversarial tests, randomized human checks, long-horizon measurement, organizational incentives, and continuous automated monitoring to detect and reduce metric gaming.

EasyTechnical

94 practiced

Describe the BLEU metric for machine translation: how n-gram precision and the brevity penalty are combined. Explain major limitations of BLEU when evaluating open-ended LLM outputs such as summarization or dialog, and suggest alternative or complementary automatic metrics and why human evaluation is still required.

MediumTechnical

66 practiced

List and compare automated approaches to detect hallucinations in LLM outputs: QA-based factuality checks, NLI entailment-based detectors, knowledge-base grounding and citation matching, LLM-as-evaluator scoring, and retrieval-augmented verification. For each approach describe strengths, weaknesses, and how you would validate and calibrate it with human labels.

Sample Answer

Brief overview: below I list each automated approach, its strengths, weaknesses, and a practical plan to validate and calibrate it against human labels.

1) QA-based factuality checks- Strengths: Directly targets factual claims by converting claims to questions; scalable; interpretable (answers vs. references).- Weaknesses: Question formulation failures, sensitivity to answer-paraphrase, depends on the QA model and context window; may miss implicit claims.- Validation/calibration: Build a labeled set of claim→(human label: true/false/unsupported). Measure precision/recall of QA-derived verdicts (e.g., exact-match / F1 vs. ground truth). Tune question templates, confidence thresholds, and aggregation rules; calibrate score to human probability via Platt scaling or isotonic regression.

2) NLI entailment-based detectors- Strengths: Leverages entailment notion (entails/contradicts/neutral); compact pipelines for claim vs. evidence.- Weaknesses: NLI models trained on synthetic premises may not generalize; can be overconfident; struggles with multi-claim sentences and world knowledge.- Validation/calibration: Create premise-evidence pairs labeled by humans for entail/contradict/neutral. Compute confusion matrix, recalibrate logits to human labels, and combine sentence-level judgments into document-level via learned aggregation.

3) Knowledge-base grounding & citation matching- Strengths: High precision when KB coverage exists; provides provenance and structured verification.- Weaknesses: KB incompleteness/outdatedness, mapping natural language to KB queries is hard, limited to covered domains.- Validation/calibration: Annotate whether cited KB facts support claim. Evaluate recall of KB hits and precision of matches. Calibrate by weighting KB matches by match quality (entity/linking confidence) and human-derived reliability scores per KB source.

4) LLM-as-evaluator scoring- Strengths: Flexible, can reason about nuance and uncertainty; easy to deploy with few-shot prompts.- Weaknesses: Evaluator LLMs can hallucinate or mirror biases; vulnerability to prompt sensitivity and label leakage.- Validation/calibration: Use human-labeled dataset; measure correlation (Spearman/Kendall), accuracy, and calibration (reliability diagrams). Use cross-model ensembles and temperature tuning; constrain prompts with tool-verified evidence to reduce evaluator hallucination.

5) Retrieval-augmented verification (RAV)- Strengths: Combines retrieval of external evidence + model reasoning; good recall when retrieval works; balances flexibility and grounding.- Weaknesses: Retrieval failures (low recall), retrieval-model misalignment, latency/cost.- Validation/calibration: Human-labeled claim-evidence-support triples. Evaluate end-to-end precision/recall and separately: retrieval recall, verification classifier accuracy. Calibrate by improving retriever (hard negatives), adjusting rank thresholds, and using human labels to set decision thresholds for “supported/unsupported”.

Cross-cutting validation best practices:- Use stratified human datasets covering claim types, uncertainty levels, and domains.- Report precision at high recall and vice versa; construct ROC/PR curves and calibration plots.- Ensemble methods: combine multiple detectors (e.g., NLI + QA + KB) with a meta-classifier trained on human labels to exploit complementary strengths.- Continuous monitoring: collect human-in-the-loop feedback on low-confidence or high-impact outputs and re-calibrate periodically.

EasyTechnical

118 practiced

Explain precision, recall, and F1 score for binary classification. Provide mathematical definitions and formulas using true positives (TP), false positives (FP), false negatives (FN), and true negatives (TN). Give a short numeric example using a confusion matrix and explain in what scenarios F1 is preferred over accuracy, including brief notes on macro and micro F1 for multiclass.

Unlock Full Question Bank

Get access to hundreds of Model Evaluation and Quality Assessment interview questions and detailed answers.

Join thousands of developers preparing for their dream job.