PennyLane
Overview
PennyLane is a quantum computing library that enables training quantum computers like neural networks. It provides automatic differentiation of quantum circuits, device-independent programming, and seamless integration with classical machine learning frameworks.
Installation
Install using uv:
uv pip install pennylane
For quantum hardware access, install device plugins:
# IBM Quantum
uv pip install pennylane-qiskit
# Amazon Braket
uv pip install amazon-braket-pennylane-plugin
# Google Cirq
uv pip install pennylane-cirq
# Rigetti Forest
uv pip install pennylane-rigetti
# IonQ
uv pip install pennylane-ionq
Quick Start
Build a quantum circuit and optimize its parameters:
import pennylane as qml
from pennylane import numpy as np
# Create device
dev = qml.device('default.qubit', wires=2)
# Define quantum circuit
@qml.qnode(dev)
def circuit(params):
qml.RX(params[0], wires=0)
qml.RY(params[1], wires=1)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
# Optimize parameters
opt = qml.GradientDescentOptimizer(stepsize=0.1)
params = np.array([0.1, 0.2], requires_grad=True)
for i in range(100):
params = opt.step(circuit, params)
Core Capabilities
1. Quantum Circuit Construction
Build circuits with gates, measurements, and state preparation. See references/quantum_circuits.md for:
- Single and multi-qubit gates
- Controlled operations and conditional logic
- Mid-circuit measurements and adaptive circuits
- Various measurement types (expectation, probability, samples)
- Circuit inspection and debugging
2. Quantum Machine Learning
Create hybrid quantum-classical models. See references/quantum_ml.md for:
- Integration with PyTorch, JAX, TensorFlow
- Quantum neural networks and variational classifiers
- Data encoding strategies (angle, amplitude, basis, IQP)
- Training hybrid models with backpropagation
- Transfer learning with quantum circuits
3. Quantum Chemistry
Simulate molecules and compute ground state energies. See references/quantum_chemistry.md for:
- Molecular Hamiltonian generation
- Variational Quantum Eigensolver (VQE)
- UCCSD ansatz for chemistry
- Geometry optimization and dissociation curves
- Molecular property calculations
4. Device Management
Execute on simulators or quantum hardware. See references/devices_backends.md for:
- Built-in simulators (default.qubit, lightning.qubit, default.mixed)
- Hardware plugins (IBM, Amazon Braket, Google, Rigetti, IonQ)
- Device selection and configuration
- Performance optimization and caching
- GPU acceleration and JIT compilation
5. Optimization
Train quantum circuits with various optimizers. See references/optimization.md for:
- Built-in optimizers (Adam, gradient descent, momentum, RMSProp)
- Gradient computation methods (backprop, parameter-shift, adjoint)
- Variational algorithms (VQE, QAOA)
- Training strategies (learning rate schedules, mini-batches)
- Handling barren plateaus and local minima
6. Advanced Features
Leverage templates, transforms, and compilation. See references/advanced_features.md for:
- Circuit templates and layers
- Transforms and circuit optimization
- Pulse-level programming
- Catalyst JIT compilation
- Noise models and error mitigation
- Resource estimation
Common Workflows
Train a Variational Classifier
# 1. Define ansatz
@qml.qnode(dev)
def classifier(x, weights):
# Encode data
qml.AngleEmbedding(x, wires=range(4))
# Variational layers
qml.StronglyEntanglingLayers(weights, wires=range(4))
return qml.expval(qml.PauliZ(0))
# 2. Train
opt = qml.AdamOptimizer(stepsize=0.01)
weights = np.random.random((3, 4, 3)) # 3 layers, 4 wires
for epoch in range(100):
for x, y in zip(X_train, y_train):
weights = opt.step(lambda w: (classifier(x, w) - y)**2, weights)
Run VQE for Molecular Ground State
from pennylane import qchem
# 1. Build Hamiltonian
symbols = ['H', 'H']
coords = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.74])
H, n_qubits = qchem.molecular_hamiltonian(symbols, coords)
# 2. Define ansatz
@qml.qnode(dev)
def vqe_circuit(params):
qml.BasisState(qchem.hf_state(2, n_qubits), wires=range(n_qubits))
qml.UCCSD(params, wires=range(n_qubits))
return qml.expval(H)
# 3. Optimize
opt = qml.AdamOptimizer(stepsize=0.1)
params = np.zeros(10, requires_grad=True)
for i in range(100):
params, energy = opt.step_and_cost(vqe_circuit, params)
print(f"Step {i}: Energy = {energy:.6f} Ha")
Switch Between Devices
# Same circuit, different backends
circuit_def = lambda dev: qml.qnode(dev)(circuit_function)
# Test on simulator
dev_sim = qml.device('default.qubit', wires=4)
result_sim = circuit_def(dev_sim)(params)
# Run on quantum hardware
dev_hw = qml.device('qiskit.ibmq', wires=4, backend='ibmq_manila')
result_hw = circuit_def(dev_hw)(params)
Detailed Documentation
For comprehensive coverage of specific topics, consult the reference files:
- Getting started:
references/getting_started.md - Installation, basic concepts, first steps
- Quantum circuits:
references/quantum_circuits.md - Gates, measurements, circuit patterns
- Quantum ML:
references/quantum_ml.md - Hybrid models, framework integration, QNNs
- Quantum chemistry:
references/quantum_chemistry.md - VQE, molecular Hamiltonians, chemistry workflows
- Devices:
references/devices_backends.md - Simulators, hardware plugins, device configuration
- Optimization:
references/optimization.md - Optimizers, gradients, variational algorithms
- Advanced:
references/advanced_features.md - Templates, transforms, JIT compilation, noise
Best Practices
- Start with simulators - Test on
default.qubit before deploying to hardware
- Use parameter-shift for hardware - Backpropagation only works on simulators
- Choose appropriate encodings - Match data encoding to problem structure
- Initialize carefully - Use small random values to avoid barren plateaus
- Monitor gradients - Check for vanishing gradients in deep circuits
- Cache devices - Reuse device objects to reduce initialization overhead
- Profile circuits - Use
qml.specs() to analyze circuit complexity
- Test locally - Validate on simulators before submitting to hardware
- Use templates - Leverage built-in templates for common circuit patterns
- Compile when possible - Use Catalyst JIT for performance-critical code
Resources
Converted and distributed by TomeVault | Claim this content
1---2name: pennylane3description: Cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Enables building and training quantum circuits with automatic differentiation, seamless integration with PyTorch/JAX/TensorFlow, and device-independent execution across simulators and quantum hardware (IBM, Amazon Braket, Google, Rigetti, IonQ, etc.). Use when working with quantum circuits, variational quantum algorithms (VQE, QAOA), quantum neural networks, hybrid quantum-classical models, molecular simulations, quantum chemistry calculations, or any quantum computing tasks requiring gradient-based optimization, hardware-agnostic programming, or quantum machine learning workflows.4metadata:5 source: https://skillmd.com/skills/mahabdalla/pennylane6---78# PennyLane910## Overview1112PennyLane is a quantum computing library that enables training quantum computers like neural networks. It provides automatic differentiation of quantum circuits, device-independent programming, and seamless integration with classical machine learning frameworks.1314## Installation1516Install using uv:1718```bash19uv pip install pennylane20```2122For quantum hardware access, install device plugins:2324```bash25# IBM Quantum26uv pip install pennylane-qiskit2728# Amazon Braket29uv pip install amazon-braket-pennylane-plugin3031# Google Cirq32uv pip install pennylane-cirq3334# Rigetti Forest35uv pip install pennylane-rigetti3637# IonQ38uv pip install pennylane-ionq39```4041## Quick Start4243Build a quantum circuit and optimize its parameters:4445```python46import pennylane as qml47from pennylane import numpy as np4849# Create device50dev = qml.device('default.qubit', wires=2)5152# Define quantum circuit53@qml.qnode(dev)54def circuit(params):55 qml.RX(params[0], wires=0)56 qml.RY(params[1], wires=1)57 qml.CNOT(wires=[0, 1])58 return qml.expval(qml.PauliZ(0))5960# Optimize parameters61opt = qml.GradientDescentOptimizer(stepsize=0.1)62params = np.array([0.1, 0.2], requires_grad=True)6364for i in range(100):65 params = opt.step(circuit, params)66```6768## Core Capabilities6970### 1. Quantum Circuit Construction7172Build circuits with gates, measurements, and state preparation. See `references/quantum_circuits.md` for:73- Single and multi-qubit gates74- Controlled operations and conditional logic75- Mid-circuit measurements and adaptive circuits76- Various measurement types (expectation, probability, samples)77- Circuit inspection and debugging7879### 2. Quantum Machine Learning8081Create hybrid quantum-classical models. See `references/quantum_ml.md` for:82- Integration with PyTorch, JAX, TensorFlow83- Quantum neural networks and variational classifiers84- Data encoding strategies (angle, amplitude, basis, IQP)85- Training hybrid models with backpropagation86- Transfer learning with quantum circuits8788### 3. Quantum Chemistry8990Simulate molecules and compute ground state energies. See `references/quantum_chemistry.md` for:91- Molecular Hamiltonian generation92- Variational Quantum Eigensolver (VQE)93- UCCSD ansatz for chemistry94- Geometry optimization and dissociation curves95- Molecular property calculations9697### 4. Device Management9899Execute on simulators or quantum hardware. See `references/devices_backends.md` for:100- Built-in simulators (default.qubit, lightning.qubit, default.mixed)101- Hardware plugins (IBM, Amazon Braket, Google, Rigetti, IonQ)102- Device selection and configuration103- Performance optimization and caching104- GPU acceleration and JIT compilation105106### 5. Optimization107108Train quantum circuits with various optimizers. See `references/optimization.md` for:109- Built-in optimizers (Adam, gradient descent, momentum, RMSProp)110- Gradient computation methods (backprop, parameter-shift, adjoint)111- Variational algorithms (VQE, QAOA)112- Training strategies (learning rate schedules, mini-batches)113- Handling barren plateaus and local minima114115### 6. Advanced Features116117Leverage templates, transforms, and compilation. See `references/advanced_features.md` for:118- Circuit templates and layers119- Transforms and circuit optimization120- Pulse-level programming121- Catalyst JIT compilation122- Noise models and error mitigation123- Resource estimation124125## Common Workflows126127### Train a Variational Classifier128129```python130# 1. Define ansatz131@qml.qnode(dev)132def classifier(x, weights):133 # Encode data134 qml.AngleEmbedding(x, wires=range(4))135136 # Variational layers137 qml.StronglyEntanglingLayers(weights, wires=range(4))138139 return qml.expval(qml.PauliZ(0))140141# 2. Train142opt = qml.AdamOptimizer(stepsize=0.01)143weights = np.random.random((3, 4, 3)) # 3 layers, 4 wires144145for epoch in range(100):146 for x, y in zip(X_train, y_train):147 weights = opt.step(lambda w: (classifier(x, w) - y)**2, weights)148```149150### Run VQE for Molecular Ground State151152```python153from pennylane import qchem154155# 1. Build Hamiltonian156symbols = ['H', 'H']157coords = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.74])158H, n_qubits = qchem.molecular_hamiltonian(symbols, coords)159160# 2. Define ansatz161@qml.qnode(dev)162def vqe_circuit(params):163 qml.BasisState(qchem.hf_state(2, n_qubits), wires=range(n_qubits))164 qml.UCCSD(params, wires=range(n_qubits))165 return qml.expval(H)166167# 3. Optimize168opt = qml.AdamOptimizer(stepsize=0.1)169params = np.zeros(10, requires_grad=True)170171for i in range(100):172 params, energy = opt.step_and_cost(vqe_circuit, params)173 print(f"Step {i}: Energy = {energy:.6f} Ha")174```175176### Switch Between Devices177178```python179# Same circuit, different backends180circuit_def = lambda dev: qml.qnode(dev)(circuit_function)181182# Test on simulator183dev_sim = qml.device('default.qubit', wires=4)184result_sim = circuit_def(dev_sim)(params)185186# Run on quantum hardware187dev_hw = qml.device('qiskit.ibmq', wires=4, backend='ibmq_manila')188result_hw = circuit_def(dev_hw)(params)189```190191## Detailed Documentation192193For comprehensive coverage of specific topics, consult the reference files:194195- **Getting started**: `references/getting_started.md` - Installation, basic concepts, first steps196- **Quantum circuits**: `references/quantum_circuits.md` - Gates, measurements, circuit patterns197- **Quantum ML**: `references/quantum_ml.md` - Hybrid models, framework integration, QNNs198- **Quantum chemistry**: `references/quantum_chemistry.md` - VQE, molecular Hamiltonians, chemistry workflows199- **Devices**: `references/devices_backends.md` - Simulators, hardware plugins, device configuration200- **Optimization**: `references/optimization.md` - Optimizers, gradients, variational algorithms201- **Advanced**: `references/advanced_features.md` - Templates, transforms, JIT compilation, noise202203## Best Practices2042051. **Start with simulators** - Test on `default.qubit` before deploying to hardware2062. **Use parameter-shift for hardware** - Backpropagation only works on simulators2073. **Choose appropriate encodings** - Match data encoding to problem structure2084. **Initialize carefully** - Use small random values to avoid barren plateaus2095. **Monitor gradients** - Check for vanishing gradients in deep circuits2106. **Cache devices** - Reuse device objects to reduce initialization overhead2117. **Profile circuits** - Use `qml.specs()` to analyze circuit complexity2128. **Test locally** - Validate on simulators before submitting to hardware2139. **Use templates** - Leverage built-in templates for common circuit patterns21410. **Compile when possible** - Use Catalyst JIT for performance-critical code215216## Resources217218- Official documentation: https://docs.pennylane.ai219- Codebook (tutorials): https://pennylane.ai/codebook220- QML demonstrations: https://pennylane.ai/qml/demonstrations221- Community forum: https://discuss.pennylane.ai222- GitHub: https://github.com/PennyLaneAI/pennylane223224---225> Converted and distributed by [TomeVault](https://tomevault.io) | [Claim this content](https://tomevault.io/claim/davila7/claude-code-templates)