Features, Labels, and the Politics of Measurement: How Data Definitions Shape Machine Learning

Last Updated June 21, 2026

Features, labels, and the politics of measurement explain why machine-learning systems are never built from neutral facts alone. Before a model can learn, someone has to decide what counts as data, which attributes become features, what outcome becomes a label, how categories are defined, how missing cases are handled, and which proxy variables stand in for things that cannot be directly observed. These decisions are technical, but they are also institutional, social, historical, and ethical.

Machine learning often appears to begin with data, but data are already the result of measurement systems. A hiring model may treat prior job titles as features. A health model may use billing codes as labels. An education model may use test scores as outcomes. A public-sector risk model may use administrative records as evidence. In each case, the model learns from categories that were created by people, organizations, policies, incentives, databases, forms, sensors, audits, and omissions.

This article examines features, labels, measurement, proxy variables, construct validity, data provenance, classification systems, bias, institutional history, annotation, missingness, feedback, and governance. It shows why computational reasoning must ask not only how a model learns, but what the model is allowed to see, what it is asked to predict, and whose reality its measurements represent.

This article explains features, labels, measurement, construct validity, proxy variables, annotation, classification, data provenance, missingness, selection effects, institutional history, feedback loops, fairness, documentation, governance, and representation risk. It emphasizes that machine-learning systems do not merely process the world; they process measured representations of the world.

Why Measurement Matters

Measurement matters because algorithms can only reason over what has been represented. A machine-learning system does not directly see poverty, skill, risk, trust, safety, vulnerability, merit, learning, health, need, credibility, or harm. It sees variables. Those variables are produced by records, sensors, surveys, administrative systems, classifications, human annotations, historical data, platform interactions, and institutional decisions.

If the measurement is narrow, the model learns from a narrow world. If labels reflect biased decisions, the model may reproduce those decisions. If features encode institutional history, the model may treat that history as evidence. If categories erase differences, the model may appear efficient while making people less visible.

Measurement is not a preliminary detail. It is part of the reasoning structure of the algorithm.

Back to top ↑

Features Defined

Features are the input variables used by a machine-learning model. They may describe people, events, documents, images, transactions, institutions, environments, behaviors, signals, records, or contexts. A feature can be numerical, categorical, textual, spatial, temporal, relational, visual, or embedded in a learned representation.

Features are often treated as technical material, but they are also interpretive choices. Selecting a feature says that a measured attribute is relevant to the task. Encoding a feature says that the attribute can be represented in a particular form. Scaling, grouping, transforming, and excluding features all change what the model can learn.

Features are not simply inputs. They are claims about what matters.

Back to top ↑

Labels Defined

Labels are the target outcomes used to train or evaluate supervised machine-learning models. In a classification task, the label might be approved or denied, safe or unsafe, fraudulent or legitimate, high risk or low risk, successful or unsuccessful. In a regression task, the label might be a score, cost, probability, rating, measurement, or time-to-event.

Labels often carry authority because they appear as ground truth. But many labels are not direct truths. They may be human judgments, administrative decisions, historical outcomes, legal categories, institutional classifications, billing codes, survey responses, crowd annotations, or delayed consequences. Some labels measure what happened; others measure what was recorded; others measure what an institution chose to recognize.

A label is not automatically truth. It is a recorded answer to a measurement question.

Back to top ↑

From World to Data

The world does not enter a model directly. Events become records. People become rows. Contexts become variables. Histories become distributions. Judgments become labels. Institutions create forms, databases, categories, permissions, incentives, thresholds, and workflows that shape what gets captured.

The path from world to data is therefore a path of translation. Each translation can lose information, distort meaning, or introduce power. A model trained on data inherits the assumptions of the measurement system. Computational reasoning requires examining those assumptions before treating data as evidence.

The measured dataset is a constructed artifact, not an untouched mirror of the world.

Back to top ↑

Constructs, Operationalization, and Validity

Many machine-learning systems try to reason about constructs that cannot be observed directly: skill, risk, trustworthiness, quality, well-being, fraud, vulnerability, need, fairness, engagement, threat, success, or learning. These constructs must be operationalized through observable measurements.

Operationalization is the process of turning a concept into measurable variables. Construct validity asks whether the measurement actually captures the concept it claims to represent. A model may be accurate at predicting an operationalized label while still failing to measure the intended construct.

Construct validity is not optional. It determines whether the model is learning the right target.

Back to top ↑

Proxy Variables

A proxy variable is an observable substitute for something harder to measure. Proxies are common because many important constructs cannot be measured directly. But proxies can mislead. They may correlate with the target while capturing access, surveillance, institutional history, economic status, geography, or group membership.

Proxy variables become especially risky when they appear neutral. Zip code may proxy for neighborhood resources or racialized housing history. Health cost may proxy for access to care rather than health need. Arrest records may proxy for policing patterns rather than underlying behavior. Platform activity may proxy for opportunity, compulsion, or design manipulation rather than genuine preference.

Proxy variables should be treated as hypotheses about measurement, not as self-evident evidence.

Back to top ↑

Classification Systems

Classification systems organize the world into categories. Machine learning depends on classification at many levels: data schemas, feature types, labels, taxonomies, ontologies, metadata, annotation guidelines, error categories, user groups, model outputs, and policy thresholds.

Classification is powerful because it makes computation possible. But classification also creates boundaries. It determines what is counted together, what is separated, what is ignored, and what becomes actionable. A category can be useful for one purpose and harmful for another. It can clarify, simplify, exclude, stigmatize, or normalize.

Classification is both infrastructure and interpretation.

Back to top ↑

Annotation and Human Judgment

Many datasets depend on human annotation. Annotators label images, classify text, identify toxicity, judge relevance, rate quality, assess sentiment, mark medical features, flag policy violations, or describe user intent. These annotations become training targets for models.

Annotation is labor, judgment, and interpretation. The final label may hide disagreement, uncertainty, context, emotional burden, cultural assumptions, power dynamics, and instruction design. A dataset may present a single label even when annotators disagreed. A model may then learn the appearance of certainty from a process that was actually contested.

Human judgment does not disappear when it is converted into a label.

Back to top ↑

Missingness and Selection

Missing data are not always random. A value may be missing because a person lacked access, because a system failed to collect it, because a question was not asked, because a record was suppressed, because an institution did not serve a population, because an event was not reported, or because measurement depended on prior visibility.

Selection also shapes datasets. Some people enter records more often than others. Some events are more likely to be observed. Some outcomes are only visible after contact with an institution. Some cases are removed during cleaning. A model trained on selected data may learn the logic of inclusion rather than the logic of the underlying problem.

Missingness is information about the measurement system.

Back to top ↑

Institutional History in Data

Datasets often contain institutional history. They reflect past policies, resource allocation, enforcement priorities, hiring practices, clinical access, school funding, platform incentives, lending patterns, public-sector eligibility rules, reporting procedures, and classification standards. A model trained on historical data may treat these patterns as evidence for future decisions.

This can be useful when history reflects meaningful regularities. But it becomes dangerous when history reflects exclusion, bias, unequal access, or contested institutional judgment. The model may not know whether a pattern is a valid signal or a residue of earlier decisions.

Historical data should be read as institutional evidence, not only statistical material.

Back to top ↑

Measurement and Fairness

Many algorithmic fairness problems are measurement problems. A model may appear unfair because its labels are biased, its features are proxying protected status, its outcome measure is narrow, its categories erase important differences, or its dataset excludes affected groups. Fairness cannot be reduced to a metric if the underlying construct is poorly defined.

Fairness itself is also a contested construct. Different institutions may define it as equal treatment, equal opportunity, equal error rates, equal outcomes, procedural justice, contestability, dignity, non-discrimination, accountability, or substantive repair. Computational systems must therefore make fairness definitions explicit rather than hiding them inside technical choices.

Fairness review should begin before modeling, at the level of measurement.

Back to top ↑

Feedback and Data Production

Algorithmic systems do not only consume data. Once deployed, they help produce future data. A recommendation system changes what users see. A risk model changes who receives attention. A fraud model changes which transactions are investigated. A hiring model changes who enters the organization. These interventions reshape the records used for future training.

Feedback matters because features and labels after deployment may no longer represent the same processes that produced the training data. The model can create selection effects, self-fulfilling predictions, gaming incentives, or blind spots. Measurement must therefore be monitored over time.

Data are produced by systems, and systems are changed by algorithms.

Back to top ↑

Documentation and Governance

Responsible measurement requires documentation. A dataset should record why it was created, how it was collected, what it contains, who is represented, what is missing, how labels were produced, what preprocessing was applied, what use cases are appropriate, and what use cases are outside scope. A model should document its intended use, performance across conditions, limitations, evaluation procedures, and risks.

Governance should treat feature and label design as accountable institutional reasoning. The key question is not only whether a model performs well, but whether the measurement system deserves to be used for the decision at hand.

Documentation turns hidden measurement assumptions into reviewable artifacts.

Back to top ↑

Representation Risk

Representation risk appears when computational representations are mistaken for the people, systems, or problems they describe. A feature vector is not a person. A label is not a life. A dataset is not a population. A metric is not a purpose. A model output is not an explanation.

