From 1e938135c30285286f437ab4531f64c3da223761 Mon Sep 17 00:00:00 2001
From: Gabet Joseph <joseph.gabet@centralesupelec.fr>
Date: Fri, 28 Mar 2025 15:49:00 +0000
Subject: [PATCH] Upload New File

---
 SNR.ipynb | 945 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 945 insertions(+)
 create mode 100644 SNR.ipynb

diff --git a/SNR.ipynb b/SNR.ipynb
new file mode 100644
index 0000000..0bc5420
--- /dev/null
+++ b/SNR.ipynb
@@ -0,0 +1,945 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from itertools import permutations\n",
+        "\n",
+        "def unpack_params(params, shapes, dtypes):\n",
+        "    \"\"\"Unpack params back into matrices with given shapes and dtypes.\"\"\"\n",
+        "    idx = 0\n",
+        "    matrices = []\n",
+        "    for shape, dtype in zip(shapes, dtypes):\n",
+        "        size = np.prod(shape)\n",
+        "        values = params[idx:idx + size]\n",
+        "        matrix = values.reshape(shape).astype(dtype)\n",
+        "        matrices.append(matrix)\n",
+        "        idx += size\n",
+        "    return matrices\n",
+        "\n",
+        "def TFD1D(freqs1, freqs2): # vectorized\n",
+        "    # Convertir les listes en tableaux numpy\n",
+        "    f1 = np.array(freqs1)\n",
+        "    f2 = np.array(freqs2)\n",
+        "    # Créer une grille de valeurs pour f1 et f2\n",
+        "    F1, F2 = np.meshgrid(f1, f2, indexing='ij')\n",
+        "    # Calculer la matrice TFD directement\n",
+        "    TFD = np.exp(2j * np.pi * F1 * F2)\n",
+        "    return TFD\n",
+        "\n",
+        "def sample_uniform_frequencies_1d(n, bound=0.5):\n",
+        "    # Calculer le nombre de points dans chaque dimension\n",
+        "    N = 2 * n + 1\n",
+        "    # Générer une grille uniforme de points entre -0.5 et 0.5\n",
+        "    grid_1d = np.linspace(-bound, bound, N)\n",
+        "    return grid_1d\n",
+        "\n",
+        "class Gauss1D():\n",
+        "\n",
+        "  def __init__(self, n=0, sigma=1):\n",
+        "    self.n = n\n",
+        "    self.sigma = sigma\n",
+        "\n",
+        "    self.g_ = np.array([])\n",
+        "    self.g()\n",
+        "\n",
+        "  def fourier(self, w):\n",
+        "    return np.exp(-2 * (w * self.sigma * np.pi)**2)\n",
+        "\n",
+        "  def g(self):\n",
+        "    if len(self.g_) == 0:\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      self.g_ = np.array([self.fourier(f) for f in freqs])\n",
+        "    return self.g_\n",
+        "\n",
+        "  def compute(self, t):\n",
+        "    t_array = np.array(t)\n",
+        "    return (1/(self.sigma*np.sqrt(2*np.pi))) * np.exp(-t_array**2/(2* self.sigma**2))\n",
+        "\n",
+        "  def computeK(self, t):\n",
+        "    t = np.array(t)\n",
+        "    freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "    if len(t.shape) == 0:\n",
+        "        return np.sum(np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "    V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "    return np.sum(np.abs(self.g())**2 * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_p(self, t):\n",
+        "      t = np.array(t)\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      if len(t.shape) == 0:\n",
+        "          return np.sum(2j * np.pi * freqs * np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "      V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "      return np.sum(np.abs(self.g())**2 * (2j * np.pi * freqs) * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_pp(self, t):\n",
+        "      t = np.array(t)\n",
+        "      freqs = sample_uniform_frequencies_1d(self.n)\n",
+        "      if len(t.shape) == 0:\n",
+        "          return np.sum((2j * np.pi * freqs)**2 * np.abs(self.g())**2 * np.exp(2j * np.pi * freqs * t))\n",
+        "      V = np.exp(2j * np.pi * np.outer(freqs, t))\n",
+        "      return np.sum(np.abs(self.g())**2 * (2j * np.pi * freqs)**2 * V.T, axis=1).reshape(t.shape)\n",
+        "\n",
+        "  def computeK_pp0(self):\n",
+        "      return self.computeK_pp(0)"
+      ],
+      "metadata": {
+        "id": "ePm14DloHvxX"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "def compute_z(a, tau, g, freqs):\n",
+        "    # Calcule la matrice d'exponentielles avec np.outer\n",
+        "    exp_matrix = np.exp(2j * np.pi * np.outer(freqs, tau))  # forme : (len(freqs), len(tau))\n",
+        "    # Effectue le produit matriciel sur la seconde dimension, puis multiplie par g élément par élément\n",
+        "    return g * exp_matrix.dot(a)\n",
+        "\n",
+        "def grad_approx_perso(kernel, theta_pred, data_observed, freqs):\n",
+        "    r = len(theta_pred) // 2\n",
+        "    a = theta_pred[:r]\n",
+        "    tau = theta_pred[r:]\n",
+        "\n",
+        "    # Construction de la matrice des différences de tau de taille (r, r)\n",
+        "    tau_diff_matrix = tau[:, None] - tau[None, :]\n",
+        "\n",
+        "    # Calcul vectorisé des matrices de kernel\n",
+        "    k_matrix = kernel.computeK(tau_diff_matrix)\n",
+        "    kp_matrix = kernel.computeK_p(tau_diff_matrix)\n",
+        "\n",
+        "    # Préparation de kernel_g et des données observées\n",
+        "    kernel_g = np.conj(kernel.g()).flatten()\n",
+        "    data_observed = data_observed.flatten()\n",
+        "    freqs = freqs.flatten()\n",
+        "\n",
+        "    # Calcul de la matrice d'exponentielles pour le terme en tau\n",
+        "    exp_term = np.exp(-2j * np.pi * np.outer(tau, freqs))\n",
+        "\n",
+        "    # Première partie du gradient (associée à a)\n",
+        "    # Pour chaque j : somme_i(a[i]*k_matrix[j,i]) - somme_k(kernel_g[k]*data_observed[k]*exp_term[j,k])\n",
+        "    grad_a = k_matrix.dot(a) - exp_term.dot(kernel_g * data_observed)\n",
+        "\n",
+        "    # Seconde partie du gradient (associée à tau)\n",
+        "    # Terme 1 : np.conj(a[j]) * somme_i(a[i]*kp_matrix[j,i]) pour chaque j\n",
+        "    term1 = np.conj(a) * (kp_matrix.dot(a))\n",
+        "    # Terme 2 : np.conj(a[j]) * somme_k(kernel_g[k]*data_observed[k]*(-2j*np.pi*freqs[k])*exp_term[j,k])\n",
+        "    Y = -2j * np.pi * freqs * (kernel_g * data_observed)\n",
+        "    term2 = np.conj(a) * (exp_term.dot(Y))\n",
+        "\n",
+        "    # On conserve la partie réelle pour le gradient sur tau\n",
+        "    grad_tau = np.real(term1) - np.real(term2)\n",
+        "\n",
+        "    # Concatène les deux parties pour former le gradient complet\n",
+        "    return np.concatenate([grad_a, grad_tau])"
+      ],
+      "metadata": {
+        "id": "GHHCKfspHnJw"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def min_norm_permuted_theta(theta_est, theta_star):\n",
+        "    \"\"\"\n",
+        "    Calcule la norme minimale ||theta_est - theta_star_perm|| sur toutes les permutations\n",
+        "    de la partie position de theta_star, en appliquant la même permutation aux amplitudes.\n",
+        "\n",
+        "    On suppose que theta est structuré comme suit:\n",
+        "    theta = [a1, a2, ..., a_N, tau1, tau2, ..., tau_N]\n",
+        "\n",
+        "    Paramètres:\n",
+        "    - theta_est (numpy array): Estimation du vecteur theta\n",
+        "    - theta_star (numpy array): Vecteur theta \"vrai\"\n",
+        "\n",
+        "    Retourne:\n",
+        "    - float: La norme minimale calculée sur toutes les permutations possibles\n",
+        "    \"\"\"\n",
+        "    # Nombre d'éléments par bloc (amplitudes et positions)\n",
+        "    r = len(theta_est) // 2\n",
+        "\n",
+        "    # Séparation en amplitudes et positions pour theta_est et theta_star\n",
+        "    a_est, tau_est = theta_est[:r], theta_est[r:]\n",
+        "    a_star, tau_star = theta_star[:r], theta_star[r:]\n",
+        "\n",
+        "    min_error = float('inf')\n",
+        "\n",
+        "    # Considérer toutes les permutations d'indices pour la partie positions\n",
+        "    for perm in permutations(range(r)):\n",
+        "        # Appliquer la permutation sur les positions et les amplitudes associées\n",
+        "        a_star_perm = a_star[list(perm)]\n",
+        "        tau_star_perm = tau_star[list(perm)]\n",
+        "        # Reconstruire le vecteur theta après permutation\n",
+        "        theta_star_perm = np.concatenate([a_star_perm, tau_star_perm])\n",
+        "        error = np.linalg.norm(theta_est - theta_star_perm)\n",
+        "        min_error = min(min_error, error)\n",
+        "\n",
+        "    return min_error\n",
+        "\n",
+        "\n",
+        "def min_norm_permuted_tau(theta_est, theta_star):\n",
+        "    \"\"\"\n",
+        "    Calcule la norme minimale ||tau_est - tau_star_perm|| sur toutes les permutations\n",
+        "    de la partie position de theta_star, en ignorant les amplitudes.\n",
+        "\n",
+        "    On suppose que theta est structuré comme suit:\n",
+        "    theta = [a1, a2, ..., a_N, tau1, tau2, ..., tau_N]\n",
+        "\n",
+        "    Paramètres:\n",
+        "    - theta_est (numpy array): Estimation du vecteur theta\n",
+        "    - theta_star (numpy array): Vecteur theta \"vrai\"\n",
+        "\n",
+        "    Retourne:\n",
+        "    - float: La norme minimale calculée sur toutes les permutations possibles des positions\n",
+        "    \"\"\"\n",
+        "    # Nombre d'éléments de positions (tau)\n",
+        "    r = len(theta_est) // 2\n",
+        "\n",
+        "    # Extraire les positions (tau) pour theta_est et theta_star\n",
+        "    tau_est = theta_est[r:]\n",
+        "    tau_star = theta_star[r:]\n",
+        "\n",
+        "    min_error = float('inf')\n",
+        "\n",
+        "    # Considérer toutes les permutations des indices pour la partie positions\n",
+        "    for perm in permutations(range(r)):\n",
+        "        tau_star_perm = tau_star[list(perm)]\n",
+        "        error = np.linalg.norm(tau_est - tau_star_perm)\n",
+        "        min_error = min(min_error, error)\n",
+        "\n",
+        "    return min_error"
+      ],
+      "metadata": {
+        "id": "uD_qhokaHh3S"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def add_noise(y_current, snr_db):\n",
+        "    # Calcul de la puissance du signal\n",
+        "    signal_power = np.mean(np.abs(y_current)**2)\n",
+        "\n",
+        "    # Conversion du SNR de dB à linéaire\n",
+        "    snr_linear = 10**(snr_db/10)\n",
+        "\n",
+        "    # Calcul de la puissance du bruit\n",
+        "    noise_power = signal_power / snr_linear\n",
+        "\n",
+        "    # Génération du bruit (pour un signal complexe)\n",
+        "    noise = np.sqrt(noise_power/2) * (np.random.randn(*y_current.shape) + 1j*np.random.randn(*y_current.shape))\n",
+        "\n",
+        "    # Signal bruité\n",
+        "    y_noisy = y_current + noise\n",
+        "    return y_noisy"
+      ],
+      "metadata": {
+        "id": "4SiJI5xvHcCm"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Define the Gaussian kernel in spatial domain\n",
+        "def gauss1d(x, sigma, tau):\n",
+        "    return (1 / (np.sqrt(2 * np.pi) * sigma)) * np.exp(- (x - tau) ** 2 / (2 * sigma ** 2))\n",
+        "\n",
+        "def compute_theta_star_sequence(time_steps, min_distance=5.0, threshold_ratio=1.5):\n",
+        "    theta_star_sequence = []\n",
+        "    for t in range(time_steps):\n",
+        "        # Time variable (no scaling factor)\n",
+        "        time_var = t\n",
+        "\n",
+        "        # Define deterministic functions for a_star and tau_star\n",
+        "        # Amplitudes vary sinusoidally and positions move linearly\n",
+        "        a_star = np.array([\n",
+        "            0.3 + 0.2 * np.sin(0.2 * time_var),\n",
+        "            0.3 + 0.2 * np.sin(0.2 * time_var + 2 * np.pi / 3),\n",
+        "            0.3 + 0.2 * np.sin(0.2 * time_var + 4 * np.pi / 3)\n",
+        "        ])\n",
+        "        # Ensure amplitudes are non-negative\n",
+        "        a_star = np.clip(a_star, 0, None)\n",
+        "        # Normalize amplitudes to sum to 1\n",
+        "        a_star /= np.sum(a_star)\n",
+        "\n",
+        "        # Enforce threshold on a_max / a_min ratio\n",
+        "        a_max = np.max(a_star)\n",
+        "        a_min = np.min(a_star)\n",
+        "\n",
+        "        if a_max / a_min < threshold_ratio:\n",
+        "            # Adjust the minimum value to ensure ratio meets the threshold\n",
+        "            target_min = a_max / threshold_ratio\n",
+        "            scale_factor = (1 - target_min) / (np.sum(a_star) - a_min)\n",
+        "            a_star = np.clip(a_star * scale_factor, target_min, None)\n",
+        "            # Normalize again to sum to 1\n",
+        "            a_star /= np.sum(a_star)\n",
+        "\n",
+        "\n",
+        "        # Initial tau_star with linear movement\n",
+        "        tau_star = np.array([\n",
+        "            -6 + 0.1 * time_var,\n",
+        "            -3 + 0.05 * time_var,\n",
+        "             5 - 0.08 * time_var\n",
+        "        ])\n",
+        "\n",
+        "\n",
+        "        for i in range(len(tau_star) - 1):\n",
+        "            for j in range(i + 1, len(tau_star)):\n",
+        "                # Calculate the distance between two points\n",
+        "                distance = abs(tau_star[i] - tau_star[j])\n",
+        "                if distance < min_distance:\n",
+        "                    # Adjust positions\n",
+        "                    adjustment = (min_distance - distance) / 2\n",
+        "                    tau_star[i] -= adjustment\n",
+        "                    tau_star[j] += adjustment\n",
+        "\n",
+        "\n",
+        "\n",
+        "        # Concatenate to form theta_star\n",
+        "        theta_star = np.concatenate((a_star, tau_star))\n",
+        "        theta_star_sequence.append(theta_star)\n",
+        "    return theta_star_sequence\n",
+        "\n",
+        "# Compute the sequence of theta_star\n",
+        "# Spatial grid for plotting densities\n",
+        "x = np.linspace(-10, 10, 500)\n",
+        "time_steps = 150  # Total number of time steps\n",
+        "\n",
+        "n=16\n",
+        "N=2*n+1\n",
+        "freqs = sample_uniform_frequencies_1d(n)\n",
+        "sigma = 1\n",
+        "kernel = Gauss1D(n, sigma)\n",
+        "g_star = kernel.fourier(freqs) + 0j\n",
+        "\n",
+        "theta_star_sequence = compute_theta_star_sequence(time_steps)\n",
+        "r = len(theta_star_sequence[0]) // 2\n",
+        "\n",
+        "\n",
+        "S_err = lambda theta : np.max([np.abs(theta[:r] - theta_star[:r])/np.abs(theta_star[:r]), np.sqrt(np.abs(kernel.computeK_pp0()))*np.abs(theta[r:] - theta_star[r:])])\n",
+        "\n",
+        "F_second = np.abs(kernel.computeK_pp0())\n",
+        "def P_k(a):\n",
+        "  return np.diag(np.concatenate( [np.ones(len(a)), 1/F_second * (np.abs(a)**-2)] ))"
+      ],
+      "metadata": {
+        "id": "qVhLsLpCH5Po"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def compute_crb(theta_star, snr_db):\n",
+        "    \"\"\"\n",
+        "    Calcule la borne de Cramér-Rao pour le vecteur de paramètres theta_star\n",
+        "    avec le SNR en dB donné.\n",
+        "\n",
+        "    Modèle :\n",
+        "      z[k] = sum_{j=0}^{r-1} a_star[j] * g_star[k] * exp(2Ï€i * tau_star[j] * freqs[k])\n",
+        "\n",
+        "    On suppose que les paramètres theta_star = [a_0,...,a_{r-1}, tau_0,...,tau_{r-1}]\n",
+        "    sont réels. Le bruit est supposé gaussien complexe propre de variance sigma^2.\n",
+        "\n",
+        "    Paramètres :\n",
+        "      theta_star : np.array\n",
+        "          Vecteur de paramètres vrai de longueur 2*r.\n",
+        "      snr_db : float\n",
+        "          Rapport signal sur bruit en dB.\n",
+        "\n",
+        "    Renvoie :\n",
+        "      crb_norm : float\n",
+        "          Borne inférieure sur la norme de l'erreur d'estimation (sqrt(trace(CRB_matrix))).\n",
+        "      CRB_matrix : np.array\n",
+        "          Matrice CRB complète (inverse de la FIM).\n",
+        "    \"\"\"\n",
+        "    # Extraction des paramètres\n",
+        "    a_star = theta_star[:r]\n",
+        "    tau_star = theta_star[r:]\n",
+        "\n",
+        "    # Calcul du signal sans bruit\n",
+        "    f = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "    N = len(freqs)\n",
+        "\n",
+        "    # Puissance moyenne du signal\n",
+        "    signal_power = np.mean(np.abs(f)**2)\n",
+        "\n",
+        "    # Conversion du SNR de dB en linéaire et calcul de sigma^2\n",
+        "    snr_linear = 10**(snr_db/10)\n",
+        "    sigma2 = signal_power / snr_linear\n",
+        "\n",
+        "    # Construction de la matrice Jacobienne J de dimension (N, 2r)\n",
+        "    J = np.zeros((N, 2*r), dtype=complex)\n",
+        "    for k in range(N):\n",
+        "        for j in range(r):\n",
+        "            # Dérivée par rapport à a_j\n",
+        "            J[k, j] = g_star[k] * np.exp(2j * np.pi * tau_star[j] * freqs[k])\n",
+        "            # Dérivée par rapport à tau_j\n",
+        "            J[k, r+j] = a_star[j] * g_star[k] * (2j * np.pi * freqs[k]) * np.exp(2j * np.pi * tau_star[j] * freqs[k])\n",
+        "\n",
+        "    # Calcul de la matrice d'information de Fisher (FIM)\n",
+        "    FIM = (2/sigma2) * np.real(np.conjugate(J).T @ J)\n",
+        "\n",
+        "    try:\n",
+        "        # Calcul de la CRB (matrice inverse de la FIM)\n",
+        "        CRB_matrix = np.linalg.inv(FIM) # attention pinv ou inv selon le comportement que l'on souhaite\n",
+        "        # Borne inférieure sur l'erreur en norme (erreur euclidienne minimale)\n",
+        "        crb_norm = np.sqrt(np.trace(CRB_matrix))\n",
+        "    except np.linalg.LinAlgError: # si np.inv alors ne gère pas les matrices singluières\n",
+        "        # Si la matrice est singulière, mettre NaN\n",
+        "        CRB_matrix = np.full_like(FIM, np.nan)  # Matrice remplie de NaN\n",
+        "        crb_norm = np.nan\n",
+        "\n",
+        "    return crb_norm, CRB_matrix\n",
+        "\n",
+        "\n",
+        "def compute_crb_values(theta_star_sequence, snr_db):\n",
+        "    \"\"\"\n",
+        "    Calcule les valeurs de la borne de Cramér-Rao pour chaque pas de temps\n",
+        "    d'une séquence de vecteurs de paramètres vrais.\n",
+        "\n",
+        "    Paramètres :\n",
+        "      theta_star_sequence : list ou np.array\n",
+        "          Séquence (de longueur T) des vecteurs de paramètres vrais (chacun de longueur 2*r).\n",
+        "      snr_db : float\n",
+        "          SNR en dB.\n",
+        "\n",
+        "    Renvoie :\n",
+        "      crb_vals : np.array\n",
+        "          Tableau des valeurs CRB (borne sur l'erreur en norme) pour chaque pas de temps.\n",
+        "    \"\"\"\n",
+        "    time_steps = len(theta_star_sequence)\n",
+        "    crb_vals = np.zeros(time_steps)\n",
+        "    for t in range(time_steps):\n",
+        "        crb_norm, _ = compute_crb(theta_star_sequence[t], snr_db)\n",
+        "        crb_vals[t] = crb_norm\n",
+        "    return crb_vals\n",
+        "\n",
+        "######################\n",
+        "# Uniquement tau\n",
+        "######################\n",
+        "\n",
+        "def compute_crb_tau(theta_star, snr_db):\n",
+        "    \"\"\"\n",
+        "    Calcule la borne de Cramér-Rao pour la partie position (tau) du vecteur de paramètres theta_star\n",
+        "    avec le SNR en dB donné, en ignorant les amplitudes.\n",
+        "\n",
+        "    Modèle :\n",
+        "      z[k] = sum_{j=0}^{r-1} a_star[j] * g_star[k] * exp(2Ï€i * tau_star[j] * freqs[k])\n",
+        "\n",
+        "    On suppose que les paramètres theta_star = [a_0,...,a_{r-1}, tau_0,...,tau_{r-1}]\n",
+        "    sont réels, et que les fonctions/variables g_star, freqs et compute_z sont définies ailleurs.\n",
+        "\n",
+        "    Paramètres :\n",
+        "      theta_star : np.array\n",
+        "          Vecteur de paramètres vrai de longueur 2*r (les amplitudes puis les positions).\n",
+        "      snr_db : float\n",
+        "          Rapport signal sur bruit en dB.\n",
+        "\n",
+        "    Renvoie :\n",
+        "      crb_tau_norm : float\n",
+        "          Borne inférieure sur la norme de l'erreur d'estimation pour les positions\n",
+        "          (sqrt(trace(CRB_tau_matrix))).\n",
+        "      CRB_tau_matrix : np.array\n",
+        "          Matrice CRB pour les positions (inverse de la FIM partielle).\n",
+        "    \"\"\"\n",
+        "    # Nombre d'éléments par bloc\n",
+        "    r = len(theta_star) // 2\n",
+        "    a_star = theta_star[:r]\n",
+        "    tau_star = theta_star[r:]\n",
+        "\n",
+        "    # Calcul du signal sans bruit pour obtenir la puissance du signal\n",
+        "    # compute_z doit être défini dans votre environnement et dépend de g_star et freqs.\n",
+        "    f = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "    N = len(freqs)\n",
+        "\n",
+        "    # Puissance moyenne du signal et calcul de sigma^2 à partir du SNR\n",
+        "    signal_power = np.mean(np.abs(f)**2)\n",
+        "    snr_linear = 10**(snr_db / 10)\n",
+        "    sigma2 = signal_power / snr_linear\n",
+        "\n",
+        "    # Construction de la matrice Jacobienne pour les paramètres tau seulement.\n",
+        "    J_tau = np.zeros((N, r), dtype=complex)\n",
+        "    for k in range(N):\n",
+        "        for j in range(r):\n",
+        "            J_tau[k, j] = a_star[j] * g_star[k] * (2 * 1j * np.pi * freqs[k]) * \\\n",
+        "                          np.exp(2 * 1j * np.pi * tau_star[j] * freqs[k])\n",
+        "\n",
+        "    # Calcul de la FIM pour tau uniquement.\n",
+        "    FIM_tau = (2 / sigma2) * np.real(np.conjugate(J_tau).T @ J_tau)\n",
+        "\n",
+        "    try:\n",
+        "        CRB_tau_matrix = np.linalg.inv(FIM_tau)\n",
+        "        crb_tau_norm = np.sqrt(np.trace(CRB_tau_matrix))\n",
+        "    except np.linalg.LinAlgError:\n",
+        "        CRB_tau_matrix = np.full_like(FIM_tau, np.nan)\n",
+        "        crb_tau_norm = np.nan\n",
+        "\n",
+        "    return crb_tau_norm, CRB_tau_matrix\n",
+        "\n",
+        "\n",
+        "def compute_crb_tau_values(theta_star_sequence, snr_db):\n",
+        "    \"\"\"\n",
+        "    Calcule la borne de Cramér-Rao pour la partie position (tau) pour chaque\n",
+        "    vecteur de paramètres d'une séquence.\n",
+        "\n",
+        "    Paramètres :\n",
+        "      theta_star_sequence : list ou np.array\n",
+        "          Séquence (de longueur T) des vecteurs de paramètres vrais (chacun de longueur 2*r).\n",
+        "      snr_db : float\n",
+        "          Rapport signal sur bruit en dB.\n",
+        "\n",
+        "    Renvoie :\n",
+        "      crb_tau_vals : np.array\n",
+        "          Tableau des valeurs CRB pour les positions (borne sur l'erreur en norme)\n",
+        "          pour chaque pas de temps.\n",
+        "    \"\"\"\n",
+        "    time_steps = len(theta_star_sequence)\n",
+        "    crb_tau_vals = np.zeros(time_steps)\n",
+        "    for t in range(time_steps):\n",
+        "        crb_tau_norm, _ = compute_crb_tau(theta_star_sequence[t], snr_db)\n",
+        "        crb_tau_vals[t] = crb_tau_norm\n",
+        "    return crb_tau_vals"
+      ],
+      "metadata": {
+        "id": "XhTFPZ8VHQ-G"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Loss function\n",
+        "def MSE_loss(params, y_current):\n",
+        "    shapes = [(r), (r)]  # Add dtype if needed\n",
+        "    dtypes = [complex, complex]\n",
+        "    a, tau = unpack_params(params, shapes, dtypes)\n",
+        "    z = compute_z(a, tau, g_star, freqs).reshape(-1,1)\n",
+        "    return 0.5 * np.linalg.norm(y_current - z) ** 2\n",
+        "\n",
+        "# Preconditioned gradient descent function\n",
+        "def preconditioned_gradient_descent(loss_func, initial_point, y_current, learning_rate=0.01, momentum=0.9, max_iters=200):\n",
+        "    point = np.array(initial_point, dtype=float)\n",
+        "    velocity = np.zeros_like(point)\n",
+        "    loss_values = []\n",
+        "    for i in range(max_iters):\n",
+        "        gradient = grad_approx_perso(kernel, point, y_current, freqs).real\n",
+        "        a = point[:r]\n",
+        "        velocity = momentum * velocity - learning_rate * P_k(a) @ gradient\n",
+        "        point = point + velocity\n",
+        "        point[:r] = np.abs(point[:r])\n",
+        "        loss = loss_func(point, y_current)\n",
+        "        loss_values.append(loss)\n",
+        "    return point, loss_values"
+      ],
+      "metadata": {
+        "id": "lII7b-EKI6FS"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "SV9smRcGHHGj"
+      },
+      "outputs": [],
+      "source": [
+        "# Nombre de réalisations Monte Carlo et nombre de pas de temps\n",
+        "num_experiments = 10\n",
+        "time_steps = len(theta_star_sequence)  # Nombre de pas de temps\n",
+        "errors_all = np.zeros((num_experiments, time_steps))  # Matrice pour stocker les erreurs\n",
+        "\n",
+        "# Paramètres de gradient descent et bruit\n",
+        "learning_rate = 0.1\n",
+        "momentum = 0.2\n",
+        "gradient_steps_per_time = 200\n",
+        "snr_db = 40\n",
+        "\n",
+        "# Boucle Monte Carlo pour simuler plusieurs expériences\n",
+        "for exp in range(num_experiments):\n",
+        "    # Réinitialiser l'estimation pour chaque expérience\n",
+        "    theta_est = theta_star_sequence[0] + 0.01 * np.random.randn(2 * r)\n",
+        "\n",
+        "    # Pour chaque pas de temps\n",
+        "    for t in range(time_steps):\n",
+        "        # Récupérer les vrais paramètres pour le pas de temps t\n",
+        "        theta_star = theta_star_sequence[t]\n",
+        "        a_star, tau_star = theta_star[:r], theta_star[r:]\n",
+        "\n",
+        "        # Calculer l'observation y_current et y_current bruité\n",
+        "        y_current = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "        y_current = add_noise(y_current, snr_db)\n",
+        "\n",
+        "        # Effectuer la descente de gradient préconditionnée\n",
+        "        theta_est, loss_values = preconditioned_gradient_descent(\n",
+        "            MSE_loss, theta_est, y_current.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=momentum, max_iters=gradient_steps_per_time\n",
+        "        )\n",
+        "\n",
+        "        # Calculer et stocker l'erreur (ici, la norme euclidienne)\n",
+        "        #error = min_norm_permuted_theta(theta_est, theta_star)\n",
+        "        error = min_norm_permuted_tau(theta_est, theta_star)\n",
+        "        errors_all[exp, t] = error\n",
+        "\n",
+        "# Calcul de l'erreur moyenne et de l'écart-type à chaque pas de temps\n",
+        "mean_errors = np.mean(errors_all, axis=0)[1:]\n",
+        "std_errors = np.std(errors_all, axis=0)[1:]\n",
+        "\n",
+        "# Calcul de la CRB pour chaque pas de temps via la fonction compute_crb_values\n",
+        "crb_values = compute_crb_values(theta_star_sequence, snr_db)[1:]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calcul de la CRB pour chaque pas de temps via la fonction compute_crb_values\n",
+        "#crb_values = compute_crb_values(theta_star_sequence, snr_db)[1:]\n",
+        "crb_values = compute_crb_tau_values(theta_star_sequence, snr_db)[1:]\n",
+        "\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "plt.plot(mean_errors, label=r\"Erreur moyenne $\\overline{e}$\", color='red')\n",
+        "plt.fill_between(np.arange(time_steps)[:-1],\n",
+        "                 mean_errors - std_errors,\n",
+        "                 mean_errors + std_errors,\n",
+        "                 color='red', alpha=0.1, label=r\"$\\pm 1 \\sigma$\")\n",
+        "plt.plot(crb_values, '--', label=r\"Borne de Cramér-Rao\", color=\"black\")\n",
+        "plt.xlabel(r\"Pas de temps\", fontsize=16)\n",
+        "#plt.ylabel(r'Erreur $md_2(\\hat{\\theta};\\theta^\\ast)$', fontsize=16)\n",
+        "plt.ylabel(r'Erreur $md_2(\\hat{\\tau};\\tau^\\ast)$', fontsize=16)\n",
+        "#plt.title(r\"Erreur moyenne sur {} expériences vs CRB\".format(num_experiments))\n",
+        "plt.yscale(\"log\")  # Échelle logarithmique sur l'axe des ordonnées\n",
+        "plt.ylim(1e-3,0.5)\n",
+        "plt.legend()\n",
+        "plt.grid(True, which=\"both\", linestyle=\"--\")\n",
+        "\n",
+        "# Modification\n",
+        "plt.xticks(fontsize=16)\n",
+        "plt.yticks(fontsize=16)\n",
+        "plt.legend(fontsize=16)\n",
+        "\n",
+        "# Save the figure as a PDF\n",
+        "pdf_filename = \"/content/Erreur_moyenne_DMPGD.pdf\"\n",
+        "plt.savefig(pdf_filename, format=\"pdf\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 554
+        },
+        "id": "CCSDv4m3HMcn",
+        "outputId": "dc0d3042-6936-48dd-b078-a34c405266fa"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import scipy.stats as st\n",
+        "\n",
+        "# Paramètres de simulation\n",
+        "num_experiments = 200\n",
+        "time_steps = len(theta_star_sequence)  # Nombre de pas de temps\n",
+        "gradient_steps_per_time = 40\n",
+        "learning_rate = 0.1\n",
+        "snr_db = 40\n",
+        "\n",
+        "threshold = 1e-1       # Seuil pour le taux de décochage\n",
+        "\n",
+        "# Valeurs de momentum\n",
+        "momentum_with = 0.2   # avec momentum\n",
+        "momentum_without = 0.0  # sans momentum\n",
+        "\n",
+        "# Matrices pour stocker les erreurs pour chaque scénario\n",
+        "errors_with = np.zeros((num_experiments, time_steps))\n",
+        "errors_without = np.zeros((num_experiments, time_steps))\n",
+        "\n",
+        "\n",
+        "# Liste pour stocker le succès (1 si l'erreur finale après re-descente est ≤ threshold, 0 sinon)\n",
+        "success_rates_with = []\n",
+        "success_rates_without = []\n",
+        "\n",
+        "# --- Expériences Monte Carlo sans momentum ---\n",
+        "for exp in range(num_experiments):\n",
+        "    # Réinitialisation de l'estimation\n",
+        "    theta_est = theta_star_sequence[0] + 0.01 * np.random.randn(2 * r)\n",
+        "\n",
+        "    for t in range(time_steps):\n",
+        "        # Récupération des vrais paramètres pour le pas t\n",
+        "        theta_star = theta_star_sequence[t]\n",
+        "        a_star, tau_star = theta_star[:r], theta_star[r:]\n",
+        "\n",
+        "        # Calcul de l'observation et ajout du bruit\n",
+        "        y_current = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "        y_current = add_noise(y_current, snr_db)\n",
+        "\n",
+        "        # Descente de gradient sans momentum (momentum=0)\n",
+        "        theta_est, loss_values = preconditioned_gradient_descent(\n",
+        "            MSE_loss, theta_est, y_current.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=momentum_without,\n",
+        "            max_iters=gradient_steps_per_time\n",
+        "        )\n",
+        "\n",
+        "        # Calcul et stockage de l'erreur\n",
+        "        #error = min_norm_permuted_theta(theta_est, theta_star)\n",
+        "        error = min_norm_permuted_tau(theta_est, theta_star)\n",
+        "        errors_without[exp, t] = error\n",
+        "\n",
+        "    # --- Calcul du taux de décochage ---\n",
+        "    # On définit les paramètres finaux et on calcule l'observation finale\n",
+        "    theta_star_final = theta_star_sequence[-1]\n",
+        "    a_star_final, tau_star_final = theta_star_final[:r], theta_star_final[r:]\n",
+        "    y_final = compute_z(a_star_final, tau_star_final, g_star, freqs)\n",
+        "    y_final = add_noise(y_final, snr_db)\n",
+        "\n",
+        "    # Refaire une descente de gradient à partir de theta_est obtenu à la fin\n",
+        "    theta_est_refined, loss_values_final = preconditioned_gradient_descent(\n",
+        "        MSE_loss, theta_est, y_final.reshape(-1, 1),\n",
+        "        learning_rate=learning_rate, momentum=momentum_without,\n",
+        "        max_iters=gradient_steps_per_time\n",
+        "    )\n",
+        "\n",
+        "    # Calcul de l'erreur finale après re-descente\n",
+        "    final_error = min_norm_permuted_theta(theta_est_refined, theta_star_final)\n",
+        "\n",
+        "    # Vérifier si l'erreur finale est inférieure ou égale à threshold\n",
+        "    if final_error <= threshold:\n",
+        "        success_rates_without.append(1)\n",
+        "    else:\n",
+        "        success_rates_without.append(0)\n",
+        "\n",
+        "# Calcul du taux de succès et du taux de décrochage pour le cas avec momentum\n",
+        "n_without = len(success_rates_without)  # utilisation d'un nouveau nom pour le nombre d'expériences\n",
+        "p_success = np.mean(success_rates_without)\n",
+        "taux_de_decochage = 1 - p_success\n",
+        "print(\"Taux de décrochage (avec momentum): {:.2%}\".format(taux_de_decochage))\n",
+        "# Calcul de l'intervalle exact de Clopper-Pearson pour le taux de succès\n",
+        "ci_success = st.binom.interval(0.95, n_without, p_success)\n",
+        "# Conversion de l'intervalle en proportions\n",
+        "p_lower = ci_success[0] / n_without\n",
+        "p_upper = ci_success[1] / n_without\n",
+        "# Transformation en intervalle pour le taux de décrochage :\n",
+        "# Si le taux de succès est dans [p_lower, p_upper],\n",
+        "# alors le taux de décrochage est dans [1 - p_upper, 1 - p_lower]\n",
+        "ci_decochage = (1 - p_upper, 1 - p_lower)\n",
+        "print(\"Intervalle de confiance Clopper-Pearson pour le taux de décrochage (avec momentum): [{:.2%}, {:.2%}]\".format(ci_decochage[0], ci_decochage[1]))\n",
+        "\n",
+        "\n",
+        "# --- Expériences Monte Carlo avec momentum ---\n",
+        "for exp in range(num_experiments):\n",
+        "    # Initialisation de l'estimation\n",
+        "    theta_est = theta_star_sequence[0] + 0.01 * np.random.randn(2 * r)\n",
+        "\n",
+        "    for t in range(time_steps):\n",
+        "        # Récupération des vrais paramètres pour le pas t\n",
+        "        theta_star = theta_star_sequence[t]\n",
+        "        a_star, tau_star = theta_star[:r], theta_star[r:]\n",
+        "\n",
+        "        # Calcul de l'observation et ajout du bruit\n",
+        "        y_current = compute_z(a_star, tau_star, g_star, freqs)\n",
+        "        y_current = add_noise(y_current, snr_db)\n",
+        "\n",
+        "        # Descente de gradient avec momentum\n",
+        "        theta_est, loss_values = preconditioned_gradient_descent(\n",
+        "            MSE_loss, theta_est, y_current.reshape(-1, 1),\n",
+        "            learning_rate=learning_rate, momentum=momentum_with,\n",
+        "            max_iters=gradient_steps_per_time\n",
+        "        )\n",
+        "\n",
+        "        # Calcul et stockage de l'erreur (norme euclidienne)\n",
+        "        #error = min_norm_permuted_theta(theta_est, theta_star)\n",
+        "        error = min_norm_permuted_tau(theta_est, theta_star)\n",
+        "        errors_with[exp, t] = error\n",
+        "\n",
+        "    # --- Calcul du taux de décochage ---\n",
+        "    # On définit les paramètres finaux et on calcule l'observation finale\n",
+        "    theta_star_final = theta_star_sequence[-1]\n",
+        "    a_star_final, tau_star_final = theta_star_final[:r], theta_star_final[r:]\n",
+        "    y_final = compute_z(a_star_final, tau_star_final, g_star, freqs)\n",
+        "    y_final = add_noise(y_final, snr_db)\n",
+        "\n",
+        "    # Refaire une descente de gradient à partir de theta_est obtenu à la fin\n",
+        "    theta_est_refined, loss_values_final = preconditioned_gradient_descent(\n",
+        "        MSE_loss, theta_est, y_final.reshape(-1, 1),\n",
+        "        learning_rate=learning_rate, momentum=momentum_with,\n",
+        "        max_iters=gradient_steps_per_time\n",
+        "    )\n",
+        "\n",
+        "    # Calcul de l'erreur finale après re-descente\n",
+        "    final_error = min_norm_permuted_theta(theta_est_refined, theta_star_final)\n",
+        "\n",
+        "    # Vérifier si l'erreur finale est inférieure ou égale à threshold\n",
+        "    if final_error <= threshold:\n",
+        "        success_rates_with.append(1)\n",
+        "    else:\n",
+        "        success_rates_with.append(0)\n",
+        "\n",
+        "# Calcul du taux de succès et du taux de décrochage pour le cas avec momentum\n",
+        "n_with = len(success_rates_with)  # utilisation d'un nouveau nom pour le nombre d'expériences\n",
+        "p_success = np.mean(success_rates_with)\n",
+        "taux_de_decochage = 1 - p_success\n",
+        "print(\"Taux de décrochage (avec momentum): {:.2%}\".format(taux_de_decochage))\n",
+        "# Calcul de l'intervalle exact de Clopper-Pearson pour le taux de succès\n",
+        "ci_success = st.binom.interval(0.95, n_with, p_success)\n",
+        "# Conversion de l'intervalle en proportions\n",
+        "p_lower = ci_success[0] / n_with\n",
+        "p_upper = ci_success[1] / n_with\n",
+        "# Transformation en intervalle pour le taux de décrochage :\n",
+        "# Si le taux de succès est dans [p_lower, p_upper],\n",
+        "# alors le taux de décrochage est dans [1 - p_upper, 1 - p_lower]\n",
+        "ci_decochage = (1 - p_upper, 1 - p_lower)\n",
+        "print(\"Intervalle de confiance Clopper-Pearson pour le taux de décrochage (avec momentum): [{:.2%}, {:.2%}]\".format(ci_decochage[0], ci_decochage[1]))"
+      ],
+      "metadata": {
+        "id": "h7ALP7toJFzL",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6cb484e4-d667-4983-b10f-52349d585ec3"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Taux de décrochage (avec momentum): 8.00%\n",
+            "Intervalle de confiance Clopper-Pearson pour le taux de décrochage (avec momentum): [4.50%, 12.00%]\n",
+            "Taux de décrochage (avec momentum): 1.50%\n",
+            "Intervalle de confiance Clopper-Pearson pour le taux de décrochage (avec momentum): [0.00%, 3.50%]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calcul des erreurs moyennes et des écarts-types (on ignore le premier pas si nécessaire)\n",
+        "mean_errors_with = np.median(errors_with, axis=0)[1:]\n",
+        "q1_errors_with = np.percentile(errors_with, 25, axis=0)[1:]\n",
+        "q3_errors_with = np.percentile(errors_with, 75, axis=0)[1:]\n",
+        "\n",
+        "mean_errors_without = np.median(errors_without, axis=0)[1:]\n",
+        "std_errors_without = np.std(errors_without, axis=0)[1:]\n",
+        "q1_errors_without = np.percentile(errors_without, 25, axis=0)[1:]\n",
+        "q3_errors_without = np.percentile(errors_without, 75, axis=0)[1:]\n",
+        "\n",
+        "# Calcul de la borne de Cramér-Rao (CRB) pour chaque pas de temps\n",
+        "#crb_values = compute_crb_values(theta_star_sequence, snr_db)[1:]\n",
+        "crb_values = compute_crb_tau_values(theta_star_sequence, snr_db)[1:]\n",
+        "\n",
+        "# Tracé des résultats\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "\n",
+        "# Courbe sans momentum\n",
+        "plt.plot(mean_errors_without, label=\"Erreur médiane \\n sans momentum\", color='green', linestyle='-.')\n",
+        "plt.fill_between(np.arange(time_steps)[:-1], mean_errors_without - q1_errors_without,\n",
+        "                 mean_errors_without + q3_errors_without, color='green', alpha=0.3,\n",
+        "                 label=r\"$Q_1 - Q_3$\")\n",
+        "\n",
+        "# Courbe avec momentum\n",
+        "plt.plot(mean_errors_with, label=\"Erreur médiane \\n avec momentum\", color='red', linestyle=':')\n",
+        "plt.fill_between(np.arange(time_steps)[:-1], mean_errors_with - q1_errors_with,\n",
+        "                 mean_errors_with + q3_errors_with, color='red', alpha=0.3,\n",
+        "                 label=r\"$Q_1 - Q_3$\")\n",
+        "\n",
+        "# Borne de Cramér-Rao\n",
+        "plt.plot(crb_values, '--', label=\"Borne de Cramér-Rao\", color=\"black\")\n",
+        "\n",
+        "\n",
+        "plt.xlabel(\"Pas de temps\", fontsize=16)\n",
+        "#plt.ylabel(r\"Erreur $md_2(\\hat{\\theta};\\theta^\\ast)$\", fontsize=16)\n",
+        "plt.ylabel(r\"Erreur $md_2(\\hat{\\tau};\\tau^\\ast)$\", fontsize=16)\n",
+        "#plt.title(\"Comparaison des performances avec et sans momentum sur {} expériences\".format(num_experiments))\n",
+        "plt.yscale(\"log\")  # Échelle logarithmique sur l'axe des ordonnées\n",
+        "plt.ylim(1e-3,10)\n",
+        "plt.legend()\n",
+        "plt.grid(True, which=\"both\", linestyle=\"--\")\n",
+        "\n",
+        "# Modification\n",
+        "plt.xticks(fontsize=16)\n",
+        "plt.yticks(fontsize=16)\n",
+        "plt.legend(fontsize=16)\n",
+        "\n",
+        "# Save the figure as a PDF\n",
+        "pdf_filename = \"/content/DMPGDvDPGD.pdf\"\n",
+        "plt.savefig(pdf_filename, format=\"pdf\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 564
+        },
+        "id": "bzRoKSmWaSE3",
+        "outputId": "523f3423-b1a1-40fc-ddee-1eeb0bbd9055"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "pZ1b75i5ZCeX"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
-- 
GitLab