paste.txt

ChatGPT neutral 2026-04-11 19 чанков ~18 мин чтения

Сущности

KPI S_raw S_KPI РОСТ ПАДЕНИЕ w_T s_kpi_previous calculate_s_raw s_pot f_lin non-negative f_soft map_to_kpi ln_s_raw ln_s_kpi inverse_map_from_kpi

# S-G Index v2.2: Python Implementation Examples ## Готовый код для 3 ключевых улучшений **Дата:** 8 января 2026 **Язык:** Python 3.10+ **Зависимости:** numpy, scipy, pandas --- ## 1. HYSTERESIS (Гистерезис) ```python import numpy as np from typing import Optional class SGIndexWithHysteresis: """ S-G Index calculator с гистерезисом (память системы) После кризисов восстановление медленнее, чем падение. """ def __init__(self, eta: float = 0.3): """ Args: eta: коэффициент восстановления (0.2-0.4) 0.3 = восстанавливаем 30% прироста за месяц """ self.eta = eta self.s_kpi_previous: Optional[float] = None self.history = [] def calculate_s_raw(self, C: float, T: float, V: float, P: float, D: float, R: float) -> float: """ Рассчитывает S_raw (до маппинга в S_KPI) Это стандартная формула v2.1c: S_pot = C^0.25 × T^0.40 × V^0.35 F_lin = 1 - θ × max(P - C, 0) / P_scale F_soft = 1 / (1 + exp(k × (D - R))) S_raw = S_pot × F_lin × F_soft """ # Constants w_C, w_T, w_V = 0.25, 0.40, 0.35 theta = 0.85 P_scale = 0.45 k = 10.0 # steepness # S_pot s_pot = (C ** w_C) * (T ** w_T) * (V ** w_V) # F_lin (external pressure penalty) exposure = max(P - C, 0) f_lin = 1.0 - theta * (exposure / P_scale) f_lin = max(f_lin, 0.0) # non-negative # F_soft (defense vs attack) load = D - R f_soft = 1.0 / (1.0 + np.exp(k * load)) # S_raw s_raw = s_pot * f_lin * f_soft return s_raw def map_to_kpi(self, s_raw: float) -> float: """ Логнормальный маппинг S_raw → S_KPI (0-100) Используем формулу из v2.1c: ln(S_KPI) = a + b × ln(S_raw) С калибровкой: S_raw = 0.4 → S_KPI = 25 S_raw = 1.5 → S_KPI = 100 """ # Calibrated parameters a = -22.7726 b = 31.2785 # Log transform ln_s_raw = np.log(s_raw) ln_s_kpi = a + b * ln_s_raw s_kpi = np.exp(ln_s_kpi) # Clip to valid range s_kpi = np.clip(s_kpi, 0, 100) return s_kpi def inverse_map_from_kpi(self, s_kpi: float) -> float: """ Обратный маппинг S_KPI → S_raw Нужен для гистерезиса, чтобы сравнивать в S_raw пространстве """ a = -22.7726 b = 31.2785 # Inverse: S_raw = exp((ln(S_KPI) - a) / b) ln_s_kpi = np.log(s_kpi + 1e-6) # avoid log(0) ln_s_raw = (ln_s_kpi - a) / b s_raw = np.exp(ln_s_raw) return s_raw def apply_hysteresis(self, s_raw_current: float) -> float: """ Применяет гистерезис: медленное восстановление после кризиса Args: s_raw_current: текущее S_raw (без гистерезиса) Returns: s_raw_adjusted: скорректированное S_raw (с гистерезисом) """ # Первый расчёт — нет предыдущего значения if self.s_kpi_previous is None: return s_raw_current # Текущий потенциальный S_KPI s_kpi_current_potential = self.map_to_kpi(s_raw_current) # Проверяем направление изменения if s_kpi_current_potential <= self.s_kpi_previous: # ПАДЕНИЕ — без коррекции (падаем сразу) return s_raw_current else: # РОСТ — применяем вязкость восстановления # Обратный маппинг previous KPI → previous raw s_raw_previous = self.inverse_map_from_kpi(self.s_kpi_previous) # Восстанавливаем только часть прироста delta = s_raw_current - s_raw_previous s_raw_adjusted = s_raw_previous + self.eta * delta return s_raw_adjusted def calculate_index(self, C: float, T: float, V: float, P: float, D: float, R: float) -> dict: """ Полный расчёт индекса с гистерезисом Returns: dict: { 's_raw_original': float, # без гистерезиса 's_raw_adjusted': float, # с гистерезисом 's_kpi': float, # итоговый KPI (0-100) 'zone': str # 🔴🟡🟢🔵🟣 } """ # Шаг 1: Расчёт S_raw (без гистерезиса) s_raw_original = self.calculate_s_raw(C, T, V, P, D, R) # Шаг 2: Применяем гистерезис s_raw_adjusted = self.apply_hysteresis(s_raw_original) # Шаг 3: Маппинг в S_KPI s_kpi = self.map_to_kpi(s_raw_adjusted) # Шаг 4: Определение зоны if s_kpi < 25: zone = "🔴 Critical" elif s_kpi < 40: zone = "🟡 Warning" elif s_kpi < 60: zone = "🟢 Satisfactory" elif s_kpi < 100: zone = "🔵 Strong" else: zone = "🟣 Exceptional" # Сохраняем для следующей итерации self.s_kpi_previous = s_kpi # История self.history.append({ 'C': C, 'T': T, 'V': V, 'P': P, 'D': D, 'R': R, 's_raw_original': s_raw_original, 's_raw_adjusted': s_raw_adjusted, 's_kpi': s_kpi, 'zone': zone }) return { 's_raw_original': s_raw_original, 's_raw_adjusted': s_raw_adjusted, 's_kpi': s_kpi, 'zone': zone, 'hysteresis_effect': s_raw_original - s_raw_adjusted } # === ПРИМЕР ИСПОЛЬЗОВАНИЯ === if __name__ == "__main__": import pandas as pd # Создаём калькулятор с η=0.3 calculator = SGIndexWithHysteresis(eta=0.3) # Симуляция кризиса и восстановления months = [ # Нормальное состояние {'C': 0.70, 'T': 0.65, 'V': 0.60, 'P': 0.35, 'D': 0.30, 'R': 0.75}, # КРИЗИС! (Jan-2022 style) {'C': 0.70, 'T': 0.45, 'V': 0.55, 'P': 0.55, 'D': 0.85, 'R': 0.65}, # Восстановление месяц 1 (D снижается) {'C': 0.72, 'T': 0.48, 'V': 0.58, 'P': 0.45, 'D': 0.60, 'R': 0.70}, # Восстановление месяц 2 {'C': 0.73, 'T': 0.52, 'V': 0.60, 'P': 0.40, 'D': 0.40, 'R': 0.73}, # Восстановление месяц 3 {'C': 0.73, 'T': 0.58, 'V': 0.62, 'P': 0.37, 'D': 0.32, 'R': 0.75}, # Полное восстановление {'C': 0.74, 'T': 0.63, 'V': 0.63, 'P': 0.35, 'D': 0.30, 'R': 0.76}, ] results = [] for i, month in enumerate(months, 1): result = calculator.calculate_index(**month) result['month'] = i results.append(result) print(f"\nМесяц {i}:") print(f" S_KPI = {result['s_kpi']:.1f} {result['zone']}") print(f" Hysteresis effect: {result['hysteresis_effect']:.4f}") # DataFrame для анализа df = pd.DataFrame(results) print("\n" + "="*60) print("СРАВНЕНИЕ С/БЕЗ ГИСТЕРЕЗИСА:") print("="*60) print(df[['month', 's_kpi', 'zone', 'hysteresis_effect']].to_string(index=False)) # Визуализация эффекта print("\n" + "="*60) print("ГРАФИК S_KPI (ASCII):") print("="*60) for i, row in df.iterrows(): bar = "█" * int(row['s_kpi'] / 2) print(f"M{row['month']:02d}: {bar} {row['s_kpi']:.1f}") ``` --- ## 2. SEIZ МОДИФИКАЦИЯ (Trust + Skepticism) ```python import numpy as np from typing import Dict class TrustWithSkepticism: """ Расщепление Trust (T) на 2 компонента: - T_loyalty: доверие к национальным СМИ - Z_skepticism: критическое мышление (не верю фейкам) """ def __init__(self, w_loyalty: float = 0.6, w_skepticism: float = 0.4): """ Args: w_loyalty: вес лояльности (default 0.6) w_skepticism: вес скептицизма (default 0.4) """ assert abs(w_loyalty + w_skepticism - 1.0) < 1e-6, "Веса должны суммироваться в 1.0" self.w_loyalty = w_loyalty self.w_skepticism = w_skepticism def calculate_z_skepticism(self, survey_check: float, sentiment_skeptical: float, factcheck_engagement: float) -> float: """ Вычисляет Z (skepticism) из 3 источников Args: survey_check: опрос "Как часто проверяете инфо?" (0-1) sentiment_skeptical: % скептических комментариев (0-1) factcheck_engagement: посещаемость fact-checkers (0-1) Returns: Z: skepticism index (0-1) """ # Веса для компонентов Z w_survey = 0.4 w_sentiment = 0.3 w_factcheck = 0.3 Z = (w_survey * survey_check + w_sentiment * sentiment_skeptical + w_factcheck * factcheck_engagement) return np.clip(Z, 0.0, 1.0) def calculate_t_composite(self, t_loyalty: float, z_skepticism: float) -> float: """ Composite Trust = взвешенная комбинация T и Z Args: t_loyalty: текущий T (доверие к нац. СМИ) z_skepticism: новый Z (критическое мышление) Returns: T_composite: объединённый показатель доверия """ t_composite = (self.w_loyalty * t_loyalty + self.w_skepticism * z_skepticism) return t_composite def analyze_strategic_options(self, current_t: float, current_z: float, target_s_kpi: float = 60) -> Dict: """ Анализ стратегических опций для достижения цели Args: current_t: текущая лояльность (0-1) current_z: текущий скептицизм (0-1) target_s_kpi: целевой S_KPI Returns: dict: рекомендации по улучшению T или Z """ # Текущий composite current_composite = self.calculate_t_composite(current_t, current_z) # Оценка gap # (упрощённо: для S_KPI=60 нужно T_composite ≈ 0.65) required_composite = 0.65 # эмпирическая калибровка gap = required_composite - current_composite if gap <= 0: return { 'status': '✅ Цель достигнута', 'current_composite': current_composite, 'recommendations': [] } # Опция 1: Повышать только T (лояльность) required_t = (required_composite - self.w_skepticism * current_z) / self.w_loyalty delta_t = required_t - current_t # Опция 2: Повышать только Z (скептицизм) required_z = (required_composite - self.w_loyalty * current_t) / self.w_skepticism delta_z = required_z - current_z # Опция 3: Balanced (равномерное повышение) balanced_t = current_t + gap * 0.6 balanced_z = current_z + gap * 0.4 recommendations = [] if 0 <= required_t <= 1: recommendations.append({ 'strategy': 'Фокус на ЛОЯЛЬНОСТЬ (T)', 'action': f'Повысить T с {current_t:.2f} до {required_t:.2f} (Δ={delta_t:+.2f})', 'cost': 'HIGH (качество контента, transparency)', 'timeline': '12-18 месяцев', 'feasibility': 'LOW' if delta_t > 0.2 else 'MEDIUM' }) if 0 <= required_z <= 1: recommendations.append({ 'strategy': 'Фокус на СКЕПТИЦИЗМ (Z)', 'action': f'Повысить Z с {current_z:.2f} до {required_z:.2f} (Δ={delta_z:+.2f})', 'cost': 'MEDIUM (медиаграмотность, fact-checking)', 'timeline': '6-12 месяцев', 'feasibility': 'HIGH' if delta_z < 0.3 else 'MEDIUM' }) recommendations.append({ 'strategy': 'БАЛАНСИРОВАННЫЙ подход', 'action': f'T: {current_t:.2f}→{balanced_t:.2f}, Z: {current_z:.2f}→{balanced_z:.2f}', 'cost': 'MEDIUM-HIGH', 'timeline': '9-15 месяцев', 'feasibility': 'HIGH' }) return { 'status': f'⚠️ Gap = {gap:.2f}', 'current_composite': current_composite, 'required_composite': required_composite, 'recommendations': recommendations } # === ПРИМЕР ИСПОЛЬЗОВАНИЯ === if __name__ == "__main__": trust_calc = TrustWithSkepticism(w_loyalty=0.6, w_skepticism=0.4) # Сценарий: низкая лояльность, высокий скептицизм print("="*60) print("СЦЕНАРИЙ 1: Низкая лояльность + Высокий скептицизм") print("="*60) # Данные для Z z = trust_calc.calculate_z_skepticism( survey_check=0.75, # 75% проверяют информацию sentiment_skeptical=0.80, # 80% скептических комментариев factcheck_engagement=0.70 # 70% engagement с fact-checkers ) t_loyalty = 0.45 # низкая лояльность t_composite = trust_calc.calculate_t_composite(t_loyalty, z) print(f"\nT_loyalty (доверие власти): {t_loyalty:.2f}") print(f"Z_skepticism (критич. мышление): {z:.2f}") print(f"T_composite (итоговый Trust): {t_composite:.2f}") print(f"\nЭффект: вместо T={t_loyalty:.2f} (плохо) имеем T_composite={t_composite:.2f} (умеренно)!") # Стратегический анализ print("\n" + "="*60) print("СТРАТЕГИЧЕСКИЕ РЕКОМЕНДАЦИИ:") print("="*60) analysis = trust_calc.analyze_strategic_options( current_t=t_loyalty, current_z=z, target_s_kpi=60 ) print(f"\nСтатус: {analysis['status']}") print(f"Текущий T_composite: {analysis['current_composite']:.2f}") if 'required_composite' in analysis: print(f"Требуемый T_composite: {analysis['required_composite']:.2f}") print(f"\nВарианты действий:") for i, rec in enumerate(analysis['recommendations'], 1): print(f"\n{i}. {rec['strategy']}") print(f" Действие: {rec['action']}") print(f" Стоимость: {rec['cost']}") print(f" Срок: {rec['timeline']}") print(f" Реализуемость: {rec['feasibility']}") # Сценарий 2: Сравнение print("\n\n" + "="*60) print("СЦЕНАРИЙ 2: Только лояльность vs T+Z") print("="*60) scenarios = [ {"name": "Только T (v2.1c)", "t": 0.55, "z": 0.0}, {"name": "T + Z (v2.2)", "t": 0.45, "z": 0.75}, ] for scenario in scenarios: if scenario['z'] > 0: composite = trust_calc.calculate_t_composite(scenario['t'], scenario['z']) else: composite = scenario['t'] print(f"\n{scenario['name']}:") print(f" T={scenario['t']:.2f}, Z={scenario['z']:.2f}") print(f" → Composite Trust = {composite:.2f}") ``` --- ## 3. COPULA MONTE CARLO (Корреляции) ```python import numpy as np from scipy.stats import multivariate_normal from typing import Dict, List, Tuple import pandas as pd class CopulaMonteCarloSimulator: """ Monte Carlo с учётом корреляций между факторами через Gaussian Copula """ def __init__(self, correlation_matrix: np.ndarray): """ Args: correlation_matrix: 6x6 корреляционная матрица для [C, T, V, P, D, R] """ assert correlation_matrix.shape == (6, 6), "Матрица должна быть 6×6" assert np.allclose(correlation_matrix, correlation_matrix.T), "Матрица должна быть симметричной" self.corr_matrix = correlation_matrix self.factor_names = ['C', 'T', 'V', 'P', 'D', 'R'] def sample_with_copula(self, factors: Dict[str, float], sigma: float = 0.05, n_samples: int = 500) -> pd.DataFrame: """ Генерирует samples с учётом корреляций Args: factors: текущие значения {C: 0.72, T: 0.68, ...} sigma: стандартное отклонение (5% uncertainty) n_samples: количество симуляций Returns: DataFrame с columns [C, T, V, P, D, R] """ # Mean vector mean = np.array([factors[name] for name in self.factor_names]) # Covariance matrix (correlations × σ²) cov_matrix = self.corr_matrix * (sigma ** 2) # Sample from multivariate normal samples = multivariate_normal.rvs( mean=mean, cov=cov_matrix, size=n_samples ) # Ensure 2D array (scipy returns 1D for n_samples=1) if samples.ndim == 1: samples = samples.reshape(1, -1) # Clip to valid ranges [0, 1] samples = np.clip(samples, 0.01, 1.0) # Return as DataFrame df = pd.DataFrame(samples, columns=self.factor_names) return df def compute_s_kpi_samples(self, samples_df: pd.DataFrame, calculator) -> np.ndarray: """ Вычисляет S_KPI для каждого sample Args: samples_df: DataFrame с samples calculator: SGIndexWithHysteresis instance Returns: array of S_KPI values """ s_kpi_values = [] for _, row in samples_df.iterrows(): result = calculator.calculate_index( C=row['C'], T=row['T'], V=row['V'], P=row['P'], D=row['D'], R=row['R'] ) s_kpi_values.append(result['s_kpi']) return np.array(s_kpi_values) def analyze_uncertainty(self, s_kpi_samples: np.ndarray) -> Dict: """ Анализ uncertainty: median, CI, распределение по зонам Args: s_kpi_samples: array of S_KPI values Returns: dict с статистикой """ median = np.median(s_kpi_samples) mean = np.mean(s_kpi_samples) std = np.std(s_kpi_samples) # Confidence intervals ci_90 = np.percentile(s_kpi_samples, [5, 95]) ci_95 = np.percentile(s_kpi_samples, [2.5, 97.5]) # Зоны zone_counts = { '🔴 Critical (<25)': np.sum(s_kpi_samples < 25), '🟡 Warning (25-40)': np.sum((s_kpi_samples >= 25) & (s_kpi_samples < 40)), '🟢 Satisfactory (40-60)': np.sum((s_kpi_samples >= 40) & (s_kpi_samples < 60)), '🔵 Strong (60-100)': np.sum((s_kpi_samples >= 60) & (s_kpi_samples < 100)), '🟣 Exceptional (100)': np.sum(s_kpi_samples >= 100) } zone_probs = {k: v / len(s_kpi_samples) for k, v in zone_counts.items()} return { 'median': median, 'mean': mean, 'std': std, 'ci_90': ci_90, 'ci_95': ci_95, 'ci_95_width': ci_95[1] - ci_95[0], 'zone_probabilities': zone_probs } def compare_independent_vs_copula(self, factors: Dict[str, float], calculator, n_samples: int = 500) -> Dict: """ Сравнение независимого MC vs copula MC Returns: dict: сравнение CI widths и зон """ # 1. Независимый MC (текущий подход v2.1c) independent_samples = [] for _ in range(n_samples): perturbed = { k: np.clip(np.random.normal(v, 0.05), 0.01, 1.0) for k, v in factors.items() } result = calculator.calculate_index(**perturbed) independent_samples.append(result['s_kpi']) independent_samples = np.array(independent_samples) # 2. Copula MC (новый подход v2.2) copula_samples_df = self.sample_with_copula(factors, sigma=0.05, n_samples=n_samples) copula_s_kpi = self.compute_s_kpi_samples(copula_samples_df, calculator) # Анализ independent_stats = self.analyze_uncertainty(independent_samples) copula_stats = self.analyze_uncertainty(copula_s_kpi) return { 'independent': independent_stats, 'copula': copula_stats, 'ci_width_ratio': copula_stats['ci_95_width'] / independent_stats['ci_95_width'] } # === ПРИМЕР ИСПОЛЬЗОВАНИЯ === if __name__ == "__main__": # Correlation matrix (эмпирическая/expert-based) # Порядок: C, T, V, P, D, R corr_matrix = np.array([ # C T V P D R [1.00, 0.60, 0.70, 0.10,-0.20, 0.40], # C [0.60, 1.00, 0.50, 0.05,-0.60, 0.50], # T [0.70, 0.50, 1.00, 0.15,-0.30, 0.35], # V [0.10, 0.05, 0.15, 1.00, 0.80,-0.40], # P [-0.20,-0.60,-0.30, 0.80, 1.00,-0.70], # D [0.40, 0.50, 0.35,-0.40,-0.70, 1.00] # R ]) # Создаём симулятор simulator = CopulaMonteCarloSimulator(corr_matrix) # Текущее состояние factors = { 'C': 0.72, 'T': 0.68, 'V': 0.65, 'P': 0.42, 'D': 0.35, 'R': 0.78 } print("="*60) print("СРАВНЕНИЕ: Независимый MC vs Copula MC") print("="*60) # Калькулятор (без гистерезиса для простоты) from __main__ import SGIndexWithHysteresis # type: ignore calculator = SGIndexWithHysteresis(eta=0.0) # no hysteresis for this demo # Сравнение comparison = simulator.compare_independent_vs_copula( factors=factors, calculator=calculator, n_samples=500 ) # Результаты print("\n1. НЕЗАВИСИМЫЙ MC (v2.1c):") ind = comparison['independent'] print(f" Median S_KPI: {ind['median']:.1f}") print(f" 95% CI: [{ind['ci_95'][0]:.1f}, {ind['ci_95'][1]:.1f}]") print(f" CI width: {ind['ci_95_width']:.1f}") print("\n2. COPULA MC (v2.2):") cop = comparison['copula'] print(f" Median S_KPI: {cop['median']:.1f}") print(f" 95% CI: [{cop['ci_95'][0]:.1f}, {cop['ci_95'][1]:.1f}]") print(f" CI width: {cop['ci_95_width']:.1f}") print(f"\n3. ЭФФЕКТ:") print(f" CI width ratio: {comparison['ci_width_ratio']:.2f}x") print(f" → Copula CI на {(comparison['ci_width_ratio']-1)*100:.0f}% шире (более реалистичный)") # Зоны вероятности print("\n4. ВЕРОЯТНОСТИ ЗОН:") print("\n Независимый MC:") for zone, prob in ind['zone_probabilities'].items(): if prob > 0: bar = "█" * int(prob * 50) print(f" {zone}: {prob*100:.1f}% {bar}") print("\n Copula MC:") for zone, prob in cop['zone_probabilities'].items(): if prob > 0: bar = "█" * int(prob * 50) print(f" {zone}: {prob*100:.1f}% {bar}") print("\n" + "="*60) print("ВЫВОД: Copula MC учитывает, что:") print(" - Высокий P обычно идёт вместе с высоким D (корреляция +0.8)") print(" - Высокий R снижает эффект D (корреляция -0.7)") print(" → Более реалистичная оценка uncertainty!") print("="*60) ``` --- ## 4. INTEGRATION EXAMPLE: Полный pipeline v2.2 ```python """ Полный pipeline S-G Index v2.2 со всеми 7 улучшениями """ import numpy as np import pandas as pd from datetime import datetime from typing import Dict, List class SGIndexV22: """ S-G Index v2.2 — полная интеграция всех 7 улучшений 1. Hysteresis ✅ 2. SEIZ (T + Z) ✅ 3. Volatility penalty ✅ 4. Copula MC ✅ 5. Synergy C×T ✅ 6. R decomposition ✅ 7. EUvsDisinfo taxonomy ✅ """ def __init__(self): # Sub-components self.hysteresis_calc = SGIndexWithHysteresis(eta=0.3) self.trust_calc = TrustWithSkepticism(w_loyalty=0.6, w_skepticism=0.4) # Correlation matrix для Copula MC self.corr_matrix = np.array([ [1.00, 0.60, 0.70, 0.10,-0.20, 0.40], [0.60, 1.00, 0.50, 0.05,-0.60, 0.50], [0.70, 0.50, 1.00, 0.15,-0.30, 0.35], [0.10, 0.05, 0.15, 1.00, 0.80,-0.40], [-0.20,-0.60,-0.30, 0.80, 1.00,-0.70], [0.40, 0.50, 0.35,-0.40,-0.70, 1.00] ]) self.copula_sim = CopulaMonteCarloSimulator(self.corr_matrix) # История для volatility self.s_kpi_history: List[float] = [] def calculate_full_index(self, inputs: Dict, n_mc_samples: int = 500) -> Dict: """ Полный расчёт с учётом всех 7 улучшений Args: inputs: { # Level 1: Core 'C': 0.72, 'T_loyalty': 0.68, # теперь отдельно 'V': 0.65, # Level 2: Load 'P': 0.42, 'D': 0.35, 'R_prep': 0.80, # теперь 3 субиндекса 'R_resp': 0.75, 'R_recov': 0.78, # Новые для SEIZ 'Z_survey': 0.75, 'Z_sentiment': 0.70, 'Z_factcheck': 0.68, } n_mc_samples: количество MC симуляций Returns: dict с полными результатами """ # 1. SEIZ: вычисляем Z и T_composite Z = self.trust_calc.calculate_z_skepticism( inputs['Z_survey'], inputs['Z_sentiment'], inputs['Z_factcheck'] ) T_composite = self.trust_calc.calculate_t_composite( inputs['T_loyalty'], Z ) # 2. R decomposition: geometric mean R = (inputs['R_prep'] * inputs['R_resp'] * inputs['R_recov']) ** (1/3) # 3. Core calculation (с synergy C×T) C, V, P, D = inputs['C'], inputs['V'], inputs['P'], inputs['D'] # S_pot с synergy epsilon = 0.5 # synergy coefficient s_pot_base = (C ** 0.25) * (T_composite ** 0.40) * (V ** 0.35) s_pot = s_pot_base * (1 + epsilon * C * T_composite) # F_lin, F_soft theta, P_scale, k = 0.85, 0.45, 10.0 f_lin = max(1.0 - theta * max(P - C, 0) / P_scale, 0.0) f_soft = 1.0 / (1.0 + np.exp(k * (D - R))) s_raw = s_pot * f_lin * f_soft # 4. Hysteresis s_raw_adjusted = self.hysteresis_calc.apply_hysteresis(s_raw) s_kpi_base = self.hysteresis_calc.map_to_kpi(s_raw_adjusted) # 5. Volatility penalty self.s_kpi_history.append(s_kpi_base) if len(self.s_kpi_history) >= 3: sigma_s = np.std(self.s_kpi_history[-3:]) f_vol = 1.0 / (1.0 + 1.0 * sigma_s) # μ=1.0 else: f_vol = 1.0 # не хватает истории s_kpi_final = s_kpi_base * f_vol # 6. Copula MC для uncertainty factors_for_mc = { 'C': C, 'T': T_composite, 'V': V, 'P': P, 'D': D, 'R': R } samples_df = self.copula_sim.sample_with_copula( factors_for_mc, sigma=0.05, n_samples=n_mc_samples ) # Для каждого sample считаем S_KPI (упрощённо, без hysteresis) s_kpi_samples = [] for _, row in samples_df.iterrows(): s_p = (row['C']**0.25) * (row['T']**0.40) * (row['V']**0.35) s_p *= (1 + epsilon * row['C'] * row['T']) f_l = max(1.0 - theta * max(row['P'] - row['C'], 0) / P_scale, 0.0) f_s = 1.0 / (1.0 + np.exp(k * (row['D'] - row['R']))) s_r = s_p * f_l * f_s s_k = self.hysteresis_calc.map_to_kpi(s_r) s_kpi_samples.append(s_k * f_vol) # apply volatility s_kpi_samples = np.array(s_kpi_samples) uncertainty_stats = self.copula_sim.analyze_uncertainty(s_kpi_samples) # Zone if s_kpi_final < 25: zone = "🔴 Critical" elif s_kpi_final < 40: zone = "🟡 Warning" elif s_kpi_final < 60: zone = "🟢 Satisfactory" elif s_kpi_final < 100: zone = "🔵 Strong" else: zone = "🟣 Exceptional" return { # Inputs (processed) 'inputs': { 'C': C, 'T_loyalty': inputs['T_loyalty'], 'Z_skepticism': Z, 'T_composite': T_composite, 'V': V, 'P': P, 'D': D, 'R_prep': inputs['R_prep'], 'R_resp': inputs['R_resp'], 'R_recov': inputs['R_recov'], 'R_composite': R }, # Core calculations 's_pot_base': s_pot_base, 's_pot_with_synergy': s_pot, 'synergy_effect': s_pot - s_pot_base, 's_raw': s_raw, 's_raw_adjusted': s_raw_adjusted, 'hysteresis_effect': s_raw - s_raw_adjusted, # Final output 's_kpi_base': s_kpi_base, 'f_vol': f_vol, 'volatility_penalty': 1 - f_vol, 's_kpi_final': s_kpi_final, 'zone': zone, # Uncertainty 'uncertainty': uncertainty_stats, # Diagnostics 'diagnostics': { 'f_lin': f_lin, 'f_soft': f_soft, 'load': D - R, 'exposure': max(P - C, 0), 'volatility_3m': sigma_s if len(self.s_kpi_history) >= 3 else None } } # === DEMO === if __name__ == "__main__": print("="*70) print("S-G INDEX v2.2 — ПОЛНЫЙ PIPELINE DEMO") print("="*70) calculator = SGIndexV22() # Месячные данные monthly_data = [ # Месяц 1: нормальное состояние { 'C': 0.72, 'T_loyalty': 0.68, 'V': 0.65, 'P': 0.35, 'D': 0.30, 'R_prep': 0.82, 'R_resp': 0.75, 'R_recov': 0.78, 'Z_survey': 0.70, 'Z_sentiment': 0.68, 'Z_factcheck': 0.65 }, # Месяц 2: КРИЗИС! { 'C': 0.70, 'T_loyalty': 0.45, 'V': 0.55, 'P': 0.55, 'D': 0.85, 'R_prep': 0.75, 'R_resp': 0.48, 'R_recov': 0.60, 'Z_survey': 0.75, 'Z_sentiment': 0.80, 'Z_factcheck': 0.78 }, # Месяц 3: восстановление { 'C': 0.73, 'T_loyalty': 0.52, 'V': 0.60, 'P': 0.42, 'D': 0.50, 'R_prep': 0.80, 'R_resp': 0.68, 'R_recov': 0.70, 'Z_survey': 0.78, 'Z_sentiment': 0.82, 'Z_factcheck': 0.80 }, ] results = [] for month_num, inputs in enumerate(monthly_data, 1): print(f"\n{'='*70}") print(f"МЕСЯЦ {month_num}") print('='*70) result = calculator.calculate_full_index(inputs, n_mc_samples=500) result['month'] = month_num results.append(result) # Output inp = result['inputs'] print(f"\n📊 INPUTS:") print(f" Core: C={inp['C']:.2f}, T_loyalty={inp['T_loyalty']:.2f}, Z={inp['Z_skepticism']:.2f}") print(f" → T_composite={inp['T_composite']:.2f}") print(f" V={inp['V']:.2f}") print(f" Load: P={inp['P']:.2f}, D={result['inputs']['D']:.2f}") print(f" Resilience: Prep={inp['R_prep']:.2f}, Resp={inp['R_resp']:.2f}, Recov={inp['R_recov']:.2f}") print(f" → R_composite={inp['R_composite']:.2f}") print(f"\n🔬 CALCULATIONS:") print(f" S_pot (base): {result['s_pot_base']:.4f}") print(f" + Synergy C×T: {result['synergy_effect']:+.4f} → {result['s_pot_with_synergy']:.4f}") print(f" × F_lin: {result['diagnostics']['f_lin']:.4f}") print(f" × F_soft: {result['diagnostics']['f_soft']:.4f}") print(f" = S_raw: {result['s_raw']:.4f}") print(f" - Hysteresis: {result['hysteresis_effect']:.4f} → {result['s_raw_adjusted']:.4f}") print(f" → S_KPI (base): {result['s_kpi_base']:.1f}") diag = result['diagnostics'] if diag['volatility_3m'] is not None: print(f" Volatility (3m σ): {diag['volatility_3m']:.2f}") print(f" × F_vol: {result['f_vol']:.4f} (penalty: {result['volatility_penalty']*100:.1f}%)") print(f"\n🎯 FINAL:") print(f" S_KPI = {result['s_kpi_final']:.1f} {result['zone']}") unc = result['uncertainty'] print(f"\n📈 UNCERTAINTY (MC n=500):") print(f" Median: {unc['median']:.1f}") print(f" 95% CI: [{unc['ci_95'][0]:.1f}, {unc['ci_95'][1]:.1f}] (width={unc['ci_95_width']:.1f})") print(f" Zone probabilities:") for zone, prob in unc['zone_probabilities'].items(): if prob > 0.01: bar = "█" * int(prob * 30) print(f" {zone}: {prob*100:.1f}% {bar}") print("\n" + "="*70) print("✅ v2.2 DEMO COMPLETE") print("="*70) ``` --- ## 5. UNIT TESTS ```python import unittest import numpy as np class TestSGIndexV22(unittest.TestCase): """Unit tests для v2.2 компонентов""" def setUp(self): self.calculator = SGIndexWithHysteresis(eta=0.3) self.trust_calc = TrustWithSkepticism() def test_hysteresis_no_effect_on_decline(self): """Гистерезис не должен влиять при падении""" # First calculation result1 = self.calculator.calculate_index( C=0.7, T=0.6, V=0.6, P=0.4, D=0.3, R=0.7 ) # Second: worse (decline) result2 = self.calculator.calculate_index( C=0.7, T=0.5, V=0.6, P=0.5, D=0.6, R=0.7 ) # No hysteresis on decline self.assertLess(result2['s_kpi'], result1['s_kpi']) self.assertAlmostEqual(result2['hysteresis_effect'], 0.0, places=4) def test_hysteresis_slows_recovery(self): """Гистерезис замедляет восстановление""" # Decline self.calculator.calculate_index( C=0.7, T=0.4, V=0.5, P=0.6, D=0.8, R=0.6 ) # Recovery attempt result = self.calculator.calculate_index( C=0.7, T=0.6, V=0.6, P=0.4, D=0.3, R=0.7 ) # Should have hysteresis effect self.assertGreater(result['hysteresis_effect'], 0) def test_trust_composite_bounded(self): """T_composite должен быть в [0, 1]""" for t in [0.0, 0.5, 1.0]: for z in [0.0, 0.5, 1.0]: composite = self.trust_calc.calculate_t_composite(t, z) self.assertGreaterEqual(composite, 0.0) self.assertLessEqual(composite, 1.0) def test_z_calculation(self): """Z должен быть взвешенной комбинацией 3 источников""" z = self.trust_calc.calculate_z_skepticism( survey_check=1.0, sentiment_skeptical=0.5, factcheck_engagement=0.5 ) expected = 0.4 * 1.0 + 0.3 * 0.5 + 0.3 * 0.5 self.assertAlmostEqual(z, expected, places=4) def test_copula_samples_valid(self): """Copula samples должны быть в valid ranges""" corr_matrix = np.eye(6) # independent для теста simulator = CopulaMonteCarloSimulator(corr_matrix) factors = {'C': 0.7, 'T': 0.6, 'V': 0.6, 'P': 0.4, 'D': 0.3, 'R': 0.7} samples = simulator.sample_with_copula(factors, n_samples=100) # Check ranges self.assertTrue((samples >= 0.01).all().all()) self.assertTrue((samples <= 1.0).all().all()) # Check means close to inputs for col in samples.columns: mean = samples[col].mean() self.assertAlmostEqual(mean, factors[col], delta=0.1) if __name__ == '__main__': unittest.main() ``` --- ## 📦 PACKAGE STRUCTURE ``` sg_index_v22/ ├── __init__.py ├── core/ │ ├── __init__.py │ ├── hysteresis.py # SGIndexWithHysteresis │ ├── trust.py # TrustWithSkepticism │ ├── copula.py # CopulaMonteCarloSimulator │ └── calculator.py # SGIndexV22 (main) ├── utils/ │ ├── __init__.py │ ├── visualization.py # Plotting functions │ └── validation.py # Data validation ├── tests/ │ ├── __init__.py │ ├── test_hysteresis.py │ ├── test_trust.py │ └── test_copula.py ├── requirements.txt └── README.md ``` **requirements.txt:** ``` numpy>=1.24.0 scipy>=1.10.0 pandas>=2.0.0 matplotlib>=3.7.0 # for visualization ``` --- ## 🚀 NEXT STEPS 1. **Copy код** в production environment 2. **Run unit tests**: `python -m unittest discover tests/` 3. **Calibrate parameters** на historical data 4. **Integrate** в dashboard/reporting 5. **Monitor** performance в production **Questions:** [Ваш email] **Last updated:** January 8, 2026