{ "cells": [ { "cell_type": "markdown", "id": "dde95705", "metadata": {}, "source": [ "---\n", "title: \"Gerenciamento de desempenho - Uma função Qiskit da Q-CTRL Fire Opal\"\n", "description: \"Aplique a supressão automatizada de erros usando o Fire Opal Performance Management da Q-CTRL\"\n", "---\n", "\n", "{/* cspell:ignore fontsize, Mundada, Yamauchi, supersymmetric, Paterakis, Gharibyan */}\n", "\n", "\n", "\n", "# Gerenciamento de desempenho: uma função Qiskit da Q-CTRL Fire Opal\n", "\n", "*Consulte a [referência da API](/docs/api/functions/q-ctrl-performance-management)*\n", "\n", "\n", " As funções do Qiskit são um recurso experimental disponível apenas para usuários dos planos IBM Quantum® Premium Plan, Flex Plan e On-Prem (via IBM Quantum Platform API). Eles estão no status de versão prévia e estão sujeitos a alterações.\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", " O código nesta página foi desenvolvido utilizando os seguintes requisitos.\n", " Recomendamos usar essas versões ou mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.3.1\n", " qiskit-ibm-runtime~=0.45.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "c1732b45", "metadata": {}, "source": [ "\n", "\n", "## Visão geral\n", "\n", "O Fire Opal Performance Management simplifica para qualquer pessoa a obtenção de resultados significativos de computadores quânticos em escala, sem a necessidade de ser especialista em hardware quântico. Ao executar circuitos com o Fire Opal Performance Management, as técnicas de supressão de erros orientadas por IA são aplicadas automaticamente, permitindo o dimensionamento de problemas maiores com mais portas e qubits. Essa abordagem reduz o número de disparos necessários para chegar à resposta correta, sem acréscimo de sobrecarga, o que resulta em uma economia significativa de tempo e custo de computação.\n", "\n", "O Gerenciamento de desempenho suprime os erros e aumenta a probabilidade de obter a resposta correta em um hardware com ruído. Em outras palavras, ele aumenta a relação sinal-ruído. A imagem a seguir mostra como o aumento da precisão possibilitado pelo Gerenciamento de Desempenho pode reduzir a necessidade de disparos adicionais no caso de um algoritmo de Transformada de Fourier Quântica de 10 qubits. Com apenas 30 disparos, o Q-CTRL atinge o limite de confiança de 99%, enquanto o padrão (`QiskitRuntime` Sampler, `optimization_level`=3 e `resilience_level`=1, `ibm_sherbrooke`) requer 170.000 disparos. Ao obter a resposta certa mais rapidamente, você economiza um tempo de execução de computação significativo.\n", "\n", "![Visualização do tempo de execução aprimorado](https://eu-de.quantum.cloud.ibm.com/docs/images/guides/qctrl-performance-management/achieve_more.svg)\n", "\n", "A função de gerenciamento de desempenho pode ser usada com qualquer algoritmo, e você pode utilizá-la facilmente no lugar das [primitivas](/docs/guides/primitives) padrão do `Qiskit Runtime`. Nos bastidores, várias técnicas de supressão de erros atuam em conjunto para evitar que erros ocorram durante a execução. Todos os métodos de pipeline do Fire Opal vêm pré-configurados e são independentes de algoritmos, o que significa que você sempre obtém o melhor desempenho desde o início.\n", "\n", "Para obter acesso ao Performance Management, [entre em contato com a Q-CTRL](https://form.typeform.com/to/uOAVDnGg?typeform-source=q-ctrl.com).\n", "\n" ] }, { "cell_type": "markdown", "id": "5f761442", "metadata": {}, "source": [ "\n", "\n", "## Descrição\n", "\n", "O Fire Opal Performance Management tem duas opções de execução que são semelhantes às primitivas do site Qiskit Runtime, de modo que você pode facilmente trocar o Q-CTRL Sampler e o Estimator. O fluxo de trabalho geral para usar a função Gerenciamento de desempenho é o seguinte:\n", "\n", "1. Defina seu circuito (e operadores no caso do Estimador).\n", "2. Execute o circuito.\n", "3. Recuperar os resultados.\n", "\n", "Para reduzir o ruído do hardware, o Fire Opal emprega uma série de técnicas de supressão de erros orientadas por IA, descritas na imagem a seguir. Com o Fire Opal, todo o pipeline é totalmente automatizado, sem necessidade de configuração.\n", "\n", "O pipeline do Fire Opal elimina a necessidade de sobrecarga adicional, como o aumento do tempo de execução quântico ou qubits físicos extras. Observe que o tempo de processamento clássico continua sendo um fator (consulte a seção [Benchmarks](#benchmarks) para obter estimativas, em que \"Tempo total\" reflete o processamento clássico e quântico). Em contraste com a atenuação de erros, que requer sobrecarga na forma de amostragem, a supressão de erros do Fire Opal funciona nos níveis de porta e de pulso para lidar com várias fontes de ruído e evitar a probabilidade de ocorrência de um erro. Ao evitar erros, a necessidade de um pós-processamento caro é eliminada.\n", "\n", "A imagem a seguir mostra os métodos de supressão de erros automatizados pelo Fire Opal Performance Management.\n", "\n", "![Visualização do pipeline de supressão de erros](https://eu-de.quantum.cloud.ibm.com/docs/images/guides/qctrl-performance-management/error_suppression.svg)\n", "\n", "A função oferece duas primitivas, Sampler e Estimator, e as entradas e saídas de ambas ampliam a especificação implementada para [as primitivas](/docs/guides/primitive-input-output#pubs) Qiskit Runtime V2.\n", "\n" ] }, { "cell_type": "markdown", "id": "64534d1a", "metadata": {}, "source": [ "\n", "\n", "## Referências\n", "\n", "Os resultados [de benchmarking algorítmico publicados](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.20.024034) demonstram uma melhoria significativa no desempenho de vários algoritmos, incluindo Bernstein-Vazirani, transformada quântica de Fourier, busca de Grover, algoritmo de otimização quântica aproximada e eigensolver quântico variacional. O restante desta seção fornece mais detalhes sobre os tipos de algoritmos que podem ser executados, bem como o desempenho e os tempos de execução esperados.\n", "\n", "Os estudos independentes a seguir demonstram como o Gerenciamento de Desempenho da Q-CTRL permite a pesquisa algorítmica em escala recorde:\n", "\n", "* [Kernels quânticos parametrizados com eficiência energética para diagnóstico de falhas em serviços de rede](https://arxiv.org/abs/2405.09724v1) - aprendizado de kernel quântico de até 50 qubits\n", "* [Estimativa de diferença de fase quântica baseada em tensor para demonstração em larga escala](https://arxiv.org/abs/2408.04946) - estimativa de fase quântica de até 33 qubits\n", "* [Aprendizado hierárquico para ML quântico: nova técnica de treinamento para circuitos quânticos variacionais de larga escala](https://arxiv.org/abs/2311.12929) - carregamento de dados quânticos de até 21 qubits\n", "\n", "A tabela a seguir fornece um guia aproximado sobre a precisão e os tempos de execução de execuções anteriores de benchmarking em `ibm_fez`. O desempenho em outros dispositivos pode variar. O tempo de uso é baseado em uma suposição de 10.000 disparos por circuito. O \"Número de qubits\" indicado não é uma limitação rígida, mas representa limites aproximados em que você pode esperar uma precisão de solução extremamente consistente. Problemas de tamanhos maiores foram resolvidos com sucesso, e os testes além desses limites são incentivados.\n", "\n", "| Exemplo | Número de qubits | Precisão | Medida de precisão | Tempo Total (s) | Uso do tempo de execução (s) | Primitivo (modo) |\n", "| ------------------------------------------------------------- | ---------------- | -------- | -------------------------------------------------------------------------------------------------------- | ----------------------- | ---------------------------- | ---------------- |\n", "| Bernstein-Vazirani | 50Q | 100% | Taxa de sucesso (porcentagem de execuções em que a resposta correta é a bitstring de contagem mais alta) | 22 | 8 | Amostra |\n", "| Transformada quântica de Fourier | 30Q | 100% | Taxa de sucesso (porcentagem de execuções em que a resposta correta é a bitstring de contagem mais alta) | 22 | 8 | Amostra |\n", "| Estimativa de fase quântica | 30Q | 99.9998% | Precisão do ângulo encontrado: `1- abs(real_angle - angle_found)/pi` | 22 | 8 | Amostra |\n", "| Simulação quântica: Modelo de Ising (15 etapas) | 20Q | 99.775% | $A$ (definido abaixo) | 60 (por etapa) | 15 (por etapa) | Orçador |\n", "| Simulação quântica 2: dinâmica molecular (20 pontos de tempo) | 34Q | 96.78% | $A_{mean}$ (definido abaixo) | 10 (por ponto de tempo) | 6 (por ponto de tempo) | Orçador |\n", "\n", "Definição da precisão da medição de um valor de expectativa - a métrica $A$ é definida da seguinte forma:\n", "\n", "$$\n", "A = 1 - \\frac{|\\epsilon^{ideal} - \\epsilon^{meas}|}{\\epsilon^{ideal}_{max} - \\epsilon^{ideal}_{min}},\n", "$$\n", "\n", "em que $\\epsilon^{ideal}$ = valor esperado ideal, $\\epsilon^{meas}$ = valor esperado medido, $\\epsilon^{ideal}_{max} $ = valor máximo ideal e $\\epsilon^{ideal}_{min}$ = valor mínimo ideal. $A_{mean}$ é simplesmente a média do valor de $A$ em várias medições.\n", "\n", "Essa métrica é usada porque é invariável a mudanças globais e escalonamento no intervalo de valores atingíveis. Em outras palavras, independentemente de você mudar o intervalo de possíveis valores de expectativa para cima ou para baixo ou aumentar o spread, o valor de $A$ deve permanecer consistente.\n", "\n" ] }, { "cell_type": "markdown", "id": "870af0fe", "metadata": {}, "source": [ "\n", "\n", "## Introdução\n", "\n", "O Fire Opal Performance Management utiliza o Qiskit v`2.0.0`, que é a versão recomendada. As versões compatíveis são Qiskit >=v`2.0.0`.\n", "Autentique-se usando sua [chave de API IBM Quantum Platform](http://quantum.cloud.ibm.com/) e selecione a função Qiskit da seguinte forma. (Este trecho pressupõe que você já tenha [salvo sua conta](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) no seu ambiente local.)\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", " Se você quiser usar um backend que esta função ainda não suporta, [entre em contato com a Q-CTRL](https://form.typeform.com/to/iuujEAEI?typeform-source=q-ctrl.com) para solicitar a adição desse suporte.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "2947b5c3", "metadata": {}, "source": [ "\n", "\n", "## Estimador primitivo\n", "\n" ] }, { "cell_type": "markdown", "id": "df2788d5", "metadata": {}, "source": [ "\n", "\n", "### Exemplo de estimador\n", "\n", "Use a primitiva Estimator do Fire Opal Performance Management para determinar o valor esperado de um único par circuito-observável.\n", "\n" ] }, { "cell_type": "markdown", "id": "82932760", "metadata": {}, "source": [ "Além dos pacotes `qiskit-ibm-catalog` e `qiskit` , você também usará o pacote `numpy` para executar este exemplo. Você pode instalar esse pacote descomentando a célula a seguir se estiver executando este exemplo em um notebook usando o kernel IPython.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "70bb93ef", "metadata": {}, "outputs": [], "source": [ "# %pip install numpy" ] }, { "cell_type": "markdown", "id": "02b2a79a", "metadata": {}, "source": [ "**1. Criar o circuito**\n", "\n", "Como exemplo, gere um operador Hermitiano aleatório e um observável para inserir na função Performance Management.\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. Executar o circuito**\n", "\n", "Execute o circuito e, opcionalmente, defina o backend e o número de disparos.\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": [ "Você pode usar as conhecidas [APIs](/docs/guides/serverless) do Qiskit Serverless para verificar o status da sua carga de trabalho do Qiskit Function:\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. Recuperar o resultado**\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": [ "Os resultados têm o mesmo formato que [os resultados do](/docs/guides/estimator-input-output) Estimator:\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", "## Primitiva Sampler\n", "\n" ] }, { "cell_type": "markdown", "id": "b1300f06", "metadata": {}, "source": [ "\n", "\n", "### Exemplo de amostrador\n", "\n", "Use a primitiva Sampler do Fire Opal Performance Management para executar um circuito Bernstein-Vazirani. Esse algoritmo, usado para encontrar uma cadeia oculta a partir das saídas de uma função de caixa preta, é um algoritmo de benchmarking comum porque há uma única resposta correta.\n", "\n" ] }, { "cell_type": "markdown", "id": "144e48f3", "metadata": {}, "source": [ "**1. Criar o circuito**\n", "\n", "Defina a resposta correta para o algoritmo, a cadeia de bits oculta e o circuito Bernstein-Vazirani. Você pode ajustar a largura do circuito simplesmente alterando o endereço `circuit_width`.\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. Executar o circuito**\n", "\n", "Execute o circuito e, opcionalmente, defina o backend e o número de disparos.\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": [ "Verifique [o status](/docs/guides/functions-get-started#check-job-status) da sua carga de trabalho do Qiskit Function ou obtenha [os resultados](/docs/guides/functions-get-started#retrieve-results) da seguinte maneira:\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. Recuperar o resultado**\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. Plotar as principais cadeias de bits**\n", "\n", "Trace o bitstring com as contagens mais altas para ver se o bitstring oculto era o modo.\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": [ "A bitstring oculta é destacada em roxo e deve ser a bitstring com o maior número de contagens.\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "8106d906", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_top_bitstrings(counts, hidden_bitstring)" ] }, { "cell_type": "markdown", "id": "d8104000b3d94c69", "metadata": {}, "source": [ "\n", "\n", "## Log de mudanças\n", "\n", "* 2026-02-20: Aviso de descontinuação - o campo `provider_job_ids` de metadados será descontinuado em 30 dias na versão 0.13.0. Os usuários podem acessar o ID da tarefa por meio `job_id()` do método do serviço de tempo de execução.\n", "* 11/02/2026: Agora oferecemos suporte para `ibm_miami`e adicionamos metadados de execução ao `PubResult`.\n", "\n" ] }, { "cell_type": "markdown", "id": "bb33258d", "metadata": {}, "source": [ "\n", "\n", "## Obtenha suporte\n", "\n", "Em caso de dúvidas ou problemas, [entre em contato com a Q-CTRL](https://form.typeform.com/to/iuujEAEI).\n", "\n" ] }, { "cell_type": "markdown", "id": "2fe4a6ea", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Solicite acesso ao [Q-CTRL Performance Management](/functions?id=q-ctrl-performance-management).\n", " * Consulte a [referência da API](/docs/api/functions/q-ctrl-performance-management) para esta função do Qiskit.\n", " * Experimente o [modelo Ising de campo transversal com](/docs/tutorials/transverse-field-ising-model) o tutorial de gerenciamento de desempenho da Q-CTRL.\n", " * Experimente a [Estimativa de Fase Quântica com](/docs/tutorials/quantum-phase-estimation-qctrl) o tutorial “ Qiskit Functions ” (Estimativa de Fase Quântica) da Q-CTRL\n", " * Avaliação [Mundada P. S., et al. (2023). Avaliação comparativa experimental de um fluxo de trabalho automatizado e determinístico de supressão de erros para algoritmos quânticos. Revisão Física Aplicada, 20, 2](https://quantum-journal.org/papers/q-2023-07-25-1067/).\n", " * Revisão [Kanno, S., et al. (2025). Estimativa da diferença de fase quântica baseada em tensores para demonstração em grande escala. arXiv pré-impressão arXiv:2408.04946](https://arxiv.org/abs/2408.04946).\n", " * Revisão [SoftBank Corp, Experiência de demonstração de um sistema de diagnóstico de falhas em serviços de comunicação utilizando o Quantum Machine Learning (blog), 30 de agosto de 2024](https://www.softbank.jp/en/corp/technology/research/topics/102/).\n", " * Revisão [Yamauchi, H., et al. (2024). Kernels quânticos parametrizados e energeticamente eficientes para diagnóstico de falhas em serviços de rede. arXiv pré-impressão arXiv:2405.09724v1](https://arxiv.org/abs/2405.09724v1).\n", " * Revisão [Yamauchi, H., et al. (2025). Espectroscopia quântica da dinâmica topológica por meio de um hamiltoniano supersimétrico. arXiv pré-impressão arXiv:2511.23169v1](https://arxiv.org/abs/2511.23169v1).\n", " * Revisão [Wang, Y., et al. (2025). Δ-Motif: Isomorfismo de subgrafo em escala por meio do paralelismo centrado em dados. arXiv pré-impressão arXiv:2508.21287](https://arxiv.org/abs/2508.21287).\n", " * Revisão [Paterakis, N. G., et al. (2025). Computação quântica no panorama computacional da eletrónica de potência: visão e realidade. arXiv pré-impressão arXiv:2507.02577](https://arxiv.org/abs/2507.02577).\n", " * Revisão [Gharibyan, H., et al. (2023). Aprendizagem hierárquica para ML quântico: nova técnica de treinamento para circuitos quânticos variacionais em grande escala. arXiv pré-impressão arXiv:2311.12929](https://arxiv.org/abs/2311.12929).\n", " * Analise [o estudo de caso da Mitsubishi Chemical Corp](https://q-ctrl.com/case-study/unlocking-new-performance-capability-in-quantum-chemistry).\n", " * Analise o [estudo de caso do banco Redacted](https://q-ctrl.com/case-study/reducing-quantum-compute-costs-2-500x-with-fire-opal).\n", " * Analise o [estudo de caso](https://q-ctrl.com/case-study/enabling-data-loading-for-quantum-machine-learning-with-fire-opal) da BlueQubit.\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 }