{
"cells": [
{
"cell_type": "markdown",
"id": "828c3465-62a7-4c42-b376-e3ec32f67595",
"metadata": {},
"source": [
"---\n",
"title: \"Ayudante para aprender sobre el ruido\"\n",
"description: \"Empiece a utilizar el programa auxiliar de aprendizaje de ruido para guardar los modelos de ruido creados al ejecutar cargas de trabajo en Qiskit IBM Runtime\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Ayudante para aprender sobre el ruido\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",
" El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos.\n",
" Recomendamos utilizar estas versiones o versiones más recientes.\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": [
"Las técnicas de mitigación de errores [PEA](/docs/guides/error-mitigation-and-suppression-techniques#pea) y [PEC](/docs/guides/error-mitigation-and-suppression-techniques#pec) utilizan ambas un componente de aprendizaje del ruido basado en un [modelo de ruido de Pauli-Lindblad](https://arxiv.org/abs/2201.09866), que normalmente se gestiona durante la ejecución tras enviar uno o varios trabajos a través de `qiskit-ibm-runtime` sin ningún tipo de acceso local al modelo de ruido ajustado. Sin embargo, en `qiskit-ibm-runtime`v0.27.1 se han creado una [`NoiseLearner`](/docs/api/qiskit-ibm-runtime/noise-learner) clase y otra [`NoiseLearnerOptions`](/docs/api/qiskit-ibm-runtime/options-noise-learner-options) asociada para obtener los resultados de estos experimentos de aprendizaje con ruido. Estos resultados pueden almacenarse localmente como un `NoiseLearnerResult` y utilizarse como datos de entrada en experimentos posteriores. Esta página ofrece una descripción general de su uso y de las opciones disponibles.\n",
"\n",
"Además, a partir de la versión `qiskit-ibm-runtime`v0.47.0, hay una nueva `NoiseLearnerV3` clase que es compatible con el tipo primitivo Executor. Esta nueva versión, que también forma parte del [modelo de ejecución dirigida](/docs/guides/directed-execution-model), te permite especificar explícitamente las capas que deseas aprender.\n",
"\n",
"\n",
" `NoiseLearner` solo funciona con EstimatorV2 y `NoiseLearnerV3` solo funciona con Executor.\n",
"\n",
"\n",
"\n",
"\n",
"## `NoiseLearner`\n",
"\n",
"\n",
"\n",
"### Visión general\n",
"\n",
"En esta `NoiseLearner` clase se realizan experimentos para caracterizar los procesos de ruido basándose en un modelo de ruido de Pauli-Lindblad para uno (o más) circuitos. Dispone de un `run()` método que ejecuta los experimentos de aprendizaje y toma como entrada una lista de circuitos o un objeto [PUB](/docs/guides/primitive-input-output), y devuelve un objeto `NoiseLearnerResult` que contiene los canales de ruido aprendidos y los metadatos sobre los trabajos enviados. A continuación se muestra un fragmento de código que muestra cómo se utiliza el 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": [
"El resultado `NoiseLearnerResult.data` es una lista de [`LayerError`](/docs/api/qiskit-ibm-runtime/results-layer-error) objetos que contienen el [modelo de ruido](https://arxiv.org/abs/2201.09866) para cada capa de entrelazamiento individual que pertenece al circuito o circuitos de destino. Cada una `LayerError` almacena la información de la capa, en forma de circuito y de un conjunto de etiquetas de qubits, junto con el [`PauliLindbladError`](/docs/api/qiskit-ibm-runtime/results-pauli-lindblad-error) modelo de ruido que se ha aprendido para esa capa concreta.\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": [
"El atributo `LayerError.error` del resultado del aprendizaje del ruido contiene los generadores y las tasas de error del modelo Pauli Lindblad ajustado, que tiene la forma\n",
"\n",
"$\\Lambda(\\rho) = \\exp{\\sum_j r_j \\left(P_j \\rho P_j^\\dagger - \\rho\\right)},$\n",
"\n",
"donde $r_j$ son los `LayerError.rates` y $P_j$ son los operadores de Pauli especificados en `LayerError.generators`.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "fc0000e6-e77a-4b87-a9ee-262f904953fc",
"metadata": {},
"source": [
"\n",
"\n",
"### Opciones de aprendizaje sobre ruido\n",
"\n",
"Puedes elegir entre varias opciones a la hora de crear una instancia `NoiseLearner` de un objeto. Estas opciones están integradas en la `qiskit_ibm_runtime.options.NoiseLearnerOptions` clase e incluyen la posibilidad de especificar el número máximo de capas que se van a aprender, el número de aleatorizaciones y la estrategia de rotación, entre otras. Consulte la documentación de la [`NoiseLearnerOptions`](/docs/api/qiskit-ibm-runtime/options-noise-learner-options) API para obtener información detallada.\n",
"\n",
"A continuación se muestra un ejemplo sencillo que ilustra cómo utilizar el `NoiseLearnerOptions` en un `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",
"### Introducir modelo de ruido en una primitiva\n",
"\n",
"El modelo de ruido aprendido en el circuito también puede utilizarse como entrada para la `EstimatorV2` primitiva implementada en Qiskit Runtime Esto se puede pasar a la primitiva de varias formas diferentes. Los tres ejemplos siguientes muestran cómo se puede pasar el modelo de ruido directamente al `estimator.options` atributo, utilizando un `ResilienceOptionsV2` objeto antes de instanciar una primitiva Estimator y pasando un diccionario con el formato adecuado.\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": [
"Una vez que el modelo de ruido se ha pasado al `EstimatorV2` objeto, este puede utilizarse para ejecutar cargas de trabajo y llevar a cabo la mitigación de errores con total normalidad.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dad71939-7fe2-42f0-90fe-6974fe0854e7",
"metadata": {},
"source": [
"\n",
"\n",
"## NoiseLearnerV3\n",
"\n",
"\n",
"\n",
"### Visión general\n",
"\n",
"Al igual que `NoiseLearner`, la `NoiseLearnerV3` clase lleva a cabo experimentos que caracterizan los procesos de ruido basándose en un modelo de ruido de Pauli-Lindblad para uno o varios circuitos. Su `run()` método toma una lista de instrucciones, cada una de las cuales debe ser una estructura «twirled» anotada [`BoxOp`](/docs/api/qiskit/qiskit.circuit.BoxOp) que contenga operaciones [ISA](/docs/guides/transpile#instruction-set-architecture).\n",
"\n",
"El resultado de una `NoiseLearnerV3` tarea contiene una lista de [`NoiseLearnerV3Result`](/docs/api/qiskit-ibm-runtime/results-noise-learner-v3-result) objetos, uno por cada instrucción de entrada.\n",
"El siguiente código muestra cómo utilizar el 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": [
"El resultado de la operación es una lista de `NoiseLearnerV3Result` objetos, uno por cada conjunto de instrucciones entre corchetes. `NoiseLearnerV3Result` tiene un `to_pauli_lindblad_map()` método que devuelve un [`PauliLindbladMap`](/docs/api/qiskit/qiskit.quantum_info.PauliLindbladMap) objeto, el cual cuenta con métodos para extraer los generadores, las tasas de error y mucho más.\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",
"### Opciones de aprendizaje sobre ruido\n",
"\n",
"`NoiseLearnerV3` ofrece varias opciones, entre las que se incluyen el número de aleatorizaciones y la profundidad de los pares de capas, entre otras. Al igual que con los tipos primitivos, puedes especificar las opciones durante o después de instanciar el `NoiseLearnerV3` objeto. El ejemplo de código anterior mostraba cómo configurar las opciones `shots_per_randomization` y `num_randomizations` . Consulte la documentación de la [`NoiseLearnerV3Options`](/docs/api/qiskit-ibm-runtime/options-models-noise-learner-v3-options) API para obtener información detallada.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e76e997d-506f-4607-a89a-e4723c640a44",
"metadata": {},
"source": [
"\n",
"\n",
"### Introducir un modelo de ruido en Executor\n",
"\n",
"Executor sigue las intenciones de diseño especificadas en las anotaciones del circuito (en forma de samplex) y en las opciones. `InjectNoise` es la anotación que especifica dónde inyectar el ruido, y el `pauli_lindblad_maps` argumento `samplex` indica qué mapa de ruido se debe utilizar.\n",
"\n",
"El circuito del ejemplo anterior pasa por el gestor de pasos de encajado, que agrupa las instrucciones en bloques anotados. Se incluye aquí el código correspondiente para facilitar la comprensión.\n",
"\n",
"* `inject_noise_targets=”gates”` especifica que se añadan las `InjectNoise` anotaciones a los recuadros que contienen elementos de entrelazamiento.\n",
"* `inject_noise_strategy=\"uniform_modification\"` especifica que se asignen los mismos `ref` y `modifier_ref` a todas las casillas equivalentes con `InjectNoise` anotaciones.\n",
" * `InjectNoise.ref` es un identificador único que se utiliza para asignar un modelo de ruido a esa casilla.\n",
" * `InjectNoise.modifier_ref` permite ajustar el modelo de ruido asignado a un cuadro mediante factores 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",
"El circuito del ejemplo anterior contiene tres recuadros, dos de los cuales contienen `InjectNoise` anotaciones con atributos diferentes `ref` (ya que no son 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": [
"El resultado del `NoiseLearnerV3` trabajo debe convertirse en un diccionario antes de pasárselo a Executor. Las claves de este diccionario son los `InjectNoise.ref` atributos y los valores son los mapas de ruido correspondientes. Esta asignación indica a Executor qué modelos de ruido debe insertar y en qué lugar.\n",
"\n",
"El siguiente código muestra cómo tomar el circuito y el `NoiseLearnerV3` resultado del ejemplo anterior y pasarlos a Executor, que generará las variantes del circuito con los modelos de ruido inyectados y las ejecutará en el 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óximos pasos\n",
"\n",
"\n",
" * Revise la [referencia de la API EstimatorOptions](/docs/api/qiskit-ibm-runtime/options-estimator-options) y [la referencia de la API ResilienceOptionsV2](/docs/api/qiskit-ibm-runtime/options-resilience-options-v2).\n",
" * Obtenga más información sobre [las técnicas de mitigación y supresión de](error-mitigation-and-suppression-techniques) errores disponibles en Qiskit Runtime.\n",
" * Descubre cómo implementar [la gestión del ruido](/docs/guides/estimator-noise-management) en Estimator.\n",
" * Lea [Migrar a 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
}