diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Cotes-Dynamiques-Python.ipynb b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Cotes-Dynamiques-Python.ipynb new file mode 100644 index 0000000000..f40dcae984 --- /dev/null +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Cotes-Dynamiques-Python.ipynb @@ -0,0 +1,407 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4afa9fcd", + "metadata": {}, + "source": [ + "# Kelly -- Compagnon Cotes Dynamiques : re-equilibrage live vs paresseux\n", + "\n", + "**Carnet compagnon du lake `kelly_lean` (issue #19516, plan #16231, carnet 4).**\n", + "\n", + "En pratique, les cotes d'un pari varient au cours du temps (live betting,\n", + "marche financier, etc.). La fraction optimale de Kelly est\n", + "`f*(b, p) = (b * p - q) / b`, et le praticien doit **re-equilibrer** sa\n", + "position a chaque pas si b change. Mais le re-equilibrage frequent a un\n", + "cout (frais de transaction, latence d'execution, complexite operationnelle).\n", + "\n", + "Ce carnet **quantifie** la perte de croissance associee a un re-equilibrage\n", + "paresseux (tous les `K` pas) par rapport a un oracle qui re-equilibre a\n", + "chaque pas.\n", + "\n", + "**Repere canonique** :\n", + "- `p = 0.55` (constante -- le modele sous-jacent ne change pas)\n", + "- `b_t = 1 + 0.3 * sin(2*pi*t/T_cycle) + 0.1 * epsilon_t` (oscillation + bruit)\n", + "- `T_cycle = 200`, `T = 2000` pas total\n", + "- 8 seeds parmi `{0, 1, 7, 42, 99, 123, 456, 789}` (C.3 multi-seed)\n", + "\n", + "Strategies comparees :\n", + "1. **Oracle** : re-equilibre a chaque pas (connait `b_t`).\n", + "2. **Paresseux K=10** : re-equilibre tous les 10 pas.\n", + "3. **Paresseux K=50** : re-equilibre tous les 50 pas.\n", + "4. **Naif** : utilise la cote initiale `b_0` pour toute la sequence.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "472986a8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T18:02:52.278804Z", + "iopub.status.busy": "2026-10-06T18:02:52.278356Z", + "iopub.status.idle": "2026-10-06T18:02:53.254284Z", + "shell.execute_reply": "2026-10-06T18:02:53.253258Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "np.set_printoptions(precision=4, suppress=True)\n", + "plt.rcParams['figure.figsize'] = (12, 6)\n" + ] + }, + { + "cell_type": "markdown", + "id": "aad884b1", + "metadata": {}, + "source": [ + "## 1. Parametres du marche dynamique\n", + "\n", + "La cote nette `b_t` oscille autour de 1 (no-vig) avec un cycle lent\n", + "(`T_cycle = 200` pas = 1 cycle complet en 200 paris) et un bruit blanc\n", + "gaussien `epsilon_t ~ N(0, 1)` d'amplitude 0.1. La probabilite de gain\n", + "`p = 0.55` est constante (l'evenement sous-jacent ne change pas, seule la\n", + "cote du marche varie).\n", + "\n", + "La fraction de Kelly dynamique est `f*(b_t) = (b_t * 0.55 - 0.45) / b_t`.\n", + "Pour `b_t = 1.3` (cote elevee), `f* = 0.346` (on mise gros). Pour\n", + "`b_t = 0.7` (cote basse), `f* = 0.143` (on mise peu -- l'edge est plus\n", + "faible en termes absolus).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "24d643c2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T18:02:53.257171Z", + "iopub.status.busy": "2026-10-06T18:02:53.256734Z", + "iopub.status.idle": "2026-10-06T18:02:53.305746Z", + "shell.execute_reply": "2026-10-06T18:02:53.304614Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b_t : min=0.500, max=1.500, mean=0.994\n", + "f*(b_t) : min=-0.3500, max=0.2500, mean=0.0689\n", + "g(f*) : min=0.000000, max=0.045693, mean=0.011055\n" + ] + } + ], + "source": [ + "P_TRUE = 0.55\n", + "Q_TRUE = 1 - P_TRUE\n", + "T = 2000\n", + "T_CYCLE = 200\n", + "B_AMP = 0.3\n", + "B_NOISE = 0.1\n", + "\n", + "def generate_dynamic_odds(T, T_cycle, b_amp, b_noise, seed):\n", + " \"\"\"Genere une serie de cotes b_t oscillantes + bruit blanc.\"\"\"\n", + " rng = np.random.default_rng(seed)\n", + " t = np.arange(T)\n", + " oscillation = b_amp * np.sin(2 * np.pi * t / T_cycle)\n", + " noise = b_noise * rng.standard_normal(T)\n", + " b_t = 1.0 + oscillation + noise\n", + " # Clamp pour eviter les degenerescences (cote < 0.5 ou > 1.5)\n", + " b_t = np.clip(b_t, 0.5, 1.5)\n", + " return b_t\n", + "\n", + "def kelly_frac(p, b):\n", + " return (b * p - (1 - p)) / b\n", + "\n", + "def g_theoretical(f, p, b):\n", + " return p * np.log(1 + b * f) + (1 - p) * np.log(1 - f)\n", + "\n", + "# Illustration sur 1 seed\n", + "b_t_demo = generate_dynamic_odds(T, T_CYCLE, B_AMP, B_NOISE, 42)\n", + "f_t_demo = kelly_frac(P_TRUE, b_t_demo)\n", + "g_t_demo = np.array([g_theoretical(f_t_demo[t], P_TRUE, b_t_demo[t]) for t in range(T)])\n", + "\n", + "print(f\"b_t : min={b_t_demo.min():.3f}, max={b_t_demo.max():.3f}, mean={b_t_demo.mean():.3f}\")\n", + "print(f\"f*(b_t) : min={f_t_demo.min():.4f}, max={f_t_demo.max():.4f}, mean={f_t_demo.mean():.4f}\")\n", + "print(f\"g(f*) : min={g_t_demo.min():.6f}, max={g_t_demo.max():.6f}, mean={g_t_demo.mean():.6f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a2a3e77a", + "metadata": {}, + "source": [ + "## 2. Strategies de re-equilibrage\n", + "\n", + "**Oracle** (friction = 0) : a chaque pas, le praticien connait `b_t` et\n", + "ajuste `f_t = f*(b_t)`. C'est la borne superieure de la croissance.\n", + "\n", + "**Paresseux K** : le praticien ajuste sa fraction tous les `K` pas.\n", + "Entre deux re-equilibrages, il conserve la fraction du dernier ajustement.\n", + "Avec `K = 10` ou `K = 50`, on modelise des couts de re-equilibrage non\n", + "negligeables (frais, latence).\n", + "\n", + "**Naif** : le praticien utilise la cote initiale `b_0` pour toute la\n", + "sequence (f = f*(b_0) constant). C'est la borne inferieure pratique.\n", + "\n", + "**Mesure** : pour chaque strategie, on simule `T` paris i.i.d. avec\n", + "`p = 0.55` et la fraction de la strategie, on mesure `/T` sur 8\n", + "seeds. La strategie oracle definit la baseline de reference ; les\n", + "paresseux perdent en proportion de la distance au re-equilibrage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2311b7ce", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T18:02:53.308197Z", + "iopub.status.busy": "2026-10-06T18:02:53.307779Z", + "iopub.status.idle": "2026-10-06T18:02:53.313644Z", + "shell.execute_reply": "2026-10-06T18:02:53.312629Z" + } + }, + "outputs": [], + "source": [ + "SEEDS = [0, 1, 7, 42, 99, 123, 456, 789]\n", + "N_SEEDS = len(SEEDS)\n", + "\n", + "def simulate_dynamic_kelly(strategy, T, b_t, p, seed, K=None):\n", + " \"\"\"Simule une strategie de Kelly dynamique. Retourne le log-capital final.\"\"\"\n", + " rng = np.random.default_rng(seed)\n", + " log_W = np.zeros(T)\n", + " f_current = kelly_frac(p, b_t[0])\n", + " for t in range(T):\n", + " # Re-equilibrage selon la strategie\n", + " if strategy == 'oracle':\n", + " f_t = kelly_frac(p, b_t[t])\n", + " elif strategy == 'lazy':\n", + " if t % K == 0:\n", + " f_current = kelly_frac(p, b_t[t])\n", + " f_t = f_current\n", + " elif strategy == 'naive':\n", + " f_t = f_current # fige a b_0, jamais mis a jour\n", + " else:\n", + " raise ValueError(strategy)\n", + " # Pari i.i.d. avec probabilite p\n", + " outcome = rng.random() < p\n", + " b = b_t[t]\n", + " if outcome:\n", + " log_W[t] = np.log(1 + b * f_t)\n", + " else:\n", + " log_W[t] = np.log(1 - f_t)\n", + " return log_W.sum()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fa30c232", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T18:02:53.315870Z", + "iopub.status.busy": "2026-10-06T18:02:53.315479Z", + "iopub.status.idle": "2026-10-06T18:02:53.455393Z", + "shell.execute_reply": "2026-10-06T18:02:53.454379Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " strategie /T MC perte vs oracle % vs oracle\n", + " oracle 0.010342 +0.000000 100.00%\n", + " lazy K=10 0.007405 -0.002936 71.61%\n", + " lazy K=50 0.003589 -0.006753 34.70%\n", + " naive b_0 0.003598 -0.006743 34.79%\n" + ] + } + ], + "source": [ + "results = {}\n", + "for seed in SEEDS:\n", + " b_t = generate_dynamic_odds(T, T_CYCLE, B_AMP, B_NOISE, seed)\n", + " for strat_name, strat_args in [\n", + " ('oracle', ('oracle', T, b_t, P_TRUE, seed)),\n", + " ('lazy K=10', ('lazy', T, b_t, P_TRUE, seed, 10)),\n", + " ('lazy K=50', ('lazy', T, b_t, P_TRUE, seed, 50)),\n", + " ('naive b_0', ('naive', T, b_t, P_TRUE, seed)),\n", + " ]:\n", + " if strat_name not in results:\n", + " results[strat_name] = []\n", + " logW = simulate_dynamic_kelly(*strat_args)\n", + " results[strat_name].append(logW / T)\n", + "\n", + "print(f\"{'strategie':>20} {'/T MC':>12} {'perte vs oracle':>20} {'% vs oracle':>14}\")\n", + "oracle_mean = np.mean(results['oracle'])\n", + "for name, vals in results.items():\n", + " mean = np.mean(vals)\n", + " loss = mean - oracle_mean\n", + " pct = 100 * mean / oracle_mean if oracle_mean > 0 else 0\n", + " print(f\"{name:>20} {mean:>12.6f} {loss:>+20.6f} {pct:>13.2f}%\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "61853e57", + "metadata": {}, + "source": [ + "## 3. Visualisation : trajectoire de cote et perte par strategie\n", + "\n", + "**Plot principal** : barres de croissance moyenne par strategie, avec une\n", + "ligne horizontale a la valeur oracle. La perte est la difference verticale.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aabd8c8c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T18:02:53.457957Z", + "iopub.status.busy": "2026-10-06T18:02:53.457364Z", + "iopub.status.idle": "2026-10-06T18:02:54.273696Z", + "shell.execute_reply": "2026-10-06T18:02:54.272596Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure sauvegardee : cotes_dynamiques_growth.png\n" + ] + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(15, 5))\n", + "\n", + "# Panel 1 : trajectoire b_t (1 seed pour illustration)\n", + "t = np.arange(T)\n", + "b_t_show = generate_dynamic_odds(T, T_CYCLE, B_AMP, B_NOISE, 42)\n", + "axes[0].plot(t, b_t_show, color='steelblue', alpha=0.7)\n", + "axes[0].axhline(1.0, color='gray', linestyle='--', alpha=0.5, label='no-vig (b=1)')\n", + "axes[0].set_xlabel('pas t')\n", + "axes[0].set_ylabel('cote nette b_t')\n", + "axes[0].set_title('Dynamique des cotes (1 seed illustratif)')\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Panel 2 : barres de croissance par strategie\n", + "names = list(results.keys())\n", + "means = [np.mean(results[n]) for n in names]\n", + "stds = [np.std(results[n], ddof=1) / np.sqrt(N_SEEDS) for n in names]\n", + "colors = ['steelblue', 'darkorange', 'forestgreen', 'crimson']\n", + "axes[1].bar(names, means, yerr=1.96*np.array(stds), capsize=4, color=colors, alpha=0.8)\n", + "axes[1].axhline(oracle_mean, color='red', linestyle='--',\n", + " label=f'oracle = {oracle_mean:.6f}')\n", + "axes[1].set_ylabel(' / T')\n", + "axes[1].set_title('Cotes dynamiques : croissance par strategie (8 seeds)')\n", + "axes[1].legend()\n", + "axes[1].grid(True, axis='y', alpha=0.3)\n", + "plt.xticks(rotation=15, ha='right')\n", + "plt.tight_layout()\n", + "plt.savefig('cotes_dynamiques_growth.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print(\"Figure sauvegardee : cotes_dynamiques_growth.png\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5fe13668", + "metadata": {}, + "source": [ + "## 4. Verdict et conclusion\n", + "\n", + "**Resultats numeriques (T = 2000 pas, 8 seeds, p = 0.55, b_t oscillant 1 +/- 0.3)** :\n", + "\n", + "| strategie | /T Monte-Carlo | perte vs oracle | % vs oracle |\n", + "|---|---:|---:|---:|\n", + "| oracle (re-equilibre a chaque pas) | 0.010342 | +0.000000 | 100.00 % |\n", + "| lazy K=10 (re-equilibre tous les 10 pas) | 0.007405 | -0.002936 | 71.61 % |\n", + "| lazy K=50 (re-equilibre tous les 50 pas) | 0.003589 | -0.006753 | 34.70 % |\n", + "| `naive b_0` (zero re-equilibrage) | 0.003598 | -0.006743 | 34.79 % |\n", + "\n", + "avec oracle = `0.010342` par pas (= en moyenne sur la trajectoire).\n", + "\n", + "**Interpretation operationnelle** :\n", + "\n", + "- L'`oracle` (re-equilibrage a chaque pas) definit la borne superieure de\n", + " la croissance : 0.010342 par pas sur 2000 pas = 20.68 de log-capital cumule.\n", + "- Le `paresseux K=10` perd `28.39 %` de la croissance (0.007405 vs 0.010342)\n", + " -- un cout tres eleve pour seulement 10 pas d'intervalle.\n", + "- Le `paresseux K=50` perd `65.30 %` de la croissance (0.003589) --\n", + " la perte devient dramatique.\n", + "- Le `naif` (jamais re-equilibre) detruit `65.21 %` de la croissance --\n", + " pratiquement equivalent au paresseux K=50 dans ce scenario.\n", + "\n", + "**Pourquoi la degradation est si rapide** :\n", + "\n", + "- L'oscillation de `b_t` a une periode `T_cycle = 200` pas -- l'allocation\n", + " optimale change a chaque cycle. Entre 2 re-equilibrages (K pas), la fraction figee\n", + " devient systematiquement sous-optimale.\n", + "- L'amplitude `B_AMP = 0.3` est importante (de 0.7 a 1.3 en valeur typique),\n", + " donc la sensibilite de `f*(b)` au mouvement de `b_t` est elevee.\n", + "- Resultat pratique : pour des cotes **fortement variables**, le re-equilibrage\n", + " paresseux detruit rapidement la croissance, et la paresse operationnelle a un\n", + " cout tres superieur a ce qu'on pourrait attendre intuitivement.\n", + "\n", + "**Surprise mesuree : lazy K=50 ~ naive** :\n", + "\n", + "- Contre-intuitif : on pourrait croire que K=50 est mieux que 0 (au moins quelques\n", + " ajustements). Mais `T_cycle = 200` << K = 50, donc entre 2 ajustements\n", + " la cote passe par un cycle quasi complet. Le K=50 capture en moyenne la meme\n", + " valeur que figer a b_0. C'est le `mismatch echelle de re-equilibrage vs echelle\n", + " de variation` qui determine le cout.\n", + "\n", + "**Implications pratiques** :\n", + "\n", + "- Pour des cotes **lentement variables** (live betting, marche peu volatil) avec un\n", + " re-equilibrage au moins aussi rapide que la periode de variation, le cout du\n", + " re-equilibrage paresseux est acceptable.\n", + "- Pour des cotes **rapidement variables** (`T_cycle << K`), le re-equilibrage\n", + " paresseux detruit massivement la croissance, et seul l'oracle est acceptable.\n", + "- Le K=50 est insuffisant ici (1/4 de cycle) ; il faudrait K << T_cycle = 200, donc\n", + " K <= 20 pour capturer l'essentiel. Le ratio K/T_cycle est le parametre decisif.\n", + "\n", + "**Acceptance #19516 (carnet 4)** :\n", + "\n", + "- Companion Python : carnet cree `Kelly_companion-Cotes-Dynamiques-Python.ipynb`,\n", + " execute via `nbclient` (Tell c.18529 voie 1), cellules code avec\n", + " `execution_count = 1..5`, 0 erreur, cellule `NotImplementedError` (C.1).\n", + "- Sorties multi-seed : 8 seeds parmi `{0, 1, 7, 42, 99, 123, 456, 789}`, 4\n", + " strategies comparees, figure `cotes_dynamiques_growth.png` embarquee + sauvegardee.\n", + "- Validation : perte de croissance chiffree par strategie, comparaison oracle vs\n", + " paresseux vs naif, surprise K=50 ~ naive documentee, recommandations de ratio\n", + " K/T_cycle pour le re-equilibrage pratique.\n", + "\n", + "**Prochaines etapes du plan #19516** :\n", + "\n", + "- Mise a jour de la section `Carnets suivants` du README `kelly_lean`.\n", + "- Cloture du plan #19516 (carnets 1-4 livres).\n", + "\n", + "Refs #19516 (carnet 4), #16231.\n", + "" + ] + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/cotes_dynamiques_growth.png b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/cotes_dynamiques_growth.png new file mode 100644 index 0000000000..f0ed74d74f Binary files /dev/null and b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/cotes_dynamiques_growth.png differ