ins-pricing 0.3.0__tar.gz → 0.3.2__tar.gz

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ins_pricing
-Version: 0.3.0
+Version: 0.3.2
 Summary: Reusable modelling, pricing, governance, and reporting utilities.
 Author: meishi125478
 License: Proprietary

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/cli/Explain_entry.py

@@ -491,54 +491,56 @@ def explain_from_config(args: argparse.Namespace) -> None:
         categorical_features = cfg.get("categorical_features")
         plot_path_style = runtime_cfg["plot_path_style"]
 
-        model = ropt.BayesOptModel(
-            train_df,
-            test_df,
-            model_name,
-            cfg["target"],
-            cfg["weight"],
-            feature_list,
-            task_type=str(cfg.get("task_type", "regression")),
-            binary_resp_nme=binary_target,
-            cate_list=categorical_features,
-            prop_test=prop_test,
-            rand_seed=rand_seed,
-            epochs=int(runtime_cfg["epochs"]),
-            use_gpu=bool(cfg.get("use_gpu", True)),
-            output_dir=output_dir,
-            xgb_max_depth_max=runtime_cfg["xgb_max_depth_max"],
-            xgb_n_estimators_max=runtime_cfg["xgb_n_estimators_max"],
-            resn_weight_decay=cfg.get("resn_weight_decay"),
-            final_ensemble=bool(cfg.get("final_ensemble", False)),
-            final_ensemble_k=int(cfg.get("final_ensemble_k", 3)),
-            final_refit=bool(cfg.get("final_refit", True)),
-            optuna_storage=runtime_cfg["optuna_storage"],
-            optuna_study_prefix=runtime_cfg["optuna_study_prefix"],
-            best_params_files=runtime_cfg["best_params_files"],
-            gnn_use_approx_knn=cfg.get("gnn_use_approx_knn", True),
-            gnn_approx_knn_threshold=cfg.get("gnn_approx_knn_threshold", 50000),
-            gnn_graph_cache=cfg.get("gnn_graph_cache"),
-            gnn_max_gpu_knn_nodes=cfg.get("gnn_max_gpu_knn_nodes", 200000),
-            gnn_knn_gpu_mem_ratio=cfg.get("gnn_knn_gpu_mem_ratio", 0.9),
-            gnn_knn_gpu_mem_overhead=cfg.get("gnn_knn_gpu_mem_overhead", 2.0),
-            region_province_col=cfg.get("region_province_col"),
-            region_city_col=cfg.get("region_city_col"),
-            region_effect_alpha=cfg.get("region_effect_alpha"),
-            geo_feature_nmes=cfg.get("geo_feature_nmes"),
-            geo_token_hidden_dim=cfg.get("geo_token_hidden_dim"),
-            geo_token_layers=cfg.get("geo_token_layers"),
-            geo_token_dropout=cfg.get("geo_token_dropout"),
-            geo_token_k_neighbors=cfg.get("geo_token_k_neighbors"),
-            geo_token_learning_rate=cfg.get("geo_token_learning_rate"),
-            geo_token_epochs=cfg.get("geo_token_epochs"),
-            ft_role=str(cfg.get("ft_role", "model")),
-            ft_feature_prefix=str(cfg.get("ft_feature_prefix", "ft_emb")),
-            ft_num_numeric_tokens=cfg.get("ft_num_numeric_tokens"),
-            infer_categorical_max_unique=int(cfg.get("infer_categorical_max_unique", 50)),
-            infer_categorical_max_ratio=float(cfg.get("infer_categorical_max_ratio", 0.05)),
-            reuse_best_params=runtime_cfg["reuse_best_params"],
-            plot_path_style=plot_path_style,
-        )
+        config_fields = getattr(ropt.BayesOptConfig, "__dataclass_fields__", {})
+        allowed_config_keys = set(config_fields.keys())
+        config_payload = {k: v for k, v in cfg.items() if k in allowed_config_keys}
+        config_payload.update({
+            "model_nme": model_name,
+            "resp_nme": cfg["target"],
+            "weight_nme": cfg["weight"],
+            "factor_nmes": feature_list,
+            "task_type": str(cfg.get("task_type", "regression")),
+            "binary_resp_nme": binary_target,
+            "cate_list": categorical_features,
+            "prop_test": prop_test,
+            "rand_seed": rand_seed,
+            "epochs": int(runtime_cfg["epochs"]),
+            "use_gpu": bool(cfg.get("use_gpu", True)),
+            "output_dir": output_dir,
+            "xgb_max_depth_max": runtime_cfg["xgb_max_depth_max"],
+            "xgb_n_estimators_max": runtime_cfg["xgb_n_estimators_max"],
+            "resn_weight_decay": cfg.get("resn_weight_decay"),
+            "final_ensemble": bool(cfg.get("final_ensemble", False)),
+            "final_ensemble_k": int(cfg.get("final_ensemble_k", 3)),
+            "final_refit": bool(cfg.get("final_refit", True)),
+            "optuna_storage": runtime_cfg["optuna_storage"],
+            "optuna_study_prefix": runtime_cfg["optuna_study_prefix"],
+            "best_params_files": runtime_cfg["best_params_files"],
+            "gnn_use_approx_knn": cfg.get("gnn_use_approx_knn", True),
+            "gnn_approx_knn_threshold": cfg.get("gnn_approx_knn_threshold", 50000),
+            "gnn_graph_cache": cfg.get("gnn_graph_cache"),
+            "gnn_max_gpu_knn_nodes": cfg.get("gnn_max_gpu_knn_nodes", 200000),
+            "gnn_knn_gpu_mem_ratio": cfg.get("gnn_knn_gpu_mem_ratio", 0.9),
+            "gnn_knn_gpu_mem_overhead": cfg.get("gnn_knn_gpu_mem_overhead", 2.0),
+            "region_province_col": cfg.get("region_province_col"),
+            "region_city_col": cfg.get("region_city_col"),
+            "region_effect_alpha": cfg.get("region_effect_alpha"),
+            "geo_feature_nmes": cfg.get("geo_feature_nmes"),
+            "geo_token_hidden_dim": cfg.get("geo_token_hidden_dim"),
+            "geo_token_layers": cfg.get("geo_token_layers"),
+            "geo_token_dropout": cfg.get("geo_token_dropout"),
+            "geo_token_k_neighbors": cfg.get("geo_token_k_neighbors"),
+            "geo_token_learning_rate": cfg.get("geo_token_learning_rate"),
+            "geo_token_epochs": cfg.get("geo_token_epochs"),
+            "ft_role": str(cfg.get("ft_role", "model")),
+            "ft_feature_prefix": str(cfg.get("ft_feature_prefix", "ft_emb")),
+            "ft_num_numeric_tokens": cfg.get("ft_num_numeric_tokens"),
+            "reuse_best_params": runtime_cfg["reuse_best_params"],
+            "plot_path_style": plot_path_style or "nested",
+        })
+        config_payload = {k: v for k, v in config_payload.items() if v is not None}
+        config = ropt.BayesOptConfig(**config_payload)
+        model = ropt.BayesOptModel(train_df, test_df, config=config)
 
         output_overrides = resolve_explain_output_overrides(
             explain_cfg,

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/cli/bayesopt_entry_runner.py

@@ -1223,76 +1223,79 @@ def train_from_config(args: argparse.Namespace) -> None:
             cfg.get("ft_feature_prefix", args.ft_feature_prefix))
         ft_num_numeric_tokens = cfg.get("ft_num_numeric_tokens")
 
