{ "cells": [ { "cell_type": "markdown", "id": "d31e7ada-7707-4f25-9058-c895d1b205fc", "metadata": {}, "source": [ "---\n", "title: \"Optimización dinámica de carteras con el Portfolio Optimizer de Global Data Quantum\"\n", "description: \"Resuelva un problema de optimización dinámica a escala de servicios públicos utilizando el optimizador de cartera cuántica de Global Data Quantum.\"\n", "---\n", "\n", "{/* cspell:ignore fontsize rebalance patheffects labelsize */}\n", "\n", "\n", "\n", "# Optimización dinámica de carteras con el Portfolio Optimizer de Global Data Quantum\n", "\n" ] }, { "cell_type": "markdown", "id": "36a8cc7a-179a-45f7-b28e-a2b4bbeaabd3", "metadata": {}, "source": [ "\n", " Las funciones Qiskit son una función experimental disponible únicamente para los usuarios de los planes IBM Quantum® Premium Plan, Flex Plan y On-Prem (a través de IBM Quantum Platform API). Se trata de versiones preliminares sujetas a cambios.\n", "\n", "\n", "*Estimación de uso: Aproximadamente 55 minutos en un procesador Heron r2. (NOTA: Esto es sólo una estimación. El tiempo de ejecución real puede variar)*\n", "\n" ] }, { "cell_type": "markdown", "id": "16f9751a-3f70-4c1c-a384-78f402567279", "metadata": {}, "source": [ "\n", "\n", "## En segundo plano\n", "\n" ] }, { "cell_type": "markdown", "id": "80d86936-8073-415e-a024-2adbd0efef2a", "metadata": {}, "source": [ "El problema de la optimización dinámica de carteras tiene como objetivo encontrar la estrategia de inversión óptima a lo largo de múltiples periodos de tiempo para maximizar la rentabilidad esperada de la cartera y minimizar los riesgos, a menudo bajo ciertas restricciones como el presupuesto, los costes de transacción o la aversión al riesgo. A diferencia de la optimización de carteras estándar, que considera un único momento para reequilibrar la cartera, la versión dinámica tiene en cuenta la naturaleza evolutiva de los activos y adapta las inversiones en función de los cambios en el rendimiento de los activos a lo largo del tiempo.\n", "\n", "Este tutorial muestra cómo realizar una optimización dinámica de carteras utilizando la función Qiskit de Quantum Portfolio Optimizer. En concreto, ilustramos cómo utilizar esta función de aplicación para resolver un problema de asignación de inversiones en múltiples pasos temporales.\n", "\n", "El enfoque consiste en formular la optimización de la cartera como un problema multiobjetivo de optimización binaria cuadrática sin restricciones (QUBO). En concreto, formulamos la función QUBO $O$ para optimizar simultáneamente cuatro objetivos diferentes:\n", "\n", "* Maximizar la función de retorno $F$\n", "* Minimizar el riesgo de la inversión $R$\n", "* Minimizar los costes de transacción $C$\n", "* Cumplir las restricciones de inversión, formuladas en un plazo adicional para minimizar $P$.\n", "\n", "En resumen, para abordar estos objetivos formulamos la función QUBO como $O = -F + \\frac{\\gamma}{2} R + C + \\rho P,$ donde $\\gamma$ es el coeficiente de aversión al riesgo y $\\rho$ es el coeficiente de refuerzo de las restricciones (multiplicador de Lagrange). La formulación explícita se encuentra en la Ec. (15) de nuestro manuscrito [\\[1\\]](#references).\n", "\n", "Resolvemos utilizando un método híbrido cuántico-clásico basado en el Eigensolver Cuántico Variacional (VQE). En esta configuración, el circuito cuántico estima la función de coste, mientras que la optimización clásica se realiza mediante el algoritmo de Evolución Diferencial, lo que permite una navegación eficiente por el paisaje de soluciones. El número de qubits necesarios depende de tres factores principales: el número de activos `na`, el número de periodos de tiempo `nt`, y la resolución de bits utilizada para representar la inversión `nq`. En concreto, el número mínimo de qubits en nuestro problema es `na*nt*nq`.\n", "\n", "En este tutorial, nos centraremos en la optimización de una cartera regional basada en el índice español IBEX 35. En concreto, utilizamos una cartera de siete activos, como se indica en el cuadro siguiente:\n", "\n", "| **Cartera IBEX 35** | ACS.MC | ITX.MC | FER.MC | ELE.MC | SCYR.MC | AENA.MC | AMS.MC |\n", "| ------------------- | ------ | ------ | ------ | ------ | ------- | ------- | ------ |\n", "\n", "Reequilibramos nuestra cartera en cuatro etapas, cada una separada por un intervalo de 30 días a partir del 1 de noviembre de 2022. Cada variable de inversión se codifica mediante dos bits. El resultado es un problema que requiere 56 qubits para resolverse.\n", "\n", "Utilizamos el ansatz de Amplitudes Reales Optimizadas, una adaptación personalizada y eficiente desde el punto de vista del hardware del ansatz de Amplitudes Reales estándar, diseñado específicamente para mejorar el rendimiento de este tipo de problema de optimización financiera.\n", "\n", "La ejecución cuántica se realiza en el backend `ibm_torino` . Para una explicación detallada de la formulación del problema, la metodología y la evaluación del rendimiento, consulte el manuscrito publicado [\\[1\\]](#references).\n", "\n" ] }, { "cell_type": "markdown", "id": "3716659d-a44f-448b-a131-e0044b05d2ed", "metadata": {}, "source": [ "\n", "\n", "## Requisitos\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "49cddc2b-6759-4d18-aa1c-c38c344139d7", "metadata": {}, "outputs": [], "source": [ "!pip install qiskit-ibm-catalog\n", "!pip install pandas\n", "!pip install matplotlib\n", "!pip install yfinance" ] }, { "cell_type": "markdown", "id": "ab6114f0-fad3-4f44-809d-3ff966f2b2ea", "metadata": {}, "source": [ "\n", "\n", "## Configuración\n", "\n" ] }, { "cell_type": "markdown", "id": "689bf5f3-8332-4a7c-b62e-047566c1971f", "metadata": {}, "source": [ "Para utilizar el Optimizador de Cartera Quantum, seleccione la función a través del Catálogo de Funciones Qiskit. Necesita una cuenta IBM Quantum Premium Plan o Flex Plan con una licencia de Global Data Quantum para ejecutar esta función.\n", "\n", "En primer lugar, inicia sesión con tu [clave API](). A continuación, carga la función deseada desde el archivo « Qiskit Functions Catalog ». Aquí estás accediendo a la `quantum_portfolio_optimizer` función del catálogo mediante la `QiskitFunctionsCatalog` clase. Esta función nos permite utilizar el solucionador Quantum Portfolio Optimization predefinido.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "301a8a04-3106-478b-816e-5d5f0a3c0737", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_catalog import QiskitFunctionsCatalog\n", "\n", "catalog = QiskitFunctionsCatalog(\n", " channel=\"ibm_quantum_platform\",\n", " instance=\"INSTANCE_CRN\",\n", " # For `token`, use the 44-character API_KEY you created\n", " # and saved from the IBM Quantum Platform Home dashboard\n", " token=\"YOUR_API_KEY\",\n", ")\n", "\n", "# Access function\n", "dpo_solver = catalog.load(\"global-data-quantum/quantum-portfolio-optimizer\")" ] }, { "cell_type": "markdown", "id": "0856b7ca-8cf5-457d-ac08-df83a02852af", "metadata": {}, "source": [ "\n", "\n", "## Paso 1: Lea la cartera de entrada\n", "\n", "En este paso, cargamos datos históricos para los siete activos seleccionados del índice IBEX 35, concretamente desde **el 1 de noviembre de 2022** hasta **el 1 de abril de 2023**.\n", "\n", "Obtenemos los datos utilizando la API de Yahoo Finanzas, centrándonos en los precios de cierre. A continuación, los datos se procesan para garantizar que todos los activos tengan el mismo número de días con datos. Cualquier dato que falte (días no hábiles) se trata adecuadamente, garantizando que todos los activos estén alineados en las mismas fechas.\n", "\n", "Los datos se estructuran en DataFrame con un formato coherente en todos los activos.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "57ba1c16-4670-4557-9a16-2034be98f471", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "[*********************100%***********************] 1 of 1 completed" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Downloading data for ACS.MC...\n", "Downloading data for ITX.MC...\n", "Downloading data for FER.MC...\n", "Downloading data for ELE.MC...\n", "Downloading data for SCYR.MC...\n", "Downloading data for AENA.MC...\n", "Downloading data for AMS.MC...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "import yfinance as yf\n", "import pandas as pd\n", "\n", "# List of IBEX 35 symbols\n", "symbols = [\n", " \"ACS.MC\",\n", " \"ITX.MC\",\n", " \"FER.MC\",\n", " \"ELE.MC\",\n", " \"SCYR.MC\",\n", " \"AENA.MC\",\n", " \"AMS.MC\",\n", "]\n", "\n", "start_date = \"2022-11-01\"\n", "end_date = \"2023-4-01\"\n", "\n", "series_list = []\n", "symbol_names = [symbol.replace(\".\", \"_\") for symbol in symbols]\n", "\n", "# Create a full date index including weekends\n", "full_index = pd.date_range(start=start_date, end=end_date, freq=\"D\")\n", "\n", "for symbol, name in zip(symbols, symbol_names):\n", " print(f\"Downloading data for {symbol}...\")\n", " data = yf.download(symbol, start=start_date, end=end_date)[\"Close\"]\n", " data.name = name\n", "\n", " # Reindex to include weekends\n", " data = data.reindex(full_index)\n", "\n", " # Fill missing values (for example, weekends or holidays)\n", " # by forward/backward fill\n", " data.ffill(inplace=True)\n", " data.bfill(inplace=True)\n", "\n", " series_list.append(data)\n", "\n", "# Combine all series into a single DataFrame\n", "assets = pd.concat(series_list, axis=1)\n", "\n", "# Convert index to string for consistency\n", "assets.index = assets.index.astype(str)" ] }, { "cell_type": "markdown", "id": "574e52d6-c87e-4eb4-a2b6-eee8954231aa", "metadata": {}, "source": [ "\n", " Recomendamos ejecutar la siguiente celda para verificar que los datos se hayan descargado correctamente desde la API de Yahoo Finance. Si la descarga falla, aparecerá una notificación indicando que los datos se recuperarán de una base de datos en línea alternativa.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "be78a997-678f-4bd0-a0c5-1a04c8a94afb", "metadata": {}, "outputs": [], "source": [ "if (\n", " assets.isna().values.any()\n", "): # If has nan values, load the data from the fallback online database\n", " print(\n", " \"WARNING: Asset data format is invalid or incomplete. \"\n", " \"Loading data from the remote backup database.\"\n", " )\n", "\n", " url = \"https://raw.githubusercontent.com/Global-Data-Quantum/PortfolioData/1f3ebb95fdef245014a04d4273f688a2951e0061/data/qpo_tutorial_ibex.csv\"\n", " assets = pd.read_csv(url, index_col=0)" ] }, { "cell_type": "markdown", "id": "fbd9f5aa-dc2d-48bb-805f-ae0d55aedc54", "metadata": {}, "source": [ "\n", "\n", "## Paso 2: Definir los datos de entrada del problema\n", "\n" ] }, { "cell_type": "markdown", "id": "8f066377-62fb-46fd-ae1a-1058d99c5f7f", "metadata": {}, "source": [ "Los parámetros necesarios para definir el problema QUBO se configuran en el diccionario `qubo_settings` . Definimos el número de pasos temporales (`nt`), el número de bits para la especificación de la inversión (`nq`) y la ventana temporal para cada paso temporal (`dt`). Además, fijamos la inversión máxima por activo, el coeficiente de aversión al riesgo, la comisión de transacción y el coeficiente de restricción (véase [nuestro documento](https://arxiv.org/pdf/2412.19150) para más detalles sobre la formulación del problema). Estos ajustes nos permiten adaptar el problema QUBO al escenario de inversión específico.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "d5e8137c-e3ef-45a7-928f-3bd6d02402cd", "metadata": {}, "outputs": [], "source": [ "qubo_settings = {\n", " \"nt\": 4,\n", " \"nq\": 2,\n", " \"dt\": 30,\n", " # maximum investment per asset is 2**nq/max_investment = 80%\n", " \"max_investment\": 5,\n", " \"risk_aversion\": 1000.0,\n", " \"transaction_fee\": 0.01,\n", " \"restriction_coeff\": 1.0,\n", "}" ] }, { "cell_type": "markdown", "id": "06608c0a-34ac-47b4-84c5-da98458e6dab", "metadata": {}, "source": [ "El `optimizer_settings` diccionario configura el proceso de optimización, incluyendo parámetros como `num_generations` para el número de iteraciones y `population_size` para el número de soluciones candidatas por generación. Otros parámetros controlan aspectos como la tasa de recombinación, los trabajos en paralelo, el tamaño de los lotes y el rango de mutaciones. Además, los parámetros primitivos, como `estimator_shots`, `estimator_precision`, y `sampler_shots`, definen las configuraciones del estimador y el muestreador cuánticos para el proceso de optimización.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "d4946f9e-91bf-49a2-9970-2239c877b544", "metadata": {}, "outputs": [], "source": [ "optimizer_settings = {\n", " \"de_optimizer_settings\": {\n", " \"num_generations\": 20,\n", " \"population_size\": 40,\n", " \"recombination\": 0.4,\n", " \"max_parallel_jobs\": 5,\n", " \"max_batchsize\": 4,\n", " \"mutation_range\": [0.0, 0.25],\n", " },\n", " \"optimizer\": \"differential_evolution\",\n", " \"primitive_settings\": {\n", " \"estimator_shots\": 25_000,\n", " \"estimator_precision\": None,\n", " \"sampler_shots\": 100_000,\n", " },\n", "}" ] }, { "cell_type": "markdown", "id": "fd9b0940-54b2-4ad1-833e-36b61b90cb46", "metadata": {}, "source": [ "\n", " El número total de circuitos depende de los parámetros de `optimizer_settings` y se calcula como `(num_generations + 1) * population_size`.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "866224f8-c27e-43c6-8906-dab87d7a4219", "metadata": {}, "source": [ "El `ansatz_settings` diccionario configura el ansatz del circuito cuántico. El `ansatz` parámetro especifica el uso del `\"optimized_real_amplitudes\"` enfoque, que es un ansatz eficiente en términos de hardware diseñado para problemas de optimización financiera. La `multiple_passmanager` opción, que permite el uso de múltiples gestores de pases (incluido el gestor de pases local predeterminado de Qiskit y el servicio de transpilador basado en IA de Qiskit) para mejorar el rendimiento y la eficiencia de la optimización de circuitos, está actualmente desactivada porque esta función está temporalmente deshabilitada.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "0054fbb0-75f0-468a-acc9-0066eabb85dd", "metadata": {}, "outputs": [], "source": [ "ansatz_settings = {\n", " \"ansatz\": \"optimized_real_amplitudes\",\n", " \"multiple_passmanager\": False,\n", "}" ] }, { "cell_type": "markdown", "id": "76087a8d-a1f5-4adb-a96d-7c17b7c67cdf", "metadata": {}, "source": [ "Por último, ejecutamos la optimización ejecutando la función `dpo_solver.run()` , pasando las entradas preparadas. Estos incluyen el diccionario de datos de activos (`assets`), la configuración de QUBO (`qubo_settings`), los parámetros de optimización (`optimizer_settings`), y los ajustes del ansatz del circuito cuántico (`ansatz_settings`). Además, especificamos los detalles de ejecución, como el backend, y si se debe aplicar post-procesamiento a los resultados. Esto inicia el proceso de optimización dinámica de la cartera en el backend cuántico seleccionado.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "c24af785-105d-45db-a242-3f215c845cf6", "metadata": {}, "outputs": [], "source": [ "dpo_job = dpo_solver.run(\n", " assets=assets.to_dict(), # Insert assets as a dictionary\n", " qubo_settings=qubo_settings,\n", " optimizer_settings=optimizer_settings,\n", " ansatz_settings=ansatz_settings,\n", " backend_name=\"ibm_torino\",\n", " previous_session_id=[],\n", " apply_postprocess=True,\n", ")" ] }, { "cell_type": "markdown", "id": "7bc6ac05-5c0b-418e-9978-8dd5bdcd97c4", "metadata": {}, "source": [ "\n", "\n", "## Paso 3: Analizar los resultados de la optimización\n", "\n" ] }, { "cell_type": "markdown", "id": "0c248fb7-0605-4456-a5ac-ced65b7593e7", "metadata": {}, "source": [ "En esta sección, extraemos y mostramos la solución con el menor coste objetivo a partir de los resultados de la optimización. Junto con el coste objetivo mínimo, también presentamos métricas clave asociadas a la solución asociada, incluida la desviación de restricción, el ratio de Sharpe y el rendimiento de la inversión.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "3b41e88f-9f5e-4663-a225-ec732544a36a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'time_step_0': {'ACS.MC': 0.11764705882352941,\n", " 'ITX.MC': 0.20588235294117646,\n", " 'FER.MC': 0.38235294117647056,\n", " 'ELE.MC': 0.058823529411764705,\n", " 'SCYR.MC': 0.0,\n", " 'AENA.MC': 0.058823529411764705,\n", " 'AMS.MC': 0.17647058823529413},\n", " 'time_step_1': {'ACS.MC': 0.11428571428571428,\n", " 'ITX.MC': 0.14285714285714285,\n", " 'FER.MC': 0.2,\n", " 'ELE.MC': 0.02857142857142857,\n", " 'SCYR.MC': 0.42857142857142855,\n", " 'AENA.MC': 0.0,\n", " 'AMS.MC': 0.08571428571428572},\n", " 'time_step_2': {'ACS.MC': 0.0,\n", " 'ITX.MC': 0.09375,\n", " 'FER.MC': 0.3125,\n", " 'ELE.MC': 0.34375,\n", " 'SCYR.MC': 0.0,\n", " 'AENA.MC': 0.0,\n", " 'AMS.MC': 0.25},\n", " 'time_step_3': {'ACS.MC': 0.3939393939393939,\n", " 'ITX.MC': 0.09090909090909091,\n", " 'FER.MC': 0.12121212121212122,\n", " 'ELE.MC': 0.18181818181818182,\n", " 'SCYR.MC': 0.0,\n", " 'AENA.MC': 0.0,\n", " 'AMS.MC': 0.21212121212121213}}" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the results of the job\n", "dpo_result = dpo_job.result()\n", "\n", "# Show the solution strategy\n", "dpo_result[\"result\"]" ] }, { "cell_type": "code", "execution_count": null, "id": "48b545ed-5350-4a72-b792-ad4c4400c833", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Minimum Objective Cost Found: -3.67\n", "Best Solution:\n", " - Restriction Deviation: 40.0%\n", " - Sharpe Ratio: 14.54\n", " - Return: 0.28\n" ] } ], "source": [ "import pandas as pd\n", "\n", "# Get results from the job\n", "dpo_result = dpo_job.result()\n", "\n", "# Convert metadata to a DataFrame, excluding 'session_id'\n", "df = pd.DataFrame(dpo_result[\"metadata\"][\"all_samples_metrics\"])\n", "\n", "# Find the minimum objective cost\n", "min_cost = df[\"objective_costs\"].min()\n", "print(f\"Minimum Objective Cost Found: {min_cost:.2f}\")\n", "\n", "# Extract the row with the lowest cost\n", "best_row = df[df[\"objective_costs\"] == min_cost].iloc[0]\n", "\n", "# Display the results associated with the best solution\n", "print(\"Best Solution:\")\n", "print(f\" - Restriction Deviation: {best_row['rest_breaches']}%\")\n", "print(f\" - Sharpe Ratio: {best_row['sharpe_ratios']:.2f}\")\n", "print(f\" - Return: {best_row['returns']:.2f}\")" ] }, { "cell_type": "markdown", "id": "09116415-afbc-4e89-b3fd-9464b8f1d5df", "metadata": {}, "source": [ "El siguiente código muestra cómo visualizar y comparar la distribución de costes de un algoritmo de optimización con una distribución de muestreo aleatorio. Del mismo modo, exploramos el panorama de la función objetivo QUBO (que se puede cargar desde la salida de la función) evaluándola con inversiones aleatorias. Trazamos ambas distribuciones normalizadas en amplitud para facilitar la comparación de cómo el proceso de optimización difiere del muestreo aleatorio en términos de coste. Además, el resultado obtenido con DOCPlex se incluye como una línea de referencia vertical discontinua que sirve como referencia clásica. Utilizamos la [versión gratuita de DOCPlex](https://ibmdecisionoptimization.github.io/docplex-doc/), la IBM® biblioteca de código abierto para la optimización matemática en Python, para resolver el mismo problema de forma clásica.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "2dd1d015-3015-409f-b5d9-016c8ff592ce", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from matplotlib.ticker import MultipleLocator\n", "import matplotlib.patheffects as patheffects\n", "\n", "\n", "def plot_normalized(dpo_x, dpo_y_normalized, random_x, random_y_normalized):\n", " \"\"\"\n", " Plots normalized results for two sampling results.\n", "\n", " Parameters:\n", " dpo_x (array-like): X-values for the VQE Post-processed curve.\n", " dpo_y_normalized (array-like): Y-values (normalized) for the\n", " VQE Post-processed curve.\n", " random_x (array-like): X-values for the Noise (Random) curve.\n", " random_y_normalized (array-like): Y-values (normalized) for the\n", " Noise (Random) curve.\n", " \"\"\"\n", " plt.figure(figsize=(6, 3))\n", " plt.tick_params(axis=\"both\", which=\"major\", labelsize=12)\n", "\n", " # Define custom colors\n", " colors = [\"#4823E8\", \"#9AA4AD\"]\n", "\n", " # Plot DPO results\n", " (line1,) = plt.plot(\n", " dpo_x, dpo_y_normalized, label=\"VQE Postprocessed\", color=colors[0]\n", " )\n", " line1.set_path_effects(\n", " [patheffects.withStroke(linewidth=3, foreground=\"white\")]\n", " )\n", "\n", " # Plot Random results\n", " (line2,) = plt.plot(\n", " random_x, random_y_normalized, label=\"Noise (Random)\", color=colors[1]\n", " )\n", " line2.set_path_effects(\n", " [patheffects.withStroke(linewidth=3, foreground=\"white\")]\n", " )\n", "\n", " # Set X-axis ticks to increment by 5 units\n", " plt.gca().xaxis.set_major_locator(MultipleLocator(5))\n", "\n", " # Axis labels and legend\n", " plt.xlabel(\"Objective cost\", fontsize=14)\n", " plt.ylabel(\"Normalized Counts\", fontsize=14)\n", "\n", " # Add DOCPLEX reference line\n", " plt.axvline(\n", " x=-4.11, color=\"black\", linestyle=\"--\", linewidth=1, label=\"DOCPlex\"\n", " ) # DOCPlex value\n", " plt.ylim(bottom=0)\n", "\n", " plt.legend()\n", "\n", " # Adjust layout\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "6b662682-279b-48b5-bc61-681846cf3c00", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "from collections import defaultdict\n", "\n", "# ================================\n", "# STEP 1: DPO COST DISTRIBUTION\n", "# ================================\n", "\n", "# Extract data from DPO results\n", "counts_list = dpo_result[\"metadata\"][\"all_samples_metrics\"][\n", " \"counts\"\n", "] # List of how many times each solution occurred\n", "cost_list = dpo_result[\"metadata\"][\"all_samples_metrics\"][\n", " \"objective_costs\"\n", "] # List of corresponding objective function values (costs)\n", "\n", "# Round costs to one decimal and accumulate counts for each unique cost\n", "dpo_counter = defaultdict(int)\n", "for cost, count in zip(cost_list, counts_list):\n", " rounded_cost = round(cost, 1)\n", " dpo_counter[rounded_cost] += count\n", "\n", "# Prepare data for plotting\n", "dpo_x = sorted(dpo_counter.keys()) # Sorted list of cost values\n", "dpo_y = [dpo_counter[c] for c in dpo_x] # Corresponding counts\n", "\n", "# Normalize the counts to the range [0, 1] for better comparison\n", "dpo_min = min(dpo_y)\n", "dpo_max = max(dpo_y)\n", "dpo_y_normalized = [\n", " (count - dpo_min) / (dpo_max - dpo_min) for count in dpo_y\n", "]\n", "\n", "# ================================\n", "# STEP 2: RANDOM COST DISTRIBUTION\n", "# ================================\n", "\n", "# Read the QUBO matrix\n", "qubo = np.array(dpo_result[\"metadata\"][\"qubo\"])\n", "\n", "bitstring_length = qubo.shape[0]\n", "num_random_samples = 100_000 # Number of random samples to generate\n", "random_cost_counter = defaultdict(int)\n", "\n", "# Generate random bitstrings and calculate their cost\n", "for _ in range(num_random_samples):\n", " x = np.random.randint(0, 2, size=bitstring_length)\n", " cost = float(x @ qubo @ x.T)\n", " rounded_cost = round(cost, 1)\n", " random_cost_counter[rounded_cost] += 1\n", "\n", "# Prepare random data for plotting\n", "random_x = sorted(random_cost_counter.keys())\n", "random_y = [random_cost_counter[c] for c in random_x]\n", "\n", "# Normalize the random cost distribution\n", "random_min = min(random_y)\n", "random_max = max(random_y)\n", "random_y_normalized = [\n", " (count - random_min) / (random_max - random_min) for count in random_y\n", "]\n", "\n", "# ================================\n", "# STEP 3: PLOTTING\n", "# ================================\n", "\n", "plot_normalized(dpo_x, dpo_y_normalized, random_x, random_y_normalized)" ] }, { "cell_type": "markdown", "id": "457ecd2e-50e5-49ea-b435-fb26e43a3266", "metadata": {}, "source": [ "El gráfico muestra cómo el optimizador cuántico de carteras devuelve sistemáticamente estrategias de inversión optimizadas.\n", "\n" ] }, { "cell_type": "markdown", "id": "4f996a6d-b696-4d33-b832-97bda30b3969", "metadata": {}, "source": [ "\n", "\n", "## Referencias\n", "\n", "\\[1] [Nodar, Álvaro, Irene De León, Danel Arias, Ernesto Mamedaliev, María Esperanza Molina, Manuel Martín-Cordero, Senaida Hernández-Santana et al. «Ampliación del solucionador variacional de valores propios cuánticos para el « Portfolio Optimization » dinámico» arXiv Preimpresión arXiv:2412.19150 (2024)](https://arxiv.org/pdf/2412.19150).\n", "\n" ] }, { "cell_type": "markdown", "id": "819996e9-e98d-4753-9d6a-be0ab443088f", "metadata": {}, "source": [ "\n", "\n", "## Encuesta tutorial\n", "\n", "Tómese un minuto para comentar este tutorial. Su opinión nos ayudará a mejorar nuestra oferta de contenidos y la experiencia de los usuarios.\n", "[Enlace a la encuesta](https://your.feedback.ibm.com/jfe/form/SV_3BLFkNVEuh0QBWm)\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" }, "hours": 1.5, "qpuSeconds": 3300 }, "nbformat": 4, "nbformat_minor": 2 }