Diagnostics, Residuals, and Model Error: How to Find Where Models Fail

Last Updated June 13, 2026

Diagnostics, residuals, and model error show how a mathematical model fails, where it fails, and whether those failures matter for interpretation or decision-making. Residuals measure the difference between observed values and model outputs, but they are more than leftover noise.

Residuals reveal bias, missed structure, changing variance, autocorrelation, outliers, subgroup errors, boundary problems, and model-form limitations. A model with a low average error can still fail systematically in the exact region where a decision matters most. A model can appear accurate overall while performing poorly for particular periods, places, populations, thresholds, or stress conditions.

Model diagnostics are therefore part of responsible modeling practice. They help analysts move beyond the question “How large is the error?” toward better questions: where is the error, what pattern does it show, what assumption might be wrong, and how should model users interpret the result?

Responsible diagnostic work does not treat error as an embarrassment to hide. Error is evidence. It tells the analyst where the model is incomplete, where the data may be misaligned, where assumptions may be too strong, and where outputs should be communicated with caution.

Why Diagnostics Matter

Diagnostics matter because model error is not evenly distributed, equally important, or automatically harmless. A model can have a good summary score while failing in a pattern that reveals a missing mechanism, an inappropriate assumption, a poor data transformation, an unmodeled subgroup, or a serious decision risk.

Model diagnostics help analysts understand whether error behaves like random noise or like structured evidence of model failure. This distinction is essential for validation, model comparison, generalization, uncertainty communication, and decision support.

Diagnostics transform error from a single number into an interpretive map of where the model should be trusted, revised, constrained, or communicated with caution.

Back to top ↑

What Residuals Are

A residual is the difference between an observed value and the corresponding model output. Residuals are often written as observed minus predicted, though sign conventions should always be stated clearly.

Residuals are not only a technical byproduct. They are diagnostic evidence. They show whether model errors are small or large, positive or negative, random or patterned, stable or changing, localized or widespread.

A residual plot can sometimes reveal more than a single performance metric. It can show the shape of model failure.

Back to top ↑

Model Error Is Evidence, Not Just Noise

Model error is often treated as leftover noise after the “real” model has done its work. That view is too narrow. Error can represent measurement noise, random variability, missing variables, wrong functional form, poor calibration, structural uncertainty, or changing system conditions.

Diagnostic interpretation asks what kind of error is being observed. Random error has different implications from systematic error. Measurement error has different implications from model-form error. Decision-relevant error has different implications from harmless mismatch.

Error should be interpreted against purpose. The same residual pattern may be acceptable for teaching but unacceptable for forecasting, control, public safety, or policy decisions.

Back to top ↑

Error Metrics and Their Limits

Error metrics summarize model performance. They are useful, but they compress many kinds of model failure into a small number of values. A single metric rarely tells the whole diagnostic story.

Mean absolute error, root mean squared error, mean bias, maximum absolute error, median absolute error, and percentage errors each emphasize different features of model-data mismatch.

Metrics should be paired with plots, subgroup summaries, residual patterns, uncertainty intervals, and decision-specific diagnostics. A low RMSE is not enough if the model fails near the action threshold.

Back to top ↑

Residual Patterns and Model Misspecification

Residual patterns often reveal model misspecification. If residuals show structure, the model may be missing a relationship, using the wrong functional form, omitting a variable, ignoring a lag, aggregating too coarsely, or applying an assumption outside its valid range.

Residuals should ideally be interpreted in context. A curve, fan shape, drift, cluster, or repeated sign sequence may all point to different modeling issues.

Residual patterns do not automatically prescribe one fix. They guide investigation. The right response depends on purpose, evidence, model family, uncertainty, and cost of error.

Back to top ↑

Bias and Systematic Error

Bias occurs when model error tends to lean in one direction. A model may consistently overpredict demand, underpredict risk, overestimate stock, underestimate disease spread, or miss extreme load.

Bias is especially important because errors can cancel in aggregate. A model may show a small average absolute error while still being directionally wrong for a meaningful subset of cases.

Bias should be documented, not smoothed away. If bias matters for the decision, the model may need revision, recalibration, alternative structure, or a narrower use limit.

Back to top ↑

Changing Variance, Scale Effects, and Heteroscedasticity

Heteroscedasticity means that error variance changes across the range of predictions, inputs, or conditions. In simple terms, the model is more uncertain in some regions than others.

