moospread 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

moospread/core.py

@@ -9,6 +9,11 @@ from torch.utils.data import DataLoader, TensorDataset
 import copy
 import math
 import json
+
+import cv2
+import re
+import glob
+
 import os
 import pickle
 from tqdm import tqdm
@@ -25,7 +30,7 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
 
 from moospread.utils import *
-
+print
 class SPREAD:
     def __init__(self, 
                  problem,
@@ -54,7 +59,6 @@ class SPREAD:
                  seed: int = 0,
                  offline_global_clamping: bool = False,
                  offline_normalization_method: str = "z_score",
-                 dominance_classifier = None,
                  train_func_surrogate = None,
                  plot_func = None,
                  verbose: bool = True):
@@ -83,14 +87,12 @@ class SPREAD:
         if self.mode == "bayesian":
             self.mobo_coef_lcb = mobo_coef_lcb
         
-
         self.xi_shift = xi_shift
-        self.model_dir = model_dir
+        self.model_dir = model_dir+f"/{self.problem.__class__.__name__}_{self.mode}"
         os.makedirs(self.model_dir, exist_ok=True)
         
         self.train_func_surrogate = train_func_surrogate
         self.plot_func = plot_func
-        self.dominance_classifier = dominance_classifier
 
         self.seed = seed
         # Set the seed for reproducibility
@@ -132,7 +134,7 @@ class SPREAD:
                     print("Training dataset generated.")
                 
         if self.mode == "offline":
-            assert offline_normalization_method in ["z_score", "min_max", "none"], "Invalid normalization method"
+            assert offline_normalization_method in ["z_score", "min_max", None], "Invalid normalization method"
             if offline_normalization_method == "z_score":
                 self.offline_normalization = offdata_z_score_normalize
                 self.offline_denormalization = offdata_z_score_denormalize
@@ -142,9 +144,23 @@ class SPREAD:
             else:
                 self.offline_normalization = lambda x: x
                 self.offline_denormalization = lambda x: x
+                
+            if self.mode == "offline":
+                X, y = self.dataset
+                X = X.clone().detach()
+                y = y.clone().detach()
+                if self.problem.is_discrete:
+                    X = offdata_to_logits(X)
+                    _, n_dim, n_classes = tuple(X.shape)
+                    X = X.reshape(-1, n_dim * n_classes)
+                if self.problem.is_sequence:
+                    X = offdata_to_logits(X)
+                # For usual cases, we normalize the inputs 
+                # and outputs with z-score normalization
+                X, self.X_meanormin, self.X_stdormax = self.offline_normalization(X)
+                y, self.y_meanormin, self.y_stdormax = self.offline_normalization(y)
+                self.dataset = (X, y)
 
-            self.X_meanormin, self.y_meanormin  = 0, 0
-            self.X_stdormax, self.y_stdormax = 1, 1
             if self.problem.has_bounds():
                 xl = self.problem.xl
                 xu = self.problem.xu
@@ -156,7 +172,9 @@ class SPREAD:
                     xl = xl.reshape(-1, n_dim * n_classes)
                 if self.problem.is_sequence:
                     xl = offdata_to_logits(xl)
-                xl, _, _ = self.offline_normalization(xl)
+                xl, _, _ = self.offline_normalization(xl,
+                                                      self.X_meanormin,
+                                                      self.X_stdormax)
                 # xu
                 if self.problem.is_discrete:
                     xu = offdata_to_logits(xu)
@@ -164,7 +182,9 @@ class SPREAD:
                     xu = xu.reshape(-1, n_dim * n_classes)
                 if self.problem.is_sequence:
                     xu = offdata_to_logits(xu)
-                xu, _, _ = self.offline_normalization(xu)
+                xu, _, _ = self.offline_normalization(xu,
+                                                      self.X_meanormin,
+                                                      self.X_stdormax)
                 ## Set the normalized bounds
                 self.problem.xl = xl
                 self.problem.xu = xu
@@ -225,7 +245,9 @@ class SPREAD:
                  num_inner_steps=10, lr_inner=0.9,
                  free_initial_h=True,
                  use_sigma_rep=False, kernel_sigma_rep=0.01,
-                 iterative_plot=True, plot_period=100,
+                 iterative_plot=True, plot_period=100, 
+                 plot_dataset=False, plot_population=False,
+                 elev=30, azim=45, legend=False,
                  max_backtracks=100, label=None, save_results=True,
                  load_models=False,
                  samples_store_path="./samples_dir/",
@@ -238,19 +260,6 @@ class SPREAD:
             X, y = self.dataset
             
             if self.mode == "offline":
-                X = X.clone().detach()
-                y = y.clone().detach()
-                if self.problem.is_discrete:
-                    X = offdata_to_logits(X)
-                    _, n_dim, n_classes = tuple(X.shape)
-                    X = X.reshape(-1, n_dim * n_classes)
-                if self.problem.is_sequence:
-                    X = offdata_to_logits(X)
-                # For usual cases, we normalize the inputs 
-                # and outputs with z-score normalization
-                X, self.X_meanormin, self.X_stdormax = self.offline_normalization(X)
-                y, self.y_meanormin, self.y_stdormax = self.offline_normalization(y)
-
                 #### SURROGATE MODEL TRAINING ####
                 if not load_models or self.surrogate_given:
                     self.train_surrogate(X, y)
@@ -288,7 +297,9 @@ class SPREAD:
                  num_inner_steps=num_inner_steps, lr_inner=lr_inner,
                  free_initial_h=free_initial_h,
                  use_sigma_rep=use_sigma_rep, kernel_sigma_rep=kernel_sigma_rep,
-                 iterative_plot=iterative_plot, plot_period=plot_period,
+                 iterative_plot=iterative_plot, plot_period=plot_period, 
+                 plot_dataset=plot_dataset, plot_population=plot_population,
+                 elev=elev, azim=azim, legend=legend,
                  max_backtracks=max_backtracks, label=label,
                  save_results=save_results,
                  samples_store_path=samples_store_path,
@@ -382,6 +393,8 @@ class SPREAD:
                                             free_initial_h=free_initial_h,
                                             use_sigma_rep=use_sigma_rep, kernel_sigma_rep=kernel_sigma_rep,
                                             iterative_plot=iterative_plot, plot_period=plot_period,
+                                            plot_dataset=plot_dataset, plot_population=plot_population,
+                                            elev=elev, azim=azim, legend=legend,
                                             max_backtracks=max_backtracks, label=label,
                                             samples_store_path=samples_store_path,
                                             images_store_path=images_store_path,
@@ -716,7 +729,9 @@ class SPREAD:
                  num_inner_steps=10, lr_inner=1e-4,
                  free_initial_h=True,
                  use_sigma_rep=False, kernel_sigma_rep=0.01,
-                 iterative_plot=True, plot_period=100,
+                 iterative_plot=True, plot_period=100, 
+                 plot_dataset=False, plot_population=False,
+                 elev=30, azim=45, legend=False,
                  max_backtracks=25, label=None,
                  samples_store_path="./samples_dir/",
                  images_store_path="./images_dir/",
@@ -764,13 +779,14 @@ class SPREAD:
         x_t = torch.rand((num_points_sample, self.problem.n_var)) # in [0, 1]
         x_t = self.problem.bounds()[0] + (self.problem.bounds()[1] - self.problem.bounds()[0]) * x_t # scale to bounds
         if self.mode == "offline":
