ins-pricing 0.1.8__tar.gz → 0.1.11__tar.gz

{ins_pricing-0.1.8/Ins_Pricing.egg-info → ins_pricing-0.1.11}/PKG-INFO

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

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/ins_pricing/modelling/BayesOpt_entry.py

@@ -250,22 +250,46 @@ def _plot_curves_for_model(model: ropt.BayesOptModel, trained_keys: List[str], c
         [m for m in trained_keys if m in PLOT_MODEL_LABELS]
     )
 
-    if oneway_enabled:
-        model.plot_oneway(n_bins=n_bins)
-
-    if not available_models:
-        return
-
     lift_models = plot_cfg.get("lift_models")
     if lift_models is None:
-        lift_models = [
-            m for m, enabled in legacy_lift_flags.items() if enabled]
+        lift_models = [m for m, enabled in legacy_lift_flags.items() if enabled]
         if not lift_models:
             lift_models = available_models
     lift_models = dedupe_preserve_order(
         [m for m in lift_models if m in available_models]
     )
 
+    if oneway_enabled:
+        oneway_pred = bool(plot_cfg.get("oneway_pred", False))
+        oneway_pred_models = plot_cfg.get("oneway_pred_models")
+        pred_plotted = False
+        if oneway_pred:
+            if oneway_pred_models is None:
+                oneway_pred_models = lift_models or available_models
+            oneway_pred_models = dedupe_preserve_order(
+                [m for m in oneway_pred_models if m in available_models]
+            )
+            for model_key in oneway_pred_models:
+                label, pred_nme = PLOT_MODEL_LABELS[model_key]
+                if pred_nme not in model.train_data.columns:
+                    print(
+                        f"[Oneway] Missing prediction column '{pred_nme}'; skip.",
+                        flush=True,
+                    )
+                    continue
+                model.plot_oneway(
+                    n_bins=n_bins,
+                    pred_col=pred_nme,
+                    pred_label=label,
+                    plot_subdir="oneway/post",
+                )
+                pred_plotted = True
+        if not oneway_pred or not pred_plotted:
+            model.plot_oneway(n_bins=n_bins, plot_subdir="oneway/post")
+
+    if not available_models:
+        return
+
     for model_key in lift_models:
         label, pred_nme = PLOT_MODEL_LABELS[model_key]
         model.plot_lift(model_label=label, pred_nme=pred_nme, n_bins=n_bins)
@@ -302,10 +326,10 @@ def _plot_loss_curve_for_trainer(model_name: str, trainer) -> None:
         return
     try:
         plot_dir = trainer.output.plot_path(
-            f"loss_{model_name}_{trainer.model_name_prefix}.png"
+            f"{model_name}/loss/loss_{model_name}_{trainer.model_name_prefix}.png"
         )
     except Exception:
-        default_dir = Path("plot")
+        default_dir = Path("plot") / model_name / "loss"
         default_dir.mkdir(parents=True, exist_ok=True)
         plot_dir = str(
             default_dir / f"loss_{model_name}_{trainer.model_name_prefix}.png")
@@ -504,6 +528,19 @@ def train_from_config(args: argparse.Namespace) -> None:
             reuse_best_params=reuse_best_params,
         )
 
+        if plot_requested:
+            plot_cfg = cfg.get("plot", {})
+            legacy_lift_flags = {
+                "glm": cfg.get("plot_lift_glm", False),
+                "xgb": cfg.get("plot_lift_xgb", False),
+                "resn": cfg.get("plot_lift_resn", False),
+                "ft": cfg.get("plot_lift_ft", False),
+            }
+            plot_enabled = plot_cfg.get("enable", any(legacy_lift_flags.values()))
+            if plot_enabled and plot_cfg.get("pre_oneway", False) and plot_cfg.get("oneway", True):
+                n_bins = int(plot_cfg.get("n_bins", 10))
+                model.plot_oneway(n_bins=n_bins, plot_subdir="oneway/pre")
+
         if "all" in args.model_keys:
             requested_keys = ["glm", "xgb", "resn", "ft", "gnn"]
         else:
@@ -547,14 +584,14 @@ def train_from_config(args: argparse.Namespace) -> None:
             trainer = model.trainers[key]
             trainer_uses_ddp = bool(
                 getattr(trainer, "enable_distributed_optuna", False))
-            should_run = True
             if dist_active and not trainer_uses_ddp:
-                should_run = dist_rank == 0
-                if not should_run:
+                if dist_rank != 0:
                     print(
                         f"[Rank {dist_rank}] Skip {model_name}/{key} because trainer is not DDP-enabled."
                     )
-                    _ddp_barrier(f"skip_non_ddp_{model_name}_{key}")
+                _ddp_barrier(f"start_non_ddp_{model_name}_{key}")
+                if dist_rank != 0:
+                    _ddp_barrier(f"finish_non_ddp_{model_name}_{key}")
                     continue
 
             print(

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/ins_pricing/modelling/BayesOpt_incremental.py

@@ -285,16 +285,43 @@ def _plot_curves_for_model(model: ropt.BayesOptModel, trained: List[str], cfg: D
     oneway_enabled = plot_cfg.get("oneway", True)
     available = dedupe_preserve_order([k for k in trained if k in PLOT_MODEL_LABELS])
 
-    if oneway_enabled:
-        model.plot_oneway(n_bins=n_bins)
-    if not available:
-        return
-
     lift_models = plot_cfg.get("lift_models")
     if lift_models is None:
-        lift_models = [m for m, flag in legacy_flags.items() if flag] or available
+        lift_models = [m for m, flag in legacy_flags.items() if flag]
+        if not lift_models:
+            lift_models = available
     lift_models = dedupe_preserve_order([m for m in lift_models if m in available])
 
+    if oneway_enabled:
+        oneway_pred = bool(plot_cfg.get("oneway_pred", False))
+        oneway_pred_models = plot_cfg.get("oneway_pred_models")
+        pred_plotted = False
+        if oneway_pred:
+            if oneway_pred_models is None:
+                oneway_pred_models = lift_models or available
+            oneway_pred_models = dedupe_preserve_order(
+                [m for m in oneway_pred_models if m in available]
+            )
+            for model_key in oneway_pred_models:
+                label, pred_nme = PLOT_MODEL_LABELS[model_key]
+                if pred_nme not in model.train_data.columns:
+                    print(
+                        f"[Oneway] Missing prediction column '{pred_nme}'; skip.",
+                        flush=True,
+                    )
+                    continue
+                model.plot_oneway(
+                    n_bins=n_bins,
+                    pred_col=pred_nme,
+                    pred_label=label,
+                    plot_subdir="oneway/post",
+                )
+                pred_plotted = True
+        if not oneway_pred or not pred_plotted:
+            model.plot_oneway(n_bins=n_bins, plot_subdir="oneway/post")
+    if not available:
+        return
+
     for key in lift_models:
         label, pred_nme = PLOT_MODEL_LABELS[key]
         model.plot_lift(model_label=label, pred_nme=pred_nme, n_bins=n_bins)
@@ -558,6 +585,19 @@ class IncrementalUpdateRunner:
             infer_categorical_max_ratio=float(self.cfg.get("infer_categorical_max_ratio", 0.05)),
         )
 
+        if self.plot_requested and not self.args.dry_run:
+            plot_cfg = self.cfg.get("plot", {})
+            legacy_flags = {
+                "glm": self.cfg.get("plot_lift_glm", False),
+                "xgb": self.cfg.get("plot_lift_xgb", False),
+                "resn": self.cfg.get("plot_lift_resn", False),
+                "ft": self.cfg.get("plot_lift_ft", False),
+            }
+            plot_enabled = plot_cfg.get("enable", any(legacy_flags.values()))
+            if plot_enabled and plot_cfg.get("pre_oneway", False) and plot_cfg.get("oneway", True):
+                n_bins = int(plot_cfg.get("n_bins", 10))
+                model.plot_oneway(n_bins=n_bins, plot_subdir="oneway/pre")
+
         requested_keys = self._requested_model_keys(model.trainers)
         executed_keys: List[str] = []
         param_sources: Dict[str, str] = {}

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/ins_pricing/modelling/bayesopt/core.py

@@ -474,10 +474,39 @@ class BayesOptModel:
             ]
 
     # Single-factor plotting helper.
-    def plot_oneway(self, n_bins=10):
+    def plot_oneway(
+        self,
+        n_bins=10,
+        pred_col: Optional[str] = None,
+        pred_label: Optional[str] = None,
+        pred_weighted: Optional[bool] = None,
+        plot_subdir: Optional[str] = None,
+    ):
         if plt is None and plot_diagnostics is None:
             _plot_skip("oneway plot")
             return
+        if pred_col is not None and pred_col not in self.train_data.columns:
+            print(
+                f"[Oneway] Missing prediction column '{pred_col}'; skip predicted line.",
+                flush=True,
+            )
+            pred_col = None
+        if pred_weighted is None and pred_col is not None:
+            pred_weighted = pred_col.startswith("w_pred_")
+        if pred_weighted is None:
+            pred_weighted = False
+        plot_subdir = plot_subdir.strip("/\\") if plot_subdir else "oneway"
+        plot_prefix = f"{self.model_nme}/{plot_subdir}"
+
+        def _safe_tag(value: str) -> str:
+            return (
+                value.strip()
+                .replace(" ", "_")
+                .replace("/", "_")
+                .replace("\\", "_")
+                .replace(":", "_")
+            )
+
         if plot_diagnostics is None:
             for c in self.factor_nmes:
                 fig = plt.figure(figsize=(7, 5))
@@ -492,14 +521,32 @@ class BayesOptModel:
                         duplicates='drop'  # Drop duplicate quantiles to avoid errors.
                     )
                     plot_source = self.train_data.assign(**{group_col: bins})
+                if pred_col is not None and pred_col in plot_source.columns:
+                    if pred_weighted:
+                        plot_source = plot_source.assign(
+                            _pred_w=plot_source[pred_col]
+                        )
+                    else:
+                        plot_source = plot_source.assign(
+                            _pred_w=plot_source[pred_col] * plot_source[self.weight_nme]
+                        )
                 plot_data = plot_source.groupby(
                     [group_col], observed=True).sum(numeric_only=True)
                 plot_data.reset_index(inplace=True)
                 plot_data['act_v'] = plot_data['w_act'] / \
                     plot_data[self.weight_nme]
+                if pred_col is not None and "_pred_w" in plot_data.columns:
+                    plot_data["pred_v"] = plot_data["_pred_w"] / plot_data[self.weight_nme]
                 ax = fig.add_subplot(111)
                 ax.plot(plot_data.index, plot_data['act_v'],
                         label='Actual', color='red')
+                if pred_col is not None and "pred_v" in plot_data.columns:
+                    ax.plot(
+                        plot_data.index,
+                        plot_data["pred_v"],
+                        label=pred_label or "Predicted",
+                        color="tab:blue",
+                    )
                 ax.set_title(
                     'Analysis of  %s : Train Data' % group_col,
                     fontsize=8)
@@ -518,8 +565,15 @@ class BayesOptModel:
                 plt.yticks(fontsize=6)
                 plt.margins(0.05)
                 plt.subplots_adjust(wspace=0.3)
+                if pred_col is not None and "pred_v" in plot_data.columns:
+                    ax.legend(fontsize=6)
+                pred_tag = _safe_tag(pred_label or pred_col) if pred_col else None
+                if pred_tag:
+                    filename = f'00_{self.model_nme}_{group_col}_oneway_{pred_tag}.png'
+                else:
+                    filename = f'00_{self.model_nme}_{group_col}_oneway.png'
                 save_path = self.output_manager.plot_path(
-                    f'00_{self.model_nme}_{group_col}_oneway.png')
+                    f'{plot_prefix}/{filename}')
                 plt.savefig(save_path, dpi=300)
                 plt.close(fig)
             return
@@ -532,14 +586,22 @@ class BayesOptModel:
             is_cat = c in (self.cate_list or [])
             group_col = c if is_cat else f"{c}_bins"
             title = f"Analysis of {group_col} : Train Data"
