{ "cells": [ { "cell_type": "markdown", "id": "d31e7ada-7707-4f25-9058-c895d1b205fc", "metadata": {}, "source": [ "---\n", "title: \"Optimisation dynamique de portefeuille avec le Portfolio Optimizer de Global Data Quantum\"\n", "description: \"Résolvez un problème d'optimisation dynamique à l'échelle des services publics à l'aide du Quantum Portfolio Optimizer de Global Data Quantum.\"\n", "---\n", "\n", "{/* cspell:ignore fontsize rebalance patheffects labelsize */}\n", "\n", "\n", "\n", "# Optimisation dynamique de portefeuille avec le Portfolio Optimizer de Global Data Quantum\n", "\n" ] }, { "cell_type": "markdown", "id": "36a8cc7a-179a-45f7-b28e-a2b4bbeaabd3", "metadata": {}, "source": [ "\n", " Les fonctions Qiskit sont une fonctionnalité expérimentale disponible uniquement pour IBM Quantum® Premium Plan, Flex Plan, et On-Prem (via IBM Quantum Platform API). Elles sont en cours de publication et peuvent être modifiées.\n", "\n", "\n", "*Estimation de l'utilisation : Environ 55 minutes sur un processeur Heron r2. (NOTE : Il s'agit uniquement d'une estimation. La durée d'exécution réelle peut varier.)*\n", "\n" ] }, { "cell_type": "markdown", "id": "16f9751a-3f70-4c1c-a384-78f402567279", "metadata": {}, "source": [ "\n", "\n", "## Arrière-plan\n", "\n" ] }, { "cell_type": "markdown", "id": "80d86936-8073-415e-a024-2adbd0efef2a", "metadata": {}, "source": [ "Le problème de l'optimisation dynamique de portefeuille vise à trouver la stratégie d'investissement optimale sur plusieurs périodes afin de maximiser le rendement attendu du portefeuille et de minimiser les risques, souvent sous certaines contraintes telles que le budget, les coûts de transaction ou l'aversion au risque. Contrairement à l'optimisation de portefeuille standard, qui considère un seul moment pour rééquilibrer le portefeuille, la version dynamique tient compte de la nature évolutive des actifs et adapte les investissements en fonction des changements dans la performance des actifs au fil du temps.\n", "\n", "Ce tutoriel montre comment réaliser une optimisation dynamique de portefeuille en utilisant la fonction Qiskit de Quantum Portfolio Optimizer. Plus précisément, nous illustrons comment utiliser cette fonction d'application pour résoudre un problème d'allocation d'investissement sur plusieurs étapes temporelles.\n", "\n", "L'approche consiste à formuler l'optimisation du portefeuille comme un problème multi-objectif d'optimisation binaire quadratique sans contrainte (QUBO). Plus précisément, nous formulons la fonction QUBO $O$ pour optimiser simultanément quatre objectifs différents :\n", "\n", "* Maximiser la fonction de retour $F$\n", "* Minimiser le risque de l'investissement $R$\n", "* Minimiser les coûts de transaction $C$\n", "* Respecter les restrictions d'investissement, formulées dans une durée supplémentaire pour minimiser $P$.\n", "\n", "En résumé, pour atteindre ces objectifs, nous formulons la fonction QUBO comme suit $O = -F + \\frac{\\gamma}{2} R + C + \\rho P,$ où $\\gamma$ est le coefficient d'aversion au risque et $\\rho$ est le coefficient de renforcement des restrictions (multiplicateur de Lagrange). La formulation explicite se trouve dans l'Eq. (15) de notre manuscrit [\\[1\\]](#references).\n", "\n", "Nous résolvons le problème à l'aide d'une méthode hybride quantique-classique basée sur le Variational Quantum Eigensolver (VQE). Dans cette configuration, le circuit quantique estime la fonction de coût, tandis que l'optimisation classique est réalisée à l'aide de l'algorithme d'évolution différentielle, ce qui permet une navigation efficace dans le paysage des solutions. Le nombre de qubits requis dépend de trois facteurs principaux : le nombre d'actifs `na`, le nombre de périodes `nt`, et la résolution en bits utilisée pour représenter l'investissement `nq`. Plus précisément, le nombre minimum de qubits dans notre problème est `na*nt*nq`.\n", "\n", "Pour ce tutoriel, nous nous concentrons sur l'optimisation d'un portefeuille régional basé sur l'indice espagnol IBEX 35. Plus précisément, nous utilisons un portefeuille de sept actifs, comme indiqué dans le tableau ci-dessous :\n", "\n", "| **Portefeuille IBEX 35** | ACS.MC | ITX.MC | FER.MC | ELE.MC | SCYR.MC | AENA.MC | AMS.MC |\n", "| ------------------------ | ------ | ------ | ------ | ------ | ------- | ------- | ------ |\n", "\n", "Nous rééquilibrons notre portefeuille en quatre étapes, chacune séparée par un intervalle de 30 jours à partir du 1er novembre 2022. Chaque variable d'investissement est codée sur deux bits. Il en résulte un problème dont la résolution nécessite 56 qubits.\n", "\n", "Nous utilisons l'ansatz Optimized Real Amplitudes, une adaptation personnalisée et efficace du point de vue matériel de l'ansatz Real Amplitudes standard, spécialement conçu pour améliorer les performances pour ce type de problème d'optimisation financière.\n", "\n", "L'exécution du quantum est réalisée sur le backend `ibm_torino` . Pour une explication détaillée de la formulation du problème, de la méthodologie et de l'évaluation des performances, veuillez vous référer au manuscrit publié [\\[1\\].](#references)\n", "\n" ] }, { "cell_type": "markdown", "id": "3716659d-a44f-448b-a131-e0044b05d2ed", "metadata": {}, "source": [ "\n", "\n", "## Exigences\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", "## Configuration\n", "\n" ] }, { "cell_type": "markdown", "id": "689bf5f3-8332-4a7c-b62e-047566c1971f", "metadata": {}, "source": [ "Pour utiliser l'Optimiseur de portefeuille Quantum, sélectionnez la fonction dans le catalogue de fonctions Qiskit. Vous devez disposer d'un compte IBM Quantum Premium Plan ou Flex Plan avec une licence de Global Data Quantum pour exécuter cette fonction.\n", "\n", "Commencez par vous authentifier à l'aide de votre [clé API](). Ensuite, chargez la fonction souhaitée à partir de l' Qiskit Functions Catalog Ici, vous accédez à la `quantum_portfolio_optimizer` fonction du catalogue à l'aide de la `QiskitFunctionsCatalog` classe. Cette fonction nous permet d'utiliser le solveur prédéfini « Quantum Portfolio Optimization ».\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", "## Étape 1 : Lire le portefeuille d'entrée\n", "\n", "Dans cette étape, nous chargeons des données historiques pour les sept actifs sélectionnés de l'indice IBEX 35, en particulier du **1er novembre 2022** au **1er avril 2023**.\n", "\n", "Nous récupérons les données en utilisant l'API de Yahoo Finance, en nous concentrant sur les prix de clôture. Les données sont ensuite traitées pour s'assurer que tous les actifs ont le même nombre de jours avec des données. Les données manquantes (jours de non-négociation) sont traitées de manière appropriée, ce qui garantit que tous les actifs sont alignés sur les mêmes dates.\n", "\n", "Les données sont structurées sur le site DataFrame avec un formatage cohérent pour tous les actifs.\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", " Nous vous recommandons d'exécuter la cellule suivante pour vérifier que les données ont été correctement téléchargées à partir de l'API Yahoo Finance. Si le téléchargement échoue, une notification indiquera que les données seront récupérées à partir d'une autre base de données en ligne.\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", "## Étape 2 : Définir les données d'entrée du problème\n", "\n" ] }, { "cell_type": "markdown", "id": "8f066377-62fb-46fd-ae1a-1058d99c5f7f", "metadata": {}, "source": [ "Les paramètres nécessaires à la définition du problème QUBO sont configurés dans le dictionnaire `qubo_settings` . Nous définissons le nombre de pas de temps (`nt`), le nombre de bits pour la spécification de l'investissement (`nq`) et la fenêtre temporelle pour chaque pas de temps (`dt`). En outre, nous fixons l'investissement maximal par actif, le coefficient d'aversion au risque, les frais de transaction et le coefficient de restriction (voir [notre article](https://arxiv.org/pdf/2412.19150) pour plus de détails sur la formulation du problème). Ces paramètres nous permettent d'adapter le problème QUBO au scénario d'investissement spécifique.\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": [ "Le `optimizer_settings` dictionnaire configure le processus d'optimisation, notamment en définissant des paramètres tels que `num_generations` pour le nombre d'itérations et `population_size` pour le nombre de solutions candidates par génération. D'autres paramètres permettent de contrôler des aspects tels que le taux de recombinaison, le nombre de tâches parallèles, la taille des lots et la plage de mutations. De plus, les paramètres de base, tels que `estimator_shots`, `estimator_precision`, et `sampler_shots`, définissent les configurations de l'estimateur et de l'échantillonneur quantiques pour le processus d'optimisation.\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", " Le nombre total de circuits dépend des paramètres de `optimizer_settings` et est calculé comme suit : `(num_generations + 1) * population_size`.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "866224f8-c27e-43c6-8906-dab87d7a4219", "metadata": {}, "source": [ "Le `ansatz_settings` dictionnaire configure l'approximation du circuit quantique. Le `ansatz` paramètre spécifie l'utilisation de `\"optimized_real_amplitudes\"` l'approche, qui est une approche efficace sur le plan matériel conçue pour les problèmes d'optimisation financière. L'option `multiple_passmanager` , qui permet d'utiliser plusieurs gestionnaires de passes (y compris le gestionnaire de passes local Qiskit par défaut et le service de transcompilation alimenté par l'IA Qiskit) afin d'améliorer les performances et l'efficacité de l'optimisation des circuits, est actuellement définie sur false car cette fonctionnalité est temporairement désactivée.\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": [ "Enfin, nous exécutons l'optimisation en lançant la fonction `dpo_solver.run()` , en passant par les entrées préparées. Il s'agit notamment du dictionnaire de données des actifs (`assets`), de la configuration de QUBO (`qubo_settings`), des paramètres d'optimisation (`optimizer_settings`) et des paramètres de l'ansatz du circuit quantique (`ansatz_settings`). En outre, nous spécifions les détails d'exécution tels que le backend et l'application éventuelle d'un post-traitement aux résultats. Le processus d'optimisation dynamique du portefeuille est alors lancé sur le backend quantique sélectionné.\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", "## Étape 3 : Analyser les résultats de l'optimisation\n", "\n" ] }, { "cell_type": "markdown", "id": "0c248fb7-0605-4456-a5ac-ced65b7593e7", "metadata": {}, "source": [ "Dans cette section, nous extrayons et affichons la solution ayant le coût objectif le plus bas à partir des résultats de l'optimisation. Outre le coût objectif minimum, nous présentons également les principales mesures associées à la solution correspondante, notamment l'écart de restriction, le ratio de Sharpe et le rendement de l'investissement.\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": [ "Le code suivant montre comment visualiser et comparer la distribution des coûts d'un algorithme d'optimisation avec une distribution d'échantillonnage aléatoire. De même, nous explorons le paysage de la fonction objective QUBO (qui peut être chargée à partir de la sortie de la fonction) en l'évaluant avec des investissements aléatoires. Nous représentons graphiquement les deux distributions normalisées en amplitude afin de faciliter la comparaison entre le processus d'optimisation et l'échantillonnage aléatoire en termes de coût. De plus, le résultat obtenu à l'aide de DOCPlex est inclus sous forme de ligne de référence verticale en pointillés afin de servir de référence classique. Nous utilisons la [version gratuite de DOCPlex](https://ibmdecisionoptimization.github.io/docplex-doc/) — la IBM® bibliothèque open source pour l'optimisation mathématique dans Python — pour résoudre le même problème de manière classique.\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": [ "Le graphique montre comment l'optimiseur quantique de portefeuille renvoie systématiquement des stratégies d'investissement optimisées.\n", "\n" ] }, { "cell_type": "markdown", "id": "4f996a6d-b696-4d33-b832-97bda30b3969", "metadata": {}, "source": [ "\n", "\n", "## Références\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. « Mise à l'échelle du solveur variationnel des valeurs propres quantiques pour l' Portfolio Optimization dynamique » arXiv prépublication 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", "## Enquête tutorielle\n", "\n", "Veuillez prendre une minute pour nous faire part de vos commentaires sur ce tutoriel. Vos commentaires nous aideront à améliorer nos offres de contenu et l'expérience des utilisateurs.\n", "[Lien vers l'enquête](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 }