sequenzo 0.1.31__cp310-cp310-macosx_10_9_x86_64.whl

sequenzo/clustering/src/module.cpp

@@ -0,0 +1,228 @@
+#include "PAM.cpp"
+#include "KMedoid.cpp"
+#include "PAMonce.cpp"
+#include "weightedinertia.cpp"
+#include "cluster_quality.cpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(clustering_c_code, m) {
+    py::class_<PAM>(m, "PAM")
+            .def(py::init<int, py::array_t<double>, py::array_t<int>, int, py::array_t<double>>())
+            .def("runclusterloop", &PAM::runclusterloop);
+
+    py::class_<KMedoid>(m, "KMedoid")
+            .def(py::init<int, py::array_t<double>, py::array_t<int>, int, py::array_t<double>>())
+            .def("runclusterloop", &KMedoid::runclusterloop);
+
+    py::class_<PAMonce>(m, "PAMonce")
+            .def(py::init<int, py::array_t<double>, py::array_t<int>, int, py::array_t<double>>())
+            .def("runclusterloop", &PAMonce::runclusterloop);
+
+    py::class_<weightedinertia>(m, "weightedinertia")
+            .def(py::init<py::array_t<double>, py::array_t<int>, py::array_t<double>>())
+            .def("tmrWeightedInertiaContrib", &weightedinertia::tmrWeightedInertiaContrib);
+
+    // Cluster Quality functions
+    m.def("cluster_quality", [](py::array_t<double> diss_matrix, 
+                               py::array_t<int> cluster_labels,
+                               py::array_t<double> weights,
+                               int nclusters) -> py::dict {
+        auto diss_buf = diss_matrix.request();
+        auto cluster_buf = cluster_labels.request();
+        auto weights_buf = weights.request();
+        
+        if (diss_buf.ndim != 2 || diss_buf.shape[0] != diss_buf.shape[1]) {
+            throw std::runtime_error("Distance matrix must be square");
+        }
+        
+        int n = diss_buf.shape[0];
+        
+        if (cluster_buf.size != n || weights_buf.size != n) {
+            throw std::runtime_error("Cluster labels and weights must have same length as matrix dimension");
+        }
+        
+        double* diss_ptr = static_cast<double*>(diss_buf.ptr);
+        int* cluster_ptr = static_cast<int*>(cluster_buf.ptr);
+        double* weights_ptr = static_cast<double*>(weights_buf.ptr);
+        
+        // Prepare output arrays
+        std::vector<double> stats(ClusterQualNumStat);
+        std::vector<double> asw(2 * nclusters);
+        
+        // Create Kendall tree for caching
+        KendallTree kendall;
+        
+        // Call core function
+        clusterquality(diss_ptr, cluster_ptr, weights_ptr, n, 
+                      stats.data(), nclusters, asw.data(), kendall);
+        
+        // Clean up Kendall tree
+        finalizeKendall(kendall);
+        
+        // Return results as dictionary
+        py::dict result;
+        result["PBC"] = stats[ClusterQualHPG];  // PBC is stored in HPG position
+        result["HG"] = stats[ClusterQualHG];
+        result["HGSD"] = stats[ClusterQualHGSD];
+        result["ASW"] = stats[ClusterQualASWi];
+        result["ASWw"] = stats[ClusterQualASWw];
+        result["CH"] = stats[ClusterQualF];
+        result["R2"] = stats[ClusterQualR];
+        result["CHsq"] = stats[ClusterQualF2];
+        result["R2sq"] = stats[ClusterQualR2];
+        result["HC"] = stats[ClusterQualHC];
+        
+        // Convert ASW array to numpy array
+        auto asw_array = py::array_t<double>(2 * nclusters);
+        auto asw_buf = asw_array.request();
+        double* asw_out = static_cast<double*>(asw_buf.ptr);
+        std::copy(asw.begin(), asw.end(), asw_out);
+        result["cluster_asw"] = asw_array;
+        
+        return result;
+    }, "Compute cluster quality indicators for full distance matrix");
+
+    m.def("cluster_quality_condensed", [](py::array_t<double> diss_condensed,
+                                         py::array_t<int> cluster_labels,
+                                         py::array_t<double> weights,
+                                         int n, int nclusters) -> py::dict {
+        auto diss_buf = diss_condensed.request();
+        auto cluster_buf = cluster_labels.request();
+        auto weights_buf = weights.request();
+        
+        int expected_size = n * (n - 1) / 2;
+        if (diss_buf.size != expected_size) {
+            throw std::runtime_error("Condensed distance array size mismatch");
+        }
+        
+        if (cluster_buf.size != n || weights_buf.size != n) {
+            throw std::runtime_error("Cluster labels and weights must have length n");
+        }
+        
+        double* diss_ptr = static_cast<double*>(diss_buf.ptr);
+        int* cluster_ptr = static_cast<int*>(cluster_buf.ptr);
+        double* weights_ptr = static_cast<double*>(weights_buf.ptr);
+        
+        // Prepare output arrays
+        std::vector<double> stats(ClusterQualNumStat);
+        std::vector<double> asw(2 * nclusters);
+        
+        // Create Kendall tree for caching
+        KendallTree kendall;
+        
+        // Call core function
+        clusterquality_dist(diss_ptr, cluster_ptr, weights_ptr, n,
+                           stats.data(), nclusters, asw.data(), kendall);
+        
+        // Clean up Kendall tree
+        finalizeKendall(kendall);
+        
+        // Return results as dictionary
+        py::dict result;
+        result["PBC"] = stats[ClusterQualHPG];  // PBC is stored in HPG position
+        result["HG"] = stats[ClusterQualHG];
+        result["HGSD"] = stats[ClusterQualHGSD];
+        result["ASW"] = stats[ClusterQualASWi];
+        result["ASWw"] = stats[ClusterQualASWw];
+        result["CH"] = stats[ClusterQualF];
+        result["R2"] = stats[ClusterQualR];
+        result["CHsq"] = stats[ClusterQualF2];
+        result["R2sq"] = stats[ClusterQualR2];
+        result["HC"] = stats[ClusterQualHC];
+        
+        // Convert ASW array to numpy array
+        auto asw_array = py::array_t<double>(2 * nclusters);
+        auto asw_buf = asw_array.request();
+        double* asw_out = static_cast<double*>(asw_buf.ptr);
+        std::copy(asw.begin(), asw.end(), asw_out);
+        result["cluster_asw"] = asw_array;
+        
+        return result;
+    }, "Compute cluster quality indicators for condensed distance array");
+
+    m.def("individual_asw", [](py::array_t<double> diss_matrix,
+                              py::array_t<int> cluster_labels,
+                              py::array_t<double> weights,
+                              int nclusters) -> py::dict {
+        auto diss_buf = diss_matrix.request();
+        auto cluster_buf = cluster_labels.request();
+        auto weights_buf = weights.request();
+        
+        if (diss_buf.ndim != 2 || diss_buf.shape[0] != diss_buf.shape[1]) {
+            throw std::runtime_error("Distance matrix must be square");
+        }
+        
+        int n = diss_buf.shape[0];
+        
+        if (cluster_buf.size != n || weights_buf.size != n) {
+            throw std::runtime_error("Cluster labels and weights must have same length as matrix dimension");
+        }
+        
+        double* diss_ptr = static_cast<double*>(diss_buf.ptr);
+        int* cluster_ptr = static_cast<int*>(cluster_buf.ptr);
+        double* weights_ptr = static_cast<double*>(weights_buf.ptr);
+        
+        // Prepare output arrays
+        auto asw_i = py::array_t<double>(n);
+        auto asw_w = py::array_t<double>(n);
+        
+        auto asw_i_buf = asw_i.request();
+        auto asw_w_buf = asw_w.request();
+        
+        double* asw_i_ptr = static_cast<double*>(asw_i_buf.ptr);
+        double* asw_w_ptr = static_cast<double*>(asw_w_buf.ptr);
+        
+        // Call core function
+        indiv_asw(diss_ptr, cluster_ptr, weights_ptr, n, nclusters, asw_i_ptr, asw_w_ptr);
+        
+        // Return results as dictionary
+        py::dict result;
+        result["asw_individual"] = asw_i;
+        result["asw_weighted"] = asw_w;
+        
+        return result;
+    }, "Compute individual ASW scores for all samples");
+
+    m.def("individual_asw_condensed", [](py::array_t<double> diss_condensed,
+                                        py::array_t<int> cluster_labels,
+                                        py::array_t<double> weights,
+                                        int n, int nclusters) -> py::dict {
+        auto diss_buf = diss_condensed.request();
+        auto cluster_buf = cluster_labels.request();
+        auto weights_buf = weights.request();
+        
+        int expected_size = n * (n - 1) / 2;
+        if (diss_buf.size != expected_size) {
+            throw std::runtime_error("Condensed distance array size mismatch");
+        }
+        
+        if (cluster_buf.size != n || weights_buf.size != n) {
+            throw std::runtime_error("Cluster labels and weights must have length n");
+        }
+        
+        double* diss_ptr = static_cast<double*>(diss_buf.ptr);
+        int* cluster_ptr = static_cast<int*>(cluster_buf.ptr);
+        double* weights_ptr = static_cast<double*>(weights_buf.ptr);
+        
+        // Prepare output arrays
+        auto asw_i = py::array_t<double>(n);
+        auto asw_w = py::array_t<double>(n);
+        
+        auto asw_i_buf = asw_i.request();
+        auto asw_w_buf = asw_w.request();
+        
+        double* asw_i_ptr = static_cast<double*>(asw_i_buf.ptr);
+        double* asw_w_ptr = static_cast<double*>(asw_w_buf.ptr);
+        
+        // Call core function
+        indiv_asw_dist(diss_ptr, cluster_ptr, weights_ptr, n, nclusters, asw_i_ptr, asw_w_ptr);
+        
+        // Return results as dictionary
+        py::dict result;
+        result["asw_individual"] = asw_i;
+        result["asw_weighted"] = asw_w;
+        
+        return result;
+    }, "Compute individual ASW scores for condensed distance array");
+}

