diff --git a/README.md b/README.md index 1de16567..99932233 100644 --- a/README.md +++ b/README.md @@ -82,3 +82,4 @@ See this [step-by-step guide](https://huggingface.co/docs/evaluate/creating_and_ ## Credits Thanks to [@marella](https://github.com/marella) for letting us use the `evaluate` namespace on PyPi previously used by his [library](https://github.com/marella/evaluate). + diff --git a/data/human_ai_trust_demo.csv b/data/human_ai_trust_demo.csv new file mode 100644 index 00000000..e60111f1 --- /dev/null +++ b/data/human_ai_trust_demo.csv @@ -0,0 +1,121 @@ +prediction,reference,confidence,human_trust,belief_prior,belief_posterior,explanation_length +0,0,0.462,0.389,0.462,0.462,111 +1,1,0.746,0.768,0.695,0.721,57 +0,0,0.759,0.764,0.572,0.665,63 +0,0,0.99,0.925,0.368,0.679,64 +0,0,0.721,0.936,0.396,0.559,99 +1,1,0.795,0.859,0.199,0.497,72 +0,0,0.745,0.542,0.396,0.571,86 +0,0,0.575,0.593,0.342,0.458,104 +0,0,0.921,0.855,0.465,0.693,90 +0,1,0.69,0.775,0.235,0.462,98 +0,0,0.869,0.789,0.504,0.686,64 +0,0,0.614,0.602,0.707,0.66,86 +0,0,0.96,0.99,0.378,0.669,38 +0,0,0.54,0.626,0.48,0.51,107 +1,1,0.838,0.718,0.538,0.688,61 +1,0,0.792,0.759,0.32,0.556,60 +0,1,0.481,0.434,0.445,0.463,105 +0,1,0.532,0.467,0.403,0.467,95 +0,1,0.612,0.789,0.42,0.516,113 +0,0,0.674,0.715,0.245,0.46,97 +0,1,0.414,0.288,0.405,0.409,120 +0,0,0.76,0.852,0.5,0.63,93 +1,1,0.591,0.803,0.69,0.64,99 +1,1,0.821,0.924,0.592,0.706,62 +1,1,0.612,0.46,0.831,0.721,111 +1,1,0.982,0.934,0.247,0.615,57 +1,1,0.633,0.759,0.574,0.603,83 +1,1,0.702,0.631,0.437,0.569,83 +1,1,0.872,0.916,0.838,0.855,56 +1,1,0.565,0.643,0.238,0.402,88 +1,0,0.627,0.535,0.232,0.43,103 +0,0,0.946,0.94,0.28,0.613,75 +1,1,0.509,0.185,0.05,0.279,94 +1,1,0.778,0.675,0.295,0.536,82 +1,1,0.789,0.764,0.248,0.519,68 +0,0,0.867,0.742,0.43,0.649,61 +1,1,0.564,0.728,0.468,0.516,96 +1,0,0.442,0.299,0.775,0.608,108 +0,0,0.828,0.784,0.59,0.709,71 +0,0,0.795,0.808,0.285,0.54,66 +0,0,0.788,0.932,0.22,0.504,78 +0,0,0.802,0.658,0.498,0.65,73 +1,1,0.648,0.764,0.136,0.392,89 +1,1,0.785,0.786,0.766,0.776,66 +1,1,0.794,0.696,0.636,0.715,68 +0,1,0.514,0.56,0.306,0.41,115 +1,1,0.99,0.99,0.057,0.524,56 +0,0,0.821,0.761,0.671,0.746,61 +1,1,0.571,0.578,0.377,0.474,102 +0,1,0.679,0.64,0.648,0.663,96 +0,0,0.604,0.615,0.081,0.342,80 +1,1,0.868,0.934,0.28,0.574,71 +0,0,0.924,0.99,0.401,0.662,52 +1,1,0.627,0.503,0.409,0.518,100 +1,0,0.716,0.929,0.31,0.513,76 +0,1,0.65,0.454,0.525,0.587,74 +0,1,0.699,0.683,0.186,0.443,69 +0,0,0.99,0.99,0.372,0.681,51 +1,0,0.571,0.599,0.424,0.497,104 +0,0,0.637,0.575,0.503,0.57,84 +1,0,0.493,0.472,0.542,0.518,117 +0,0,0.628,0.578,0.175,0.401,78 +0,0,0.738,0.679,0.093,0.416,80 +0,0,0.801,0.886,0.656,0.728,61 +0,0,0.792,0.827,0.466,0.629,68 +0,1,0.699,0.63,0.25,0.475,86 +1,1,0.752,0.842,0.71,0.731,71 +0,0,0.968,0.99,0.423,0.696,49 +0,1,0.568,0.65,0.636,0.602,111 +1,1,0.99,0.99,0.414,0.702,45 +1,1,0.844,0.761,0.812,0.828,77 +1,1,0.621,0.565,0.751,0.686,84 +0,0,0.589,0.664,0.35,0.47,104 +0,1,0.658,0.719,0.594,0.626,105 +1,0,0.573,0.571,0.529,0.551,76 +1,1,0.857,0.869,0.674,0.765,59 +1,1,0.821,0.949,0.207,0.514,77 +0,1,0.591,0.532,0.537,0.564,97 +0,0,0.623,0.678,0.612,0.617,98 +1,1,0.523,0.503,0.05,0.286,101 +0,0,0.683,0.661,0.163,0.423,88 +1,1,0.878,0.988,0.05,0.464,63 +0,0,0.782,0.865,0.346,0.564,87 +0,1,0.451,0.532,0.544,0.497,118 +1,0,0.621,0.751,0.7,0.661,98 +1,0,0.646,0.648,0.415,0.531,88 +1,1,0.617,0.686,0.726,0.672,91 +0,0,0.773,0.742,0.124,0.449,72 +1,1,0.759,0.791,0.059,0.409,82 +1,1,0.579,0.566,0.389,0.484,96 +1,1,0.804,0.813,0.477,0.64,76 +1,1,0.834,0.894,0.393,0.614,90 +1,1,0.912,0.831,0.05,0.481,69 +1,1,0.908,0.99,0.382,0.645,57 +0,1,0.435,0.334,0.139,0.287,129 +1,1,0.609,0.488,0.534,0.572,92 +1,1,0.827,0.943,0.473,0.65,50 +1,1,0.827,0.906,0.212,0.52,60 +1,1,0.827,0.89,0.297,0.562,52 +0,0,0.99,0.99,0.188,0.589,47 +0,0,0.836,0.834,0.387,0.612,69 +1,1,0.92,0.831,0.591,0.756,76 +1,1,0.893,0.901,0.203,0.548,66 +0,1,0.678,0.61,0.501,0.589,86 +1,1,0.703,0.8,0.294,0.498,93 +1,1,0.864,0.849,0.241,0.553,44 +1,1,0.634,0.552,0.379,0.506,96 +1,1,0.714,0.682,0.193,0.454,91 +1,1,0.677,0.718,0.289,0.483,73 +0,0,0.762,0.706,0.16,0.461,89 +1,1,0.99,0.908,0.793,0.891,54 +0,0,0.47,0.494,0.407,0.438,109 +1,1,0.853,0.877,0.26,0.556,73 +0,1,0.406,0.356,0.443,0.425,143 +1,0,0.543,0.496,0.378,0.46,106 +0,1,0.731,0.754,0.356,0.543,84 +0,0,0.76,0.615,0.523,0.641,74 +0,1,0.471,0.33,0.552,0.511,105 +1,1,0.643,0.571,0.294,0.468,101 +1,0,0.682,0.66,0.285,0.483,79 diff --git a/data/validate.py b/data/validate.py new file mode 100644 index 00000000..154a6858 --- /dev/null +++ b/data/validate.py @@ -0,0 +1,19 @@ +import evaluate +import pandas as pd + +metric = evaluate.load("human_ai_trust") + +df = pd.read_csv("data/human_ai_trust_demo.csv") + +out = metric.compute( + predictions=df["prediction"].tolist(), + references=df["reference"].tolist(), + confidences=df["confidence"].tolist(), + human_trust_scores=df["human_trust"].tolist(), + belief_priors=df["belief_prior"].tolist(), + belief_posteriors=df["belief_posterior"].tolist(), + explanation_complexity=df["explanation_length"].tolist(), +) + +print(out) + diff --git a/examples/human_ai_trust_demo.ipynb b/examples/human_ai_trust_demo.ipynb new file mode 100644 index 00000000..800a752d --- /dev/null +++ b/examples/human_ai_trust_demo.ipynb @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "37c7a89a", + "metadata": {}, + "source": [ + "# Human Trust & Uncertainty Metrics — Demo\n", + "\n", + "This notebook demonstrates the `human_ai_trust` evaluation metric suite for human-centered AI evaluation.\n", + "\n", + "Unlike traditional metrics that focus solely on predictive accuracy, these metrics surface:\n", + "\n", + "- trust calibration \n", + "- belief updating \n", + "- uncertainty sensitivity \n", + "- asymmetric harm from overconfident errors \n", + "- explanation–confidence alignment \n", + "\n", + "The goal is to show how human–AI interaction quality can be evaluated computationally using theory-grounded metrics.\n", + "\n", + "---\n", + "\n", + "**Companion Dataset:** \n", + "`dyra-12/human_ai_trust_demo`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abf76e3e", + "metadata": {}, + "outputs": [], + "source": [ + "import evaluate\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5097debe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictionreferenceconfidencehuman_trustbelief_priorbelief_posteriorexplanation_length
0000.4620.3890.4620.462111
1110.7460.7680.6950.72157
2000.7590.7640.5720.66563
3000.9900.9250.3680.67964
4000.7210.9360.3960.55999
\n", + "
" + ], + "text/plain": [ + " prediction reference confidence human_trust belief_prior \\\n", + "0 0 0 0.462 0.389 0.462 \n", + "1 1 1 0.746 0.768 0.695 \n", + "2 0 0 0.759 0.764 0.572 \n", + "3 0 0 0.990 0.925 0.368 \n", + "4 0 0 0.721 0.936 0.396 \n", + "\n", + " belief_posterior explanation_length \n", + "0 0.462 111 \n", + "1 0.721 57 \n", + "2 0.665 63 \n", + "3 0.679 64 \n", + "4 0.559 99 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load demo dataset\n", + "from pathlib import Path\n", + "\n", + "# Prefer the local copy shipped with this repo to avoid auth/network issues.\n", + "url = \"https://huggingface.co/datasets/Dyra1204/human_ai_trust_demo/resolve/main/human_ai_trust_demo.csv\"\n", + "local_path = Path(\"..\") / \"data\" / \"human_ai_trust_demo.csv\"\n", + "\n", + "df = pd.read_csv(local_path if local_path.exists() else url)\n", + "\n", + "df.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9c166c5c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'expected_trust_error': 0.07086666797598203,\n", + " 'trust_sensitivity_index': 0.8666191489611619,\n", + " 'belief_shift_magnitude': 0.16639166666666666,\n", + " 'overconfidence_penalty': 0.1472083330154419,\n", + " 'overconfidence_penalty_normalized': 0.20490186898320353,\n", + " 'explanation_confidence_alignment': -0.863066801839177}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "# The metric isn't on the Hub; load it from the local repo checkout.\n", + "try:\n", + " metric = evaluate.load(\"human_ai_trust\")\n", + "except FileNotFoundError:\n", + " repo_root = Path.cwd()\n", + " while not (repo_root / \"metrics\").exists() and repo_root != repo_root.parent:\n", + " repo_root = repo_root.parent\n", + " metric = evaluate.load(str(repo_root / \"metrics\" / \"human_ai_trust\"))\n", + "\n", + "out = metric.compute(\n", + " predictions=df[\"prediction\"].tolist(),\n", + " references=df[\"reference\"].tolist(),\n", + " confidences=df[\"confidence\"].tolist(),\n", + " human_trust_scores=df[\"human_trust\"].tolist(),\n", + " belief_priors=df[\"belief_prior\"].tolist(),\n", + " belief_posteriors=df[\"belief_posterior\"].tolist(),\n", + " explanation_complexity=df[\"explanation_length\"].tolist(),\n", + ")\n", + "\n", + "out\n" + ] + }, + { + "cell_type": "markdown", + "id": "aa5965b7", + "metadata": {}, + "source": [ + "## Metric Outputs\n", + "\n", + "The metric suite produces the following values:\n", + "\n", + "- **Expected Trust Error (ETE):** \n", + " Misalignment between human trust and model confidence.\n", + "\n", + "- **Trust Sensitivity Index (TSI):** \n", + " Correlation between trust and confidence.\n", + "\n", + "- **Belief Shift Magnitude (BSM):** \n", + " Degree of belief updating after AI exposure.\n", + "\n", + "- **Overconfidence Penalty (OCP):** \n", + " Asymmetric harm from confident but wrong predictions.\n", + "\n", + "- **Explanation–Confidence Alignment (ECA):** \n", + " Coupling between explanation complexity and model confidence.\n", + "\n", + "These values surface human-centered failure modes that accuracy alone cannot detect.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0cb8d8da", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.scatter(df[\"confidence\"], df[\"human_trust\"], alpha=0.6)\n", + "plt.xlabel(\"Model Confidence\")\n", + "plt.ylabel(\"Human Trust\")\n", + "plt.title(\"Trust Calibration: Confidence vs Human Trust\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5ad2c538", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "belief_shift = df[\"belief_posterior\"] - df[\"belief_prior\"]\n", + "\n", + "plt.figure()\n", + "plt.hist(belief_shift, bins=20)\n", + "plt.xlabel(\"Belief Shift (Posterior - Prior)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Distribution of Belief Shifts After AI Exposure\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c493b9f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.scatter(df[\"confidence\"], df[\"explanation_length\"], alpha=0.6)\n", + "plt.xlabel(\"Model Confidence\")\n", + "plt.ylabel(\"Explanation Length\")\n", + "plt.title(\"Explanation–Confidence Alignment\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3306ecdf", + "metadata": {}, + "source": [ + "## Why Accuracy Alone Is Insufficient\n", + "\n", + "Accuracy treats all errors equally.\n", + "\n", + "However, in human–AI interaction:\n", + "\n", + "- A confident but wrong prediction is more damaging than a hesitant error \n", + "- Users may over-trust highly confident systems \n", + "- Users may ignore uncertainty signals \n", + "- Beliefs may shift even when the model is wrong \n", + "\n", + "The metrics demonstrated here surface:\n", + "\n", + "- misalignment between trust and uncertainty (ETE) \n", + "- insensitivity to uncertainty (low TSI) \n", + "- asymmetric harm from confident errors (OCP) \n", + "- belief influence (BSM) \n", + "- explanation–uncertainty coupling (ECA) \n", + "\n", + "These human-centered dimensions are invisible to accuracy alone.\n" + ] + }, + { + "cell_type": "markdown", + "id": "54e29fad", + "metadata": {}, + "source": [ + "## Cognitive Interpretation\n", + "\n", + "This dataset demonstrates a psychologically plausible interaction pattern:\n", + "\n", + "- Human trust tracks model confidence with noise \n", + "- Beliefs partially update toward AI outputs \n", + "- Explanations are longer when confidence is lower \n", + "\n", + "The resulting metrics show:\n", + "\n", + "- Low ETE → trust is well calibrated \n", + "- High TSI → users are uncertainty-sensitive \n", + "- Moderate BSM → partial belief updating \n", + "- Non-zero OCP → confident errors exist \n", + "- Strong negative ECA → explanations hedge under uncertainty \n", + "\n", + "This illustrates how cognitive and social dimensions of human–AI interaction can be formalized into computational evaluation metrics.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/metrics/human_ai_trust/README.md b/metrics/human_ai_trust/README.md new file mode 100644 index 00000000..506c5fe7 --- /dev/null +++ b/metrics/human_ai_trust/README.md @@ -0,0 +1,133 @@ +# Human Trust & Uncertainty Metrics + +This module provides a human-centered evaluation framework for AI systems that operationalizes: + +- trust calibration +- belief updating +- uncertainty alignment +- asymmetric harm from overconfident errors +- explanation–confidence coupling + +It complements traditional performance metrics by surfacing how users interpret, trust, and act on model outputs under uncertainty. + +**Trust calibration** refers to the alignment between a user's level of trust in an AI system and the system's actual reliability or confidence. Well-calibrated trust means users trust the AI appropriately—more when it's confident and correct, less when it's uncertain or error-prone. + +--- + +## Why These Metrics Exist + +Accuracy alone is insufficient for evaluating AI systems in high-stakes or vulnerable contexts. + +Human decision-makers experience AI failures asymmetrically: +a confident but wrong prediction is far more damaging than a hesitant error. + +Moreover, highly accurate systems can still cause harm if they: + +- induce over-reliance (automation bias) +- induce under-reliance (algorithmic aversion) +- miscommunicate uncertainty +- distort user beliefs + +This metric suite provides theory-grounded, computational signals for evaluating these human-centered failure modes. + +--- + +## Metrics Included + +| Metric | What It Measures | +|--------|------------------| +| Expected Trust Error (ETE) | Misalignment between human trust and model confidence | +| Trust Sensitivity Index (TSI) | Responsiveness of trust to uncertainty signals | +| Belief Shift Magnitude (BSM) | Degree of belief updating after AI exposure | +| Overconfidence Penalty (OCP) | Asymmetric harm from confident but wrong predictions | +| OCP (normalized) | Scale-invariant version of OCP | +| Explanation–Confidence Alignment (ECA) | Coupling between explanation form and model confidence | + +--- + +## Usage + +```python +import evaluate + +metric = evaluate.load("human_ai_trust") + +out = metric.compute( + predictions=[1, 0, 1], + references=[1, 1, 0], + confidences=[0.9, 0.7, 0.8], + human_trust_scores=[0.85, 0.6, 0.75], + belief_priors=[0.3, 0.4, 0.5], + belief_posteriors=[0.6, 0.5, 0.7], + explanation_complexity=[10, 20, 15], +) + +print(out) +``` + +--- + +## Interpretation Guide + +**Low ETE + High TSI** +→ well-calibrated, uncertainty-sensitive users + +**High ETE + High TSI** +→ sensitive but miscalibrated trust + +**Low TSI** +→ users ignore uncertainty signals + +**High OCP** +→ confident errors dominate harm + +**High BSM** +→ strong AI influence on beliefs + +**Strong ECA (±)** +→ explanation style tracks uncertainty + +--- + +## Limitations + +- These are descriptive metrics, not causal estimators +- They do not evaluate explanation correctness or faithfulness +- They do not measure fairness or bias +- They assume confidence and trust are provided on comparable scales +- Synthetic datasets cannot substitute for real human data + +--- + +## Theory Foundations + +These metrics draw on: + +- calibration in probabilistic judgment +- trust in automation +- Bayesian belief updating +- overconfidence bias +- explanation trust mismatch + +They operationalize core human-centered constructs into computational form. + +--- + +## Companion Dataset + +A small reference dataset is available at: + +**dyra-12/human_ai_trust_demo** + +It demonstrates: + +- trust calibration +- belief updating +- uncertainty communication +- explanation–confidence alignment + +--- + +## License + +Apache 2.0 \ No newline at end of file diff --git a/metrics/human_ai_trust/human_ai_trust.json b/metrics/human_ai_trust/human_ai_trust.json new file mode 100644 index 00000000..1b7e25fa --- /dev/null +++ b/metrics/human_ai_trust/human_ai_trust.json @@ -0,0 +1,16 @@ +{ + "description": "Human-centered evaluation metrics for trust calibration, belief updating, and uncertainty alignment in AI systems.", + "citation": "@misc{human_ai_trust2026,\n title={Human Trust & Uncertainty Metrics for AI Evaluation},\n author={Dyra},\n year={2026},\n note={Hugging Face Evaluate metric}\n}", + "homepage": "https://huggingface.co/datasets/Dyra1204/human_ai_trust_demo", + "license": "Apache-2.0", + "inputs_description": "predictions: List[Any], references: List[Any], confidences: List[float], human_trust_scores: List[float], belief_priors: Optional[List[float]], belief_posteriors: Optional[List[float]], explanation_complexity: Optional[List[float]]", + "keywords": [ + "trust", + "uncertainty", + "human-ai-interaction", + "calibration", + "interpretability", + "belief-updating", + "hcai" + ] +} diff --git a/metrics/human_ai_trust/human_ai_trust.py b/metrics/human_ai_trust/human_ai_trust.py new file mode 100644 index 00000000..e0ceb4ac --- /dev/null +++ b/metrics/human_ai_trust/human_ai_trust.py @@ -0,0 +1,197 @@ +from typing import Any, Dict, List, Optional + +import datasets +import evaluate +import numpy as np + + +_DESCRIPTION = """ +Human Trust & Uncertainty Metrics for AI Evaluation. + +This metric suite operationalizes trust calibration, belief updating, +and uncertainty alignment for human–AI interaction evaluation. +It complements traditional performance metrics by surfacing +human-centered signals about trust, belief dynamics, and confidence communication. +""" + +_KWARGS_DESCRIPTION = """ +Args: + predictions (List[Any]): + Model predictions. + references (List[Any]): + Ground truth labels. + confidences (List[float]): + Model confidence values in [0, 1]. + human_trust_scores (List[float]): + Human trust ratings in [0, 1]. + belief_priors (Optional[List[float]]): + User beliefs before seeing AI output. + belief_posteriors (Optional[List[float]]): + User beliefs after seeing AI output. + explanation_complexity (Optional[List[float]]): + Explanation complexity scores (e.g., length, entropy, readability). + +Returns: + Dict[str, float]: + A dictionary containing: + - expected_trust_error + - trust_sensitivity_index + - belief_shift_magnitude (optional) + - overconfidence_penalty + - overconfidence_penalty_normalized + - explanation_confidence_alignment (optional) +""" + + +def _safe_mean(x: np.ndarray) -> float: + if len(x) == 0: + return 0.0 + return float(np.mean(x)) + + +def _safe_corr(x: np.ndarray, y: np.ndarray) -> float: + if len(x) == 0 or len(y) == 0: + return 0.0 + if len(x) < 2 or len(y) < 2: + return 0.0 + if np.std(x) == 0 or np.std(y) == 0: + return 0.0 + corr = float(np.corrcoef(x, y)[0, 1]) + return 0.0 if np.isnan(corr) else corr + + +class HumanAITrust(evaluate.Metric): + def _info(self): + return evaluate.MetricInfo( + description=_DESCRIPTION, + citation="", + inputs_description=_KWARGS_DESCRIPTION, + features=datasets.Features( + { + "predictions": datasets.Value("int32"), + "references": datasets.Value("int32"), + "confidences": datasets.Value("float32"), + "human_trust_scores": datasets.Value("float32"), + } + ), + reference_urls=[], + ) + + def _validate_inputs( + self, + predictions: List[Any], + references: List[Any], + confidences: List[float], + human_trust_scores: List[float], + belief_priors: Optional[List[float]], + belief_posteriors: Optional[List[float]], + explanation_complexity: Optional[List[float]] + ) -> None: + # Length checks + n = len(predictions) + if not ( + len(references) == n and + len(confidences) == n and + len(human_trust_scores) == n + ): + raise ValueError("All required input lists must have equal length.") + + if belief_priors is not None and len(belief_priors) != n: + raise ValueError("belief_priors must have the same length as predictions.") + + if belief_posteriors is not None and len(belief_posteriors) != n: + raise ValueError("belief_posteriors must have the same length as predictions.") + + if explanation_complexity is not None and len(explanation_complexity) != n: + raise ValueError("explanation_complexity must have the same length as predictions.") + + # Range checks + for c in confidences: + if not (0.0 <= c <= 1.0): + raise ValueError("All confidence values must be in [0, 1].") + + for t in human_trust_scores: + if not (0.0 <= t <= 1.0): + raise ValueError("All human trust scores must be in [0, 1].") + + if belief_priors is not None: + for b in belief_priors: + if not (0.0 <= b <= 1.0): + raise ValueError("All belief_priors values must be in [0, 1].") + + if belief_posteriors is not None: + for b in belief_posteriors: + if not (0.0 <= b <= 1.0): + raise ValueError("All belief_posteriors values must be in [0, 1].") + + def _compute( + self, + predictions: List[Any], + references: List[Any], + confidences: List[float], + human_trust_scores: List[float], + belief_priors: Optional[List[float]] = None, + belief_posteriors: Optional[List[float]] = None, + explanation_complexity: Optional[List[float]] = None, + ) -> Dict[str, Optional[float]]: + + # Input validation + self._validate_inputs( + predictions, + references, + confidences, + human_trust_scores, + belief_priors, + belief_posteriors, + explanation_complexity, + ) + + # Convert to numpy + confidences = np.array(confidences, dtype=float) + trust = np.array(human_trust_scores, dtype=float) + + # === Expected Trust Error (ETE) === + ete = _safe_mean(np.abs(trust - confidences)) + + # === Trust Sensitivity Index (TSI) === + tsi = _safe_corr(trust, confidences) + + # === Belief Shift Magnitude (BSM) === + if belief_priors is not None and belief_posteriors is not None: + belief_priors_arr = np.array(belief_priors, dtype=float) + belief_posteriors_arr = np.array(belief_posteriors, dtype=float) + bsm = _safe_mean(np.abs(belief_posteriors_arr - belief_priors_arr)) + else: + bsm = None + + # === Explanation–Confidence Alignment (ECA) === + if explanation_complexity is not None: + expl = np.array(explanation_complexity, dtype=float) + eca = _safe_corr(confidences, expl) + else: + eca = None + + # === Overconfidence Penalty (OCP) === + errors = np.array( + [pred != ref for pred, ref in zip(predictions, references)], + dtype=float + ) + ocp = _safe_mean(confidences * errors) + + # === Normalized Overconfidence Penalty === + mean_conf = _safe_mean(confidences) + if mean_conf > 0: + ocp_norm = ocp / mean_conf + else: + ocp_norm = 0.0 + + results = { + "expected_trust_error": float(ete), + "trust_sensitivity_index": float(tsi), + "belief_shift_magnitude": None if bsm is None else float(bsm), + "overconfidence_penalty": float(ocp), + "overconfidence_penalty_normalized": float(ocp_norm), + "explanation_confidence_alignment": None if eca is None else float(eca), + } + + return results \ No newline at end of file diff --git a/metrics/human_ai_trust/test_human_ai_trust.py b/metrics/human_ai_trust/test_human_ai_trust.py new file mode 100644 index 00000000..0addf799 --- /dev/null +++ b/metrics/human_ai_trust/test_human_ai_trust.py @@ -0,0 +1,100 @@ +import evaluate +import numpy as np + + +def test_basic_metrics(): + metric = evaluate.load("human_ai_trust") + + preds = [1, 0, 1, 1] + refs = [1, 1, 0, 1] + confs = [0.9, 0.7, 0.8, 0.6] + trust = [0.85, 0.6, 0.75, 0.65] + + out = metric.compute( + predictions=preds, + references=refs, + confidences=confs, + human_trust_scores=trust, + ) + + # ETE + ete_expected = np.mean(np.abs(np.array(trust) - np.array(confs))) + assert abs(out["expected_trust_error"] - ete_expected) < 1e-6 + + # TSI + tsi_expected = np.corrcoef(trust, confs)[0, 1] + assert abs(out["trust_sensitivity_index"] - tsi_expected) < 1e-6 + + # OCP + errors = np.array([p != r for p, r in zip(preds, refs)], dtype=float) + ocp_expected = np.mean(np.array(confs) * errors) + assert abs(out["overconfidence_penalty"] - ocp_expected) < 1e-6 + + # OCP_norm + ocp_norm_expected = ocp_expected / np.mean(confs) + assert abs(out["overconfidence_penalty_normalized"] - ocp_norm_expected) < 1e-6 + + +def test_zero_variance_confidence(): + metric = evaluate.load("human_ai_trust") + + preds = [1, 0, 1] + refs = [1, 1, 0] + confs = [0.5, 0.5, 0.5] + trust = [0.4, 0.6, 0.5] + + out = metric.compute( + predictions=preds, + references=refs, + confidences=confs, + human_trust_scores=trust, + ) + + assert out["trust_sensitivity_index"] == 0.0 + + +def test_bsm_and_eca(): + metric = evaluate.load("human_ai_trust") + + preds = [1, 0, 1] + refs = [1, 1, 0] + confs = [0.9, 0.7, 0.8] + trust = [0.85, 0.6, 0.75] + priors = [0.3, 0.4, 0.5] + posts = [0.6, 0.5, 0.7] + expl = [10, 20, 15] + + out = metric.compute( + predictions=preds, + references=refs, + confidences=confs, + human_trust_scores=trust, + belief_priors=priors, + belief_posteriors=posts, + explanation_complexity=expl, + ) + + bsm_expected = np.mean(np.abs(np.array(posts) - np.array(priors))) + assert abs(out["belief_shift_magnitude"] - bsm_expected) < 1e-6 + + eca_expected = np.corrcoef(confs, expl)[0, 1] + assert abs(out["explanation_confidence_alignment"] - eca_expected) < 1e-6 + + +def test_missing_optional_inputs(): + metric = evaluate.load("human_ai_trust") + + preds = [1, 0] + refs = [1, 1] + confs = [0.8, 0.6] + trust = [0.75, 0.65] + + out = metric.compute( + predictions=preds, + references=refs, + confidences=confs, + human_trust_scores=trust, + ) + + assert out["belief_shift_magnitude"] is None + assert out["explanation_confidence_alignment"] is None \ No newline at end of file diff --git a/test.py b/test.py new file mode 100644 index 00000000..ba847d33 --- /dev/null +++ b/test.py @@ -0,0 +1,12 @@ +import evaluate + +metric = evaluate.load("human_ai_trust") + +out = metric.compute( + predictions=[1, 0, 1], + references=[1, 1, 0], + confidences=[0.9, 0.7, 0.8], + human_trust_scores=[0.85, 0.6, 0.75], +) + +print(out)