Changing variance is common in real systems. Larger systems often have larger absolute errors. Extreme values may be harder to predict. Low-count systems may have different error behavior than high-volume systems. Diagnostics should reveal these differences rather than treating all residuals as equally distributed.

Changing variance matters because uncertainty communication should not imply equal confidence everywhere. A model may be reliable in the center of the evidence range and weak at the edges.

Back to top ↑

Temporal Dependence and Autocorrelation

Autocorrelation occurs when residuals are correlated across time. If positive residuals tend to follow positive residuals, or negative residuals tend to follow negative residuals, the model may be missing temporal structure.

Temporal dependence can indicate omitted lags, delayed feedback, seasonality, trend, regime change, smoothing, or persistence. It is especially important in forecasting, system dynamics, epidemiology, economics, infrastructure, ecology, and policy models.

Temporal diagnostics are crucial when models are used for future-facing decisions. A model that fits historical averages but misses time dependence can produce misleading forecasts.

Back to top ↑

Outliers, Extremes, and Tail Error

Outliers are observations with unusually large residuals. They may reflect data errors, rare events, unmodeled regimes, measurement anomalies, or genuinely important system behavior.

Outliers should not automatically be removed. In many decision contexts, extreme cases are exactly where the model matters most. Public safety, finance, climate risk, infrastructure, health, and ecological systems often require attention to tails, not only averages.

Extreme residuals are not merely inconvenient. They may be the most informative cases in the diagnostic record.

Back to top ↑

Subgroup, Spatial, and Context-Specific Diagnostics

Overall error metrics can hide uneven model performance. A model may work well on average while failing for certain subgroups, locations, time periods, system states, or scenarios.

Context-specific diagnostics are especially important when models inform institutional decisions. If a model performs unevenly across groups or places, the average metric may not represent the experience of those most affected by model error.

Diagnostic slicing should be done carefully, but it should not be avoided. A model that is only accurate for the average case may be insufficient for real decisions.

Back to top ↑

Uncertainty, Structural Error, and Model-Form Limits

Diagnostics help separate ordinary uncertainty from deeper structural error. Ordinary uncertainty may be represented with intervals, distributions, or stochastic variation. Structural error arises when the model form itself is incomplete, inappropriate, or unstable under the intended use.

Residuals can point toward structural error when they show systematic patterns that cannot be explained by measurement noise or random variability. In those cases, improving parameter estimates may not be enough. The model structure may need revision.

When structural error is present, the responsible response is not simply to report a wider uncertainty band. The model’s assumptions, boundaries, mechanisms, or purpose may need to be reconsidered.

Back to top ↑

Mathematical Lens: Residuals, Error, and Diagnostic Evidence

The basic residual compares an observation with a model output:

Mean error summarizes directional bias:

Mean absolute error summarizes average absolute mismatch:

Root mean squared error emphasizes larger errors:

A diagnostic assessment can be represented as a function of residuals, context, uncertainty, and purpose:

This mathematical lens shows why error metrics are not enough by themselves. Residual meaning depends on where the error occurs and what the model is being used to support.

Back to top ↑

Example: Diagnosing a Resource Forecasting Model

Consider a model that forecasts resource stock under extraction. The model has been calibrated and validated. Its overall error appears acceptable. Diagnostic review now asks where the model fails and whether those failures matter.

The diagnostic conclusion may be that the model is useful for broad scenario comparison but not reliable enough for precise threshold-based control. That is not a failure of diagnostics. It is exactly what diagnostics are supposed to reveal.

Back to top ↑

Diagnostics for Decision Support

Decision support changes the meaning of error. A small error can matter if it occurs near an action threshold. A large error may matter less if it does not change the decision. Diagnostics should therefore be tied to the decision context.

A diagnostic report should not simply say whether the model is accurate. It should say whether the model’s error profile is acceptable for the decision being considered.

Back to top ↑

Ethical Stakes of Model Error

Model error has ethical stakes because error is not always evenly distributed or honestly communicated. If diagnostic weaknesses are hidden, users may trust model outputs beyond the evidence. If subgroup error is ignored, the model may support decisions that are less reliable for some people, places, or conditions.

Ethical diagnostic practice makes model error visible. It reports not only aggregate performance but also failure patterns, uncertainty, assumptions, limitations, and decision-relevant risk.

