Reference

Glossary

Every term the demonstrator marks up inline, gathered in one place. Search by name or definition, or browse the list alphabetically.

153 terms

A

Accuracy: The share of all worn / not-worn decisions the model gets right. It can look high even when rare worn tools are missed, so read it alongside recall.
Acoustic emission: High-frequency stress waves released during cutting; captured as a sensor signal that helps detect tool wear and process anomalies.
Affine transform: A straight-line correction a·ŷ+b (scale plus offset) fitted on validation predictions to stretch a compressed ensemble back onto the true wear scale.
Aggregation server: The central component that collects client model updates and combines them (e.g. via FedAvg) into the global model.
Anomaly score: A numeric measure of how unusual the current process is compared to normal operation, used to flag potential faults.
Asset Administration Shell: An Industry 4.0 standard for a machine-readable digital representation of an asset; a shared vocabulary that sits outside the Gaia-X trust baseline.

B

Best local: The single best-performing site model applied to everyone.
Bias: A model's systematic tendency to predict consistently too high or too low; here the ensembles miss worn tools because averaging compresses their range rather than shifting it down.
Boosted-tree ensemble: A model built as a sequence of decision-tree split rules added one after another; not an averageable weight vector, so FedAvg cannot merge it.
Boosting: Building a model as a sequence of trees that each correct the previous ones' errors; 'booster' means one such tree ensemble.
Bootstrap confidence interval: Bootstrap confidence interval: a noise band found by re-sampling the test set many times (about 1,000 here) and recomputing the MAE; it bounds one method's own resampling spread, not the gap between two methods.
Bulyan: A robust aggregation that stacks Krum and the trimmed mean for stronger Byzantine tolerance; it requires even more participants (n >= 4f+3).
Byzantine resilience: Robust to a fraction of clients behaving arbitrarily or maliciously, so a few corrupted updates cannot derail the aggregated model.

C

C2D: Compute-to-Data: Ocean Protocol's mechanism that sends the algorithm to the dataset as a sandboxed, Kubernetes-orchestrated job instead of moving the data, so raw data stays at the provider.
Calibration: Correcting a model's systematic prediction error (here the under-prediction that hides worn tools) by fitting a small map on the validation split.
Canary: A rollout strategy that releases a new model to a small subset first to catch problems before fleet-wide deployment.
Catastrophic forgetting: When sequential training on new data overwrites what a model learned earlier; here later sites in cyclic boosting erase the earlier sites' fit.
Centralized pooled model: The model trained on all sites' data pooled together; the fixed comparator (MAE 6.26 µm) federated methods are measured against. It is not an upper bound: two settings in this catalog land below it.
Centralized reference: A model trained on all sites' raw data pooled together, shown only as a non-sovereign comparator (MAE 6.26 µm), not as a federated option.
Chatter: Self-excited vibration during machining that harms surface quality and the tool; a rare event, making such data imbalanced.
Client drift: When clients' local updates diverge under non-IID data and pull the global model off course; FedProx anchors each update to tame it.
Client heterogeneity: When participating sites' data distributions differ so one model cannot fit them all; the reason picking a single best validation model fails here.
Clock sync: Aligning the clocks of all machines to a common time base so windows and features line up across the fleet.
Coalition: A subset of clients evaluated together; Shapley weighting averages each client's accuracy gain across all 2^K such subsets.
Compute-to-Data (C2D): An Ocean Protocol mechanism that sends the algorithm to the data instead of moving the data: training runs in a sandboxed container beside the dataset, returning only result files and logs.
Conformal prediction: A distribution-free method that turns a point prediction into an interval whose coverage (e.g. 90%) is guaranteed on average from validation residuals.
Convergence: The process by which iterative federated training rounds settle toward a stable, accurate global model.
Coverage: The fraction of true values that fall inside a prediction interval; here 91.4% empirically against a 90% target.
Cyclic boosting: One shared model is passed from site to site, each adding trees on its local data; the visit order matters because the last site is fitted last.

D

Data silos: Isolated data stores that, for governance or legal reasons, cannot be merged into one central dataset.
Data sovereignty: Each site keeps control over its raw data so it never leaves the shop floor; the organizing principle behind the whole aggregation catalog.
Dataspace: A federated infrastructure where organizations share data under agreed sovereignty rules while keeping control; the trained local model is returned through it.
Decentralized identifier: A self-owned, cryptographically verifiable identifier issued without a central registry; Gaia-X uses one to anchor the legal identity behind a signature.
Differential privacy: A technique that clips each contribution and adds calibrated noise so a model's outputs cannot reveal any single record; named here as a protection layer on top of Compute-to-Data.
Distillation: Training one small 'student' model to imitate a larger 'teacher' ensemble's predictions, yielding a single compact deployable model.
Distribution shift: When the data a model is scored on differs statistically from its training data, breaking assumptions like 'validation matches test'.
Ditto: A personalized-FL method that trains a local model per client, regularized toward the global model, also improving robustness and fairness.
Domain shift: When a changed machine, tool, material or parameter set alters the signal statistics, so a model trained on one setup performs worse on another.

E

Edge agent: Software running on or next to a machine that extracts features locally and forwards them (here via MQTT) without sending raw data.
Empirical coverage: The measured share of test points whose true V_B actually fell inside the prediction interval. Ideally it matches the interval's target level.
Ensemble: A combination of several models whose outputs are merged (here, by averaging or weighting per-machine predictions) into one prediction.
EUROe: A euro-denominated stablecoin token used for settlement on Pontus-X, keeping payments inside a European regulatory perimeter.
Exchangeability: The assumption that data points are interchangeable in order; conformal prediction needs it, and holding out whole tools breaks it, which is why measured coverage misses its target.

F

F1: The harmonic mean of precision and recall, a single number that is high only when both the worn-tool catch rate and the false-alarm rate are good.
Feature-space: The multi-dimensional space of input features; routing measures how close a sample sits to each site's training data here.
FedAdam: A FedOpt instance using the Adam optimizer on the server to aggregate client updates with adaptive per-parameter learning rates.
FedAsync: Asynchronous FL that aggregates each client update as it arrives, down-weighting stale ones, to handle stragglers and scale.
FedBuff: A buffered asynchronous FL scheme that collects arriving client updates into a buffer and aggregates them in batches to stay scalable and stable.
Federated Averaging: Federated Averaging: the classic FL algorithm that forms a weighted average of neural-network weights; not applicable to XGBoost trees, so not implemented here.
Federated learning: Machine learning across several clients that keep their raw data local and exchange only models, statistics or predictions; here three milling machines as a cross-silo federation.
Federated Proximal: A FedAvg variant that adds a proximal term to handle heterogeneous (non-IID) clients; like FedAvg it needs an averageable weight vector, so it is not implemented for XGBoost.
Federated random forest: An aggregation that pools independently grown decision trees from each site into one combined forest, voting or averaging their outputs.
Federated training: Sites jointly train one shared model by exchanging model updates round by round, never raw data; these results are precomputed and replayed here.
FedMA: Federated Matched Averaging: before averaging neural networks it first matches neurons across clients, since weights are only defined up to permutation.
FedMD: Federated model distillation: clients repeatedly teach one another via soft labels on a shared public dataset, instead of sharing model weights.
FedOpt: A family of FL methods that replaces the plain weight average with an adaptive server-side optimizer (e.g. momentum or Adam) applied to aggregated updates.
FedRep: A personalized-FL method that learns a shared feature representation across clients while each client keeps its own local prediction head.
FFT bands: Fast Fourier Transform: converts a time-window signal into its frequency content; FFT bands serve as features for tool-wear detection.
Flank-wear land width: Flank-wear land width V_B: the width of the worn land on a milling tool's flank, in micrometers (µm); the regression target the models predict, with a 120 µm decision threshold.

G