The risk is not that measurement is useless. Measurement is necessary for computation. The risk is that measurements become too authoritative. A system may make narrow evidence appear comprehensive, make contested labels appear objective, make proxies appear natural, or make historical classifications appear inevitable.

Responsible computational reasoning keeps the representation visible as a representation.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A supervised-learning dataset is often represented as pairs of inputs and labels:

A feature vector can be written as:

A label may be an operationalized version of a construct:

A proxy feature may be related to an unobserved construct:

A model learns a function from measured features to measured labels:

Measurement audit can be represented as a review function:

These formulas show that feature engineering and label construction are not merely preprocessing. They define the computational object being learned.

Back to top ↑

Python Workflow: Feature and Label Audit

The Python workflow below creates a dependency-light measurement audit. It generates synthetic records, defines features and labels, evaluates missingness, checks proxy risk, summarizes label-source concerns, and writes CSV and JSON outputs for review.

# features_labels_measurement_audit.py
# Dependency-light workflow for auditing features, labels, proxy variables,
# missingness, construct validity, and measurement governance.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
from datetime import datetime, timezone
import csv
import json
import random

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


@dataclass(frozen=True)
class MeasurementAuditConfig:
    article: str
    seed: int
    n: int


@dataclass(frozen=True)
class FeatureRecord:
    feature: str
    construct: str
    measurement_source: str
    proxy_risk: str
    missingness_risk: str
    governance_question: str


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def default_config() -> MeasurementAuditConfig:
    return MeasurementAuditConfig(
        article="features_labels_and_the_politics_of_measurement",
        seed=2026,
        n=600,
    )


def generate_synthetic_records(config: MeasurementAuditConfig) -> list[dict[str, object]]:
    rng = random.Random(config.seed)
    rows: list[dict[str, object]] = []
    for unit_id in range(1, config.n + 1):
        access = rng.random()
        institutional_visibility = max(0.0, min(1.0, rng.gauss(0.35 + 0.50 * access, 0.20)))
        observed_activity = max(0.0, min(1.0, rng.gauss(0.20 + 0.60 * institutional_visibility, 0.18)))
        support_need = max(0.0, min(1.0, rng.gauss(0.70 - 0.40 * access, 0.20)))
        missing_context = 1 if rng.random() > institutional_visibility else 0
        historical_decision = 1 if (0.45 * observed_activity + 0.35 * access + rng.gauss(0, 0.18)) > 0.45 else 0
        target_label = 1 if (0.55 * support_need + 0.25 * observed_activity + rng.gauss(0, 0.16)) > 0.50 else 0
        rows.append({
            "unit_id": unit_id,
            "access_index": round(access, 6),
            "institutional_visibility": round(institutional_visibility, 6),
            "observed_activity_proxy": round(observed_activity, 6),
            "latent_support_need_synthetic": round(support_need, 6),
            "missing_context_flag": missing_context,
            "historical_decision_label": historical_decision,
            "target_support_need_label": target_label,
            "interpretation": "Synthetic records distinguish measured activity, institutional visibility, and a latent support-need construct.",
        })
    return rows


def feature_register() -> list[dict[str, object]]:
    features = [
        FeatureRecord("access_index", "access to resources", "synthetic administrative proxy", "medium", "low", "Does access measure opportunity, need, or institutional privilege?"),
        FeatureRecord("institutional_visibility", "visibility to systems", "synthetic contact record", "high", "medium", "Does visibility reflect reality or prior institutional contact?"),
        FeatureRecord("observed_activity_proxy", "engagement or behavior", "synthetic platform/activity record", "high", "medium", "Does activity reflect preference, constraint, surveillance, or design?"),
        FeatureRecord("missing_context_flag", "record completeness", "synthetic missingness marker", "medium", "high", "Why is contextual information missing and for whom?"),
        FeatureRecord("historical_decision_label", "prior institutional decision", "synthetic decision record", "high", "medium", "Should prior decisions be treated as ground truth?"),
        FeatureRecord("target_support_need_label", "support need", "synthetic constructed outcome", "medium", "medium", "Does the label match the construct the system claims to predict?"),
    ]
    return [asdict(item) for item in features]


def missingness_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    total = len(rows)
    missing = sum(int(row["missing_context_flag"]) for row in rows)
    visible = [row for row in rows if int(row["missing_context_flag"]) == 0]
    missing_rows = [row for row in rows if int(row["missing_context_flag"]) == 1]
    return {
        "total_records": total,
        "missing_context_records": missing,
        "missing_context_rate": round(missing / total, 6),
        "mean_access_visible": round(mean(float(row["access_index"]) for row in visible), 6),
        "mean_access_missing": round(mean(float(row["access_index"]) for row in missing_rows), 6),
        "interpretation": "Missing context is reviewed as a property of the measurement process, not only a technical nuisance.",
    }


