Mise en route¶

Installation¶

Commençons à utiliser Qiskit ! La première chose à faire est de choisir comment vous allez exécuter et installer les paquets. Il y a trois façons principales de le faire:

Démarrer localement

Qiskit supporte Python 3.7 ou une version supérieure. Cependant, Python et Qiskit sont des écosystèmes évolutifs, et parfois quand de nouvelles versions sont disponibles pour l’un ou l’autre, il peut y avoir des problèmes de compatibilité.

Vous aurez besoin de ` télécharger Python <https://wiki.python.org/moin/BeginnersGuide/Download>` __ sur votre système local pour commencer. ` Jupyter <https://jupyter.org/install>` __ est recommandé pour interagir avec Qiskit.

Nous recommandons d’utiliser des environnements virtuels Python <https://docs.python.org/3.10/tutorial/venv.html> __ pour séparer correctement Qiskit d’autres applications et améliorer votre expérience.

Créez un environnement minimal avec seulement Python installé.

python3 -m venv /path/to/virtual/environment

Activez votre nouvel environnement.

source /path/to/virtual/environment/bin/activate

Remarque : si vous utilisez Windows, utilisez les commandes suivantes dans PowerShell.

python3 -m venv c:\path\to\virtual\environment
c:\path\to\virtual\environment\Scripts\Activate.ps1

Ensuite, installez le package Qiskit.

pip install qiskit

Si les paquets se sont installés correctement, vous pouvez lancer la commande pip list pour voir les paquets actifs de votre environnement virtuel.

Si vous prévoyez d’utiliser la fonctionnalité de visualisation ou Jupyter notebooks il est recommandé d’installer qiskit avec les options supplémentaires de visualisation :

pip install qiskit[visualization]

Il est utile de préciser que si vous êtes un utilisateur de zsh (qui est le shell par défaut dans les nouvelles versions de macOS) que vous devrez mettre qiskit[visualization] entre guillemets :

pip install 'qiskit[visualization]'

Démarrer sur le cloud

Les fournisseurs de cloud suivants disposent de Qiskit préinstallé dans leur environnement :

IBM Quantum Lab

Build quantum applications and experiments with Qiskit in a cloud programming environment.

Strangeworks

A platform that enables users and organizations to easily apply quantum computing to their most pressing problems and research.

Installation à partir de la source

Installer des éléments depuis la source vous permet d’utiliser la version la plus à jour de Qiskit, plutôt que d’utiliser la version du dépôt de PyPI (Python Package Index). Ceci vous donnera la possibilité d’inspecter et d’étendre plus efficacement la dernière version du code Qiskit.

Lorsqu’une installation depuis la source est réalisée, par défaut, la version development``(correspondant à la branche ``master de git) sera utilisée, et non la version stable (qui contient le code des packages pip publiés). Puisque la version development d’un composant inclut les toutes nouvelles modifications, il est nécessaire alors d’utiliser cette même version pour les autres éléments.

L’installation d’éléments à partir du source nécessite l’ordre d’installation suivant pour empêcher l’installation de versions d’éléments qui peuvent être inférieures à celles désirées si la version pip est derrière les versions sources:

qiskit-terra
qiskit-aer

Pour travailler avec plusieurs composants et éléments en même temps, suivez l’ordre ci-dessous pour chaque composant.

Note

Les packages Terra et Aer nécessitent un compilateur pour être construits depuis la source avant installation. Ignis, Aqua, et IBM Quantum Provider backend ne nécessitent pas de compilateur.

Note

Faites attention lorsque vous installez des packages (en raison des espaces de nommage dans le packaging Python). Si vous souhaitez installer depuis la source, n’utilisez pas le meta-package qiskit. Suivez ce guide et utilisez un environnement de développement à part. Si vous choisissez de mélanger une installation existante avec votre propre installation, lisez https://github.com/pypa/sample-namespace-packages/blob/master/table.md pour découvrir les différentes combinaisons d’installations compatibles.

Set up the Virtual Development Environment

python3 -m venv QiskitDevenv
source QiskitDevenv/bin/activate

Installing Terra from Source

L’installation à partir de la source nécessite que vous disposiez du compilateur Rust sur votre système. Pour installer le compilateur Rust, il est recommandé d’utiliser rustup, qui est un programme d’installation de Rust. Pour ce faire, vous pouvez aller à :

https://rustup.rs/

qui fournira des instructions pour installer rust sur votre plate-forme. En plus de rustup, il y a d’autres méthodes d’installation également disponibles.

Une fois le compilateur Rust installé, vous pouvez installer Qiskit Terra.

Clonez the dépôt Terra.

git clone https://github.com/Qiskit/qiskit-terra.git

