P2: vectorise _solve_w, fix CPU/GPU portability, translate FR→EN

Performance
- rens.py: pre-compute base = x@C1.T + u@D12.T + bv outside the per-neuron
  loop; divide by lam_diag once; drop w.clone() and v tensor
- renode.py: same pattern – pre-compute base = x@C1.T + u@D12.T + bv,
  remove w.clone(), drop unused v tensor

CPU/GPU device portability
- implicit.py: torch.eye(2*nx) → device=self.X.device in both forward paths;
  torch.Tensor(torch.randn(...)) → torch.randn(...)
- hinf.py (linear): self.Ix = torch.eye(nx) → register_buffer so .to('cuda')
  moves it automatically
- lipschitz.py: all torch.eye/zeros in forward() now carry device=self.A.device
- lyap.py: torch.eye(A.size(0)) → device=A.device in both Lyapunov classes
- regularizations.py: torch.eye(mat.shape[0]) → device=mat.device
- integrators.py: remove mutable default args torch.zeros(1)/torch.Tensor(1);
  default to None and lazily create zero tensor from u_batch device/dtype;
  applies to RK4Simulator, RK45Simulator and Sim_discrete

Housekeeping
- .gitignore: exclude docs/_build/, docs/_static/, docs/_sources/, docs/*.html
- translate all remaining French comments/docstrings to English across
  utils/data.py, utils/misc.py, preprocessing/scalers.py, linalg/utils.py,
  integrators/integrators.py, train/train.py, linearization/feedbacklin.py,
  layers/dd.py, tests/models/linearization/test_flnssm.py

https://claude.ai/code/session_017mH337zq1P8SP5zCakWnn8

Author: claude

.gitignore

@@ -31,4 +31,12 @@ build/
 /data/tiny-imagenet-200/
 
 # Ignore saved pytorch models
-*.pt
+*.pt
+
+# Ignore compiled documentation
+docs/_build/
+docs/_static/
+docs/_sources/
+docs/*.html
+docs/*.js
+docs/*.inv

ctrlnmod/integrators/integrators.py

@@ -87,10 +87,11 @@ def __repr__(self):
     def __str__(self) -> str:
         return f"RK4_{str(self.ss_model)}"
 
-    def forward(self, u_batch, x0_batch=torch.zeros(1), d_batch=None):
+    def forward(self, u_batch, x0_batch=None, d_batch=None):
         X_sim_list = []
         Y_sim_list = []
-        x_step = x0_batch
+        x_step = x0_batch if x0_batch is not None else torch.zeros(
+            u_batch.shape[0], self.ss_model.nx, device=u_batch.device, dtype=u_batch.dtype)
 
         with P.cached(), self.ss_model._frame_cache.cache_frame():
             for i, u_step in enumerate(u_batch.split(1, dim=1)):
@@ -143,17 +144,18 @@ def __repr__(self):
     def __str__(self) -> str:
         return f"RK45_{str(self.ss_model)}"
 
-    def forward(self, u_batch, x0_batch=torch.zeros(1), d_batch=None):
+    def forward(self, u_batch, x0_batch=None, d_batch=None):
         X_sim_list = []
         Y_sim_list = []
-        x_step = x0_batch
+        x_step = x0_batch if x0_batch is not None else torch.zeros(
+            u_batch.shape[0], self.ss_model.nx, device=u_batch.device, dtype=u_batch.dtype)
 
         with P.cached(), self.ss_model._frame_cache.cache_frame():
             for i, u_step in enumerate(u_batch.split(1, dim=1)):
                 u_step = u_step.squeeze(1)
                 d_step = d_batch[:, i, :] if d_batch is not None else None
                 X_sim_list.append(x_step)
-                
+
                 dt = self.ts
                 k1, y_step = self.ss_model(u_step, x_step, d_step)
                 Y_sim_list.append(y_step)
@@ -164,7 +166,7 @@ def forward(self, u_batch, x0_batch=torch.zeros(1), d_batch=None):
                 k5, _ = self.ss_model(u_step, x_step + dt * (439*k1/216 - 8*k2 + 3680*k3/513 - 845*k4/4104), d_step)
                 k6, _ = self.ss_model(u_step, x_step + dt * (-8*k1/27 + 2*k2 - 3544*k3/2565 + 1859*k4/4104 - 11*k5/40), d_step)
 
-                # Solution d'ordre 5
+                # 5th-order solution
                 dx = dt * (16*k1/135 + 6656*k3/12825 + 28561*k4/56430 - 9*k5/50 + 2*k6/55)
                 x_step = x_step + dx
 
@@ -205,10 +207,11 @@ def clone(self):
         copy.load_state_dict(self.state_dict())
         return copy
 
-    def forward(self, u_batch, x0_batch=torch.Tensor(1)):
+    def forward(self, u_batch, x0_batch=None):
         X_sim_list = []
         Y_sim_list = []
-        x_step = x0_batch
+        x_step = x0_batch if x0_batch is not None else torch.zeros(
+            u_batch.shape[0], self.ss_model.nx, device=u_batch.device, dtype=u_batch.dtype)
         for u_step in u_batch.split(1, dim=1):
             u_step = u_step.squeeze(1)
             X_sim_list += [x_step]

ctrlnmod/layers/dd.py

@@ -21,7 +21,7 @@ def forward(self, M):
         dQ = torch.diag(Q)
         delta_Q = self.act(torch.sum(torch.abs(Q), dim=1) - dQ - torch.abs(dQ))
 
-        DQ = torch.diag(delta_Q)  # (Une) distance à l'ensemble DD+
+        DQ = torch.diag(delta_Q)  # A distance to the DD+ set
 
         return DQ
 

ctrlnmod/linalg/utils.py

@@ -135,7 +135,7 @@ def schur(matrix, dim_A, dim_B, dim_C):
     expected_rows = dim_A + dim_C
     expected_cols = dim_A + dim_B
     if matrix.shape[0] < expected_rows or matrix.shape[1] < expected_cols:
-        raise ValueError("Les dimensions fournies sont incompatibles avec la taille de la matrice.")
+        raise ValueError("Provided dimensions are incompatible with the matrix size.")
 
     # Blocks extraction
     A = matrix[:dim_A, :dim_A]
@@ -479,23 +479,23 @@ def solve_riccati_torch(A: torch.Tensor,
         H[:nx, nx:] = H_12
         H[nx:, :nx] = H_21
 
-        # Calcul des valeurs et vecteurs propres
-        # Note: torch.linalg.eig retourne les valeurs complexes même pour matrices réelles
+        # Compute eigenvalues and eigenvectors
+        # Note: torch.linalg.eig returns complex values even for real matrices
         eigvals, eigvecs = torch.linalg.eig(H)
-        
-        # Conversion en valeurs réelles pour le tri
+
+        # Extract real parts for sorting
         real_parts = eigvals.real
-        
-        # Tri des valeurs propres par partie réelle
+
+        # Sort eigenvalues by real part (ascending)
         sorted_indices = torch.argsort(real_parts)
         eigvals = eigvals[sorted_indices]
         eigvecs = eigvecs[:, sorted_indices]
-        
-        # Vérification du nombre de valeurs propres stables
+
+        # Check number of stable eigenvalues
         n_stable = torch.sum(real_parts[sorted_indices] < -tol).item()
-        
+
         if n_stable != nx:
-            # Ajuster le seuil si nécessaire
+            # Adjust threshold if needed
             alternative_tol = abs(real_parts[nx-1].item()) * 10
             logger.debug(f"Adjusting tolerance from {tol} to {alternative_tol}")
             stable_indices = real_parts < alternative_tol
@@ -516,39 +516,39 @@ def solve_riccati_torch(A: torch.Tensor,
         X = stable_eigvecs[:nx, :]
         Y = stable_eigvecs[nx:, :]
 
-        # Vérifier le conditionnement de X
+        # Check conditioning of X
         try:
             cond_X = torch.linalg.cond(X).item()
         except:
             cond_X = float('inf')
-        
-        if cond_X > 1e12:  # seuil arbitraire
+
+        if cond_X > 1e12:  # arbitrary threshold
             logger.warning(f"Warning: X is poorly conditioned (cond = {cond_X:.2e})")
-        
+
         try:
-            # Utiliser la pseudo-inverse si X est mal conditionné
+            # Use pseudoinverse when X is ill-conditioned
             if cond_X > 1e12:
-                # Calcul manuel de la pseudo-inverse pour plus de contrôle
+                # Manual pseudoinverse via SVD for numerical control
                 U, S, Vh = torch.linalg.svd(X)
                 S_pinv = torch.where(S > tol * S[0], 1/S, torch.zeros_like(S))
                 X_pinv = (Vh.T.conj() * S_pinv.unsqueeze(0)) @ U.T.conj()
                 P = Y @ X_pinv
             else:
                 P = Y @ torch.linalg.inv(X)
 
-            # Prendre la partie réelle et symétriser
+            # Take real part and symmetrise
             P = P.real
             P = (P + P.T)/2
-            
-            # Vérifier que P est définie positive
+
+            # Verify that P is positive definite
             try:
                 L = torch.linalg.cholesky(P)
                 is_positive = True
             except:
                 is_positive = False
                 logger.warning("Warning: P is not positive definite")
 
-            # Calculer le résidu
+            # Compute the Riccati residual
             riccati_residual = (A.T @ P + P @ A + 
                             gamma_sq_inv * P @ B @ B.T @ P +
                             C.T @ C)

ctrlnmod/lmis/lipschitz.py

@@ -100,19 +100,20 @@ def forward(self) -> Tuple[Tensor, ...]:
         # Making Lambda diagonal
         Lambda = torch.diag(self.Lambda_vec)
 
-        M11 = self.lip**2 * torch.eye(self.n_in)
+        dev = self.A.device
+        M11 = self.lip**2 * torch.eye(self.n_in, device=dev)
         M12 = - self.B.T @ Lambda
-        M13 = torch.zeros((self.n_in, self.n_out))
+        M13 = torch.zeros((self.n_in, self.n_out), device=dev)
         M22 = 2 * self.beta * Lambda - Lambda @ self.A - self.A.T @ Lambda
         M23 = - self.C.T
-        M33 = torch.eye(self.n_out)
+        M33 = torch.eye(self.n_out, device=dev)
 
         M1 = torch.cat([M11, M12, M13], dim = 1)
         M2 = torch.cat([M12.T, M22, M23], dim = 1)
         M3 = torch.cat([M13.T, M23.T, M33], dim = 1)
 
         M = torch.cat([M1, M2, M3], dim = 0)
-        return M + self.epsilon*torch.eye(M.shape[0]), Lambda
+        return M + self.epsilon*torch.eye(M.shape[0], device=dev), Lambda
 
 
     @classmethod

ctrlnmod/lmis/lyap.py

@@ -27,7 +27,7 @@ def __init__(self, A: Tensor, alpha: float) -> None:
         super().__init__()
         self.A = Parameter(A)
         self.alpha = alpha
-        self.P = Parameter(torch.eye(A.size(0)))
+        self.P = Parameter(torch.eye(A.size(0), device=A.device))
 
     def forward(self) -> Tensor:
         """
@@ -93,7 +93,7 @@ def __init__(self, A: Tensor, alpha: float) -> None:
         super().__init__()
         self.A = Parameter(A)
         self.alpha = alpha
-        self.P = Parameter(torch.eye(A.size(0)))
+        self.P = Parameter(torch.eye(A.size(0), device=A.device))
 
     def _symP(self):
         return 0.5 * (self.P + self.P.T)

ctrlnmod/models/ssmodels/continuous/general/renode.py

@@ -88,15 +88,15 @@ def forward(self, u: torch.Tensor, x: torch.Tensor) -> Tuple[torch.Tensor, torch
             y = x @ C2.T + w @ D21.T + self.by.T
         return dx, y
 
-    def _solve_w(self, x: torch.Tensor, u: torch.Tensor, C1: torch.Tensor, 
+    def _solve_w(self, x: torch.Tensor, u: torch.Tensor, C1: torch.Tensor,
                  D11: torch.Tensor, D12: torch.Tensor) -> torch.Tensor:
         nb = x.shape[0]
-        w = torch.zeros(nb, self.nq, device=self.device)
-        v = torch.zeros(nb, self.nq, device=self.device)
-
+        # Pre-compute input contributions once via batch matmuls
+        base = x @ C1.T + u @ D12.T + self.bv.squeeze(-1)  # (nb, nq)
+        w = torch.zeros(nb, self.nq, device=x.device)
         for k in range(self.nq):
-            v[:, k] = x @ C1[k, :] + w.clone() @ D11[k, :] + u @ D12[k, :] + self.bv[k]
-            w[:, k] = self.act(v[:, k])
+            v_k = base[:, k] + w @ D11[k, :]
+            w[:, k] = self.act(v_k)
         return w
 
     def check(self) -> Tuple[bool, dict]:

ctrlnmod/models/ssmodels/continuous/general/rens.py

@@ -97,22 +97,28 @@ def forward(self, x: torch.Tensor, u: torch.Tensor) -> tuple[torch.Tensor, torch
 
     def _solve_w(self, x: torch.Tensor, u: torch.Tensor) -> torch.Tensor:
         """
-        Solve for the internal non-linear state w in the acyclic case
+        Solve for the internal non-linear state w in the acyclic case.
+
+        The recurrence is strictly lower-triangular (D11 is strictly lower-triangular
+        after the constrained parametrisation), so each v_k depends only on w[:k].
+        We pre-compute the input contributions once via batch matmuls and amortise
+        the per-neuron cost to a single row-vector dot product.
 
         Args:
-            x (torch.Tensor): Current state.
-            u (torch.Tensor): Input.
+            x (torch.Tensor): Current state, shape (batch, nx).
+            u (torch.Tensor): Input, shape (batch, nu).
 
         Returns:
-            torch.Tensor: Solved internal non-linear state.
+            torch.Tensor: Solved internal non-linear state, shape (batch, nq).
         """
         nb = x.shape[0]
-        w = torch.zeros(nb, self.nq, device=self.device)
-        v = torch.zeros(nb, self.nq, device=self.device)
+        lam_diag = torch.diagonal(self.Lambda)  # (nq,)
+        # Pre-compute contributions that are constant w.r.t. w (one matmul each)
+        base = (x @ self.C1.T + u @ self.D12.T + self.bv.squeeze(-1)) / lam_diag  # (nb, nq)
+        w = torch.zeros(nb, self.nq, device=x.device)
         for k in range(self.nq):
-            v[:, k] = (1 / self.Lambda[k, k]) * (x @ self.C1[k, :] +
-                                                 w.clone() @ self.D11[k, :] + u @ self.D12[k, :] + self.bv[k])
-            w[:, k] = self.act(v[:, k].clone())
+            v_k = base[:, k] + (w @ self.D11[k, :]) / lam_diag[k]
+            w[:, k] = self.act(v_k)
         return w
 
 

ctrlnmod/models/ssmodels/continuous/linear/hinf.py

@@ -47,7 +47,7 @@ def __init__(self, nu: int, ny: int, nx: int, gamma: float, alpha: float = 0.0,
 
 
         self.gamma = gamma
-        self.Ix = torch.eye(nx)
+        self.register_buffer('Ix', torch.eye(nx))
         self.eps = epsilon
         self.param = param
         self.alpha = alpha
@@ -305,7 +305,7 @@ def __init__(self, nu: int, ny: int, nx: int, nd: int, gamma: float, alpha: floa
 
 
         self.gamma = gamma
-        self.Ix = torch.eye(nx)
+        self.register_buffer('Ix', torch.eye(nx))
         self.eps = epsilon
         self.param = param
         self.alpha = alpha

ctrlnmod/models/ssmodels/continuous/linear/implicit.py

@@ -21,7 +21,7 @@ def __init__(self, input_dim: int, output_dim: int, nx, strSavpath=os.getcwd())
         self.nx = nx
         self.ny = output_dim
 
-        self.E = Parameter(torch.Tensor(torch.randn(self.nx, self.nx)))
+        self.E = Parameter(torch.randn(self.nx, self.nx))
         self.F = nn.Linear(self.nx, self.nx, bias=False)
         self.B = nn.Linear(self.nu, self.nx, bias=False)
         self.C = nn.Linear(self.nx, self.ny, bias=False)
@@ -72,17 +72,16 @@ def __init__(self, input_dim: int, output_dim: int, nx, strSavpath=os.getcwd())
         self.nx = nx
         self.ny = output_dim
 
-        self.X = Parameter(torch.Tensor(torch.randn(2 * self.nx, 2 * self.nx)))
-        self.Y = Parameter(torch.Tensor(torch.randn(self.nx, self.nx)))
+        self.X = Parameter(torch.randn(2 * self.nx, 2 * self.nx))
+        self.Y = Parameter(torch.randn(self.nx, self.nx))
         self.epsilon = 1e-4
         self.B = nn.Linear(self.nu, self.nx, bias=False)
         self.C = nn.Linear(self.nx, self.ny, bias=False)
-        # self.config = config
         self.str_savepath = strSavpath
 
     def forward(self, u, x):
         nx = self.nx
-        H = self.X @ self.X.T + self.epsilon * torch.eye(2 * self.nx)
+        H = self.X @ self.X.T + self.epsilon * torch.eye(2 * self.nx, device=self.X.device)
         H11 = H[:nx, :nx]
         P = H[nx:, nx:]
         F = H[nx:, :nx]
@@ -135,17 +134,16 @@ def __init__(self, input_dim: int, output_dim: int, nx, alpha: float = 1.0, strS
         self.ny = output_dim
         self.alpha = alpha
 
-        self.X = Parameter(torch.Tensor(torch.randn(2 * self.nx, 2 * self.nx)))
-        self.Y = Parameter(torch.Tensor(torch.randn(self.nx, self.nx)))
+        self.X = Parameter(torch.randn(2 * self.nx, 2 * self.nx))
+        self.Y = Parameter(torch.randn(self.nx, self.nx))
         self.epsilon = 1e-4
         self.B = nn.Linear(self.nu, self.nx, bias=False)
         self.C = nn.Linear(self.nx, self.ny, bias=False)
-        # self.config = config
         self.str_savepath = strSavpath
 
     def forward(self, u, x):
         nx = self.nx
-        H = self.X @ self.X.T + self.epsilon * torch.eye(2 * self.nx)
+        H = self.X @ self.X.T + self.epsilon * torch.eye(2 * self.nx, device=self.X.device)
         H11 = H[:nx, :nx]
         P = H[nx:, nx:]
         F = H[nx:, :nx]