-        model = ropt.BayesOptModel(
-            train_df,
-            test_df,
-            model_name,
-            cfg["target"],
-            cfg["weight"],
-            feature_list,
-            task_type=task_type,
-            binary_resp_nme=binary_target,
-            cate_list=categorical_features,
-            prop_test=val_ratio,
-            rand_seed=rand_seed,
-            epochs=epochs,
-            use_gpu=use_gpu,
-            use_resn_data_parallel=use_resn_dp,
-            use_ft_data_parallel=use_ft_dp,
-            use_resn_ddp=use_resn_ddp,
-            use_ft_ddp=use_ft_ddp,
-            use_gnn_data_parallel=use_gnn_dp,
-            use_gnn_ddp=use_gnn_ddp,
-            output_dir=output_dir,
-            xgb_max_depth_max=xgb_max_depth_max,
-            xgb_n_estimators_max=xgb_n_estimators_max,
-            resn_weight_decay=cfg.get("resn_weight_decay"),
-            final_ensemble=bool(cfg.get("final_ensemble", False)),
-            final_ensemble_k=int(cfg.get("final_ensemble_k", 3)),
-            final_refit=bool(cfg.get("final_refit", True)),
-            optuna_storage=optuna_storage,
-            optuna_study_prefix=optuna_study_prefix,
-            best_params_files=best_params_files,
-            gnn_use_approx_knn=gnn_use_ann,
-            gnn_approx_knn_threshold=gnn_threshold,
-            gnn_graph_cache=gnn_graph_cache,
-            gnn_max_gpu_knn_nodes=gnn_max_gpu_nodes,
-            gnn_knn_gpu_mem_ratio=gnn_gpu_mem_ratio,
-            gnn_knn_gpu_mem_overhead=gnn_gpu_mem_overhead,
-            region_province_col=region_province_col,
-            region_city_col=region_city_col,
-            region_effect_alpha=region_effect_alpha,
-            geo_feature_nmes=geo_feature_nmes,
-            geo_token_hidden_dim=geo_token_hidden_dim,
-            geo_token_layers=geo_token_layers,
-            geo_token_dropout=geo_token_dropout,
-            geo_token_k_neighbors=geo_token_k_neighbors,
-            geo_token_learning_rate=geo_token_learning_rate,
-            geo_token_epochs=geo_token_epochs,
-            ft_role=ft_role,
-            ft_feature_prefix=ft_feature_prefix,
-            ft_num_numeric_tokens=ft_num_numeric_tokens,
-            infer_categorical_max_unique=int(
-                cfg.get("infer_categorical_max_unique", 50)),
-            infer_categorical_max_ratio=float(
-                cfg.get("infer_categorical_max_ratio", 0.05)),
-            reuse_best_params=reuse_best_params,
-            bo_sample_limit=bo_sample_limit,
-            cache_predictions=cache_predictions,
-            prediction_cache_dir=prediction_cache_dir,
-            prediction_cache_format=prediction_cache_format,
-            cv_strategy=cv_strategy or split_strategy,
-            cv_group_col=cv_group_col or split_group_col,
-            cv_time_col=cv_time_col or split_time_col,
-            cv_time_ascending=cv_time_ascending,
-            cv_splits=cv_splits,
-            ft_oof_folds=ft_oof_folds,
-            ft_oof_strategy=ft_oof_strategy,
-            ft_oof_shuffle=ft_oof_shuffle,
-            save_preprocess=save_preprocess,
-            preprocess_artifact_path=preprocess_artifact_path,
-            plot_path_style=plot_path_style,
-        )
+        config_fields = getattr(ropt.BayesOptConfig,
+                                "__dataclass_fields__", {})
+        allowed_config_keys = set(config_fields.keys())
+        config_payload = {k: v for k,
+                          v in cfg.items() if k in allowed_config_keys}
+        config_payload.update({
+            "model_nme": model_name,
+            "resp_nme": cfg["target"],
+            "weight_nme": cfg["weight"],
+            "factor_nmes": feature_list,
+            "task_type": task_type,
+            "binary_resp_nme": binary_target,
+            "cate_list": categorical_features,
+            "prop_test": val_ratio,
+            "rand_seed": rand_seed,
+            "epochs": epochs,
+            "use_gpu": use_gpu,
+            "use_resn_data_parallel": use_resn_dp,
+            "use_ft_data_parallel": use_ft_dp,
+            "use_gnn_data_parallel": use_gnn_dp,
+            "use_resn_ddp": use_resn_ddp,
+            "use_ft_ddp": use_ft_ddp,
+            "use_gnn_ddp": use_gnn_ddp,
+            "output_dir": output_dir,
+            "xgb_max_depth_max": xgb_max_depth_max,
+            "xgb_n_estimators_max": xgb_n_estimators_max,
+            "resn_weight_decay": cfg.get("resn_weight_decay"),
+            "final_ensemble": bool(cfg.get("final_ensemble", False)),
+            "final_ensemble_k": int(cfg.get("final_ensemble_k", 3)),
+            "final_refit": bool(cfg.get("final_refit", True)),
+            "optuna_storage": optuna_storage,
+            "optuna_study_prefix": optuna_study_prefix,
+            "best_params_files": best_params_files,
+            "gnn_use_approx_knn": gnn_use_ann,
+            "gnn_approx_knn_threshold": gnn_threshold,
+            "gnn_graph_cache": gnn_graph_cache,
+            "gnn_max_gpu_knn_nodes": gnn_max_gpu_nodes,
+            "gnn_knn_gpu_mem_ratio": gnn_gpu_mem_ratio,
+            "gnn_knn_gpu_mem_overhead": gnn_gpu_mem_overhead,
+            "region_province_col": region_province_col,
+            "region_city_col": region_city_col,
+            "region_effect_alpha": region_effect_alpha,
+            "geo_feature_nmes": geo_feature_nmes,
+            "geo_token_hidden_dim": geo_token_hidden_dim,
+            "geo_token_layers": geo_token_layers,
+            "geo_token_dropout": geo_token_dropout,
+            "geo_token_k_neighbors": geo_token_k_neighbors,
+            "geo_token_learning_rate": geo_token_learning_rate,
+            "geo_token_epochs": geo_token_epochs,
+            "ft_role": ft_role,
+            "ft_feature_prefix": ft_feature_prefix,
+            "ft_num_numeric_tokens": ft_num_numeric_tokens,
+            "reuse_best_params": reuse_best_params,
+            "bo_sample_limit": bo_sample_limit,
+            "cache_predictions": cache_predictions,
+            "prediction_cache_dir": prediction_cache_dir,
+            "prediction_cache_format": prediction_cache_format,
+            "cv_strategy": cv_strategy or split_strategy,
+            "cv_group_col": cv_group_col or split_group_col,
+            "cv_time_col": cv_time_col or split_time_col,
+            "cv_time_ascending": cv_time_ascending,
+            "cv_splits": cv_splits,
+            "ft_oof_folds": ft_oof_folds,
+            "ft_oof_strategy": ft_oof_strategy,
+            "ft_oof_shuffle": ft_oof_shuffle,
+            "save_preprocess": save_preprocess,
+            "preprocess_artifact_path": preprocess_artifact_path,
+            "plot_path_style": plot_path_style or "nested",
+        })
+        config_payload = {
+            k: v for k, v in config_payload.items() if v is not None}
+        config = ropt.BayesOptConfig(**config_payload)
+        model = ropt.BayesOptModel(train_df, test_df, config=config)
 
         if plot_requested:
             plot_cfg = cfg.get("plot", {})

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/modelling/core/bayesopt/models/model_ft_trainer.py

