Mise en route¶

Installation¶

Démarrer localement

Qiskit supporte Python 3.6 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é.

Nous recommandons d’installer Anaconda, une distribution multi-plateformes de Python pour le calcul scientifique. Jupyter, inclus dans Anaconda, est recommandé pour l’interaction avec Qiskit.

Nous recommandons d’utiliser les environnements virtuels Python pour séparer proprement Qiskit des autres applications et améliorer votre confort d’utilisation.

La façon la plus simple d’utiliser les environnements est d’utiliser la commande conda, incluse dans Anaconda. Un environnement Conda vous permet de choisir une version spécifique de Python et un jeu de bibliothèques. Ouvrez une fenêtre de terminal dans le répertoire où vous souhaitez travailler.

Il est préférable d’utiliser l’invite Anaconda installée avec Anaconda. Tout ce que vous avez à faire est de créer un environnement virtuel dans Anaconda et d’activer l’environnement. Ces commandes peuvent être exécutées dans l’invite Anaconda indépendamment du système d’exploitation (Windows, Linux ou MacOS).

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

conda create -n ENV_NAME python=3

Activez votre enouvel environnement.

conda activate ENV_NAME

Ensuite, installez le package Qiskit.

pip install qiskit

Si les paquets se sont installés correctement, vous pouvez lancer la commande conda 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 du code 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.

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.

L’installation depuis la source requiert de respecter l’ordre d’installation suivant :

qiskit-terra
qiskit-aer
qiskit-ignis
qiskit-ibmq-provider (si vous souhaitez pouvoir vous connecter à des devices IBM Quantum ou accéder au simulateur en ligne)

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

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

conda create -y -n QiskitDevenv python=3
conda activate QiskitDevenv

Installing Terra from Source

Cette installation nécessite un compilateur C++ supportant C++11.

Compilateur pour Linux

Sur la plupart des plateformes Linux, le compilateur GCC nécessaire est déjà installé.

Compilateur pour macOS

Si vous utilisez macOS, installez XCode et Clang. Depuis une fenêtre Terminal, vérifiez si XCode et Clang sont installés de cette façon.

clang --version

Installez XCode et Clang via les commandes suivantes.

xcode-select --install

Compilateur pour Windows

Sur Windows, le plus simple est d’installer le compilateur Visual C++ depuis Build Tools for Visual Studio 2019. Vous pouvez aussi choisir Visual Studio version 2015 ou 2017, en prenant soin de valider les options pour installer le compilateur C++.

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

Clonez the dépôt Terra.

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

Le clonage du référentiel crée un dossier local appelé qiskit-terra.
```
cd qiskit-terra
```
Installez les librairies Python nécessaires depuis le répertoire qiskit-terra.
```
pip install cython
```
Si vous souhaitez réaliser des tests ou faire de l’analyse de code source (linting), installez les pré-requis Developeur.
```
pip install -r requirements-dev.txt
```
Installez qiskit-terra.
```
pip install .
```

