{
"cells": [
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"---\n",
"title: \"Leistungsmanagement – Eine Qiskit-Funktion von Q-CTRL Fire Opal\"\n",
"description: \"Wenden Sie die automatisierte Fehlerunterdrückung mit Fire Opal Performance Management von Q-CTRL an\"\n",
"---\n",
"\n",
"{/* cspell:ignore fontsize, Mundada, Yamauchi, supersymmetric, Paterakis, Gharibyan */}\n",
"\n",
"\n",
"\n",
"# Leistungsmanagement: Eine Qiskit-Funktion von Q-CTRL Fire Opal\n",
"\n",
"*Siehe [API-Referenz](/docs/api/functions/q-ctrl-performance-management)*\n",
"\n",
"\n",
" Qiskit-Funktionen sind eine experimentelle Funktion, die nur für Benutzer des IBM Quantum® Premium Plan, Flex Plan und On-Prem (über IBM Quantum Platform API) Plan verfügbar ist. Sie befinden sich im Status einer Vorabversion und können sich noch ändern.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ace2ed13",
"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",
" Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt.\n",
" Wir empfehlen die Verwendung dieser oder neuerer Versionen.\n",
"\n",
" ```\n",
" qiskit[all]~=2.3.1\n",
" qiskit-ibm-runtime~=0.45.1\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1732b45",
"metadata": {},
"source": [
"\n",
"\n",
"## Übersicht\n",
"\n",
"Mit Fire Opal Performance Management kann jeder auf einfache Weise aussagekräftige Ergebnisse mit Quantencomputern im großen Maßstab erzielen, ohne Quantenhardware-Experte sein zu müssen. Bei der Ausführung von Schaltkreisen mit Fire Opal Performance Management werden automatisch KI-gesteuerte Fehlerunterdrückungstechniken angewendet, die die Skalierung größerer Probleme mit mehr Gattern und Qubits ermöglichen. Dieser Ansatz reduziert die Anzahl der für die richtige Antwort erforderlichen Schüsse ohne zusätzlichen Aufwand, was zu erheblichen Einsparungen bei Rechenzeit und Kosten führt.\n",
"\n",
"Performance Management unterdrückt Fehler und erhöht die Wahrscheinlichkeit, dass die richtige Antwort auf verrauschter Hardware gefunden wird. Mit anderen Worten: Das Signal-Rausch-Verhältnis wird erhöht. Die folgende Abbildung zeigt, wie die durch das Leistungsmanagement ermöglichte erhöhte Genauigkeit im Falle eines 10-Qubit-Quanten-Fourier-Transformations-Algorithmus den Bedarf an zusätzlichen Aufnahmen verringern kann. Mit nur 30 Schüssen erreicht Q-CTRL die 99% Konfidenzschwelle, während die Standardeinstellung (`QiskitRuntime` Sampler, `optimization_level`=3 und `resilience_level`=1, `ibm_sherbrooke`) 170.000 Schüsse benötigt. Indem Sie schneller die richtige Antwort erhalten, sparen Sie erhebliche Rechenlaufzeit.\n",
"\n",
"\n",
"\n",
"Die Funktion „Performance Management“ kann mit jedem beliebigen Algorithmus verwendet werden, und Sie können sie problemlos anstelle der [Standardprimitive „ IBM Quantum “ einsetzen.](/docs/guides/primitives) Hinter den Kulissen arbeiten mehrere Techniken zur Fehlerunterdrückung zusammen, um Fehler während der Laufzeit zu verhindern. Alle Fire-Opal-Pipeline-Methoden sind vorkonfiguriert und algorithmunabhängig, sodass Sie von Anfang an stets die beste Leistung erzielen.\n",
"\n",
"Um Zugang zum Leistungsmanagement zu erhalten, [wenden Sie sich an Q-CTRL](https://form.typeform.com/to/uOAVDnGg?typeform-source=q-ctrl.com).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5f761442",
"metadata": {},
"source": [
"\n",
"\n",
"## Beschreibung\n",
"\n",
"Fire Opal Performance Management bietet zwei Ausführungsoptionen, die den Primitiven von „ IBM Quantum “ ähneln, sodass Sie den Q-CTRL-Sampler und den Estimator problemlos einbinden können. Der allgemeine Arbeitsablauf bei der Nutzung der Performance-Management-Funktion sieht wie folgt aus:\n",
"\n",
"1. Definieren Sie Ihre Schaltung (und Operatoren im Falle des Estimators).\n",
"2. Betreiben Sie den Stromkreis.\n",
"3. Rufen Sie die Ergebnisse ab.\n",
"\n",
"Um das Hardware-Rauschen zu reduzieren, setzt Fire Opal eine Reihe von KI-gesteuerten Fehlerunterdrückungstechniken ein, die in der folgenden Abbildung dargestellt sind. Mit Fire Opal ist die gesamte Pipeline vollständig automatisiert und muss nicht konfiguriert werden.\n",
"\n",
"Die Pipeline von Fire Opal macht zusätzlichen Overhead überflüssig, wie z. B. eine erhöhte Quantenlaufzeit oder zusätzliche physische Qubits. Beachten Sie, dass die klassische Verarbeitungszeit ein Faktor bleibt (Schätzungen finden Sie im Abschnitt \" [Benchmarks](#benchmarks)\", wo die \"Gesamtzeit\" sowohl die klassische als auch die Quantenverarbeitung berücksichtigt). Im Gegensatz zur Fehlerbegrenzung, die einen Overhead in Form von Abtastung erfordert, arbeitet die Fehlerunterdrückung von Fire Opal sowohl auf der Gatter- als auch auf der Impulsebene, um verschiedene Rauschquellen zu beseitigen und die Wahrscheinlichkeit des Auftretens eines Fehlers zu verhindern. Durch die Vermeidung von Fehlern entfällt die Notwendigkeit einer teuren Nachbearbeitung.\n",
"\n",
"Die folgende Abbildung zeigt die von Fire Opal Performance Management automatisierten Fehlerunterdrückungsmethoden.\n",
"\n",
"\n",
"\n",
"Die Funktion bietet zwei Primitive, „Sampler“ und „Estimator“, und die Ein- und Ausgänge beider Primitive erweitern die implementierte Spezifikation für [die Primitive „ IBM Quantum “ V2](/docs/guides/primitive-input-output#pubs).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "64534d1a",
"metadata": {},
"source": [
"\n",
"\n",
"## Benchmarks\n",
"\n",
"[Veröffentlichte algorithmische Benchmarking-Ergebnisse](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.20.024034) zeigen eine signifikante Leistungsverbesserung bei verschiedenen Algorithmen, einschließlich Bernstein-Vazirani, Quanten-Fourier-Transformation, Grovers Suche, Quantenapproximations-Optimierungsalgorithmus und Variations-Quanten-Eigensolver. Im weiteren Verlauf dieses Abschnitts finden Sie weitere Einzelheiten über die Arten von Algorithmen, die Sie ausführen können, sowie über die erwartete Leistung und die Laufzeiten.\n",
"\n",
"Die folgenden unabhängigen Studien zeigen, wie das Performance Management von Q-CTRL algorithmische Forschung in rekordverdächtigem Umfang ermöglicht:\n",
"\n",
"* [Parametrisierte energieeffiziente Quantenkernel für die Fehlerdiagnose bei Netzwerkdiensten](https://arxiv.org/abs/2405.09724v1) - Lernen von Quantenkerneln mit bis zu 50 Qubits\n",
"* [Tensor-basierte Quanten-Phasendifferenzschätzung für groß angelegte Demonstrationen](https://arxiv.org/abs/2408.04946) - bis zu 33-Qubit-Quantenphasenschätzung\n",
"* [Hierarchisches Lernen für Quanten-ML: Neuartige Trainingstechnik für groß angelegte Quanten-Variationsschaltungen](https://arxiv.org/abs/2311.12929) - bis zu 21-Qubit-Quantum-Datenladung\n",
"\n",
"Die folgende Tabelle gibt einen groben Anhaltspunkt über die Genauigkeit und die Laufzeiten aus früheren Benchmarking-Läufen auf `ibm_fez`. Die Leistung auf anderen Geräten kann variieren. Die Nutzungsdauer basiert auf der Annahme von 10.000 Schüssen pro Schaltkreis. Die angegebene \"Anzahl der Qubits\" ist keine harte Begrenzung, sondern stellt einen groben Schwellenwert dar, bei dem man eine extrem gleichmäßige Lösungsgenauigkeit erwarten kann. Größere Probleme wurden bereits erfolgreich gelöst, und es wird empfohlen, über diese Grenzen hinaus zu testen.\n",
"\n",
"| Beispiel | Anzahl der Qubits | Genauigkeit | Maß für die Genauigkeit | Gesamtzeit (S) | Laufzeitverbrauch (s) | Primitiv (Modus) |\n",
"| ----------------------------------------------------- | ----------------- | ----------- | ------------------------------------------------------------------------------------------------- | ------------------ | --------------------- | ------------------- |\n",
"| Bernstein-Vazirani | 50Q | 100 % | Erfolgsquote (Prozentsatz der Läufe, bei denen die richtige Antwort die höchste Zählbitfolge ist) | 10 | 8 | Stichprobenfunktion |\n",
"| Quanten-Fourier-Transformation | 30Q | 100 % | Erfolgsquote (Prozentsatz der Läufe, bei denen die richtige Antwort die höchste Zählbitfolge ist) | 10 | 8 | Stichprobenfunktion |\n",
"| Quanten-Phasenabschätzung | 30Q | 99.9998% | Genauigkeit des gefundenen Winkels: `1- abs(real_angle - angle_found)/pi` | 10 | 8 | Stichprobenfunktion |\n",
"| Quantensimulation: Ising-Modell (15 Schritte) | 20Q | 99.775% | $A$ (unten definiert) | 60 (pro Stufe) | 15 (pro Stufe) | Schätzer |\n",
"| Quantensimulation 2: Molekulardynamik (20 Zeitpunkte) | 34Q | 96.78% | $A_{mean}$ (unten definiert) | 10 (pro Zeitpunkt) | 6 (pro Zeitpunkt) | Schätzer |\n",
"\n",
"Die Genauigkeit der Messung eines Erwartungswerts - die Metrik $A$ ist wie folgt definiert:\n",
"\n",
"$$\n",
"A = 1 - \\frac{|\\epsilon^{ideal} - \\epsilon^{meas}|}{\\epsilon^{ideal}_{max} - \\epsilon^{ideal}_{min}},\n",
"$$\n",
"\n",
"wobei $\\epsilon^{ideal}$ = idealer Erwartungswert, $\\epsilon^{meas}$ = gemessener Erwartungswert, $\\epsilon^{ideal}_{max} $ = idealer Maximalwert und $\\epsilon^{ideal}_{min}$ = idealer Minimalwert. $A_{mean}$ ist einfach der Durchschnitt des Wertes von $A$ über mehrere Messungen.\n",
"\n",
"Diese Metrik wird verwendet, weil sie gegenüber globalen Verschiebungen und Skalierungen im Bereich der erreichbaren Werte unveränderlich ist. Mit anderen Worten: Unabhängig davon, ob Sie den Bereich der möglichen Erwartungswerte nach oben oder unten verschieben oder die Spanne vergrößern, sollte der Wert von $A$ konstant bleiben.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "870af0fe",
"metadata": {},
"source": [
"\n",
"\n",
"## Erste Schritte\n",
"\n",
"Fire Opal Performance Management verwendet Qiskit v`2.0.0`, die empfohlene Version. Unterstützte Versionen sind Qiskit >=v`2.0.0`.\n",
"Melden Sie sich mit Ihrem [API-Schlüssel von „ IBM Quantum Platform](http://quantum.cloud.ibm.com/) “ an und wählen Sie die Qiskit-Funktion wie folgt aus. (In diesem Codeausschnitt wird davon ausgegangen, dass Sie [Ihr Konto](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) bereits in Ihrer lokalen Umgebung gespeichert haben.)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "11af8fb4",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[QiskitFunction(qunova/hivqe-chemistry),\n",
" QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),\n",
" QiskitFunction(algorithmiq/tem),\n",
" QiskitFunction(qedma/qesem),\n",
" QiskitFunction(multiverse/singularity),\n",
" QiskitFunction(ibm/circuit-function),\n",
" QiskitFunction(q-ctrl/optimization-solver),\n",
" QiskitFunction(colibritd/quick-pde),\n",
" QiskitFunction(q-ctrl/performance-management),\n",
" QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# verify that you have access to the function\n",
"catalog.list()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "736255e4-1c1f-42a7-bf76-1487878c9e76",
"metadata": {},
"outputs": [],
"source": [
"# Access Function\n",
"perf_mgmt = catalog.load(\"q-ctrl/performance-management\")"
]
},
{
"cell_type": "markdown",
"id": "d4657810",
"metadata": {},
"source": [
"\n",
" Wenn Sie ein Backend verwenden möchten, das diese Funktion derzeit nicht unterstützt, [wenden Sie sich bitte an Q-CTRL,](https://form.typeform.com/to/iuujEAEI?typeform-source=q-ctrl.com) um die Unterstützung hinzuzufügen.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2947b5c3",
"metadata": {},
"source": [
"\n",
"\n",
"## Primitive Schätzung\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "df2788d5",
"metadata": {},
"source": [
"\n",
"\n",
"### Beispiel für einen Schätzer\n",
"\n",
"Verwenden Sie das Estimator-Primitiv von Fire Opal Performance Management, um den Erwartungswert eines einzelnen Paares aus Schaltkreisen und beobachtbaren Daten zu bestimmen.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "82932760",
"metadata": {},
"source": [
"Zusätzlich zu den Paketen `qiskit-ibm-catalog` und `qiskit` werden Sie auch das Paket `numpy` verwenden, um dieses Beispiel auszuführen. Sie können dieses Paket installieren, indem Sie die folgende Zelle auskommentieren, wenn Sie dieses Beispiel in einem Notebook ausführen, das den IPython-Kernel verwendet.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "70bb93ef",
"metadata": {},
"outputs": [],
"source": [
"# %pip install numpy"
]
},
{
"cell_type": "markdown",
"id": "02b2a79a",
"metadata": {},
"source": [
"**1. Erstellen Sie die Schaltung**\n",
"\n",
"Erzeugen Sie zum Beispiel einen zufälligen hermiteschen Operator und eine Beobachtungsgröße, die Sie in die Funktion Performance Management eingeben.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "32037218",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from qiskit.circuit.library import iqp\n",
"from qiskit.quantum_info import random_hermitian, SparsePauliOp\n",
"\n",
"n_qubits = 50\n",
"\n",
"# Generate a random circuit\n",
"mat = np.real(random_hermitian(n_qubits, seed=1234))\n",
"circuit = iqp(mat)\n",
"circuit.measure_all()\n",
"\n",
"# Define observables as a string\n",
"observable = SparsePauliOp(\"Z\" * n_qubits)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "476fae6a",
"metadata": {},
"outputs": [],
"source": [
"# Create PUB tuple\n",
"estimator_pubs = [(circuit, observable)]"
]
},
{
"cell_type": "markdown",
"id": "09e64cd7",
"metadata": {},
"source": [
"**2. Schalten Sie den Stromkreis**\n",
"\n",
"Führen Sie die Schaltung aus und legen Sie optional das Backend und die Anzahl der Schüsse fest.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "26952e1f",
"metadata": {},
"outputs": [],
"source": [
"# Run the circuit using Estimator\n",
"qctrl_estimator_job = perf_mgmt.run(\n",
" primitive=\"estimator\",\n",
" pubs=estimator_pubs,\n",
" backend_name=backend_name,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "c07af9d0",
"metadata": {},
"source": [
"Sie können die bekannten [„ Qiskit Serverless “-APIs](/docs/guides/serverless) verwenden, um den Status Ihrer Qiskit-Funktions-Workload zu überprüfen:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "2b309861",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'QUEUED'"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qctrl_estimator_job.status()"
]
},
{
"cell_type": "markdown",
"id": "23556c8e",
"metadata": {},
"source": [
"**3. Abrufen des Ergebnisses**\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "8be67088",
"metadata": {},
"outputs": [],
"source": [
"# Retrieve the counts from the result list\n",
"result = qctrl_estimator_job.result()"
]
},
{
"cell_type": "markdown",
"id": "7375fcad",
"metadata": {},
"source": [
"Die Ergebnisse haben dasselbe Format wie ein [Estimator-Ergebnis](/docs/guides/estimator-input-output) :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "ef85a036",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The result of the submitted job had 1 PUB\n",
"The result of the submitted job had 1 PUB and has a value:\n",
" PubResult(data=DataBin(evs=0.0195, stds=0.9998098569228051), metadata={'precision': None})\n",
"\n",
"The associated PubResult of this job has the following DataBins:\n",
"DataBin(evs=0.0195, stds=0.9998098569228051)\n",
"\n",
"And this DataBin has attributes: dict_keys(['evs', 'stds'])\n",
"The expectation values measured from this PUB are:\n",
"0.0195\n"
]
}
],
"source": [
"import numpy\n",
"\n",
"result_str = str(result)\n",
"\n",
"with numpy.printoptions(threshold=200):\n",
" print(\n",
" f\"The result of the submitted job had {len(result)} PUB \"\n",
" f\"and has a value:\\n {result[0]}\\n\"\n",
" )\n",
"\n",
"print(\"The associated PubResult of this job has the following DataBins:\")\n",
"print(f\"{result[0].data}\\n\")\n",
"\n",
"print(f\"And this DataBin has attributes: {result[0].data.keys()}\")\n",
"\n",
"print(\"The expectation values measured from this PUB are:\")\n",
"print(f\"{result[0].data.evs}\")"
]
},
{
"cell_type": "markdown",
"id": "a78ce8bd",
"metadata": {},
"source": [
"\n",
"\n",
"## Sampler-Primitive\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b1300f06",
"metadata": {},
"source": [
"\n",
"\n",
"### Beispiel für einen Sampler\n",
"\n",
"Verwenden Sie das Sampler-Primitiv von Fire Opal Performance Management, um eine Bernstein-Vazirani-Schaltung auszuführen. Dieser Algorithmus, mit dem eine versteckte Zeichenkette aus den Ausgaben einer Blackbox-Funktion gefunden werden soll, ist ein gängiger Benchmarking-Algorithmus, da es nur eine einzige richtige Antwort gibt.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "144e48f3",
"metadata": {},
"source": [
"**1. Erstellen Sie die Schaltung**\n",
"\n",
"Definieren Sie die richtige Antwort auf den Algorithmus, die versteckte Bitfolge und die Bernstein-Vazirani-Schaltung. Sie können die Breite der Schaltung anpassen, indem Sie einfach die `circuit_width` ändern.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "2cd807b1",
"metadata": {},
"outputs": [],
"source": [
"import qiskit\n",
"\n",
"circuit_width = 35\n",
"hidden_bitstring = \"1\" * circuit_width\n",
"\n",
"# Create circuit, reserving one qubit for BV oracle\n",
"bv_circuit = qiskit.QuantumCircuit(circuit_width + 1, circuit_width)\n",
"bv_circuit.x(circuit_width)\n",
"bv_circuit.h(range(circuit_width + 1))\n",
"for input_qubit, bit in enumerate(reversed(hidden_bitstring)):\n",
" if bit == \"1\":\n",
" bv_circuit.cx(input_qubit, circuit_width)\n",
"bv_circuit.barrier()\n",
"bv_circuit.h(range(circuit_width + 1))\n",
"bv_circuit.barrier()\n",
"for input_qubit in range(circuit_width):\n",
" bv_circuit.measure(input_qubit, input_qubit)\n",
"\n",
"# Create PUB tuple\n",
"sampler_pubs = [(bv_circuit,)]"
]
},
{
"cell_type": "markdown",
"id": "85d3c00b",
"metadata": {},
"source": [
"**2. Schalten Sie den Stromkreis**\n",
"\n",
"Führen Sie die Schaltung aus und legen Sie optional das Backend und die Anzahl der Schüsse fest.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "2595df84",
"metadata": {},
"outputs": [],
"source": [
"# Run the circuit using Sampler\n",
"qctrl_sampler_job = perf_mgmt.run(\n",
" primitive=\"sampler\",\n",
" pubs=sampler_pubs,\n",
" backend_name=backend_name,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "3c49fbba",
"metadata": {},
"source": [
"Überprüfen Sie [den Status](/docs/guides/functions-get-started#check-job-status) Ihrer Qiskit-Funktions-Workload oder rufen Sie [die Ergebnisse](/docs/guides/functions-get-started#retrieve-results) wie folgt ab:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "b7acbb7f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"60fe2fa1-a860-43e4-8615-c6ac4180f93b\n"
]
},
{
"data": {
"text/plain": [
"'QUEUED'"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the ID so you can use it later, if necessary\n",
"print(qctrl_sampler_job.job_id)\n",
"\n",
"qctrl_sampler_job.status()"
]
},
{
"cell_type": "markdown",
"id": "35921605",
"metadata": {},
"source": [
"**3. Abrufen des Ergebnisses**\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "2d4f5f7d",
"metadata": {},
"outputs": [],
"source": [
"# Retrieve the job results\n",
"sampler_result = qctrl_sampler_job.result()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "7a359d99",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Counts for the meas output register (limited to 30 results):\n",
" 11111111111111111111111111111111111: 1661\n",
" 11111111111111111111111111110111111: 60\n",
" 11111111111111111111111111111101111: 54\n",
" 11111111111111111111111111111110111: 54\n",
" 11111111111111011111111111111111111: 46\n",
" 11111111111111111110111111111111111: 44\n",
" 11111111111111111111111101111111111: 42\n",
" 11111111111111111111111110111111111: 42\n",
" 11111111111111110111111111111111111: 41\n",
" 11111111111111111111111111111111101: 39\n",
" 11111111111111111111101111111111111: 38\n",
" 11111111111111111111110111111111111: 38\n",
" 11111111111111111111111111101111111: 37\n",
" 11111111111111111111111111111111110: 36\n",
" 11111111111110111111111111111111111: 35\n",
" 11111111111111111111111111111011111: 32\n",
" 11111111111111101111111111111111111: 32\n",
" 01111111111111111111111111111111111: 27\n",
" 11111111111111111011111111111111111: 23\n",
" 11111111101111111111111111111111111: 22\n",
" 11111111111111111111111111111111011: 21\n",
" 11111111011111111111111111111111111: 20\n",
" 00000000000000011111111111111111111: 18\n",
" 11111111111111111111110101111111111: 18\n",
" 00000001111111111111111111111111111: 17\n",
" 11111111001111111111111111111111111: 16\n",
" 11101111111111111111111111111111111: 16\n",
" 11111111111101111111111111111111111: 16\n",
" 00000101111111111111111111111111111: 13\n",
" 11111111111111111111111011111111111: 13\n",
" 11111111111111111111111110101111111: 13\n",
" 11111111111111111101111111111111111: 12\n",
" 10111111111111111111111111111111111: 12\n",
" 11111111111111111111111110001111111: 12\n",
" 00000000000000000011111111111111111: 11\n",
" 11111111111111111111111111111110110: 10\n",
" 00000000000000000000000001111111111: 10\n",
" 11111111111011111111111111111111111: 9\n",
" 11111111111111101011111111111111111: 9\n",
" 00000000011111111111111111111111111: 8\n",
" 10101111111111111111111111111111111: 8\n",
" 00000000000000000000000001011111111: 8\n",
" 11111111111111111111111111111111001: 8\n",
" 00000111111111111111111111111111111: 7\n",
" 11111111111111111111111111111101110: 7\n",
" 11111111110111111111111111111111111: 7\n",
" 00000000000001011111111111111111111: 6\n",
" 00000000000000001111111111111111111: 6\n",
" 00000000000000000001011111111111111: 6\n",
" 11111111111111111111111111011111111: 6\n",
" ... (1050 more items)\n"
]
}
],
"source": [
"# Get results for the first (and only) PUB\n",
"pub_result = sampler_result[0]\n",
"counts = pub_result.data.c.get_counts()\n",
"\n",
"print(\"Counts for the meas output register (limited to 30 results):\")\n",
"for i, (bitstring, count) in enumerate(counts.items()):\n",
" if i >= 50:\n",
" print(f\" ... ({len(counts) - 30} more items)\")\n",
" break\n",
" print(f\" {bitstring}: {count}\")"
]
},
{
"cell_type": "markdown",
"id": "d920922e",
"metadata": {},
"source": [
"**3. Zeichnen Sie die obersten Bitstrings**\n",
"\n",
"Zeichnen Sie die Bitfolge mit den höchsten Zählwerten auf, um festzustellen, ob die versteckte Bitfolge der Modus war.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "cefa2234",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def plot_top_bitstrings(counts_dict, hidden_bitstring=None):\n",
" # Sort and take the top 100 bitstrings\n",
" top_100 = sorted(counts_dict.items(), key=lambda x: x[1], reverse=True)[\n",
" :100\n",
" ]\n",
" if not top_100:\n",
" print(\"No bitstrings found in the input dictionary.\")\n",
" return\n",
"\n",
" # Unzip the bitstrings and their counts\n",
" bitstrings, counts = zip(*top_100)\n",
"\n",
" # Assign colors: purple if the bitstring matches hidden_bitstring,\n",
" # otherwise gray\n",
" colors = [\n",
" \"#680CE9\" if bit == hidden_bitstring else \"gray\" for bit in bitstrings\n",
" ]\n",
"\n",
" # Create the bar plot\n",
" plt.figure(figsize=(15, 8))\n",
" plt.bar(\n",
" range(len(bitstrings)), counts, tick_label=bitstrings, color=colors\n",
" )\n",
"\n",
" # Rotate the bitstrings for better readability\n",
" plt.xticks(rotation=90, fontsize=8)\n",
" plt.xlabel(\"Bitstrings\")\n",
" plt.ylabel(\"Counts\")\n",
" plt.title(\"Top 100 Bitstrings by Counts\")\n",
"\n",
" # Show the plot\n",
" plt.tight_layout()\n",
" plt.show()"
]
},
{
"cell_type": "markdown",
"id": "1d9d3b69",
"metadata": {},
"source": [
"Die verborgene Bitfolge ist violett hervorgehoben und sollte die Bitfolge mit der höchsten Anzahl von Zählungen sein.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "8106d906",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot_top_bitstrings(counts, hidden_bitstring)"
]
},
{
"cell_type": "markdown",
"id": "d8104000b3d94c69",
"metadata": {},
"source": [
"\n",
"\n",
"## Änderungsprotokoll\n",
"\n",
"* 2026-02-20: Hinweis zur Abkündigung – Das `provider_job_ids` Metadatenfeld wird in 30 Tagen in Version 0.13.0 abgekündigt. Benutzer können über `job_id()` die Methode des Laufzeitdienstes auf die Job-ID zugreifen.\n",
"* 11.02.2026: Wir bieten nun Unterstützung für `ibm_miami`und haben Ausführungsmetadaten zum `PubResult`hinzugefügt.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bb33258d",
"metadata": {},
"source": [
"\n",
"\n",
"## Unterstützung anfordern\n",
"\n",
"Bei Fragen oder Problemen [wenden Sie sich bitte an Q-CTRL](https://form.typeform.com/to/iuujEAEI).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2fe4a6ea",
"metadata": {},
"source": [
"\n",
"\n",
"## Nächste Schritte\n",
"\n",
"\n",
" * Beantragen Sie Zugriff auf [Q-CTRL Performance Management](/functions?id=q-ctrl-performance-management).\n",
" * Rufen Sie die [API-Referenz](/docs/api/functions/q-ctrl-performance-management) für diese Qiskit-Funktion auf.\n",
" * Probieren Sie das [Transverse-Field-Ising-Modell mit](/docs/tutorials/transverse-field-ising-model) dem Tutorial „Leistungsmanagement“ von Q-CTRL aus.\n",
" * Probieren Sie die [Quantenphasenabschätzung mit](/docs/tutorials/quantum-phase-estimation-qctrl) dem Tutorial „ Qiskit Functions ” von Q-CTRL aus\n",
" * Rezension [Mundada P. S., et al. (2023). Experimentelles Benchmarking eines automatisierten deterministischen Fehlerunterdrückungs-Workflows für Quantenalgorithmen. Physical Review Applied, 20, 2](https://quantum-journal.org/papers/q-2023-07-25-1067/).\n",
" * Rezension [Kanno, S., et al. (2025). Tensorbasierte Quantephasendifferenzschätzung für groß angelegte Demonstrationen. arXiv Vorabdruck arXiv:2408.04946](https://arxiv.org/abs/2408.04946).\n",
" * Rezension [SoftBank Corp, Demonstrationsexperiment eines Kommunikationsdienst-Fehlerdiagnosesystems unter Verwendung von Quanten- Machine Learning us (Blog), 30. August 2024](https://www.softbank.jp/en/corp/technology/research/topics/102/).\n",
" * Rezension [Yamauchi, H., et al. (2024). Parametrisierte energieeffiziente Quantenkernel für die Fehlerdiagnose von Netzwerkdiensten. arXiv Vorabdruck arXiv:2405.09724v1](https://arxiv.org/abs/2405.09724v1).\n",
" * Rezension [Yamauchi, H., et al. (2025). Quantenspektroskopie der topologischen Dynamik mittels eines supersymmetrischen Hamilton-Operators. arXiv Vorabdruck arXiv:2511.23169v1](https://arxiv.org/abs/2511.23169v1).\n",
" * Rezension [Wang, Y., et al. (2025). Δ-Motiv: Subgraph-Isomorphismus in großem Maßstab durch datenzentrierte Parallelität. arXiv Vorabdruck arXiv:2508.21287](https://arxiv.org/abs/2508.21287).\n",
" * Rezension [Paterakis, N. G., et al. (2025). Quantencomputing in der Rechenlandschaft der Leistungselektronik: Vision und Realität. arXiv Vorabdruck arXiv:2507.02577](https://arxiv.org/abs/2507.02577).\n",
" * Rezension [Gharibyan, H., et al. (2023). Hierarchisches Lernen für Quanten-ML: Neuartige Trainingstechnik für groß angelegte variationale Quantenschaltungen. arXiv Vorabdruck arXiv:2311.12929](https://arxiv.org/abs/2311.12929).\n",
" * Lesen Sie die [Fallstudie zu Mitsubishi Chemical Corp](https://q-ctrl.com/case-study/unlocking-new-performance-capability-in-quantum-chemistry).\n",
" * Lesen Sie die [Fallstudie zur Bank Redacted](https://q-ctrl.com/case-study/reducing-quantum-compute-costs-2-500x-with-fire-opal).\n",
" * Lesen Sie die [Fallstudie „ BlueQubit](https://q-ctrl.com/case-study/enabling-data-loading-for-quantum-machine-learning-with-fire-opal) “.\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": 5
}