ins-pricing 0.1.11__py3-none-any.whl → 0.2.0__py3-none-any.whl

ins_pricing_gemini/modelling/tests/test_explain.py

@@ -1,56 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-
-
-def test_permutation_importance_simple():
-    from ins_pricing.explain import permutation_importance
-
-    rng = np.random.default_rng(0)
-    X = pd.DataFrame(
-        {
-            "x1": rng.normal(size=200),
-            "x2": rng.normal(size=200),
-        }
-    )
-    y = 3.0 * X["x1"].to_numpy() + rng.normal(scale=0.1, size=200)
-
-    def predict_fn(df):
-        return 3.0 * df["x1"].to_numpy()
-
-    imp = permutation_importance(
-        predict_fn,
-        X,
-        y,
-        metric="rmse",
-        n_repeats=3,
-        max_rows=None,
-        random_state=0,
-    )
-
-    assert imp.loc[0, "feature"] == "x1"
-    assert imp["importance_mean"].iloc[0] > imp["importance_mean"].iloc[1]
-
-
-def test_integrated_gradients_linear():
-    torch = pytest.importorskip("torch")
-    from ins_pricing.explain import integrated_gradients_torch
-
-    torch.manual_seed(0)
-    model = torch.nn.Linear(3, 1, bias=False)
-    with torch.no_grad():
-        model.weight[:] = torch.tensor([[1.0, 2.0, -1.0]])
-
-    X = torch.tensor(
-        [[1.0, 2.0, 3.0], [0.5, -1.0, 0.0]],
-        dtype=torch.float32,
-    )
-
-    def forward(x):
-        return model(x).squeeze(1)
-
-    attrs = integrated_gradients_torch(forward, X, baseline="zeros", steps=10)
-    expected = X.numpy() * np.array([1.0, 2.0, -1.0])
-
-    assert attrs.shape == X.shape
-    np.testing.assert_allclose(attrs, expected, rtol=1e-2, atol=1e-2)

ins_pricing_gemini/modelling/tests/test_geo_tokens_split.py

@@ -1,49 +0,0 @@
-import types
-
-import pandas as pd
-import pytest
-
-pytest.importorskip("torch")
-pytest.importorskip("optuna")
-pytest.importorskip("xgboost")
-pytest.importorskip("statsmodels")
-
-from ins_pricing.bayesopt.trainers import FTTrainer
-
-
-class DummyCtx:
-    def __init__(self, train_df: pd.DataFrame, test_df: pd.DataFrame):
-        self.task_type = "regression"
-        self.config = types.SimpleNamespace(use_ft_ddp=False, geo_feature_nmes=["geo"])
-        self.train_data = train_df
-        self.test_data = test_df
-        self._build_calls = []
-
-    def _build_geo_tokens(self, _params=None):
-        self._build_calls.append(
-            (self.train_data.copy(deep=True), self.test_data.copy(deep=True))
-        )
-        return self.train_data.copy(deep=True), self.test_data.copy(deep=True), ["geo_token"], None
-
-
-def test_geo_token_split_uses_fold_and_restores_context():
-    train = pd.DataFrame({"geo": ["a", "b", "c", "d"], "x": [1, 2, 3, 4]})
-    test = pd.DataFrame({"geo": ["e"], "x": [5]})
-    ctx = DummyCtx(train, test)
-    trainer = FTTrainer(ctx)
-
-    X_train = train.iloc[[0, 1]]
-    X_val = train.iloc[[2, 3]]
-
-    orig_train = ctx.train_data
-    orig_test = ctx.test_data
-
-    result = trainer._build_geo_tokens_for_split(X_train, X_val, geo_params={"k": 1})
-
-    assert ctx.train_data is orig_train
-    assert ctx.test_data is orig_test
-    assert result is not None
-
-    train_snapshot, test_snapshot = ctx._build_calls[0]
-    assert train_snapshot.equals(train.loc[X_train.index])
-    assert test_snapshot.equals(train.loc[X_val.index])

ins_pricing_gemini/modelling/tests/test_graph_cache.py

