Primeiros Passos¶

Instalação¶

Vamos começar a usar o Qiskit! O primeiro passo é escolher como você irá rodar e instalar os pacotes. Existem três maneiras principais para fazer isto:

Iniciar localmente

Qiskit suporta Python 3.7 ou superior. Contudo, tanto o Python quanto o Qiskit são ecosistemas que estão em constante evolução, e as vezes, com novos lançamentos em um ou no outro, alguns problemas de compatibilidade podem surgir.

Você precisará baixar Python em seu sistema local para começar. Jupyter é recomendado para interagir com o Qiskit.

Recomendamos o uso de ambientes virtuais Python para separar o Qiskit de outros aplicativos e melhorar sua experiência.

Crie um ambiente mínimo com apenas o Python instalado.

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

Ative seu novo ambiente.

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

Observação: se você estiver usando o Windows, use os seguintes comandos no PowerShell.

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

Em seguida, instale o pacote Qiskit.

pip install qiskit

Se os pacotes foram instalados corretamente, você pode executar pip list para ver os pacotes ativos em seu ambiente virtual.

Se você pretende usar a funcionalidade de visualização ou notebooks Jupyter, é recomendável instalar o Qiskit com suporte extra à visualização:

pip install qiskit[visualization]

Vale ressaltar que se você for um usuário zsh (que é o shell padrão nas versões mais recentes do macOS), você precisará colocar qiskit[visualization] entre aspas:

pip install 'qiskit[visualization]'

Começar na nuvem

Os seguintes fornecedores de nuvem têm o Qiskit pré-instalado em seus ambientes:

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.

Instalando da Fonte

Instalar os elementos da fonte permite que você acesse a versão atualizada mais recentemente do Qiskit em vez de usar a versão no repositório Python Package Index (PyPI). Isso lhe dará a capacidade de inspecionar e estender a versão mais recente do código Qiskit com mais eficiência.

Ao instalar os elementos e componentes da fonte, por padrão, sua versão development (que corresponde ao ramo git master) será usada, em oposição à versão stable (que contém o mesmo codebase como os pacotes pip publicados). Uma vez que as versões development de um elemento ou componente geralmente incluem novos recursos e mudanças, elas geralmente requerem o uso da versão development do resto dos itens também.

A instalação de elementos a partir do código-fonte requer a seguinte ordem de instalação para evitar a instalação de versões de elementos que podem ser inferiores às desejadas se a versão pip estiver atrás das versões do código-fonte:

qiskit-terra
qiskit-aer

Para trabalhar com vários componentes e elementos simultaneamente, use as seguintes etapas para cada elemento.

Nota

Os pacotes Terra e Aer requerem um compilador para construir a partir do código-fonte antes que você possa instalar. Ignis, Aqua e o provedor IBM Quantum não requerem um compilador.

Nota

Devido ao uso de pacotes de namespace em Python, é preciso ter cuidado com a forma como você instala os pacotes. Se você está planejando instalar algum elemento desde a fonte, não use o meta-package qiskit. Além disso, siga este guia e use um ambiente virtual separado para desenvolvimento. Se você optar por misturar uma instalação existente com o seu desenvolvimento, consulte https://github.com/pypa/sample-namespace-packages/blob/master/table.md para o conjunto de combinações de métodos de instalação que funcionam juntos.

Set up the Virtual Development Environment

python3 -m venv QiskitDevenv
source QiskitDevenv/bin/activate

Installing Terra from Source

A instalação a partir da fonte requer que você tenha o compilador Rust em seu sistema. Para instalar o compilador Rust, o caminho recomendado é usar rustup, que é um instalador Rust multiplataforma. Para usar o rustup, você pode acessar:

https://rustup.rs/

que fornecerá instruções sobre como instalar o rust em sua plataforma. Além do rustup, também existem outros métodos de instalação disponíveis.

Quando o compilador Rust estiver instalado, você estará pronto para instalar o Qiskit Terra.

Clone o repositório Terra.

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

Clonar o repositório criará uma pasta local chamada qiskit-terra.
```
cd qiskit-terra
```
Se você quiser executar testes ou análise de código, instale os requisitos de desenvolvedor.
```
pip install -r requirements-dev.txt
```
Instale o qiskit-terra.
```
pip install .
```

Se você quiser instalá-lo em modo editável, o que significa que as alterações ao código no projeto não requerem que uma reinstalação seja aplicada, você pode fazer isso com:

pip install -e .

A instalação no modo editável criará as extensões compiladas no modo de depuração sem otimizações. Isso afetará o desempenho do tempo de execução do código compilado. Se você quiser usar o modo editável e construir o código compilado na versão com otimizações habilitadas, você pode executar:

python setup.py build_rust --release --inplace

depois de executar o pip e isso reconstruirá o binário no modo de liberação. Se você estiver trabalhando no código Rust no Qiskit, precisará reconstruir o código de extensão sempre que fizer uma alteração local. pip install -e . apenas construirá a extensão Rust quando ela for chamada, então qualquer alteração local que você fizer no código Rust após executar o pip não será refletida no pacote instalado, a menos que você reconstrua a extensão. Você pode usar o comando build_rust acima para fazer isso (com ou sem --release dependendo se você deseja compilar em modo de depuração ou modo de lançamento).

Você pode então executar os código de exemplo após instalar o Terra. Você pode executar o código de exemplo com o seguinte comando.

python examples/python/using_qiskit_terra_level_0.py

Installing Aer from Source

Clone o repositório Aer.

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

Para instalar o Aer depende de qual sistema operacional você está usando. Como o Aer é um programa C++ compilado com uma interface Python, existem dependências não-Python para construir o binário Aer que não pode ser instalado universalmente dependendo do sistema operacional.

O Qiskit Aer é um framework de simulador de alto desempenho para circuitos quânticos. Ele fornece diversos backends para alcançar diferentes objetivos de simulação.

Faça a criação dos pacotes e instale o qiskit-aer diretamente

Se você tiver o pip <19.0.0 instalado e seu ambiente não requer um build personalizado, execute:
```
cd qiskit-aer
pip install .
```
Isto irá fazer o build dos binários e instalar o Aer.

Alternativamente, se você tiver uma versão do pip mais recente instalado ou tiver um requisito personalizado, você pode fazer a criação dos pacotes do Python wheel manualmente.
```
cd qiskit-aer
python ./setup.py bdist_wheel
```
Se você precisar definir uma opção personalizada durante o processo de wheel build, consulte Opções personalizadas.

Depois de feito a criação dos pacotes do Python wheel, ela será armazenada no diretório dist/ no repositório Aer. A versão exata dependerá
```
cd dist
pip install qiskit_aer-*.whl
```
O nome exato do arquivo da wheel de saída depende da versão atual do Aer em desenvolvimento.

Custom options

O sistema do Aer build usa scikit-build para executar a compilação ao construí-la com a interface Python. Ele atua como uma interface de setuptools para chamar CMake e compilar os binários no seu sistema local.

Devido à complexidade de compilar os binários, você pode precisar passar opções para uma determinada parte do processo de build. A maneira de passar variáveis é:

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

onde os elementos dentro de colchetes [] são opcionais, e skbuild_opts, cmake_opts, build_tool_opts serão substituídos por flags de sua escolha. Uma lista das opções CMake está disponível aqui: https://cmake.org/cmake/help/v3.6/manual/cmake.1.html#options. Por exemplo, você pode executar algo como:

python setup.py bdist_wheel -- -- -j8

Isso está passando a flag -j8 para o sistema de empacotamento subjacente (que neste caso é Automake), dizendo que você deseja fazer o empacotamento em paralelo usando 8 processos.

Por exemplo, um caso de uso comum para essas flags no Linux é definir uma versão específica do compilador C++ para usar (normalmente se o padrão for muito antigo):

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

que dirá ao CMake para usar o comando g++-7 em vez do g++ padrão ao compilar o Aer.

Outro caso de uso comum para isso, dependendo do seu ambiente, é que você pode precisar especificar o nome da sua plataforma e desativar a linkagem estática.

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

