pennylane-qnn

pennylane-qnn

Purpose

Use this skill to implement or refactor PennyLane-first hybrid quantum neural network code in a clean, reusable way. The goal is to separate circuit definition, parameter handling, training logic, and evaluation so variational classifiers and related models are easy to extend toward PyTorch-first training, Qiskit backends, and fair benchmarking later.

Use this skill when

• Building a variational classifier in PennyLane.
• Refactoring notebook-based QML prototypes into cleaner code.
• Adding data reuploading, measurement logic, or circuit modularity.
• Keeping PyTorch integration while improving architecture.

Do not use this skill when

• The main task is PyTorch interface migration details.
• The main task is Optax training-loop design.
• The main task is backend diversification through Qiskit.

Required inputs

Before applying this skill, identify:

• device and wire count
• input encoding strategy
• ansatz structure and parameter shape
• measurement outputs and label format
• training interface and evaluation metrics

Core rules

1. Keep circuit logic separate from training logic.
2. Make parameter shapes explicit and stable.
3. Design the model so backend or interface changes do not require rewriting the whole circuit.

Decision rules

Circuit structure

• Use simple, inspectable ansatz blocks first.
• Add depth only when justified by the experiment.

Integration boundary

• Keep PennyLane as the authoring layer.
• Treat PyTorch as the default integration layer and avoid redesigning the circuit just to satisfy the training stack.

Implementation guidance

Recommended migration sequence

1. Isolate data encoding.
2. Isolate the variational block.
3. Isolate the QNode.
4. Build prediction and loss functions separately.
5. Add training and evaluation on top.

Recommended code-shape pattern

• encode_input(x)
• variational_block(params)
• qnode(params, x)
• predict(params, batch)
• loss_fn(...) and evaluation utilities

Pitfalls to avoid

• packing all logic into notebook cells
• hiding parameter-shape assumptions inside the circuit body
• changing encoding, ansatz, and optimizer all at once
• making the circuit depend on one training framework too deeply

Verification checklist

• circuit components are modular
• parameter shapes are explicit
• prediction and loss paths are testable separately
• training/evaluation code does not duplicate circuit logic
• the model can be extended to PyTorch-first training and Qiskit backend work without major rewrite

Output standard

When this skill is applied, the resulting PennyLane model should be clean enough to serve as the stable center of the broader QML library.