Mathias's issues give to Nachid test 1

Author: ExoRoy

scripts/lanch_one_simu.py

@@ -0,0 +1,86 @@
+import os
+import sys
+
+from typing import *
+import numpy as np
+import onnxruntime as ort
+
+simu_path = __file__.rsplit('/', 2)[0] + '/src/Simulateur'
+if simu_path not in sys.path:
+    sys.path.insert(0, simu_path)
+
+from onnx_utils import run_onnx_model
+from config import *
+from WebotsSimulationGymEnvironment import WebotsSimulationGymEnvironment
+from TemporalResNetExtractor import TemporalResNetExtractor
+from CNN1DResNetExtractor import CNN1DResNetExtractor
+# -------------------------------------------------------------------------
+
+def log(s: str):
+    # Conservez votre fonction de log
+    if B_DEBUG:
+        print(s, file=open("/tmp/autotech/logs", "a"))
+
+# --- Chemin vers le fichier ONNX ---
+
+ONNX_MODEL_PATH = "model.onnx"
+
+# --- Initialisation du moteur d'inférence ONNX Runtime (ORT) ---
+def init_onnx_runtime_session(onnx_path: str) -> ort.InferenceSession:
+    if not os.path.exists(onnx_path):
+        raise FileNotFoundError(f"Le fichier ONNX est introuvable à : {onnx_path}. Veuillez l'exporter d'abord.")
+
+    # Crée la session d'inférence
+    return ort.InferenceSession(onnx_path) #On peut modifier le providers afin de mettre une CUDA
+
+
+if __name__ == "__main__":
+    if not os.path.exists("/tmp/autotech/"):
+        os.mkdir("/tmp/autotech/")
+
+    os.system('if [ -n "$(ls /tmp/autotech)" ]; then rm /tmp/autotech/*; fi')
+    if B_DEBUG:
+        print("Webots started", file=open("/tmp/autotech/logs", "w"))
+
+
+    # 2. Initialisation de la session ONNX Runtime
+    try:
+        ort_session = init_onnx_runtime_session(ONNX_MODEL_PATH)
+        input_name = ort_session.get_inputs()[0].name
+        output_name = ort_session.get_outputs()[0].name
+        print(f"Modèle ONNX chargé depuis {ONNX_MODEL_PATH}")
+        print(f"Input Name: {input_name}, Output Name: {output_name}")
+    except FileNotFoundError as e:
+        print(f"ERREUR : {e}")
+        print(
+            "Veuillez vous assurer que vous avez exécuté une fois le script d'entraînement pour exporter 'model.onnx'.")
+        sys.exit(1)
+
+    # 3. Boucle d'inférence (Test)
+    env = WebotsSimulationGymEnvironment(0,0)
+    obs = env.reset()
+    print("Début de la simulation en mode inférence...")
+
+    max_steps = 5000
+    step_count = 0
+
+    while True:
+
+        action = run_onnx_model(ort_session,obs)
+
+        # 4. Exécuter l'action dans l'environnement
+        obs, reward, done, info = env.step(action)
+
+        # Note: L'environnement Webots gère généralement son propre affichage
+        # env.render() # Décommenter si votre env supporte le rendu externe
+
+        # Gestion des fins d'épisodes
+        if done:
+            print(f"Épisode(s) terminé(s) après {step_count} étapes.")
+            obs = env.reset()
+
+
+
+    # Fermeture propre (très important pour les processus parallèles SubprocVecEnv)
+    envs.close()
+    print("Simulation terminée. Environnements fermés.")

src/Simulateur/onnx_utils.py

@@ -3,7 +3,7 @@
 import torch.nn as nn
 import torch
 from config import *
-
+import numpy as np
 from CNN1DExtractor import CNN1DExtractor
 from TemporalResNetExtractor import TemporalResNetExtractor
 
@@ -38,32 +38,32 @@ def export_onnx(model):
     model.policy.to(device)
     model.policy.train()
 
+def run_onnx_model(session : ort.InferenceSession,x : np.ndarray):
+
+    return session.run(None, {"input": x})[0]
 
 def test_onnx(model):
     device = model.policy.device
     model.policy.eval()
     true_model = get_true_model(model)
 
+    loss_fn = nn.MSELoss()
+    x = torch.randn(1000, 2, context_size, lidar_horizontal_resolution)
+
     try:
         session = ort.InferenceSession("model.onnx")
     except Exception as e:
         print(f"Error loading ONNX model: {e}")
         return
 
-    def model_onnx(x):
-        return session.run(None, {"input": x.cpu().numpy()})[0]
-
-    loss_fn = nn.MSELoss()
-    x = torch.randn(1000, 2, context_size, lidar_horizontal_resolution)
-
     with torch.no_grad():
         y_true_test = true_model(x)
 
         true_model.train()
         y_true_train = true_model(x)
         true_model.eval()
 
-        y_onnx = model_onnx(x)
+        y_onnx = run_onnx_model(session,x.cpu().numpy())
 
         loss_test = loss_fn(y_true_test, torch.tensor(y_onnx))
         loss_train = loss_fn(y_true_train, torch.tensor(y_onnx))