NN_ft_exp_LR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creation df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import re\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import (\n",
    "    mean_squared_error,\n",
    "    mean_absolute_error,\n",
    "    median_absolute_error,\n",
    "    r2_score,\n",
    ")\n",
    "from sklearn.metrics import root_mean_squared_error\n",
    "import os\n",
    "import joblib\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import (\n",
    "    mean_squared_error,\n",
    "    mean_absolute_error,\n",
    "    median_absolute_error,\n",
    "    r2_score,\n",
    ")\n",
    "import os\n",
    "import joblib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import (\n",
    "    mean_squared_error,\n",
    "    mean_absolute_error,\n",
    "    median_absolute_error,\n",
    "    r2_score,\n",
    ")\n",
    "from itertools import combinations\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression, Ridge\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import time\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression, Ridge\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import time\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from joblib import dump"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"simulation_results_with_pressure_without_early_values.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_predictions_vs_actual(\n",
    "    y_true, y_pred, save_path=\"graphes_NN\", sample_fraction=0.1\n",
    "):\n",
    "    \"\"\"\n",
    "    Plots predicted values versus actual values and saves the plot as a PDF.\n",
    "\n",
    "    Parameters:\n",
    "        y_true (array-like): Array of true values.\n",
    "        y_pred (array-like): Array of predicted values.\n",
    "        save_path (str): Directory where the PDF file will be saved.\n",
    "        sample_fraction (float): Fraction of the data to sample for faster plotting.\n",
    "    \"\"\"\n",
    "    # Ensure the directory exists\n",
    "    if not os.path.exists(save_path):\n",
    "        os.makedirs(save_path)\n",
    "\n",
    "    # Reducing the dataset size if it's too large\n",
    "    if len(y_true) > 1000:  # Only sample if the dataset is large\n",
    "        sample_size = int(len(y_true) * sample_fraction)\n",
    "        indices = np.random.choice(len(y_true), sample_size, replace=False)\n",
    "        y_true = y_true[indices]\n",
    "        y_pred = y_pred[indices]\n",
    "\n",
    "    # Create the plot\n",
    "    fig, ax = plt.subplots(figsize=(8, 8))\n",
    "    ax.scatter(y_true, y_pred, alpha=0.7, label=\"Predicted vs Actual\")\n",
    "    ax.plot(\n",
    "        [min(y_true), max(y_true)], [min(y_true), max(y_true)], \"r--\", label=\"Ideal\"\n",
    "    )\n",
    "    ax.set_title(\"Predicted vs Actual Values\")\n",
    "    ax.set_xlabel(\"Actual Values\")\n",
    "    ax.set_ylabel(\"Predicted Values\")\n",
    "    ax.grid(True)\n",
    "\n",
    "    # Save the plot as a PDF\n",
    "    pdf_path = os.path.join(save_path, \"predicted_vs_actual.pdf\")\n",
    "    fig.savefig(pdf_path, format=\"pdf\")\n",
    "    plt.close(fig)  # Close the figure to free memory\n",
    "\n",
    "    print(f\"Graph saved to {pdf_path}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_regression_model(\n",
    "    df,\n",
    "    feature_expansion=False,\n",
    "    regularization=False,\n",
    "    folder=\".\",\n",
    "    alpha=1.0,\n",
    "    plot_and_save=False,\n",
    "    plot_coefs=False,\n",
    "    degree=7,\n",
    "):\n",
    "    # Création du dossier si non existant\n",
    "    if not os.path.exists(folder):\n",
    "        os.makedirs(folder)\n",
    "\n",
    "    # Sélection des variables d'entrée et de sortie\n",
    "    X = df[\n",
    "        [\n",
    "            \"lhgr\",\n",
    "            \"fuel_radius\",\n",
    "            \"gap_size\",\n",
    "            \"clad_thickness\",\n",
    "            \"coolant_temperature\",\n",
    "            \"time\",\n",
    "        ]\n",
    "    ]\n",
    "    y = df[\"volAverage(T)\"]\n",
    "\n",
    "    # Standardisation des données pour éviter les problèmes de conditionnement\n",
    "    scaler = StandardScaler()\n",
    "    X_scaled = scaler.fit_transform(X)\n",
    "\n",
    "    # Expansion des caractéristiques si activée\n",
    "    if feature_expansion:\n",
    "        poly = PolynomialFeatures(\n",
    "            degree=degree, interaction_only=False, include_bias=False\n",
    "        )\n",
    "        X_expanded = poly.fit_transform(X_scaled)\n",
    "        feature_names = poly.get_feature_names_out(X.columns)\n",
    "        X_scaled = X_expanded\n",
    "\n",
    "    # Séparation des données en ensembles d'entraînement et de test\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X_scaled, y, test_size=0.2, random_state=42\n",
    "    )\n",
    "\n",
    "    # Création du modèle avec régularisation (Ridge) si activée\n",
    "    if regularization:\n",
    "        model = Ridge(alpha=alpha)\n",
    "    else:\n",
    "        model = LinearRegression()\n",
    "\n",
    "    # Entraînement du modèle\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # Prédictions\n",
    "    y_pred = model.predict(X_test)\n",
    "\n",
    "    # Calcul de l'erreur MSE et RMSE\n",
    "    mse = mean_squared_error(y_test, y_pred)\n",
    "    rmse = np.sqrt(mse)\n",
    "    print(f\"Mean Squared Error: {mse}\")\n",
    "    print(f\"Root Mean Squared Error (RMSE): {rmse}\")\n",
    "\n",
    "    # Paramètres utilisés dans le graphique\n",
    "    feature_expansion_str = (\n",
    "        \"Feature Expansion\" if feature_expansion else \"No Feature Expansion\"\n",
    "    )\n",
    "    regularization_str = (\n",
    "        f\"Regularization (alpha={alpha})\" if regularization else \"No Regularization\"\n",
    "    )\n",
    "\n",
    "    # Plot et sauvegarde des résultats de prédiction si activé\n",
    "    if plot_and_save:\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        plt.scatter(y_test, y_pred, alpha=0.2, label=\"Predictions\")\n",
    "        plt.plot(\n",
    "            [y_test.min(), y_test.max()],\n",
    "            [y_test.min(), y_test.max()],\n",
    "            color=\"red\",\n",
    "            linestyle=\"--\",\n",
    "            label=\"Ideal line\",\n",
    "        )\n",
    "        plt.xlabel(\"Real temperature (K)\", fontsize=18)\n",
    "        plt.ylabel(\"Predicted temperature (K)\", fontsize=18)\n",
    "        plt.legend(title=f\"RMSE: {rmse:.2f} K\")\n",
    "        plt.grid(True)\n",
    "        plt.tight_layout()\n",
    "\n",
    "        # Increase the tick label size\n",
    "        plt.tick_params(axis=\"both\", labelsize=16)  # Adjust '14' as per your preference\n",
    "\n",
    "        plt.savefig(\n",
    "            f\"{folder}/predictions_vs_true_values_{feature_expansion_str}_{regularization_str}_degree{degree}.pdf\"\n",
    "        )\n",
    "        plt.show()\n",
    "        plt.close()\n",
    "\n",
    "    # Plot et sauvegarde des coefficients si activé\n",
    "    if plot_coefs:\n",
    "        coefs = model.coef_\n",
    "        coef_names = X.columns if not feature_expansion else feature_names\n",
    "\n",
    "        # Sélection des 15 plus grands coefficients en valeur absolue\n",
    "        abs_coefs = np.abs(coefs)\n",
    "        top_15_indices = np.argsort(abs_coefs)[-15:]\n",
    "\n",
    "        top_15_coefs = coefs[top_15_indices]\n",
    "        top_15_coef_names = [coef_names[i] for i in top_15_indices]\n",
    "\n",
    "        plt.figure(figsize=(10, 6))\n",
    "        plt.barh(top_15_coef_names, top_15_coefs)\n",
    "        plt.xlabel(\"Coefficient Value\", fontsize=18)\n",
    "        plt.grid(True)\n",
    "        plt.tight_layout()\n",
    "\n",
    "        # Increase the tick label size\n",
    "        plt.tick_params(axis=\"both\", labelsize=16)  # Adjust '14' as per your preference\n",
    "\n",
    "        plt.savefig(\n",
    "            f\"{folder}/top_15_model_coefficients_{feature_expansion_str}_{regularization_str}_degree{degree}.pdf\"\n",
    "        )\n",
    "        plt.show()\n",
    "        plt.close()\n",
    "\n",
    "    return model, mse, rmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_rmse_time(df, folder=\".\", regularization=False, alpha=1.0):\n",
    "    results = []  # Pour stocker les résultats\n",
    "    for degree in range(1, 11):  # Degré de 1 à 11\n",
    "        print(f\"Evaluating degree {degree}...\")\n",
    "        start_time = time.time()\n",
    "\n",
    "        # Appel de la fonction de régression avec l'expansion des caractéristiques\n",
    "        model, mse, rmse = linear_regression_model(\n",
    "            df,\n",
    "            feature_expansion=True,\n",
    "            regularization=regularization,\n",
    "            folder=folder,\n",
    "            alpha=alpha,\n",
    "            plot_and_save=False,\n",
    "            plot_coefs=False,\n",
    "            degree=degree,\n",
    "        )\n",
    "\n",
    "        elapsed_time = time.time() - start_time  # Temps de calcul\n",
    "        print(f\"Time for degree {degree}: {elapsed_time:.4f} seconds\")\n",
    "\n",
    "        # Enregistrement des résultats dans la liste\n",
    "        results.append(\n",
    "            {\"Degree\": degree, \"RMSE\": rmse, \"Computation Time\": elapsed_time}\n",
    "        )\n",
    "\n",
    "        # Sauvegarde dans un fichier CSV\n",
    "        results_df = pd.DataFrame(results)\n",
    "        results_df.to_csv(f\"{folder}/evaluation_results.csv\", index=False)\n",
    "\n",
    "    # Lecture des résultats et tracé des courbes\n",
    "    results_df = pd.read_csv(f\"{folder}/evaluation_results.csv\")\n",
    "\n",
    "    plt.figure(figsize=(12, 8))\n",
    "\n",
    "    # Axe principal pour RMSE\n",
    "    ax1 = plt.gca()\n",
    "    ax1.plot(\n",
    "        results_df[\"Degree\"], results_df[\"RMSE\"], label=\"RMSE\", marker=\"o\", color=\"blue\"\n",
    "    )\n",
    "    ax1.set_xlabel(\"Degree of Polynomial Expansion\", fontsize=18)\n",
    "    ax1.set_ylabel(\"RMSE\", fontsize=18, color=\"blue\")\n",
    "    ax1.tick_params(axis=\"y\", labelcolor=\"blue\", labelsize=18)\n",
    "    ax1.tick_params(axis=\"x\", labelsize=18)\n",
    "\n",
    "    # Formatage des axes x pour n'afficher que des entiers\n",
    "    ax1.set_xticks(np.arange(1, 10, 1))  # Seules les valeurs entières de 1 à 9\n",
    "    ax1.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f\"{int(x)}\"))\n",
    "\n",
    "    # Application de l'échelle logarithmique sur l'axe des RMSE\n",
    "    ax1.set_yscale(\"log\")\n",
    "\n",
    "    # Axe secondaire pour le temps de calcul\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(\n",
    "        results_df[\"Degree\"],\n",
    "        results_df[\"Computation Time\"],\n",
    "        label=\"Computation Time\",\n",
    "        marker=\"o\",\n",
    "        color=\"black\",\n",
    "    )\n",
    "    ax2.set_ylabel(\"Computation Time (s)\", fontsize=18, color=\"black\")\n",
    "    ax2.tick_params(axis=\"y\", labelcolor=\"black\", labelsize=18)\n",
    "\n",
    "    # Application de l'échelle logarithmique sur l'axe du temps de calcul\n",
    "    ax2.set_yscale(\"log\")\n",
    "\n",
    "    # Formatage des axes y pour les entiers\n",
    "    ax2.tick_params(axis=\"y\", labelsize=18)\n",
    "\n",
    "    # Grille pour les entiers seulement\n",
    "    ax1.grid(True, which=\"both\", axis=\"x\", color=\"gray\", linestyle=\"-\", linewidth=0.5)\n",
    "\n",
    "    # Titre et légendes\n",
    "    plt.title(\n",
    "        \"RMSE and Computation Time vs Degree of Polynomial Expansion\", fontsize=18\n",
    "    )\n",
    "    ax1.legend(loc=\"upper left\", fontsize=18)\n",
    "    ax2.legend(loc=\"upper right\", fontsize=18)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(f\"{folder}/rmse_and_computation_time_vs_degree_log.pdf\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 1481.1741820995328\n",
      "Root Mean Squared Error (RMSE): 38.48602580287464\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model, mse, rmse = linear_regression_model(\n",
    "    df,\n",
    "    feature_expansion=False,\n",
    "    regularization=True,\n",
    "    folder=\"LR_plots\",\n",
    "    alpha=1.0,\n",
    "    plot_and_save=True,\n",
    "    plot_coefs=True,\n",
    "    degree=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully connected NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_hidden_layers):\n",
    "        super(NeuralNetwork, self).__init__()\n",
    "        layers = [nn.Linear(input_size, hidden_size), nn.ReLU()]\n",
    "        for _ in range(num_hidden_layers - 1):\n",
    "            layers.extend([nn.Linear(hidden_size, hidden_size), nn.ReLU()])\n",
    "        layers.append(nn.Linear(hidden_size, 1))\n",
    "        self.network = nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.network(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fully_connected_NN(\n",
    "    df, K, L, num_epochs, lr_init, lr_step, lr_gamma, save_path=\"model_save\"\n",
    "):\n",
    "    # Définir les entrées (features) et la sortie (target)\n",
    "    X = df[\n",
    "        [\n",
    "            \"lhgr\",\n",
    "            \"fuel_radius\",\n",
    "            \"gap_size\",\n",
    "            \"clad_thickness\",\n",
    "            \"coolant_temperature\",\n",
    "            \"time\",\n",
    "        ]\n",
    "    ].values\n",
    "    y = df[\"volAverage(T)\"].values\n",
    "\n",
    "    # Diviser les données en ensembles d'entraînement et de test\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, test_size=0.2, random_state=42\n",
    "    )\n",
    "\n",
    "    # Standardiser les données d'entrée\n",
    "    scaler = StandardScaler()\n",
    "    X_train_scaled = scaler.fit_transform(X_train)\n",
    "    X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "    # Convertir les données en tenseurs PyTorch\n",
    "    X_train_tensor = torch.tensor(X_train_scaled, dtype=torch.float32)\n",
    "    y_train_tensor = torch.tensor(y_train, dtype=torch.float32).unsqueeze(1)\n",
    "    X_test_tensor = torch.tensor(X_test_scaled, dtype=torch.float32)\n",
    "    y_test_tensor = torch.tensor(y_test, dtype=torch.float32).unsqueeze(1)\n",
    "\n",
    "    # Initialisation du modèle\n",
    "    model = NeuralNetwork(\n",
    "        input_size=X_train_tensor.shape[1], hidden_size=K, num_hidden_layers=L\n",
    "    )\n",
    "\n",
    "    # Définir la fonction de perte, l'optimiseur et le scheduler\n",
    "    criterion = nn.MSELoss()\n",
    "    optimizer = optim.Adam(model.parameters(), lr=lr_init)\n",
    "    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=lr_step, gamma=lr_gamma)\n",
    "\n",
    "    # Entraîner le modèle\n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "    y_pred_all = []  # Liste pour stocker les prédictions\n",
    "    y_test_all = []  # Liste pour stocker les valeurs réelles\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        # Entraînement\n",
    "        model.train()\n",
    "        optimizer.zero_grad()\n",
    "        predictions = model(X_train_tensor)\n",
    "        loss = criterion(predictions, y_train_tensor)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Ajuster le learning rate avec le scheduler\n",
    "        scheduler.step()\n",
    "\n",
    "        # Évaluation sur l'ensemble de test\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            test_predictions = model(X_test_tensor)\n",
    "            test_loss = criterion(test_predictions, y_test_tensor)\n",
    "\n",
    "            # Stocker les valeurs réelles et prédites pour le tracé\n",
    "            y_pred_all.append(test_predictions.numpy().flatten())\n",
    "            y_test_all.append(y_test_tensor.numpy().flatten())\n",
    "\n",
    "        train_losses.append(loss.item())\n",
    "        test_losses.append(test_loss.item())\n",
    "        print(\n",
    "            f\"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}, Test Loss: {test_loss.item():.4f}\"\n",
    "        )\n",
    "\n",
    "    # Convertir les listes en tableaux numpy pour faciliter l'utilisation\n",
    "    y_pred_all = np.concatenate(y_pred_all)\n",
    "    y_test_all = np.concatenate(y_test_all)\n",
    "\n",
    "    # Sauvegarde des informations nécessaires pour utiliser le modèle comme boîte noire\n",
    "    os.makedirs(save_path, exist_ok=True)\n",
    "    torch.save(model.state_dict(), os.path.join(save_path, \"model.pth\"))\n",
    "    np.save(os.path.join(save_path, \"scaler_mean.npy\"), scaler.mean_)\n",
    "    np.save(os.path.join(save_path, \"scaler_scale.npy\"), scaler.scale_)\n",
    "\n",
    "    print(f\"Modèle et informations sauvegardés dans le dossier : {save_path}\")\n",
    "\n",
    "    # Tracer les learning curves (courbes d'apprentissage)\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(range(num_epochs), train_losses, label=\"Training Loss\")\n",
    "    plt.plot(range(num_epochs), test_losses, label=\"Test Loss\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Learning Curves\")\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.yscale(\"log\")\n",
    "    learning_curve_path = os.path.join(save_path, \"learning_curve.pdf\")\n",
    "    plt.savefig(learning_curve_path, format=\"pdf\")\n",
    "    plt.show()\n",
    "\n",
    "    # Sélectionner 1000 points au hasard\n",
    "    indices_aleatoires = np.random.choice(len(y_test_all), 1000, replace=False)\n",
    "    y_test_sample = y_test_all[indices_aleatoires]\n",
    "    y_pred_sample = y_pred_all[indices_aleatoires]\n",
    "\n",
    "    # Tracer la température prédites vs réelle pour les 1000 points choisis\n",
    "    plt.scatter(y_test_sample, y_pred_sample, alpha=0.5)\n",
    "    bounds = [min(y_test_sample + y_pred_sample), max(y_test_sample + y_pred_sample)]\n",
    "    plt.plot(bounds, bounds, \"r--\")\n",
    "    plt.xlabel(\"Actual Temperature (K)\")\n",
    "    plt.ylabel(\"Predicted Temperature (K)\")\n",
    "    plt.title(\"Predicted vs Actual Temperature\")\n",
    "    temperature_plot_path = os.path.join(save_path, \"predicted_vs_real_temperature.pdf\")\n",
    "    plt.savefig(temperature_plot_path, format=\"pdf\")\n",
    "    plt.grid()\n",
    "    plt.show()\n",
    "\n",
    "    # Retourner les résultats pour tracé et analyse\n",
    "    return model, y_pred_all, y_test_all, train_losses, test_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_temperature(params, model_path):\n",
    "    # Extraire K et L à partir du nom du dossier\n",
    "    match = re.search(r\"K(\\d+)_L(\\d+)\", model_path)\n",
    "    if not match:\n",
    "        raise ValueError(\"Le nom du dossier ne contient pas les informations K et L\")\n",
    "\n",
    "    K = int(match.group(1))\n",
    "    L = int(match.group(2))\n",
    "\n",
    "    # Initialisation du modèle avec K et L extraits\n",
    "    model = NeuralNetwork(input_size=6, hidden_size=K, num_hidden_layers=L)\n",
    "    model.load_state_dict(\n",
    "        torch.load(os.path.join(model_path, \"model.pth\"), weights_only=True)\n",
    "    )\n",
    "\n",
    "    # Normalisation des paramètres d'entrée (toujours nécessaire pour les features)\n",
    "    scaler_mean = np.load(os.path.join(model_path, \"scaler_mean.npy\"))\n",
    "    scaler_scale = np.load(os.path.join(model_path, \"scaler_scale.npy\"))\n",
    "    params_scaled = (params - scaler_mean) / scaler_scale\n",
    "\n",
    "    # Convertir les paramètres d'entrée en tenseur PyTorch\n",
    "    X_input_tensor = torch.tensor(params_scaled, dtype=torch.float32).unsqueeze(\n",
    "        0\n",
    "    )  # Ajouter la dimension du batch\n",
    "\n",
    "    # Prédiction\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        y_pred_normalized = model(X_input_tensor).numpy().flatten()\n",
    "\n",
    "    # Pas de dénormalisation nécessaire, retourner directement la prédiction\n",
    "    return y_pred_normalized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_validate_NN(\n",
    "    df,\n",
    "    K,\n",
    "    L,\n",
    "    num_epochs,\n",
    "    lr_init,\n",
    "    lr_step,\n",
    "    lr_gamma,\n",
    "    cv_folds=5,\n",
    "    save_path=\"crossvalidation_NN\",\n",
    "):\n",
    "    # Séparer le dataset initial\n",
    "    X = df[\n",
    "        [\n",
    "            \"lhgr\",\n",
    "            \"fuel_radius\",\n",
    "            \"gap_size\",\n",
    "            \"clad_thickness\",\n",
    "            \"coolant_temperature\",\n",
    "            \"time\",\n",
    "        ]\n",
    "    ].values\n",
    "    y = df[\"volAverage(T)\"].values\n",
    "    y = df[\"rodPressure\"].values\n",
    "\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, test_size=0.2, random_state=42\n",
    "    )\n",
    "\n",
    "    # Créer le dossier pour sauvegarder les modèles\n",
    "    os.makedirs(save_path, exist_ok=True)\n",
    "\n",
    "    # Initialiser les variables pour la validation croisée\n",
    "    kf = KFold(n_splits=cv_folds, shuffle=True, random_state=42)\n",
    "    results = []\n",
    "\n",
    "    best_model = None\n",
    "    best_rmse = float(\"inf\")\n",
    "    best_model_path = None\n",
    "\n",
    "    for fold, (train_idx, val_idx) in enumerate(kf.split(X_train)):\n",
    "        # Préparer les données pour le fold actuel\n",
    "        X_train_fold, X_val_fold = X_train[train_idx], X_train[val_idx]\n",
    "        y_train_fold, y_val_fold = y_train[train_idx], y_train[val_idx]\n",
    "\n",
    "        # Standardiser les données\n",
    "        scaler = StandardScaler()\n",
    "        X_train_fold_scaled = scaler.fit_transform(X_train_fold)\n",
    "        X_val_fold_scaled = scaler.transform(X_val_fold)\n",
    "\n",
    "        # Convertir en tenseurs PyTorch\n",
    "        X_train_tensor = torch.tensor(X_train_fold_scaled, dtype=torch.float32)\n",
    "        y_train_tensor = torch.tensor(y_train_fold, dtype=torch.float32).unsqueeze(1)\n",
    "        X_val_tensor = torch.tensor(X_val_fold_scaled, dtype=torch.float32)\n",
    "        y_val_tensor = torch.tensor(y_val_fold, dtype=torch.float32).unsqueeze(1)\n",
    "\n",
    "        # Initialiser le modèle\n",
    "        model = NeuralNetwork(\n",
    "            input_size=X_train_tensor.shape[1], hidden_size=K, num_hidden_layers=L\n",
    "        )\n",
    "        criterion = nn.MSELoss()\n",
    "        optimizer = optim.Adam(model.parameters(), lr=lr_init)\n",
    "        scheduler = optim.lr_scheduler.StepLR(\n",
    "            optimizer, step_size=lr_step, gamma=lr_gamma\n",
    "        )\n",
    "\n",
    "        # Entraîner le modèle\n",
    "        for epoch in range(num_epochs):\n",
    "            model.train()\n",
    "            optimizer.zero_grad()\n",
    "            predictions = model(X_train_tensor)\n",
    "            loss = criterion(predictions, y_train_tensor)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            scheduler.step()\n",
    "\n",
    "        # Évaluer le modèle sur l'ensemble de validation\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            val_predictions = model(X_val_tensor).numpy().flatten()\n",
    "            val_rmse = np.sqrt(mean_squared_error(y_val_fold, val_predictions))\n",
    "            val_mae = mean_absolute_error(y_val_fold, val_predictions)\n",
    "            val_r2 = r2_score(y_val_fold, val_predictions)\n",
    "\n",
    "        # Sauvegarder les résultats\n",
    "        results.append(\n",
    "            {\"fold\": fold + 1, \"rmse\": val_rmse, \"mae\": val_mae, \"r2\": val_r2}\n",
    "        )\n",
    "\n",
    "        # Sauvegarder le modèle si c'est le meilleur\n",
    "        model_path = os.path.join(save_path, f\"model_fold{fold + 1}.pth\")\n",
    "        torch.save(model.state_dict(), model_path)\n",
    "        if val_rmse < best_rmse:\n",
    "            best_rmse = val_rmse\n",
    "            best_model = model\n",
    "            best_model_path = model_path\n",
    "\n",
    "    # Sauvegarder les résultats de la validation croisée\n",
    "    results_df = pd.DataFrame(results)\n",
    "    results_df.loc[\"mean\"] = results_df.mean(numeric_only=True)\n",
    "    results_df.loc[\"std\"] = results_df.std(numeric_only=True)\n",
    "    results_df.to_csv(\n",
    "        os.path.join(save_path, \"cross_validation_results.csv\"), index=False\n",
    "    )\n",
    "\n",
    "    # Évaluer le meilleur modèle sur l'ensemble de test\n",
    "    best_model.load_state_dict(torch.load(best_model_path))\n",
    "    best_model.eval()\n",
    "    with torch.no_grad():\n",
    "        X_test_scaled = scaler.transform(X_test)\n",
    "        X_test_tensor = torch.tensor(X_test_scaled, dtype=torch.float32)\n",
    "        y_test_tensor = torch.tensor(y_test, dtype=torch.float32).unsqueeze(1)\n",
    "        test_predictions = best_model(X_test_tensor).numpy().flatten()\n",
    "        test_rmse = np.sqrt(mean_squared_error(y_test, test_predictions))\n",
    "        test_mae = mean_absolute_error(y_test, test_predictions)\n",
    "        test_r2 = r2_score(y_test, test_predictions)\n",
    "\n",
    "    print(\n",
    "        f\"Test RMSE: {test_rmse:.4f}, Test MAE: {test_mae:.4f}, Test R²: {test_r2:.4f}\"\n",
    "    )\n",
    "    return best_model, test_rmse, test_mae, test_r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "K = 15\n",
    "L = 3\n",
    "num_epochs = 5000\n",
    "lr_init = 0.2\n",
    "lr_step = num_epochs // 3  # mise à jour du learning rate tous les lr_step epochs\n",
    "lr_gamma = 0.2  # le learning rate en multiplié par cette valeur tous les lr_step epochs\n",
    "\n",
    "save_path = f\"model_save_K{K}_L{L}_num_epochs{num_epochs}_lrinit{lr_init}_lrstep{lr_step}_lrgamma{lr_gamma}\"\n",
    "\n",
    "# model, y_pred_all, y_test_all, train_losses, test_losses = fully_connected_NN(\n",
    "#     df, K, L, num_epochs, lr_init, lr_step, lr_gamma, save_path=save_path\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test RMSE: 13.0623, Test MAE: 8.2752, Test R²: 0.9960\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jlefo\\AppData\\Local\\Temp\\ipykernel_15460\\1789701885.py:106: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  best_model.load_state_dict(torch.load(best_model_path))\n"
     ]
    }
   ],
   "source": [
    "best_model, test_rmse, test_mae, test_r2 = cross_validate_NN(\n",
    "    df=df,  # Votre dataframe contenant les données\n",
    "    K=K,  # Taille des couches cachées\n",
    "    L=L,  # Nombre de couches cachées\n",
    "    num_epochs=num_epochs,  # Nombre d'époques d'entraînement\n",
    "    lr_init=lr_init,  # Taux d'apprentissage initial\n",
    "    lr_step=lr_step,  # Intervalle pour réduire le taux d'apprentissage\n",
    "    lr_gamma=lr_gamma,  # Facteur de réduction du taux d'apprentissage\n",
    "    cv_folds=5,  # Nombre de folds pour la validation croisée\n",
    "    save_path=\"crossvalidation_NN_rodpressure\",  # Dossier de sauvegarde des résultats et modèles\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Température prédite : 1286 K\n"
     ]
    }
   ],
   "source": [
    "params = df.iloc[32][\n",
    "    [\"lhgr\", \"fuel_radius\", \"gap_size\", \"clad_thickness\", \"coolant_temperature\", \"time\"]\n",
    "].tolist()\n",
    "print(\n",
    "    f\"Température prédite : {round(float(predict_temperature(params=params, model_path=save_path)[0]))} K\"\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}