Le clonage du dépôt crée un dossier local appelé qiskit-terra.
```
cd qiskit-terra
```
Si vous souhaitez réaliser des tests ou faire de l’analyse de code source (linting), installez les pré-requis du développeur.
```
pip install -r requirements-dev.txt
```
Installez qiskit-terra.
```
pip install .
```

Pour une installation en mode éditable (les changements dans le code sont alors pris en compte sans besoin de réinstaller le projet), vous pouvez choisir cette commande :

pip install -e .

L’installation en mode modifiable construira les extensions compilées en mode débogage et sans optimisation. Cela affectera les performances d’exécution du code compilé. Si vous souhaitez utiliser le mode modifiable et construire le code compilé avec des optimisations activées, vous pouvez exécuter :

python setup.py build_rust --release --inplace

après avoir exécuté pip et qui reconstruira le binaire en mode release. Si vous travaillez sur le code Rust dans Qiskit, vous devrez recompiler le code d’extension chaque fois que vous faites un changement local. pip install -e . ` ne construira l'extension Rust que lorsqu'il sera appelé, donc toutes les modifications locales que vous apportez au code Rust après l'exécution de pip ne seront pas reflétées dans le paquet installé, à moins que vous ne reconstruisiez l'extension. Vous pouvez utiliser la commande ``build_rust ci-dessus pour faire cela (avec ou sans --release selon que vous voulez construire en mode débogage ou en mode release).

Une fois l’installation terminée, vous pouvez exécuter un premier exemple de code.

python examples/python/using_qiskit_terra_level_0.py

Installing Aer from Source

Cloner le dépôt Aer.

git clone https://github.com/Qiskit/qiskit-aer

L’installation d’Aer dépend du système d’exploitation que vous utilisez. Comme Aer est un programme C++ compilé avec une interface Python, il y a des dépendances non-Python pour construire le binaire Aer qui ne peut pas être installé universellement en fonction du système d’exploitation.

Qiskit Aer est un environnement de simulation haute performance pour les circuits quantiques. Il fournit plusieurs backends <apidoc/aer_provider.html#simulator-backends> __ pour atteindre différents objectifs de simulation.

Construire et installer qiskit-aer directement

Si pip <19.0.0 est installé et que votre environnement n’a pas besoin d’une génération personnalisée, exécutez:
```
cd qiskit-aer
pip install .
```
Ceci permettra de construire les binaires et d’installer Aer.

Autrement, si vous avez installé un pip plus récent ou si vous avez des exigences personnalisées, vous pouvez construire un « wheel » Python manuellement.
```
cd qiskit-aer
python ./setup.py bdist_wheel
```
If you need to set a custom option during the wheel build, refer to Custom options.

Après avoir construit le « wheel » Python, il sera stockée dans le répertoire dist/ dans le dépôt Aer. La version exacte dépendra
```
cd dist
pip install qiskit_aer-*.whl
```
Le nom exact du fichier « wheel » en sortie dépend de la version d’Aer en cours de développement.

Custom options

Le système de construction Aer utilise scikit-build <https://scikit-build.readthedocs.io/en/latest/index.html> __ pour exécuter la compilation lors de sa création avec l’interface Python. Il agit comme une interface pour setuptools <https://setuptools.readthedocs.io/en/latest/> __ pour appeler CMake <https://cmake.org/> __ et compiler les binaires pour votre système local.

En raison de la complexité de la compilation des fichiers binaires, vous devrez peut-être passer des options à certains moments du processus de génération. Pour passer des variables, procédez comme suit :

python setup.py bdist_wheel [skbuild_opts] [-- [cmake_opts] [-- build_tool_opts]]

où les éléments entre crochets [] sont optionnels et skbuild_opts, cmake_opts, build_tool_opts doivent être remplacés par des options de votre choix. Une liste des options CMake est disponible ici: https://cmake.org/cmake/help/v3.6/manual/cmake.1.html#options. Par exemple, vous pouvez exécuter quelque chose comme :

python setup.py bdist_wheel -- -- -j8

Ceci passe le commutateur -j8 ` au système de construction sous-jacent (qui dans ce cas est `Automake <https://www.gnu.org/software/automake/> __), en indiquant que vous voulez construire en parallèle à l’aide de 8 processus.

Par exemple, un cas d’utilisation commun pour ces indicateurs sur linux est de spécifier une version spécifique du compilateur C++ à utiliser (normalement si la valeur par défaut est trop ancienne) :

python setup.py bdist_wheel -- -DCMAKE_CXX_COMPILER=g++-7

qui indiquera à CMake d’utiliser la commande g++-7 au lieu de la commande g++ par défaut lors de la compilation d’Aer.

Un autre cas d’utilisation courant pour ceci, en fonction de votre environnement, est que vous devrez peut-être spécifier le nom de votre plate-forme et désactiver la liaison statique.

python setup.py bdist_wheel --plat-name macosx-10.9-x86_64 \
-- -DSTATIC_LINKING=False -- -j8

Ici, --plat-name est un commutateur pour setuptools, pour spécifier le nom de la plate-forme à utiliser dans les métadonnées du paquet, -DSTATIC_LINKING est un commutateur pour utiliser CMake pour désactiver les liens statiques, et -j8 est un commutateur pour Automake afin d’utiliser 8 processus pour la compilation.

Voici une liste des options courantes en fonction de la plateforme :

Plateforme	Outil	Option	Cas d’utilisation
Tout	Automake	-j	Suivi d’un nombre qui définit le nombre de processus à utiliser pour la compilation.
Linux	CMake	-DCMAKE_CXX_COMPILER	Utilisé pour désigner un compilateur C++ spécifique; c’est souvent nécessaire si votre g++ par défaut est trop ancien.
OSX	outils d’installation (setuptools)	–plat-name	Utilisé pour spécifier le nom de la plateforme dans le package Python de sortie.
OSX	CMake	-DSTATIC_LINKING	Utilisé pour indiquer si un lien statique doit être utilisé ou non.

Note

Certaines de ces options ne sont pas spécifiques à une plateforme. Ces plateformes spécifiques sont répertoriées parce qu’elles sont couramment utilisées dans l’environnement. Pour plus d’informations, reportez-vous à la documentation de l’outil.

Plateformes prises en charge¶

Qiskit s’efforce de prendre en charge autant de plateformes que possible, mais en raison des limitations des ressources de test disponibles et de la disponibilité de la plateforme, toutes les plateformes ne peuvent pas être prises en charge. Le support de plateforme pour Qiskit est divisé en 3 niveaux avec différents niveaux de support pour chaque niveau. Pour les plateformes en dehors de celles-ci, Qiskit est probablement toujours installable, mais il n’est pas testé et vous aurez à construire Qiskit (et probablement les dépendances de Qiskit) à partir de la source.

De plus, Qiskit ne prend en charge que CPython. L’exécution avec d’autres interprèteur Python n’est pas prise en charge actuellement.

Niveau 1¶

Les plates-formes prises en charge par le niveau 1 sont entièrement testées en amont dans le cadre des processus de développement pour s’assurer que tout changement proposé fonctionnera correctement. Les binaires pré-compilés sont construits, testés et publiés dans PyPI dans le cadre du processus de publication. Ces plates-formes sont censées être installables avec un environnement Python fonctionnel, car toutes les dépendances sont disponibles sur ces plates-formes.

Les plateformes de niveau 1 sont actuellement:

Linux x86_64 (distributions compatibles avec les spécifications d’empaquetage manylinux 2014).

macOS x86_64 (10.9 ou plus récent)

Windows 64 bits

Niveau 2¶

Les plateformes de niveau 2 ne sont pas testées en amont dans le cadre du processus de développement. Cependant, les binaires pré-compilés sont construits, testés et publiés dans PyPI dans le cadre du processus de libération et ces paquets peuvent être installés avec un environnement Python fonctionnel.

Les plateformes de niveau 2 sont actuellement:

Linux i686 (distributions compatibles avec les spécifications d’empaquetage manylinux 2014) pour Python < 3.10

Windows 32 bits pour Python < 3.10

Linux aarch64 (distributions compatibles avec la spécification manylinux 2014)

Niveau 3¶

Les plateformes de niveau 3 ne sont pas testées en amont dans le cadre du processus de développement. Les binaires pré-compilés sont construits et publiés dans PyPI dans le cadre du processus de publication, sans aucun test du tout. Ils peuvent ne pas être installables uniquement avec un environnement Python fonctionnel et peuvent nécessiter un compilateur C/C++ ou des programmes supplémentaires pour construire des dépendances à partir des sources dans le cadre du processus d’installation. La prise en charge de ces plates-formes est le meilleur effort possible.

Les plateformes de niveau 3 sont actuellement:

Linux ppc64le (distributions compatibles avec la spécification manylinux 2014)

Linux s390x (distributions compatibles avec la spécification manylinux 2014)

macOS arm64 (10.15 ou plus récent)

Linux i686 (distributions compatibles avec les spécifications d’empaquetage manylinux 2014) pour Python >= 3.10

Windows 32 bits pour Python > = 3.10

Prêt à y aller ?…¶

Qiskit from the ground up

Learn how to build, execute, and post-process quantum circuits with Qiskit.

Start learning Qiskit

Dive into the tutorials

Find out how to leverage Qiskit for everything from single-circuits to full quantum application development.

Qiskit tutorials