Pour une installation en mode modifiable (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 .

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

python examples/python/using_qiskit_terra_level_0.py

Note

Si vous n’installez aucun composant supplémentaire, qiskit-terra émettra un avertissement (RuntimeWarning) vous informant que qiskit-aer et qiskit-ibmq-provider ne sont pas installés. Ceci est fait car il est fréquent que les utilisateurs souhaitent utiliser des éléments additionnels, sans réaliser qu’ils ne sont pas installés, ou que les installations de Aer ou de IBM Quantum Provider ont échoué . Si vous souhaitez ne plus avoir cet avertissement, ajoutez :

import warnings
warnings.filterwarnings('ignore', category=RuntimeWarning,
                        module='qiskit')

avant chaque import qiskit dans votre code. Cela permettra de ne plus recevoir les messages d’alerte concernant qiskit-aer et qiskit-ibmq-provider, mais vous recevrez toujours les autres avertissements venant de qiskit ou des autres packages.

Installing Aer from Source

Cloner le dépôt Aer.

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

Installez les pré-requis du compilateur.
```
pip install cmake scikit-build cython
```

Ensuite, les étapes d’installation de Aer dépendent 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 autres qu’avec Python pour construire le binaire Aer dont la méthode d’installation dépend du système d’exploitation utilisé.

Le module Aer de Qiskit fournit un environnement performant pour l’émulation de circuits quantiques. Il fournit la possibilité de travailler avec plusieurs plateformes selon les objectifs poursuivis.

conda install --update-deps -c conda-forge -y openblas cmake

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.

Alternativement, si vous avez installé un pip plus récent ou si vous avez des exigences personnalisées, vous pouvez construire une « wheel » Python manuellement.
```
cd qiskit-aer
python ./setup.py bdist_wheel
```
Si vous avez besoin de définir une option personnalisée pendant la construction de la wheel reportez-vous à Options personnalisées lors de la construction de « wheel ».

Après avoir construit la wheel Python, elle 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 courante 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 carrés [] sont optionnels et skbuild_opts, cmake_opts, build_tool_opts doivent être remplacés par des drapeaux 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 utiliser Automake pour utiliser 8 processus pour la compilation.

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

Plateforme	Outil	Option	Cas d’utilisation
Tous	Automake	-j	Suivi d’un nombre qui définit le nombre de processus à utiliser pour la compilation.
Linux	CMake	-DCMAKE_CXX_COMPILER	Utilisé pour spécifier un compilateur C++ spécifique; c’est souvent nécessaire si votre g++ par défaut l’est aussi.
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.

Installing Ignis from Source

Cloner le dépôt Ignis.

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

Le clonage du référentiel crée un répertoire local appelé qiskit-aqua.
```
cd qiskit-ignis
```
Si vous souhaitez exécuter des tests ou du linting (vérification de votre code), installez les outils développeur. Il n’est pas nécessaire d’installer ou d’utiliser le package qiskit-ignis lors de l’installation à partir du code source.
```
pip install -r requirements-dev.txt
```
Installez Ignis.
```
pip install .
```

Si vous souhaitez l’installer en mode modifiable, ce qui signifie que les modifications de programme apportées au projet ne nécessitent pas une réinstallation :

pip install -e .

Installing IBM Quantum Provider from Source

Cloner le dépôt qiskit-ibmq-provider .

git clone https://github.com/Qiskit/qiskit-ibmq-provider.git

Cloner le dépôt crée un répertoire local appelé qiskit-ibmq-provider.
```
cd qiskit-ibmq-provider
```
Si vous souhaitez exécuter des tests ou du linting (vérification de votre code), installez les outils développeur. Il n’est pas nécessaire d’installer ou d’utiliser le package qiskit-ibmq-provider lors de l’installation à partir du code source.
```
pip install -r requirements-dev.txt
```
Installez qiskit-ibmq-provider.
```
pip install .
```

Si vous souhaitez l’installer en mode modifiable, ce qui signifie que les modifications de programme apportées au projet ne nécessitent pas une réinstallation :

pip install -e .

Platform Support¶

Qiskit strives to support as many platforms as possible, but due to limitations in available testing resources and platform availability, not all platforms can be supported. Platform support for Qiskit is broken into 3 tiers with different levels of support for each tier. For platforms outside these, Qiskit is probably still installable, but it’s not tested and you will have to build Qiskit (and likely Qiskit’s dependencies) from source.

Additionally, Qiskit only supports CPython. Running with other Python interpreters isn’t currently supported.

Tier 1¶

Tier 1 supported platforms are fully tested upstream as part of the development processes to ensure any proposed change will function correctly. Pre-compiled binaries are built, tested, and published to PyPI as part of the release process. These platforms are expected to be installable with just a functioning Python environment as all dependencies are available on these platforms.

Tier 1 platforms are currently:

Linux x86_64 (distributions compatible with the manylinux 2010 packaging specification)

macOS x86_64 (10.9 or newer)

Windows 64 bit

Tier 2¶

Tier 2 platforms are not tested upstream as part of development process. However, pre-compiled binaries are built, tested, and published to PyPI as part of the release process and these packages can be expected to be installed with just a functioning Python environment.

Tier 2 platforms are currently:

Linux i686 (distributions compatible with the manylinux 2010 packaging specification) for Python < 3.10

Windows 32 bit for Python < 3.10

Linux aarch64 (distributions compatible with the manylinux 2014 packaging specification)

Tier 3¶

Tier 3 platforms are not tested upstream as part of the development process. Pre-compiled binaries are built and published to PyPI as part of the release process, with no testing at all. They may not be installable with just a functioning Python environment and may require a C/C++ compiler or additional programs to build dependencies from source as part of the installation process. Support for these platforms are best effort only.

Tier 3 platforms are currently:

Linux i686 (distributions compatible with the manylinux 2010 packaging specification) for Python >= 3.10

Windows 32bit for Python >= 3.10

macOS arm64 (10.15 or newer)

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