sequenzo/clustering/src/weightedinertia.cpp

@@ -0,0 +1,111 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <iostream>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+#include <cfloat>
+#include <cmath>
+
+namespace py = pybind11;
+
+class weightedinertia {
+public:
+    weightedinertia(py::array_t<double> distmatrix, py::array_t<int> individuals, py::array_t<double> weights) {
+        std::cout << std::flush;  // 刷新 C++ 输出
+
+        try {
+            this->distmatrix = distmatrix;
+            this->individuals = individuals;
+            this->weights = weights;
+
+            ilen = individuals.size();
+
+            result = py::array_t<double>(ilen);
+        } catch (const std::exception& e) {
+            py::print("Error in constructor: ", e.what());
+            throw;
+        }
+    }
+
+    py::array_t<double> tmrWeightedInertiaContrib() {
+        auto ptr_dist = distmatrix.unchecked<2>();
+        auto ptr_indiv = individuals.unchecked<1>();
+        auto ptr_weights = weights.unchecked<1>();
+
+        py::array_t<double> result_local(ilen);
+        auto ptr_result = result_local.mutable_unchecked<1>();
+
+        for (int i = 0; i < ilen; i++) {
+            ptr_result(i) = 0.0;
+        }
+
+        double totweights = 0.0;
+
+        #pragma omp parallel for reduction(+:totweights)
+        for (int i = 0; i < ilen; i++) {
+            totweights += ptr_weights(ptr_indiv(i));
+        }
+
+        // 每个线程使用局部 result 副本，最后归约合并
+        int nthreads = 1;
+        #ifdef _OPENMP
+        #pragma omp parallel
+        {
+            #pragma omp single
+            nthreads = omp_get_num_threads();
+        }
+        #endif
+
+        std::vector<std::vector<double>> result_private(nthreads, std::vector<double>(ilen, 0.0));
+
+        #pragma omp parallel
+        {
+            #ifdef _OPENMP
+            int tid = omp_get_thread_num();
+            #else
+            int tid = 0;
+            #endif
+            auto& local = result_private[tid];
+
+            #pragma omp for schedule(static)
+            for (int i = 0; i < ilen; ++i) {
+                int pos_i = ptr_indiv(i);
+                double i_weight = ptr_weights(pos_i);
+
+                for (int j = i + 1; j < ilen; ++j) {
+                    int pos_j = ptr_indiv(j);
+                    double diss = ptr_dist(pos_i, pos_j);
+
+                    local[i] += diss * ptr_weights(pos_j);
+                    local[j] += diss * i_weight;
+                }
+            }
+        }
+
+        // 合并各线程的 result_private 到主 result
+        for (int t = 0; t < nthreads; ++t) {
+            for (int i = 0; i < ilen; ++i) {
+                ptr_result(i) += result_private[t][i];
+            }
+        }
+
+        if (totweights > 0) {
+            #pragma omp parallel for
+            for (int i = 0; i < ilen; ++i) {
+                ptr_result(i) /= totweights;
+            }
+        }
+
+        return result_local;
+    }
+
+private:
+    py::array_t<double> distmatrix;  // 距离矩阵
+    py::array_t<int> individuals;    // 某组数据点的集合
+    py::array_t<double> weights;     // 权重数组
+
+    int ilen;
+    py::array_t<double> result;
+};

sequenzo/clustering/utils/__init__.py

@@ -0,0 +1,27 @@
+"""
+@Author  : Yuqi Liang 梁彧祺
+@File    : __init__.py
+@Time    : 27/02/2025 10:38
+@Desc    : 
+"""
+# utils/__init__.py
+
+from .disscenter import disscentertrim
+
+
+def _import_c_code():
+    """Lazily import the c_code module to avoid circular dependencies during installation"""
+    try:
+        from sequenzo.dissimilarity_measures.src import c_code
+        return c_code
+    except ImportError:
+        # If the C extension cannot be imported, return None
+        print(
+            "Warning: The C++ extension (c_code) could not be imported. Please ensure the extension module is compiled correctly.")
+        return None
+
+
+__all__ = [
+    "disscentertrim",
+    # Add other functions as needed
+]

sequenzo/clustering/utils/disscenter.py

@@ -0,0 +1,122 @@
+"""
+@Author  : 李欣怡
+@File    : disscenter.py
+@Time    : 2025/2/8 12:57
+@Desc    :
+    Utility function for the k_medoids algorithm.
+"""
+
+import numpy as np
+import pandas as pd
+
+import importlib
+import sequenzo.clustering.clustering_c_code
+
+clustering_c_code = importlib.import_module("sequenzo.clustering.clustering_c_code")
+
+def disscentertrim(diss, group=None, medoids_index=None, allcenter=False, weights=None, squared=False, trim=0):
+
+    # Lazily import the c_code module to avoid circular dependencies during installation
+    # from .__init__ import _import_c_code
+    # c_code = _import_c_code()
+
+    if isinstance(medoids_index, bool):
+        if medoids_index:
+            medoids_index = "First"
+        else:
+            medoids_index = None
+
+    retmedoids = medoids_index is not None  # Whether medoids need to be returned
+    if retmedoids:
+        allcenter = False
+
+    allmedoids = False
+
+    if medoids_index is not None:
+        if medoids_index == "all":
+            allmedoids = True
+        elif medoids_index != "first":
+            raise ValueError('\'medoids_index\' argument should be one of "First", "all" or None')
+
+    if weights is None:
+        weights = np.ones(len(diss), dtype=float)
+
+    if squared:
+        diss = np.square(diss)
+
+    if group is None:
+        group = np.ones(diss.shape[0], dtype=int)
+
+    ind = np.arange(diss.shape[0])
+    grp = np.array(group)
+    lgrp = np.unique(group)
+
+    if allcenter:
+        ret = pd.DataFrame(np.zeros((diss.shape[0], 1)))
+    else:
+        ret = np.zeros(diss.shape[0])
+
+    if retmedoids:
+        if allmedoids:
+            medoids = []
+        else:
+            medoids = np.zeros(len(lgrp))
+
+    for i in range(len(lgrp)):
+        cond = (grp == lgrp[i])
+        grpindiv = ind[cond]   # 第 i 组所有数据点在隶属矩阵里的位置（0-based 索引）
+
+        if allcenter:
+            # TODO : 以后再补充
+            print("以后再补充")
+
+        else:
+            inertia = clustering_c_code.weightedinertia(diss.astype(np.float64),
+                                                        grpindiv.astype(np.int32),
+                                                        weights.astype(np.float64))
+            dc = inertia.tmrWeightedInertiaContrib()
+            dc = dc - np.average(dc, weights=weights[cond]) / 2
+
+            if trim > 0:
+                # TODO : 以后再补充
+                print("以后再补充")
+
+            ret[grpindiv] = dc
+            mindc = np.min(dc)
+
+            if retmedoids:
+                if allmedoids:
+                    medoids.append(np.where((ret == mindc) & cond)[0])
+                else:
+                    medoids[i] = np.where((ret == mindc) & cond)[0][0]
+
+    if retmedoids:
+        if len(lgrp) == 1:
+            return medoids[[1]]
+
+        return medoids
+
+    return ret
+
+
+if __name__ == '__main__':
+    # Load the data that we would like to explore in this tutorial
+    # `df` is the short for `dataframe`, which is a common variable name for a dataset
+    from sequenzo import *
+    df = load_dataset('country_co2_emissions')
+
+    time = list(df.columns)[1:]
+
+    states = ['Very Low', 'Low', 'Middle', 'High', 'Very High']
+
+    sequence_data = SequenceData(df, time=time, states=states)
+
+    result = clara(seqdata=sequence_data,
+                   R=2,
+                   kvals=range(2, 21),
+                   sample_size=3000,
+                   criteria=['distance', 'pbm'],
+                   parallel=True,
+                   stability=True)
+    result = result['allstat']
+

sequenzo/data_preprocessing/__init__.py

@@ -0,0 +1,22 @@
+"""
+@Author  : Yuqi Liang 梁彧祺
+@File    : __init__.py
+@Time    : 01/05/2025 09:27
+@Desc    : 
+"""
+from .helpers import (clean_time_columns_auto,
+                      assign_unique_ids,
+                      wide_to_long_format_data,
+                      long_to_wide_format_data,
+                      summarize_missing_values,
+                      replace_cluster_id_by_labels)
+
+
+__all__ = [
+    "clean_time_columns_auto",
+    "assign_unique_ids",
+    "wide_to_long_format_data",
+    "long_to_wide_format_data",
+    "summarize_missing_values",
+    "replace_cluster_id_by_labels"
+]