+            pred_tag = _safe_tag(pred_label or pred_col) if pred_col else None
+            if pred_tag:
+                filename = f"00_{self.model_nme}_{group_col}_oneway_{pred_tag}.png"
+            else:
+                filename = f"00_{self.model_nme}_{group_col}_oneway.png"
             save_path = self.output_manager.plot_path(
-                f"00_{self.model_nme}_{group_col}_oneway.png"
+                f"{plot_prefix}/{filename}"
             )
             plot_diagnostics.plot_oneway(
                 self.train_data,
                 feature=c,
                 weight_col=self.weight_nme,
                 target_col="w_act",
+                pred_col=pred_col,
+                pred_weighted=pred_weighted,
+                pred_label=pred_label,
                 n_bins=n_bins,
                 is_categorical=is_cat,
                 title=title,
@@ -855,6 +917,15 @@ class BayesOptModel:
             if model_label.startswith(k):
                 pred_nme = v
                 break
+        safe_label = (
+            str(model_label)
+            .replace(" ", "_")
+            .replace("/", "_")
+            .replace("\\", "_")
+            .replace(":", "_")
+        )
+        plot_prefix = f"{self.model_nme}/lift"
+        filename = f"01_{self.model_nme}_{safe_label}_lift.png"
 
         datasets = []
         for title, data in [
@@ -900,7 +971,7 @@ class BayesOptModel:
 
             plt.subplots_adjust(wspace=0.3)
             save_path = self.output_manager.plot_path(
-                f'01_{self.model_nme}_{model_label}_lift.png')
+                f"{plot_prefix}/{filename}")
             plt.savefig(save_path, dpi=300)
             plt.show()
             plt.close(fig)
@@ -945,7 +1016,7 @@ class BayesOptModel:
 
         plt.subplots_adjust(wspace=0.3)
         save_path = self.output_manager.plot_path(
-            f'01_{self.model_nme}_{model_label}_lift.png')
+            f"{plot_prefix}/{filename}")
         if finalize_figure:
             finalize_figure(fig, save_path=save_path, show=True, style=style)
         else:
@@ -977,6 +1048,8 @@ class BayesOptModel:
         name1, name2 = model_comp
         if name1 not in model_name_map or name2 not in model_name_map:
             raise ValueError(f"Unsupported model key. Choose from {list(model_name_map.keys())}.")
+        plot_prefix = f"{self.model_nme}/double_lift"
+        filename = f"02_{self.model_nme}_dlift_{name1}_vs_{name2}.png"
 
         datasets = []
         for data_name, data in [('Train Data', self.train_data),
@@ -1030,7 +1103,7 @@ class BayesOptModel:
 
             plt.subplots_adjust(bottom=0.25, top=0.95, right=0.8, wspace=0.3)
             save_path = self.output_manager.plot_path(
-                f'02_{self.model_nme}_dlift_{name1}_vs_{name2}.png')
+                f"{plot_prefix}/{filename}")
             plt.savefig(save_path, dpi=300)
             plt.show()
             plt.close(fig)
@@ -1089,7 +1162,7 @@ class BayesOptModel:
 
         plt.subplots_adjust(bottom=0.25, top=0.95, right=0.8, wspace=0.3)
         save_path = self.output_manager.plot_path(
-            f'02_{self.model_nme}_dlift_{name1}_vs_{name2}.png')
+            f"{plot_prefix}/{filename}")
         if finalize_figure:
             finalize_figure(fig, save_path=save_path, show=True, style=style)
         else:

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/ins_pricing/modelling/bayesopt/trainers.py

@@ -1733,7 +1733,7 @@ class ResNetTrainer(TrainerBase):
             self.model.epochs = int(refit_epochs)
         self.best_params = params
         loss_plot_path = self.output.plot_path(
-            f'loss_{self.ctx.model_nme}_{self.model_name_prefix}.png')
+            f'{self.ctx.model_nme}/loss/loss_{self.ctx.model_nme}_{self.model_name_prefix}.png')
         self.model.loss_curve_path = loss_plot_path
 
         self._fit_predict_cache(
@@ -2190,7 +2190,7 @@ class FTTrainer(TrainerBase):
         self.model.set_params(resolved_params)
         self.best_params = resolved_params
         loss_plot_path = self.output.plot_path(
-            f'loss_{self.ctx.model_nme}_{self.model_name_prefix}.png')
+            f'{self.ctx.model_nme}/loss/loss_{self.ctx.model_nme}_{self.model_name_prefix}.png')
         self.model.loss_curve_path = loss_plot_path
         geo_train = self.ctx.train_geo_tokens
         geo_test = self.ctx.test_geo_tokens
@@ -2395,7 +2395,7 @@ class FTTrainer(TrainerBase):
             self.model.set_params(resolved_params)
 
         loss_plot_path = self.output.plot_path(
-            f'loss_{self.ctx.model_nme}_FTTransformerUnsupervised.png')
+            f'{self.ctx.model_nme}/loss/loss_{self.ctx.model_nme}_FTTransformerUnsupervised.png')
         self.model.loss_curve_path = loss_plot_path
 
         # Build a simple holdout split for pretraining early stopping.

