Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
Instruções da origem · Visualização somente leitura
name
pennylane
description
Cross-platform Python library for differentiable quantum computing. Integrated with machine learning libraries like PyTorch, TensorFlow, and JAX. Designed for quantum machine learning (QML), variational algorithms, and hardware-agnostic quantum programming. Use for Quantum Neural Networks (QNNs), Variational Quantum Algorithms (VQE, QAOA), hybrid classical-quantum machine learning, quantum chemistry calculations, benchmarking quantum algorithms, optimizing quantum control pulses, and investigating QML phenomena like Barren Plateaus.
version
0.35
license
Apache-2.0
PennyLane - Quantum Machine Learning
PennyLane treats quantum computers like neural network layers. It allows for the calculation of gradients of quantum circuits (using the parameter-shift rule or backpropagation), enabling the optimization of hybrid classical-quantum models.
When to Use
Developing and training Quantum Neural Networks (QNNs)
A QNode is a quantum circuit bound to a device, which can be called like a standard Python function. It is the fundamental unit that PennyLane can differentiate.
Hardware Agnosticism
PennyLane provides a unified interface. The same code can run on a high-performance simulator (default.qubit), a GPU-accelerated backend (lightning.qubit), or real quantum hardware.
Automatic Differentiation
Quantum circuits in PennyLane are "aware" of their gradients. You can use standard optimizers (Adam, SGD) to tune rotation angles in the circuit.
Quick Reference
Installation
pip install pennylane
# For GPU support
pip install pennylane-lightning[gpu]
Standard Imports
import pennylane as qml
from pennylane import numpy as np # Use PennyLane's wrapped NumPy for gradients
Use qml.numpy - Always use the PennyLane-wrapped NumPy for parameters you want to differentiate
Use Templates - Instead of building layers manually, use qml.templates (like StronglyEntanglingLayers) for efficient QML architectures
Set requires_grad - Explicitly mark trainable parameters with requires_grad=True
Prefer lightning.qubit - For simulations with >15 qubits, use the lightning device for significantly better performance
Use Broadcasting - Many gates support broadcasting over input arrays, which is faster than loops
Batch Circuits - Use qml.batch_input or qml.map for processing multiple inputs simultaneously
❌ DON'T
Mix NumPy versions - Using standard import numpy as np for trainable parameters will break the autograd engine
Overcomplicate Ansätze - Start with simple circuits to avoid Barren Plateaus (where gradients vanish)
Use too many qubits on simulators - Memory scales as 2^N. 30 qubits require ~16GB of RAM for a single statevector
Hardcode Wire Indices - Use variables for wires to make your code reusable and scalable
Anti-Patterns (NEVER)
import pennylane as qml
# ❌ BAD: Standard numpy for trainable parametersimport numpy as np
# ✅ GOOD: PennyLane's wrapped numpyfrom pennylane import numpy as np
# ❌ BAD: Creating a device inside a loopfor i inrange(100):
dev = qml.device("default.qubit", wires=2) # Expensive initialization# ✅ GOOD: Define device once
dev = qml.device("default.qubit", wires=2)
# ❌ BAD: Manual parameter shifting# (shift = 0.5 * pi, calc f(x+s) - f(x-s)...)# ✅ GOOD: Let PennyLane handle it automatically
grad = qml.grad(circuit)(params)
Circuit Templates (qml.templates)
Built-in QML Layers
import pennylane as qml
@qml.qnode(dev)defqnn_layer(inputs, weights):
# Encoding classical data into quantum state
qml.AngleEmbedding(inputs, wires=range(n_qubits))
# Trainable entangling layer
qml.StronglyEntanglingLayers(weights, wires=range(n_qubits))
return qml.expval(qml.PauliZ(0))
Hybrid Optimization (PyTorch/TF)
Integration with Classical Frameworks
import torch
import pennylane as qml
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev, interface="torch")defquantum_layer(phi, theta):
qml.RX(phi, wires=0)
qml.RZ(theta, wires=1)
return qml.expval(qml.PauliZ(0))
# Now this QNode can be used in a Torch Module
phi = torch.tensor(0.1, requires_grad=True)
theta = torch.tensor(0.2, requires_grad=True)
result = quantum_layer(phi, theta)
result.backward()
print(phi.grad)
defvariational_classifier(weights, bias, x):
"""A simple QNN classifier."""return circuit(weights, x) + bias
defcost(weights, bias, X, Y):
predictions = [variational_classifier(weights, bias, x) for x in X]
return square_loss(Y, predictions)
# Optimizer
opt = qml.AdamOptimizer(stepsize=0.1)
# ... loop with opt.step(cost, ...)
2. Computing Gradients on Hardware (Parameter-Shift)
# When running on real hardware, PennyLane automatically uses# the parameter-shift rule to calculate gradients via multiple executions.
dev_remote = qml.device("braket.aws.qubit", device_arn="...", wires=2)
@qml.qnode(dev_remote, diff_method="parameter-shift")defhardware_circuit(params):
qml.RY(params[0], wires=0)
return qml.expval(qml.PauliZ(0))
For large circuits, diff_method="adjoint" is much more memory-efficient than backpropagation.
dev = qml.device("lightning.qubit", wires=20)
@qml.qnode(dev, diff_method="adjoint")deflarge_circuit(params):
...
Common Pitfalls and Solutions
The "Vanishing Gradient" (Barren Plateaus)
As the number of qubits and layers increases, the gradient often becomes exponentially small.
# ✅ Solution: # 1. Use better initialization for weights.# 2. Use local observables (PauliZ(i)) instead of global ones.# 3. Use identity-block initialization.
Non-Trainable Inputs
Sometimes you want to pass data (like images) that shouldn't be optimized.
# ✅ Solution: Use the 'argnum' in qml.grad or use non-array types# Or explicitly:
params = np.array(0.1, requires_grad=True)
data = np.array(0.5, requires_grad=False)
Output Shape Mismatch
qml.probs returns an array of size 2^N.
# ❌ Problem: Using probs(wires=[0,1,2]) in a loss function expecting a scalar.# ✅ Solution: Use expval() for a single scalar or handle the distribution.
PennyLane bridges the gap between quantum physics and artificial intelligence. By making quantum circuits differentiable, it transforms them into powerful, trainable tools for the next generation of scientific computing.
