PennyLane/en

PennyLane est une plateforme logicielle open-source pour le calcul quantique différentiable, développée par Xanadu. Elle permet aux utilisateurs de concevoir des circuits quantiques et de les exécuter sur divers simulateurs et matériels quantiques. PennyLane est conçue pour faciliter la simulation, l'optimisation et l’apprentissage d’algorithmes quantiques hybrides, qui combinent des traitements classiques et quantiques.

Histoire

PennyLane a été lancé en 2018 par Xanadu, une entreprise de technologie quantique basée à Toronto, au Canada. La première version de PennyLane a été publiée en tant que projet open-source sur GitHub.

Fonctionnalités

PennyLane offre plusieurs fonctionnalités pour faciliter la recherche et le développement dans le domaine de l'informatique quantique différentiable:

Interface quantique unifiée

PennyLane fournit une interface quantique unifiée qui permet aux utilisateurs de concevoir des circuits quantiques et de les exécuter sur différents simulateurs et matériels quantiques. PennyLane prend en charge plusieurs simulateurs quantiques populaires, tels que Qiskit, Cirq, Strawberry Field ou encore QuTip. PennyLane prend également en charge plusieurs matériels quantiques, notamment les dispositifs quantiques de Xanadu, les dispositifs quantiques d'IBM, les dispositifs quantiques de Rigetti et les dispositifs quantiques d'IonQ.

Calcul Québec a développé un plug-in PennyLane-Snowflurry utilisant l’interface PennyLane pour concevoir et exécuter des circuits quantiques sur MonarQ.

Intégration avec des bibliothèques d'apprentissage automatique

PennyLane s'intègre de manière transparente avec des librairies d'apprentissage automatique populaires telles que TensorFlow et PyTorch, permettant aux utilisateurs d'utiliser les outils d'apprentissage automatique pour construire des modèles d'apprentissage automatique quantiques hybrides et optimiser les circuits quantiques.

Optimisation de circuits quantiques

En utilisant des techniques d'optimisation différentiables et en combinant les méthodes de différenciation classiques et quantiques, PennyLane permet d'optimiser les paramètres des circuits quantiques afin de résoudre des problèmes variés.

Outils de visualisation

PennyLane fournit des outils de visualisation pour aider les utilisateurs à comprendre le fonctionnement de leurs circuits quantiques.

Communauté et développement

PennyLane est un projet open-source avec une communauté active de développeurs et d'utilisateurs. Le projet est constamment mis à jour avec de nouvelles fonctionnalités et améliorations, et les utilisateurs peuvent contribuer au développement de la plateforme.

Utiliser PennyLane avec MonarQ

MonarQ est conçu pour être programmé avec Snowflurry, une bibliothèque logicielle programmée en Julia et développée par Anyon Systems. Par contre, grâce au plugiciel pennylane-snowflurry, les utilisateurs peuvent créer des circuits PennyLane en utilisant Snowflurry en arrière-plan. Cela permet d’exécuter des circuits sur MonarQ tout en bénéficiant des fonctionnalités et de l'environnement de développement offerts par PennyLane. Voir la documentation PennyLane-Snowflurry pour le guide d’installation et d’usage.

Création de l'environnement virtuel pour l'utilisation de Pennylane

Créons l'environnement virtuel Python pour l'utilisation de Pennylane:

[name@server ~]$ module load python/3.11
[name@server ~]$ virtualenv --no-download --clear ~/ENV && source ~/ENV/bin/activate
[name@server ~]$ pip install --no-index --upgrade pip
[name@server ~]$ python -c "import pennylane"

Vous pouvez également inscrire les trois dernières commandes ci-haut dans un fichier pennylane-reqs.txt et appeler le fichier à l'intérieur d'une session avec les commandes:

[name@server ~]$ module load python/3.11
[name@server ~]$ pip install --no-index -r pennylane-reqs.txt

Exécuter Pennylane sur une grappe

File : script.sh

#!/bin/bash
#SBATCH --account=def-someuser #Modify with your account name
#SBATCH --time=00:15:00        #Modify as needed
#SBATCH --cpus-per-task=1      #Modify as needed
#SBATCH --mem-per-cpu=1G       #Modify as needed
</div>

# Load modules dependencies.
module load StdEnv/2023 gcc python/3.11 

# Generate your virtual environment in $SLURM_TMPDIR.                                                                                                         
virtualenv --no-download ${SLURM_TMPDIR}/env                                                                                                                   
source ${SLURM_TMPDIR}/env/bin/activate  

# Install Pennylane and its dependencies.                                                                                                                                                                                                                                                                                    
pip install --no-index --upgrade pip                                                                                                                            
pip install --no-index --requirement ~/pennylane_requirements.txt

<div lang="fr" dir="ltr" class="mw-content-ltr">
#Edit with your Pennylane program                                                                                                                                                                       
python pennylane_example.py

Vous pouvez ensuite soumettre votre tâche à l'ordonnanceur.

Exemple d’utilisation: état de Bell

Commençons par créer l'environnement vituelle, tel que décrit ci-haut.

Nous allons ensuite générer le premier état de Bell en utilisant PennyLane.

   import pennylane as qml

1. Définir le circuit quantique pour générer le premier état de Bell

   def bell_circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])

1. Définir le simulateur de circuit quantique

   dev = qml.device('default.qubit', wires=2)

1. Définir le circuit quantique comme fonction QNode

   @qml.qnode(dev)
   def generate_bell_state():
    bell_circuit()
    return qml.state()

1. Générer et afficher le premier état de Bell

   bell_state_0 = generate_bell_state()
   print("Premier état de Bell :", bell_state_0)
   Premier état de Bell :[0.70710678+0.j 0.        +0.j 0.        +0.j 0.70710678+0.j]

Références

• Site officiel de PennyLane
• Documentation de PennyLane sur GitHub
• PennyLane-Snowflurry