spc-lib 1.0.0__py3-none-any.whl

spc_lib/__init__.py

@@ -0,0 +1,17 @@
+from .charts.variables import XBarRChart, XBarSChart, IMRChart
+from .charts.attributes import PChart, CChart
+from .charts.time_weighted import CUSUMChart, CUSUMVarianceChart, EWMAChart
+from .visualization.plotly_engine import plot_control_chart, plot_rules_violations
+
+__all__ = [
+    "XBarRChart",
+    "XBarSChart",
+    "IMRChart",
+    "PChart",
+    "CChart",
+    "CUSUMChart",
+    "CUSUMVarianceChart",
+    "EWMAChart",
+    "plot_control_chart",
+    "plot_rules_violations"
+]

spc_lib/charts/__init__.py

@@ -0,0 +1,14 @@
+from .variables import XBarRChart, XBarSChart, IMRChart
+from .attributes import PChart, CChart
+from .time_weighted import CUSUMChart, CUSUMVarianceChart, EWMAChart
+
+__all__ = [
+    "XBarRChart",
+    "XBarSChart",
+    "IMRChart",
+    "PChart",
+    "CChart",
+    "CUSUMChart",
+    "CUSUMVarianceChart",
+    "EWMAChart"
+]

spc_lib/charts/attributes.py

@@ -0,0 +1,147 @@
+import numpy as np
+from src.spc_lib.core.base_chart import BaseControlChart
+
+class PChart(BaseControlChart):
+    """
+    p-карта (контрольная карта доли дефектных изделий).
+    """
+    def __init__(self, data, n_fixed=None, datetimes=None, target=None, usl=None, lsl=None):
+        super().__init__(data, datetimes, target, usl, lsl)
+        self.n_fixed = n_fixed
+        self.main_label = "p-карта: Доля дефектных единиц"
+        self.disp_label = None
+
+        self.p_values = None
+        self.n_values = None
+        self.p_bar = None
+        self.n_bar = None
+
+    def fit(self, baseline_mask=None, method='classic', use_average_n=False):
+        """
+        use_average_n: bool
+            Если True, для переменного размера выборки будут вычислены
+            константные (прямые) границы на основе среднего размера выборки (n_bar).
+        """
+        if baseline_mask is None:
+            baseline_mask = np.ones(self.n_subgroups, dtype=bool)
+
+        if self.n_fixed is not None:
+            if self.data.ndim == 2 and self.data.shape[1] == 1:
+                self.p_values = self.data.flatten()
+            else:
+                self.p_values = np.asarray(self.data).flatten()
+            self.n_values = np.full(len(self.p_values), self.n_fixed)
+        else:
+            if self.data.ndim == 2 and self.data.shape[1] == 2:
+                self.p_values = self.data[:, 0] / self.data[:, 1]
+                self.n_values = self.data[:, 1]
+            else:
+                raise ValueError("При переменном объеме выборки data должно быть 2D массивом: [x, n]")
+
+        base_p = self.p_values[baseline_mask]
+        base_n = self.n_values[baseline_mask]
+
+        if self.target is not None:
+            self.p_bar = self.target
+        else:
+            total_defects = np.sum(base_p * base_n)
+            total_n = np.sum(base_n)
+            self.p_bar = total_defects / total_n if total_n > 0 else np.mean(base_p)
+
+        self.n_bar = np.mean(base_n)
+
+        if method == 'classic':
+            self.cl_main = self.p_bar
+
+            # --- ИЗМЕНЕНИЕ ЗДЕСЬ ---
+            # Если n_fixed задан ИЛИ пользователь попросил усредненные границы
+            if self.n_fixed is not None or use_average_n:
+                n_eval = self.n_fixed if self.n_fixed is not None else self.n_bar
+
+                sigma_p = np.sqrt(self.p_bar * (1 - self.p_bar) / n_eval)
+                self.ucl_main = self.p_bar + 3 * sigma_p
+                self.lcl_main = max(0, self.p_bar - 3 * sigma_p)
+            else:
+                # Переменные (ступенчатые) границы
+                self.ucl_main = np.zeros(len(self.p_values))
+                self.lcl_main = np.zeros(len(self.p_values))
+
+                for i in range(len(self.p_values)):
+                    n_i = self.n_values[i]
+                    sigma_p_i = np.sqrt(self.p_bar * (1 - self.p_bar) / n_i)
+                    self.ucl_main[i] = self.p_bar + 3 * sigma_p_i
+                    self.lcl_main[i] = max(0, self.p_bar - 3 * sigma_p_i)
+
+            self.sigma_est = np.sqrt(self.p_bar * (1 - self.p_bar))
+
+        elif method == 'percentiles':
+            self.cl_main = np.median(base_p)
+            self.ucl_main = np.percentile(base_p, 99.865)
+            self.lcl_main = np.percentile(base_p, 0.135)
+            self.sigma_est = np.std(base_p, ddof=1)
+
+        else:
+            raise ValueError(f"Неизвестный метод: {method}")
+
+        self.stat_main = self.p_values
+        self.cl_disp = None
+        self.ucl_disp = None
+        self.lcl_disp = None
+
+        return self
+
+class CChart(BaseControlChart):
+    """
+    c-карта (контрольная карта числа дефектов).
+
+    Используется для мониторинга количества дефектов на единицу продукции
+    при постоянном объеме выборки.
+    """
+
+    def __init__(self, data, datetimes=None, target=None, usl=None, lsl=None):
+        super().__init__(data, datetimes, target, usl, lsl)
+        self.main_label = "c-карта: Число дефектов"
+        self.disp_label = None
+
+        self.c_values = None
+        self.c_bar = None
+
+    def fit(self, baseline_mask=None, method='classic'):
+        if baseline_mask is None:
+            baseline_mask = np.ones(self.n_subgroups, dtype=bool)
+
+        if self.data.ndim == 2 and self.data.shape[1] == 1:
+            self.c_values = self.data.flatten()
+        else:
+            self.c_values = np.asarray(self.data).flatten()
+
+        base_c = self.c_values[baseline_mask]
+
+        if self.target is not None:
+            self.c_bar = self.target
+        else:
+            self.c_bar = np.mean(base_c)
+
+        if method == 'classic':
+            self.cl_main = self.c_bar
+            sigma_c = np.sqrt(self.c_bar)
+            self.ucl_main = self.c_bar + 3 * sigma_c
+            # LCL не может быть меньше 0
+            self.lcl_main = max(0, self.c_bar - 3 * sigma_c)
+            self.sigma_est = sigma_c
+
+        elif method == 'percentiles':
+            self.cl_main = np.median(base_c)
+            self.ucl_main = np.percentile(base_c, 99.865)
+            self.lcl_main = np.percentile(base_c, 0.135)
+            self.sigma_est = np.std(base_c, ddof=1)
+
+        else:
+            raise ValueError(f"Неизвестный метод: {method}")
+
+        self.stat_main = self.c_values
+        self.cl_disp = None
+        self.ucl_disp = None
+        self.lcl_disp = None
+
+        return self