-            x_t, _, _ = self.offline_normalization(x_t)
+            x_t, _, _ = self.offline_normalization(x_t,
+                                                    self.X_meanormin,
+                                                    self.X_stdormax)
         x_t = x_t.to(self.device)
         x_t.requires_grad = True
         if self.problem.need_repair:
             x_t.data = self.repair_bounds(x_t.data.clone())
-            
-        if self.mode == "online":
+        if self.mode in ["online", "offline"]:
             if iterative_plot and (not is_pass_function(self.problem._evaluate)):        
                 if self.problem.n_obj <= 3:   
                     pf_population = x_t.detach()
@@ -778,9 +794,45 @@ class SPREAD:
                         pf_population,
                         keep_shape=False
                     )
-                    list_fi = self.objective_functions(pf_points).split(1, dim=1)
-                    list_fi = [fi.detach().cpu().numpy() for fi in list_fi]
+                    if self.mode == "offline":
+                        # Denormalize the points before plotting
+                        res_x_t = pf_points.clone().detach()
+                        res_x_t = self.offline_denormalization(res_x_t,
+                                                                    self.X_meanormin, 
+                                                                    self.X_stdormax)
+                        res_pop = pf_population.clone().detach()
+                        res_pop = self.offline_denormalization(res_pop,
+                                                                    self.X_meanormin, 
+                                                                    self.X_stdormax)
+                        norm_xl, norm_xu = self.problem.bounds()
+                        xl, xu = self.problem.original_bounds
+                        self.problem.xl = xl
+                        self.problem.xu = xu
+                        if self.problem.is_discrete:
+                            _, dim, n_classes = tuple(res_x_t.shape)
+                            res_x_t = res_x_t.reshape(-1, dim, n_classes)
+                            res_x_t = offdata_to_integers(res_x_t)
+                                    
+                            _, dim_pop, n_classes_pop = tuple(res_pop.shape)
+                            res_pop = res_pop.reshape(-1, dim_pop, n_classes_pop)
+                            res_pop = offdata_to_integers(res_pop)
+                        if self.problem.is_sequence:
+                            res_x_t = offdata_to_integers(res_x_t)
+                            res_pop = offdata_to_integers(res_pop)
+                        # we need to evaluate the true objective functions for plotting
+                        list_fi =  self.objective_functions(res_x_t, 
+                                                                    evaluate_true=True).split(1, dim=1)
+                        list_fi_pop =  self.objective_functions(res_pop, 
+                                                                        evaluate_true=True).split(1, dim=1) 
+                        # restore the normalized bounds
+                        self.problem.xl = norm_xl
+                        self.problem.xu = norm_xu
+                    else:
+                        list_fi = self.objective_functions(pf_points).split(1, dim=1)
+                        list_fi_pop =  self.objective_functions(pf_population.detach()).split(1, dim=1)
                     pareto_front = None
+                    list_fi = [fi.detach().cpu().numpy() for fi in list_fi]
+                    list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                     if self.problem.pareto_front() is not None:
                         pareto_front = self.problem.pareto_front()
                         pareto_front = [pareto_front[:, i] for i in range(self.problem.n_obj)]
@@ -788,17 +840,18 @@ class SPREAD:
                         self.plot_func(list_fi, self.timesteps,
                                        num_points_sample,
                                        extra=pareto_front,
+                                       plot_dataset=plot_dataset,
+                                       dataset = self.dataset,
+                                       elev=elev, azim=azim, legend=legend,
                                        label=label, images_store_path=images_store_path)
                     else:
-                        plot_dataset = True if self.mode == "offline" else False
-                        list_fi_pop =  self.objective_functions(pf_population.detach()).split(1, dim=1)
-                        list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                         self.plot_pareto_front(list_fi,  self.timesteps,
                                                 num_points_sample,
                                                 extra=pareto_front,
                                                 plot_dataset=plot_dataset,
-                                                    pop=list_fi_pop,
-                                                    label=label, images_store_path=images_store_path)
+                                                pop=list_fi_pop,
+                                                elev=elev, azim=azim, legend=legend,
+                                                label=label, images_store_path=images_store_path)
 
         prev_pf_points = None
         num_optimal_points = 0
@@ -812,7 +865,9 @@ class SPREAD:
             point_n0 = torch.rand((1, self.problem.n_var)) # in [0, 1]
             point_n0 = self.problem.bounds()[0] + (self.problem.bounds()[1] - self.problem.bounds()[0]) * point_n0 # scale to bounds
             if self.mode == "offline":
-                point_n0, _, _ = self.offline_normalization(point_n0)
+                point_n0, _, _ = self.offline_normalization(point_n0,
+                                                      self.X_meanormin,
+                                                      self.X_stdormax)
             point_n0 = point_n0.to(self.device)
             point_n0.requires_grad = True
             if self.problem.need_repair:
@@ -868,7 +923,6 @@ class SPREAD:
                 else:
                     pf_population = copy.deepcopy(x_t.detach())
 
-                # print("Number of points before selection:", len(pf_population))
                 pf_points, _, _ = self.get_non_dominated_points(
                     pf_population,
                     keep_shape=False
@@ -881,7 +935,6 @@ class SPREAD:
                                         pf_points,
                                         keep_shape=False,
                                     )