Gaia-X: A Franco-German trust framework and architecture (published as a standard, not a running platform) for keeping European industrial data within reach of European law; provides identity, trust and catalogs, but no training runtime.
Gaia-X Credentials: Gaia-X's machine-readable, linked-data document (a W3C verifiable credential, formerly a self-description) that carries signed claims about a participant, resource or service offering.
Gaia-X Digital Clearing Houses: Gaia-X compliance endpoints that validate credentials and sign them into compliant Gaia-X Credentials; Pontus-X connects to them to stay Gaia-X-aligned.
Geometric median: The single vector minimizing total Euclidean distance to all model prediction vectors (the multivariate L1 median); a robust consensus that down-weights a drifting client.
Git Re-Basin: A weight-merging method that aligns the permutation symmetries of two trained networks so their weights can be averaged into one working model.
Global model: The single model the aggregation server builds from all clients' updates and distributes back to the whole fleet.
Gradient and hessian histograms: Per-feature summaries of the loss gradients (and curvatures) that boosting uses to choose tree splits; summing them across sites reproduces pooled training without sharing raw rows.
Gradient-Boosted Decision Trees: Gradient-Boosted Decision Trees: an ensemble that adds trees to correct earlier errors; XGBoost is the per-client implementation, and tree-based FL forms its own protocol family.
Grafana: An open-source dashboarding tool used here to visualize live machine telemetry such as spindle current, vibration and feed.
Ground truth: The verified true value a model is trained and evaluated against; here a measured wear state obtained by stopping and measuring the tool.
Grouped split: Train, validation and test are split by whole tool, not by random row, so no window of the same tool lands in two sets, which prevents leakage.

H

Held-out test set: Data set aside and never used for training, so scoring on it shows how the model behaves on tools it has not seen; used here for the test and validation splits.
Held-out validation split: A held-out slice of each site's data, not used for training, used to fit weights or calibration without ever touching the test labels.
Horizontal federation: FL where each site holds whole samples but shares the same features (as in this demonstrator: each machine contributes complete rows).

I

Inference at the edge: Running the trained model directly on the machine/edge device to compute a condition indicator or anomaly score in real time.
Inverse-distance weighting: Blending experts with weights that shrink as feature-space distance grows (here distance squared); a soft alternative to hard nearest-site routing.
Isotonic regression: Calibration by a free monotone (only-increasing) map fitted with pool-adjacent-violators; captures curved miscalibration a straight affine line cannot.
Iterative federation: Textbook FL where clients and server exchange updates over many communication rounds until the global model converges (FedAvg and its variants).

L

Label scarcity: Too few labeled examples, because wear labels require physical measurement and machine downtime, making ground truth expensive.
Late-wear MAE: The mean absolute error computed only on tools that are already worn, in µm. It measures accuracy exactly where a wrong call is most expensive.
Leakage-safe: When information from the test set sneaks into training and inflates scores; the grouped split avoids it by keeping each whole tool in a single split.
Least squares: Fitting weights by minimizing the sum of squared errors; here it learns each model's ensemble weight on the validation split.

M

Mean absolute error: Mean Absolute Error: the average absolute gap between predicted and true flank wear, in the same unit as V_B (micrometers, µm); the demonstrator's primary metric.
Mean residual: The difference between a model's prediction and the true value; its mean estimates a site's bias and its spread its consistency.
Median abs. error: Median Absolute Error (µm): the middle prediction error across all samples. Unlike MAE it ignores a few extreme outliers, showing the typical-case error.
Mixture-of-experts gate: A small network trained to predict which expert model handles each input best, the learned generalization of the routing family's heuristic distance gates.
MLOps: Machine-Learning Operations: the practices and tooling for deploying, versioning, monitoring and maintaining ML models in production.
Model drift: Gradual change over time in the data or model behavior (e.g. aging bearings, spindle or sensors) that degrades a deployed model's accuracy.
Model soups: A recipe that averages the weights of several already-trained networks into one model; it needs a shared weight space, which tree ensembles lack.
Model updates: The learned changes (weights or gradients) a client sends to the server instead of its raw data.
MQTT: A lightweight publish/subscribe messaging protocol; here the edge agent uses it to stream each machine's feature data off the shop floor.
Multi-Krum: A Byzantine-robust rule that selects the client update most agreed with by its neighbors to resist malicious clients; needs 2f+2 < n participants.

N

Nearest centroid: The mean point of a site's training data in feature space; routing sends each sample to whichever site's centroid is nearest, without seeing the owner label.
Non-IID: Independent and identically distributed: the assumption that samples share one common distribution; FL clients are typically non-IID, which slows convergence and motivates personalization.

O

Ocean Protocol: A blockchain-based protocol that publishes datasets and algorithms as on-chain assets and runs Compute-to-Data jobs next to the data; it supplies the asset and execution layer Gaia-X lacks.
One-shot federation: FL where each site trains once and the models or predictions are combined a single time, rather than iterating over many communication rounds.
OPC UA: An industrial machine-to-machine communication standard; its companion specifications define shared vocabularies for sensor data, sitting outside the Gaia-X baseline.
Out-of-distribution: Inputs that differ from the training data (e.g. new tools or materials), where a model's predictions become unreliable.
Overfitting: When a model learns one setup's data too closely, scoring well there but generalizing poorly to new machines or jobs.
Owner-local: Each sample is scored only by its own machine's local model: the no-collaboration floor that any aggregation must beat to be worthwhile (global MAE 6.88 µm).

P

Per-FedAvg: A personalized-FL method that meta-learns a shared initialization each client can fine-tune to its own data in a few local steps.
Personalized FL: Federated learning that tailors a model to each client instead of one global model, relevant here because every site is a different machine (non-IID).
PFedMe: A personalized-FL method that learns a per-client model kept close to a shared global model via a regularized (Moreau-envelope) objective.
PFNM: Probabilistic Federated Neural Matching: matches and merges neurons across client networks before averaging; the precursor idea to FedMA.
PLC: Programmable logic controller: the industrial controller that runs a machine; its signals are tapped as input features.
Poisoning: An attack where a malicious client sends crafted model updates to corrupt the global model; robust aggregation defends against it.
Pontus-X: A running, Gaia-X-aligned, Ocean-based Pan-European network that bundles trust, assets and sandboxed Compute-to-Data execution; the operational layer a federated client connects through.
Pool-adjacent-violators: The algorithm that fits isotonic regression by merging neighboring points that violate the monotone order until the fit only increases.
Precision: Of all the tools the model flags as worn, the fraction that really were worn. High precision means few false replacement alarms.
Prediction vector: The list of a site's model outputs over the shared evaluation samples; the artifact this demonstrator combines instead of raw data or weights.
Prediction-level ensembles: Each site's model predicts on its own, then the predictions are combined; no model weights are merged, so no new model file is produced.
Proximal term: A penalty added to a client's loss that pulls its local update back toward the global model, limiting how far it can drift each round.

Q

Quantization: Communication compression that stores each transmitted update at lower numeric precision, shrinking the bytes sent without changing how predictions combine.

R

R²: Coefficient of determination: the share of variance in flank wear the model explains (1 is perfect, 0 is no better than the mean); used to compare with the tool-monitoring literature.
Recall: Of all the genuinely worn tools, the fraction the model flags as worn. High recall means few worn tools slip through, the safety-critical case here.
Remaining tool life: The estimated time or cycles a cutting tool can still be used before it must be replaced; an edge inference output of the model.
Ring buffer: A fixed-size circular store that keeps the most recent data and overwrites the oldest; used at the edge before batch upload.
RMS: Root mean square: an amplitude measure of a signal window, used here as a vibration/current feature for tool-wear models.
RMSE: Root Mean Squared Error: the square root of the mean squared prediction error (in µm); penalizes large residuals more than MAE, so big errors stay visible.
Robust Federated Averaging (RFA): A federated method that aggregates clients by their geometric median instead of the mean, so a few corrupted updates cannot drag the result.

S

SCAFFOLD: A federated optimizer that adds control variates to correct client drift via variance reduction, so local updates stay aligned with the global direction.
Secure aggregation: A cryptographic protocol that combines clients' model updates so the server learns only their sum, not any single contribution; named here as a protection layer on top of Compute-to-Data.
SecureBoost: A vertical-FL boosting protocol where parties holding different features of the same samples exchange encrypted gradients so the label-holder can pick splits.
Self-description: The former name for a Gaia-X Credential: the machine-readable, signed document describing a Gaia-X participant, resource or service offering.
Service offerings: A Gaia-X-described, machine-readable offer of a dataset, algorithm or model that providers publish in catalogs; here it describes the exported model, prediction, metric and cost artifacts rather than the global model itself.
Shapley value: Game-theoretic fair-credit measure: a client's average marginal contribution to ensemble accuracy across all client coalitions; used here for fairness-aware weighting.
Simplex constraint: A constraint forcing the learned weights to be non-negative and sum to one, which guards stacking against over-fit weights.
Single-site: A model trained on data from only one machine or setup; it tends to overfit that setup and transfers poorly to others.
Site boundary: The line around each site's premises; the catalog characterizes every method by what (if anything) it lets cross this boundary.
Smart contracts: Self-executing code on a blockchain; in Ocean Protocol it mediates each asset interaction so authorization, payment and audit share one transaction flow.
Soft labels: A model's full probability or score outputs (not just the hard class), shared in distillation so one model can teach another what it learned.
Sovereign data space: Keeping control of your data: each site keeps its raw data and model and shares only what it chooses, the constraint behind owner-local.
Sparsification: Communication compression that transmits only the largest update entries and zeros the rest, reducing the bytes sent each round.
Spindle current: The electrical current drawn by the milling spindle motor; it rises with cutting load and is a key tool-wear feature.
Split-conformal prediction interval: A range around each prediction, calibrated on held-out residuals, meant to contain the true V_B at a chosen confidence such as 90 %.
Stacking: An ensemble method that learns each base model's combining weight from data (here by least squares on validation) instead of fixing them by hand.
Stiehl et al.: The public milling tool-wear dataset this demonstrator uses, split by machine tool into three federated sites for the experiments.
System heterogeneity: Differences in clients' compute power, cycle times and connectivity, which complicate coordinating federated training rounds.

T

TLS: Transport Layer Security: encryption that protects model updates and data while in transit between participants and the aggregation server.
Tool Condition Monitoring: Continuously estimating cutting-tool wear from process signals; the demonstrator's use case, framed as V_B flank-wear regression.
Tool wear: Gradual degradation of a cutting tool's edge during machining; the demonstrator predicts it (flank wear V_B, in µm) from sensor signals.
Transfer learning: Reusing a model pre-trained on a source task and fine-tuning it on the target; unlike federated learning it usually needs the target data available and does not protect sovereignty.
Tree-bagging: Combining independently trained models by averaging to reduce variance; here limited because the site models share one feature space.
Trimmed mean: A robust aggregation that drops the highest and lowest values before averaging; with only three sites it collapses to the median ensemble.
Trust anchors: A recognized authority whose cryptographic signature on a Gaia-X claim raises its trust level, so participants can rely on the claim without re-checking its source.
Trust framework: A set of rules, roles and credential formats that lets parties trust each other's identity and claims; Gaia-X is published as one rather than as a running platform.

U

Underestimation rate: How often the model predicts a tool as less worn than it really is near the threshold. These misses are the costly, safety-relevant errors.

V

Vertical federation: FL where sites hold different features for the same samples and must combine columns (the SecureBoost case), unlike this horizontal demonstrator.

W

W3C: World Wide Web Consortium: the standards body behind the verifiable-credential and decentralized-identifier models that Gaia-X credentials build on.
W3C verifiable credential: A W3C standard for a cryptographically signed, machine-verifiable digital claim; Gaia-X expresses its credentials in this format so signatures can be checked independently.
Wear threshold: The V_B value (120 µm here) at or above which a tool counts as worn, turning the regression output into a replace/keep decision.
Weiszfeld: The iterative algorithm that computes the geometric median by repeatedly reweighting points by their inverse distance to the current estimate.
Windowing: Splitting a continuous sensor signal into fixed time windows so features (like RMS or FFT bands) can be computed per window.

X

XGBoost: The gradient-boosted decision-tree library each client trains locally; its tree ensembles cannot be parameter-averaged, which shapes the aggregation strategies used.