{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GPT\n",
    "\n",
    "Objectif : repartir du TP 1 (régression logistique) pour implémenter GPT-2 sur les prénoms\n",
    "\n",
    "Programme :\n",
    "- algèbre linéaire en Python pur ;\n",
    "- différentiation automatique avec **ordre topologique inverse** ;\n",
    "- régression logistique **façon autodiff** ;\n",
    "- implémentation GPT (attention naïve + KV cache) ;\n",
    "- entraînement **sur le même nombre de steps** et comparaison (courbes + éval + générations)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c47d818",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3eace42",
   "metadata": {},
   "source": [
    "## Données + tokens\n",
    "\n",
    "Tokens = caractères + token `stop` (début/fin). Donc \\(T = 27\\)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "260031d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num names: 32033\n",
      "['yuheng', 'diondre', 'xavien', 'jori', 'juanluis', 'erandi', 'phia', 'samatha']\n",
      "vocab size: T = 27\n",
      "anna -> [26, 0, 13, 13, 0, 26]\n"
     ]
    }
   ],
   "source": [
    "# noms (dataset makemore)\n",
    "if not os.path.exists('input.txt'):\n",
    "    import urllib.request\n",
    "    names_url = 'https://raw.githubusercontent.com/karpathy/makemore/988aa59/names.txt'\n",
    "    urllib.request.urlretrieve(names_url, 'input.txt')\n",
    "\n",
    "names = [line.strip() for line in open('input.txt') if line.strip()]\n",
    "random.shuffle(names)\n",
    "print(f\"num names: {len(names)}\")\n",
    "print(names[:8])\n",
    "\n",
    "characters = sorted(set(''.join(names)))\n",
    "stop_token = len(characters)\n",
    "T = len(characters) + 1\n",
    "print(f\"vocab size: T = {T}\")\n",
    "\n",
    "def encode(name):\n",
    "    return [stop_token] + [characters.index(ch) for ch in name] + [stop_token]\n",
    "\n",
    "print('anna ->', encode('anna'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45ca8646",
   "metadata": {},
   "source": [
    "## 0. Algèbre linéaire en Python (snippets)\n",
    "\n",
    "Vecteurs = listes, matrices = listes de lignes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d68d43b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vecteurs\n",
    "rand_vec = lambda d, std=1: [random.gauss(0, std) for _ in range(d)]\n",
    "one_hot = lambda t, T: [1.0 if i == t else 0.0 for i in range(T)]\n",
    "ext_prod = lambda alpha, u: [alpha * ui for ui in u]\n",
    "sum_vec = lambda u, v: [ui + vi for ui, vi in zip(u, v)]\n",
    "dot_prod = lambda u, v: sum(ui * vi for ui, vi in zip(u, v))\n",
    "norm = lambda v: math.sqrt(dot_prod(v, v))\n",
    "\n",
    "# matrices\n",
    "rand_mat = lambda n, m, std=1: [rand_vec(m, std) for _ in range(n)]\n",
    "transpose = lambda M: list(zip(*M))\n",
    "mat_vec = lambda M, v: [dot_prod(mi_, v) for mi_ in M]\n",
    "mat_mat = lambda A, B: [[dot_prod(ai_, b_j) for b_j in zip(*B)] for ai_ in A]\n",
    "\n",
    "def softmax(v):\n",
    "    # snippet du poly + stabilité numérique (translation invariance)\n",
    "    m = max(v)\n",
    "    exp_v = [math.exp(vk - m) for vk in v]\n",
    "    return ext_prod(1 / sum(exp_v), exp_v)\n",
    "\n",
    "def moving_average(x, k=100):\n",
    "    out, s = [], 0.0\n",
    "    from collections import deque\n",
    "    win = deque()\n",
    "    for xi in x:\n",
    "        win.append(xi); s += xi\n",
    "        if len(win) > k: s -= win.popleft()\n",
    "        out.append(s / len(win))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edcf9d8b",
   "metadata": {},
   "source": [
    "## 1. Feature vector (régression logistique)\n",
    "\n",
    "\\(v(t_0,\\dots,t_{l-1}) = \\frac{1}{l}\\sum_{k=0}^{l-1} \\mathbf{1}_{t_k}\\)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ea385413",
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_vector(tokens, T):\n",
    "    sum_tokens = [0.0] * T\n",
    "    for token in tokens:\n",
    "        sum_tokens[token] += 1.0\n",
    "        # sum_tokens = sum_vec(sum_tokens, one_hot(token, T))  # autre façon\n",
    "    return ext_prod(1 / len(tokens), sum_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c20ff96",
   "metadata": {},
   "source": [
    "## 2. Différentiation automatique (ordre topologique inverse)\n",
    "\n",
    "Classe `Value` inspirée du poly : opérations élémentaires, puis `backward()` avec **build_topo** + parcours en ordre topologique inverse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c570d735",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Value:\n",
    "    def __init__(self, value, parents=(), dself_dparents=()):\n",
    "        self.value = value\n",
    "        self.dloss_dself = None\n",
    "        self.parents = parents\n",
    "        self.dself_dparents = dself_dparents\n",
    "\n",
    "    # operations a deux arguments (une constante est transformee en noeud)\n",
    "    def __add__(self, other):\n",
    "        other = other if isinstance(other, Value) else Value(other)\n",
    "        return # compléter\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        other = other if isinstance(other, Value) else Value(other)\n",
    "        return # compléter\n",
    "    \n",
    "    # operations d'une variable\n",
    "    def __pow__(self, n): # compléter\n",
    "    def exp(self): # compléter\n",
    "    def log(self): # compléter\n",
    "    def relu(self): # compléter\n",
    "\n",
    "    # operations derivees\n",
    "    def __neg__(self): return self * -1\n",
    "    def __radd__(self, other): return self + other\n",
    "    def __sub__(self, other): return self + (-other)\n",
    "    def __rsub__(self, other): return other + (-self)\n",
    "    def __rmul__(self, other): return self * other\n",
    "    def __truediv__(self, other): return self * other ** -1\n",
    "    def __rtruediv__(self, other): return other * self ** -1\n",
    "\n",
    "    def build_topo(self, topo=None, visited=None):\n",
    "        if topo is None: topo = []\n",
    "        if visited is None: visited = set()\n",
    "        # compléter\n",
    "        return topo, visited\n",
    "\n",
    "    def backward(self):\n",
    "        # compléter\n",
    "        # pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "302cf052",
   "metadata": {},
   "source": [
    "On reprend l'exemple 1D du cours $\\mathcal{L}(x) = \\exp( (x^2 + 1)^{0.5})$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8be1e08",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calcul explicite\n",
    "x_ = math.sqrt(3)\n",
    "L_x_ = # compléter, \n",
    "L_prime_x_ = # compléter\n",
    "print(f\"L(x) = {L_x_:.7f}, L'(x) = {L_prime_x_:.7f}\")\n",
    "# differentiation automatique\n",
    "x = Value(math.sqrt(3))\n",
    "L_x = # compléter\n",
    "L_x.backward()\n",
    "print(f\"L(x) = {L_x.value:.7f}, L'(x) = {x.dloss_dself:.7f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93e83362",
   "metadata": {},
   "outputs": [],
   "source": [
    "# on redéfinit softmax_value pour que z soit une liste de Value\n",
    "def softmax_value(z):\n",
    "    m = max(zi.value for zi in z)  # stabilite numerique\n",
    "    exp_z = [(zi - m).exp() for zi in z]\n",
    "    s = sum(exp_z)\n",
    "    return [e / s for e in exp_z]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815f6298",
   "metadata": {},
   "source": [
    "## 2 Retour sur la régression logistique (autodiff)\n",
    "\n",
    "Modèle : \\(p = \\mathrm{softmax}(M v)\\), loss = moyenne des \\(-\\log p_{t_l}\\) sur les tokens.\n",
    "\n",
    "Entraînement : SGD (batch=1) — **même nombre de steps que GPT**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92ddfc56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing matrix M to zero matrix...\n",
      "Number of parameters: 729\n",
      "logreg | step  1000/1000 | loss 2.6635 (2.6027)\n",
      "logreg done in 13.15s\n",
      "['laheyv', 'alainai', 'kbmsavrhb', 'ead', 'lrom', 'gltnyouagibgchskkeh', 'mjarbi', 'ljnxteaiig', 'seol', 'iddner']\n"
     ]
    }
   ],
   "source": [
    "def loss_logreg_autodiff(M, tokens):\n",
    "    losses = []\n",
    "    for l in range(len(tokens) - 1):\n",
    "        # calculer la loss sur les tokens et l'ajouter à la liste losses\n",
    "        loss = 0.\n",
    "    # renvoyer la loss moyenne sur les tpkens\n",
    "    return sum(losses) * (1 / len(losses))\n",
    "\n",
    "def generate_name_logreg(M_float, max_chars=100, temperature=1.0):\n",
    "    context = [stop_token]\n",
    "    out = []\n",
    "    for _ in range(max_chars):\n",
    "        v = feature_vector(context, T)\n",
    "        z = mat_vec(M_float, v)\n",
    "        p = softmax([zi / temperature for zi in z])\n",
    "        t = random.choices(range(T), weights=p)[0]\n",
    "        if t == stop_token:\n",
    "            break\n",
    "        out.append(characters[t])\n",
    "        context.append(t)\n",
    "    return ''.join(out)\n",
    "\n",
    "learning_rate_logreg = 1.0\n",
    "num_steps = 1000\n",
    "\n",
    "print(\"Initializing matrix M to zero matrix...\")\n",
    "M = [[Value(0.0) for _ in range(T)] for _ in range(T)]\n",
    "params_logreg = [p for row in M for p in row]\n",
    "print(f\"Number of parameters: {len(params_logreg)}\")\n",
    "\n",
    "hist_logreg = []\n",
    "t0 = time.time()\n",
    "for step in range(num_steps):\n",
    "    loss = ###\n",
    "    # backward pour le gradiens\n",
    "    # update des paramètres\n",
    "    if step % 100 == 0 or step == num_steps - 1:\n",
    "        print(f\"logreg | step {step + 1:5d}/{num_steps} | loss {loss.value:.4f} ({sum(hist_logreg[-100:])/100:.4f})\", end='\\r')\n",
    "print(f\"\\nlogreg done in {time.time() - t0:.2f}s\")\n",
    "\n",
    "M_logreg = [[p.value for p in row] for row in M]\n",
    "random.seed(42)\n",
    "print([generate_name_logreg(M_logreg) for _ in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a52e9cda",
   "metadata": {},
   "source": [
    "## 3. Le transformer\n",
    "\n",
    "Architecture : GPT-2 simplifié (RMSNorm, pas de biais, ReLU). Implémentation naïve + KV cache (pour génération)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0997e96",
   "metadata": {},
   "source": [
    "Fonctions pour le transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f318ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "def embed(Wte, Wpe, token, pos):\n",
    "    return # compléter\n",
    "\n",
    "def rmsnorm(x):\n",
    "    return # compléter\n",
    "\n",
    "def attention_head(q, ks, vs):\n",
    "    \"\"\" q: vecteur query, ks: liste de vecteurs keys, vs: liste de vecteurs values \"\"\"\n",
    "    return # compléter\n",
    "\n",
    "def attention_naive_1head(X, Wq, Wk, Wv):\n",
    "    Q = # matrice de vecteurs query\n",
    "    K = # matrice de vecteurs keys\n",
    "    V = # matrice de vecteurs values\n",
    "    return [attention_head(Q[l], K[:l + 1], V[:l + 1]) for l in range(len(X))]\n",
    "\n",
    "def multi_head(q, ks, vs, n_head):\n",
    "    d_h = len(q) // n_head\n",
    "    out = []\n",
    "    for h in range(n_head):\n",
    "        # compléter\n",
    "    return out\n",
    "\n",
    "def attention_naive(X, Wq, Wk, Wv, Wo, n_head):\n",
    "    return # compléter\n",
    "\n",
    "def mlp(x, W1, W2):\n",
    "    # compléter\n",
    "\n",
    "def attention_kv(x, Wq, Wk, Wv, Wo, n_head, keys, values):\n",
    "    q, k, v = mat_vec(Wq, x), mat_vec(Wk, x), mat_vec(Wv, x)\n",
    "    keys.append(k)\n",
    "    values.append(v)\n",
    "    return mat_vec(Wo, multi_head(q, keys, values, n_head))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31618aa7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# paramètres du transformer\n",
    "n_layer = 1\n",
    "n_embd = 16\n",
    "block_size = 16\n",
    "n_head = 4\n",
    "head_dim = n_embd // n_head\n",
    "mlp_dilation = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8bc855f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fonction qui renvoie une matrice de parametres initises avec une distribution gaussienne\n",
    "param_mat = lambda n, m, std=0.08: # compléter\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7074af1",
   "metadata": {},
   "source": [
    "On stocke les paramètres dans un dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9e41188",
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(42)\n",
    "state_dict = {\n",
    "    'wte': param_mat(T, n_embd), # embedding tokens\n",
    "    'wpe': param_mat(block_size, n_embd), # embedding positions\n",
    "    'lm_head': param_mat(T, n_embd), # head de prediction (matrice de régression logistique)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba55825e",
   "metadata": {},
   "source": [
    "Ajouter aux parametres les parametre du transformer et afficher le nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ac7afd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for li in range(n_layer):\n",
    "    state_dict[f'layer{li}.attn_wq'] = # matrice pour q quety\n",
    "    # etc: keys, values, output, fc1, fc2\n",
    "params_gpt = [p for mat in state_dict.values() for row in mat for p in row]\n",
    "print(f\"nombre de parametres : {len(params_gpt)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d98b7bde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre de parametres : 4192\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "def gpt_naive(tokens):\n",
    "    sd = state_dict\n",
    "    X = [rmsnorm(embed(sd['wte'], sd['wpe'], t, l)) for l, t in enumerate(tokens)]\n",
    "    for li in range(n_layer):\n",
    "        A = # attrntion\n",
    "        X = # residual\n",
    "        X = # mlp + residual + rmsnorm\n",
    "    logits = # matrice de logits\n",
    "    return logits\n",
    "\n",
    "\n",
    "\n",
    "def gpt_kv(token, pos, keys, values):\n",
    "    # compléter\n",
    "\n",
    "def sample(logits, temperature):\n",
    "    p = softmax_value([z / temperature for z in logits])\n",
    "    return random.choices(range(T), weights=[pi.value for pi in p])[0]\n",
    "\n",
    "def generate_kv(temperature=0.8):\n",
    "    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n",
    "    token, out = stop_token, []\n",
    "    for pos in range(block_size):\n",
    "        token = sample(gpt_kv(token, pos, keys, values), temperature)\n",
    "        if token == stop_token:\n",
    "            break\n",
    "        out.append(characters[token])\n",
    "    return ''.join(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6f496c6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "64ff6332",
   "metadata": {},
   "source": [
    "## 4 Entraînement GPT \n",
    "\n",
    "Méthode ADAM\n",
    "\n",
    "Même NLL que la logreg, gradient via `loss.backward()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "252f932d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_gpt_naive(tokens):\n",
    "    # compléter\n",
    "\n",
    "def loss_gpt_kv(tokens):\n",
    "    # compléter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c5100cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gpt    | step  1000/1000 | loss 2.5641\n",
      "gpt done in 88.84s\n",
      "['makar', 'sanalia', 'main', 'arlei', 'edasn', 'neyin', 'lonnan', 'akalin', 'beynon', 'alynn']\n"
     ]
    }
   ],
   "source": [
    "learning_rate_gpt, beta1, beta2, eps_adam = 0.01, 0.85, 0.99, 1e-8\n",
    "m_adam = [0.0] * len(params_gpt)\n",
    "v_adam = [0.0] * len(params_gpt)\n",
    "\n",
    "loss_gpt = loss_gpt_kv\n",
    "hist_gpt = []\n",
    "t0 = time.time()\n",
    "for step in range(num_steps):\n",
    "    # en entraînement, on utilise la version naïve : toute la séquence est connue\n",
    "    loss = loss_gpt(encode(names[step]))\n",
    "    loss.backward()\n",
    "\n",
    "    lr_t = learning_rate_gpt * (1 - step / num_steps)  # decroissance lineaire\n",
    "    for i, p in enumerate(params_gpt):\n",
    "        if p.dloss_dself is None:\n",
    "            continue\n",
    "        g = p.dloss_dself\n",
    "        m_adam[i] = # compléter\n",
    "        v_adam[i] = # compléter\n",
    "        m_hat = # compléter\n",
    "        v_hat = # compléter\n",
    "        p.value -=  # compléter\n",
    "        p.dloss_dself = None\n",
    "\n",
    "    hist_gpt.append(loss.value)\n",
    "    if step % 50 == 0 or step == num_steps - 1:\n",
    "        print(f\"gpt    | step {step + 1:5d}/{num_steps} | loss {loss.value:.4f}\", end='\\r')\n",
    "print(f\"\\ngpt done in {time.time() - t0:.2f}s\")\n",
    "\n",
    "random.seed(42)\n",
    "print([generate_kv(temperature=0.8) for _ in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed81e5bd",
   "metadata": {},
   "source": [
    "## 5 Comparaison GPT vs log-reg\n",
    "\n",
    "On compare les courbes NLL et une évaluation sur des prénoms **non vus** (les `eval_names` après les `num_steps` premiers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9a4f245b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logreg train last loss: 2.6635 | eval NLL: 2.6903\n",
      "gpt    train last loss: 2.5641 | eval NLL: 2.3201\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def eval_logreg_loss(M_float, names_list):\n",
    "    total, n = 0.0, 0\n",
    "    for nm in names_list:\n",
    "        toks = encode(nm)\n",
    "        for l in range(len(toks) - 1):\n",
    "            v = feature_vector(toks[:l + 1], T)\n",
    "            z = mat_vec(M_float, v)\n",
    "            p = softmax(z)\n",
    "            total += -math.log(p[toks[l + 1]])\n",
    "            n += 1\n",
    "    return total / n\n",
    "\n",
    "def eval_gpt_loss(names_list):\n",
    "    total, n = 0.0, 0\n",
    "    for nm in names_list:\n",
    "        toks = encode(nm)\n",
    "        logits = gpt_naive(toks)\n",
    "        for l in range(len(toks) - 1):\n",
    "            p = softmax_value(logits[l])\n",
    "            total += -math.log(p[toks[l + 1]].value)\n",
    "            n += 1\n",
    "    return total / n\n",
    "\n",
    "n_eval_names = 50\n",
    "eval_names = names[-n_eval_names:]\n",
    "logreg_eval = eval_logreg_loss(M_logreg, eval_names)\n",
    "gpt_eval = eval_gpt_loss(eval_names)\n",
    "\n",
    "print(f\"logreg train last loss: {hist_logreg[-1]:.4f} | eval NLL: {logreg_eval:.4f}\")\n",
    "print(f\"gpt    train last loss: {hist_gpt[-1]:.4f} | eval NLL: {gpt_eval:.4f}\")\n",
    "\n",
    "avg_window = 10\n",
    "plt.figure(figsize=(8, 4))\n",
    "plt.plot(moving_average(hist_logreg, avg_window), label='logreg (autodiff)')\n",
    "plt.plot(moving_average(hist_gpt, avg_window), label='gpt (adam)')\n",
    "plt.axhline(math.log(T), color='gray', ls='--', label='log(T) (uniforme)')\n",
    "plt.xlabel('etape')\n",
    "plt.ylabel('NLL')\n",
    "plt.title('Comparaison — même nombre de steps')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2e0e721",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv (3.12.11)",
   "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.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}