@@ -626,6 +626,7 @@ class FTTransformerSklearn(TorchTrainerMixin, nn.Module):
         best_state = None
         patience_counter = 0
         is_ddp_model = isinstance(self.ft, DDP)
+        use_collectives = dist.is_initialized() and is_ddp_model
 
         clip_fn = None
         if self.device.type == 'cuda':
@@ -669,7 +670,7 @@ class FTTransformerSklearn(TorchTrainerMixin, nn.Module):
                             device=X_num_b.device)
                         local_bad = 0 if bool(torch.isfinite(batch_loss)) else 1
                         global_bad = local_bad
-                        if dist.is_initialized():
+                        if use_collectives:
                             bad = torch.tensor(
                                 [local_bad],
                                 device=batch_loss.device,
@@ -774,7 +775,7 @@ class FTTransformerSklearn(TorchTrainerMixin, nn.Module):
                             total_n += float(end - start)
                     val_loss_tensor[0] = total_val / max(total_n, 1.0)
 
-                if dist.is_initialized():
+                if use_collectives:
                     dist.broadcast(val_loss_tensor, src=0)
                 val_loss_value = float(val_loss_tensor.item())
                 prune_now = False
@@ -806,7 +807,7 @@ class FTTransformerSklearn(TorchTrainerMixin, nn.Module):
                     if trial.should_prune():
                         prune_now = True
 
-                if dist.is_initialized():
+                if use_collectives:
                     flag = torch.tensor(
                         [1 if prune_now else 0],
                         device=loss_tensor_device,

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/modelling/core/bayesopt/models/model_gnn.py

@@ -42,6 +42,12 @@ _GNN_MPS_WARNED = False
 # Simplified GNN implementation.
 # =============================================================================
 
+def _adj_mm(adj: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
+    """Matrix multiply that supports sparse or dense adjacency."""
+    if adj.is_sparse:
+        return torch.sparse.mm(adj, x)
+    return adj.matmul(x)
+
 
 class SimpleGraphLayer(nn.Module):
     def __init__(self, in_dim: int, out_dim: int, dropout: float = 0.1):
@@ -52,7 +58,7 @@ class SimpleGraphLayer(nn.Module):
 
     def forward(self, x: torch.Tensor, adj: torch.Tensor) -> torch.Tensor:
         # Message passing with normalized sparse adjacency: A_hat * X * W.
-        h = torch.sparse.mm(adj, x)
+        h = _adj_mm(adj, x)
         h = self.linear(h)
         h = self.activation(h)
         return self.dropout(h)
@@ -86,7 +92,7 @@ class SimpleGNN(nn.Module):
         h = x
         for layer in self.layers:
             h = layer(h, adj_used)
-        h = torch.sparse.mm(adj_used, h)
+        h = _adj_mm(adj_used, h)
         out = self.output(h)
         return self.output_act(out)
 
@@ -124,7 +130,11 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
         self.knn_gpu_mem_ratio = max(0.0, min(1.0, knn_gpu_mem_ratio))
         self.knn_gpu_mem_overhead = max(1.0, knn_gpu_mem_overhead)
         self.knn_cpu_jobs = knn_cpu_jobs
+        self.mps_dense_max_nodes = int(
+            os.environ.get("BAYESOPT_GNN_MPS_DENSE_MAX_NODES", "5000")
+        )
         self._knn_warning_emitted = False
+        self._mps_fallback_triggered = False
         self._adj_cache_meta: Optional[Dict[str, Any]] = None
         self._adj_cache_key: Optional[Tuple[Any, ...]] = None
         self._adj_cache_tensor: Optional[torch.Tensor] = None
@@ -168,11 +178,11 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             else:
                 self.device = torch.device('cuda')
         elif torch.backends.mps.is_available():
-            self.device = torch.device('cpu')
+            self.device = torch.device('mps')
             global _GNN_MPS_WARNED
             if not _GNN_MPS_WARNED:
                 print(
-                    "[GNN] MPS backend does not support sparse ops; falling back to CPU.",
+                    "[GNN] Using MPS backend; will fall back to CPU on unsupported ops.",
                     flush=True,
                 )
                 _GNN_MPS_WARNED = True
@@ -235,6 +245,41 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
         else:
             base.register_buffer("adj_buffer", adj)
 
+    @staticmethod
+    def _is_mps_unsupported_error(exc: BaseException) -> bool:
+        msg = str(exc).lower()
+        if "mps" not in msg:
+            return False
+        if any(token in msg for token in ("not supported", "not implemented", "does not support", "unimplemented", "out of memory")):
+            return True
+        return "sparse" in msg
+
+    def _fallback_to_cpu(self, reason: str) -> None:
+        if self.device.type != "mps" or self._mps_fallback_triggered:
+            return
+        self._mps_fallback_triggered = True
+        print(f"[GNN] MPS op unsupported ({reason}); falling back to CPU.", flush=True)
+        self.device = torch.device("cpu")
+        self.use_pyg_knn = False
+        self.data_parallel_enabled = False
+        self.ddp_enabled = False
+        base = self._unwrap_gnn()
+        try:
+            base = base.to(self.device)
+        except Exception:
+            pass
+        self.gnn = base
+        self.invalidate_graph_cache()
+
+    def _run_with_mps_fallback(self, fn, *args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except (RuntimeError, NotImplementedError) as exc:
+            if self.device.type == "mps" and self._is_mps_unsupported_error(exc):
+                self._fallback_to_cpu(str(exc))
+                return fn(*args, **kwargs)
+            raise
+
     def _graph_cache_meta(self, X_df: pd.DataFrame) -> Dict[str, Any]:
         row_hash = pd.util.hash_pandas_object(X_df, index=False).values
         idx_hash = pd.util.hash_pandas_object(X_df.index, index=False).values
@@ -255,11 +300,14 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             "knn_gpu_mem_ratio": float(self.knn_gpu_mem_ratio),
             "knn_gpu_mem_overhead": float(self.knn_gpu_mem_overhead),
         }
+        adj_format = "dense" if self.device.type == "mps" else "sparse"
         return {
             "n_samples": int(X_df.shape[0]),
             "n_features": int(X_df.shape[1]),
             "hash": hasher.hexdigest(),
             "knn_config": knn_config,
+            "adj_format": adj_format,
+            "device_type": self.device.type,
         }
 
     def _graph_cache_key(self, X_df: pd.DataFrame) -> Tuple[Any, ...]:
@@ -284,8 +332,7 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             if meta_expected is None:
                 meta_expected = self._graph_cache_meta(X_df)
             try:
-                payload = torch.load(self.graph_cache_path,
-                                     map_location=self.device)
+                payload = torch.load(self.graph_cache_path, map_location="cpu")
             except Exception as exc:
                 print(
                     f"[GNN] Failed to load cached graph from {self.graph_cache_path}: {exc}")
@@ -293,7 +340,13 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             if isinstance(payload, dict) and "adj" in payload:
                 meta_cached = payload.get("meta")
                 if meta_cached == meta_expected:
-                    return payload["adj"].to(self.device)
+                    adj = payload["adj"]
+                    if self.device.type == "mps" and getattr(adj, "is_sparse", False):
+                        print(
+                            f"[GNN] Cached sparse graph incompatible with MPS; rebuilding: {self.graph_cache_path}"
+                        )
+                        return None
+                    return adj.to(self.device)
                 print(
                     f"[GNN] Cached graph metadata mismatch; rebuilding: {self.graph_cache_path}")
                 return None
@@ -408,6 +461,11 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
         return True
 
     def _normalized_adj(self, edge_index: torch.Tensor, num_nodes: int) -> torch.Tensor:
+        if self.device.type == "mps":
+            return self._normalized_adj_dense(edge_index, num_nodes)
+        return self._normalized_adj_sparse(edge_index, num_nodes)
+
+    def _normalized_adj_sparse(self, edge_index: torch.Tensor, num_nodes: int) -> torch.Tensor:
         values = torch.ones(edge_index.shape[1], device=self.device)
         adj = torch.sparse_coo_tensor(
             edge_index.to(self.device), values, (num_nodes, num_nodes))
@@ -421,6 +479,21 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             adj.indices(), norm_values, size=adj.shape)
         return adj_norm
 
+    def _normalized_adj_dense(self, edge_index: torch.Tensor, num_nodes: int) -> torch.Tensor:
+        if self.mps_dense_max_nodes <= 0 or num_nodes > self.mps_dense_max_nodes:
+            raise RuntimeError(
+                f"MPS dense adjacency not supported for {num_nodes} nodes; "
+                f"max={self.mps_dense_max_nodes}. Falling back to CPU."
+            )
+        edge_index = edge_index.to(self.device)
+        adj = torch.zeros((num_nodes, num_nodes), device=self.device, dtype=torch.float32)
+        adj[edge_index[0], edge_index[1]] = 1.0
+        deg = adj.sum(dim=1)
+        deg_inv_sqrt = torch.pow(deg + 1e-8, -0.5)
+        adj = adj * deg_inv_sqrt.view(-1, 1)
+        adj = adj * deg_inv_sqrt.view(1, -1)
+        return adj
+
     def _tensorize_split(self, X, y, w, allow_none: bool = False):
         if X is None and allow_none:
             return None, None, None
@@ -462,17 +535,25 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
             if self._adj_cache_meta == meta_expected and self._adj_cache_tensor is not None:
                 cached = self._adj_cache_tensor
                 if cached.device != self.device:
-                    cached = cached.to(self.device)
-                    self._adj_cache_tensor = cached
-                return cached
+                    if self.device.type == "mps" and getattr(cached, "is_sparse", False):
+                        self._adj_cache_tensor = None
+                    else:
+                        cached = cached.to(self.device)
+                        self._adj_cache_tensor = cached
+                if self._adj_cache_tensor is not None:
+                    return self._adj_cache_tensor
         else:
             cache_key = self._graph_cache_key(X_df)
             if self._adj_cache_key == cache_key and self._adj_cache_tensor is not None:
                 cached = self._adj_cache_tensor
                 if cached.device != self.device:
-                    cached = cached.to(self.device)
-                    self._adj_cache_tensor = cached
-                return cached
+                    if self.device.type == "mps" and getattr(cached, "is_sparse", False):
+                        self._adj_cache_tensor = None
+                    else:
+                        cached = cached.to(self.device)
+                        self._adj_cache_tensor = cached
+                if self._adj_cache_tensor is not None:
+                    return self._adj_cache_tensor
         X_np = None
         if X_tensor is None:
             X_np = X_df.to_numpy(dtype=np.float32, copy=False)
@@ -511,7 +592,20 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
     def fit(self, X_train, y_train, w_train=None,
             X_val=None, y_val=None, w_val=None,
             trial: Optional[optuna.trial.Trial] = None):
+        return self._run_with_mps_fallback(
+            self._fit_impl,
+            X_train,
+            y_train,
+            w_train,
+            X_val,
+            y_val,
+            w_val,
+            trial,
+        )
 
+    def _fit_impl(self, X_train, y_train, w_train=None,
+                  X_val=None, y_val=None, w_val=None,
+                  trial: Optional[optuna.trial.Trial] = None):
         X_train_tensor, y_train_tensor, w_train_tensor = self._tensorize_split(
             X_train, y_train, w_train, allow_none=False)
         has_val = X_val is not None and y_val is not None
@@ -621,6 +715,9 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
         self.best_epoch = int(best_epoch or self.epochs)
 
     def predict(self, X: pd.DataFrame) -> np.ndarray:
+        return self._run_with_mps_fallback(self._predict_impl, X)
+
+    def _predict_impl(self, X: pd.DataFrame) -> np.ndarray:
         self.gnn.eval()
         X_tensor, _, _ = self._tensorize_split(
             X, None, None, allow_none=False)
@@ -640,6 +737,9 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
         return y_pred.ravel()
 
     def encode(self, X: pd.DataFrame) -> np.ndarray:
+        return self._run_with_mps_fallback(self._encode_impl, X)
+
+    def _encode_impl(self, X: pd.DataFrame) -> np.ndarray:
         """Return per-sample node embeddings (hidden representations)."""
         base = self._unwrap_gnn()
         base.eval()
@@ -655,7 +755,7 @@ class GraphNeuralNetSklearn(TorchTrainerMixin, nn.Module):
                 raise RuntimeError("GNN base module does not expose layers.")
             for layer in layers:
                 h = layer(h, adj)
-            h = torch.sparse.mm(adj, h)
+            h = _adj_mm(adj, h)
         return h.detach().cpu().numpy()
 
     def set_params(self, params: Dict[str, Any]):

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/modelling/core/bayesopt/trainers/trainer_base.py

@@ -27,6 +27,7 @@ from sklearn.preprocessing import StandardScaler
 from ..config_preprocess import BayesOptConfig, OutputManager
 from ..utils import DistributedUtils, EPS, ensure_parent_dir
 from ins_pricing.utils import get_logger, GPUMemoryManager, DeviceManager
+from ins_pricing.utils.torch_compat import torch_load
 
 # Module-level logger
 _logger = get_logger("ins_pricing.trainer")
@@ -616,7 +617,7 @@ class TrainerBase:
                 pass
             else:
                 # FT-Transformer: load state_dict and reconstruct model
-                loaded = torch.load(path, map_location='cpu', weights_only=False)
+                loaded = torch_load(path, map_location='cpu', weights_only=False)
                 if isinstance(loaded, dict):
                     if "state_dict" in loaded and "model_config" in loaded:
                         # New format: state_dict + model_config
@@ -1094,7 +1095,7 @@ class TrainerBase:
                 split_iter = splitter
 
         losses: List[float] = []
-        for train_idx, val_idx in split_iter:
+        for fold_idx, (train_idx, val_idx) in enumerate(split_iter):
             X_train = X_all.iloc[train_idx]
             y_train = y_all.iloc[train_idx]
             X_val = X_all.iloc[val_idx]
@@ -1108,9 +1109,11 @@ class TrainerBase:
             model = model_builder(params)
             try:
                 if fit_predict_fn:
+                    # Avoid duplicate Optuna step reports across folds.
+                    trial_for_fold = trial if fold_idx == 0 else None
                     y_pred = fit_predict_fn(
                         model, X_train, y_train, w_train,
-                        X_val, y_val, w_val, trial
+                        X_val, y_val, w_val, trial_for_fold
                     )
                 else:
                     fit_kwargs = {}
@@ -1288,4 +1291,3 @@ class TrainerBase:
             predict_kwargs_train=predict_kwargs_train,
             predict_kwargs_test=predict_kwargs_test,
             predict_fn=predict_fn)
-

{ins_pricing-0.3.0 → ins_pricing-0.3.2}/ins_pricing/modelling/core/bayesopt/trainers/trainer_gnn.py

@@ -12,6 +12,7 @@ from .trainer_base import TrainerBase
 from ..models import GraphNeuralNetSklearn
 from ..utils import EPS
 from ins_pricing.utils import get_logger
+from ins_pricing.utils.torch_compat import torch_load
 
 _logger = get_logger("ins_pricing.trainer.gnn")
 
@@ -300,7 +301,7 @@ class GNNTrainer(TrainerBase):
         if not os.path.exists(path):
             print(f"[load] Warning: Model file not found: {path}")
             return
-        payload = torch.load(path, map_location='cpu', weights_only=False)
+        payload = torch_load(path, map_location='cpu', weights_only=False)
         if not isinstance(payload, dict):
             raise ValueError(f"Invalid GNN checkpoint: {path}")
         params = payload.get("best_params") or {}
@@ -322,4 +323,3 @@ class GNNTrainer(TrainerBase):
         self.model = model
         self.best_params = dict(params) if isinstance(params, dict) else None
         self.ctx.gnn_best = self.model
-