Initial Commit

2025/2025.ipynb

@@ -0,0 +1,298 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "2QuiuhUXUndl"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import scipy.io\n",
+        "import time\n",
+        "from scipy.sparse import csc_matrix, hstack"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "1xIVmvlUUvFZ"
+      },
+      "outputs": [],
+      "source": [
+        "def load_data(name, big_data=False):\n",
+        "  S = scipy.io.loadmat(name)\n",
+        "  if big_data:\n",
+        "    a = S[\"a\"].tocsr() #ajouter \".tocsr()\" pour le dataset \"Ybig_train_set.mat\"\n",
+        "  else:\n",
+        "    a = S[\"a\"]\n",
+        "  y = S[\"y\"]\n",
+        "  id_classe1 = np.where(y==1)[0]\n",
+        "  id_classe2 = np.where(y==0)[0]\n",
+        "  return a[id_classe1,:], a[id_classe2,:]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "l4L0fk4YU1fE"
+      },
+      "outputs": [],
+      "source": [
+        "def optimisation(classe1,classe2,methode=\"gradient\",pas=\"wolfe\",maxiter=10000,maxtime=10,big_data=False):\n",
+        "  def fct(x):\n",
+        "\n",
+        "    # Valeur pour clip l'exponentielle (éviter certains problèmes)\n",
+        "    D = 50\n",
+        "\n",
+        "    # Pour les yi==0\n",
+        "    exposant = np.clip(a1@x, -D , D)\n",
+        "    exp = np.exp(-exposant)\n",
+        "    f1 = sum(np.log(1+exp))\n",
+        "\n",
+        "    g1 = -a1.T@(exp/(1+exp))\n",
+        "\n",
+        "    # Pour les yi==1\n",
+        "    exposant = np.clip(a2@x, -D, D)\n",
+        "    exp = np.exp(-exposant)\n",
+        "\n",
+        "    f2 = sum(exp) + sum(np.log(1+exp))\n",
+        "\n",
+        "    g2 = a2.T@(1/(1+exp))\n",
+        "\n",
+        "    f = f1 + f2\n",
+        "    g = g1 + g2\n",
+        "    return f, g\n",
+        "\n",
+        "  def w1(x,d,alpha,beta1):\n",
+        "    f0, g0 = fct(x)\n",
+        "    f1, g1 = fct(x+alpha*d)\n",
+        "    return f1 <= f0 + alpha*beta1*np.dot(d,g0)\n",
+        "\n",
+        "  def w2(x,d,alpha,beta2):\n",
+        "    f0, g0 = fct(x)\n",
+        "    f1, g1 = fct(x+alpha*d)\n",
+        "    return np.dot(d,g1) >= beta2*np.dot(d,g0)\n",
+        "\n",
+        "  def wolfebissection(x,d,alpha=1,beta1=0.0001,beta2=0.9):\n",
+        "    aleft  = 0\n",
+        "    aright = np.inf\n",
+        "    iter   = 0\n",
+        "    while True:\n",
+        "      if w1(x,d,alpha,beta1) and w2(x,d,alpha,beta2):\n",
+        "        break\n",
+        "      if not w1(x,d,alpha,beta1):\n",
+        "        aright = alpha\n",
+        "        alpha  = (aleft+aright)/2\n",
+        "      elif not w2(x,d,alpha,beta2):\n",
+        "        aleft = alpha\n",
+        "        if aright<np.inf:\n",
+        "          alpha = (aleft+aright)/2\n",
+        "        else:\n",
+        "          alpha = 2*alpha #le \"2\" est arbitraire, du moment que ce soit >1\n",
+        "      iter += 1\n",
+        "    return alpha\n",
+        "\n",
+        "  def backtrackingsimple(x,d,alpha=1):\n",
+        "    f0, g0 = fct(x) # valeur et gradient à l'itéré\n",
+        "    f1, g1 = fct(x+alpha*d) # valeur et gradient à l'itéré souhaité\n",
+        "\n",
+        "    while f1>f0 and alpha>=1e-16:\n",
+        "      alpha /= 2\n",
+        "      f1, g1 = fct(alpha*d)\n",
+        "    \n",
+        "    return alpha\n",
+        "\n",
+        "  def methgradient(x0):\n",
+        "    start_time = time.time()\n",
+        "    temps = np.zeros(maxiter)\n",
+        "    fobj = np.zeros(maxiter)\n",
+        "    x = x0.copy()\n",
+        "\n",
+        "    for k in range(maxiter):\n",
+        "      f, g = fct(x)\n",
+        "      d = -g\n",
+        "\n",
+        "      if pas==\"wolfe\":\n",
+        "        alpha = wolfebissection(x, d)\n",
+        "      elif pas==\"back\":\n",
+        "        alpha = backtrackingsimple(x, d)\n",
+        "\n",
+        "      x = x + alpha*d\n",
+        "\n",
+        "      f, g = fct(x)\n",
+        "      fobj[k] = f\n",
+        "      temps[k] = time.time() - start_time\n",
+        "\n",
+        "      if temps[k] >= maxtime:\n",
+        "        break\n",
+        "    return x, fobj[k+1], temps[k+1]\n",
+        "\n",
+        "  def methgradientacc(x0):\n",
+        "    # Pas fait en séance\n",
+        "    pass\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "  #Données des deux groupes a1 et a2\n",
+        "  n1, m    = classe1.shape\n",
+        "  n2, m    = classe2.shape\n",
+        "  if big_data:\n",
+        "    a1       = np.ones((n1, 1+m)) # !! csc_matrix()\n",
+        "    a2       = np.ones((n1, 1+m))\n",
+        "  else:\n",
+        "    a1       = np.ones((n1, 1+m)) # !! csc_matrix()\n",
+        "    a2       = np.ones((n1, 1+m))\n",
+        "\n",
+        "  a1[:,1:] = classe1\n",
+        "  a2[:,1:] = classe2\n",
+        "  #Itéré initial\n",
+        "  x0       = np.ones(1+m)\n",
+        "\n",
+        "  if methode==\"gradient\":    x,f,t = methgradient(x0)\n",
+        "  # Pas fait en séance\n",
+        "  # if methode==\"gradientacc\": x,f,t = methgradientacc(x0)\n",
+        "\n",
+        "  return x, f, t"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "DOjbhWDDgxW0"
+      },
+      "outputs": [],
+      "source": [
+        "# ############# Entrainement du modèle #############\n",
+        "classe1_train, classe2_train = load_data(\"train_set.mat\")\n",
+        "x_gd_wf, f_gd_wf, t_gd_wf = optimisation(classe1_train,classe2_train,maxtime=60)\n",
+        "x_gd_bt, f_gd_bt, t_gd_bt = optimisation(classe1_train,classe2_train,pas=\"back\",maxtime=60)\n",
+        "#x_ga_wf, f_ga_wf, t_ga_wf = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"wolfe\",maxtime=60)\n",
+        "#x_ga_bt, f_ga_bt, t_ga_bt = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"backtracking\",maxtime=60)\n",
+        "plt.loglog(t_gd_wf,f_gd_wf,label=\"Grad. Wolfe\")\n",
+        "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n",
+        "#plt.loglog(t_ga_wf,f_ga_wf,label=\"GradAcc. Wolfe\")\n",
+        "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n",
+        "plt.xlabel(\"Temps\")\n",
+        "plt.ylabel(\"Erreur\")\n",
+        "plt.legend(loc=1)\n",
+        "plt.show()\n",
+        "\n",
+        "plt.loglog(t_gd_wf,f_gd_wf,label=\"Grad. Wolfe\")\n",
+        "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n",
+        "#plt.loglog(t_ga_wf,f_ga_wf,label=\"GradAcc. Wolfe\")\n",
+        "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n",
+        "plt.xlabel(\"Temps\")\n",
+        "plt.ylabel(\"Erreur\")\n",
+        "plt.legend(loc=1)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "LLaiMIxoYG6P"
+      },
+      "outputs": [],
+      "source": [
+        "classe1_train, classe2_train = load_data(\"big_train_set.mat\", big_data=True)\n",
+        "x_gd_bt, f_gd_bt, t_gd_bt = optimisation(classe1_train,classe2_train,pas=\"backtracking\",maxtime=180,big_data=True)\n",
+        "#x_ga_bt, f_ga_bt, t_ga_bt = optimisation(classe1_train,classe2_train,methode=\"gradientacc\", pas=\"backtracking\",maxtime=180)\n",
+        "\n",
+        "plt.loglog(t_gd_bt,f_gd_bt,label=\"Grad. Backting\")\n",
+        "#plt.loglog(t_ga_bt,f_ga_bt,label=\"GradAcc. Backting\")\n",
+        "plt.xlabel(\"Temps\")\n",
+        "plt.ylabel(\"Erreur\")\n",
+        "plt.legend(loc=1)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "AmSlY7I-kH7X"
+      },
+      "outputs": [],
+      "source": [
+        "def entrainement(classe1,classe2):\n",
+        "  ..."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qE7YMoJ7lbJN"
+      },
+      "outputs": [],
+      "source": [
+        "############# Entrainement du modèle #############\n",
+        "classe1_train, classe2_train = load_data(\"Ybig_train_set.mat\")\n",
+        "poids_reseau = entrainement(classe1_train,classe2_train)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JEyEwFCcVQge"
+      },
+      "outputs": [],
+      "source": [
+        "def validation(poids_reseau,classe1_test,classe2_test):\n",
+        "  def pred_sigmoide(poids_reseau,data):\n",
+        "    return np.round(1/(1+np.exp(-poids_reseau[0]-data.dot(poids_reseau[1:]))))\n",
+        "  correct = 0\n",
+        "  nb1, nb2 = classe1_test.shape[0], classe2_test.shape[0]\n",
+        "  for i in range(nb1): correct += pred_sigmoide(poids_reseau,classe1_test[i,:])\n",
+        "  for i in range(nb2): correct += 1-pred_sigmoide(poids_reseau,classe2_test[i,:])\n",
+        "  print(f\"{correct}/{nb1+nb2} donnees classees correctement dans jeu test\")\n",
+        "  return correct"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "HgnXLoUmmY8h"
+      },
+      "outputs": [],
+      "source": [
+        "############# Validation du modèle #############\n",
+        "classe1_test, classe2_test = load_data(\"Ybig_test_set.mat\")\n",
+        "result = validation(poids_reseau,classe1_test,classe2_test)"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "optinonlin",
+      "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.13.2"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}