Diagnostics are part of accountability. They show whether model users are being given the evidence they need to interpret outputs responsibly.

Back to top ↑

Python Workflow: Residual Diagnostics and Error Review

The Python workflow below computes residuals, error metrics, threshold diagnostics, group-level diagnostics, outlier flags, and a diagnostic assessment card. It is dependency-light and designed for reproducible article companion code.

# diagnostics_residuals_model_error_workflow.py
# Dependency-light workflow for residual diagnostics and model error review.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import math
import statistics


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
OUTPUTS = ARTICLE_ROOT / "outputs"
TABLES = OUTPUTS / "tables"
JSON_DIR = OUTPUTS / "json"


@dataclass(frozen=True)
class DiagnosticObservation:
    time: int
    group: str
    observed_value: float
    predicted_value: float
    decision_threshold: float


@dataclass(frozen=True)
class DiagnosticRecord:
    key: str
    diagnostic_layer: str
    modeling_role: str
    review_question: str
    status: str


def observations() -> list[DiagnosticObservation]:
    return [
        DiagnosticObservation(1, "baseline", 82.0, 81.5, 70.0),
        DiagnosticObservation(2, "baseline", 79.5, 80.2, 70.0),
        DiagnosticObservation(3, "baseline", 77.0, 78.4, 70.0),
        DiagnosticObservation(4, "baseline", 74.3, 75.6, 70.0),
        DiagnosticObservation(5, "threshold", 71.5, 72.8, 70.0),
        DiagnosticObservation(6, "threshold", 69.2, 71.0, 70.0),
        DiagnosticObservation(7, "threshold", 67.8, 69.8, 70.0),
        DiagnosticObservation(8, "stress", 65.5, 68.0, 70.0),
        DiagnosticObservation(9, "stress", 63.0, 66.4, 70.0),
        DiagnosticObservation(10, "stress", 61.1, 65.2, 70.0),
    ]


def diagnostic_register() -> list[DiagnosticRecord]:
    return [
        DiagnosticRecord(
            key="residual_bias",
            diagnostic_layer="bias",
            modeling_role="Reviews directional error across observations.",
            review_question="Does the model systematically overpredict or underpredict?",
            status="active",
        ),
        DiagnosticRecord(
            key="threshold_error",
            diagnostic_layer="decision_support",
            modeling_role="Reviews residuals near action thresholds.",
            review_question="Could residual error change the decision?",
            status="review",
        ),
        DiagnosticRecord(
            key="group_error",
            diagnostic_layer="subgroup",
            modeling_role="Compares error across diagnostic groups.",
            review_question="Does performance differ across contexts?",
            status="review",
        ),
        DiagnosticRecord(
            key="outlier_review",
            diagnostic_layer="tail_error",
            modeling_role="Flags unusually large residuals.",
            review_question="Do extreme residuals reveal data or model-form problems?",
            status="review",
        ),
        DiagnosticRecord(
            key="structural_error",
            diagnostic_layer="model_form",
            modeling_role="Reviews whether residual patterns suggest missing structure.",
            review_question="Is error random or structurally patterned?",
            status="review",
        ),
    ]


def residual_rows(data: list[DiagnosticObservation]) -> list[dict[str, object]]:
    rows = []
    for item in data:
        residual = item.observed_value - item.predicted_value
        near_threshold = abs(item.observed_value - item.decision_threshold) <= 3.0
        decision_disagreement = (
            item.observed_value < item.decision_threshold
        ) != (
            item.predicted_value < item.decision_threshold
        )
        rows.append({
            **asdict(item),
            "residual": round(residual, 8),
            "absolute_error": round(abs(residual), 8),
            "squared_error": round(residual * residual, 8),
            "near_threshold": near_threshold,
            "decision_disagreement": decision_disagreement,
        })
    return rows


def error_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    residuals = [float(row["residual"]) for row in rows]
    abs_errors = [float(row["absolute_error"]) for row in rows]
    sq_errors = [float(row["squared_error"]) for row in rows]

    return {
        "mean_error": round(statistics.mean(residuals), 8),
        "mae": round(sum(abs_errors) / len(abs_errors), 8),
        "rmse": round(math.sqrt(sum(sq_errors) / len(sq_errors)), 8),
        "median_absolute_error": round(statistics.median(abs_errors), 8),
        "max_absolute_error": round(max(abs_errors), 8),
        "n": len(rows),
    }


