{ "cells": [ { "cell_type": "markdown", "id": "008d2ceb-f6fa-42f6-a7df-6bd604775278", "metadata": {}, "source": [ "---\n", "title: \"Comece com primitivas\"\n", "description: \"Como usar as primitivas Estimator e Sampler em Qiskit Runtime.\"\n", "---\n", "\n", "\n", "\n", "# Comece com primitivas\n", "\n", "\n", " A versão beta de um novo modelo de execução já está disponível. O modelo de execução direcionada oferece mais flexibilidade ao personalizar seu fluxo de trabalho de atenuação de erros. Consulte o guia [do modelo de execução direcionada](/docs/guides/directed-execution-model) para obter mais informações.\n", "\n", "\n", "\n", " Embora esta documentação use as primitivas de Qiskit Runtime, que permitem que você use os backends de IBM®, as primitivas podem ser executadas em qualquer provedor usando as [primitivas de backend](#backend). Além disso, você pode usar as primitivas *de referência* para executar em um simulador de vetor de estado local. Consulte [Simulação exata com primitivos Qiskit](/docs/guides/simulate-with-qiskit-sdk-primitives) para obter detalhes.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "b7e96291-0925-4d7f-81a8-a7738549477c", "metadata": {}, "source": [ "As etapas deste tópico descrevem como configurar primitivas, explorar as opções que podem ser usadas para configurá-las e invocá-las em um programa.\n", "\n", "\n", " Para usar as novas [portas fracionárias](./fractional-gates) compatíveis, defina `use_fractional_gates=True` ao solicitar um backend de uma instância `QiskitRuntimeService` . Por exemplo:\n", "\n", " ```python\n", " service = QiskitRuntimeService()\n", " fractional_gate_backend = service.least_busy(use_fractional_gates=True)\n", " ```\n", "\n", " Observe que esse é um recurso experimental e pode mudar no futuro.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "818a2b3d-3950-4a28-8e37-39959c56484b", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " O código desta página foi desenvolvido usando os seguintes requisitos.\n", " Recomendamos o uso dessas versões ou de versões mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.3.1\n", " qiskit-ibm-runtime~=0.45.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "bafa61f0-c049-4ee6-ac76-a0ed97e67caf", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Comece a usar o Estimador\n", "\n", "{/*Verified the v2 examples 2/29/24 - updated 10/29/24*/}\n", "\n", "\n", "\n", "### 1. Inicialize a conta\n", "\n", "Como o Qiskit Runtime Estimator é um serviço gerenciado, primeiro você precisa inicializar sua conta. Em seguida, você pode selecionar a QPU que deseja usar para calcular o valor de expectativa.\n", "\n", "Siga as etapas no [tópico Instalar e configurar](install-qiskit) se você ainda não tiver uma conta.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "71d62ba2-b1ba-405a-b304-5bdd7ec5e11b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ibm_fez\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, min_num_qubits=127\n", ")\n", "\n", "print(backend.name)" ] }, { "cell_type": "markdown", "id": "d894fbe3-3ea8-4db0-908e-95790b560ddb", "metadata": {}, "source": [ "\n", "\n", "### 2. Crie um circuito e um observável\n", "\n", "Você precisa de pelo menos um circuito e um observável como entradas para a primitiva Estimator.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "c0ad8982-d19b-46d4-8a2d-dd30357c0e52", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Observable: ['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII...', ...]\n" ] } ], "source": [ "from qiskit.circuit.library import qaoa_ansatz\n", "from qiskit.quantum_info import SparsePauliOp\n", "\n", "entanglement = [tuple(edge) for edge in backend.coupling_map.get_edges()]\n", "observable = SparsePauliOp.from_sparse_list(\n", " [(\"ZZ\", [i, j], 0.5) for i, j in entanglement],\n", " num_qubits=backend.num_qubits,\n", ")\n", "circuit = qaoa_ansatz(observable, reps=2)\n", "# the circuit is parametrized, so we will define the parameter values for execution\n", "param_values = [0.1, 0.2, 0.3, 0.4]\n", "\n", "print(f\">>> Observable: {observable.paulis}\")" ] }, { "cell_type": "markdown", "id": "84b42c6f-d80e-4cff-8e34-03affa566a97", "metadata": {}, "source": [ "O circuito e o observável precisam ser transformados para usar somente as instruções compatíveis com a QPU (chamadas de circuitos *de arquitetura de conjunto de instruções (ISA)* ). Usaremos o transpilador para fazer isso.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "abefc665-24a7-466e-a9ec-67cac6a50ebd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Circuit ops (ISA): OrderedDict([('rz', 4472), ('sx', 1884), ('cz', 1120)])\n" ] } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "pm = generate_preset_pass_manager(optimization_level=1, backend=backend)\n", "isa_circuit = pm.run(circuit)\n", "isa_observable = observable.apply_layout(isa_circuit.layout)\n", "print(f\">>> Circuit ops (ISA): {isa_circuit.count_ops()}\")" ] }, { "cell_type": "markdown", "id": "b53e9ab3-7d87-4dd5-b362-138b24cfa73b", "metadata": {}, "source": [ "\n", "\n", "### 3. Inicializar um estimador d Qiskit Runtime\n", "\n", "Ao inicializar o Estimador, use o `mode` parâmetro para especificar o modo em que deseja que ele seja executado. Os valores possíveis são `batch`, `session`, ou `backend` objetos para os modos de execução em lote, sessão e tarefa, respectivamente. Para obter mais informações, consulte [Introdução aos modos de execução do Qiskit Runtime](execution-modes).\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "961508db-e534-4fc9-970d-7babcd6c39ef", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", "\n", "estimator = Estimator(mode=backend)" ] }, { "cell_type": "markdown", "id": "59b13a43-0c9f-4fdb-a379-af5115c153e1", "metadata": {}, "source": [ "\n", "\n", "### 4. Invoque o Estimador e obtenha resultados\n", "\n", "Em seguida, invoque o método `run()` para calcular os valores de expectativa para os circuitos de entrada e os observáveis. Os conjuntos de valores de parâmetros de circuito, observáveis e opcionais são inseridos como tuplas *primitivas de bloco unificado* ( PUB ).\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "f1a60bad-cf09-4136-aa1a-4482759b3aea", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: d76cm768faus73f14eg0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ ">>> Job Status: QUEUED\n" ] } ], "source": [ "job = estimator.run([(isa_circuit, isa_observable, param_values)])\n", "print(f\">>> Job ID: {job.job_id()}\")\n", "print(f\">>> Job Status: {job.status()}\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "c817cce5-4686-43d2-89a1-ed0842d8ace3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(), stds=np.ndarray(), ensemble_standard_error=np.ndarray()), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})\n", " > Expectation value: 28.628978416256825\n", " > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}\n" ] } ], "source": [ "result = job.result()\n", "print(f\">>> {result}\")\n", "print(f\" > Expectation value: {result[0].data.evs}\")\n", "print(f\" > Metadata: {result[0].metadata}\")" ] }, { "cell_type": "markdown", "id": "64e2e09f-8528-4088-897b-1529b451ab1e", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Comece a usar o Sampler\n", "\n", "\n", "\n", "### 1. Inicialize a conta\n", "\n", "Como o Qiskit Runtime Sampler é um serviço gerenciado, primeiro você precisa inicializar sua conta. Em seguida, você pode selecionar a QPU que deseja usar para calcular o valor de expectativa.\n", "\n", "Siga as etapas no [tópico Instalar e configurar](install-qiskit) se você ainda não tiver uma conta configurada.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "b40504d7-aee5-4b30-98b1-265e70bece8d", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, min_num_qubits=127\n", ")" ] }, { "cell_type": "markdown", "id": "73374fbc-d3b6-4d2d-84c6-edf85b43ea25", "metadata": {}, "source": [ "\n", "\n", "### 2. Crie um circuito\n", "\n", "Você precisa de pelo menos um circuito como entrada para o primitivo Sampler.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "dfe23a34-2ea9-48af-bd1d-c7e3185aa80c", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from qiskit.circuit.library import efficient_su2\n", "\n", "circuit = efficient_su2(127, entanglement=\"linear\")\n", "circuit.measure_all()\n", "# The circuit is parametrized, so we will define the parameter values for execution\n", "param_values = np.random.rand(circuit.num_parameters)" ] }, { "cell_type": "markdown", "id": "6cf08ef6-34d3-42e6-8cb3-391b60217289", "metadata": {}, "source": [ "Use o transpilador para obter um circuito ISA.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "062bd89b-b13e-46d0-96b6-6c84b2131415", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Circuit ops (ISA): OrderedDict([('sx', 3088), ('rz', 3036), ('cz', 1089), ('measure', 127), ('barrier', 1)])\n" ] } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "pm = generate_preset_pass_manager(optimization_level=1, backend=backend)\n", "isa_circuit = pm.run(circuit)\n", "print(f\">>> Circuit ops (ISA): {isa_circuit.count_ops()}\")" ] }, { "cell_type": "markdown", "id": "cf0f2c0a-8574-45c6-a43b-1a99eac81279", "metadata": {}, "source": [ "\n", "\n", "### 3. Inicialize o Sampler do Qiskit Runtime\n", "\n", "Ao inicializar o Sampler, use o `mode` parâmetro para especificar o modo em que deseja que ele seja executado. Os valores possíveis são `batch`, `session`, ou `backend` objetos para os modos de execução em lote, sessão e tarefa, respectivamente. Para obter mais informações, consulte [Introdução aos modos de execução do Qiskit Runtime](/docs/guides/execution-modes). Observe que os usuários do Open Plan não podem enviar trabalhos de sessão.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "a2b80dca-dff8-49f9-8154-e2cb0b768507", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import SamplerV2 as Sampler\n", "\n", "sampler = Sampler(mode=backend)" ] }, { "cell_type": "markdown", "id": "f35972bf-17d3-40be-852b-9e56615c7c3c", "metadata": {}, "source": [ "\n", "\n", "### 4. Invoque o Sampler e obtenha resultados\n", "\n", "Em seguida, invoque o método `run()` para gerar a saída. O circuito e os conjuntos de valores de parâmetros opcionais são inseridos como tuplas *primitivas de bloco unificado* ( PUB ).\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "e52e6a96-dc23-4f76-8152-b54514a99dfb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: d76cmme8faus73f14fi0\n", ">>> Job Status: QUEUED\n" ] } ], "source": [ "job = sampler.run([(isa_circuit, param_values)])\n", "print(f\">>> Job ID: {job.job_id()}\")\n", "print(f\">>> Job Status: {job.status()}\")" ] }, { "cell_type": "code", "execution_count": 12, "id": "4543fac5-abdc-4440-a1a2-d32aabe135d6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "First ten results for the 'meas' output register: ['1001101111100100101100100000100000001000110000010000011010111000000101100000110111010010100001010101011100110100100101000000011', '0000010001011111011000010001101100110010110001111010110001001000000100110111011111010011000001011100110111111010001010000000000', '0000100111000111110111110010000000101010100011110111110111000110101000100000100001000111000001110000000101000011111100100000000', '0100111111100001011101101101010010101100010001101110101010010100000011101100010100100011001000010011010101011010000000100010011', '1111000001001101001011010010000100010010010101010111001000100000100000010110111011010101000101011110001100101100011110000111110', '1100000111101011001001110010001000001000111111010101000011001000010101100001011000000100000000011010101001111110100110100010100', '1000111001100001100000111100101111100011100110101000100110001111010010111110011010010010010101010011100101001101111101000100000', '0111101010100001110000100010010100101010100010010101011010011001101100011001010000000100111010010001100011001010000000101001111', '0100001110000101111111101111010111000000000101011010100111001101001001001000101001100010101010000001001001000000100000101010101', '1101010100001000000100000110110101000000000000000100100001100100000000100000011101001100110110011100000001100111110010001011100']\n" ] } ], "source": [ "result = job.result()\n", "\n", "# Get results for the first (and only) PUB\n", "pub_result = result[0]\n", "print(\n", " f\"First ten results for the 'meas' output register: {pub_result.data.meas.get_bitstrings()[:10]}\"\n", ")" ] }, { "cell_type": "markdown", "id": "ec04840d-5fa1-4716-b585-48aa371f67d4", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Comece com os primitivos de back-end\n", "\n", "Diferentemente das primitivas específicas do provedor, as primitivas de backend são implementações genéricas que podem ser usadas com um objeto arbitrário `backend` arbitrário, desde que ele implemente a [`Backend`](/docs/api/qiskit/qiskit.providers.Backend) interface.\n", "\n", "* A primitiva Sampler pode ser executada com qualquer provedor usando [`qiskit.primitives.BackendSamplerV2`](/docs/api/qiskit/qiskit.primitives.BackendSamplerV2).\n", "* A primitiva do Estimator pode ser executada com qualquer provedor usando [`qiskit.primitives.BackendEstimatorV2`](../api/qiskit/qiskit.primitives.BackendEstimatorV2).\n", "\n", "Alguns provedores implementam primitivas nativamente. Consulte a [página do ecossistema Qiskit](https://qiskit.github.io/ecosystem#provider) para obter detalhes.\n", "\n" ] }, { "cell_type": "markdown", "id": "9d78f323-1c58-4360-8880-59179c8a14b7", "metadata": {}, "source": [ "\n", "\n", "### Exemplo: BackendEstimator\n", "\n", "```python\n", "from qiskit.primitives import BackendEstimatorV2\n", "from import QiskitProvider\n", "\n", "provider = QiskitProvider()\n", "backend = provider.get_backend('backend_name')\n", "estimator = BackendEstimatorV2(backend)\n", "```\n", "\n", "\n", "\n", "### Exemplo: BackendSampler\n", "\n", "```python\n", "from qiskit.primitives import BackendSamplerV2\n", "from import QiskitProvider\n", "\n", "provider = QiskitProvider()\n", "backend = provider.get_backend('backend_name')\n", "sampler = BackendSamplerV2(backend)\n", "```\n", "\n" ] }, { "cell_type": "markdown", "id": "e620a7b2-233d-4e0d-8a42-ee4eda3ccd8d", "metadata": {}, "source": [ "\n", "\n", "### Semelhanças e diferenças entre primitivas de backend e Runtime\n", "\n", "* As entradas e saídas de [`qiskit.primitives.BackendSamplerV2`](/docs/api/qiskit/qiskit.primitives.BackendSamplerV2) e [`qiskit.primitives.BackendEstimatorV2`](../api/qiskit/qiskit.primitives.BackendEstimatorV2) seguem o mesmo formato de PUB que as primitivas em Qiskit Runtime. Consulte [Entradas e saídas primitivas](primitive-input-output) para obter detalhes.\n", " No entanto, pode haver diferenças nos campos dos metadados retornados.\n", "\n", "* A classe [`qiskit.primitives.BackendEstimatorV2`](/docs/api/qiskit/qiskit.primitives.BackendEstimatorV2) a classe não oferece implementações de medição ou mitigação de erro de porta prontas para uso, pois as primitivas de backend são projetadas para serem executadas localmente na máquina do usuário.\n", "\n", "* A classe [`qiskit.primitives.BackendSamplerV2`](/docs/api/qiskit/qiskit.primitives.BackendSamplerV2) requer um backend compatível com a opção `memory` .\n", "\n", "* As interfaces primitivas de backend expõem [`SamplerV2`](/docs/api/qiskit/qiskit.primitives.BackendSamplerV2) e [`EstimatorV2`](/docs/api/qiskit/qiskit.primitives.BackendEstimatorV2) `Options` que são diferentes das implementações de tempo de execução.\n", "\n" ] }, { "cell_type": "markdown", "id": "d38dd409-e0d8-4749-bb22-58ae9a53d26a", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Saiba como [testar localmente](local-testing-mode) antes de executar em computadores quânticos.\n", " * Revise [exemplos](/docs/guides/primitives-examples) detalhados de primitivas.\n", " * Pratique com primitivos trabalhando na [lição sobre função de custo](/learning/courses/variational-algorithm-design/cost-functions) em IBM Quantum Learning.\n", " * Saiba como transpilar localmente na seção [Transpilar](transpile/).\n", " * Experimente o guia [Comparar configurações do transpiler](/docs/guides/circuit-transpilation-settings#compare-transpiler-settings).\n", " * Aprenda a [usar as opções primitivas](runtime-options-overview).\n", " * Veja a API para as opções [Sampler](/docs/api/qiskit-ibm-runtime/options-sampler-options) e [Estimator](/docs/api/qiskit-ibm-runtime/options-estimator-options).\n", " * Leia [Migrar para V2 primitives](/docs/guides/v2-primitives).\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" } }, "nbformat": 4, "nbformat_minor": 4 }