spc_lib/charts/time_weighted.py

@@ -0,0 +1,412 @@
+import numpy as np
+import warnings
+from src.spc_lib.core.base_chart import BaseControlChart
+
+
+class CUSUMChart(BaseControlChart):
+    """
+    Кумулятивная сумма (CUSUM) - контрольная карта для обнаружения
+    малых сдвигов процесса.
+
+    Параметры:
+    ----------
+    data : array-like
+        Данные подгрупп (2D массив) или индивидуальные значения (1D)
+    datetimes : array-like, optional
+        Временные метки
+    target : float, optional
+        Целевое значение процесса
+    usl, lsl : float, optional
+        Верхняя/нижняя границы спецификации
+    h : float, default=5
+        Параметр принятия решения (расстояние от нулевой линии до границы)
+    k : float, default=0.5
+        Параметр ссылочного значения (обычно 0.5 для стандартного CUSUM)
+    std_est : float, optional
+        Оценка стандартного отклонения. Если None, рассчитывается из данных.
+    """
+
+    def __init__(self, data, datetimes=None, target=None, usl=None, lsl=None,
+                 h=5.0, k=0.5, std_est=None):
+        super().__init__(data, datetimes, target, usl, lsl)
+        self.h = h
+        self.k = k
+        self.std_est = std_est
+        self.main_label = "CUSUM: Кумулятивная сумма (верхняя/нижняя)"
+        self.disp_label = None
+
+        self.cusum_upper = None
+        self.cusum_lower = None
+        self.sigma_est = None
+
+    def fit(self, baseline_mask=None, method='classic'):
+        """
+        Методы:
+        - 'classic': стандартный CUSUM с параметрами h и k
+        - 'percentiles': эмпирические пределы на основе процентилей
+        - 'made': робастный CUSUM на основе MAD
+        """
+        if baseline_mask is None:
+            baseline_mask = np.ones(self.n_subgroups, dtype=bool)
+
+        if self.data.ndim == 2:
+            if self.subgroup_size == 1:
+                x = self.data.flatten()
+                n = 1
+            else:
+                x = np.mean(self.data, axis=1)
+                n = self.subgroup_size
+        else:
+            warnings.warn(
+                "Передан 1D массив. Рекомендуется использовать 2D формат: data.reshape(-1, 1)",
+                UserWarning
+            )
+            x = self.data
+            n = 1
+
+        base_x = x[baseline_mask]
+
+        if self.std_est is None:
+            if n > 1 and method == 'classic':
+                r = np.ptp(self.data[baseline_mask], axis=1)
+                d2 = {2: 1.128, 3: 1.693, 4: 2.059, 5: 2.326,
+                      6: 2.534, 7: 2.704, 8: 2.847, 9: 2.970, 10: 3.078}
+                sigma_est = np.mean(r) / d2.get(n, 1.128)
+            else:
+                sigma_est = np.std(base_x, ddof=1)
+        else:
+            sigma_est = self.std_est
+
+        if self.target is not None:
+            target = self.target
+        elif method == 'classic':
+            target = np.mean(base_x)
+        else:
+            target = np.median(base_x)
+
+        # Нормировка
+        if sigma_est > 0:
+            z = (x - target) / sigma_est
+        else:
+            z = x - target
+            warnings.warn("Сигма равна 0, используется ненормированная статистика", UserWarning)
+
+        self.cusum_upper = np.zeros(len(x))
+        self.cusum_lower = np.zeros(len(x))
+
+        if method == 'classic':
+            for i in range(1, len(x)):
+                self.cusum_upper[i] = max(0, self.cusum_upper[i-1] + z[i] - self.k)
+                self.cusum_lower[i] = max(0, self.cusum_lower[i-1] - z[i] - self.k)
+
+            self.cl_main = 0
+            self.ucl_main = self.h
+            self.lcl_main = self.h
+
+        elif method == 'percentiles':
+            for i in range(1, len(x)):
+                self.cusum_upper[i] = max(0, self.cusum_upper[i-1] + z[i])
+                self.cusum_lower[i] = max(0, self.cusum_lower[i-1] - z[i])
+
+            base_cusum_upper = self.cusum_upper[baseline_mask]
+            base_cusum_lower = self.cusum_lower[baseline_mask]
+
+            self.cl_main = 0
+            self.ucl_main = np.percentile(base_cusum_upper, 99.865)
+            self.lcl_main = np.percentile(base_cusum_lower, 99.865)
+
+        elif method == 'made':
+            mad = np.median(np.abs(base_x - np.median(base_x)))
+            robust_sigma = 1.4826 * mad if mad > 0 else 1e-10
+
+            z_robust = (x - target) / robust_sigma if robust_sigma > 0 else x - target
+
+            for i in range(1, len(x)):
+                self.cusum_upper[i] = max(0, self.cusum_upper[i-1] + z_robust[i] - self.k)
+                self.cusum_lower[i] = max(0, self.cusum_lower[i-1] - z_robust[i] - self.k)
+
+            self.cl_main = 0
+            self.ucl_main = self.h
+            self.lcl_main = self.h
+            sigma_est = robust_sigma
+
+        else:
+            raise ValueError(f"Неизвестный метод: {method}")
+
+        self.target = target
+        self.sigma_est = sigma_est
+        self.stat_main = x
+
+        return self
+
+    def get_cusum_stats(self):
+        """Возвращает верхнюю и нижнюю CUSUM статистики"""
+        return self.cusum_upper, self.cusum_lower
+
+
+class EWMAChart(BaseControlChart):
+    """
+    Экспоненциально взвешенное скользящее среднее (EWMA)
+    - контрольная карта для обнаружения малых сдвигов процесса.
+
+    Параметры:
+    ----------
+    data : array-like
+        Данные подгрупп (2D массив) или индивидуальные значения (1D)
+    datetimes : array-like, optional
+        Временные метки
+    target : float, optional
+        Целевое значение процесса
+    usl, lsl : float, optional
+        Верхняя/нижняя границы спецификации
+    lambda_ : float, default=0.2
+        Весовой коэффициент (0 < lambda <= 1)
+    L : float, default=3
+        Коэффициент ширины контрольных границ
+    std_est : float, optional
+        Оценка стандартного отклонения. Если None, рассчитывается из данных.
+    """
+
+    def __init__(self, data, datetimes=None, target=None, usl=None, lsl=None,
+                 lambda_=0.2, L=3, std_est=None):
+        super().__init__(data, datetimes, target, usl, lsl)
+        self.lambda_ = lambda_
+        self.L = L
+        self.std_est = std_est
+        self.main_label = "EWMA: Экспоненциально взвешенное скользящее среднее"
+        self.disp_label = None
+
+        self.ewma_values = None
+        self.ewma_sigma = None
+        self.sigma_est = None
+
+    def fit(self, baseline_mask=None, method='classic'):
+        """
+        Методы:
+        - 'classic': стандартная EWMA с фиксированными пределами
+        - 'percentiles': эмпирические пределы на основе процентилей
+        - 'made': робастная EWMA на основе MAD
+        """
+        if baseline_mask is None:
+            baseline_mask = np.ones(self.n_subgroups, dtype=bool)
+
+        # Извлечение данных
+        if self.data.ndim == 2:
+            if self.subgroup_size == 1:
+                x = self.data.flatten()
+                n = 1
+            else:
+                x = np.mean(self.data, axis=1)
+                n = self.subgroup_size
+        else:
+            warnings.warn(
+                "Передан 1D массив. Рекомендуется использовать 2D формат: data.reshape(-1, 1)",
+                UserWarning
+            )
+            x = self.data
+            n = 1
+
+        base_x = x[baseline_mask]
+
+        # Оценка стандартного отклонения
+        if self.std_est is None:
+            if n > 1 and method == 'classic':
+                r = np.ptp(self.data[baseline_mask], axis=1)
+                d2 = {2: 1.128, 3: 1.693, 4: 2.059, 5: 2.326,
+                      6: 2.534, 7: 2.704, 8: 2.847, 9: 2.970, 10: 3.078}
+                sigma_est = np.mean(r) / d2.get(n, 1.128)
+            else:
+                sigma_est = np.std(base_x, ddof=1)
+        else:
+            sigma_est = self.std_est
+
+        # Целевое значение
+        if self.target is not None:
+            target = self.target
+        elif method == 'classic':
+            target = np.mean(base_x)
+        else:
+            target = np.median(base_x)
+
+        lambda_ = self.lambda_
+        L = self.L
+
+        # Расчет EWMA
+        self.ewma_values = np.zeros(len(x))
+        self.ewma_values[0] = target
+
+        for i in range(1, len(x)):
+            self.ewma_values[i] = lambda_ * x[i] + (1 - lambda_) * self.ewma_values[i-1]
+
+        # Стандартное отклонение EWMA: σ * sqrt(λ/(2-λ) * (1 - (1-λ)^(2i)))
+        weights = np.zeros(len(x))
+        for i in range(1, len(x) + 1):
+            weights[i-1] = np.sqrt(lambda_ / (2 - lambda_) * (1 - (1 - lambda_)**(2*i)))
+
+        self.ewma_sigma = sigma_est * weights
+
+        # Расчет границ в зависимости от метода
+        if method == 'classic':
+            self.cl_main = target
+            self.ucl_main = target + L * self.ewma_sigma
+            self.lcl_main = target - L * self.ewma_sigma
+
+        elif method == 'percentiles':
+            base_ewma = self.ewma_values[baseline_mask]
+            self.cl_main = np.median(base_ewma)
+            self.ucl_main = np.percentile(base_ewma, 99.865)
+            self.lcl_main = np.percentile(base_ewma, 0.135)
+
+        elif method == 'made':
+            mad = np.median(np.abs(base_x - np.median(base_x)))
+            robust_sigma = 1.4826 * mad if mad > 0 else 1e-10
+
+            self.ewma_sigma = robust_sigma * weights
+            self.cl_main = target
+            self.ucl_main = target + L * self.ewma_sigma
+            self.lcl_main = target - L * self.ewma_sigma
+            sigma_est = robust_sigma
+
+        else:
+            raise ValueError(f"Неизвестный метод: {method}")
+
+        self.target = target
+        self.sigma_est = sigma_est
+        self.stat_main = self.ewma_values
+
+        return self
+
+    def get_ewma_values(self):
+        """Возвращает EWMA значения и их стандартные отклонения"""
+        return self.ewma_values, self.ewma_sigma
+
+class CUSUMVarianceChart(BaseControlChart):
+    """
+    CUSUM карта для контроля дисперсии/стандартного отклонения.
+    Использует преобразование Хокинса для мониторинга вариабельности процесса.
+
+    Параметры:
+    ----------
+    data : array-like
+        Данные подгрупп (2D массив) или индивидуальные значения (1D)
+    datetimes : array-like, optional
+        Временные метки
+    target_mean : float, optional
+        Целевое среднее процесса. Если None - оценивается из данных.
+    target_std : float, optional
+        Целевое стандартное отклонение. Если None - оценивается из данных.
+    usl, lsl : float, optional
+        Верхняя/нижняя границы спецификации
+    h : float, default=5
+        Параметр принятия решения
+    k : float, default=0.5
+        Параметр ссылочного значения
+    """
+
+    def __init__(self, data, datetimes=None, target_mean=None, target_std=None,
+                 usl=None, lsl=None, h=5.0, k=0.5):
+        super().__init__(data, datetimes, None, usl, lsl)  # target передаем как None, используем target_mean
+        self.target_mean = target_mean
+        self.target_std = target_std
+        self.h = h
+        self.k = k
+        self.main_label = "CUSUM для дисперсии (верхняя/нижняя)"
+        self.disp_label = None
+
+        self.cusum_upper = None
+        self.cusum_lower = None
+        self.v_values = None  # Преобразованные значения v_i
+        self.sigma_est = None
+
+    def fit(self, baseline_mask=None, method='classic'):
+        """
+        Методы:
+        - 'classic': стандартный CUSUM для дисперсии с преобразованием Хокинса
+        - 'percentiles': эмпирические пределы на основе процентилей
+        """
+        if baseline_mask is None:
+            baseline_mask = np.ones(self.n_subgroups, dtype=bool)
+
+        # Извлечение данных
+        if self.data.ndim == 2:
+            if self.subgroup_size == 1:
+                x = self.data.flatten()
+                n = 1
+            else:
+                x = np.mean(self.data, axis=1)
+                n = self.subgroup_size
+        else:
+            warnings.warn(
+                "Передан 1D массив. Рекомендуется использовать 2D формат: data.reshape(-1, 1)",
+                UserWarning
+            )
+            x = self.data
+            n = 1
+
+        base_x = x[baseline_mask]
+
+        # Оценка среднего и стандартного отклонения
+        if self.target_mean is not None:
+            mu = self.target_mean
+        elif method == 'classic':
+            mu = np.mean(base_x)
+        else:
+            mu = np.median(base_x)
+
+        if self.target_std is not None:
+            sigma = self.target_std
+        elif method == 'classic' and n > 1:
+            r = np.ptp(self.data[baseline_mask], axis=1)
+            d2 = {2: 1.128, 3: 1.693, 4: 2.059, 5: 2.326,
+                  6: 2.534, 7: 2.704, 8: 2.847, 9: 2.970, 10: 3.078}
+            sigma = np.mean(r) / d2.get(n, 1.128)
+        else:
+            sigma = np.std(base_x, ddof=1)
+
+        # Стандартизованные значения
+        if sigma > 0:
+            y = (x - mu) / sigma
+        else:
+            y = x - mu
+            warnings.warn("Сигма равна 0, используется ненормированная статистика", UserWarning)
+
+        # Преобразование Хокинса для мониторинга дисперсии
+        # v_i = (sqrt(|y_i|) - 0.822) / 0.349
+        # При нормальном распределении v_i ~ N(0,1)
+        self.v_values = (np.sqrt(np.abs(y)) - 0.822) / 0.349
+
+        self.cusum_upper = np.zeros(len(x))
+        self.cusum_lower = np.zeros(len(x))
+
+        if method == 'classic':
+            # Стандартный CUSUM для v_i
+            for i in range(1, len(x)):
+                self.cusum_upper[i] = max(0, self.cusum_upper[i-1] + self.v_values[i] - self.k)
+                self.cusum_lower[i] = max(0, self.cusum_lower[i-1] - self.k - self.v_values[i])
+
+            self.cl_main = 0
+            self.ucl_main = self.h
+            self.lcl_main = self.h
+
+        elif method == 'percentiles':
+            for i in range(1, len(x)):
+                self.cusum_upper[i] = max(0, self.cusum_upper[i-1] + self.v_values[i])
+                self.cusum_lower[i] = max(0, self.cusum_lower[i-1] - self.v_values[i])
+
+            base_cusum_upper = self.cusum_upper[baseline_mask]
+            base_cusum_lower = self.cusum_lower[baseline_mask]
+
+            self.cl_main = 0
+            self.ucl_main = np.percentile(base_cusum_upper, 99.865)
+            self.lcl_main = np.percentile(base_cusum_lower, 99.865)
+
+        else:
+            raise ValueError(f"Неизвестный метод: {method}")
+
+        self.target = mu  # Для совместимости с базовым классом
+        self.target_mean = mu
+        self.target_std = sigma
+        self.sigma_est = sigma
+        self.stat_main = x  # Исходные данные для справки
+
+        return self