-                    # print("Number of non-dominated points before selection:", len(non_dom_points))
                     if len(pf_points) > num_points_sample:
                         pf_points = self.select_top_n_candidates(
                                             pf_points,
@@ -902,6 +955,10 @@ class SPREAD:
                                 res_x_t = self.offline_denormalization(res_x_t,
                                                                             self.X_meanormin, 
                                                                             self.X_stdormax)
+                                res_pop = pf_population.clone().detach()
+                                res_pop = self.offline_denormalization(res_pop,
+                                                                            self.X_meanormin, 
+                                                                            self.X_stdormax)
                                 norm_xl, norm_xu = self.problem.bounds()
                                 xl, xu = self.problem.original_bounds
                                 self.problem.xl = xl
@@ -910,40 +967,55 @@ class SPREAD:
                                     _, dim, n_classes = tuple(res_x_t.shape)
                                     res_x_t = res_x_t.reshape(-1, dim, n_classes)
                                     res_x_t = offdata_to_integers(res_x_t)
+                                    
+                                    _, dim_pop, n_classes_pop = tuple(res_pop.shape)
+                                    res_pop = res_pop.reshape(-1, dim_pop, n_classes_pop)
+                                    res_pop = offdata_to_integers(res_pop)
                                 if self.problem.is_sequence:
                                     res_x_t = offdata_to_integers(res_x_t)
+                                    res_pop = offdata_to_integers(res_pop)
                                 # we need to evaluate the true objective functions for plotting
-                                list_fi =  self.objective_functions(pf_points, evaluate_true=True).split(1, dim=1)
+                                list_fi =  self.objective_functions(res_x_t, 
+                                                                    evaluate_true=True).split(1, dim=1)
+                                list_fi_pop =  self.objective_functions(res_pop, 
+                                                                        evaluate_true=True).split(1, dim=1)
+                                list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                                 # restore the normalized bounds
                                 self.problem.xl = norm_xl
                                 self.problem.xu = norm_xu
                             elif self.mode == "bayesian":
                                 # we need to evaluate the true objective functions for plotting
                                 list_fi = self.objective_functions(pf_points, evaluate_true=True).split(1, dim=1)
+                                list_fi_pop =  self.objective_functions(pf_population.detach(), evaluate_true=True).split(1, dim=1)
+                                list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                             else:
                                 list_fi = self.objective_functions(pf_points).split(1, dim=1)
+                                list_fi_pop =  self.objective_functions(pf_population.detach()).split(1, dim=1)
+                                list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                             
                             list_fi = [fi.detach().cpu().numpy() for fi in list_fi]
                             pareto_front = None
                             if self.problem.pareto_front() is not None:
                                 pareto_front = self.problem.pareto_front()
                                 pareto_front = [pareto_front[:, i] for i in range(self.problem.n_obj)]
+
                             if self.plot_func is not None:
                                 self.plot_func(list_fi, t, 
                                                    num_points_sample,
                                                    extra= pareto_front,
+                                                   plot_dataset=plot_dataset,
+                                                   dataset = self.dataset,
+                                                   elev=elev, azim=azim, legend=legend,
                                                    label=label, images_store_path=images_store_path)
                             else:
-                                plot_dataset = True if self.mode == "offline" else False
-                                list_fi_pop =  self.objective_functions(pf_population.detach()).split(1, dim=1)
-                                list_fi_pop = [fi.detach().cpu().numpy() for fi in list_fi_pop]
                                 self.plot_pareto_front(list_fi, t, 
                                                     num_points_sample,
                                                     extra= pareto_front,
-                                                    pop=list_fi_pop,
+                                                    pop=list_fi_pop if plot_population else None,
                                                     plot_dataset=plot_dataset,
+                                                    elev=elev, azim=azim, legend=legend,
                                                     label=label, images_store_path=images_store_path)
-                                
+                        
 
                 x_t = x_t.detach()
                 pbar.set_postfix({
@@ -1402,19 +1474,14 @@ class SPREAD:
                              n_prob=grads[0].shape[0], n_obj=self.problem.n_obj, 
                             verbose=False)
             y = self.objective_functions(x, get_constraint=True)
-            # print("y.keys():", y.keys())
             if "H" in y:
                 pre_h_vals = y["H"].sum(dim=1)
                 constraint_mtd='eq'
-                # print("pre_h_vals.shape:", pre_h_vals.shape)
             elif "G" in y:
-                # print("pre_h_vals.shape before:", y["G"].shape)
                 pre_h_vals = y["G"].sum(dim=1)
                 print("pre_h_vals.shape:", pre_h_vals.shape)
                 constraint_mtd='ineq'
-                # print("pre_h_vals.shape:", pre_h_vals.shape)
             y = y["F"]
-            # print("pre_h_vals.shape:", pre_h_vals.shape)
             alphas = SOLVER.compute_weights(x, y, pre_h_vals=pre_h_vals, 
                                             constraint_mtd=constraint_mtd)
             alphas = torch.nan_to_num(alphas, nan=torch.nanmean(alphas),
@@ -1624,7 +1691,6 @@ class SPREAD:
                 i for i in range(N)
                 if not any(label_matrix[j, i] == 2 for j in range(N))
             ]
-            # print(f"Number of non-dominated points: {len(PS_idx)} out of {N}")
         else:
             raise ValueError(f"Mode {self.mode} not recognized!")
             
@@ -1699,7 +1765,6 @@ class SPREAD:
                 final_idx = top_indices[torch.randperm(top_indices.size(0))]
         else:
             N = points.shape[0]
-            # print(f"In selection, N={N}, n={n}")
             # 1) Predict dominance
             label_matrix, conf_matrix = nn_predict_dom_intra(points.detach().cpu().numpy(), 
                                                             self.dominance_classifier, 
@@ -1709,7 +1774,6 @@ class SPREAD:
                 i for i in range(N)
                 if not any(label_matrix[j, i] == 2 for j in range(N))
             ]
-            # print(f"(selection) Number of non-dominated points: {len(nondom_inds)} out of {N}")
 
             # --- CASE A: too many non‑dominated → pick top-n by crowding ---
             if len(nondom_inds) > n:
@@ -1784,6 +1848,7 @@ class SPREAD:
                           label=None,
                           plot_dataset=False,
                           pop=None,
+                          elev=30, azim=45, legend=False,
                           images_store_path="./images_dir/"):
         name = (
             "spread"
@@ -1807,63 +1872,88 @@ class SPREAD:
             return None
 
         elif len(list_fi) == 2:
+            fig, ax = plt.subplots()
+            if plot_dataset and (self.dataset) is not None:
+                _, Y = self.dataset
+                # Denormalize the data
+                Y = self.offline_denormalization(Y,
+                                                self.y_meanormin,
+                                                self.y_stdormax)
+                ax.scatter(Y[:, 0], Y[:, 1],
+                            c="violet", s=5, alpha=1.0,
+                            label="Training Data")
+                            
             if extra is not None:
                 f1, f2 = extra
-                plt.scatter(f1, f2, c="yellow", s = 5, alpha=1.0,)
-                            # label="Pareto optimal points")
+                ax.scatter(f1, f2, c="yellow", s = 5, alpha=1.0,
+                            label="Pareto Optimal")
                             
             if pop is not None:
                 f_pop1, f_pop2 = pop
-                plt.scatter(f_pop1, f_pop2, c="blue", s=10, alpha=1.0,)
-                            # label="Population points")
+                ax.scatter(f_pop1, f_pop2, c="blue", s=10, alpha=1.0,
+                            label="Gen Population")
                 
             f1, f2 = list_fi
-            plt.scatter(f1, f2, c="red", s=10, alpha=1.0,)
-                        # label="Generated optimal points")
-            if plot_dataset and (self.dataset) is not None:
-                _, Y = self.dataset
-                Y = self.offline_denormalization(Y,
-                                                 self.y_meanormin,
-                                                 self.y_stdormax)
-                plt.scatter(Y[:, 0], Y[:, 1],
-                            c="blue", s=5, alpha=1.0,)
-                            # label="Training data points")
-
-            plt.xlabel("$f_1$", fontsize=14)
-            plt.ylabel("$f_2$", fontsize=14)
-            plt.title(f"Reverse Time Step: {t}", fontsize=14)
+            ax.scatter(f1, f2, c="red", s=10, alpha=1.0,
+                        label="Gen Optimal")
+            
+            ax.set_xlabel("$f_1$", fontsize=14)
+            ax.set_ylabel("$f_2$", fontsize=14)
+            ax.set_title(f"Reverse Time Step: {t}", fontsize=14)
+            ax.text(
+                -0.17, 0.5,
+                self.problem.__class__.__name__.upper() + f"({self.mode})",
+                transform=ax.transAxes,      
+                va='center',
+                ha='center',
+                rotation='vertical',
+                fontsize=20,
+                fontweight='bold'
+            )
 
         elif len(list_fi) == 3:
             fig = plt.figure()
             ax = fig.add_subplot(111, projection="3d")
             
+            if plot_dataset and (self.dataset is not None):
+                _, Y = self.dataset
+                # Denormalize the data
+                Y = self.offline_denormalization(Y,
+                                                self.y_meanormin,
+                                                self.y_stdormax)
+                ax.scatter(Y[:, 0], Y[:, 1], Y[:, 2],
+                           c="violet", s=5, alpha=1.0,
+                           label="Training Data")
+            
             if extra is not None:
                 f1, f2, f3 = extra
-                ax.scatter(f1, f2, f3, c="yellow", s = 5, alpha=0.05,)
-                        #    label="Pareto optimal points")
+                ax.scatter(f1, f2, f3, c="yellow", s = 5, alpha=0.05,
+                           label="Pareto Optimal")
                         
             if pop is not None:
                 f_pop1, f_pop2, f_pop3 = pop
-                ax.scatter(f_pop1, f_pop2, f_pop3, c="blue", s=10, alpha=1.0,)
-                        #    label="Population points")
+                ax.scatter(f_pop1, f_pop2, f_pop3, c="blue", s=10, alpha=1.0,
+                           label="Gen Population")
                 
             f1, f2, f3 = list_fi
-            ax.scatter(f1, f2, f3, c="red", s = 10, alpha=1.0,)
-                    #    label="Generated optimal points")
-
-            if plot_dataset and (self.dataset is not None):
-                _, Y = self.dataset
-                Y = self.offline_denormalization(Y,
-                                                 self.y_meanormin,
-                                                 self.y_stdormax)
-                ax.scatter(Y[:, 0], Y[:, 1], Y[:, 2],
-                           c="blue", s=5, alpha=1.0,)
-                        #    label="Training data points")
+            ax.scatter(f1, f2, f3, c="red", s = 10, alpha=1.0,
+                       label="Gen Optimal")
+            
             ax.set_xlabel("$f_1$", fontsize=14)
             ax.set_ylabel("$f_2$", fontsize=14)
             ax.set_zlabel("$f_3$", fontsize=14)
-            ax.view_init(elev=30, azim=45)
+            ax.view_init(elev=elev, azim=azim)
             ax.set_title(f"Reverse Time Step: {t}", fontsize=14)
+            ax.text2D(
+                -0.17, 0.5,
+                self.problem.__class__.__name__.upper() + f"({self.mode})",
+                transform=ax.transAxes,
+                va='center',
+                ha='center',
+                rotation='vertical',
+                fontsize=20,
+                fontweight='bold'
+            )
 
         img_dir = f"{images_store_path}/{self.problem.__class__.__name__}_{self.mode}"
         if label is not None:
@@ -1871,7 +1961,8 @@ class SPREAD:
         if not os.path.exists(img_dir):
             os.makedirs(img_dir)
 
-        # plt.legend(fontsize=12)
+        if legend:
+            plt.legend(fontsize=12)
         
         plt.savefig(
                 f"{img_dir}/{name}.jpg",
@@ -1879,3 +1970,96 @@ class SPREAD:
                 bbox_inches="tight",
             )
         plt.close()
+
+    def create_video(self, image_folder, output_video,
+                            total_duration_s=20.0,
+                            first_transition_s=2.0,
+                            fps=30,
+                            extensions=("*.jpg", "*.png", "*.jpeg", "*.bmp")):
+        """Create a video from images in `image_folder`, sorted by t=... in filename.
+        The first transition (first->second image) lasts `first_transition_s` seconds.
+        The remaining transitions share the remaining time equally.
+        The output video has total duration `total_duration_s` seconds at `fps` frames per second.
+        """
+
+        # Collect and sort by t=... (descending)
+        paths = []
+        for ext in extensions:
+            paths.extend(glob.glob(os.path.join(image_folder, ext)))
+        if not paths:
+            raise RuntimeError(f"No images found in {image_folder}")
+
+        t_pat = re.compile(r"t=(\d+)")
+        def t_val(p):
+            m = t_pat.search(p)
+            return int(m.group(1)) if m else -1
+
+        paths.sort(key=lambda p: t_val(p), reverse=True)
+        N = len(paths)
+        if N < 2:
+            raise RuntimeError("Need at least two images for a transition.")
+
+        # Read first to get size
+        first_img = cv2.imread(paths[0])
+        if first_img is None:
+            raise RuntimeError(f"Cannot read: {paths[0]}")
+        h, w = first_img.shape[:2]
+        size = (w, h)
+
+        # Prepare writer
+        os.makedirs(os.path.dirname(output_video), exist_ok=True)
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(output_video, fourcc, float(fps), size)
+
+        # Frame budget
+        F_total = int(round(total_duration_s * fps))
+        F_first = int(round(first_transition_s * fps))
+        F_first = max(0, min(F_first, F_total))  # clamp just in case
+        self.frames_written = 0
+
+        def write_transition(img1, img2, d):
+            """Blend img1->img2 over d frames; d==0 means hard cut; d==1 means single frame of img2."""
+            if d <= 0:
+                return
+            img1 = cv2.resize(img1, size)
+            img2 = cv2.resize(img2, size)
+            if d == 1:
+                writer.write(img2); self.frames_written += 1
+                return
+            for j in range(d):
+                alpha = j / (d - 1)  # includes endpoints: j=0 -> img1, j=d-1 -> img2
+                frame = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+                writer.write(frame); self.frames_written += 1
+
+        # Load all images (resized) once to avoid repeated disk I/O
+        imgs = []
+        for p in paths:
+            im = cv2.imread(p)
+            if im is None:
+                im = first_img.copy()
+            imgs.append(cv2.resize(im, size))
+
+        # 1) First transition: fixed 2 seconds (or less if total is tiny)
+        write_transition(imgs[0], imgs[1], F_first)
+
+        # 2) Remaining transitions share remaining frames
+        remaining_frames = F_total - self.frames_written
+        remaining_transitions = max(0, N - 2)
+
+        if remaining_transitions > 0:
+            # Distribute remaining frames across the remaining transitions.
+            # Some transitions may get 0 or 1 frame (hard/near-hard cut) if time is tight.
+            base = 0 if remaining_transitions == 0 else remaining_frames // remaining_transitions
+            extra = 0 if remaining_transitions == 0 else remaining_frames % remaining_transitions
+            # Ensure we don't exceed the total budget:
+            for i in range(remaining_transitions):
+                d = base + (1 if i < extra else 0)
+                write_transition(imgs[i + 1], imgs[i + 2], d)
+
+        # 3) If we still have spare frames (due to rounding), hold last frame
+        last = imgs[-1]
+        while self.frames_written < F_total:
+            writer.write(last); self.frames_written += 1
+
+        writer.release()
+        print(f"✅ Saved: {output_video}  | duration={total_duration_s}s, fps={fps}, frames={F_total}")

moospread/tasks/__init__.py

@@ -1,4 +1,5 @@
 from moospread.tasks.dtlz_torch import DTLZ, DTLZ2, DTLZ4, DTLZ7
 from moospread.tasks.zdt_torch import ZDT, ZDT1, ZDT2, ZDT3
 from moospread.tasks.re_torch import RE21, RE33, RE34, RE37, RE41
-from moospread.tasks.mw_torch import MW7
+from moospread.tasks.bo_torch import BraninCurrin, Penicillin, VehicleSafety
+from moospread.tasks.mw_torch import MW7

moospread/tasks/bo_torch.py

@@ -0,0 +1,300 @@
+import torch
+import torch.nn as nn
+from torch import Tensor
+from pymoo.problems import get_problem
+from moospread.problem import PymooProblemTorch
+from importlib import resources
+import os
+import numpy as np
+import math
+
+
+######## RE Problems ########
+# Note: For the sake of differentiability, we will use the strict bounds:
+# - Lower bound: xl + 1e-6 (instead of xl)
+# - Upper bound: xu - 1e-6 (instead of xu)
+# ref_point: The default reference points are suitable for the "bayesian" mode.
+
+"Adapted from: https://botorch.readthedocs.io/en/stable/_modules/botorch/test_functions/multi_objective.html"
+
+class BraninCurrin(PymooProblemTorch):
+    r"""Two objective problem composed of the Branin and Currin functions.
+
+    Branin (rescaled):
+
+        f(x) = (
+        15*x_1 - 5.1 * (15 * x_0 - 5) ** 2 / (4 * pi ** 2) + 5 * (15 * x_0 - 5)
+        / pi - 5
+        ) ** 2 + (10 - 10 / (8 * pi)) * cos(15 * x_0 - 5))
+
+    Currin:
+
+        f(x) = (1 - exp(-1 / (2 * x_1))) * (
+        2300 * x_0 ** 3 + 1900 * x_0 ** 2 + 2092 * x_0 + 60
+        ) / 100 * x_0 ** 3 + 500 * x_0 ** 2 + 4 * x_0 + 20
+
+    """
+    
+    def __init__(self, path = None, ref_point=None, negate=True, **kwargs):
+        super().__init__(n_var=2, n_obj=2, 
+                         xl=torch.zeros(2, dtype=torch.float) + 1e-6,
+                         xu=torch.ones(2, dtype=torch.float) - 1e-6,
+                         vtype=float, **kwargs)
+        if ref_point is None:
+            self.ref_point = [18.0, 6.0]
+        else:
+            self.ref_point = ref_point
+            
+        self.path = path
+        self.max_hv = 59.36011874867746  # this is approximated using NSGA-II
+        
+    def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
+        if self.path is not None:
+            front = np.loadtxt(self.path)
+            return torch.from_numpy(front).to(self.device)
+        else:
+            return None
+        
+    def _branin(self, X: Tensor) -> Tensor:
+        t1 = (
+            X[..., 1]
+            - 5.1 / (4 * math.pi**2) * X[..., 0].pow(2)
+            + 5 / math.pi * X[..., 0]
+            - 6
+        )
+        t2 = 10 * (1 - 1 / (8 * math.pi)) * torch.cos(X[..., 0])
+        return t1.pow(2) + t2 + 10
+    
+    def _rescaled_branin(self, X: Tensor) -> Tensor:
+        # return to Branin bounds
+        x_0 = 15 * X[..., 0] - 5
+        x_1 = 15 * X[..., 1]
+        return self._branin(torch.stack([x_0, x_1], dim=-1))
+
+    @staticmethod
+    def _currin(X: Tensor) -> Tensor:
+        x_0 = X[..., 0]
+        x_1 = X[..., 1]
+        factor1 = 1 - torch.exp(-1 / (2 * x_1))
+        numer = 2300 * x_0.pow(3) + 1900 * x_0.pow(2) + 2092 * x_0 + 60
+        denom = 100 * x_0.pow(3) + 500 * x_0.pow(2) + 4 * x_0 + 20
+        return factor1 * numer / denom
+    
+    def _evaluate(self, X: torch.Tensor, out: dict, *args, **kwargs) -> None:
+        # branin rescaled with inputsto [0,1]^2
+        branin = self._rescaled_branin(X=X)
+        currin = self._currin(X=X)
+        out["F"] = torch.stack([branin, currin], dim=-1)
+    
+class Penicillin(PymooProblemTorch):
+    r"""A penicillin production simulator from [Liang2021]_.
+
+    This implementation is adapted from
+    https://github.com/HarryQL/TuRBO-Penicillin.
+
+    The goal is to maximize the penicillin yield while minimizing
+    time to ferment and the CO2 byproduct.
+
+    The function is defined for minimization of all objectives.
+
+    The reference point was set using the `infer_reference_point` heuristic
+    on the Pareto frontier obtained via NSGA-II.
+    """
+    
+    Y_xs = 0.45
+    Y_ps = 0.90
+    K_1 = 10 ** (-10)
+    K_2 = 7 * 10 ** (-5)
+    m_X = 0.014
+    alpha_1 = 0.143
+    alpha_2 = 4 * 10 ** (-7)
+    alpha_3 = 10 ** (-4)
+    mu_X = 0.092
+    K_X = 0.15
+    mu_p = 0.005
+    K_p = 0.0002
+    K_I = 0.10
+    K = 0.04
+    k_g = 7.0 * 10**3
+    E_g = 5100.0
+    k_d = 10.0**33
+    E_d = 50000.0
+    lambd = 2.5 * 10 ** (-4)
+    T_v = 273.0  # Kelvin
+    T_o = 373.0
+    R = 1.9872  # CAL/(MOL K)
+    V_max = 180.0
+    
+    def __init__(self, path = None, ref_point=None, negate=True, **kwargs):
+        super().__init__(n_var=7, n_obj=3, 
+                         xl=torch.tensor([60.0, 0.05, 293.0, 0.05, 0.01, 500.0, 5.0], dtype=torch.float) + 1e-6,
+                         xu=torch.tensor([120.0, 18.0, 303.0, 18.0, 0.5, 700.0, 6.5], dtype=torch.float) - 1e-6,
+                         vtype=float, **kwargs)
+        if ref_point is None:
+            self.ref_point = [25.935, 57.612, 935.5]
+        else:
+            self.ref_point = ref_point
+            
+        self.path = path
+        self.max_hv = 2183455.909507436
+        
+    def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
+        if self.path is not None:
+            front = np.loadtxt(self.path)
+            return torch.from_numpy(front).to(self.device)
+        else:
+            return None
+
+    @classmethod
+    def penicillin_vectorized(cls, X_input: Tensor) -> Tensor:
+        r"""Penicillin simulator, simplified and vectorized.
+
+        The 7 input parameters are (in order): culture volume, biomass
+        concentration, temperature, glucose concentration, substrate feed
+        rate, substrate feed concentration, and H+ concentration.
+
+        Args:
+            X_input: A `n x 7`-dim tensor of inputs.
+
+        Returns:
+            An `n x 3`-dim tensor of (negative) penicillin yield, CO2 and time.
+        """
+        V, X, T, S, F, s_f, H_ = torch.split(X_input, 1, -1)
+        P, CO2 = torch.zeros_like(V), torch.zeros_like(V)
+        H = torch.full_like(H_, 10.0).pow(-H_)
+
+        active = torch.ones_like(V).bool()
+        t_tensor = torch.full_like(V, 2500)
+
+        for t in range(1, 2501):
+            if active.sum() == 0:
+                break
+            F_loss = (
+                V[active]
+                * cls.lambd
+                * torch.special.expm1(5 * ((T[active] - cls.T_o) / (cls.T_v - cls.T_o)))
+            )
+            dV_dt = F[active] - F_loss
+            mu = (
+                (cls.mu_X / (1 + cls.K_1 / H[active] + H[active] / cls.K_2))
+                * (S[active] / (cls.K_X * X[active] + S[active]))
+                * (
+                    (cls.k_g * torch.exp(-cls.E_g / (cls.R * T[active])))
+                    - (cls.k_d * torch.exp(-cls.E_d / (cls.R * T[active])))
+                )
+            )
+            dX_dt = mu * X[active] - (X[active] / V[active]) * dV_dt
+            mu_pp = cls.mu_p * (
+                S[active] / (cls.K_p + S[active] + S[active].pow(2) / cls.K_I)
+            )
+            dS_dt = (
+                -(mu / cls.Y_xs) * X[active]
+                - (mu_pp / cls.Y_ps) * X[active]
+                - cls.m_X * X[active]
+                + F[active] * s_f[active] / V[active]
+                - (S[active] / V[active]) * dV_dt
+            )
+            dP_dt = (
+                (mu_pp * X[active])
+                - cls.K * P[active]
+                - (P[active] / V[active]) * dV_dt
+            )
+            dCO2_dt = cls.alpha_1 * dX_dt + cls.alpha_2 * X[active] + cls.alpha_3
+
+            # UPDATE
+            P[active] = P[active] + dP_dt  # Penicillin concentration
+            V[active] = V[active] + dV_dt  # Culture medium volume
+            X[active] = X[active] + dX_dt  # Biomass concentration
+            S[active] = S[active] + dS_dt  # Glucose concentration
+            CO2[active] = CO2[active] + dCO2_dt  # CO2 concentration
+
+            # Update active indices
+            full_dpdt = torch.ones_like(P)
+            full_dpdt[active] = dP_dt
+            inactive = (V > cls.V_max) + (S < 0) + (full_dpdt < 10e-12)
+            t_tensor[inactive] = torch.minimum(
+                t_tensor[inactive], torch.full_like(t_tensor[inactive], t)
+            )
+            active[inactive] = 0
+
+        return torch.stack([-P, CO2, t_tensor], dim=-1)
+
+    def _evaluate(self, X: torch.Tensor, out: dict, *args, **kwargs) -> None:
+        # This uses in-place operations. Hence, the clone is to avoid modifying
+        # the original X in-place.
+        out["F"] = self.penicillin_vectorized(X.view(-1, self.dim).clone()).view(
+            *X.shape[:-1], self.num_objectives
+        )
+        
+
+class VehicleSafety(PymooProblemTorch):
+    r"""Optimize Vehicle crash-worthiness.
+
+    See [Tanabe2020]_ for details.
+
+    The reference point is 1.1 * the nadir point from
+    approximate front provided by [Tanabe2020]_.
+
+    The maximum hypervolume is computed using the approximate
+    pareto front from [Tanabe2020]_.
+    """
+    
+    def __init__(self, path = None, ref_point=None, negate=True, **kwargs):
+        super().__init__(n_var=5, n_obj=3, 
+                         xl=torch.ones(5, dtype=torch.float) + 1e-6,
+                         xu=3*torch.ones(5, dtype=torch.float) - 1e-6,
+                         vtype=float, **kwargs)
+        if ref_point is None:
+            self.ref_point = [1864.72022, 11.81993945, 0.2903999384]
+        else:
+            self.ref_point = ref_point
+            
+        self.path = path
+        self.max_hv = 246.81607081187002
+        
+    def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
+        if self.path is not None:
+            front = np.loadtxt(self.path)
+            return torch.from_numpy(front).to(self.device)
+        else:
+            return None
+
+
+    def _evaluate(self, X: torch.Tensor, out: dict, *args, **kwargs) -> None:
+        X1, X2, X3, X4, X5 = torch.split(X, 1, -1)
+        f1 = (
+            1640.2823
+            + 2.3573285 * X1
+            + 2.3220035 * X2
+            + 4.5688768 * X3
+            + 7.7213633 * X4
+            + 4.4559504 * X5
+        )
+        f2 = (
+            6.5856
+            + 1.15 * X1
+            - 1.0427 * X2
+            + 0.9738 * X3
+            + 0.8364 * X4
+            - 0.3695 * X1 * X4
+            + 0.0861 * X1 * X5
+            + 0.3628 * X2 * X4
+            - 0.1106 * X1.pow(2)
+            - 0.3437 * X3.pow(2)
+            + 0.1764 * X4.pow(2)
+        )
+        f3 = (
+            -0.0551
+            + 0.0181 * X1
+            + 0.1024 * X2
+            + 0.0421 * X3
+            - 0.0073 * X1 * X2
+            + 0.024 * X2 * X3
+            - 0.0118 * X2 * X4
+            - 0.0204 * X3 * X4
+            - 0.008 * X3 * X5
+            - 0.0241 * X2.pow(2)
+            + 0.0109 * X4.pow(2)
+        )
+        f_X = torch.cat([f1, f2, f3], dim=-1)
+        out["F"] = f_X

moospread/tasks/re_torch.py

@@ -2,6 +2,7 @@ import torch
 import torch.nn as nn
 from pymoo.problems import get_problem
 from moospread.problem import PymooProblemTorch
+from importlib import resources
 import os
 import numpy as np
 
@@ -9,7 +10,7 @@ import numpy as np
 # Note: For the sake of differentiability, we will use the strict bounds:
 # - Lower bound: xl + 1e-6 (instead of xl)
 # - Upper bound: xu - 1e-6 (instead of xu)
-# ref_point: The default reference points are suitable for the "online" mode.
+# ref_point: The default reference points are suitable for the "offline" mode.
 
 class RE21(PymooProblemTorch):
     def __init__(self, path = None, ref_point=None, **kwargs):
@@ -26,14 +27,19 @@ class RE21(PymooProblemTorch):
                          vtype=float, **kwargs)
         if ref_point is None:
             self.ref_point = [3144.44, 0.05]
+            # self.ref_point = [3144.44, 0.05] # suitable for "online" mode
         else:
             self.ref_point = ref_point
             
         self.path = path
     
     def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
-        assert self.path is not None, "Path to Pareto front file not specified."
-        front = np.loadtxt(self.path)
+        try:
+            front = np.loadtxt(self.path)
+        except:
+            front = np.loadtxt(resources.files("moospread.tasks.pf_re_tasks").joinpath(f"reference_points_{self.__class__.__name__}.dat"))
+        else:
+            assert self.path is not None, "Path to Pareto front file not specified."
         return torch.from_numpy(front).to(self.device)
 
     def _evaluate(self, X: torch.Tensor, out: dict, *args, **kwargs) -> None:
@@ -81,15 +87,20 @@ class RE33(PymooProblemTorch):
                          xu=torch.tensor([80.0, 110.0, 3000.0, 20.0])- 1e-6,
                          vtype=float, **kwargs)
         if ref_point is None:
-            self.ref_point = [5.01, 9.84, 4.30]
+            self.ref_point = [8.01,    8.84, 2343.30]
+            # self.ref_point = [5.01, 9.84, 4.30] # suitable for "online" mode
         else:
             self.ref_point = ref_point
             
         self.path = path
     
     def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
-        assert self.path is not None, "Path to Pareto front file not specified."
-        front = np.loadtxt(self.path)
+        try:
+            front = np.loadtxt(self.path)
+        except:
+            front = np.loadtxt(resources.files("moospread.tasks.pf_re_tasks").joinpath(f"reference_points_{self.__class__.__name__}.dat"))
+        else:
+            assert self.path is not None, "Path to Pareto front file not specified."
         return torch.from_numpy(front).to(self.device)
 
 
@@ -153,15 +164,20 @@ class RE34(PymooProblemTorch):
                          xu=torch.full((5,), 3.0) - 1e-6,
                          vtype=float, **kwargs)
         if ref_point is None:
-            self.ref_point = [1.86472022e+03, 1.18199394e+01, 2.90399938e-01]
+            self.ref_point = [1702.52, 11.68, 0.26]
+            # self.ref_point = [1.86472022e+03, 1.18199394e+01, 2.90399938e-01] # suitable for "online" mode
         else:
             self.ref_point = ref_point
             
         self.path = path
 
     def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
-        assert self.path is not None, "Path to Pareto front file not specified."
-        front = np.loadtxt(self.path)
+        try:
+            front = np.loadtxt(self.path)
+        except:
+            front = np.loadtxt(resources.files("moospread.tasks.pf_re_tasks").joinpath(f"reference_points_{self.__class__.__name__}.dat"))
+        else:
+            assert self.path is not None, "Path to Pareto front file not specified."
         return torch.from_numpy(front).to(self.device)
 
     def _evaluate(self, x: torch.Tensor, out: dict, *args, **kwargs) -> None:
@@ -233,15 +249,20 @@ class RE37(PymooProblemTorch):
                          xu=torch.ones(4) - 1e-6,
                          vtype=float, **kwargs)
         if ref_point is None:
-            self.ref_point = [1.1022, 1.20726899, 1.20318656]
+            self.ref_point = [0.99, 0.96, 0.99]
+            # self.ref_point = [1.1022, 1.20726899, 1.20318656] # suitable for "online" mode
         else:
             self.ref_point = ref_point
             
         self.path = path
 
     def _calc_pareto_front(self, n_pareto_points: int = 100) -> torch.Tensor:
-        assert self.path is not None, "Path to Pareto front file not specified."
-        front = np.loadtxt(self.path)
+        try:
+            front = np.loadtxt(self.path)
+        except:
+            front = np.loadtxt(resources.files("moospread.tasks.pf_re_tasks").joinpath(f"reference_points_{self.__class__.__name__}.dat"))
+        else:
+            assert self.path is not None, "Path to Pareto front file not specified."
         return torch.from_numpy(front).to(self.device)
 
     def _evaluate(self, x: torch.Tensor, out: dict, *args, **kwargs) -> None:
@@ -325,7 +346,8 @@ class RE41(PymooProblemTorch):
                          xu=torch.tensor([1.5, 1.35, 1.5, 1.5, 2.625, 1.2, 1.2], dtype=torch.float) - 1e-6,
                          vtype=float, **kwargs)
         if ref_point is None:
-            self.ref_point = [47.04480682,  4.86997366, 14.40049127, 10.3941957 ]
+            self.ref_point = [42.65,  4.43, 13.08, 13.45]
+            # self.ref_point = [47.04480682,  4.86997366, 14.40049127, 10.3941957 ] # suitable for "online" mode
         else:
             self.ref_point = ref_point
             
@@ -391,4 +413,4 @@ class RE41(PymooProblemTorch):
         zero = torch.tensor(0.0, dtype=X.dtype, device=X.device)
         g = torch.where(g < 0, -g, zero)
         f4 = g.sum(dim=-1, keepdim=True)
-        out["F"] = torch.cat([f1, f2, f3, f4], dim=-1)
+        out["F"] = torch.cat([f1, f2, f3, f4], dim=-1)

moospread/utils/offline_utils/handle_task.py

@@ -1,6 +1,6 @@
 import torch
 import torch.nn.functional as F
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 
 def one_hot(a: torch.Tensor, num_classes: int) -> torch.Tensor:
@@ -139,7 +139,9 @@ def offdata_to_integers(x: torch.Tensor, num_classes_on_each_position: List[int]
     return torch.cat(integers, dim=1)
 
 
-def offdata_z_score_normalize(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+def offdata_z_score_normalize(x: torch.Tensor, 
+                              mean: Optional[torch.Tensor] = None,
+                              std: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """Z-score normalize features columnwise (match NumPy semantics).
 
     Args:
@@ -150,11 +152,17 @@ def offdata_z_score_normalize(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tens
     if not torch.is_floating_point(x):
         raise ValueError("cannot normalize discrete design values")
 
+    if mean is not None and std is not None:
+        x_norm = (x - mean.to(x.device)) / std.to(x.device)
+        return x_norm, mean, std
+    
     mean = torch.mean(x, dim=0)
     # NumPy's np.std uses population std (ddof=0) by default -> unbiased=False
     std = torch.std(x, dim=0, unbiased=False)
-    x_norm = (x - mean) / std
-    return x_norm, mean, std
+    eps = 1e-6
+    std_safe = torch.clamp(std, min=eps)
+    x_norm = (x - mean) / std_safe
+    return x_norm, mean, std_safe
 
 
 def offdata_z_score_denormalize(x: torch.Tensor, 
@@ -174,7 +182,9 @@ def offdata_z_score_denormalize(x: torch.Tensor,
     return x * x_std.to(x.device) + x_mean.to(x.device)
 
 
-def offdata_min_max_normalize(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+def offdata_min_max_normalize(x: torch.Tensor,
+                              min_val: Optional[torch.Tensor] = None,
+                              max_val: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """Min-max normalize features columnwise.
 
     Args:
@@ -182,10 +192,17 @@ def offdata_min_max_normalize(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tens
     Returns:
         (x_norm, x_min, x_max)
     """
+    
+    if min_val is not None and max_val is not None:
+        x_norm = (x - min_val.to(x.device)) / (max_val.to(x.device) - min_val.to(x.device))
+        return x_norm, min_val, max_val
+    
     x_min = torch.min(x, dim=0).values
     x_max = torch.max(x, dim=0).values
-    x_norm = (x - x_min) / (x_max - x_min)
-    return x_norm, x_min, x_max
+    eps = 1e-6
+    x_max_x_min_safe = torch.clamp(x_max - x_min, min=eps)
+    x_norm = (x - x_min) / x_max_x_min_safe
+    return x_norm, x_max-x_max_x_min_safe, x_max
 
 
 def offdata_min_max_denormalize(x: torch.Tensor, 

{moospread-0.1.2.dist-info → moospread-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moospread
-Version: 0.1.2
+Version: 0.1.4
 Summary: Sampling-based Pareto front Refinement via Efficient Adaptive Diffusion
 Author-email: Sedjro Salomon Hotegni <salomon.hotegni@aims.ac.rw>
 Maintainer-email: Sedjro Salomon Hotegni <salomon.hotegni@tu-dortmund.de>
@@ -26,6 +26,8 @@ Requires-Dist: scipy>=1.10
 Requires-Dist: scikit-learn>=1.3
 Requires-Dist: matplotlib>=3.7
 Requires-Dist: pandas>=2.0
+Requires-Dist: importlib
+Requires-Dist: opencv-python-headless
 Requires-Dist: pytz
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: tqdm>=4.66
@@ -61,6 +63,20 @@ Dynamic: license-file
 </p>
 -->
 
+<p align="center">
+  <a href="https://pypi.org/project/moospread/"><img src="https://img.shields.io/pypi/v/moospread.svg" alt="PyPI version"></a>
+  <a href="https://moospread.readthedocs.io">
+  <img src="https://img.shields.io/badge/docs-online-brightgreen.svg" alt="Documentation">
+</a>
+</p>
+<div align="center">
+    <h3>
+      <a href="https://pypi.org/project/moospread/">Installation</a> |
+      <a href="https://moospread.readthedocs.io/en/latest/">Documentation</a> | 
+      <a href="https://arxiv.org/pdf/2509.21058">Paper</a>
+    </h3>
+</div>
+
 # SPREAD: Sampling-based Pareto front Refinement via Efficient Adaptive Diffusion
 
 > SPREAD is a novel sampling-based approach for multi-objective optimization that leverages diffusion models to efficiently refine and generate well-spread Pareto front approximations. It combines the expressiveness of diffusion models with multi-objective optimization principles to achieve both high convergence to the Pareto front and excellent diversity across the objective space. SPREAD demonstrates competitive performance against state-of-the-art methods while providing a flexible framework for different optimization contexts.
@@ -96,35 +112,23 @@ from moospread import SPREAD
 from moospread.tasks import ZDT2
 
 # Define the problem
-n_var = 30
-problem = ZDT2(n_var=n_var)
+problem = ZDT2(n_var=30)
 
 # Initialize the SPREAD solver
 solver = SPREAD(
     problem,
     data_size=10000,
-    timesteps=5000,
+    timesteps=1000,
     num_epochs=1000,
     train_tol=100,
-    num_blocks=3,
-    validation_split=0.1,
     mode="online",
     seed=2026,
     verbose=True
 )
 
 # Solve the problem
-results = solver.solve(
+res_x, res_y = solver.solve(
     num_points_sample=200,
-    strict_guidance=False,
-    rho_scale_gamma=0.9,
-    nu_t=10.0,
-    eta_init=0.9,
-    num_inner_steps=10,
-    lr_inner=0.9,
-    free_initial_h=True,
-    use_sigma_rep=False,
-    kernel_sigma_rep=0.01,
     iterative_plot=True,
     plot_period=10,
     max_backtracks=25,
@@ -138,11 +142,10 @@ This will train a diffusion-based multi-objective solver, approximate the Pareto
 
 ---
 
-<!--
+
 ### 📚 Next steps
 
-For more advanced examples (offline mode, Bayesian mode, custom problems), see the full [documentation](https://moospread.readthedocs.io/en/latest/).
--->
+For more advanced examples (offline mode, mobo mode, tutorials), see the full [documentation](https://moospread.readthedocs.io/en/latest/).
 
 ## Citation
 If you find `moospread` useful in your research, please consider citing:

{moospread-0.1.2.dist-info → moospread-0.1.4.dist-info}/RECORD

@@ -1,10 +1,11 @@
 moospread/__init__.py,sha256=v9TLUZq0-q0j_23NB7S4ugJqogOMutUuL9MMCi4zu4I,124
-moospread/core.py,sha256=nuSEnWBCxxEHXN0AOe1KGp93l7UjkBJjEMUZD3xS64c,82331
+moospread/core.py,sha256=KL7gOta4OUAzb3TYWjgCXrDTot2-Pxt-6vI4fZzzv4s,91644
 moospread/problem.py,sha256=YjT4k_K7qTZDhWzIYkaBQlsZRVnpP6iV3F8ShFhGAck,6042
-moospread/tasks/__init__.py,sha256=S_zM0GjBNbSPH9uyn1RAdQtA6-BDkcbmF4uWUi-8NVo,231
+moospread/tasks/__init__.py,sha256=RrtuZs1TyL35fDzGjlm1PnFqxXd75Qdl-q3Sdld7dsw,309
+moospread/tasks/bo_torch.py,sha256=0I77aWBM4TzfH7l2iQLTRm_5Orc25rmXabrcpPQpVb8,10371
 moospread/tasks/dtlz_torch.py,sha256=dhmzUj-dbhF3zXIOgx2Z-PpuIqvxAttnEoBM0C9nUt0,5134
 moospread/tasks/mw_torch.py,sha256=hvYGxcaCr-AFgZd_-rLcIul_a5cZrOV3dRVB5sl9Wuo,9585
-moospread/tasks/re_torch.py,sha256=Q5aANkHatO_FgPoPQsLVrwOESNo1LW8sDhXH351GdDM,12856
+moospread/tasks/re_torch.py,sha256=TK7i-9i7qlDZC2H4vdhcVgHybarKwJ-M27yAibAg3LI,14062
 moospread/tasks/zdt_torch.py,sha256=xdtfF6K3LmgH0vINQa6ogeMrJOdoyg3xaQ1EmldcEvg,4161
 moospread/utils/__init__.py,sha256=l7iUhBmGcOaZVyJI4SI4XlecDNLhRy0L5CTNmdXccIc,336
 moospread/utils/ditmoo.py,sha256=fP3NZ-CmnCSoK7m8b7RSoDZiVh053rcOUbu8Llwpz48,3680
@@ -54,10 +55,10 @@ moospread/utils/mobo_utils/mobo/surrogate_model/base.py,sha256=YvTx-ORldAnnQ4bT0
 moospread/utils/mobo_utils/mobo/surrogate_model/gaussian_process.py,sha256=-OkFEte66FAXSPk32Dy2vhJ9RGoTsJWagbHosCE9qus,7722
 moospread/utils/mobo_utils/mobo/surrogate_model/thompson_sampling.py,sha256=Nmp63vuAgNv-iyVxxRn_yTaAlRLVXW28wsnIu5JpZ1o,3293
 moospread/utils/offline_utils/__init__.py,sha256=MJC-fqvQnbQ0T_wjCw_QK8nKo_xpQxh0buq91fxYjFY,742
-moospread/utils/offline_utils/handle_task.py,sha256=VJjcWZC5AoPm42YN_SKgSpcyHtKBAgXgWwSFU0-Ehis,7586
+moospread/utils/offline_utils/handle_task.py,sha256=kgHpWotCIrmDBjs08KXyp1BuwXe5APkw3q7cu-xWlz4,8365
 moospread/utils/offline_utils/proxies.py,sha256=DPBykB8l1XJmT5QQCAQrgMZz-8FiGEiNwN0bBdYJIaY,11218
-moospread-0.1.2.dist-info/licenses/LICENSE,sha256=YwtV5PRo6WMw5CWQMD728fSF8cWEKKfwOhek37Yi1so,1079
-moospread-0.1.2.dist-info/METADATA,sha256=wzYcnaPd_T-vgO7vsUS1vgIRMr4uNyX4bcbrfdDoSGM,5839
-moospread-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-moospread-0.1.2.dist-info/top_level.txt,sha256=LWi5kIahDQRNXNkx55T-gefn09Bgcq8SoCxp72S-7x0,10
-moospread-0.1.2.dist-info/RECORD,,
+moospread-0.1.4.dist-info/licenses/LICENSE,sha256=YwtV5PRo6WMw5CWQMD728fSF8cWEKKfwOhek37Yi1so,1079
+moospread-0.1.4.dist-info/METADATA,sha256=Q1Sw5QOvVA4j973tkEjk4Wse2BPXRNSh9Pzf5gFy4Ts,6179
+moospread-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+moospread-0.1.4.dist-info/top_level.txt,sha256=LWi5kIahDQRNXNkx55T-gefn09Bgcq8SoCxp72S-7x0,10
+moospread-0.1.4.dist-info/RECORD,,