def group_summary(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    grouped: dict[str, list[dict[str, object]]] = {}
    for row in rows:
        grouped.setdefault(str(row["group"]), []).append(row)

    output = []
    for group, values in sorted(grouped.items()):
        summary = error_summary(values)
        output.append({"group": group, **summary})
    return output


def flag_outliers(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    abs_errors = [float(row["absolute_error"]) for row in rows]
    median_error = statistics.median(abs_errors)
    threshold = max(2.5, 2.0 * median_error)

    flagged = []
    for row in rows:
        if float(row["absolute_error"]) >= threshold:
            flagged.append({**row, "outlier_threshold": round(threshold, 8)})
    return flagged


def diagnostic_risk_score(record: DiagnosticRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.diagnostic_layer} {record.modeling_role} {record.review_question}".lower()
    for term in ["bias", "threshold", "group", "outlier", "structural", "decision"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows supplied for {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    data = observations()
    records = diagnostic_register()
    rows = residual_rows(data)
    overall = error_summary(rows)
    by_group = group_summary(rows)
    outliers = flag_outliers(rows)

    register_rows = [
        {**asdict(record), "diagnostic_risk_score": diagnostic_risk_score(record)}
        for record in records
    ]

    threshold_rows = [row for row in rows if bool(row["near_threshold"])]

    write_csv(TABLES / "diagnostic_observations.csv", [asdict(item) for item in data])
    write_csv(TABLES / "residual_diagnostics.csv", rows)
    write_csv(TABLES / "diagnostic_group_summary.csv", by_group)
    write_csv(TABLES / "diagnostic_register.csv", register_rows)

    if outliers:
        write_csv(TABLES / "diagnostic_outlier_flags.csv", outliers)

    write_json(JSON_DIR / "diagnostic_assessment_card.json", {
        "article": "Diagnostics, Residuals, and Model Error",
        "overall_error_summary": overall,
        "group_summary": by_group,
        "threshold_case_count": len(threshold_rows),
        "decision_disagreement_count": sum(1 for row in rows if bool(row["decision_disagreement"])),
        "outlier_count": len(outliers),
        "diagnostic_register": register_rows,
        "use_limit": "Diagnostic evidence is purpose-specific and should be interpreted against model scope, uncertainty, and decision consequences.",
        "diagnostic_checks": [
            "residuals are preserved",
            "bias metrics are reported",
            "group summaries are exported",
            "threshold cases are identified",
            "outliers are flagged",
            "model-form review remains required when residuals show structure",
        ],
    })

    print("Residual diagnostic workflow complete.")
    print(f"Overall error summary: {overall}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats residuals as diagnostic evidence. It preserves residual rows, error summaries, group-level diagnostics, threshold cases, outlier flags, and a diagnostic assessment card.

Back to top ↑

R Workflow: Diagnostic Plots and Error Summaries

The R workflow below reviews generated residual diagnostics, writes additional summaries, and creates base R plots for residuals over time and residuals by group.

# diagnostics_residuals_model_error_review.R
# Base R workflow for residual diagnostics and model error review.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

residual_path <- file.path(tables_dir, "residual_diagnostics.csv")
register_path <- file.path(tables_dir, "diagnostic_register.csv")

if (!file.exists(residual_path) || !file.exists(register_path)) {
  stop("Missing diagnostic outputs. Run the Python workflow first.")
}

residuals <- read.csv(residual_path, stringsAsFactors = FALSE)
register <- read.csv(register_path, stringsAsFactors = FALSE)

residuals$residual <- as.numeric(residuals$residual)
residuals$absolute_error <- as.numeric(residuals$absolute_error)
residuals$time <- as.integer(residuals$time)

overall_review <- data.frame(
  mean_error = mean(residuals$residual),
  mae = mean(residuals$absolute_error),
  rmse = sqrt(mean(residuals$residual ^ 2)),
  median_absolute_error = median(residuals$absolute_error),
  max_absolute_error = max(residuals$absolute_error),
  n = nrow(residuals)
)

group_review <- aggregate(
  cbind(residual, absolute_error) ~ group,
  data = residuals,
  FUN = mean
)

names(group_review) <- c("group", "mean_residual", "mean_absolute_error")

register$priority <- ifelse(
  register$diagnostic_risk_score >= 8,
  "high",
  ifelse(register$diagnostic_risk_score >= 6, "medium", "low")
)

write.csv(
  overall_review,
  file.path(tables_dir, "r_overall_diagnostic_review.csv"),
  row.names = FALSE
)

write.csv(
  group_review,
  file.path(tables_dir, "r_group_diagnostic_review.csv"),
  row.names = FALSE
)

write.csv(
  register,
  file.path(tables_dir, "r_diagnostic_review_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_residuals_over_time.png"), width = 1000, height = 700)

plot(
  residuals$time,
  residuals$residual,
  type = "b",
  xlab = "Time",
  ylab = "Residual",
  main = "Residuals Over Time"
)
abline(h = 0, lty = 2)
grid()

dev.off()

png(file.path(figures_dir, "r_absolute_error_by_group.png"), width = 1000, height = 700)

barplot(
  group_review$mean_absolute_error,
  names.arg = group_review$group,
  las = 2,
  ylab = "Mean absolute error",
  main = "Mean Absolute Error by Diagnostic Group"
)

dev.off()

print(overall_review)
print(group_review)
print(register)

The R layer supports diagnostic review by preserving overall metrics, group summaries, review priorities, and simple visual checks of residual structure.

Back to top ↑

Haskell Workflow: Typed Diagnostic Records

Haskell is useful here because diagnostic concepts should remain distinct. Bias is not the same as tail error. Threshold error is not the same as average error. Structural error is not the same as random noise.

{-# OPTIONS_GHC -Wall #-}

module Main where

data DiagnosticLayer
  = Bias
  | DecisionThreshold
  | SubgroupError
  | TailError
  | ModelForm
  | UncertaintyReview
  | Governance
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresValidation
  | RequiresUncertaintyCheck
  | Revise
  deriving (Eq, Show)

data DiagnosticRecord = DiagnosticRecord
  { key :: String
  , layer :: DiagnosticLayer
  , modelingRole :: String
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

diagnosticRegister :: [DiagnosticRecord]
diagnosticRegister =
  [ DiagnosticRecord
      "residual_bias"
      Bias
      "Reviews directional error across observations."
      "Systematic overprediction or underprediction."
      Active
  , DiagnosticRecord
      "threshold_error"
      DecisionThreshold
      "Reviews residuals near action thresholds."
      "Decision-changing error."
      RequiresValidation
  , DiagnosticRecord
      "group_error"
      SubgroupError
      "Compares error across diagnostic groups."
      "Uneven model reliability."
      RequiresReview
  , DiagnosticRecord
      "outlier_review"
      TailError
      "Flags unusually large residuals."
      "Tail behavior and extreme cases."
      RequiresReview
  , DiagnosticRecord
      "structural_error"
      ModelForm
      "Reviews whether residual patterns suggest missing structure."
      "Model-form limitations."
      RequiresReview
  , DiagnosticRecord
      "uncertainty_review"
      UncertaintyReview
      "Connects diagnostic evidence to uncertainty communication."
      "Uncertainty adequacy."
      RequiresUncertaintyCheck
  ]

needsReview :: DiagnosticRecord -> Bool
needsReview item =
  case status item of
    Active -> False
    _ -> True

main :: IO ()
main = do
  putStrLn "Typed diagnostic records:"
  mapM_ print diagnosticRegister

  putStrLn "\nDiagnostic records requiring review:"
  mapM_ print (filter needsReview diagnosticRegister)

This typed layer supports diagnostic governance by keeping bias, threshold error, subgroup error, tail error, model-form error, uncertainty, and governance review conceptually separate.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for residual diagnostics, error metrics, bias review, group-level diagnostics, threshold error, outlier flags, typed Haskell diagnostic records, uncertainty notes, and responsible decision-support workflows.

Back to top ↑

A Practical Method for Diagnostic Assessment

Diagnostic assessment should be systematic. The goal is not only to calculate error, but to interpret model failure in relation to purpose, evidence, uncertainty, and decision consequences.

This method turns diagnostics into an evidence trail. It helps future users understand not only how well the model performed, but how it failed.

Back to top ↑

Common Pitfalls

Diagnostic work can become superficial when analysts reduce model quality to one metric or treat residuals as disposable.

• Reporting one metric only: hiding residual patterns behind a single average error score.
• Ignoring residual plots: missing curvature, drift, clustering, or changing variance.
• Letting bias cancel: allowing positive and negative errors to hide systematic failure.
• Ignoring threshold error: missing the region where the model affects action.
• Discarding outliers too quickly: removing rare but important cases without investigation.
• Ignoring subgroup performance: assuming average accuracy applies everywhere.
• Confusing measurement error with model error: failing to distinguish data problems from model-form problems.
• Ignoring temporal dependence: treating time-linked residuals as independent noise.
• Over-widening uncertainty bands: using uncertainty to hide structural model failure.
• No diagnostic record: leaving future users unable to see how the model was assessed.

These pitfalls can be reduced through residual tables, multiple metrics, diagnostic plots, subgroup review, threshold analysis, outlier audit, uncertainty review, and clear use-limit statements.

Back to top ↑

Conclusion: Error Is Part of the Model’s Evidence

Diagnostics, residuals, and model error are central to mathematical modeling because they show where model claims are strong, weak, incomplete, or misleading. Error is not simply what remains after the model has succeeded. It is evidence about the model’s structure, assumptions, data, uncertainty, and use limits.

Residuals reveal whether a model is biased, misspecified, fragile, uneven, or weak near decision thresholds. Error metrics summarize performance, but diagnostic interpretation gives those metrics meaning.

Responsible diagnostic assessment asks where error occurs, what pattern it shows, what it implies about the model, and whether it matters for the intended purpose. A model does not become credible by hiding error. It becomes more accountable when its errors are examined carefully.

Used well, diagnostics help analysts improve models, communicate uncertainty, avoid false confidence, and support responsible decisions. Model error is not the end of modeling. It is one of modeling’s most important sources of evidence.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Calibration, Estimation, and Parameter Fitting
• Validation and Model Assessment
• Model Comparison and Selection
• Overfitting, Underfitting, and Model Generalization
• Sensitivity Analysis and Robustness
• Uncertainty in Mathematical Models
• Structural Uncertainty and Model Form Error
• Model Interpretation and Decision-Making
• Model Repositories, Data, and Reproducible Research

Back to top ↑

Further Reading

• Box, G.E.P., Hunter, J.S. and Hunter, W.G. (2005) Statistics for Experimenters: Design, Innovation, and Discovery. 2nd edn. Hoboken, NJ: Wiley.
• Davison, A.C. (2003) Statistical Models. Cambridge: Cambridge University Press.
• Draper, N.R. and Smith, H. (1998) Applied Regression Analysis. 3rd edn. New York: Wiley.
• Faraway, J.J. (2014) Linear Models with R. 2nd edn. Boca Raton, FL: CRC Press.
• Gelman, A. and Hill, J. (2007) Data Analysis Using Regression and Multilevel/Hierarchical Models. Cambridge: Cambridge University Press.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning. 2nd edn. New York: Springer.
• Montgomery, D.C., Peck, E.A. and Vining, G.G. (2012) Introduction to Linear Regression Analysis. 5th edn. Hoboken, NJ: Wiley.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Wickham, H. and Grolemund, G. (2017) R for Data Science. Sebastopol, CA: O’Reilly Media.

Back to top ↑

References

• Box, G.E.P., Hunter, J.S. and Hunter, W.G. (2005) Statistics for Experimenters: Design, Innovation, and Discovery. 2nd edn. Hoboken, NJ: Wiley.
• Davison, A.C. (2003) Statistical Models. Cambridge: Cambridge University Press.
• Draper, N.R. and Smith, H. (1998) Applied Regression Analysis. 3rd edn. New York: Wiley.
• Faraway, J.J. (2014) Linear Models with R. 2nd edn. Boca Raton, FL: CRC Press.
• Gelman, A. and Hill, J. (2007) Data Analysis Using Regression and Multilevel/Hierarchical Models. Cambridge: Cambridge University Press.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning. 2nd edn. New York: Springer.
• Montgomery, D.C., Peck, E.A. and Vining, G.G. (2012) Introduction to Linear Regression Analysis. 5th edn. Hoboken, NJ: Wiley.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Wickham, H. and Grolemund, G. (2017) R for Data Science. Sebastopol, CA: O’Reilly Media.

Back to top ↑