{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a5fe1528",
   "metadata": {},
   "source": [
    "# GPT_corr \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",
    "- implémentattion de la différentiation automatique par ordre topologique inverse ;\n",
    "- réimplémenter la régression logistique avec la différentiation automatique ;\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": 1,
   "id": "2c47d818",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "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": 2,
   "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": [
    "random.seed(42)\n",
    "# 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": 3,
   "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": 4,
   "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": 5,
   "id": "c570d735",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Value:\n",
    "    # Noms alignés sur le poly : value, dloss_dself, parents, dself_dparents\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 Value(self.value + other.value, parents=(self, other), dself_dparents=(1, 1))\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        other = other if isinstance(other, Value) else Value(other)\n",
    "        return Value(self.value * other.value, (self, other), dself_dparents=(other.value, self.value))\n",
    "\n",
    "    # operations d'une variable\n",
    "    def __pow__(self, n): return Value(self.value**n, (self,), (n * self.value**(n-1),))\n",
    "    def exp(self): return Value(math.exp(self.value), (self,), (math.exp(self.value),))\n",
    "    def log(self): return Value(math.log(self.value), (self,), (1 / self.value,))\n",
    "    def relu(self): return Value(max(0, self.value), (self,), (float(self.value > 0),))\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",
    "        if self not in visited:\n",
    "            visited.add(self)\n",
    "            self.dloss_dself = 0\n",
    "            for parent in self.parents:\n",
    "                parent.build_topo(topo, visited)\n",
    "            topo.append(self)\n",
    "        return topo, visited\n",
    "\n",
    "    def backward(self):\n",
    "        topo, _ = self.build_topo()\n",
    "        self.dloss_dself = 1\n",
    "        for v in reversed(topo):\n",
    "            for parent, dself_dparent in zip(v.parents, v.dself_dparents):\n",
    "                parent.dloss_dself += dself_dparent * v.dloss_dself\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc23b7ea",
   "metadata": {},
   "source": [
    "Premier exemple, fonction a une variable\n",
    "$$\\mathcal{L}(x) = \\exp( \\sqrt{x^2 + 1})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9f296f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 7.3890561, deriv = 6.3991103\n",
      "loss = 7.3890561, deriv = 6.3991103\n"
     ]
    }
   ],
   "source": [
    "# calcul explicite\n",
    "x_ = math.sqrt(3)\n",
    "loss_ = math.exp(math.sqrt(x_**2 + 1))\n",
    "loss_prime_ = x_ / math.sqrt(x_**2 + 1) * loss_\n",
    "print(f\"loss = {loss_:.7f}, deriv = {loss_prime_:.7f}\")\n",
    "# differentiation automatique\n",
    "x = Value(math.sqrt(3))\n",
    "loss = ((x**2 + 1) ** 0.5).exp()\n",
    "loss.backward()\n",
    "print(f\"loss = {loss.value:.7f}, deriv = {x.dloss_dself:.7f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b2dbead-bfb2-4e15-9b9c-e54eb54dd08f",
   "metadata": {},
   "source": [
    "Deuxième exemple, fonction a deux variables\n",
    "$$\\mathcal{L}(x, y) = 2\\exp(x + y) - 0.5\\exp(x_- y) + 1.1\\exp(-2x + y)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fe571dea-1015-47c9-9f0e-b770a1a8e732",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 41.0871341 (attendu 41.0871341)\n",
      "dl/dx = 37.7871341 (attendu 37.7871341)\n",
      "dl/dy = 41.4550136 (attendu 41.4550136)\n"
     ]
    }
   ],
   "source": [
    "# test numerique pour x=1, y=2\n",
    "x_ = 1.0\n",
    "y_ = 2.0\n",
    "z_ = -1\n",
    "# calcul explicite de la loss et de ses derivees partielles\n",
    "loss_ = 2*math.exp(x_ + y_) - 0.5*math.exp(x_ - y_) + 1.1*math.exp(-2*x_ + y_)\n",
    "dloss_dx_ = 2*math.exp(x_ + y_) - 0.5*math.exp(x_ - y_) - 2.2*math.exp(-2*x_ + y_)\n",
    "dloss_dy_ = 2*math.exp(x_ + y_) + 0.5*math.exp(x_ - y_) + 1.1*math.exp(-2*x_ + y_)\n",
    "\n",
    "# loss et ses derivees partielles par differentiation automatique\n",
    "x = Value(x_)\n",
    "y = Value(y_)\n",
    "z = Value(z_)\n",
    "loss = 2*(x + y).exp() - 0.5*(x - y).exp() + 1.1*(-2*x + y).exp()\n",
    "loss.backward()\n",
    "print(f\"loss = {loss.value:.7f} (attendu {loss_:.7f})\")\n",
    "print(f\"dl/dx = {x.dloss_dself:.7f} (attendu {dloss_dx_:.7f})\")\n",
    "print(f\"dl/dy = {y.dloss_dself:.7f} (attendu {dloss_dy_:.7f})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815f6298",
   "metadata": {},
   "source": [
    "## 2 Retour sur la régression logistique avec differentiation automatique\n",
    "\n",
    "Modèle : \n",
    "$p = \\mathrm{softmax}(M v)$, loss = moyenne des $-\\log p_{t_l}$ sur les tokens.\n",
    "\n",
    "Entraînement par descente de gradient stochastique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d7d22a7c-b626-4989-ab96-335198954095",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fonction softmax calculée avec 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": "code",
   "execution_count": 9,
   "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 11.55s\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",
    "        v = feature_vector(tokens[:l + 1], T)            # float\n",
    "        z = mat_vec(M, v)                                # Value\n",
    "        p = softmax_value(z)                             # Value\n",
    "        losses.append(-p[tokens[l + 1]].log())\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 = loss_logreg_autodiff(M, encode(names[step]))\n",
    "    loss.backward()\n",
    "    for p in params_logreg:\n",
    "        p.value -= learning_rate_logreg * p.dloss_dself\n",
    "        p.dloss_dself = 0.0\n",
    "    hist_logreg.append(loss.value)\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": "code",
   "execution_count": 10,
   "id": "d98b7bde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre de parametres : 4192\n"
     ]
    }
   ],
   "source": [
    "n_layer = 1\n",
    "n_embd = 16\n",
    "block_size = 16\n",
    "n_head = 4\n",
    "head_dim = n_embd // n_head\n",
    "\n",
    "random.seed(42)\n",
    "param_mat = lambda n, m, std=0.08: [[Value(random.gauss(0, std)) for _ in range(m)] for _ in range(n)]\n",
    "state_dict = {\n",
    "    'wte': param_mat(T, n_embd),\n",
    "    'wpe': param_mat(block_size, n_embd),\n",
    "    'lm_head': param_mat(T, n_embd),\n",
    "}\n",
    "for li in range(n_layer):\n",
    "    state_dict[f'layer{li}.attn_wq'] = param_mat(n_embd, n_embd)\n",
    "    state_dict[f'layer{li}.attn_wk'] = param_mat(n_embd, n_embd)\n",
    "    state_dict[f'layer{li}.attn_wv'] = param_mat(n_embd, n_embd)\n",
    "    state_dict[f'layer{li}.attn_wo'] = param_mat(n_embd, n_embd)\n",
    "    state_dict[f'layer{li}.mlp_fc1'] = param_mat(4 * n_embd, n_embd)\n",
    "    state_dict[f'layer{li}.mlp_fc2'] = param_mat(n_embd, 4 * n_embd)\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)}\")\n",
    "\n",
    "def embed(token, pos):\n",
    "    return sum_vec(state_dict['wte'][token], state_dict['wpe'][pos])\n",
    "\n",
    "def rmsnorm(x):\n",
    "    ms = sum(xi * xi for xi in x) / len(x)\n",
    "    scale = (ms + 1e-5) ** -0.5\n",
    "    return [xi * scale for xi in x]\n",
    "\n",
    "def attention_head(q, ks, vs):\n",
    "    scores = [dot_prod(q, k) / math.sqrt(len(q)) for k in ks]\n",
    "    w = softmax_value(scores)\n",
    "    return mat_vec(transpose(vs), w)\n",
    "\n",
    "def attention_naive_1head(X, Wq, Wk, Wv):\n",
    "    Q = [mat_vec(Wq, x) for x in X]\n",
    "    K = [mat_vec(Wk, x) for x in X]\n",
    "    V = [mat_vec(Wv, x) for x in X]\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",
    "        hs = slice(h * d_h, (h + 1) * d_h)\n",
    "        out += attention_head(q[hs], [k[hs] for k in ks], [v[hs] for v in vs])\n",
    "    return out\n",
    "\n",
    "def attention_naive(X, Wq, Wk, Wv, Wo, n_head):\n",
    "    Q = [mat_vec(Wq, x) for x in X]\n",
    "    K = [mat_vec(Wk, x) for x in X]\n",
    "    V = [mat_vec(Wv, x) for x in X]\n",
    "    return [mat_vec(Wo, multi_head(Q[l], K[:l + 1], V[:l + 1], n_head)) for l in range(len(X))]\n",
    "\n",
    "def mlp(x, W1, W2):\n",
    "    h = [hi.relu() for hi in mat_vec(W1, x)]\n",
    "    return mat_vec(W2, h)\n",
    "\n",
    "def gpt_naive(tokens):\n",
    "    sd = state_dict\n",
    "    X = [rmsnorm(embed(t, l)) for l, t in enumerate(tokens)]\n",
    "    for li in range(n_layer):\n",
    "        A = attention_naive([rmsnorm(x) for x in X],\n",
    "                            sd[f'layer{li}.attn_wq'], sd[f'layer{li}.attn_wk'],\n",
    "                            sd[f'layer{li}.attn_wv'], sd[f'layer{li}.attn_wo'], n_head)\n",
    "        X = [sum_vec(x, a) for x, a in zip(X, A)]\n",
    "        X = [sum_vec(x, mlp(rmsnorm(x), sd[f'layer{li}.mlp_fc1'], sd[f'layer{li}.mlp_fc2'])) for x in X]\n",
    "    return [mat_vec(sd['lm_head'], x) for x in X]\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))\n",
    "\n",
    "def gpt_kv(token, pos, keys, values):\n",
    "    sd = state_dict\n",
    "    x = rmsnorm(embed(token, pos))\n",
    "    for li in range(n_layer):\n",
    "        a = attention_kv(rmsnorm(x),\n",
    "                         sd[f'layer{li}.attn_wq'], sd[f'layer{li}.attn_wk'],\n",
    "                         sd[f'layer{li}.attn_wv'], sd[f'layer{li}.attn_wo'], n_head,\n",
    "                         keys[li], values[li])\n",
    "        x = sum_vec(x, a)\n",
    "        x = sum_vec(x, mlp(rmsnorm(x), sd[f'layer{li}.mlp_fc1'], sd[f'layer{li}.mlp_fc2']))\n",
    "    return mat_vec(sd['lm_head'], x)\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": "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": 11,
   "id": "252f932d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_gpt_naive(tokens):\n",
    "    logits = gpt_naive(tokens)\n",
    "    # logits = feature_vector(tokens)\n",
    "    losses = []\n",
    "    for l in range(len(tokens) - 1):\n",
    "        p = softmax_value(logits[l])\n",
    "        losses.append(-p[tokens[l + 1]].log())\n",
    "    return sum(losses) * (1 / len(losses))\n",
    "\n",
    "def loss_gpt_kv(tokens):\n",
    "    # version sequence + KV cache : on calcule position par position\n",
    "    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n",
    "    losses = []\n",
    "    for pos, token in enumerate(tokens[:-1]):\n",
    "        logits = gpt_kv(token, pos, keys, values)  # logits de la position courante\n",
    "        p = softmax_value(logits)\n",
    "        losses.append(-p[tokens[pos + 1]].log())\n",
    "    return sum(losses) * (1 / len(losses))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6c5100cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gpt    | step  1000/1000 | loss 2.5641\n",
      "gpt done in 80.95s\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] = beta1 * m_adam[i] + (1 - beta1) * g\n",
    "        v_adam[i] = beta2 * v_adam[i] + (1 - beta2) * g * g\n",
    "        m_hat = m_adam[i] / (1 - beta1 ** (step + 1))\n",
    "        v_hat = v_adam[i] / (1 - beta2 ** (step + 1))\n",
    "        p.value -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)\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": 13,
   "id": "352338ab-339a-4acf-ade9-9ffa79736457",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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('Loss training curve')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9a4f245b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logreg final train loss (avg 50): 2.6433 | eval NLL 50 samples: 2.6903\n",
      "gpt    final train loss (avg 50): 2.3373 | eval NLL 50 samples: 2.3201\n"
     ]
    }
   ],
   "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",
    "\n",
    "print(f\"logreg final train loss (avg {n_eval_names}): {sum(hist_logreg[-n_eval_names:])/n_eval_names:.4f} | eval NLL {n_eval_names} samples: {logreg_eval:.4f}\")\n",
    "print(f\"gpt    final train loss (avg {n_eval_names}): {sum(hist_gpt[-n_eval_names:])/n_eval_names:.4f} | eval NLL {n_eval_names} samples: {gpt_eval:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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
}