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

rock_physics_open/equinor_utilities/anisotropy.py

@@ -0,0 +1,211 @@
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import gen_utilities
+
+# These routines are not finalised or used in any plugins yet
+"""
+	c11, c12, c13, c33, c44, c66 = c_ij_2_c_factors(cij)
+
+	Transform a single stiffness tensor into components. VTI medium is assumed
+	"""
+
+
+def c_ij_2_c_factors(
+    cij: npt.NDArray[np.float64],
+) -> (
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ]
+    | None
+):
+    """Transform a single stiffness tensor into components. VTI medium is assumed
+
+    Parameters
+    ----------
+    cij : np.ndarray
+            A 6x6 matrix.
+
+    Returns
+    -------
+    tuple
+            (c11, c12, c13, c33, c44, c66).
+    """
+    if not isinstance(cij, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance]
+        try:  # pyright: ignore[reportUnreachable]
+            cij = np.array(cij, dtype=float)  # pyright: ignore[reportUnreachable]
+        except ValueError:
+            print("Input data can't be transformed into a NumPy array")  # pyright: ignore[reportUnreachable]
+    try:
+        num_samp = int(cij.size / 36)
+        cij = cij.reshape((6, 6, num_samp))
+        c11 = cij[0, 0, :].reshape(num_samp, 1)
+        c12 = cij[0, 1, :].reshape(num_samp, 1)
+        c13 = cij[0, 2, :].reshape(num_samp, 1)
+        c33 = cij[2, 2, :].reshape(num_samp, 1)
+        c44 = cij[3, 3, :].reshape(num_samp, 1)
+        c66 = cij[5, 5, :].reshape(num_samp, 1)
+        return c11, c12, c13, c33, c44, c66
+
+    except ValueError:
+        print("Input data is not a 6x6xN array")
+
+
+def cfactors2cij(
+    c11: npt.NDArray[np.float64],
+    c12: npt.NDArray[np.float64],
+    c13: npt.NDArray[np.float64],
+    c33: npt.NDArray[np.float64],
+    c44: npt.NDArray[np.float64],
+    c66: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Transform individual stiffness factors to stiffness tensor 6x6x(number of samples).
+
+    Parameters
+    ----------
+    c11, c12, c13, c33, c44, c66 : np.ndarray
+            All 1-dimensional of same length.
+
+    Returns
+    -------
+    np.ndarray
+            A 6x6x(number of samples) stiffness tensor.
+    """
+    c11, c12, c13, c33, c44, c66 = cast(
+        list[npt.NDArray[np.float64]],
+        gen_utilities.dim_check_vector((c11, c12, c13, c33, c44, c66)),
+    )
+
+    num_samp = c11.shape[1]
+
+    cij = np.zeros((6, 6, num_samp))
+    cij[0, 0, :] = c11
+    cij[0, 1, :] = c12
+    cij[0, 2, :] = c13
+    cij[1, 0, :] = c12
+    cij[1, 1, :] = c11
+    cij[1, 2, :] = c13
+    cij[2, 0, :] = c13
+    cij[2, 1, :] = c13
+    cij[2, 1, :] = c33
+    cij[3, 3, :] = c44
+    cij[4, 4, :] = c44
+    cij[5, 5, :] = c66
+
+    return cij
+
+
+def c_ij_2_thomsen(
+    c: npt.NDArray[np.float64], rho: npt.NDArray[np.float64]
+) -> (
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ]
+    | None
+):
+    """Thomsen parameter for weak anisotropy.
+
+    Parameters
+    ----------
+    c : np.ndarray
+            A (log of or single instance of) 6x6 elastic tensor.
+    rho : np.ndarray
+            Density - log of same length as c.
+
+    Returns
+    -------
+    tuple
+            alpha, beta, gamma, delta, epsilon.
+    """
+    # C matrix should be 6x6
+    if not isinstance(c, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance]
+        try:  # pyright: ignore[reportUnreachable]
+            c = np.array(c, dtype=float)  # pyright: ignore[reportUnreachable]
+        except ValueError:
+            print("Input data can't be transformed into a NumPy array")  # pyright: ignore[reportUnreachable]
+    try:
+        num_samp = int(c.size / 36)
+        c = c.reshape((6, 6, num_samp))
+        rho = rho.reshape(num_samp, 1)
+        alpha = np.sqrt(c[2, 2, :].reshape(num_samp, 1) / rho)
+        beta = np.sqrt(c[3, 3, :].reshape(num_samp, 1) / rho)
+        gamma = ((c[5, 5, :] - c[3, 3, :]) / (2 * c[3, 3, :])).reshape(num_samp, 1)
+        epsilon = ((c[0, 0, :] - c[2, 2, :]) / (2 * c[2, 2, :])).reshape(num_samp, 1)
+        delta = (
+            ((c[0, 2, :] + c[3, 3, :]) ** 2 - (c[2, 2, :] - c[3, 3, :]) ** 2)
+            / (2 * c[2, 2, :] * (c[2, 2, :] - c[3, 3, :]))
+        ).reshape(num_samp, 1)
+
+        return alpha, beta, epsilon, gamma, delta
+    except ValueError:
+        print("Input data is not a 6x6xN array")
+
+
+def thomsen_2_c_ij(
+    alpha: npt.NDArray[np.float64],
+    beta: npt.NDArray[np.float64],
+    gamma: npt.NDArray[np.float64],
+    delta: npt.NDArray[np.float64],
+    epsilon: npt.NDArray[np.float64],
+    rho: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
+    """Elastic stiffness. Assumptions:
+            Thomsen's parameters apply for weak anisotropy in a transversely isotropic medium:
+
+            c11 c12 c13  0   0   0
+
+            c12 c11 c13  0   0   0
+
+            c13 c13 c33  0   0   0
+
+            0   0   0    c44 0   0
+
+            0   0   0    0   c44 0
+
+            0   0   0    0   0   c66
+
+            Where c66 = 1/2(c11 - c12)
+
+    Parameters
+    ----------
+    alpha, beta, gamma, delta, epsilon :
+            Thomsen's parameters.
+    rho :
+            Bulk density.
+
+    Returns
+    -------
+    tuple
+            Elastic stiffness c11, c12, c13, c33, c44, c66.
+    """
+    alpha, beta, gamma, delta, epsilon = cast(
+        list[npt.NDArray[np.float64]],
+        gen_utilities.dim_check_vector((alpha, beta, gamma, delta, epsilon)),
+    )
+
+    c33 = rho * alpha**2
+    c44 = rho * beta**2
+    c11 = c33 * (1 + 2 * epsilon)
+    c66 = c44 * (1 + 2 * gamma)
+    c12 = c11 - 2 * c66
+    c13 = np.sqrt(2 * c33 * (c33 - c44) * delta + (c33 - c44) ** 2) - c44
+
+    return c11, c12, c13, c33, c44, c66

rock_physics_open/equinor_utilities/classification_functions/__init__.py

@@ -0,0 +1,17 @@
+from .class_stats import gen_class_stats
+from .lin_class import lin_class
+from .mahal_class import mahal_class
+from .norm_class import norm_class
+from .poly_class import poly_class
+from .post_prob import posterior_probability
+from .two_step_classification import gen_two_step_class_stats
+
+__all__ = [
+    "gen_class_stats",
+    "lin_class",
+    "mahal_class",
+    "norm_class",
+    "poly_class",
+    "posterior_probability",
+    "gen_two_step_class_stats",
+]

rock_physics_open/equinor_utilities/classification_functions/class_stats.py

@@ -0,0 +1,68 @@
+import numpy as np
+import numpy.typing as npt
+
+NULL_CLASS = 0
+
+
+def gen_class_stats(
+    obs: npt.NDArray[np.float64],
+    class_val: npt.NDArray[np.int64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.int64],
+    npt.NDArray[np.int64],
+]:
+    """
+    Generate statistics - mean, covariance and prior probability - for each
+    class in the training data.	The observations are an n x m array, where n
+    is the number of observations and m is the number of variables. With p
+    classes the returned mean value will be an array of dimension p x m,
+    covariance m x m x p and the class_id and prior probability p length vector.
+    class_mean, class_cov, prior_prob, class_counts, class_id = gen_class_stats(obs, class_val).
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array of data samples (observations).
+    class_val : np.ndarray
+        n length vector with class ID of the observations. Assumed to
+        be integer.
+
+    Returns
+    -------
+    tuple
+        class_mean, class_cov, prior_prob, class_counts, class_id : (np.ndarray, np.ndarray, np.ndarray, np.ndarray,
+        np.ndarray).
+    """
+
+    n, m = obs.shape
+    # Find number of classes. If class_val input is not integer, raise an exception
+    if not (
+        isinstance(class_val, np.ndarray)  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        and issubclass(class_val.dtype.type, np.integer)  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+    ):
+        raise ValueError(f"{__file__}: class values are not discrete numbers")
+
+    class_id, class_counts = np.unique(class_val, return_counts=True)
+    # Remove Null class
+    idx_null = np.where(class_id == NULL_CLASS)
+    class_id = np.delete(class_id, idx_null)
+    class_counts = np.delete(class_counts, idx_null)
+    p = class_id.shape[0]
+
+    # Very simple prior probability - number of observations in each class
+    # divided by total number of observations
+    prior_prob = class_counts / n
+
+    # Assign output arrays
+    class_mean = np.zeros((p, m))
+    class_cov = np.zeros((m, m, p))
+
+    for i in range(len(class_id)):
+        idx = class_val == class_id[i]
+        class_mean[i, :] = np.mean(obs[idx, :], axis=0)
+        class_cov[:, :, i] = np.cov(obs[idx, :], rowvar=False)
+
+    return class_mean, class_cov, prior_prob, class_counts, class_id

rock_physics_open/equinor_utilities/classification_functions/lin_class.py

@@ -0,0 +1,53 @@
+import numpy as np
+import numpy.typing as npt
+
+NULL_CLASS = 0
+
+
+def lin_class(
+    obs: npt.NDArray[np.float64],
+    class_mean: npt.NDArray[np.float64],
+    class_id: npt.NDArray[np.float64],
+    thresh: float = np.inf,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    Linear classification routine. All data points are assigned a class, unless a threshold is set.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of features.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of features.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        lin_class_arr, lin_dist : (np.ndarray, np.ndarray).
+        lin_class_arr: nx1 vector. The classes are numbered according to class_id,
+        and unclassified samples (with distance greater than thresh) are set to 0,
+        lin_dist: nx1 vector with linear distance from the closest class centre to each sample.
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        dist[:, i] = np.sqrt(np.sum((obs - class_mean[i, :]) ** 2, axis=1))
+
+    # Find the shortest distance, assign class, filter out observations with distance
+    # greater than the threshold
+    lin_class_arr = np.choose(np.argmin(dist, axis=1), class_id)
+    lin_dist = np.amin(dist, axis=1)
+    lin_class_arr[lin_dist > thresh] = NULL_CLASS
+
+    return lin_class_arr, lin_dist

rock_physics_open/equinor_utilities/classification_functions/mahal_class.py

@@ -0,0 +1,63 @@
+import numpy as np
+import numpy.typing as npt
+
+from .post_prob import posterior_probability
+
+NULL_CLASS = 0
+
+
+def mahal_class(
+    obs: npt.NDArray[np.float64],
+    class_mean: npt.NDArray[np.float64],
+    class_cov: npt.NDArray[np.float64],
+    class_id: npt.NDArray[np.int64],
+    thresh: float = np.inf,
+):
+    """
+    Mahalanobis classification routine. All data points are assigned a class, unless a threshold is set
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_cov : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        mahal_class_arr, mahal_dist, mahal_pp : (np.ndarray, np.ndarray, np.ndarray).
+        mahal_class_arr: nx1 vector. The classes are numbered 1 to m, and unclassified samples (with distance
+        greater than thresh) are set to 0,
+        mahal_dist:	nx1 vector with mahalanobis distance from the closest class centre to sample,
+        mahal_pp: nx1 vector with posterior probability based on the distance to each class
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        cov_inv = np.linalg.inv(class_cov[:, :, i])
+        delta = obs - class_mean[i, :]
+        dist[:, i] = np.sqrt(np.einsum("nj,jk,nk->n", delta, cov_inv, delta))
+
+    # Find the shortest distance, assign class, calculate posterior probability and
+    # filter out observations with distance greater than the threshold
+    mahal_class_arr = np.choose(np.argmin(dist, axis=1), class_id)
+    mahal_dist = np.amin(dist, axis=1)
+    mahal_pp = posterior_probability(mahal_dist, dist)
+    d_idx = mahal_dist > thresh
+    mahal_class_arr[d_idx] = NULL_CLASS
+
+    return mahal_class_arr, mahal_dist, mahal_pp

rock_physics_open/equinor_utilities/classification_functions/norm_class.py

@@ -0,0 +1,73 @@
+import numpy as np
+import numpy.typing as npt
+
+NULL_CLASS = 0
+
+
+def norm_class(
+    obs: npt.NDArray[np.float64],
+    class_mean: npt.NDArray[np.float64],
+    class_cov: npt.NDArray[np.float64],
+    prior_prob: npt.NDArray[np.float64],
+    class_id: npt.NDArray[np.int64],
+    thresh: float = np.inf,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    Normal distribution classification routine. All data points are assigned a
+    class, unless a threshold is set. The "dist" calculated here is the quadratic
+    discriminant function according to a Bayes classification. This is a negative
+    number, and the closest class has the smallest absolute value.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_cov : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    prior_prob : np.ndarray
+        A p length vector, where p is the number of classes containing prior probabilities for each class.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+
+    Returns
+    --------
+    tuple
+        norm_class_id, norm_dist, norm_pp : (np.ndarray, np.ndarray, np.ndarray).
+        norm_class_id:	nx1 vector. The classes are numbered 1 to m, and unclassified
+        samples (with absolute distance greater than thresh) are set to 0,
+        norm_dist: nx1 vector with quadratic discriminant distance from the closest class centre to sample,
+        norm_pp: nx1 vector with posterior probability based on the distance to each class.
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        cov_inv = np.linalg.inv(class_cov[:, :, i])
+        delta = obs - class_mean[i, :]
+        dist[:, i] = (
+            -0.5 * np.log(np.linalg.det(class_cov[:, :, i]))
+            - 0.5 * np.sqrt(np.einsum("nj,jk,nk->n", delta, cov_inv, delta))
+            + np.log(prior_prob[i])
+        )
+
+    # The discrimination function ("dist") are negative numbers. Choose the one
+    # with the smallest value as the closest class
+    norm_class_id = np.choose(np.argmax(dist, axis=1), class_id)
+    norm_dist = np.amax(dist, axis=1)
+    norm_pp = -np.exp(norm_dist) / np.sum(np.exp(dist), axis=1)
+
+    # Compare the absolute value of the discriminator with the threshold
+    norm_class_id[np.abs(norm_dist) > thresh] = NULL_CLASS
+
+    return norm_class_id, norm_dist, norm_pp

rock_physics_open/equinor_utilities/classification_functions/poly_class.py

@@ -0,0 +1,45 @@
+import matplotlib.path as mplpath
+import numpy as np
+import numpy.typing as npt
+
+
+def poly_class(
+    train_data: npt.NDArray[np.float64],
+    polygons: npt.NDArray[np.float64],
+    labels: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    Points within the polygons are assigned to class labels. Point that do not
+    fall within any polygon are set to NULL_CLASS.
+
+    Parameters
+    ----------
+
+    train_data : np.ndarray
+        Data points of two variables.
+    polygons : np.ndarray
+        Vertices of polygons in two-dimensional space.
+    labels : np.ndarray
+        Class label for each polygon.
+
+    Returns
+    -------
+    np.ndarray
+        Class id.
+    """
+    if len(labels) != len(polygons):
+        raise ValueError("Number of labels are not matching number of polygons")
+
+    # Create output variables
+    idx_filtered = np.zeros(train_data.shape[0]).astype("bool")
+    poly_class_id = np.zeros(train_data.shape[0]).astype("int")
+
+    for i in range(len(polygons)):
+        class_polygon = polygons[i]
+        path = mplpath.Path(class_polygon)
+        # Only points within the given polygon are used
+        idx_poly = path.contains_points(train_data)
+        poly_class_id[idx_poly] = labels[i]
+        idx_filtered = np.logical_or(idx_filtered, idx_poly)
+    # idx_filtered is no longer returned
+    return poly_class_id

rock_physics_open/equinor_utilities/classification_functions/post_prob.py

@@ -0,0 +1,27 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def posterior_probability(
+    min_dist: npt.NDArray[np.float64], dist: npt.NDArray[np.float64]
+) -> npt.NDArray[np.float64]:
+    """
+    Posterior probability, which is defined as the exponential of minimum distance divided by the sum of the
+    exponentials of distance to all classes.
+
+    Parameters
+    ----------
+    min_dist : np.ndarray
+        Minimum class distance according to some metric.
+    dist : np.ndarray
+        All class distances, each class in a column in a two-dimensional array.
+
+    Returns
+    -------
+    np.ndarray
+        Posterior probability array.
+    """
+    dist *= -1.0
+    n_exp = np.exp(dist)
+    d_sum = n_exp.sum(axis=1)
+    return np.exp(-min_dist) / d_sum

rock_physics_open/equinor_utilities/classification_functions/two_step_classification.py

@@ -0,0 +1,60 @@
+import numpy as np
+import numpy.typing as npt
+
+from .class_stats import gen_class_stats
+from .mahal_class import mahal_class
+
+NULL_CLASS = 0
+
+
+def gen_two_step_class_stats(
+    obs: npt.NDArray[np.float64],
+    class_val: npt.NDArray[np.int64],
+    thresh: float,
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.int64],
+    npt.NDArray[np.int64],
+    npt.NDArray[np.float64],
+]:
+    """
+    The observations are an n x m array, where n
+    is the number of observations and m is the number of variables. With p
+    classes the returned mean value will be an array of dimension p x m,
+    covariance m x m x p and the class_id and prior probability p length vector.
+
+    Generate statistics - mean, covariance and prior probability - for each
+    class in the training data.	Run a mahalanobis classification, and exclude
+    values that have distance above the threshold. Generate class statistics again
+    and return them.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_val : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        class_mean, class_cov: statistics for each class after rejects;
+        prior_prob, class_counts: based on number of observations in each class,
+        find the prior probability of each class;
+        class_id: label for each class;
+        mahal_class_id: class id from mahalanobis classification.
+    """
+    mean_class_id, class_cov, _, _, class_id = gen_class_stats(obs, class_val)
+    mahal_class_id = mahal_class(obs, mean_class_id, class_cov, class_id, thresh)[0]
+
+    idx = mahal_class_id != NULL_CLASS
+    mean_class_id, class_cov, prior_prob, class_counts, class_id = gen_class_stats(
+        obs[idx], class_val[idx]
+    )
+
+    return mean_class_id, class_cov, prior_prob, class_counts, class_id, mahal_class_id

rock_physics_open/equinor_utilities/conversions.py

@@ -0,0 +1,10 @@
+"""
+Simple conversions required for the material models.
+"""
+
+
+def celsius_to_kelvin(temperature: float) -> float:
+    """
+    Convert temperature from Celsius to kelvin
+    """
+    return temperature + 273.15

rock_physics_open/equinor_utilities/gen_utilities/__init__.py

@@ -0,0 +1,11 @@
+from .dict_to_float import dict_value_to_float
+from .dim_check_vector import dim_check_vector
+from .filter_input import filter_input_log
+from .filter_output import filter_output
+
+__all__ = [
+    "dict_value_to_float",
+    "dim_check_vector",
+    "filter_input_log",
+    "filter_output",
+]

rock_physics_open/equinor_utilities/gen_utilities/dict_to_float.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+
+def dict_value_to_float(
+    input_dict: dict[str, Any],
+) -> dict[str, float | list[float]]:
+    """
+    Convert dictionary strings to floating point numbers. Each value can have multiple floats.
+
+    Parameters
+    ----------
+    input_dict : dict
+        Input dictionary.
+
+    Returns
+    -------
+    dict
+        Output dictionary.
+    """
+
+    for item in input_dict:
+        if isinstance(input_dict[item], float):
+            pass
+        else:
+            try:
+                ff = float(input_dict[item])
+                input_dict[item] = ff
+            except ValueError:  # if a list or tuple is hidden in the string
+                try:
+                    ll = eval(input_dict[item])
+                    ff = [float(i) for i in ll]
+                    input_dict[item] = ff
+                except ValueError:
+                    raise ValueError(
+                        "dict_value_to_float: not possible to convert value to float"
+                    )
+
+    return input_dict