def label_alignment_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    disagreements = sum(
        1 for row in rows
        if int(row["historical_decision_label"]) != int(row["target_support_need_label"])
    )
    return {
        "total_records": len(rows),
        "historical_decision_mean": round(mean(int(row["historical_decision_label"]) for row in rows), 6),
        "target_support_need_mean": round(mean(int(row["target_support_need_label"]) for row in rows), 6),
        "label_disagreement_count": disagreements,
        "label_disagreement_rate": round(disagreements / len(rows), 6),
        "interpretation": "Prior institutional decisions and constructed support-need labels are not interchangeable targets.",
    }


def proxy_risk_summary(register: list[dict[str, object]]) -> list[dict[str, object]]:
    risk_order = {"low": 1, "medium": 2, "high": 3}
    rows: list[dict[str, object]] = []
    for item in register:
        proxy_score = risk_order[str(item["proxy_risk"])]
        missing_score = risk_order[str(item["missingness_risk"])]
        rows.append({
            "feature": item["feature"],
            "proxy_risk": item["proxy_risk"],
            "missingness_risk": item["missingness_risk"],
            "combined_measurement_risk_score": proxy_score + missing_score,
            "governance_question": item["governance_question"],
        })
    return rows


def main() -> None:
    config = default_config()
    records = generate_synthetic_records(config)
    register = feature_register()
    missingness = missingness_summary(records)
    label_alignment = label_alignment_summary(records)
    proxy_risks = proxy_risk_summary(register)
    audit_summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "records": config.n,
        "features_reviewed": len(register),
        "high_proxy_risk_items": sum(1 for item in register if item["proxy_risk"] == "high"),
        "missing_context_rate": missingness["missing_context_rate"],
        "label_disagreement_rate": label_alignment["label_disagreement_rate"],
        "interpretation": "Feature and label review should precede model evaluation because measurement choices define what the model can learn.",
    }
    write_csv(TABLES / "measurement_synthetic_records.csv", records)
    write_csv(TABLES / "feature_label_register.csv", register)
    write_csv(TABLES / "missingness_summary.csv", [missingness])
    write_csv(TABLES / "label_alignment_summary.csv", [label_alignment])
    write_csv(TABLES / "proxy_risk_summary.csv", proxy_risks)
    write_csv(TABLES / "measurement_audit_summary.csv", [audit_summary])
    write_json(JSON_DIR / "measurement_audit_config.json", asdict(config))
    write_json(JSON_DIR / "feature_label_register.json", register)
    write_json(JSON_DIR / "missingness_summary.json", missingness)
    write_json(JSON_DIR / "label_alignment_summary.json", label_alignment)
    write_json(JSON_DIR / "proxy_risk_summary.json", proxy_risks)
    write_json(JSON_DIR / "measurement_audit_summary.json", audit_summary)
    print("Feature and label measurement audit complete.")
    print(TABLES / "measurement_audit_summary.csv")


if __name__ == "__main__":
    main()

This workflow treats features and labels as reviewable measurement artifacts rather than neutral technical inputs.

Back to top ↑

R Workflow: Measurement Summary and Diagnostics

The R workflow below reads the Python-generated outputs, summarizes missingness, compares label alignment, and creates basic diagnostic plots for feature and label review.

# features_labels_measurement_summary.R
# Summary diagnostics for the feature and label measurement audit.

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()
}

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

summary_path <- file.path(tables_dir, "measurement_audit_summary.csv")
if (!file.exists(summary_path)) stop("Run the Python workflow first.")

audit_summary <- read.csv(summary_path, stringsAsFactors = FALSE)
proxy_path <- file.path(tables_dir, "proxy_risk_summary.csv")
label_path <- file.path(tables_dir, "label_alignment_summary.csv")
missing_path <- file.path(tables_dir, "missingness_summary.csv")

if (file.exists(proxy_path)) {
  proxy_risk <- read.csv(proxy_path, stringsAsFactors = FALSE)
  png(file.path(figures_dir, "proxy_measurement_risk_scores.png"), width = 1300, height = 850)
  barplot(proxy_risk$combined_measurement_risk_score,
          names.arg = proxy_risk$feature,
          las = 2,
          ylab = "Combined measurement risk score",
          main = "Feature and Label Measurement Risk")
  grid()
  dev.off()
}

