rock-physics-open 0.3.2__py3-none-any.whl

rock_physics_open/equinor_utilities/machine_learning_utilities/exponential_model.py

@@ -0,0 +1,137 @@
+import pickle
+from typing import Any, Self, final
+
+import numpy as np
+from typing_extensions import override
+
+from .base_pressure_model import BasePressureModel
+
+
+@final
+class ExponentialPressureModel(BasePressureModel):
+    """
+    Exponential pressure sensitivity model for velocity prediction.
+
+    Uses exponential decay function: v = v0 * (1 - a*exp(-p/b)) / (1 - a*exp(-p0/b))
+    where v0 is reference velocity, p is pressure, a and b are model parameters.
+
+    Input format (n,3): [velocity, p_eff_in_situ, p_eff_depleted]
+    """
+
+    def __init__(
+        self,
+        a_factor: float,
+        b_factor: float,
+        model_max_pressure: float | None = None,
+        description: str = "",
+    ):
+        """
+        Initialize exponential pressure model.
+
+        Parameters
+        ----------
+        a_factor : float
+            Exponential amplitude parameter [unitless].
+        b_factor : float
+            Exponential decay parameter [Pa].
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
+        self._a_factor = a_factor
+        self._b_factor = b_factor
+
+    @property
+    def a_factor(self) -> float:
+        """Exponential amplitude factor."""
+        return self._a_factor
+
+    @property
+    def b_factor(self) -> float:
+        """Exponential decay factor."""
+        return self._b_factor
+
+    @override
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input for exponential model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input format is invalid.
+        """
+        if not isinstance(inp_arr, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+            raise ValueError("Input must be numpy ndarray.")  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
+        if inp_arr.ndim != 2 or inp_arr.shape[1] != 3:
+            raise ValueError(
+                "Input must be (n,3): [velocity, p_eff_in_situ, p_eff_depleted]"
+            )
+        return inp_arr
+
+    @override
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Calculate absolute velocity for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,3).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Velocity values [m/s].
+        """
+        arr = self.validate_input(inp_arr)
+
+        vel = arr[:, 0]
+        p_in_situ = arr[:, 1]
+        p_depleted = arr[:, 2]
+
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        return (
+            vel
+            * (1.0 - self._a_factor * np.exp(-p_eff / self._b_factor))
+            / (1.0 - self._a_factor * np.exp(-p_in_situ / self._b_factor))
+        )
+
+    @override
+    def todict(self) -> dict[str, Any]:
+        """Convert model to dictionary."""
+        return {
+            "a_factor": self._a_factor,
+            "b_factor": self._b_factor,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
+
+    @override
+    @classmethod
+    def load(cls, file: str | bytes) -> Self:
+        """Load exponential model from pickle file."""
+        with open(file, "rb") as f_in:
+            d = pickle.load(f_in)
+
+        return cls(
+            a_factor=d["a_factor"],
+            b_factor=d["b_factor"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )

rock_physics_open/equinor_utilities/machine_learning_utilities/import_ml_models.py

@@ -0,0 +1,77 @@
+import warnings
+from pickle import load
+
+from sklearn.preprocessing import OneHotEncoder, RobustScaler
+
+from .exponential_model import ExponentialPressureModel
+from .polynomial_model import PolynomialPressureModel
+from .sigmoidal_model import SigmoidalPressureModel
+
+AnyModel = ExponentialPressureModel | PolynomialPressureModel | SigmoidalPressureModel
+
+
+def import_model(
+    model_file_name: str,
+) -> tuple[
+    AnyModel,
+    RobustScaler,
+    OneHotEncoder | None,
+    str,
+    str,
+    list[str],
+    str | list[str],
+]:
+    """
+    Utility to import a pickled dict containing information needed to run a classification or regression based on
+    a calibrated model.
+
+    Parameters
+    ----------
+    model_file_name : str
+        Full name including path for model file.
+
+    Returns
+    -------
+    models, scaler, ohe, label_var, label_units, feature_var, cat_var : Any
+        models: various regression or classification models from e.g. sklearn or tensorflow keras, scaler: preprocessing
+        Robust Scaler, label_var: name(s) of label variable(s), label_unit: unit(s) of label variable(s), cat_var:
+        categorical variables that should be encoded with one-hot-encoder.
+    """
+
+    with open(model_file_name, "rb") as fin, warnings.catch_warnings():
+        # 11.04.2021 HFLE: There is an issue that is not connected to the local function, in that a warning is issued
+        # when the model is loaded, claiming that it is of an older version. This is debugged in detail, and the model
+        # IS of the correct version, so the error arise elsewhere. To avoid confusion, the warning is suppressed here
+
+        warnings.simplefilter("ignore", category=UserWarning)
+        mod_dict = load(fin)
+
+    if mod_dict["model_type"] == "Sigmoid":
+        models = SigmoidalPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "Exponential":
+        models = ExponentialPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "Polynomial":
+        models = PolynomialPressureModel.load(mod_dict["nn_mod"])
+    else:
+        raise ValueError("unknown model type {}".format(mod_dict["model_type"]))
+
+    ohe: OneHotEncoder | None = None
+    cat_var: str | list[str] = []
+    try:
+        if mod_dict["ohe"]:
+            with open(mod_dict["ohe"], "rb") as f:
+                ohe_dict = load(f)
+                ohe = ohe_dict["ohe"]
+                cat_var = ohe_dict["cat_var"]
+    except (FileExistsError, FileNotFoundError):
+        pass
+
+    return (
+        models,
+        mod_dict["scaler"],
+        ohe,
+        mod_dict["label_var"],
+        mod_dict["label_units"],
+        mod_dict["feature_var"],
+        cat_var,
+    )

rock_physics_open/equinor_utilities/machine_learning_utilities/polynomial_model.py

@@ -0,0 +1,132 @@
+import pickle
+from typing import Any, Self, final
+
+import numpy as np
+from typing_extensions import override
+
+from .base_pressure_model import BasePressureModel
+
+
+@final
+class PolynomialPressureModel(BasePressureModel):
+    """
+    Polynomial pressure sensitivity model for velocity prediction.
+
+    Uses polynomial function: v = v0 * P(p_depl) / P(p_in_situ)
+    where P(p) is a polynomial function with specified coefficients.
+
+    Input format (n,3): [velocity, p_eff_in_situ, p_eff_depleted]
+    """
+
+    def __init__(
+        self,
+        weights: list[float],
+        model_max_pressure: float | None = None,
+        description: str = "",
+    ):
+        """
+        Initialize polynomial pressure model.
+
+        Parameters
+        ----------
+        weights : list[float]
+            Polynomial coefficients [unitless]. First element is constant term,
+            second is linear coefficient, etc.
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
+        self._weights = weights
+
+    @property
+    def weights(self) -> list[float]:
+        """Polynomial coefficients."""
+        return self._weights
+
+    @override
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input for polynomial model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input format is invalid.
+        """
+        if not isinstance(inp_arr, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+            raise ValueError("Input must be numpy ndarray.")  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
+        if inp_arr.ndim != 2 or inp_arr.shape[1] != 3:
+            raise ValueError(
+                "Input must be (n,3): [velocity, p_eff_in_situ, p_eff_depleted]"
+            )
+        return inp_arr
+
+    @override
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Calculate absolute velocity for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,3).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Velocity values [m/s].
+        """
+        arr = self.validate_input(inp_arr)
+
+        # Validate weights are set
+        if not self._weights:
+            raise ValueError('Field "weights" is not set.')
+
+        vel = arr[:, 0]
+        p_in_situ = arr[:, 1]
+        p_depleted = arr[:, 2]
+
+        # Create polynomial from weights
+        polynomial_expr = np.polynomial.Polynomial(self._weights)
+
+        # Select pressure based on case
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        # Calculate velocity using polynomial pressure correction
+        return vel * polynomial_expr(p_eff) / polynomial_expr(p_in_situ)
+
+    @override
+    def todict(self) -> dict[str, Any]:
+        """Convert model to dictionary."""
+        return {
+            "weights": self._weights,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
+
+    @override
+    @classmethod
+    def load(cls, file: str | bytes) -> Self:
+        """Load polynomial model from pickle file."""
+        with open(file, "rb") as f_in:
+            d = pickle.load(f_in)
+
+        return cls(
+            weights=d["weights"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )

rock_physics_open/equinor_utilities/machine_learning_utilities/run_regression.py

@@ -0,0 +1,209 @@
+import os
+from collections.abc import Sequence
+from pathlib import Path
+from re import match
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+from sklearn.preprocessing import OneHotEncoder, RobustScaler
+
+from .dummy_vars import generate_dummy_vars
+from .import_ml_models import AnyModel, import_model
+
+
+def _read_models(
+    *model_files: str, model_dir: str | Path | None = None
+) -> tuple[
+    list[AnyModel],
+    list[RobustScaler],
+    list[OneHotEncoder | None],
+    list[str],
+    list[str],
+    list[list[str]],
+    list[Any],
+    list[str],
+    list[str],
+]:
+    # Find the directory of the model files, change working directory, return to original directory at end of function
+    orig_dir = os.getcwd()
+    if model_dir is None:
+        model_dir, _ = os.path.split(model_files[0])
+    os.chdir(model_dir)
+    # Allocate lists and read model
+    reg_models: list[AnyModel] = []
+    scalers: list[RobustScaler] = []
+    ohes: list[OneHotEncoder | None] = []
+    label_vars: list[str] = []
+    label_units: list[str] = []
+    feat_vars: list[list[str]] = []
+    cat_vars: list[Any] = []
+    col_names: list[str] = []
+    col_units: list[str] = []
+
+    for mod_name in model_files:
+        models, scaler, ohe, label_var, label_unit, feat_var, cat_var = import_model(
+            model_file_name=mod_name
+        )
+        reg_models.append(models)
+        scalers.append(scaler)
+        ohes.append(ohe)
+        label_vars.append(label_var)
+        # Need to modify names
+        col_names.append(label_var + "_" + mod_name.replace(label_var, ""))
+        col_units.append(label_unit)
+        label_units.append(label_unit)
+        feat_vars.append(feat_var)
+        cat_vars.append(cat_var)
+
+        # Need to modify names
+        col_names, col_units = ([] for _ in range(2))
+        for i in range(len(label_var)):
+            col_names.append(
+                label_var[i] + "_" + model_files[i].replace(label_var[i], "")
+            )
+            col_units.append(label_unit[i])
+
+    os.chdir(orig_dir)
+
+    return (
+        reg_models,
+        scalers,
+        ohes,
+        label_vars,
+        label_units,
+        feat_vars,
+        cat_vars,
+        col_names,
+        col_units,
+    )
+
+
+def _perform_regression(
+    inp_frame: pd.DataFrame,
+    col_names: list[str],
+    feat_var: list[list[str]],
+    cat_var: str | list[str],
+    ohe: Sequence[OneHotEncoder | None],
+    scaler: Sequence[RobustScaler | None],
+    reg_model: Sequence[AnyModel],
+) -> pd.DataFrame:
+    depth = inp_frame.index.to_numpy()
+
+    res_frame = pd.DataFrame(index=depth, columns=col_names)
+
+    for j, _ in enumerate(col_names):
+        tmp_frame = inp_frame.copy()
+
+        # Limit to columns used in estimation before dropping NaNs
+        num_var = [i for i in feat_var[j] if not bool(match(r"x\d", i))]
+        no_num_var = len(num_var)
+        if cat_var[j]:
+            num_var.append(cat_var[j])
+        tmp_frame = tmp_frame[num_var]
+        idx_na_n = tmp_frame.isna().any(axis=1)
+
+        if cat_var[j]:
+            dum_features, _, dum_var_names = generate_dummy_vars(
+                inp_frame=tmp_frame.loc[~idx_na_n],
+                class_var=cat_var[j],
+                ohe=ohe[j],
+            )
+            # Add dummy features to data frame
+            kept_dum_var: list[str] = []
+            for i, name in enumerate(dum_var_names):
+                if name in feat_var[j]:
+                    tmp_frame.loc[~idx_na_n, name] = dum_features[:, i]
+                    kept_dum_var.append(name)
+            tmp_frame.drop(columns=[cat_var[j]], inplace=True)
+
+            # Need to assure that we have the correct sequence of features
+            tmp_frame = tmp_frame.reindex(columns=feat_var[j])
+
+            new_features = np.zeros((np.sum(~idx_na_n), tmp_frame.shape[1]))
+            # Make scaling optional
+            scaler_ = scaler[j]
+            if scaler_ is not None:
+                new_features = (
+                    cast(  # Casting since scikit-learn is not yet fully typed.
+                        npt.NDArray[np.float64],
+                        scaler_.transform(tmp_frame.to_numpy()[~idx_na_n, :]),
+                    )
+                )
+            else:
+                new_features[:, :no_num_var] = tmp_frame.to_numpy()[
+                    ~idx_na_n, :no_num_var
+                ]
+            new_features[:, no_num_var:] = tmp_frame.loc[
+                ~idx_na_n, kept_dum_var
+            ].to_numpy()
+        else:
+            # Much simpler if there are no dummy variables
+            # Need to assure that we have the correct sequence of features
+            tmp_frame = tmp_frame.reindex(columns=feat_var[j])
+            # Make scaling optional
+            scaler_ = scaler[j]
+            if scaler_ is not None:
+                new_features = (
+                    cast(  # Casting since scikit-learn is not yet fully typed.
+                        npt.NDArray[np.float64],
+                        scaler_.transform(tmp_frame.to_numpy()[~idx_na_n, :]),
+                    )
+                )
+            else:
+                new_features = tmp_frame.to_numpy()[~idx_na_n, :]
+
+        new_var = np.ones(depth.shape[0]) * np.nan
+        new_var[~idx_na_n] = reg_model[j].predict(new_features).flatten()
+        res_frame[col_names[j]] = new_var
+
+    return res_frame
+
+
+def run_regression(
+    inp_df: pd.DataFrame,
+    first_model_file_name: str,
+    second_model_file_name: str,
+    model_dir: str | None = None,
+) -> pd.DataFrame:
+    """
+    Estimate Vp and Vs by neural network regression with multiple inputs.
+
+    Parameters
+    ----------
+    inp_df : pd.DataFrame
+        Input logs required for the regression.
+    first_model_file_name : str
+        Full file name for vp model.
+    second_model_file_name : str
+        Full file name for vs model.
+    model_dir : str | None
+        Directory.
+
+    Returns
+    -------
+    vp, vs : pd.DataFrame
+        Estimated vp and vs as series in Pandas DataFrame.
+    """
+
+    (
+        regression_model,
+        scaler_obj,
+        ohe_obj,
+        _,
+        _,
+        feature_var,
+        category_var,
+        column_names,
+        _,
+    ) = _read_models(first_model_file_name, second_model_file_name, model_dir=model_dir)
+    return _perform_regression(
+        inp_frame=inp_df,
+        col_names=column_names,
+        feat_var=feature_var,
+        cat_var=category_var,
+        ohe=ohe_obj,
+        scaler=scaler_obj,
+        reg_model=regression_model,
+    )