Visualizar resultados

Versões dos pacotes

O código nesta página foi desenvolvido usando os seguintes requisitos. Recomendamos o uso dessas versões ou versões mais recentes.

qiskit[all]~=2.5.2

Plotar histograma

A função plot_histogram visualiza o resultado da amostragem de um circuito quântico em uma QPU.

Usando a saída das funções

Essa função retorna um objeto matplotlib.Figure. Quando a última linha de uma célula de código retorna esses objetos, os notebooks Jupyter os exibem abaixo da célula. Se você chamar essas funções em outros ambientes ou em scripts, será necessário exibir ou salvar as saídas explicitamente.

Há duas opções:

• Chame .show() no objeto retornado para abrir a imagem em uma nova janela (supondo que o backend matplotlib configurado seja interativo).
• Chame .savefig("out.png") para salvar a figura em out.png no diretório de trabalho atual. O método savefig() aceita um caminho, então você pode ajustar o local e o nome do arquivo onde está salvando a saída. Por exemplo, plot_state_city(psi).savefig("out.png").

Por exemplo, crie um estado de Bell de dois qubits:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit.primitives import StatevectorSampler as Sampler
from qiskit.transpiler import generate_preset_pass_manager

from qiskit.circuit import QuantumCircuit
from qiskit.visualization import plot_histogram

# Quantum circuit to make a Bell state
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()

pm = generate_preset_pass_manager(optimization_level=1)
isa_circuit = pm.run(bell)

# execute the quantum circuit
sampler = Sampler()
job = sampler.run([isa_circuit])
result = job.result()

print(result)

PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(), num_shots=1024, num_bits=2>)), metadata={'shots': 1024, 'circuit_metadata': {}})], metadata={'version': 2})

plot_histogram(result[0].data.meas.get_counts())

Opções ao plotar um histograma

Use as seguintes opções do plot_histogram para ajustar o gráfico de saída.

• legend: Fornece um rótulo para as execuções. Recebe uma lista de strings usadas para rotular os resultados de cada execução. Isso é mais útil ao plotar múltiplos resultados de execução no mesmo histograma

• sort: Ajusta a ordem das barras no histograma. Pode ser definido como ordem crescente com asc ou ordem decrescente com desc

• number_to_keep: Recebe um inteiro com o número de termos a exibir. Os demais são agrupados em uma única barra chamada "rest"

• color: Ajusta a cor das barras; recebe uma string ou uma lista de strings com as cores a usar nas barras de cada execução

• bar_labels: Define se os rótulos são exibidos acima das barras

• figsize: Recebe uma tupla com o tamanho em polegadas para a figura de saída

# Execute two-qubit Bell state again

job = sampler.run([isa_circuit], shots=1000)
second_result = job.result()

# Plot results with custom options
plot_histogram(
    [
        result[0].data.meas.get_counts(),
        second_result[0].data.meas.get_counts(),
    ],
    legend=["first", "second"],
    sort="desc",
    figsize=(15, 12),
    color=["orange", "black"],
    bar_labels=False,
)

Plotar resultados do Estimator

O Qiskit não possui uma função nativa para plotar resultados do Estimator, mas você pode usar o gráfico bar do Matplotlib para uma visualização rápida.

Para demonstrar, a célula a seguir estima os valores esperados de sete observáveis diferentes em um estado quântico.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator as Estimator
from qiskit.transpiler import generate_preset_pass_manager
from matplotlib import pyplot as plt

# Simple estimation experiment to create results
qc = QuantumCircuit(2)
qc.h(0)
qc.crx(1.5, 0, 1)

observables_labels = ["ZZ", "XX", "YZ", "ZY", "XY", "XZ", "ZX"]
observables = [SparsePauliOp(label) for label in observables_labels]

pm = generate_preset_pass_manager(optimization_level=1)
isa_circuit = pm.run(qc)
isa_observables = [
    operator.apply_layout(isa_circuit.layout) for operator in observables
]

# Reshape observable array for broadcasting
reshaped_ops = np.fromiter(isa_observables, dtype=object)
reshaped_ops = reshaped_ops.reshape((7, 1))

estimator = Estimator()
job = estimator.run([(isa_circuit, reshaped_ops)])
result = job.result()[0]
exp_val = job.result()[0].data.evs
print(result)

# Since the result array is structured as a 2D array where each element is a
# list containing a single value, you need to flatten the array.

# Plot using Matplotlib
plt.bar(observables_labels, exp_val.flatten())

PubResult(data=DataBin(evs=np.ndarray(<shape=(7, 1), dtype=float64>), stds=np.ndarray(<shape=(7, 1), dtype=float64>), shape=(7, 1)), metadata={'target_precision': 0.0, 'circuit_metadata': {}})

<BarContainer object of 7 artists>

A célula a seguir usa o erro padrão estimado de cada resultado e os adiciona como barras de erro. Consulte a documentação do gráfico bar para uma descrição completa do gráfico.

standard_error = job.result()[0].data.stds

_, ax = plt.subplots()
ax.bar(
    observables_labels,
    exp_val.flatten(),
    yerr=standard_error.flatten(),
    capsize=2,
)
ax.set_title("Expectation values (with standard errors)")

Text(0.5, 1.0, 'Expectation values (with standard errors)')