PennyLane

Vue d'ensemble

PennyLane est une bibliothèque de calcul quantique qui permet d'entraîner des ordinateurs quantiques comme des réseaux de neurones. Elle fournit la différentiation automatique des circuits quantiques, la programmation indépendante du matériel, et l'intégration transparente avec les frameworks classiques d'apprentissage automatique.

Installation

Installez avec uv :

uv pip install pennylane

Pour accéder au matériel quantique, installez les plugins de périphérique :

# 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

Démarrage rapide

Construisez un circuit quantique et optimisez ses paramètres :

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)

Capacités principales

1. Construction de circuits quantiques

Construisez des circuits avec portes, mesures et préparation d'états. Voir references/quantum_circuits.md pour :

Portes à un et plusieurs qubits
Opérations contrôlées et logique conditionnelle
Mesures en milieu de circuit et circuits adaptatifs
Différents types de mesures (espérance, probabilité, échantillons)
Inspection et débogage de circuits

2. Apprentissage automatique quantique

Créez des modèles hybrides quantique-classique. Voir references/quantum_ml.md pour :

Intégration avec PyTorch, JAX, TensorFlow
Réseaux de neurones quantiques et classifieurs variationnels
Stratégies d'encodage de données (angle, amplitude, base, IQP)
Entraînement de modèles hybrides avec rétropropagation
Apprentissage par transfert avec circuits quantiques

3. Chimie quantique

Simulez des molécules et calculez les énergies d'état fondamental. Voir references/quantum_chemistry.md pour :

Génération d'Hamiltoniens moléculaires
Variational Quantum Eigensolver (VQE)
Ansatz UCCSD pour la chimie
Optimisation de géométrie et courbes de dissociation
Calculs de propriétés moléculaires

4. Gestion des périphériques

Exécutez sur des simulateurs ou du matériel quantique. Voir references/devices_backends.md pour :

Simulateurs intégrés (default.qubit, lightning.qubit, default.mixed)
Plugins matériel (IBM, Amazon Braket, Google, Rigetti, IonQ)
Sélection et configuration des périphériques
Optimisation des performances et mise en cache
Accélération GPU et compilation JIT

5. Optimisation

Entraînez des circuits quantiques avec différents optimiseurs. Voir references/optimization.md pour :

Optimiseurs intégrés (Adam, gradient descent, momentum, RMSProp)
Méthodes de calcul de gradient (backprop, parameter-shift, adjoint)
Algorithmes variationnels (VQE, QAOA)
Stratégies d'entraînement (planification du taux d'apprentissage, mini-batches)
Gestion des plateaux stériles et minima locaux

6. Fonctionnalités avancées

Exploitez les templates, transformations et compilation. Voir references/advanced_features.md pour :

Templates et couches de circuits
Transformations et optimisation de circuits
Programmation au niveau du pulse
Compilation JIT Catalyst
Modèles de bruit et atténuation des erreurs
Estimation de ressources

Workflows courants

Entraîner un classifieur variationnel

# 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)

Exécuter VQE pour l'état fondamental moléculaire

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")

Basculer entre les périphériques

# 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)

Documentation détaillée

Pour une couverture complète de sujets spécifiques, consultez les fichiers de référence :

Démarrage : references/getting_started.md - Installation, concepts fondamentaux, premiers pas
Circuits quantiques : references/quantum_circuits.md - Portes, mesures, motifs de circuits
ML quantique : references/quantum_ml.md - Modèles hybrides, intégration de frameworks, QNNs
Chimie quantique : references/quantum_chemistry.md - VQE, Hamiltoniens moléculaires, workflows chimiques
Périphériques : references/devices_backends.md - Simulateurs, plugins matériel, configuration des périphériques
Optimisation : references/optimization.md - Optimiseurs, gradients, algorithmes variationnels
Avancé : references/advanced_features.md - Templates, transformations, compilation JIT, bruit

Bonnes pratiques

Commencez avec des simulateurs - Testez sur default.qubit avant de déployer sur du matériel
Utilisez parameter-shift pour le matériel - La rétropropagation fonctionne uniquement sur les simulateurs
Choisissez les encodages appropriés - Adaptez l'encodage des données à la structure du problème
Initialisez avec soin - Utilisez des petites valeurs aléatoires pour éviter les plateaux stériles
Surveillez les gradients - Vérifiez les gradients qui s'annulent dans les circuits profonds
Mettez en cache les périphériques - Réutilisez les objets périphérique pour réduire le surcoût d'initialisation
Profilez les circuits - Utilisez qml.specs() pour analyser la complexité des circuits
Testez localement - Validez sur les simulateurs avant de soumettre au matériel
Utilisez les templates - Exploitez les templates intégrés pour les motifs de circuits courants
Compilez si possible - Utilisez Catalyst JIT pour le code critique en performance

Ressources

Documentation officielle : https://docs.pennylane.ai
Codebook (tutoriels) : https://pennylane.ai/codebook
Démonstrations QML : https://pennylane.ai/qml/demonstrations
Forum communautaire : https://discuss.pennylane.ai
GitHub : https://github.com/PennyLaneAI/pennylane