Merge branch 'evoxtorch-dev-xbq' of https://github.com/EMI-Group/evox into evoxtorch-dev-xbq

Author: XU-Boqing

src/evox/algorithms/so/de_variants/shade.py

@@ -69,7 +69,10 @@ def step(self):
         device = self.pop.device
         indices = torch.arange(self.pop_size, device=device)
 
-        FCR_ids = torch.randperm(self.pop_size)
+        # FCR_ids = torch.randperm(self.pop_size)
+        # The above code does not support the torch.compile (at least up to Pytorch 2.9.0), see https://github.com/pytorch/pytorch/issues/158457.
+        # Thus, use the following codes:
+        FCR_ids = torch.argsort(torch.rand(self.pop_size, device=device))
         M_F_vect = self.Memory_FCR[0, FCR_ids]
         M_CR_vect = self.Memory_FCR[1, FCR_ids]
 

src/evox/algorithms/so/es_variants/cma_es.py

@@ -125,8 +125,8 @@ def _update_covariance_matrix(
         y = (population - old_mean) / self.sigma
         update = (
             (1 - self.c_1 - self.c_mu) * C
-            + self.c_1 * (p_c @ p_c.T + (1 - h_sigma) * self.c_c * (2 - self.c_c) * C)
-            + self.c_mu * (y.T * self.weights) @ y
+            + self.c_1 * (p_c.dot(p_c) + (1 - h_sigma) * self.c_c * (2 - self.c_c) * C)
+            + self.c_mu * (y.mT * self.weights) @ y
         )
         return update
 
@@ -161,20 +161,22 @@ def _conditional_decomposition(self, iteration: torch.Tensor, C: torch.Tensor):
         return B, D, C_invsqrt
 
     def _no_decomposition(self, C: torch.Tensor):
-        return torch.stack([self.B, self.D, self.C_invsqrt], dim=0)
+        return self.B.clone(), self.D.clone(), self.C_invsqrt.clone()
 
     def _decomposition(
         self,
         C: torch.Tensor,
     ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        C = (C + C.T) / 2
-        D, B = torch.linalg.eigh(C)
+        # symC = (C + C.T) / 2 # This will fail to compile since PyTorch tries to in-place modify C
+        symC = C.clone()
+        symC = (symC + symC.mT) / 2
+        D, B = torch.linalg.eigh(symC)
         D = torch.clamp(D, min=1e-8)
-        C_invsqrt = B @ torch.diag(1.0 / torch.sqrt(D)) @ B.T
+        C_invsqrt = B @ torch.diag(1.0 / torch.sqrt(D)) @ B.mT
         D = torch.diag(D)
         D = torch.sqrt(D)
         D = B @ D
-        return torch.stack([B.T, D, C_invsqrt], dim=0)
+        return B.mT, D, C_invsqrt
 
     def record_step(self):
         return {

src/evox/metrics/hv.py

@@ -14,7 +14,7 @@ def hv(objs: torch.Tensor, ref: torch.Tensor, num_sample: int = 100000):
     points = torch.abs(objs - ref)
     bound = torch.max(points, dim=0).values
     max_vol = torch.prod(bound)
-    samples = torch.rand(num_sample, points.size(1)) * bound
+    samples = torch.rand(num_sample, points.size(1), device=objs.device) * bound
     in_hypercube = torch.any(torch.all(samples.unsqueeze(1) < points.unsqueeze(0), dim=2), dim=1)
     hv = in_hypercube.sum() / num_sample * max_vol
     return hv