flkit 0.1.0__py3-none-any.whl

flkit/alg/inter/idw.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+反距离权重插值算法实现
+Inverse Distance Weighting (IDW) Interpolation
+
+IDW是一种基于距离的插值方法，距离越近的点权重越大。
+适用于地理空间数据插值，计算简单高效。
+"""
+
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+class IDW2D:
+    """
+    二维反距离加权插值
+
+    适用于地形高程插值、温度分布等二维空间数据插值
+    """
+
+    def __init__(self, p: float = 2.0, k: int = 12, eps: float = 1e-8):
+        """
+        初始化IDW2D插值器
+
+        Parameters:
+        -----------
+        p : float, default=2.0
+            距离权重指数，值越大距离影响越强
+        k : int, default=12
+            使用的最近邻点数量
+        eps : float, default=1e-8
+            数值稳定性参数
+        """
+        self.p = p
+        self.k = k
+        self.eps = eps
+        self.tree = None
+        self.known_z = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练IDW模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, 3)
+            已知点数据，每行为 [x, y, z]，其中z为插值目标值
+
+        Returns:
+        --------
+        self : IDW2D
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] != 3:
+            raise ValueError("输入数据必须是3列：[x, y, z]")
+
+        self.tree = cKDTree(xyzv[:, :2])
+        self.known_z = xyzv[:, 2]
+        return self
+
+    def predict(self, xy: np.ndarray):
+        """
+        在指定位置进行插值预测
+
+        Parameters:
+        -----------
+        xy : np.ndarray, shape (M, 2) or (2,)
+            待插值点的坐标 [x, y]
+
+        Returns:
+        --------
+        float or np.ndarray
+            - 单点输入 (2,): 返回标量值
+            - 多点输入 (M, 2): 返回数组 shape (M,)
+        """
+        if self.tree is None:
+            raise ValueError("模型尚未训练，请先调用 fit() 方法")
+
+        # 检查输入是单点还是多点
+        is_single_point = xy.ndim == 1 or (xy.ndim == 2 and xy.shape[0] == 1)
+
+        xy = np.atleast_2d(xy)
+        if xy.shape[1] != 2:
+            raise ValueError("预测点坐标必须是2列：[x, y]")
+
+        # 查找最近邻点
+        dist, idx = self.tree.query(xy, k=min(self.k, len(self.known_z)), eps=self.eps)
+
+        # 处理单点查询的情况
+        if dist.ndim == 1:
+            dist = dist.reshape(1, -1)
+            idx = idx.reshape(1, -1)
+
+        # 避免除零错误
+        dist = np.maximum(dist, self.eps)
+
+        # 计算权重
+        w = 1.0 / (dist**self.p)
+
+        # 加权平均
+        z = np.sum(w * self.known_z[idx], axis=1) / np.sum(w, axis=1)
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(z[0])  # 单点返回标量
+        else:
+            return z  # 多点返回数组
+
+
+class IDW3D:
+    """
+    三维反距离加权插值
+
+    适用于三维空间中的属性插值，如地质属性、污染物浓度等
+    """
+
+    def __init__(self, p: float = 2.0, k: int = 15, eps: float = 1e-8):
+        """
+        初始化IDW3D插值器
+
+        Parameters:
+        -----------
+        p : float, default=2.0
+            距离权重指数
+        k : int, default=15
+            使用的最近邻点数量
+        eps : float, default=1e-8
+            数值稳定性参数
+        """
+        self.p = p
+        self.k = k
+        self.eps = eps
+        self.tree = None
+        self.known_v = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练IDW3D模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, 4)
+            已知点数据，每行为 [x, y, z, value]
+
+        Returns:
+        --------
+        self : IDW3D
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] != 4:
+            raise ValueError("输入数据必须是4列：[x, y, z, value]")
+
+        self.tree = cKDTree(xyzv[:, :3])
+        self.known_v = xyzv[:, 3]
+        return self
+
+    def predict(self, xyz: np.ndarray):
+        """
+        在指定位置进行插值预测
+
+        Parameters:
+        -----------
+        xyz : np.ndarray, shape (M, 3) or (3,)
+            待插值点的坐标 [x, y, z]
+
+        Returns:
+        --------
+        float or np.ndarray
+            - 单点输入 (3,): 返回标量值
+            - 多点输入 (M, 3): 返回数组 shape (M,)
+        """
+        if self.tree is None:
+            raise ValueError("模型尚未训练，请先调用 fit() 方法")
+
+        # 检查输入是单点还是多点
+        is_single_point = xyz.ndim == 1 or (xyz.ndim == 2 and xyz.shape[0] == 1)
+
+        xyz = np.atleast_2d(xyz)
+        if xyz.shape[1] != 3:
+            raise ValueError("预测点坐标必须是3列：[x, y, z]")
+
+        # 查找最近邻点
+        dist, idx = self.tree.query(xyz, k=min(self.k, len(self.known_v)), eps=self.eps)
+
+        # 处理单点查询的情况
+        if dist.ndim == 1:
+            dist = dist.reshape(1, -1)
+            idx = idx.reshape(1, -1)
+
+        # 避免除零错误
+        dist = np.maximum(dist, self.eps)
+
+        # 计算权重
+        w = 1.0 / (dist**self.p)
+
+        # 加权平均
+        v = np.sum(w * self.known_v[idx], axis=1) / np.sum(w, axis=1)
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(v[0])  # 单点返回标量
+        else:
+            return v  # 多点返回数组
+
+    def predict_grid(self, x_range, y_range, z_range, resolution=None):
+        """
+        在规则网格上进行预测
+
+        Parameters:
+        -----------
+        x_range : tuple
+            x方向的范围 (x_min, x_max)
+        y_range : tuple
+            y方向的范围 (y_min, y_max)
+        z_range : tuple
+            z方向的范围 (z_min, z_max)
+        resolution : tuple, optional
+            网格分辨率 (nx, ny, nz)，默认为 (50, 50, 50)
+
+        Returns:
+        --------
+        tuple
+            (grid_x, grid_y, grid_z, predictions)
+            - grid_x, grid_y, grid_z: 网格坐标
+            - predictions: 预测值网格
+        """
+        if self.tree is None:
+            raise ValueError("模型尚未训练，请先调用 fit() 方法")
+
+        if resolution is None:
+            resolution = (50, 50, 50)
+
+        # 创建网格
+        x = np.linspace(x_range[0], x_range[1], resolution[0])
+        y = np.linspace(y_range[0], y_range[1], resolution[1])
+        z = np.linspace(z_range[0], z_range[1], resolution[2])
+
+        grid_x, grid_y, grid_z = np.meshgrid(x, y, z, indexing="ij")
+
+        # 展平网格点进行预测
+        points = np.column_stack([grid_x.ravel(), grid_y.ravel(), grid_z.ravel()])
+
+        predictions = self.predict(points)
+        predictions = predictions.reshape(grid_x.shape)
+
+        return grid_x, grid_y, grid_z, predictions
+
+
+# 向下兼容旧接口
+IDW = IDW2D

flkit/alg/inter/midw.py

@@ -0,0 +1,145 @@
+import numpy as np
+from .BasePredictor import Predictor
+from .LossFuncs import ErrorMetrics
+
+
+class IDW(Predictor):
+    class IDWModel:
+        def __init__(self, x, y, value, power=2):
+            self.x = x
+            self.y = y
+            self.value = value
+            self.power = power
+
+        def execute(self, point_x, point_y):
+            numerator = 0
+            denominator = 0
+
+            for i, (x, y, val) in enumerate(zip(self.x, self.y, self.value)):
+                d = ((x - point_x) ** 2 + (y - point_y) ** 2) ** 0.5
+                if d == 0:
+                    return val, 0
+                weight = 1 / (d**self.power)
+                numerator += weight * val
+                denominator += weight
+
+            result = numerator / denominator
+            return result, 0
+
+    def fit(self, data: np.ndarray):
+        x = data[:, 0]
+        y = data[:, 1]
+        z = data[:, 2]
+        self.model = self.IDWModel(x, y, z)
+
+    def predict(self, points: np.ndarray):
+        z1 = np.zeros(points.shape[0])
+        for i in range(points.shape[0]):
+            z1[i], _ = self.model.execute(points[i, 0], points[i, 1])
+        return z1
+
+    def loss(self, data, res):
+        return ErrorMetrics.mse(data, res)
+
+
+class IDWOpm(Predictor):
+    class IDWModel:
+        def __init__(self, x, y, value, power=2):
+            self.x = x
+            self.y = y
+            self.value = value
+            self.power = power
+
+        def execute(self, point_x, point_y):
+            numerator = 0
+            denominator = 0
+
+            for i, (x, y, val) in enumerate(zip(self.x, self.y, self.value)):
+                d = ((x - point_x) ** 2 + (y - point_y) ** 2) ** 0.5
+                if d == 0:
+                    return val, 0
+                weight = 1 / (d**self.power)
+                numerator += weight * val
+                denominator += weight
+
+            result = numerator / denominator
+            return result, 0
+
+    def fit(self, data):
+        arr = np.asarray(data)
+        if arr.ndim != 2 or arr.shape[1] != 3:
+            raise ValueError("输入数据必须是3列：[x, y, z]")
+        x, y, z = arr[:, 0], arr[:, 1], arr[:, 2]
+        self.model = self.IDWModel(x.tolist(), y.tolist(), z.tolist())
+        return self
+
+    def predict(self, points):
+        arr = np.asarray(points)
+        if arr.ndim == 1:
+            x, y = float(arr[0]), float(arr[1])
+            result, _ = self.model.execute(x, y)
+            return result
+        elif arr.ndim == 2 and arr.shape[1] == 2:
+            z1 = np.zeros(arr.shape[0], dtype=float)
+            for i in range(arr.shape[0]):
+                z1[i], _ = self.model.execute(float(arr[i, 0]), float(arr[i, 1]))
+            return z1
+        else:
+            raise ValueError("预测点坐标必须是2列：[x, y] 或形状 (M, 2)")
+
+    def loss(self, data, res):
+        return ErrorMetrics.mse(data, res)
+
+
+class IDWOpm3D(Predictor):
+    class IDWModel:
+        def __init__(self, x, y, z, value, power=2):
+            self.x = x
+            self.y = y
+            self.z = z
+            self.value = value
+            self.power = power
+
+        def execute(self, point_x, point_y, point_z):
+            numerator = 0
+            denominator = 0
+
+            for i, (x, y, z, val) in enumerate(zip(self.x, self.y, self.z, self.value)):
+                d = (
+                    (x - point_x) ** 2 + (y - point_y) ** 2 + (z - point_z) ** 2
+                ) ** 0.5
+                if d == 0:
+                    return val, 0
+                weight = 1 / (d**self.power)
+                numerator += weight * val
+                denominator += weight
+
+            result = numerator / denominator
+            return result, 0
+
+    def fit(self, data):
+        arr = np.asarray(data)
+        if arr.ndim != 2 or arr.shape[1] != 4:
+            raise ValueError("输入数据必须是4列：[x, y, z, value]")
+        x, y, z, value = arr[:, 0], arr[:, 1], arr[:, 2], arr[:, 3]
+        self.model = self.IDWModel(x.tolist(), y.tolist(), z.tolist(), value.tolist())
+        return self
+
+    def predict(self, points):
+        arr = np.asarray(points)
+        if arr.ndim == 1:
+            x, y, z = float(arr[0]), float(arr[1]), float(arr[2])
+            result, _ = self.model.execute(x, y, z)
+            return result
+        elif arr.ndim == 2 and arr.shape[1] == 3:
+            z1 = np.zeros(arr.shape[0], dtype=float)
+            for i in range(arr.shape[0]):
+                z1[i], _ = self.model.execute(
+                    float(arr[i, 0]), float(arr[i, 1]), float(arr[i, 2])
+                )
+            return z1
+        else:
+            raise ValueError("预测点坐标必须是3列：[x, y, z] 或形状 (M, 3)")
+
+    def loss(self, data, res):
+        return ErrorMetrics.mse(data, res)