Quantum machine learning for wind power forecasting: a hybrid quantum network against persistence and classical models
We tested a hybrid quantum neural network, a 5-qubit circuit on a noiseless simulator, against persistence and classical models on two years of hourly wind power from western Denmark, 1 and 6 hours ahead. At this size it did not forecast better: one hour ahead a plain linear autoregression was the most accurate model, and six hours ahead the hybrid, classical networks of the same size and the linear model were tied within the seed-to-seed noise. Replacing the circuit with a classical block of the same width and parameter count changed its error by less than that noise. The run measures what a small circuit adds to a short-horizon forecast without weather inputs, and the same test runs on your own wind data.
Updated
The short answer
- 1 hour ahead, best model
- Linear autoregression (ridge): nMAE 5.82%, RMSE skill 0.211 against persistence
- 1 hour ahead, hybrid quantum regressor
- nMAE 5.90% ± 0.03%, skill 0.200 ± 0.003; significantly behind ridge in 3 of 5 seeds, ahead in none
- 6 hours ahead
- A tie: skill 0.114 ± 0.006 for the hybrid, 0.116 ± 0.008 for an MLP of the same size, 0.110 for ridge
- Effect of the circuit
- Hybrid minus its classical twin: 0.005 ± 0.011 skill at 1 hour ( = 0.40), 0.005 ± 0.017 at 6 hours ( = 0.54)
- Cost on a simulator
- One fit of the hybrid took 39.2 s, its classical twin 1.6 s, ridge 0.005 s
The data and the question
The series is the hourly wind power of the Danish price area DK1, onshore and offshore summed, from Energinet's open data service under CC BY 4.0[1]. We used two years, 2022 and 2023: the first fifteen months for training, the next three for validation and the last six, July to December 2023, as the test window. The split is by time, so every forecast is made from the past only. The mean output over the test window was 1633 MW, and the errors below are given as a share of it.
The task is the short-horizon forecast a scheduler or a balancing desk needs: from the last 24 hours of output and the calendar, predict the output 1 hour and 6 hours ahead. No weather forecast is used. Every model gets the same 28 inputs (24 lags, plus sine and cosine of the hour and the day of the year) and predicts the change from the last observed value.
The reference is persistence, the forecast , which is hard to beat at short horizons because wind output changes slowly from hour to hour. We report the normalised mean absolute error and the skill score : a skill of 0 is persistence, a skill of 1 is a perfect forecast.
The quantum model is eigenkit's HQNR: a linear map from the 28 inputs to 5 values, a 5-qubit circuit of depth 2 with the strong ansatz, and a linear output, 181 parameters in all. RecurrentHQNR puts an LSTM in front of the same circuit and reads the 24 hours as a sequence. Both ran on eigenkit's exact, noiseless statevector simulator. Against them stand ridge regression (a linear autoregression), gradient boosting, an MLP and an LSTM with exactly as many parameters as HQNR, and for each hybrid a classical twin: the same network with the circuit swapped for Linear(5, 5) and Tanh, which has the same width and the same 30 parameters. Every model got three configurations, chosen on validation, then ran with five seeds.
Results on the test half-year
Mean ± standard deviation over five seeds for the trained networks; persistence, ridge and gradient boosting are deterministic here. nMAE is in percent of the mean output; the skill is against persistence, higher is better.
| Model | nMAE, 1 h | Skill, 1 h | nMAE, 6 h | Skill, 6 h | Parameters |
|---|---|---|---|---|---|
| Persistence | 7.52% | 0.000 | 31.92% | 0.000 | none |
| Ridge (linear autoregression) | 5.82% | 0.211 | 29.48% | 0.110 | 29 |
| Gradient boosting | 6.22% | 0.159 | 30.29% | 0.082 | tree ensemble |
| HQNR (5-qubit circuit) | 5.90% ± 0.03% | 0.200 ± 0.003 | 29.08% ± 0.21% | 0.114 ± 0.006 | 181 |
| HQNR classical twin | 5.99% ± 0.12% | 0.196 ± 0.009 | 29.06% ± 0.32% | 0.108 ± 0.012 | 181 |
| MLP of the same size | 6.05% ± 0.22% | 0.191 ± 0.015 | 28.96% ± 0.17% | 0.116 ± 0.008 | 181 |
| LSTM of the same size | 5.85% ± 0.11% | 0.201 ± 0.006 | 29.60% ± 1.23% | 0.090 ± 0.036 | 181 |
| RecurrentHQNR (LSTM + circuit) | 6.03% ± 0.05% | 0.183 ± 0.007 | 28.85% ± 0.33% | 0.111 ± 0.010 | 276 |
| RecurrentHQNR classical twin | 6.12% ± 0.12% | 0.173 ± 0.013 | 29.22% ± 0.29% | 0.105 ± 0.006 | 276 |
Run wind-power-forecasting-hqnn of 2026-11-03, mean and spread over 5 seeds, on Energinet, Energi Data Service, Production and Consumption - Settlement (ProductionConsumptionSettlement), price area DK1, sum of the four wind columns (offshore and onshore), hourly, 2022-01-01 to 2023-12-31 UTC. Every model beat persistence significantly in every seed at both horizons. The circuit holds 30 of the hybrid's 181 parameters. At 6 hours the differences between the networks and ridge are smaller than their spread, so the table ranks nothing there.
Does the circuit help? Pairs of the same size
Paired per seed: the quantum model's skill minus the classical model's, on the same split, with the two-sided paired t-test over five seeds. Positive means the quantum model did better. The tests against ridge use the Diebold-Mariano test of forecast accuracy[4] on each seed.
| Comparison | Skill difference, 1 h | p, 1 h | Skill difference, 6 h | p, 6 h |
|---|---|---|---|---|
| HQNR vs its classical twin | 0.005 ± 0.011 | 0.40 | 0.005 ± 0.017 | 0.54 |
| RecurrentHQNR vs its classical twin | 0.010 ± 0.019 | 0.28 | 0.006 ± 0.014 | 0.39 |
| HQNR vs the MLP of its size | 0.010 ± 0.017 | 0.28 | -0.003 ± 0.014 | 0.70 |
| RecurrentHQNR vs the LSTM | -0.017 ± 0.012 | 0.03 | 0.021 ± 0.033 | 0.22 |
Run wind-power-forecasting-hqnn of 2026-11-03, mean and spread over 5 seeds, on Energinet, Energi Data Service, Production and Consumption - Settlement (ProductionConsumptionSettlement), price area DK1, sum of the four wind columns (offshore and onshore), hourly, 2022-01-01 to 2023-12-31 UTC. The only significant pair is RecurrentHQNR behind the plain LSTM at 1 hour. Against ridge, RecurrentHQNR was significantly worse in 5 of 5 seeds at 1 hour and HQNR in 3; at 6 hours HQNR was significantly better in 0 and worse in 0.
Why a linear model is hard to beat here
Over one to six hours, most of what can be known about the output of a whole price area is already in its recent level and trend. DK1's wind power is the sum of many farms, so it moves smoothly, and the change over the next hour is close to a linear function of the last few hours. Ridge fits that with 29 coefficients and no training noise. The small networks have to learn the same thing by gradient descent from random weights, and at 1 hour they come close to ridge without passing it. Gradient boosting does worse than ridge at both horizons. A likely reason is that its trees return piecewise-constant values seen in training, while the hour-to-hour change here is close to linear in the inputs.
At 6 hours the past output says less, every model's skill falls, and the small networks, quantum or classical, edge slightly ahead of ridge on average, within the spread. Beyond a few hours the information that matters is the weather to come, which none of these models sees. Operational forecasts get it from numerical weather prediction, and a fair test of any new model at those horizons has to include it.
The circuit in HQNR is a bounded nonlinear map of 5 values with 30 trainable angles. Its classical twin, a 5-by-5 linear layer and tanh, scored within noise of it at both horizons, so the run measures no contribution of the quantum part beyond what any small nonlinearity gives. That matches the broader evidence: in a benchmark of 12[3] quantum machine learning models on 160[3] datasets, out-of-the-box classical models did better overall, and removing entanglement often did not hurt[3].
Published quantum results on wind are hard to compare with this one. A recent study reports its best quantum neural network at an RMSE of 174.67 kW[2] against 182.99 kW[2] for k-nearest neighbours, a 4.5%[2] reduction, on 4,464[2] ten-minute records of one turbine. Its inputs are wind speed, direction, pressure and temperature measured at the same time as the power, its subsets are drawn at random with an 80/20[2] split, and its classical baselines are k-nearest neighbours, a decision tree and linear regression. That is a power-curve regression, not a forecast ahead in time, and it has no persistence or boosting baseline.
What would change this result
The signal to look for is a hybrid that beats its classical twin and ridge, on the same chronological split and over several seeds, by more than the seed-to-seed spread. Here it beat neither. Three things could move that, and each can be tested rather than assumed.
A harder forecast. Over one hour the target is close to linear in the last few hours, which leaves a nonlinear model little to add. At 6 hours the small networks edged ahead of ridge on average, within the spread; longer horizons with weather forecasts as inputs, or the noisier output of a single farm, give a nonlinear model more to learn. The test is the same protocol with those inputs and the classical twin beside the hybrid.
A larger share for the circuit. The 5-qubit circuit holds a small part of HQNR's parameters, and its twin scored within noise of it. A wider circuit gives the quantum layer more to do, at the cost of slower simulation and gradients that flatten with width; barren plateaus explains when that happens and what avoids it.
Real hardware. On a QPU, shot and gate noise add error to every forecast, and each forecast is a circuit run. Before planning on a device, check which QPUs can run a circuit of this size within their error budget and what a run costs.
Run it on a real QPU with EigenOrbit RouterThe trained HQNR, forecasting a sample of test hours on a real QPU, to measure what noise and finite shots add to its error.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).
How to test a quantum model on your own wind data
Split by time and keep persistence as the reference
Train on the past, validate on the next block, test on the block after it, and never shuffle hours across the split. Report every model's skill against persistence at each horizon you care about.
Fit the classical baselines first
A ridge regression on recent lags and calendar terms, and gradient boosting. Add numerical weather forecasts as inputs if you have them: beyond the first few hours, the past output alone says little.
Fit HQNR on the same features, or RecurrentHQNR on the window
HQNRtakes one row of features per forecast origin.RecurrentHQNRreads the window as a sequence through an LSTM or GRU.QuantumTimeSeriesRegressorcan build the sliding windows for either of them.Run the classical twin over several seeds
Train the same network with
Linear(5, 5)andTanhin place of the circuit throughGenericRegressor, on the same split, and report the paired difference. Without it, a hybrid's score says nothing about its quantum layer.Test the trained circuit on hardware only if the simulator result holds
Train on the simulator, then run the trained model on a QPU to measure what noise does to the forecast. Training on the device is not the supported path.
HQNR against persistence and ridge on a wind-like series
import warnings
import numpy as np
from sklearn.linear_model import Ridge
from eigenkit import HQNR
warnings.simplefilter("ignore", UserWarning) # the HQNR input-adapter notice
# A wind-like hourly series: AR(1) weather plus a daily cycle, through a power curve.
rng = np.random.default_rng(0)
hours = np.arange(5000)
weather = np.zeros(len(hours))
for t in range(1, len(hours)):
weather[t] = 0.97 * weather[t - 1] + 0.6 * rng.normal()
speed = 8.0 + weather + 1.5 * np.sin(2 * np.pi * hours / 24)
power = np.clip((speed.clip(3, 12) - 3) ** 3 / 9**3, 0, 1) # share of capacity
# 24 lags as features; the target is the change h hours ahead.
h, window = 1, 24
idx = np.arange(window - 1, len(power) - h)
X = np.stack([power[idx - k] for k in range(window)], axis=1).astype(np.float32)
y = (power[idx + h] - power[idx]).astype(np.float32)
split = 4000 # chronological: train on the past, test on the future
X_tr, X_te, y_tr, y_te = X[:split], X[split:], y[:split], y[split:]
def rmse(pred):
return float(np.sqrt(np.mean((pred - y_te) ** 2)))
base = rmse(np.zeros_like(y_te)) # persistence predicts no change
models = {
"Ridge (linear AR)": Ridge(alpha=1.0),
"HQNR, 5 qubits": HQNR(in_features=window, in_quantum=5, n_qubits=5, depth=2,
variational_type="strong", epochs=15, batch_size=64,
lr=0.01, show_progress=False, random_state=0),
}
print(f"persistence: RMSE {base:.4f}")
for name, model in models.items():
model.fit(X_tr, y_tr)
score = rmse(model.predict(X_te))
print(f"{name}: RMSE {score:.4f}, skill {1 - score / base:+.3f}")Synthetic data, so it runs anywhere in about ten seconds. It prints the RMSE of persistence and the RMSE and skill of each model. On the run we checked, ridge and HQNR both had a small positive skill, within a few thousandths of each other: one synthetic series and one seed are enough to wire the pipeline, not to rank models. Repeat it over seeds on your own data, with the classical twin, as the run above does.
Where to read more
The hybrid pipeline (adapter, MinMaxNorm, circuit, head) and its limits, including barren plateaus and the clipping of inputs outside the fitted range, are in the eigenkit docs under HQNN: guarantees and limits. The worked example time series regression with HQNR and RecurrentHQNR runs the same two estimators on hourly air-quality data. For running a trained model on hardware, see train on a simulator, run on the QPU. The same ablation on classification data is on the HQNN vs classical neural network page, and a quantum reservoir on a forecasting task is on the volatility forecasting page.
Questions
Can quantum machine learning forecast wind power?
It can produce forecasts: a hybrid quantum neural network trains on a simulator and beats persistence on hourly wind power. In our run on Danish grid data it did not beat a linear autoregression 1 hour ahead and tied classical networks of the same size at 6 hours, and its quantum circuit added no measurable gain over a classical block of the same size.
What is the best baseline for short-term wind power forecasting?
Persistence, which repeats the last observed value, is the reference every forecast is scored against, and it is hard to beat in the first hours. A linear autoregression on recent values usually beats it, and was the strongest model 1 hour ahead in our run. Beyond a few hours, numerical weather predictions carry most of the information and belong in any serious model.
Is a hybrid quantum neural network better than an LSTM for wind forecasting?
Not in our run. An LSTM with the same number of parameters tied the hybrid regressor 1 hour ahead, and an LSTM followed by a quantum circuit did worse than the plain LSTM at 1 hour in a paired test over five seeds, and tied it at 6 hours. Single-run results that show a hybrid ahead usually have no seed spread and no same-size classical twin.
How should a wind power forecast be evaluated?
On a test period that comes after the training period, never on randomly shuffled hours, which leak the future into training. Report the error normalised by capacity or mean output, the skill score against persistence for each horizon, the spread over several seeds, and a test such as Diebold-Mariano for whether two forecasts really differ.
Does the hybrid model run on real quantum hardware?
The run on this page used a noiseless simulator only. A trained eigenkit model can be evaluated on a QPU, where shot and gate noise would add error to each forecast; training on the device is slow and is not the supported workflow.
Sources
- Energinet. Production and Consumption - Settlement (dataset ProductionConsumptionSettlement). Energi Data Service, licensed under CC BY 4.0, 2026.
- B. Hangun, O. Altun, O. Eyecioglu. Quantum neural networks for wind energy forecasting: a comparative study of performance and scalability with classical models. arXiv preprint, 2025. arXiv:2506.22845.
- J. Bowles, S. Ahmed, M. Schuld. Better than classical? The subtle art of benchmarking quantum machine learning models. arXiv preprint, 2024. arXiv:2403.07059.
- F. X. Diebold, R. S. Mariano. Comparing predictive accuracy. Journal of Business and Economic Statistics 13(3), 253–263, 1995.
Run it yourself with eigenkit
eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.
$ pip install eigenkit