fix(p1): print → logging (final batch)

Complete the print → logging migration for the remaining files.
Each file gets import logging + logger = logging.getLogger(__name__).

- regularizations/regularizations.py: all verbose-gated prints →
  logger.debug; "Minimum weight reached" → logger.warning
- train/train.py: StopTrainingCallback → logger.info; LRSchedulerLogger
  → logger.info; validation error → logger.warning;
  "Updating criterion weights" → logger.debug
- utils/misc.py: "Maximum iterations reached" → logger.warning
- lmis/lyap.py: __main__ debug prints → logger.debug

P1 is now fully complete:
  ✓ torch.inverse → torch.linalg.inv (all files)
  ✓ assert → raise ValueError (all user-facing validations)
  ✓ print → logging (all files)

https://claude.ai/code/session_017mH337zq1P8SP5zCakWnn8

Author: claude

ctrlnmod/lmis/lyap.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Tuple
 import numpy as np
 import torch
@@ -7,6 +8,8 @@
 # from ..linalg.utils import isSDP
 from .base import LMI
 
+logger = logging.getLogger(__name__)
+
 
 class LyapunovDiscrete(LMI):
     """
@@ -158,10 +161,10 @@ def solve(cls, A: Tensor, alpha: float, tol: float = 1e-9, solver: str = 'MOSEK'
 
     # Discrete-time LMI
     P_discrete, LMI_discrete = LyapunovDiscrete.solve(A, alpha)
-    print(f"Discrete-time P: {P_discrete}")
-    print(f"Discrete-time LMI: {LMI_discrete}")
+    logger.debug(f"Discrete-time P: {P_discrete}")
+    logger.debug(f"Discrete-time LMI: {LMI_discrete}")
 
     # Continuous-time LMI
     P_continuous, LMI_continuous = LyapunovContinuous.solve(A, alpha)
-    print(f"Continuous-time P: {P_continuous}")
-    print(f"Continuous-time LMI: {LMI_continuous}")
+    logger.debug(f"Continuous-time P: {P_continuous}")
+    logger.debug(f"Continuous-time LMI: {LMI_continuous}")

ctrlnmod/regularizations/regularizations.py

@@ -1,3 +1,4 @@
+import logging
 from abc import ABC, abstractmethod
 import torch
 from torch.linalg import slogdet
@@ -6,6 +7,8 @@
 from typing import List, Callable
 from ..lmis.base import LMI
 
+logger = logging.getLogger(__name__)
+
 
 class Regularization(ABC, nn.Module):
     def __init__(self, model: nn.Module, factor: float, updatable: bool = True, verbose: bool = False):
@@ -40,7 +43,7 @@ def update(self) -> None:
                 for param in self.model.parameters():
                     param -= self.factor * param.sign()
             if self.verbose:
-                print(f"Updated L1 regularization lambda: {self.lambda_l1.item()}")
+                logger.debug(f"Updated L1 regularization lambda: {self.lambda_l1.item()}")
 
 
 class L2Regularization(Regularization):
@@ -58,7 +61,7 @@ def update(self) -> None:
                 for param in self.model.parameters():
                     param -= self.factor * param
             if self.verbose:
-                print(f"Updated L2 regularization lambda: {self.lambda_l2.item()}")
+                logger.debug(f"Updated L2 regularization lambda: {self.lambda_l2.item()}")
 
 
 class LogdetRegularization(Regularization):
@@ -81,9 +84,9 @@ def update(self) -> None:
             old_lambda = self.lambda_logdet.item()
             self.lambda_logdet *= self.factor
             if self.verbose:
-                print(f"Updated Logdet regularization lambda: {old_lambda} -> {self.lambda_logdet.item()} \n")
+                logger.debug(f"Updated Logdet regularization lambda: {old_lambda} -> {self.lambda_logdet.item()} \n")
             if self.lambda_logdet <= self.min_weight:
-                print("Minimum weight reached")
+                logger.warning("Minimum weight reached")
 
 class DDRegularization(Regularization):
     def __init__(self, lmi: LMI, lambda_dd: float, update_factor: float, actf='lse', updatable = True, verbose = False, e= 0.1):
@@ -153,7 +156,7 @@ def update(self):
         if self.updatable:
             self.lambda_dd = self.factor * self.lambda_dd
             if self.verbose:
-                print(f"Updated DD regularization lambda: {self.lambda_dd}")
+                logger.debug(f"Updated DD regularization lambda: {self.lambda_dd}")
 
 class StateRegularization(Regularization):
     def __init__(self, model: nn.Module, lambda_state: float, update_factor: float, updatable: bool = True, verbose: bool = False) -> None:
@@ -173,7 +176,7 @@ def update(self) -> None:
             old_lambda = self.lambda_state.item()
             self.lambda_state *= self.factor
             if self.verbose:
-                print(f"Updated State regularization lambda: {old_lambda} -> {self.lambda_state.item()}")
+                logger.debug(f"Updated State regularization lambda: {old_lambda} -> {self.lambda_state.item()}")
 
 
 def add_regularization(criterion: Callable[[Tensor, Tensor], Tensor], regularizers: List[Regularization]) -> Callable[[Tensor, Tensor], Tensor]:

ctrlnmod/train/train.py

@@ -1,3 +1,4 @@
+import logging
 import torch
 from torch.optim.lr_scheduler import ReduceLROnPlateau
 from typing import Optional
@@ -8,10 +9,12 @@
 import os
 from typing import Callable, Optional
 
+logger = logging.getLogger(__name__)
+
 '''
 def backtrack(self, *args, step_ratio=0.5, max_iter=100):
     with torch.no_grad():
-        print(" Statrting backtracking")
+        logger.debug(" Statrting backtracking")
         theta0 = flatten_params(self.sim_model)
         i = 0
         while i <= max_iter:
@@ -23,21 +26,21 @@ def backtrack(self, *args, step_ratio=0.5, max_iter=100):
             else:
                 break
         if i > max_iter:
-            print("Maximum iterations reached")
+            logger.warning("Maximum iterations reached")
         return crit
 '''
 
 class StopTrainingCallback(Callback):
     def on_validation_epoch_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule) -> None:
         if pl_module.stop_training_flag:
-            print("\n Stopping training because the boolean condition is set to True.")
+            logger.info("\n Stopping training because the boolean condition is set to True.")
             trainer.should_stop = True
 
 class LRSchedulerLogger(pl.Callback):
     def on_validation_epoch_end(self, trainer, pl_module):
         # Assuming the LR is scheduled per epoch
         lrs = [group['lr'] for group in trainer.optimizers[0].param_groups]
-        print(f"\n Epoch {trainer.current_epoch}: Learning rate(s): {lrs}")
+        logger.info(f"\n Epoch {trainer.current_epoch}: Learning rate(s): {lrs}")
 
 class LitNode(pl.LightningModule):
     def __init__(
@@ -122,7 +125,7 @@ def validation_step(self, batch, batch_idx):
                 for log_name, log_value in custom_logs.items():
                     self.log(log_name, log_value)
             except Exception as e:
-                print(f"Error in custom logging function: {e}")
+                logger.warning(f"Error in custom logging function: {e}")
 
             if 'is_solve_ok' in custom_logs and  (not custom_logs['is_solve_ok']):
                 self.stop_training_flag = True  # Stop training if lmi is false
@@ -159,7 +162,7 @@ def on_validation_epoch_end(self):
 
             if self.no_decrease_counter >= self.patience_soft:
                 if self.criterion.regularizers and hasattr(self.criterion, 'update') and callable(self.criterion.update):
-                    print("Updating criterion weights")
+                    logger.debug("Updating criterion weights")
                     self.criterion.update()
                     self.no_decrease_counter = 0
 

ctrlnmod/utils/misc.py

@@ -1,9 +1,12 @@
+import logging
 import torch
 from functools import wraps
 from contextlib import contextmanager
 from typing import Optional, Tuple, Union
 from torch import Tensor
 
+logger = logging.getLogger(__name__)
+
 def parse_act_f(act_f: Union[str, torch.nn.Module]) -> torch.nn.Module:
     """
     Parse the activation function from a string or a torch module.
@@ -147,7 +150,7 @@ def backtrack(module, criterion, step_ratio=0.5, max_iter=100):
             write_flat_params(module, theta)
             i += 1
             if i > max_iter:
-                print("Maximum iterations reached")
+                logger.warning("Maximum iterations reached")
                 criterion.updatable = False
                 break