{ "cells": [ { "cell_type": "markdown", "id": "828c3465-62a7-4c42-b376-e3ec32f67595", "metadata": {}, "source": [ "---\n", "title: \"Ajudante de aprendizagem de ruídos\"\n", "description: \"Comece a usar o programa auxiliar de aprendizado de ruído para salvar os modelos de ruído criados durante a execução de cargas de trabalho no qiskit-ibm-runtime\"\n", "---\n", "\n", "\n", "\n", "# Ajudante de aprendizagem de ruídos\n", "\n" ] }, { "cell_type": "markdown", "id": "40a246f5-4efd-4fb0-861b-c4e013c1572a", "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.4.1\n", " qiskit-ibm-runtime~=0.47.0\n", " samplomatic~=0.18.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "cce93074-df51-4760-9fce-5a520c3bc59a", "metadata": {}, "source": [ "As técnicas de mitigação de erros [PEA](/docs/guides/error-mitigation-and-suppression-techniques#pea) e [PEC](/docs/guides/error-mitigation-and-suppression-techniques#pec) utilizam, ambas, um componente de aprendizagem de ruído baseado no [modelo de ruído de](https://arxiv.org/abs/2201.09866) Pauli-Lindblad, que é normalmente gerenciado durante a execução após o envio de um ou mais trabalhos por meio de `qiskit-ibm-runtime` sem qualquer acesso local ao modelo de ruído ajustado. No entanto, conforme disponível em `qiskit-ibm-runtime`v0.27.1, foram criadas uma [`NoiseLearner`](/docs/api/qiskit-ibm-runtime/noise-learner) classe e uma classe [`NoiseLearnerOptions`](/docs/api/qiskit-ibm-runtime/options-noise-learner-options) associada para obter os resultados dessas experiências de aprendizado com ruído. Esses resultados podem então ser armazenados localmente como um `NoiseLearnerResult` e utilizados como dados de entrada em experimentos posteriores. Esta página oferece uma visão geral sobre como utilizá-la e as opções disponíveis.\n", "\n", "Além disso, a partir da versão `qiskit-ibm-runtime`v0.47.0, há uma nova `NoiseLearnerV3` classe compatível com a primitiva Executor. Esta nova versão, que também faz parte do [modelo de execução direcionada](/docs/guides/directed-execution-model), permite especificar explicitamente as camadas que você deseja treinar.\n", "\n", "\n", " `NoiseLearner` funciona apenas com o EstimatorV2 e `NoiseLearnerV3` funciona apenas com o Executor.\n", "\n", "\n", "\n", "\n", "## `NoiseLearner`\n", "\n", "\n", "\n", "### Visão geral\n", "\n", "A `NoiseLearner` aula realiza experimentos que caracterizam processos de ruído com base no modelo de ruído de Pauli-Lindblad para um (ou mais) circuitos. Ele possui um `run()` método que executa os experimentos de aprendizado e recebe como entrada uma lista de circuitos ou um objeto [PUB](/docs/guides/primitive-input-output), retornando um objeto `NoiseLearnerResult` que contém os canais de ruído aprendidos e metadados sobre o(s) trabalho(s) enviado(s). Abaixo está um trecho de código que demonstra como usar o programa auxiliar.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "d9a5320d-8ec6-483a-9ecf-931b0f5f5d13", "metadata": {}, "outputs": [], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.transpiler import CouplingMap\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2\n", "from qiskit_ibm_runtime.noise_learner import NoiseLearner\n", "from qiskit_ibm_runtime.options import (\n", " NoiseLearnerOptions,\n", " ResilienceOptionsV2,\n", " EstimatorOptions,\n", ")\n", "\n", "# Build a circuit with two entangling layers\n", "num_qubits = 27\n", "edges = list(CouplingMap.from_line(num_qubits, bidirectional=False))\n", "even_edges = edges[::2]\n", "odd_edges = edges[1::2]\n", "\n", "circuit = QuantumCircuit(num_qubits)\n", "for pair in even_edges:\n", " circuit.cx(pair[0], pair[1])\n", "for pair in odd_edges:\n", " circuit.cx(pair[0], pair[1])\n", "\n", "# Choose a backend to run on\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy()\n", "\n", "# Transpile the circuit for execution\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "circuit_to_learn = pm.run(circuit)\n", "\n", "# Instantiate a NoiseLearner object and execute the noise learning program\n", "learner = NoiseLearner(mode=backend)\n", "job = learner.run([circuit_to_learn])\n", "noise_model = job.result()" ] }, { "cell_type": "markdown", "id": "ef141d65-d14d-4e2b-9813-b8766e29fdb9", "metadata": {}, "source": [ "O resultado `NoiseLearnerResult.data` é uma lista de [`LayerError`](/docs/api/qiskit-ibm-runtime/results-layer-error) objetos que contém o [modelo de ruído](https://arxiv.org/abs/2201.09866) para cada camada de entrelaçamento individual pertencente ao(s) circuito(s) alvo. Cada uma delas `LayerError` armazena as informações da camada, na forma de um circuito e de um conjunto de rótulos de qubits, juntamente com o [`PauliLindbladError`](/docs/api/qiskit-ibm-runtime/results-pauli-lindblad-error) modelo de ruído que foi aprendido para a camada em questão.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "a9be8ff1-7494-407c-853c-50d471a2f55f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Noise learner result contains 2 entries and has the following type:\n", " \n", "\n", "Each element of `NoiseLearnerResult` then contains an object of type:\n", " \n", "\n", "And each of these `LayerError` objects possess data on the generators for the error channel: \n", "['IIIIIIIIIIIIIIIIIIIIIIIIIIX', 'IIIIIIIIIIIIIIIIIIIIIIIIIIY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIIZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIXI',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIXX', 'IIIIIIIIIIIIIIIIIIIIIIIIIXY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIXZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIYI',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIYX', 'IIIIIIIIIIIIIIIIIIIIIIIIIYY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIYZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIZI',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIZX', 'IIIIIIIIIIIIIIIIIIIIIIIIIZY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIIIIIIIIXII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIXIX', 'IIIIIIIIIIIIIIIIIIIIIIIIXIY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIXIZ', 'IIIIIIIIIIIIIIIIIIIIIIIIYII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIYIX', 'IIIIIIIIIIIIIIIIIIIIIIIIYIY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIYIZ', 'IIIIIIIIIIIIIIIIIIIIIIIIZII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIZIX', 'IIIIIIIIIIIIIIIIIIIIIIIIZIY',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIIZIZ', 'IIIIIIIIIIIIIIIIIIIIIIIXIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIIYIII', 'IIIIIIIIIIIIIIIIIIIIIIIZIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIXIIII', 'IIIIIIIIIIIIIIIIIIIIIIXXIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIXYIII', 'IIIIIIIIIIIIIIIIIIIIIIXZIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIYIIII', 'IIIIIIIIIIIIIIIIIIIIIIYXIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIYYIII', 'IIIIIIIIIIIIIIIIIIIIIIYZIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIZIIII', 'IIIIIIIIIIIIIIIIIIIIIIZXIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIIZYIII', 'IIIIIIIIIIIIIIIIIIIIIIZZIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIXIIIII', 'IIIIIIIIIIIIIIIIIIIIIXXIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIXYIIII', 'IIIIIIIIIIIIIIIIIIIIIXZIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIYIIIII', 'IIIIIIIIIIIIIIIIIIIIIYXIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIYYIIII', 'IIIIIIIIIIIIIIIIIIIIIYZIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIZIIIII', 'IIIIIIIIIIIIIIIIIIIIIZXIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIIZYIIII', 'IIIIIIIIIIIIIIIIIIIIIZZIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIXIIIIII', 'IIIIIIIIIIIIIIIIIIIIXXIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIXYIIIII', 'IIIIIIIIIIIIIIIIIIIIXZIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIYIIIIII', 'IIIIIIIIIIIIIIIIIIIIYXIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIYYIIIII', 'IIIIIIIIIIIIIIIIIIIIYZIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIZIIIIII', 'IIIIIIIIIIIIIIIIIIIIZXIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIIZYIIIII', 'IIIIIIIIIIIIIIIIIIIIZZIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIXIIIIIII', 'IIIIIIIIIIIIIIIIIIIXXIIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIXYIIIIII', 'IIIIIIIIIIIIIIIIIIIXZIIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIYIIIIIII', 'IIIIIIIIIIIIIIIIIIIYXIIIIII',\n", " 'IIIIIIIIIIIIIIIIIIIYYIIIIII', 'IIIIIIIIIIIIIIIIIIIYZIIIIII', ...]\n", "\n", "Along with the error rates: \n", "[5.9e-04 5.3e-04 5.7e-04 ... 0.0e+00 1.0e-05 0.0e+00]\n", "\n" ] } ], "source": [ "import numpy\n", "\n", "print(\n", " f\"Noise learner result contains {len(noise_model.data)} entries\"\n", " f\" and has the following type:\\n {type(noise_model)}\\n\"\n", ")\n", "print(\n", " f\"Each element of `NoiseLearnerResult` then contains\"\n", " f\" an object of type:\\n {type(noise_model.data[0])}\\n\"\n", ")\n", "# Results are truncated\n", "with numpy.printoptions(threshold=200):\n", " print(\n", " f\"And each of these `LayerError` objects possess\"\n", " f\" data on the generators for the error channel: \\n\"\n", " f\"{noise_model.data[0].error.generators}\\n\"\n", " )\n", "# Results are truncated\n", "with numpy.printoptions(threshold=200):\n", " print(\n", " f\"Along with the error rates: \\n{noise_model.data[0].error.rates}\\n\"\n", " )" ] }, { "cell_type": "markdown", "id": "faa3892e-30a5-48f7-87dd-39ab1b0846d9", "metadata": {}, "source": [ "O atributo `LayerError.error` do resultado do aprendizado de ruído contém os geradores e as taxas de erro do modelo Pauli Lindblad ajustado, que tem a forma\n", "\n", "$\\Lambda(\\rho) = \\exp{\\sum_j r_j \\left(P_j \\rho P_j^\\dagger - \\rho\\right)},$\n", "\n", "onde $r_j$ são os operadores `LayerError.rates` e $P_j$ são os operadores Pauli especificados em `LayerError.generators`.\n", "\n" ] }, { "cell_type": "markdown", "id": "fc0000e6-e77a-4b87-a9ee-262f904953fc", "metadata": {}, "source": [ "\n", "\n", "### Opções de aprendizagem de ruído\n", "\n", "Você pode escolher entre várias opções para inserir ao instanciar um `NoiseLearner` objeto. Essas opções estão encapsuladas na `qiskit_ibm_runtime.options.NoiseLearnerOptions` classe e incluem a possibilidade de especificar o número máximo de camadas a serem aprendidas, o número de randomizações e a estratégia de twirling, entre outras. Consulte a documentação da [`NoiseLearnerOptions`](/docs/api/qiskit-ibm-runtime/options-noise-learner-options) API para obter informações detalhadas.\n", "\n", "A seguir, apresentamos um exemplo simples que mostra como usar o `NoiseLearnerOptions` em um `NoiseLearner` experimento:\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "fcd1bd93-405d-4cfb-a5d1-bb646404aa58", "metadata": {}, "outputs": [], "source": [ "# Build a GHZ circuit\n", "circuit = QuantumCircuit(10)\n", "circuit.h(0)\n", "circuit.cx(range(0, 9), range(1, 10))\n", "# Choose a backend to run on\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy()\n", "\n", "# Transpile the circuit for execution\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "circuit_to_run = pm.run(circuit_to_learn)\n", "\n", "# Instantiate a NoiseLearnerOptions object\n", "learner_options = NoiseLearnerOptions(\n", " max_layers_to_learn=3, num_randomizations=32, twirling_strategy=\"all\"\n", ")\n", "\n", "# Instantiate a NoiseLearner object and execute the noise learning program\n", "learner = NoiseLearner(mode=backend, options=learner_options)\n", "job = learner.run([circuit_to_run])\n", "noise_model = job.result()" ] }, { "cell_type": "markdown", "id": "d952d0cc-497b-45ae-a55e-2b611ebbe4a3", "metadata": {}, "source": [ "\n", "\n", "### Modelo de ruído de entrada para uma primitiva\n", "\n", "O modelo de ruído aprendido no circuito também pode ser usado como entrada para a primitiva IBM Quantum`EstimatorV2` . Isso pode ser passado para a primitiva de várias maneiras diferentes. Os três exemplos a seguir mostram como é possível passar o modelo de ruído diretamente para o `estimator.options` atributo, utilizando um `ResilienceOptionsV2` objeto antes de instanciar uma primitiva Estimator e passando um dicionário formatado adequadamente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "9826013a-f9fd-4d72-baa7-dc5395b81007", "metadata": {}, "outputs": [], "source": [ "# Pass the noise model to the `estimator.options` attribute directly\n", "estimator = EstimatorV2(mode=backend)\n", "estimator.options.resilience.layer_noise_model = noise_model" ] }, { "cell_type": "code", "execution_count": 5, "id": "7ab10595-5c20-4954-9001-70b8879926b4", "metadata": {}, "outputs": [], "source": [ "# Specify options through a ResilienceOptionsV2 object\n", "resilience_options = ResilienceOptionsV2(layer_noise_model=noise_model)\n", "estimator_options = EstimatorOptions(resilience=resilience_options)\n", "estimator = EstimatorV2(mode=backend, options=estimator_options)" ] }, { "cell_type": "code", "execution_count": 6, "id": "17b1f8de-fe14-4998-898b-ecd409a5efd3", "metadata": {}, "outputs": [], "source": [ "# Specify options by using a dictionary\n", "options_dict = {\n", " \"resilience_level\": 2,\n", " \"resilience\": {\"layer_noise_model\": noise_model},\n", "}\n", "\n", "estimator = EstimatorV2(mode=backend, options=options_dict)" ] }, { "cell_type": "markdown", "id": "8c167b65-2e9a-41b9-b593-edfe80a2fde4", "metadata": {}, "source": [ "Depois que o modelo de ruído for passado para o `EstimatorV2` objeto, ele poderá ser usado para executar cargas de trabalho e realizar a mitigação de erros normalmente.\n", "\n" ] }, { "cell_type": "markdown", "id": "dad71939-7fe2-42f0-90fe-6974fe0854e7", "metadata": {}, "source": [ "\n", "\n", "## NoiseLearnerV3\n", "\n", "\n", "\n", "### Visão geral\n", "\n", "Assim como `NoiseLearner`, a `NoiseLearnerV3` classe realiza experimentos que caracterizam processos de ruído com base em um modelo de ruído de Pauli-Lindblad para um ou mais circuitos. Seu `run()` método recebe uma lista de instruções, cada uma das quais deve ser uma estrutura com anotação Twirled [`BoxOp`](/docs/api/qiskit/qiskit.circuit.BoxOp) contendo operações [ISA](/docs/guides/transpile#instruction-set-architecture).\n", "\n", "O resultado de uma `NoiseLearnerV3` tarefa contém uma lista de [`NoiseLearnerV3Result`](/docs/api/qiskit-ibm-runtime/results-noise-learner-v3-result) objetos, um para cada instrução de entrada.\n", "O código a seguir mostra como usar o programa auxiliar.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "0bbd2c21-6045-4954-aee9-339e6b060805", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 3 unique layers\n", "Each instruction is of type \n", "And has annotations: [Twirl(group='pauli', dressing='left', decomposition='rzsx'), InjectNoise(ref='r789B', modifier_ref='', site='before')]\n" ] } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.transpiler import CouplingMap\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService, Executor\n", "from qiskit_ibm_runtime.noise_learner_v3 import NoiseLearnerV3\n", "from samplomatic.transpiler import generate_boxing_pass_manager\n", "from samplomatic.utils import find_unique_box_instructions\n", "\n", "\n", "# Build a circuit with two entangling layers\n", "num_qubits = 27\n", "edges = list(CouplingMap.from_line(num_qubits, bidirectional=False))\n", "even_edges = edges[::2]\n", "odd_edges = edges[1::2]\n", "\n", "circuit = QuantumCircuit(num_qubits)\n", "for pair in even_edges:\n", " circuit.cx(pair[0], pair[1])\n", "for pair in odd_edges:\n", " circuit.cx(pair[0], pair[1])\n", "\n", "# Choose a backend to run on\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy()\n", "\n", "# Transpile the circuit for execution\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "isa_circuit = pm.run(circuit)\n", "\n", "# Run the boxing pass manager to group instructions into annotated boxes\n", "boxing_pm = generate_boxing_pass_manager(\n", " enable_gates=True,\n", " enable_measures=False,\n", " inject_noise_targets=\"gates\", # no measurement mitigation\n", " inject_noise_strategy=\"uniform_modification\",\n", ")\n", "boxed_circuit = boxing_pm.run(isa_circuit)\n", "\n", "# Find unique boxed instructions\n", "unique_box_instructions = find_unique_box_instructions(boxed_circuit.data)\n", "print(f\"Found {len(unique_box_instructions)} unique layers\")\n", "print(\n", " f\"Each instruction is of type {type(unique_box_instructions[0].operation)}\"\n", ")\n", "print(\n", " f\"And has annotations: {unique_box_instructions[0].operation.annotations}\"\n", ")\n", "\n", "# Instantiate a NoiseLearnerV3 object and execute the noise learning program\n", "learner = NoiseLearnerV3(backend)\n", "learner.options.shots_per_randomization = 128\n", "learner.options.num_randomizations = 32\n", "learner_job = learner.run(unique_box_instructions)\n", "learner_result = learner_job.result()" ] }, { "cell_type": "markdown", "id": "937986c1-b08d-4218-ae5d-c9dbfbf4a0cf", "metadata": {}, "source": [ "O resultado da função é uma lista de `NoiseLearnerV3Result` objetos, um para cada conjunto de instruções entre colchetes. `NoiseLearnerV3Result` possui um `to_pauli_lindblad_map()` método que retorna um [`PauliLindbladMap`](/docs/api/qiskit/qiskit.quantum_info.PauliLindbladMap) objeto, o qual possui métodos para extrair os geradores, as taxas de erro e muito mais.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "4a9b686b-cf8d-4986-8fff-83eedda1f2c1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The Noise learner V3 result contains 3 entries and each has the following type:\n", " \n", "\n", "After converting to PauliLindbladMap, you can extract data on the generators for the error channel (truncated to 3): \n", "\n", "\n", "Along with the error rates (truncated to 3): \n", "[0.00026 0.00032 0.00023]\n", "\n" ] } ], "source": [ "print(\n", " f\"The Noise learner V3 result contains {len(learner_result)} entries\"\n", " f\" and each has the following type:\\n {type(learner_result[0])}\\n\"\n", ")\n", "noise_map = learner_result[0].to_pauli_lindblad_map()\n", "print(\n", " f\"After converting to PauliLindbladMap, you can extract data \"\n", " f\" on the generators for the error channel \"\n", " f\"(truncated to 3): \\n{noise_map.generators()[:3]}\\n\"\n", ")\n", "with numpy.printoptions(threshold=20):\n", " print(\n", " f\"Along with the error rates \"\n", " f\"(truncated to 3): \\n{noise_map.rates[:3]}\\n\"\n", " )" ] }, { "cell_type": "markdown", "id": "baa61d6a-7efc-498b-bccd-260871e174df", "metadata": {}, "source": [ "\n", "\n", "### Opções de aprendizagem de ruído\n", "\n", "`NoiseLearnerV3` oferece várias opções, incluindo o número de randomizações e a profundidade do par de camadas, entre outras. Assim como nas primitivas, você pode definir as opções durante ou após a instanciação do `NoiseLearnerV3` objeto. O exemplo de código anterior mostrou como definir as opções `shots_per_randomization` e `num_randomizations` . Consulte a documentação da [`NoiseLearnerV3Options`](/docs/api/qiskit-ibm-runtime/options-models-noise-learner-v3-options) API para obter informações detalhadas.\n", "\n" ] }, { "cell_type": "markdown", "id": "e76e997d-506f-4607-a89a-e4723c640a44", "metadata": {}, "source": [ "\n", "\n", "### Insira um modelo de ruído no Executor\n", "\n", "O Executor segue as intenções de projeto especificadas nas anotações do circuito (na forma de um samplex) e nas opções. `InjectNoise` é a anotação para especificar onde injetar ruído, e o `pauli_lindblad_maps` argumento `samplex` especifica qual mapa de ruído deve ser usado.\n", "\n", "O circuito do exemplo anterior passa pelo gerenciador de passagens de encaixotamento, que agrupa instruções em caixas anotadas. O código relevante foi incluído aqui para facilitar a compreensão.\n", "\n", "* `inject_noise_targets=”gates”` especifica que as `InjectNoise` anotações devem ser adicionadas às caixas que contêm elementos de entrelaçamento.\n", "* `inject_noise_strategy=\"uniform_modification\"` especifica que se atribua o mesmo `ref` e `modifier_ref` a todas as caixas equivalentes com `InjectNoise` anotações.\n", " * `InjectNoise.ref` é um identificador único usado para atribuir um modelo de ruído a essa caixa.\n", " * `InjectNoise.modifier_ref` permite ajustar o modelo de ruído atribuído a uma caixa por meio de fatores multiplicativos.\n", "\n", "```python\n", "boxing_pm = generate_boxing_pass_manager(\n", " enable_gates=True,\n", " enable_measures=False,\n", " inject_noise_targets=\"gates\", # no measurement mitigation\n", " inject_noise_strategy=\"uniform_modification\",\n", ")\n", "```\n", "\n", "O circuito do exemplo anterior contém três caixas, duas das quais contêm `InjectNoise` anotações com atributos diferentes `ref` (uma vez que não são equivalentes).\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "3b86853b-6766-4cf6-9a6b-2ea1008aea42", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Annotations of box #0: [Twirl(group='pauli', dressing='left', decomposition='rzsx'), InjectNoise(ref='r789B', modifier_ref='r789B', site='before')]\n", "\n", "Annotations of box #1: [Twirl(group='pauli', dressing='left', decomposition='rzsx'), InjectNoise(ref='r054B', modifier_ref='r054B', site='before')]\n", "\n", "Annotations of box #2: [Twirl(group='pauli', dressing='right', decomposition='rzsx')]\n", "\n" ] } ], "source": [ "# box_circuit comes from the example above\n", "for idx, instruction in enumerate(boxed_circuit):\n", " # The `InjectNoise` annotation defines which boxes to inject noise.\n", " print(f\"Annotations of box #{idx}: {instruction.operation.annotations}\\n\")" ] }, { "cell_type": "markdown", "id": "3ab1e503-b36a-46bd-b5d1-2735c3d0a82d", "metadata": {}, "source": [ "O resultado da `NoiseLearnerV3` tarefa deve ser convertido em um dicionário antes de ser passado para o Executor. As chaves deste dicionário são os `InjectNoise.ref` atributos, e os valores são os mapas de ruído correspondentes. Este mapeamento indica ao Executor quais modelos de ruído devem ser injetados e em que pontos.\n", "\n", "O código a seguir mostra como pegar o circuito e o `NoiseLearnerV3` resultado do exemplo anterior e passá-los para o Executor, que irá gerar as variantes do circuito com os modelos de ruído injetados e executá-las no hardware.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "96d59082-7adc-482a-b57f-0f7a5c3eb217", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime.quantum_program import QuantumProgram\n", "from samplomatic import build\n", "\n", "# Generate a quantum program\n", "program = QuantumProgram(shots=1000)\n", "\n", "# Build the template circuit and samplex pair\n", "template_circuit, samplex = build(boxed_circuit)\n", "\n", "# Convert the NoiseLearnerV3 result to a dictionary\n", "noise_maps = learner_result.to_dict(\n", " instructions=unique_box_instructions, require_refs=False\n", ")\n", "\n", "# Append the samplex item and execute\n", "program.append_samplex_item(\n", " template_circuit,\n", " samplex=samplex,\n", " samplex_arguments={\n", " \"pauli_lindblad_maps\": noise_maps,\n", " },\n", ")\n", "\n", "executor = Executor(backend)\n", "executor_job = executor.run(program)" ] }, { "cell_type": "markdown", "id": "936c08fb-7838-4d61-9060-092b479e7909", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Consulte a [referência da API EstimatorOptions](/docs/api/qiskit-ibm-runtime/options-estimator-options) e a [referência da API ResilienceOptionsV2](/docs/api/qiskit-ibm-runtime/options-resilience-options-v2).\n", " * Saiba mais sobre [as técnicas](error-mitigation-and-suppression-techniques) disponíveis de mitigação e supressão de erros.\n", " * Saiba como implementar [o gerenciamento de ruído do Estimador](/docs/guides/estimator-noise-management).\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 }