if (file.exists(label_path)) {
  label_alignment <- read.csv(label_path, stringsAsFactors = FALSE)
  png(file.path(figures_dir, "label_alignment_rates.png"), width = 1000, height = 750)
  barplot(c(label_alignment$historical_decision_mean,
            label_alignment$target_support_need_mean,
            label_alignment$label_disagreement_rate),
          names.arg = c("Historical decision", "Support need", "Disagreement"),
          ylim = c(0, 1),
          ylab = "Rate",
          main = "Label Source Comparison")
  grid()
  dev.off()
}

if (file.exists(missing_path)) {
  missingness <- read.csv(missing_path, stringsAsFactors = FALSE)
  png(file.path(figures_dir, "missing_context_summary.png"), width = 1000, height = 750)
  barplot(c(missingness$missing_context_rate,
            missingness$mean_access_visible,
            missingness$mean_access_missing),
          names.arg = c("Missing context", "Access visible", "Access missing"),
          ylim = c(0, 1),
          ylab = "Rate or mean",
          main = "Missingness and Access Diagnostics")
  grid()
  dev.off()
}

r_summary <- data.frame(
  records = audit_summary$records[1],
  features_reviewed = audit_summary$features_reviewed[1],
  high_proxy_risk_items = audit_summary$high_proxy_risk_items[1],
  missing_context_rate = audit_summary$missing_context_rate[1],
  label_disagreement_rate = audit_summary$label_disagreement_rate[1]
)

write.csv(r_summary, file.path(tables_dir, "r_measurement_summary.csv"), row.names = FALSE)
print(r_summary)

The R workflow turns measurement risk into visible diagnostic summaries that can be reviewed before model deployment.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic data, audit outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Reviewing Features and Labels

Feature and label review should happen before model training, during evaluation, and after deployment. The goal is not to eliminate measurement choices. The goal is to make them explicit, justified, documented, and contestable.

A measurement audit should produce artifacts: feature dictionaries, label-source statements, missingness reports, provenance notes, use-boundary statements, and stakeholder-review records.

Back to top ↑

Common Pitfalls

Feature and label problems often appear before any model is trained. They are easy to hide because they look like ordinary preprocessing.

The most dangerous measurement errors are often the ones that become invisible because they are built into the dataset.

Back to top ↑

Why Measurement Is Computational Reasoning

Features, labels, and measurement choices are part of algorithmic reasoning because they define what the algorithm can know. A model cannot correct a target that should not have been treated as ground truth. It cannot recover a population that was never observed. It cannot understand a construct that was poorly operationalized. It cannot explain a category whose meaning was never documented.

Machine learning begins before training. It begins when a problem is translated into variables, labels, categories, samples, metrics, and records. That translation is where much of the reasoning happens.

Responsible computational systems therefore require more than better models. They require better measurement practices: clearer constructs, stronger documentation, careful proxy review, label-source audits, missingness analysis, stakeholder participation, and limits on use. The politics of measurement are not outside machine learning. They are inside the data structures from which machine learning begins.

Back to top ↑

Related Articles

• Machine Learning as Algorithmic Inference
• Supervised, Unsupervised, and Reinforcement Learning
• Training, Testing, and Generalization
• Proxy Variables and Measurement Error
• Algorithmic Bias, Data, and Institutional History

Back to top ↑

Further Reading

• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• D’Ignazio, C. and Klein, L.F. (2020) Data Feminism. Cambridge, MA: MIT Press.
• Gebru, T. et al. (2021) ‘Datasheets for datasets’, Communications of the ACM, 64(12), pp. 86–92.
• Jacobs, A.Z. and Wallach, H. (2021) ‘Measurement and fairness’, Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pp. 375–385.
• Mitchell, M. et al. (2019) ‘Model cards for model reporting’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 220–229.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework. Gaithersburg, MD: NIST.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.

Back to top ↑

References

• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• D’Ignazio, C. and Klein, L.F. (2020) Data Feminism. Cambridge, MA: MIT Press.
• Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J.W., Wallach, H., Daumé III, H. and Crawford, K. (2021) ‘Datasheets for datasets’, Communications of the ACM, 64(12), pp. 86–92.
• Jacobs, A.Z. and Wallach, H. (2021) ‘Measurement and fairness’, Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pp. 375–385.
• Mitchell, M., Wu, S., Zaldivar, A., Barnes, P., Vasserman, L., Hutchinson, B., Spitzer, E., Raji, I.D. and Gebru, T. (2019) ‘Model cards for model reporting’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 220–229.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). NIST AI 100-1. Gaithersburg, MD: NIST.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.

Back to top ↑