@@ -1,33 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-
-pytest.importorskip("torch")
-pytest.importorskip("sklearn")
-
-from ins_pricing.bayesopt.models import GraphNeuralNetSklearn
-
-
-def test_graph_cache_meta_invalidation(tmp_path):
-    X = pd.DataFrame({"a": [0.1, 0.2, 0.3], "b": [1.0, 2.0, 3.0]})
-    cache_path = tmp_path / "gnn_cache.pt"
-
-    model = GraphNeuralNetSklearn(
-        model_nme="demo",
-        input_dim=2,
-        k_neighbors=1,
-        epochs=1,
-        use_approx_knn=False,
-        graph_cache_path=str(cache_path),
-    )
-
-    adj = model._build_graph_from_df(X)
-    assert adj is not None
-    assert cache_path.exists()
-
-    cached = model._load_cached_adj(X)
-    assert cached is not None
-
-    X_changed = X.copy()
-    X_changed.iloc[0, 0] += 1.0
-    assert model._load_cached_adj(X_changed) is None

ins_pricing_gemini/modelling/tests/test_plotting_library.py

@@ -1,150 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-
-pytest.importorskip("matplotlib")
-pytest.importorskip("sklearn")
-
-
-def _configure_matplotlib(tmp_path, monkeypatch):
-    monkeypatch.setenv("MPLBACKEND", "Agg")
-    mpl_cfg = tmp_path / ".mplconfig"
-    cache_dir = tmp_path / ".cache"
-    (cache_dir / "fontconfig").mkdir(parents=True, exist_ok=True)
-    mpl_cfg.mkdir(parents=True, exist_ok=True)
-    monkeypatch.setenv("MPLCONFIGDIR", str(mpl_cfg))
-    monkeypatch.setenv("XDG_CACHE_HOME", str(cache_dir))
-
-
-def test_plotting_library_outputs(tmp_path, monkeypatch):
-    _configure_matplotlib(tmp_path, monkeypatch)
-
-    from ins_pricing.plotting import curves, diagnostics, geo, importance
-
-    rng = np.random.default_rng(42)
-    n = 80
-    pred1 = rng.normal(loc=0.2, scale=1.0, size=n)
-    pred2 = rng.normal(loc=0.1, scale=1.0, size=n)
-    actual = np.abs(rng.normal(loc=1.0, scale=0.5, size=n))
-    weight = rng.uniform(0.5, 2.0, size=n)
-
-    curves.plot_lift_curve(
-        pred1,
-        actual * weight,
-        weight,
-        n_bins=8,
-        save_path=str(tmp_path / "lift.png"),
-    )
-    curves.plot_double_lift_curve(
-        pred1,
-        pred2,
-        actual * weight,
-        weight,
-        n_bins=8,
-        save_path=str(tmp_path / "dlift.png"),
-    )
-
-    y_true = rng.integers(0, 2, size=n)
-    curves.plot_roc_curves(
-        y_true,
-        {"m1": pred1, "m2": pred2},
-        save_path=str(tmp_path / "roc.png"),
-    )
-
-    importance.plot_feature_importance(
-        {"x1": 0.3, "x2": 0.1, "x3": 0.05},
-        save_path=str(tmp_path / "importance.png"),
-    )
-
-    diagnostics.plot_loss_curve(
-        history={"train": [1.0, 0.7, 0.5], "val": [1.2, 0.8, 0.6]},
-        save_path=str(tmp_path / "loss.png"),
-    )
-    diagnostics.plot_oneway(
-        pd.DataFrame(
-            {
-                "x1": rng.normal(size=n),
-                "w_act": actual * weight,
-                "w": weight,
-            }
-        ),
-        feature="x1",
-        weight_col="w",
-        target_col="w_act",
-        n_bins=6,
-        save_path=str(tmp_path / "oneway.png"),
-    )
-
-    df_geo = pd.DataFrame(
-        {
-            "lon": rng.uniform(100, 120, size=n),
-            "lat": rng.uniform(20, 40, size=n),
-            "loss": actual,
-        }
-    )
-    geo.plot_geo_heatmap(
-        df_geo,
-        x_col="lon",
-        y_col="lat",
-        value_col="loss",
-        bins=10,
-        save_path=str(tmp_path / "geo_heat.png"),
-    )
-    geo.plot_geo_contour(
-        df_geo,
-        x_col="lon",
-        y_col="lat",
-        value_col="loss",
-        max_points=40,
-        levels=6,
-        save_path=str(tmp_path / "geo_contour.png"),
-    )
-
-    assert (tmp_path / "lift.png").exists()
-    assert (tmp_path / "dlift.png").exists()
-    assert (tmp_path / "roc.png").exists()
-    assert (tmp_path / "importance.png").exists()
-    assert (tmp_path / "loss.png").exists()
-    assert (tmp_path / "oneway.png").exists()
-    assert (tmp_path / "geo_heat.png").exists()
-    assert (tmp_path / "geo_contour.png").exists()
-
-
-def test_geo_plotting_on_map_optional(tmp_path, monkeypatch):
-    _configure_matplotlib(tmp_path, monkeypatch)
-    pytest.importorskip("contextily")
-
-    from ins_pricing.plotting import geo
-
-    rng = np.random.default_rng(7)
-    n = 60
-    df_geo = pd.DataFrame(
-        {
-            "lon": rng.uniform(105, 115, size=n),
-            "lat": rng.uniform(25, 35, size=n),
-            "loss": np.abs(rng.normal(loc=1.0, scale=0.4, size=n)),
-        }
-    )
-
-    geo.plot_geo_heatmap_on_map(
-        df_geo,
-        lon_col="lon",
-        lat_col="lat",
-        value_col="loss",
-        bins=12,
-        basemap=None,
-        save_path=str(tmp_path / "geo_heat_map.png"),
-    )
-    geo.plot_geo_contour_on_map(
-        df_geo,
-        lon_col="lon",
-        lat_col="lat",
-        value_col="loss",
-        max_points=30,
-        levels=5,
-        basemap=None,
-        save_path=str(tmp_path / "geo_contour_map.png"),
-    )
-
-    assert (tmp_path / "geo_heat_map.png").exists()
-    assert (tmp_path / "geo_contour_map.png").exists()

