cratonml 0.1.1.0__tar.gz

cratonml-0.1.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.1
+Name: cratonml
+Version: 0.1.1.0
+Summary: Python application for W-Seis
+Author: KamashevAM
+Author-email: kamashev41@gmail.com
+Requires-Python: >=3.11,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cratonapi (>=0.1.0.9,<0.2.0.0)
+Requires-Dist: imbalanced-learn (>=0.12.4,<0.13.0)
+Requires-Dist: nose2 (>=0.15.1,<0.16.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pywin32 (>=306,<307)
+Requires-Dist: pywin32-ctypes (>=0.2.2,<0.3.0)
+Requires-Dist: scikit-learn (>=1.5.0,<2.0.0)
+Requires-Dist: scipy (>=1.14.0,<2.0.0)
+Requires-Dist: seaborn (>=0.13.2,<0.14.0)
+Description-Content-Type: text/markdown
+
+# MLToolBox
+
+# Использование:
+
+
++ Установка зависимостей
+```
+$ pip install mltoolbox
+```
++ Запустите Desmana, GisWell и подгрузите сейсмический проект
+```
+# Логика версионирования CHANGELOG:
+
+M.N.K.L
+
+M - за глобальный релиз отвечает (выход в прод, закрытие этапа) 
+N - при добавлении нового модуля, либо изменения старых, но без поддержки расчета прошлых версий
+K - при добавлении новых функциональностей в существующих модулях (функции, класс и тд)
+L - при изменении текущего функционала
+
+При изменении номера, все что правее по индексу меняется на ноль.
+Подразумевается что тесты не входят в пулл changelog, но если отдельно заливаются то менять L
+Новые записи вносить вверх файла CHANGELOG

cratonml-0.1.1.0/README.md

@@ -0,0 +1,23 @@
+# MLToolBox
+
+# Использование:
+
+
++ Установка зависимостей
+```
+$ pip install mltoolbox
+```
++ Запустите Desmana, GisWell и подгрузите сейсмический проект
+```
+# Логика версионирования CHANGELOG:
+
+M.N.K.L
+
+M - за глобальный релиз отвечает (выход в прод, закрытие этапа) 
+N - при добавлении нового модуля, либо изменения старых, но без поддержки расчета прошлых версий
+K - при добавлении новых функциональностей в существующих модулях (функции, класс и тд)
+L - при изменении текущего функционала
+
+При изменении номера, все что правее по индексу меняется на ноль.
+Подразумевается что тесты не входят в пулл changelog, но если отдельно заливаются то менять L
+Новые записи вносить вверх файла CHANGELOG

cratonml-0.1.1.0/cratonml/__init__.py

@@ -0,0 +1,2 @@
+import cratonml.calculate
+import cratonml.data

cratonml-0.1.1.0/cratonml/calculate/Classification.py

@@ -0,0 +1,221 @@
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier as RandomForest
+from sklearn.naive_bayes import GaussianNB
+from sklearn.tree import DecisionTreeClassifier as DecisionTree
+from sklearn.linear_model import LogisticRegression
+
+
+class GaussianNaiveBayesClassifier:
+    """Класс для классификации алгоритмом Gaussian Naive Bayes."""
+
+    @staticmethod
+    def get_model(x_train: np.ndarray, y_train: np.ndarray):
+        """
+        Возвращает модель обученную на тренировочных данных.
+
+        Parameters
+        ----------
+        x_train: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+        y_train: np.ndarray
+            Массив значений размера N.
+
+        Returns
+        -------
+        GaussianNB
+            Обученная модель.
+        """
+
+        assert x_train.ndim == 2, "x_train: Ожидался 2D массив"
+        assert y_train.ndim == 1, "y_train: Ожидался 1D массив"
+        assert x_train.shape[0] == y_train.shape[0], "Массив y_train имеет несоответствующую длину"
+
+        model = GaussianNB()
+        model.fit(x_train, y_train)
+        return model
+
+    @staticmethod
+    def predict(model: GaussianNB, x_test: np.ndarray):
+        """
+         Прогнозирует метки для тестового набора данных.
+
+        Parameters
+        ----------
+        model: GaussianNB
+            Обученная модель.
+        x_test: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert x_test.ndim == 2, "x_test: Ожидался 2D массив"
+
+        prediction = model.predict(x_test)
+        return prediction
+
+
+class LogisticRegressionClassifier:
+    """Класс для классификации алгоритмом Logistic Regression."""
+    @staticmethod
+    def get_model(x_train: np.ndarray, y_train: np.ndarray):
+        """
+        Возвращает модель обученную на тренировочных данных.
+
+        Parameters
+        ----------
+        x_train: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+        y_train: np.ndarray
+            Массив значений размера N.
+
+        Returns
+        -------
+        LogisticRegression
+            Обученная модель.
+        """
+
+        assert x_train.ndim == 2, "x_train: Ожидался 2D массив"
+        assert y_train.ndim == 1, "y_train: Ожидался 1D массив"
+        assert x_train.shape[0] == y_train.shape[0], "Массив y_train имеет несоответствующую длину"
+
+        model = LogisticRegression()
+        model.fit(x_train, y_train)
+        return model
+
+    @staticmethod
+    def predict(model: LogisticRegression, x_test: np.ndarray):
+        """
+         Прогнозирует метки для тестового набора данных.
+
+        Parameters
+        ----------
+        model: LogisticRegression
+            Обученная модель.
+        x_test: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert x_test.ndim == 2, "x_test: Ожидался 2D массив"
+
+        prediction = model.predict(x_test)
+        return prediction
+
+
+class DecisionTreeClassifier:
+    """Класс для классификации Decision Tree."""
+    @staticmethod
+    def get_model(x_train: np.ndarray, y_train: np.ndarray, min_samples_split: int or float = 2, max_depth: int = None):
+        """
+        Возвращает модель обученную на тренировочных данных.
+
+        Parameters
+        ----------
+        x_train: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+        y_train: np.ndarray
+            Массив значений размера N.
+        min_samples_split: int or float = 2
+            Минимальное количество выборок, необходимое для разделения внутреннего узла.(параметр DecisionTree).
+        max_depth: int = None
+            Максимальная глубина дерева(параметр DecisionTree).
+
+        Returns
+        -------
+        DecisionTree
+            Обученная модель.
+        """
+
+        assert x_train.ndim == 2, "x_train: Ожидался 2D массив"
+        assert y_train.ndim == 1, "y_train: Ожидался 1D массив"
+        assert x_train.shape[0] == y_train.shape[0], "Массив y_train имеет несоответствующую длину"
+
+        model = DecisionTree(min_samples_split=min_samples_split, max_depth=max_depth)
+        model.fit(x_train, y_train)
+        return model
+
+    @staticmethod
+    def predict(model: DecisionTree, x_test: np.ndarray):
+        """
+         Прогнозирует метки для тестового набора данных.
+
+        Parameters
+        ----------
+        model: DecisionTree
+            Обученная модель.
+        x_test: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert x_test.ndim == 2, "x_test: Ожидался 2D массив"
+
+        prediction = model.predict(x_test)
+        return prediction
+
+
+class RandomForestClassifier:
+    """Класс для классификации Random Forest."""
+    @staticmethod
+    def get_model(x_train: np.ndarray, y_train: np.ndarray, n_estimators: int = 100, max_depth: int = None):
+        """
+        Возвращает модель обученную на тренировочных данных.
+
+        Parameters
+        ----------
+        x_train: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+        y_train: np.ndarray
+            Массив значений размера N.
+        n_estimators: int = 100
+            Количество деревьев в лесу.(параметр RandomForest).
+        max_depth: int = None
+            Максимальная глубина дерева(параметр RandomForest).
+        Returns
+        -------
+        RandomForest
+            Обученная модель.
+        """
+
+        assert x_train.ndim == 2, "x_train: Ожидался 2D массив"
+        assert y_train.ndim == 1, "y_train: Ожидался 1D массив"
+        assert x_train.shape[0] == y_train.shape[0], "Массив y_train имеет несоответствующую длину"
+
+        model = RandomForest(n_estimators=n_estimators, max_depth=max_depth)
+        model.fit(x_train,y_train)
+        return model
+
+    @staticmethod
+    def predict(model: RandomForest, x_test: np.ndarray):
+        """
+         Прогнозирует метки для тестового набора данных.
+
+        Parameters
+        ----------
+        model: RandomForest
+            Обученная модель.
+        x_test: np.ndarray
+            Массив значений размера (N, M). Где N - количество точек, M - количество атрибутов.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert x_test.ndim == 2, "x_test: Ожидался 2D массив"
+
+        prediction = model.predict(x_test)
+        return prediction

cratonml-0.1.1.0/cratonml/calculate/Clustering.py

@@ -0,0 +1,252 @@
+from sklearn.cluster import KMeans, HDBSCAN
+import numpy as np
+from scipy import stats
+from sklearn.mixture import GaussianMixture
+
+RANDOM_STATE = 42
+ALPHA_K = 0.02
+
+
+class KMeansClassifier:
+    """Класс для KMeans кластеризации."""
+
+    @staticmethod
+    def __get_scaled_inertia(data, cluster):
+        inertia_o = np.square((data - data.mean(axis=0))).sum()
+        scaled_inertia = cluster.inertia_ / inertia_o + ALPHA_K * cluster.n_clusters
+        return scaled_inertia
+
+    @staticmethod
+    def __get_cluster(data, n_clusters):
+        cluster = KMeans(n_clusters=n_clusters,
+                         random_state=RANDOM_STATE, algorithm='elkan')
+        cluster.fit(data)
+        return cluster
+
+    @staticmethod
+    def __get_cluster_centers(kmeans):
+        kmeans_centers = np.unique(np.sum(kmeans.cluster_centers_, axis=1))
+        return kmeans_centers
+
+    @staticmethod
+    def __get_labels(data, n_clusters):
+        kmeans = KMeansClassifier.__get_cluster(data, n_clusters)
+        kmeans_labels_before_sorting = kmeans.labels_
+        kmeans_centers = KMeansClassifier.__get_cluster_centers(kmeans)
+        kmeans_uniq_labels = np.unique(kmeans_labels_before_sorting)
+        sorted_kmeans_uniq_labels = kmeans_uniq_labels[np.argsort(kmeans_centers)]
+
+        kmeans_labels = np.zeros_like(kmeans_labels_before_sorting)
+        for i, label in enumerate(sorted_kmeans_uniq_labels):
+            kmeans_labels[kmeans_labels_before_sorting == label] = i
+
+        return kmeans_labels
+
+    @staticmethod
+    def find_the_best_number_of_clusters(data: np.ndarray) -> int:
+        """
+        Подбирает оптимальное количество кластеров на основании взвешенной инерции.
+
+        Parameters
+        ----------
+        data: np.ndarray
+            2D массив значений.
+
+        Returns
+        -------
+        int
+            Оптимальное количество кластеров.
+        """
+
+        assert data.ndim == 2, "data: Ожидался 2D массив"
+
+        scaled_inertia_list = []
+        number_of_clusters_list = range(2, min(15, data.shape[0]))
+        for number_of_clusters in number_of_clusters_list:
+            cluster = KMeansClassifier.__get_cluster(data, number_of_clusters)
+            scaled_inertia = KMeansClassifier.__get_scaled_inertia(data, cluster)
+            scaled_inertia_list.append(scaled_inertia)
+        scaled_inertia_list = np.asarray(scaled_inertia_list)
+        best_number_of_clusters = number_of_clusters_list[np.argmin(scaled_inertia_list)]
+        return best_number_of_clusters
+
+    @staticmethod
+    def calculate(data: np.ndarray, n_clusters: int) -> np.ndarray:
+        """
+        Распределяет объекты по n_clusters кластерам по сходству. Для вычисления этого сходства используется евклидово расстояние в качестве меры.
+
+        Parameters
+        ----------
+        data: np.ndarray
+            Массив значений (N, M). Где N-количество точек, M - количество атрибутов.
+        n_clusters: int
+            Количество кластеров.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert data.ndim == 2, "data: Ожидался 2D массив"
+        assert n_clusters > 0, "Параметр n_clusters должен принимать положительное значение"
+
+        labels = KMeansClassifier.__get_labels(data=data, n_clusters=n_clusters)
+        return labels
+
+
+class GaussianMixtureClassifier:
+    """Класс для Gaussian Mixture кластеризации."""
+
+    @staticmethod
+    def __get_cluster(data, number_of_clusters):
+        cluster = GaussianMixture(n_components=number_of_clusters,
+                                  random_state=RANDOM_STATE)
+        cluster.fit(data)
+        return cluster
+
+    @staticmethod
+    def __get_cluster_centers(gm, data):
+        centers = np.empty(shape=(gm.n_components, data.shape[1]))
+        for i in range(gm.n_components):
+            density = stats.multivariate_normal(cov=gm.covariances_[i], mean=gm.means_[i]).logpdf(data)
+            centers[i, :] = data[np.argmax(density)]
+        centers = np.sum(centers, axis=1)
+        return centers
+
+    @staticmethod
+    def __get_labels(data, n_clusters):
+        gm = GaussianMixtureClassifier.__get_cluster(data, n_clusters)
+        gm_labels_before_sorting = gm.predict(data)
+        gm_centers = GaussianMixtureClassifier.__get_cluster_centers(gm, data)
+        gm_uniq_labels = np.unique(gm_labels_before_sorting)
+        sorted_gm_uniq_labels = gm_uniq_labels[np.argsort(gm_centers)]
+
+        gm_labels = np.zeros_like(gm_labels_before_sorting)
+        for i, label in enumerate(sorted_gm_uniq_labels):
+            gm_labels[gm_labels_before_sorting == label] = i
+
+        return gm_labels
+
+    @staticmethod
+    def find_the_best_number_of_clusters(data: np.ndarray) -> int:
+        """
+        Подбирает оптимальное количество кластеров на основе Байесовского критерия.
+
+        Parameters
+        ----------
+        data: np.ndarray
+            2D массив значений.
+
+        Returns
+        -------
+        int
+            Оптимальное количество кластеров.
+        """
+
+        assert data.ndim == 2, "data: Ожидался 2D массив"
+
+        bic_list = []
+        number_of_clusters_list = range(2, min(15, data.shape[0] + 1))
+        for number_of_clusters in number_of_clusters_list:
+            gm = GaussianMixtureClassifier.__get_cluster(data, number_of_clusters)
+            bic = -gm.bic(data)
+            if bic < 0:
+                bic = np.nan
+            bic_list.append(bic)
+        bic_list = np.asarray(bic_list)
+        # bic_list_log = np.log(bic_list)
+        # best_number_of_clusters = number_of_clusters_list[np.nanargmin(bic_list_log)]
+        best_number_of_clusters = number_of_clusters_list[np.nanargmin(bic_list)]
+        return best_number_of_clusters
+
+    @staticmethod
+    def calculate(data: np.ndarray, n_clusters: int) -> np.ndarray:
+        """
+        Распределяет объекты по n_clusters кластерам, предполагая, что данные состоят из смеси гауссовых распределений.
+
+        Parameters
+        ----------
+        data: np.ndarray
+            Массив значений (N, M). Где N - количество точек, M - количество атрибутов.
+        n_clusters: int
+            Количество кластеров.
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert data.ndim == 2, "data: Ожидался 2D массив"
+        assert n_clusters > 0, "Параметр n_clusters должен принимать положительное значение"
+
+        labels = GaussianMixtureClassifier.__get_labels(data=data, n_clusters=n_clusters)
+        return labels
+
+
+class HDBSCANClassifier:
+    """Класс для HDBSCAN кластеризации."""
+
+    @staticmethod
+    def __get_cluster(data, min_cluster_size, min_samples, cluster_selection_epsilon):
+        cluster = HDBSCAN(min_cluster_size=min_cluster_size, min_samples=min_samples,
+                          cluster_selection_epsilon=cluster_selection_epsilon)
+        cluster.fit(data)
+        return cluster
+
+    @staticmethod
+    def __get_labels(data, min_cluster_size, min_samples, cluster_selection_epsilon):
+        hdbscan = HDBSCANClassifier.__get_cluster(data, min_cluster_size, min_samples, cluster_selection_epsilon)
+        hdbscan_labels = hdbscan.labels_
+        return hdbscan_labels
+
+    @staticmethod
+    def get_number_of_clusters(labels: np.ndarray) -> int:
+        """
+        Возвращает количество кластеров.
+
+        Parameters
+        ----------
+        labels: np.ndarray
+            1D массив меток.
+
+        Returns
+        -------
+        int
+            Количество кластеров.
+        """
+
+        assert labels.ndim == 1, "labels: Ожидался 1D массив"
+
+        return np.unique(labels).shape[0]
+
+    @staticmethod
+    def calculate(data: np.ndarray,
+                  min_cluster_size: int = 5,
+                  min_samples: int = None,
+                  cluster_selection_epsilon: float = 0.0) -> np.ndarray:
+        """
+        Выявляет кластеры в наборе данных на основе распределения плотности точек данных.
+
+        Parameters
+        ----------
+        data: np.ndarray
+            Массив значений (N, M). Где N-количество точек, M - количество атрибутов.
+        min_cluster_size: int, default=5
+            Минимальное количество выборок, чтобы эта группа считалась кластером(параметр HDBSCAN).
+        min_samples: int, default=None
+            Минимальное количество выборок в окрестности, чтобы точка считалась центральной(параметр HDBSCAN).
+        cluster_selection_epsilon: float, default=0.0
+            Максимальное расстояние, допустимое между точками, чтобы они считались связанными в процессе кластеризации на основе плотности(параметр HDBSCAN).
+
+        Returns
+        -------
+        np.ndarray
+            Массив меток размера N.
+        """
+
+        assert data.ndim == 2, "data: Ожидался 2D массив"
+
+        labels = HDBSCANClassifier.__get_labels(data, min_cluster_size, min_samples, cluster_selection_epsilon)
+        return labels

cratonml-0.1.1.0/cratonml/calculate/DimensionReduction.py

@@ -0,0 +1,52 @@
+import numpy as np
+from sklearn.decomposition import PCA
+
+
+RANDOM_STATE = 42
+
+
+def get_pca_statistics(data: np.ndarray) -> np.ndarray:
+    """
+    Считает долю дисперсии для каждого компонента.
+
+    Parameters
+    ----------
+    data: np.ndarray
+        Массив значений, размера (N, M).
+
+    Returns
+    -------
+    np.ndarray
+        Массив доль дисперсии, размера N.
+    """
+
+    assert data.ndim == 2, "data: Ожидался 2D массив"
+
+    pca = PCA(n_components=data.shape[1],
+              random_state=RANDOM_STATE)
+    pca.fit(data)
+    return pca.explained_variance_ratio_
+
+
+def pca_transform(data: np.ndarray, n_components: int) -> np.ndarray:
+    """
+    Понижение размерности с помощью PCA путём проецирования данных на главные (собственные) вектора.
+
+    Parameters
+    ----------
+    data: np.ndarray
+        Массив значений, размера (N, M).
+    n_components: int
+        Количество сохраняемых компонентов.
+
+    Returns
+    -------
+    np.ndarray
+        Преобразованный массив, размера (N, n_components).
+    """
+
+    assert data.ndim == 2, "data: Ожидался 2D массив"
+    assert n_components > 0, "Параметр n_components должен принимать положительное значение"
+
+    return PCA(n_components=n_components,
+               random_state=RANDOM_STATE).fit_transform(data)

cratonml-0.1.1.0/cratonml/calculate/PostProcessing.py

@@ -0,0 +1,68 @@
+import numpy as np
+from .curve_utils import get_peaks, remove_single_width_peaks, remove_given_width_peaks
+
+
+def fill_with_value_by_mask(data: np.ndarray, mask: np.ndarray, blank_code: float) -> np.ndarray:
+    """
+    Востанавливает массив, заполняя кодом бланковки по маске.
+
+    Parameters
+    ----------
+    data: np.ndarray
+        Массив значений, размером N.
+    mask: np.ndarray
+        Маска(True - в строке был nan, False - в строке не было nan), размером M >= N.
+    blank_code: float
+        Код бланковки.
+
+    Returns
+    -------
+    np.ndarray
+        Востановленный массив, размером M.
+    """
+
+    assert data.ndim == 1, "data: Ожидался 1D массив"
+    assert mask.ndim == 1, "mask: Ожидался 1D массив"
+    assert mask.shape[0] >= data.shape[0], "Длина массива mask должна быть не меньше длины data"
+
+    data_with_blank_code = np.zeros(mask.shape[0])
+    data_with_blank_code[mask] = blank_code
+    data_with_blank_code[~mask] = data
+    return data_with_blank_code
+
+
+def curve_peaks_processing(curve: np.ndarray, depth: np.ndarray, minimal_width_in_meter: float) -> np.ndarray:
+    """
+    Обработка пиков кривой. Удаление пиков, которые меньше заданной ширины (minimal_width_in_meter).
+
+    Parameters
+    ----------
+    curve: np.ndarray
+        Массив значений кривой, размером N.
+    depth: np.ndarray
+        Массив глубин кривой, размером N.
+    minimal_width_in_meter: float
+        Минимальная ширина пиков в метрах.
+
+    Returns
+    -------
+    np.ndarray
+        Обработанная кривая, размером N.
+    """
+
+    assert curve.ndim == 1, "curve: Ожидался 1D массив"
+    assert depth.ndim == 1, "depth: Ожидался 1D массив"
+    assert minimal_width_in_meter > 0, "Параметр minimal_width_in_meter должен принимать положительное значение"
+
+    dz = np.diff(depth)[0]
+    minimal_width_in_sample = int(minimal_width_in_meter / dz)
+
+    single_peaks = get_peaks(curve, 1)
+    single_filled_curve = remove_single_width_peaks(curve, single_peaks)
+
+    given_width_peaks = get_peaks(single_filled_curve, minimal_width_in_sample)
+    filled_curve = remove_given_width_peaks(single_filled_curve,
+                                            given_width_peaks,
+                                            minimal_width_in_sample)
+    filled_curve = abs(filled_curve - 1)
+    return filled_curve