{ins_pricing-0.1.8/ins_pricing_gemini → ins_pricing-0.1.11/ins_pricing}/modelling/plotting/diagnostics.py

@@ -72,6 +72,9 @@ def plot_oneway(
     feature: str,
     weight_col: str,
     target_col: str,
+    pred_col: Optional[str] = None,
+    pred_weighted: bool = False,
+    pred_label: Optional[str] = None,
     n_bins: int = 10,
     is_categorical: bool = False,
     title: Optional[str] = None,
@@ -86,6 +89,8 @@ def plot_oneway(
         raise KeyError(f"weight_col '{weight_col}' not found in data.")
     if target_col not in df.columns:
         raise KeyError(f"target_col '{target_col}' not found in data.")
+    if pred_col is not None and pred_col not in df.columns:
+        raise KeyError(f"pred_col '{pred_col}' not found in data.")
 
     style = style or PlotStyle()
     title = title or f"Analysis of {feature}"
@@ -102,11 +107,21 @@ def plot_oneway(
             bins = pd.cut(series, bins=max(1, int(n_bins)), duplicates="drop")
         plot_source = df.assign(**{group_col: bins})
 
+    if pred_col is not None:
+        if pred_weighted:
+            plot_source = plot_source.assign(_pred_w=plot_source[pred_col])
+        else:
+            plot_source = plot_source.assign(
+                _pred_w=plot_source[pred_col] * plot_source[weight_col]
+            )
+
     plot_data = plot_source.groupby([group_col], observed=True).sum(numeric_only=True)
     plot_data.reset_index(inplace=True)
 
     denom = np.maximum(plot_data[weight_col].to_numpy(dtype=float), EPS)
     plot_data["act_v"] = plot_data[target_col].to_numpy(dtype=float) / denom
+    if pred_col is not None:
+        plot_data["pred_v"] = plot_data["_pred_w"].to_numpy(dtype=float) / denom
 
     created_fig = ax is None
     if created_fig:
@@ -115,6 +130,13 @@ def plot_oneway(
         fig = ax.figure
 
     ax.plot(plot_data.index, plot_data["act_v"], label="Actual", color="red")
+    if pred_col is not None:
+        ax.plot(
+            plot_data.index,
+            plot_data["pred_v"],
+            label=pred_label or "Predicted",
+            color=style.palette[0],
+        )
     ax.set_title(title, fontsize=style.title_size)
     ax.set_xticks(plot_data.index)
     labels = plot_data[group_col].astype(str).tolist()
@@ -123,6 +145,8 @@ def plot_oneway(
     ax.tick_params(axis="y", labelsize=style.tick_size)
     if style.grid:
         ax.grid(True, linestyle=style.grid_style, alpha=style.grid_alpha)
+    if pred_col is not None:
+        ax.legend(fontsize=style.legend_size)
 
     ax2 = ax.twinx()
     ax2.bar(

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/ins_pricing/setup.py

@@ -14,7 +14,7 @@ def _discover_packages() -> list[str]:
 
 setup(
     name="Ins-Pricing",
-    version="0.1.8",
+    version="0.1.11",
     description="Reusable modelling, pricing, governance, and reporting utilities.",
     author="meishi125478",
     license="Proprietary",

{ins_pricing-0.1.8 → ins_pricing-0.1.11/ins_pricing.egg-info}/PKG-INFO

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

{ins_pricing-0.1.8/Ins_Pricing.egg-info → ins_pricing-0.1.11/ins_pricing.egg-info}/SOURCES.txt

@@ -1,11 +1,6 @@
 MANIFEST.in
 README.md
 pyproject.toml
-Ins_Pricing.egg-info/PKG-INFO
-Ins_Pricing.egg-info/SOURCES.txt
-Ins_Pricing.egg-info/dependency_links.txt
-Ins_Pricing.egg-info/requires.txt
-Ins_Pricing.egg-info/top_level.txt
 ins_pricing/README.md
 ins_pricing/__init__.py
 ins_pricing/setup.py

{ins_pricing-0.1.8 → ins_pricing-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ins_pricing"
-version = "0.1.8"
+version = "0.1.11"
 description = "Reusable modelling, pricing, governance, and reporting utilities."
 readme = "README.md"
 requires-python = ">=3.9"