Aqui --plat-name é uma flag de ferramentas de configuração, para especificar o nome da plataforma a utilizar nos metadados do pacote; -DSTATIC_LINKING é uma flag para usar o CMake e desabilitar links estáticos, e -j8 é uma flag para fazer o Automake usar 8 processos para a compilação.

Uma lista de opções comuns dependendo da plataforma é:

Plataforma	Ferramenta	Opção	Caso de Uso
Todos	Automake	-j	Seguido por um número, define o número de processos a serem usados para compilação.
Linux	CMake	-DCMAKE_CXX_COMPILER	Usado para definir um compilador C++ específico; isso é geralmente necessário se seu g++ padrão for muito antigo.
OSX	ferramentas de configuração	–plat-name	Usado para especificar o nome da plataforma no pacote de saída Python.
OSX	CMake	-DSTATIC_LINKING	Usado para especificar se deve ou não ser utilizada a linkagem estática.

Nota

Algumas dessas opções não são específicas da plataforma. Essas plataformas em particular são listadas porque são comumente usadas no ambiente. Consulte a documentação da ferramenta para obter mais informações.

Suporte de Plataforma¶

O Qiskit se esforça para dar suporte ao máximo possível de plataformas, mas devido às limitações em recursos de testagem e disponibilidade das plataformas, nem todas têm suporte. O suporte para o Qiskit é dividido em 3 camadas com diferentes níveis de suporte. Para plataformas que não sejam essas, é provável que seja possível instalar o Qiskit, mas ele não é testado, e você precisará compilá-lo (e provavelmente suas dependências) diretamente da fonte.

Além disso, o Qiskit apenas dá suporte ao CPython. Rodar outros interpretadores de Python não é suportado atualmente.

Camada 1¶

Plataformas com suporte na camada 1 são completamente testadas antes como parte de processos de desenvolvimento para garantir que quaisquer mudanças propostas funcionem corretamente. Binários pré-compilados são construídos, testados, e publicados no PyPI como parte do processo de lançamento. Espera-se que tais plataformas sejam instaláveis usando-se apenas um ambiente Python ativo, já que todas as dependências estão disponíveis nessas plataformas.

Plataformas da camada 1 atualmente são:

Linux x86_64 (distributions compatible with the manylinux 2014 packaging specification).

macOS x86_64 (10.9 ou mais recente)

Windows 64 bit

Camada 2¶

Plataformas da camada 2 não são testadas previamente no desenvolvimento. No entanto, binários pré-compilados são construídos, testados, e publicados no PyPI como parte do processo de lançamento, e espera-se que esses pacotes possam ser instalados com apenas um ambiente Python ativo.

Plataformas da camada 2 atualmente são:

Linux i686 (distribuições compatíveis com a especificação de pacote manylinux 2014) para Python < 3.10

Windows 32 bit para Python < 3.10

Linux aarch64 (distribuições compatíveis com a especificação de pacotes manylinux 2014 <https://www.python.org/dev/peps/pep-0599/>)

Camada 3¶

Plataformas da camada 3 não são testadas previamente no desenvolvimento. Binários pré-compilados são construídos e publicados no PyPI como parte do processo de lançamento, mas sem nenhuma testagem. Eles podem não ser instaláveis com apenas um ambiente ativo Python e podem requerer um compilador de C/C++ ou programas adicionais para construir dependências direto das fontes, como parte do processo de instalação. Suporte para essas plataformas não é garantido.

Plataformas da camada 3 atualmente são:

Linux ppc64le (distribuições compatíveis com a especificação de pacotes manylinux 2014 <https://www.python.org/dev/peps/pep-0599/>)

Linux s390x (distribuições compatíveis com a especificação de pacotes manylinux 2014 <https://www.python.org/dev/peps/pep-0599/>)

macOS arm64 (10.15 ou mais recente)

Linux i686 (distribuições compatíveis com o manylinux 2014 packaging specification) para Python >= 3.10

Windows 32 bit para Python >= 3.10

Pronto para começar?…¶

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