Microservice Latency Estimation Eval

---
name: microservice-latency-estimation-eval
description: This benchmark evaluates the accuracy of machine learning models in estimating microservice latency under diverse workload conditions. It probes the model's ability to capture hierarchical system behaviors and adapt to different operational scenes using non-intrusive service mesh monitoring data. Use when the user wants to benchmark on Online Boutique, Sock Shop, or asks about evaluating this task. Reports MAE.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 2604.16409
  bibtex_key: sun2026sceneaware
  confidence: high
---

# microservice-latency-estimation-eval

> Scene-Aware Latency Estimation for Microservices via Multi-Scale Graph Fusion — Sun et al. (2026) (arXiv:2604.16409, 2026)

## What this evaluates

This benchmark evaluates the accuracy of machine learning models in estimating microservice latency under diverse workload conditions. It probes the model's ability to capture hierarchical system behaviors and adapt to different operational scenes using non-intrusive service mesh monitoring data.

## Datasets

- **Online Boutique** — total ?; splits: test (-1)
- **Sock Shop** — total ?; splits: test (-1)

## Metrics

- `MAE` **(primary)** — range: other
  - Mean Absolute Error: the average of the absolute differences between predicted and actual latency values.
- `RMSE` — range: other
  - Root Mean Square Error: the square root of the average of squared differences between predicted and actual latency values.
- `MAPE` — range: percent
  - Mean Absolute Percentage Error: the average of the absolute percentage differences between predicted and actual latency values.

## Input / output format

**Input**: System monitoring features including resource quotas, service topology, and temporal patterns extracted from service mesh traces.

**Output**: Estimated latency value (continuous scalar).

## Scoring recipe

```python
def compute_metrics(predictions, actuals):
    mae = np.mean(np.abs(predictions - actuals))
    rmse = np.sqrt(np.mean((predictions - actuals) ** 2))
    mape = np.mean(np.abs((actuals - predictions) / actuals)) * 100
    return mae, rmse, mape
```

## Common pitfalls

- Evaluating on raw latency distributions instead of specific percentiles (P50, P90, P99) as specified in the protocol.
- Ignoring the impact of workload types (CPU-, I/O-, network-bound) on model performance, as the method relies on scene-aware adaptation.
- Assuming tail latency (P99) prediction is reliable; the paper notes it is highly volatile and unpredictable for all methods.

## Evidence (verbatim from paper)

> We use three widely used metrics to evaluate the estimation accuracy of MSGAF and other models: Root Mean Square Error (RMSE), Mean Absolute Error (MAE), and Mean Absolute Percentage Error (MAPE). Lower RMSE, MAE, and MAPE scores indicate better estimation performance. We evaluate model performance across varying latency conditions using the P50, P90, and P99 latency percentiles.

## Citation

```bibtex
@misc{sun2026sceneaware,
  title={Scene-Aware Latency Estimation for Microservices via Multi-Scale Graph Fusion},
  author={Sun et al. (2026)},
  year={2026},
  note={arXiv:2604.16409}
}
```

- arXiv: 2604.16409