Layerwise learning vs end-to-end training for variational quantum classifiers
Domain: quantum (quantum-machine-learning, training-strategies, barren-plateaus)
Topic: Layerwise learning vs end-to-end training for variational quantum classifiers: testing the Skolik 2021 claim that incremental ansatz growth avoids barren plateaus on small UCI binary classification tasks
Venue: ARC-Bench 2026
Headline metric: test_accuracy (maximize)

Research briefing:
Variational quantum classifiers (VQCs) at moderate depth (reps >= 5)
suffer from barren plateaus: the gradient of the loss with respect to
any single parameter is exponentially suppressed when the ansatz is
initialized randomly across all layers. Skolik et al. (Quantum 2021,
"Layerwise learning for quantum neural networks") proposed a training
schedule that avoids this trap by adding ansatz layers incrementally.
Concretely, the agent trains a reps=1 ansatz to convergence, freezes
its parameters, prepends or appends a fresh reps=1 block initialized
to identity, trains only the new block to convergence, and so on
until the target depth is reached. Each layer of training sees a much
smaller parameter space, so the gradient signal stays well above the
barren-plateau floor at every step.

The empirical question this topic addresses is whether the layerwise
schedule actually delivers higher final test accuracy AND faster
practical convergence than naive end-to-end training of the full
reps=5 ansatz on small UCI binary classification tasks. A
parameter-matched classical baseline (sklearn MLPClassifier) and a
logistic regression baseline serve as the cross-paradigm controls
required by the bench's PROCEED gate; they also calibrate the
difficulty of each dataset (logistic regression should fit linear
separable cases cleanly).

Implementation guidance is provided by the quantum-qiskit skill,
which is automatically injected at stage 10. Use
qiskit.circuit.library.EfficientSU2(num_qubits=4, reps=5,
entanglement='linear') as the underlying ansatz family, and use
qiskit_machine_learning.algorithms.VQC for training (it works in
qiskit 2.x; do NOT use qiskit_algorithms.VQE which is broken). For
the layerwise condition, the agent must implement the layer-freezing
schedule manually: construct an ansatz with only the first k blocks
trainable and previous blocks bound to their converged parameters.
The classical baselines train on the same 80/20 train/test split
using the same per-seed random_state.

Experimental protocol. Three quantum conditions compare training
schedules at the same final depth (reps=5): layerwise growth from
reps=1 to reps=5, end-to-end training of reps=5 from random
initialization, and a random-init control (no training, evaluate
the randomly initialized reps=5 ansatz). Two classical baselines
(logistic regression, MLPClassifier with parameter count matched to
the VQC's 40-parameter count) provide the cross-paradigm reference.
Each (condition, dataset) cell is averaged over 3 seeds. Total:
5 conditions x 2 datasets x 3 seeds = 30 cells.

Research question: *Does layerwise incremental training of a VQC
reach higher test accuracy or faster convergence than end-to-end
training of the same final-depth ansatz, and does the layerwise
gradient norm at each newly added layer remain above the
barren-plateau threshold?*

Hypotheses:
statement: Layerwise training reaches higher test accuracy than end-to-end training on at least 1 of 2 datasets, with a 3-seed-mean gap of at least 3 absolute percentage points., statement: The mean gradient norm during the first 10 optimization steps of the layerwise schedule (averaged across all newly added blocks) is at least 5 times larger than the mean gradient norm during the first 10 steps of end-to-end training (3-seed mean), confirming the Skolik 2021 mechanism., statement: Both layerwise and end-to-end VQC outperform the random-init control (no training) by at least 5 absolute percentage points on both datasets (3-seed mean), confirming that training actually contributes — the ansatz itself is not memorizing class structure at initialization.

Experiment design:
research_question: Does layerwise incremental training of a 4-qubit reps=5 VQC reach higher test accuracy or faster convergence than end-to-end training of the same ansatz on small UCI binary classification?
conditions: name: layerwise_growth
description: EfficientSU2(num_qubits=4, reps=5, entanglement='linear'). Training schedule: (1) train only the first reps=1 block via VQC.fit() for 80 COBYLA iterations; (2) freeze those parameters, add a fresh reps=1 block initialized to small N(0, 0.01) noise, train only the new block for 80 iterations; repeat until all 5 blocks are trained. Record the gradient norm at the start of each new layer's training., name: end_to_end
description: EfficientSU2(num_qubits=4, reps=5, entanglement='linear'). Single VQC.fit() call training all 40 parameters simultaneously from random N(0, 0.1) initialization for 400 COBYLA iterations (5 x 80, matching the total iteration budget of the layerwise schedule)., name: random_init_control
description: Same EfficientSU2 ansatz, parameters drawn from Uniform[-pi, pi] and NEVER trained. Evaluate predict() directly on the test set. Floor for trainability — any trained model should beat this.
baselines: logistic_regression: sklearn.linear_model.LogisticRegression(max_iter=1000, random_state=seed). Linear classical baseline., mlp_matched: sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(8,), activation='relu', max_iter=500, random_state=seed). Parameter count: 4*8 + 8 + 8*1 + 1 = 49 parameters, within 20 percent of the VQC's 40 parameters.
metrics: name: test_accuracy
direction: maximize
description: Held-out 20 percent test split accuracy, 3-seed mean. Primary metric., name: mean_gradient_norm_first10
direction: maximize
description: L2 norm of the gradient vector averaged across the first 10 optimization steps. For layerwise, averaged across the first 10 steps of each newly added block. For end-to-end, the first 10 steps of the single training run. Tests the Skolik mechanism., name: iterations_to_target_accuracy
direction: minimize
description: Number of total COBYLA iterations to reach test accuracy >= 0.8 (or to budget 400 if never reached). Tests practical convergence speed.
datasets: name: uci_iris_binary_pca4
source: sklearn.datasets.load_iris + PCA to 4 dimensions
description: Iris dataset restricted to classes {versicolor=1, virginica=2} (binary, 100 samples). PCA to 4 dimensions on standard-scaled features. 80/20 split. Approximately linearly separable; logistic regression should reach >=85 percent., name: breast_cancer_pca4
source: sklearn.datasets.load_breast_cancer + PCA to 4 dimensions
description: Wisconsin breast cancer dataset, 569 samples, 30 features reduced to 4 via PCA. 80/20 split. Non-trivially separable; logistic regression reaches around 0.92.
compute_requirements: gpu_required: no
estimated_wall_clock_sec: 1500

Requirements:

Scoring rubric:
requirements: An empirical study of layerwise vs end-to-end training of a 4-qubit reps=5 EfficientSU2 VQC on UCI binary classification (iris-binary and breast-cancer). The agent must (a) implement the layerwise training schedule manually (train reps=1, freeze, add reps=1, train, ...), (b) implement the end-to-end baseline that trains all 5 reps together, (c) measure mean gradient norm during the first 10 optimization steps of each schedule to test the Skolik 2021 mechanism, and (d) compare against logistic regression + parameter-matched MLP baselines. Score H1/H2/H3 with numerical evidence.
judging_note: Layerwise studies are scored on (i) correctness of the freeze-and-add mechanism (verifiable: the layerwise condition should have N optimizer.minimize() calls each operating on a subset of parameters, not 1 single call over all parameters), (ii) parameter counts matching across conditions (the layerwise and end-to-end VQCs must end with the same 40-parameter ansatz), (iii) the gradient-norm probe being measured at consistent points across conditions, (iv) the random-init control producing accuracy near 0.5 on both datasets (otherwise the ansatz is leaking labels through initialization).
sub_tasks: requirements: Code-development bucket: layerwise freeze-and-add schedule implemented manually, classical baselines parameter-matched, gradient-norm probe consistent.
sub_tasks: requirements: The layerwise condition trains the EfficientSU2(reps=5) ansatz by 5 sequential optimizer.minimize() calls. Each call trains only the parameters belonging to the newly added reps=1 block while the previous blocks have their parameters bound to their previously converged values via qiskit.QuantumCircuit.assign_parameters() on a partial dictionary. After all 5 calls the final fitted VQC has 40 trainable parameters, identical in count to the end-to-end VQC.
task_category: Code Development
finegrained_task_category: Method Implementation, requirements: Mean gradient norm during the first 10 optimization steps is recorded per condition via the qiskit_machine_learning VQC callback or via a custom wrapper around the loss function that uses parameter-shift gradients. For layerwise, the metric is averaged across the first 10 steps of each newly added block (so total of 50 steps averaged, since 5 blocks x 10). For end-to-end, the metric is the first 10 steps of the single training run.
task_category: Code Development
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: mlp_matched uses sklearn.neural_network.MLPClassifier(hidden_layer_sizes=(8,)) for ~49 parameters, within 20 percent of the VQC's 40 parameters. logistic_regression uses sklearn.linear_model.LogisticRegression(max_iter=1000). Both train on the same 80/20 train/test split as the VQC conditions using the same per-seed random_state.
task_category: Code Development
finegrained_task_category: Experimental Setup, requirements: Execution-validity bucket: all 30 cells ran and produced numerically valid outputs.
sub_tasks: requirements: At least 27 cells out of 30 expected (5 conditions x 2 datasets x 3 seeds) completed without unhandled errors and produced a test_accuracy value. Missing more than 3 cells (10 percent) without documented justification fails this leaf.
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Numerical validity: test_accuracy in [0, 1] with non-degenerate predictions (no condition collapses to a single-class predictor on all test samples). The random_init_control condition produces test_accuracy approximately 0.5 +/- 0.1 on both datasets (otherwise label leakage in the untrained ansatz). mean_gradient_norm_first10 is strictly positive across all cells.
task_category: Code Execution
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Results bucket: quantitative tests of H1/H2/H3 plus a per-hypothesis writeup.
sub_tasks: requirements: Quantitative test of H1. On at least 1 of 2 datasets, is layerwise test_accuracy >= end-to-end test_accuracy + 3 absolute pp (3-seed mean)? 100% if gap >= 3pp on at least 1 dataset, 67% if gap >= 1pp on at least 1 dataset, 33% if layerwise marginally faster on any dataset, 0% if end-to-end equals or beats layerwise on both datasets.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Quantitative test of H2. Is mean_gradient_norm_first10 of layerwise >= 5x mean_gradient_norm_first10 of end-to-end (3-seed mean, across both datasets combined)? 100% if ratio >= 5x, 67% if 2-5x, 33% if any positive ratio (layerwise > end-to-end), 0% otherwise.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Quantitative test of H3. Do both layerwise and end-to-end test_accuracy exceed random_init_control test_accuracy by >= 5 absolute pp on both datasets (3-seed mean)? 100% if both gaps >= 5pp on both datasets, 67% if both on 1 dataset, 33% if at least one VQC beats random anywhere, 0% if random matches or beats trained VQCs.
task_category: Result Analysis
finegrained_task_category: Evaluation, Metrics & Benchmarking, requirements: Writeup of at least 200 words (submission/README.md ## Agent-produced writeup section) with explicit supported / refuted / inconclusive verdict for each of H1/H2/H3 backed by specific 3-seed mean test_accuracy, mean_gradient_norm_first10, and iterations_to_target_accuracy values per (condition, dataset). References Skolik et al. Quantum 2021 and discusses whether the layerwise gradient-norm advantage matches their theoretical prediction.
task_category: Result Analysis
finegrained_task_category: Logging, Analysis & Presentation