{
"cells": [
{
"cell_type": "markdown",
"id": "c52e7bba-1230-4974-8e86-2dbe8f6f219b",
"metadata": {},
"source": [
"---\n",
"title: \"Depurar tarefas do Qiskit Runtime\"\n",
"description: \"Utilize o módulo e `Neat` a classe de ferramentas de depuração Qiskit Runtime para depurar e analisar tarefas.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Depurar tarefas do Qiskit Runtime\n",
"\n",
"{/* cspell:ignore ZIIIII, IZIIII,IIZIII, IIIZII, IIIIZI, IIIIIZ, rdiff */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d0599f3e",
"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.5.0\n",
" qiskit-ibm-runtime~=0.47.0\n",
" qiskit-aer~=0.17\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "80d0a1da-8d98-49e1-9cb0-0006093bf44c",
"metadata": {},
"source": [
"Você pode usar a `Neat` classe para analisar o impacto do ruído em uma carga de trabalho do Estimator. Para verificar a sintaxe, use [o modo de teste local](/docs/guides/local-testing-mode).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b08f0589",
"metadata": {},
"source": [
"\n",
"\n",
"## `Neat` uso da classe\n",
"\n",
"Antes de enviar uma carga de trabalho Qiskit Runtime com uso intensivo de recursos para ser executada no hardware, você pode usar a classe Qiskit Runtime [`Neat` (Noisy Estimator Analyzer Tool)](/docs/api/qiskit-ibm-runtime/debug-tools-neat#neat) para verificar se a carga de trabalho do Estimator está configurada corretamente, se provavelmente retornará resultados precisos, se usa as opções mais adequadas para o problema especificado e muito mais.\n",
"\n",
"`Neat` Cliffordiza os circuitos de entrada para uma simulação eficiente, ao mesmo tempo em que mantém sua estrutura e profundidade. Os circuitos Clifford sofrem níveis semelhantes de ruído e são um bom substituto para o estudo do circuito original de interesse.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0dc5bf2a-e536-4141-a77c-0ee407cbd9b2",
"metadata": {},
"source": [
"Primeiro, importe os pacotes relevantes e [autentique-se no serviço Qiskit Runtime](/docs/guides/cloud-setup).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d653e186-7ec3-4f1b-b0e9-b322055dd6c8",
"metadata": {},
"source": [
"\n",
"\n",
"### Preparar o ambiente\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "2f28c824-3158-43e6-ab3c-fd96c31859f0",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import random\n",
"\n",
"from qiskit.circuit import QuantumCircuit\n",
"from qiskit.transpiler import generate_preset_pass_manager\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"\n",
"from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator\n",
"from qiskit_ibm_runtime.debug_tools import Neat\n",
"\n",
"from qiskit_aer.noise import NoiseModel, depolarizing_error"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "a45a6d9e-de39-4586-8395-a7f580f0e0dc",
"metadata": {},
"outputs": [],
"source": [
"# Choose the least busy backend\n",
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(operational=True, simulator=False)\n",
"\n",
"# Generate a preset pass manager\n",
"# This will be used to convert the abstract circuit to an equivalent\n",
"# Instruction Set Architecture (ISA) circuit.\n",
"\n",
"pm = generate_preset_pass_manager(backend=backend, optimization_level=0)\n",
"\n",
"# Set the random seed\n",
"random.seed(10)"
]
},
{
"cell_type": "markdown",
"id": "67572a70-da01-40fe-b299-b5599561164a",
"metadata": {},
"source": [
"\n",
"\n",
"### Inicializar um circuito alvo\n",
"\n",
"Considere um circuito de seis qubits que tenha as seguintes propriedades:\n",
"\n",
"* Alterna entre rotações aleatórias `RZ` e camadas de portas `CNOT`.\n",
"* Tem uma estrutura de espelho, ou seja, aplica um `U` unitário seguido de seu inverso.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "df19af55-897d-4b1f-baf8-fac2641ae87d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def generate_circuit(n_qubits, n_layers):\n",
" r\"\"\"\n",
" A function to generate a pseudo-random a circuit with ``n_qubits`` qubits\n",
" and ``2*n_layers`` entangling layers of the type used in this notebook.\n",
" \"\"\"\n",
" # An array of random angles\n",
" angles = [\n",
" [random.random() for q in range(n_qubits)] for s in range(n_layers)\n",
" ]\n",
"\n",
" qc = QuantumCircuit(n_qubits)\n",
" qubits = list(range(n_qubits))\n",
"\n",
" # do random circuit\n",
" for layer in range(n_layers):\n",
" # rotations\n",
" for q_idx, qubit in enumerate(qubits):\n",
" qc.rz(angles[layer][q_idx], qubit)\n",
"\n",
" # cx gates\n",
" control_qubits = (\n",
" qubits[::2] if layer % 2 == 0 else qubits[1 : n_qubits - 1 : 2]\n",
" )\n",
" for qubit in control_qubits:\n",
" qc.cx(qubit, qubit + 1)\n",
"\n",
" # undo random circuit\n",
" for layer in range(n_layers)[::-1]:\n",
" # cx gates\n",
" control_qubits = (\n",
" qubits[::2] if layer % 2 == 0 else qubits[1 : n_qubits - 1 : 2]\n",
" )\n",
" for qubit in control_qubits:\n",
" qc.cx(qubit, qubit + 1)\n",
"\n",
" # rotations\n",
" for q_idx, qubit in enumerate(qubits):\n",
" qc.rz(-angles[layer][q_idx], qubit)\n",
"\n",
" return qc\n",
"\n",
"\n",
"# Generate a random circuit\n",
"qc = generate_circuit(6, 3)\n",
"# Convert the abstract circuit to an equivalent ISA circuit.\n",
"isa_qc = pm.run(qc)\n",
"\n",
"qc.draw(\"mpl\", idle_wires=0)"
]
},
{
"cell_type": "markdown",
"id": "0167329b-c6a6-4b2c-98fc-bf9aba9b7ee6",
"metadata": {},
"source": [
"Escolha operadores de Pauli `Z` únicos como observáveis e use-os para inicializar os blocos unificados primitivos (PUBs).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "830b1dcc-2669-46cc-bff8-01a96a05c6ab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Observables: ['ZIIIII', 'IZIIII', 'IIZIII', 'IIIZII', 'IIIIZI', 'IIIIIZ']\n"
]
}
],
"source": [
"# Initialize the observables\n",
"obs = [\"ZIIIII\", \"IZIIII\", \"IIZIII\", \"IIIZII\", \"IIIIZI\", \"IIIIIZ\"]\n",
"print(f\"Observables: {obs}\")\n",
"\n",
"# Map the observables to the backend's layout\n",
"isa_obs = [SparsePauliOp(o).apply_layout(isa_qc.layout) for o in obs]\n",
"\n",
"# Initialize the PUBs, which consist of six-qubit circuits\n",
"# with `n_layers` 1, ..., 6\n",
"all_n_layers = [1, 2, 3, 4, 5, 6]\n",
"\n",
"pubs = [(pm.run(generate_circuit(6, n)), isa_obs) for n in all_n_layers]"
]
},
{
"cell_type": "markdown",
"id": "2a49fc84-0c82-4cbb-a557-6e676e57c9fa",
"metadata": {},
"source": [
"\n",
"\n",
"### Cliffordize os circuitos\n",
"\n",
"Os circuitos definidos anteriormente em PUB não são de Clifford, o que dificulta a simulação clássica. No entanto, você pode usar o método `Neat` [`to_clifford`](/docs/api/qiskit-ibm-runtime/debug-tools-neat#to_clifford) para mapeá-los para circuitos Clifford para uma simulação mais eficiente. O método [`to_clifford`](/docs/api/qiskit-ibm-runtime/debug-tools-neat#to_clifford) é um invólucro em torno da passagem [`ConvertISAToClifford`](/docs/api/qiskit-ibm-runtime/transpiler-passes-convert-isa-to-clifford) que também pode ser usado de forma independente. Em particular, ele substitui as portas de qubit único não Clifford no circuito original por portas de qubit único Clifford, mas não altera as portas de dois qubits, o número de qubits ou a profundidade do circuito.\n",
"\n",
"Consulte [Simulação eficiente de circuitos estabilizadores com primitivos Qiskit Aer](/docs/guides/simulate-stabilizer-circuits) para obter mais informações sobre a simulação de circuitos Clifford.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7a86d99e-4431-4d62-8227-c49d17856369",
"metadata": {},
"source": [
"Primeiro, inicialize `Neat`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "4b5bbd4c-bd7f-4679-9348-d41da74d26eb",
"metadata": {},
"outputs": [],
"source": [
"# You could specify a custom `NoiseModel` here. If `None`, `Neat`\n",
"# pulls the noise model from the given backend\n",
"noise_model = None\n",
"\n",
"# Initialize `Neat`\n",
"analyzer = Neat(backend, noise_model)"
]
},
{
"cell_type": "markdown",
"id": "b740dcdf-660e-41e2-b5e6-e8cc288af38b",
"metadata": {},
"source": [
"Em seguida, Cliffordize os PUBs.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "3ad78f41-a2f8-4381-826a-ae728e081ad6",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"clifford_pubs = analyzer.to_clifford(pubs)\n",
"\n",
"clifford_pubs[0].circuit.draw(\"mpl\", idle_wires=0)"
]
},
{
"cell_type": "markdown",
"id": "83c3ff81-9f18-43eb-ba6e-57c5ef3d118f",
"metadata": {},
"source": [
"\n",
"\n",
"## Aplicação 1: Analisar o impacto do ruído nas saídas do circuito\n",
"\n",
"Este exemplo mostra como usar `Neat` para estudar o impacto de diferentes modelos de ruído em PUBs em função da profundidade do circuito, executando simulações em condições ideais ([`ideal_sim`](/docs/api/qiskit-ibm-runtime/debug-tools-neat#ideal_sim)) e ruidosas ([`noisy_sim`](/docs/api/qiskit-ibm-runtime/debug-tools-neat#noisy_sim)). Isso pode ser útil para definir expectativas sobre a qualidade dos resultados experimentais antes de executar um trabalho em uma QPU. Para saber mais sobre modelos de ruído, consulte [Simulação exata e ruidosa com primitivas Qiskit Aer](/docs/guides/simulate-with-qiskit-aer#exact-and-noisy-simulation-with-qiskit-aer-primitives).\n",
"\n",
"Os resultados simulados dão suporte a operações matemáticas e, portanto, podem ser comparados entre si (ou com resultados experimentais) para calcular as figuras de mérito.\n",
"\n",
"\n",
" Uma QPU pode ser afetada por diferentes tipos de ruído. O modelo de ruído do Qiskit Aer usado aqui simula apenas alguns deles e, portanto, é provável que seja menos grave do que o ruído em uma QPU real.\n",
"\n",
" Para obter detalhes sobre quais erros são incluídos ao inicializar um modelo de ruído de uma QPU, consulte a referência da API Aer [`NoiseModel`](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.NoiseModel.html#qiskit_aer.noise.NoiseModel.from_backend) Referência da API.\n",
"\n",
"\n",
"Comece realizando simulações clássicas ideais e com ruído.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "23859a99-2455-460e-98ea-17b36ea59c36",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ideal results:\n",
" NeatResult([NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.])), NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.])), NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.])), NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.])), NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.])), NeatPubResult(vals=array([1., 1., 1., 1., 1., 1.]))])\n",
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Noisy results:\n",
" NeatResult([NeatPubResult(vals=array([0.99414062, 0.99414062, 0.99804688, 0.99609375, 0.98828125,\n",
" 0.99023438])), NeatPubResult(vals=array([0.9765625 , 0.97851562, 0.9765625 , 0.98632812, 0.98828125,\n",
" 0.99414062])), NeatPubResult(vals=array([0.953125 , 0.9609375 , 0.9609375 , 0.97265625, 0.97851562,\n",
" 0.97460938])), NeatPubResult(vals=array([0.953125 , 0.94335938, 0.94140625, 0.97070312, 0.96679688,\n",
" 0.99414062])), NeatPubResult(vals=array([0.94335938, 0.92382812, 0.95703125, 0.96875 , 0.96679688,\n",
" 0.97265625])), NeatPubResult(vals=array([0.92773438, 0.90429688, 0.91210938, 0.93554688, 0.95117188,\n",
" 0.97265625]))])\n",
"\n"
]
}
],
"source": [
"# Perform a noiseless simulation\n",
"ideal_results = analyzer.ideal_sim(clifford_pubs)\n",
"print(f\"Ideal results:\\n {ideal_results}\\n\")\n",
"\n",
"# Perform a noisy simulation with the backend's noise model\n",
"noisy_results = analyzer.noisy_sim(clifford_pubs)\n",
"print(f\"Noisy results:\\n {noisy_results}\\n\")"
]
},
{
"cell_type": "markdown",
"id": "a000a77a-0285-4b72-a69f-8f144f2c2a80",
"metadata": {},
"source": [
"Em seguida, aplique operações matemáticas para calcular a diferença absoluta. O restante do guia usa a diferença absoluta como uma figura de mérito para comparar resultados ideais com resultados ruidosos ou experimentais, mas figuras de mérito semelhantes podem ser configuradas.\n",
"\n",
"A diferença absoluta mostra que o impacto do ruído aumenta com o tamanho dos circuitos.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "cd61e437-bd2f-4349-a667-7edab51c4a6e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean absolute difference between ideal and noisy results for circuits with 1 layers:\n",
" 0.65%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 2 layers:\n",
" 1.66%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 3 layers:\n",
" 3.32%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 4 layers:\n",
" 3.84%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 5 layers:\n",
" 4.46%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 6 layers:\n",
" 6.61%\n",
"\n"
]
}
],
"source": [
"# Figure of merit: Absolute difference\n",
"def rdiff(res1, re2):\n",
" r\"\"\"The absolute difference between `res1` and re2`.\n",
"\n",
" --> The closer to `0`, the better.\n",
" \"\"\"\n",
" d = abs(res1 - re2)\n",
" return np.round(d.vals * 100, 2)\n",
"\n",
"\n",
"for idx, (ideal_res, noisy_res) in enumerate(\n",
" zip(ideal_results, noisy_results)\n",
"):\n",
" vals = rdiff(ideal_res, noisy_res)\n",
"\n",
" # Print the mean absolute difference for the observables\n",
" mean_vals = np.round(np.mean(vals), 2)\n",
" print(\n",
" f\"Mean absolute difference between ideal and noisy results \"\n",
" f\"for circuits with {all_n_layers[idx]} layers:\\n {mean_vals}%\\n\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "7abcd001-9eac-4015-97a3-d6250ea4b667",
"metadata": {},
"source": [
"Você pode seguir essas diretrizes aproximadas e simplificadas para melhorar circuitos desse tipo:\n",
"\n",
"* Se a diferença média absoluta for maior que 90%, a mitigação provavelmente não ajudará.\n",
"* Se a diferença média absoluta for inferior a 90%, [a amplificação probabilística de erros (PEA)](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-amplification-pea) provavelmente poderá melhorar os resultados.\n",
"* Se a diferença média absoluta for inferior a 80%, [a ZNE com dobramento de portão](/docs/guides/error-mitigation-and-suppression-techniques#zero-noise-extrapolation-zne) provavelmente também poderá melhorar os resultados.\n",
"\n",
"Como todas as diferenças absolutas acima são inferiores a 90%, espera-se que a aplicação da AEP ao circuito original melhore a qualidade de seus resultados.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c64c936b-5b8f-4fd2-861d-8b1ded2a0ad4",
"metadata": {},
"source": [
"Você pode especificar diferentes modelos de ruído no analisador. O exemplo a seguir executa o mesmo teste, mas adiciona um modelo de ruído personalizado.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "0835c562-55c9-4dbe-879e-7271f8bed280",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean absolute difference between ideal and noisy results for circuits with 1 layers:\n",
" 0.0%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 2 layers:\n",
" 0.0%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 3 layers:\n",
" 0.0%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 4 layers:\n",
" 0.0%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 5 layers:\n",
" 0.0%\n",
"\n",
"Mean absolute difference between ideal and noisy results for circuits with 6 layers:\n",
" 0.0%\n",
"\n"
]
}
],
"source": [
"# Set up a noise model with strength 0.02 on every two-qubit gate\n",
"noise_model = NoiseModel()\n",
"for qubits in backend.coupling_map:\n",
" noise_model.add_quantum_error(\n",
" depolarizing_error(0.02, 2), [\"ecr\", \"cx\"], qubits\n",
" )\n",
"\n",
"# Update the analyzer's noise model\n",
"analyzer.noise_model = noise_model\n",
"\n",
"# Perform a noiseless simulation\n",
"ideal_results = analyzer.ideal_sim(clifford_pubs)\n",
"\n",
"# Perform a noisy simulation with the backend's noise model\n",
"noisy_results = analyzer.noisy_sim(clifford_pubs)\n",
"\n",
"# Compare the results\n",
"for idx, (ideal_res, noisy_res) in enumerate(\n",
" zip(ideal_results, noisy_results)\n",
"):\n",
" values = rdiff(ideal_res, noisy_res)\n",
"\n",
" # Print the mean absolute difference for the observables\n",
" mean_values = np.round(np.mean(values), 2)\n",
" print(\n",
" f\"Mean absolute difference between ideal and noisy results \"\n",
" f\"for circuits with {all_n_layers[idx]} layers:\\n {mean_values}%\\n\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "f2408ca9-3e3c-4a2f-a99a-ce413d5d470f",
"metadata": {},
"source": [
"Conforme mostrado, com um modelo de ruído, você pode tentar quantificar o impacto do ruído nas PUBs de interesse (versão Cliffordizada das) antes de executá-las em uma QPU.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ddd6da5f-4e84-4bf4-aaeb-0403f21275db",
"metadata": {},
"source": [
"\n",
"\n",
"## Aplicação 2: Comparar diferentes estratégias\n",
"\n",
"Este exemplo usa o site `Neat` para ajudar a identificar as melhores opções para seus PUBs. Para isso, considere a execução de um problema de estimativa com PEA, que não pode ser simulado com `qiskit_aer`. Você pode usar o site `Neat` para ajudar a determinar quais fatores de amplificação de ruído funcionarão melhor e, em seguida, usar esses fatores ao executar o experimento original em uma QPU.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "358bb82a-4bc9-46c2-98a0-e745ffc6788f",
"metadata": {},
"outputs": [],
"source": [
"# Generate a circuit with six qubits and six layers\n",
"isa_qc = pm.run(generate_circuit(6, 3))\n",
"\n",
"# Use the same observables as previously\n",
"pubs = [(isa_qc, isa_obs)]\n",
"clifford_pubs = analyzer.to_clifford(pubs)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "5774cb3f-c999-4242-a83a-7dcc0c57510b",
"metadata": {},
"outputs": [],
"source": [
"noise_factors = [\n",
" [1, 1.1],\n",
" [1, 1.1, 1.2],\n",
" [1, 1.5, 2],\n",
" [1, 1.5, 2, 2.5, 3],\n",
" [1, 4],\n",
"]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "0b9900e6-84fe-4776-9bb5-08c6c729be29",
"metadata": {},
"outputs": [],
"source": [
"# Run the PUBs on a QPU\n",
"estimator = Estimator(backend)\n",
"estimator.options.default_shots = 100000\n",
"estimator.options.twirling.enable_gates = True\n",
"estimator.options.twirling.enable_measure = True\n",
"estimator.options.twirling.shots_per_randomization = 100\n",
"estimator.options.resilience.measure_mitigation = True\n",
"estimator.options.resilience.zne_mitigation = True\n",
"estimator.options.resilience.zne.amplifier = \"pea\"\n",
"\n",
"jobs = []\n",
"for factors in noise_factors:\n",
" estimator.options.resilience.zne.noise_factors = factors\n",
" jobs.append(estimator.run(clifford_pubs))\n",
"\n",
"results = [job.result() for job in jobs]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "16c18377-059a-4751-9ab1-afee0ed5b089",
"metadata": {},
"outputs": [],
"source": [
"# Perform a noiseless simulation\n",
"ideal_results = analyzer.ideal_sim(clifford_pubs)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "7db531a1-c417-4d5b-bdc3-7a4ad3385fd4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean absolute difference for factors [1, 1.1]:\n",
" 4.57%\n",
"\n",
"Mean absolute difference for factors [1, 1.1, 1.2]:\n",
" 5.24%\n",
"\n",
"Mean absolute difference for factors [1, 1.5, 2]:\n",
" 2.62%\n",
"\n",
"Mean absolute difference for factors [1, 1.5, 2, 2.5, 3]:\n",
" 2.4%\n",
"\n",
"Mean absolute difference for factors [1, 4]:\n",
" 2.05%\n",
"\n"
]
}
],
"source": [
"# Look at the mean absolute difference to quickly determine\n",
"# the best choice for your options\n",
"for factors, res in zip(noise_factors, results):\n",
" d = rdiff(ideal_results[0], res[0])\n",
" print(\n",
" f\"Mean absolute difference for factors \"\n",
" f\"{factors}:\\n {np.round(np.mean(d), 2)}%\\n\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "0c37ef7b-df56-4f5f-9e11-10f209f105f9",
"metadata": {},
"source": [
"O resultado com a menor diferença sugere quais opções devem ser escolhidas.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2530a3e9-21a6-4841-9449-fe181c54aca4",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximas etapas\n",
"\n",
"\n",
" * Leia uma visão geral das [ferramentas de depuração do Qiskit](/docs/guides/debugging-tools).\n",
" * Saiba mais sobre [simulação exata e ruidosa com primitivas Qiskit Aer](/docs/guides/simulate-with-qiskit-aer).\n",
" * Saiba mais sobre [as opções disponíveis de Qiskit Runtime](/docs/guides/runtime-options-overview).\n",
" * Aprenda sobre [técnicas de mitigação e supressão de erros](/docs/guides/error-mitigation-and-suppression-techniques).\n",
" * Visite o tópico [Transpile com gerentes de passes](transpile-with-pass-managers).\n",
" * Aprenda [a transpilá-los](/docs/guides/circuit-transpilation-settings#compare-transpiler-settings) como parte dos fluxos de trabalho dos padrões Qiskit usando Qiskit Runtime.\n",
" * Consulte [a documentação da API das ferramentas de depuração](/docs/api/qiskit-ibm-runtime/debug-tools).\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
}