ins_pricing_gemini/modelling/tests/test_preprocessor.py

@@ -1,48 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-
-from ins_pricing.bayesopt.config_preprocess import BayesOptConfig, DatasetPreprocessor
-
-
-def _build_config(binary_resp: bool = False) -> BayesOptConfig:
-    return BayesOptConfig(
-        model_nme="demo",
-        resp_nme="y",
-        weight_nme="w",
-        factor_nmes=["x1"],
-        task_type="regression",
-        binary_resp_nme="y_bin" if binary_resp else None,
-    )
-
-
-def test_preprocessor_fills_missing_test_labels():
-    train = pd.DataFrame(
-        {
-            "x1": [1.0, 2.0, 3.0],
-            "y": [10.0, 20.0, 30.0],
-            "w": [1.0, 2.0, 3.0],
-            "y_bin": [0, 1, 0],
-        }
-    )
-    test = pd.DataFrame({"x1": [4.0, 5.0]})
-
-    cfg = _build_config(binary_resp=True)
-    result = DatasetPreprocessor(train, test, cfg).run()
-
-    assert "w_act" in result.train_data.columns
-    assert "w_act" not in result.test_data.columns
-    assert "w_binary_act" in result.train_data.columns
-    assert "w_binary_act" not in result.test_data.columns
-    assert result.test_data["w"].eq(1.0).all()
-    assert result.test_data["y"].isna().all()
-    assert result.test_data["y_bin"].isna().all()
-
-
-def test_preprocessor_missing_train_columns_raises():
-    train = pd.DataFrame({"x1": [1.0]})
-    test = pd.DataFrame({"x1": [2.0]})
-
-    cfg = _build_config(binary_resp=False)
-    with pytest.raises(KeyError):
-        DatasetPreprocessor(train, test, cfg).run()