paste.txt

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

Сущности

INDEX ПЛАН SG ML Total PRODUCT TASK T_loyalty ROADMAP CRS PLANNED OVERVIEW UNIT ТЕСТЫ ФЕВРАЛЯ test_composite_trust_basic

# 📝 SG INDEX v4.2 — ПЛАН УЛУЧШЕНИЙ P1 (ROADMAP) **Версия:** v4.2 P1 Roadmap **Период:** Февраль–Март 2026 **Статус:** 📅 **PLANNED** **Цель:** Довести качество кода и тестирование до 10/10 --- ## 1. OVERVIEW **Зачем нужен P1:** Независимая верификация выявила 5 областей улучшения (не блокирующих launch), которые повысят надёжность и управляемость модели в долгосрочной перспективе. **Приоритет:** P1 (High) — рекомендуется до конца марта 2026 **Не блокирует:** Запуск пилота 22 января ✅ **Влияет на:** Долгосрочную стабильность, coverage, security **5 задач P1:** 1. Unit-тесты (coverage → 85%) 2. Edge-case тесты 3. Pydantic валидация входов 4. Config validator 5. Anti-gaming ML --- ## 2. TASK 1: UNIT-ТЕСТЫ (15 ФЕВРАЛЯ) ### Цель Добавить 20 unit-тестов для каждого компонента модели, чтобы: - Покрытие ≥ 85% (сейчас ~60-75%) - Упростить поиск ошибок при изменениях - Протестировать каждый шаг изолированно ### Что тестировать | Компонент | Количество тестов | Примеры | |-----------|-------------------|---------| | Шаг 1: T_comp | 3 | Basic, границы [0,1], clip | | Шаг 2: S_pot (Cobb-Douglas) | 4 | Zero inputs, CRS, монотонность | | Шаг 3: F_gate | 5 | Границы (T=0, T=0.85, T=1), sigmoid overflow | | Шаг 4: F_syn | 3 | Min (C=T=0), max (C=T=1), нормализация | | Шаг 5: F_vol | 3 | σ=0, σ=50, σ>50 (clip) | | Шаг 6: S_raw (PRODUCT) | 2 | All 1.0, any 0 → result≈0 | | **TOTAL** | **20** | — | ### Код примеров ```python # tests/unit/test_step1_trust.py import pytest from sg_index_v42_final import SGIndexV42 @pytest.fixture def model(): return SGIndexV42() def test_composite_trust_basic(model): """T_comp = 0.6*T_l + 0.4*Z""" result = model.compute(C=1, V=1, T_loyalty=1, Z=0, sigma=0) # При T_l=1, Z=0 → T_comp = 0.6*1 + 0.4*0 = 0.6 assert 0.59 <= result.T_comp <= 0.61 def test_composite_trust_full(model): """При T_l=Z=1 → T_comp=1""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert result.T_comp == 1.0 def test_composite_trust_clip(model): """T_comp должно clip в [0,1]""" # Внутренний clip проверяется через граничные значения result = model.compute(C=1, V=1, T_loyalty=0, Z=0, sigma=0) assert result.T_comp == 0.0 # tests/unit/test_step2_potential.py def test_cobb_douglas_zero_c(model): """При C=0 → S_pot должен быть ≈0 (C^0.25 ≈ 0)""" result = model.compute(C=0, V=1, T_loyalty=1, Z=1, sigma=0) assert result.S_pot < 0.01 def test_cobb_douglas_all_ones(model): """При C=V=T=1 → S_pot=1""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert 0.99 <= result.S_pot <= 1.01 def test_cobb_douglas_crs(model): """Constant Returns to Scale: (2C, 2V, 2T) → 2*S_pot""" # Но входы ограничены [0,1], поэтому тестируем линейность внутри диапазона s1 = model.compute(C=0.5, V=0.5, T_loyalty=0.5, Z=0.5, sigma=0).S_pot s2 = model.compute(C=1.0, V=1.0, T_loyalty=1.0, Z=1.0, sigma=0).S_pot # s2/s1 должно быть около 2^1 = 2 (для CRS) ratio = s2 / s1 if s1 > 0 else 0 assert 1.9 <= ratio <= 2.1 # Approximate CRS def test_cobb_douglas_monotonic_c(model): """C↑ → S_pot↑""" s1 = model.compute(C=0.2, V=1, T_loyalty=1, Z=1, sigma=0).S_pot s2 = model.compute(C=0.8, V=1, T_loyalty=1, Z=1, sigma=0).S_pot assert s2 > s1 # tests/unit/test_step3_gate.py def test_gate_at_zero(model): """При T_comp=0 → F_gate=0""" result = model.compute(C=1, V=1, T_loyalty=0, Z=0, sigma=0) assert result.F_gate < 0.01 def test_gate_at_one(model): """При T_comp=1 → F_gate=1""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert result.F_gate > 0.99 def test_gate_at_threshold(model): """При T_comp=0.85 → F_gate≈0.82""" result = model.compute(C=1, V=1, T_loyalty=0.85, Z=0.85, sigma=0) assert 0.80 <= result.F_gate <= 0.85 def test_gate_sigmoid_overflow_protection(model): """Проверить, что expit защищен от overflow""" # expit должен возвращать 0/1 для очень больших/маленьких x # Косвенная проверка через граничные T result_low = model.compute(C=1, V=1, T_loyalty=0.01, Z=0.01, sigma=0) result_high = model.compute(C=1, V=1, T_loyalty=0.99, Z=0.99, sigma=0) assert 0 <= result_low.F_gate <= 1 assert 0 <= result_high.F_gate <= 1 def test_gate_monotonic(model): """T↑ → F_gate↑""" s1 = model.compute(C=1, V=1, T_loyalty=0.3, Z=0.3, sigma=0).F_gate s2 = model.compute(C=1, V=1, T_loyalty=0.9, Z=0.9, sigma=0).F_gate assert s2 > s1 # tests/unit/test_step4_synergy.py def test_synergy_min(model): """При C=T=0 → F_syn=1 (нет синергии)""" result = model.compute(C=0, V=1, T_loyalty=0, Z=0, sigma=0) assert result.F_syn == 1.0 def test_synergy_max(model): """При C=T=1 → F_syn≈1.259""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert 1.25 <= result.F_syn <= 1.27 def test_synergy_normalization(model): """F_syn должна быть ограничена (не больше 1.26)""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert result.F_syn <= 1.26 # tests/unit/test_step5_volatility.py def test_vol_zero_sigma(model): """При σ=0 → F_vol=1 (нет штрафа)""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert result.F_vol == 1.0 def test_vol_high_sigma(model): """При σ=50 → F_vol=1/(1+0.1*50)=0.167""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=50) assert 0.15 <= result.F_vol <= 0.20 def test_vol_clip_sigma(model): """При σ>50 → должно clip к 50""" result1 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=50) result2 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=100) # Оба должны дать одинаковый F_vol (σ clip к 50) assert abs(result1.F_vol - result2.F_vol) < 0.01 # tests/unit/test_step6_aggregation.py def test_product_all_ones(model): """При всех компонентах=1 → S_raw=max""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) # S_pot=1, F_gate=1, F_syn≈1.259, F_vol=1 → S_raw≈1.259 assert 1.25 <= result.S_raw <= 1.27 def test_product_any_zero(model): """При любом компоненте≈0 → S_raw≈0""" result = model.compute(C=0, V=1, T_loyalty=1, Z=1, sigma=0) # S_pot≈0 → S_raw≈0 assert result.S_raw < 0.01 ``` ### Success Criteria - [ ] Написано 20 unit-тестов - [ ] Все тесты проходят (20/20 ✅) - [ ] Coverage ≥ 85% (pytest --cov) - [ ] CI/CD проверяет coverage автоматически ### Deadline **15 февраля 2026** --- ## 3. TASK 2: EDGE-CASE ТЕСТЫ (20 ФЕВРАЛЯ) ### Цель Протестировать граничные и аномальные случаи: - Отрицательные входы (должно clip → 0) - Очень большие входы (σ > 50, должно clip → 50) - Влияние Z отдельно от T_loyalty - Комбинации крайних значений ### Что тестировать | Категория | Тесты | Цель | |-----------|-------|------| | Negative inputs | 3 | C, V, T < 0 → clip → 0 | | Overflow inputs | 3 | σ > 50 → clip → 50 | | Z influence | 2 | Отдельно от T_loyalty | | Extreme combinations | 2 | (C=0, σ=50), (C=1, σ=0) | | **TOTAL** | **10** | — | ### Код примеров ```python # tests/unit/test_edge_cases.py def test_negative_capacity(model): """C < 0 должно clip к 0""" # Внутренний clip защищает, но проверим результат result = model.compute(C=-0.5, V=1, T_loyalty=1, Z=1, sigma=0) # C=0 → S_pot≈0 → S_official≈0 assert result.S_official < 5 def test_negative_visibility(model): """V < 0 должно clip к 0""" result = model.compute(C=1, V=-0.5, T_loyalty=1, Z=1, sigma=0) assert result.S_official < 5 def test_negative_trust(model): """T_loyalty < 0 должно clip к 0""" result = model.compute(C=1, V=1, T_loyalty=-0.5, Z=0, sigma=0) # T_comp = 0.6*0 + 0.4*0 = 0 → низкий S assert result.S_official < 20 def test_sigma_overflow(model): """σ > 50 должно clip к 50""" result1 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=50) result2 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=100) result3 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=200) # Все должны дать один S_official (σ clip к 50) assert abs(result1.S_official - result2.S_official) < 1 assert abs(result1.S_official - result3.S_official) < 1 def test_sigma_negative(model): """σ < 0 (некорректно) → clip к 0 → F_vol=1""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=-10) # σ=0 → F_vol=1 → S≈100 assert result.S_official > 95 def test_sigma_extreme_positive(model): """σ=1000 (некорректно) → clip к 50""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=1000) assert 15 <= result.S_official <= 20 # F_vol≈0.167 def test_z_influence_low_trust(model): """Z влияет на T_comp отдельно от T_loyalty""" # При T_loyalty=0.5, Z=0 → T_comp=0.3 s1 = model.compute(C=1, V=1, T_loyalty=0.5, Z=0, sigma=0).S_official # При T_loyalty=0.5, Z=1 → T_comp=0.7 s2 = model.compute(C=1, V=1, T_loyalty=0.5, Z=1, sigma=0).S_official assert s2 > s1 # Z=1 должно повысить T_comp и S def test_z_influence_high_trust(model): """Z влияет даже при высоком T_loyalty""" s1 = model.compute(C=1, V=1, T_loyalty=1, Z=0, sigma=0).S_official s2 = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0).S_official # T_comp: 0.6 vs 1.0 → значительная разница assert s2 > s1 + 10 def test_extreme_low_capacity_high_vol(model): """C=0, σ=50 → S должен быть очень низким""" result = model.compute(C=0, V=1, T_loyalty=1, Z=1, sigma=50) # S_pot≈0, F_vol≈0.167 → S≈0 assert result.S_official < 1 def test_extreme_high_all_zero_vol(model): """C=V=T=Z=1, σ=0 → S≈100""" result = model.compute(C=1, V=1, T_loyalty=1, Z=1, sigma=0) assert result.S_official > 95 ``` ### Success Criteria - [ ] Написано 10 edge-case тестов - [ ] Все тесты проходят (10/10 ✅) - [ ] Все граничные случаи покрыты ### Deadline **20 февраля 2026** --- ## 4. TASK 3: PYDANTIC ВАЛИДАЦИЯ (1 МАРТА) ### Цель Защита от некорректных входов на API-уровне: - Проверка типов (float, не str) - Проверка диапазонов (C ∈ [0,1], σ ∈ [0,50]) - Автоматическая ошибка 400 Bad Request при нарушении ### Где применять В FastAPI endpoint (`api/app.py`). ### Код ```python # api/models.py from pydantic import BaseModel, Field, validator from typing import Optional class SGIndexRequest(BaseModel): """Validated input for SG INDEX computation""" C: float = Field( ..., ge=0.0, le=1.0, description="Capacity: organizational resources [0, 1]" ) V: float = Field( ..., ge=0.0, le=1.0, description="Visibility: social presence [0, 1]" ) T_loyalty: float = Field( ..., ge=0.0, le=1.0, description="Trust/Loyalty [0, 1]" ) Z: float = Field( ..., ge=0.0, le=1.0, description="Skepticism [0, 1]" ) sigma: float = Field( ..., ge=0.0, le=50.0, description="Volatility: weekly std dev [0, 50 weeks]" ) @validator('*', pre=True) def check_numeric(cls, v, field): """Ensure all fields are numeric (not str, None, etc.)""" if v is None: raise ValueError(f"{field.name} is required") if not isinstance(v, (int, float)): raise ValueError(f"{field.name} must be numeric, got {type(v).__name__}") return float(v) class Config: schema_extra = { "example": { "C": 0.8, "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 5.0 } } class SGIndexResponse(BaseModel): """Output from SG INDEX computation""" # Inputs (echo back) C: float V: float T_loyalty: float Z: float sigma: float # Intermediate components T_comp: float S_pot: float F_gate: float F_syn: float F_vol: float S_raw: float # Final output S_official: float zone: str class Config: schema_extra = { "example": { "C": 0.8, "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 5.0, "T_comp": 0.69, "S_pot": 0.768, "F_gate": 0.751, "F_syn": 1.178, "F_vol": 0.833, "S_raw": 0.519, "S_official": 41.2, "zone": "🟡 Caution" } } # api/app.py from fastapi import FastAPI, HTTPException from api.models import SGIndexRequest, SGIndexResponse from sg_index_v42_final import SGIndexV42 app = FastAPI(title="SG INDEX v4.2 API") model = SGIndexV42() @app.post("/api/sg-index/compute", response_model=SGIndexResponse) async def compute_index(request: SGIndexRequest): """ Compute SG INDEX v4.2 for given inputs. All inputs are validated by Pydantic: - C, V, T_loyalty, Z ∈ [0, 1] - sigma ∈ [0, 50] - All must be numeric """ try: result = model.compute( C=request.C, V=request.V, T_loyalty=request.T_loyalty, Z=request.Z, sigma=request.sigma ) return SGIndexResponse(**result.to_dict()) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/health") async def health(): """Health check endpoint""" return {"status": "healthy", "version": "v4.2"} ``` ### Тесты ```python # tests/api/test_validation.py from fastapi.testclient import TestClient from api.app import app client = TestClient(app) def test_valid_input(): """Валидный вход → 200 OK""" response = client.post("/api/sg-index/compute", json={ "C": 0.8, "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 5.0 }) assert response.status_code == 200 data = response.json() assert 0 <= data["S_official"] <= 100 def test_invalid_c_out_of_range(): """C > 1 → 422 Validation Error""" response = client.post("/api/sg-index/compute", json={ "C": 1.5, "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 5.0 }) assert response.status_code == 422 def test_invalid_sigma_out_of_range(): """σ > 50 → 422 Validation Error""" response = client.post("/api/sg-index/compute", json={ "C": 0.8, "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 100 }) assert response.status_code == 422 def test_invalid_type_string(): """Строка вместо числа → 422 Validation Error""" response = client.post("/api/sg-index/compute", json={ "C": "invalid", "V": 0.7, "T_loyalty": 0.75, "Z": 0.3, "sigma": 5.0 }) assert response.status_code == 422 def test_missing_field(): """Пропущено поле → 422 Validation Error""" response = client.post("/api/sg-index/compute", json={ "C": 0.8, "V": 0.7, "Z": 0.3, "sigma": 5.0 # T_loyalty missing }) assert response.status_code == 422 ``` ### Success Criteria - [ ] SGIndexRequest реализован с полной валидацией - [ ] API endpoint использует Pydantic models - [ ] 5 тестов валидации написаны (5/5 ✅) - [ ] API возвращает 422 на некорректные входы ### Deadline **1 марта 2026** --- ## 5. TASK 4: CONFIG VALIDATOR (10 МАРТА) ### Цель Валидация config.yaml при загрузке: - Проверка всех параметров (k, θ, ε, μ, weights) - Проверка CRS: w_C + w_T + w_V = 1.0 - Защита от ручного редактирования конфига с ошибками ### Код ```python # utils/config_validator.py import yaml from pydantic import BaseModel, validator from typing import Dict, Any class ModelParameters(BaseModel): """Validated model parameters""" # Theory-fixed k: float = 2.0 theta: float = 0.85 # Data-calibrated epsilon: float = 0.35 mu: float = 0.10 # Cobb-Douglas weights w_C: float = 0.25 w_T: float = 0.40 w_V: float = 0.35 # Scaling scale_divisor: float = 1.26 @validator('k') def validate_k(cls, v): if not (1.0 <= v <= 5.0): raise ValueError(f"k must be in [1.0, 5.0], got {v}") return v @validator('theta') def validate_theta(cls, v): if not (0.5 <= v <= 1.0): raise ValueError(f"theta must be in [0.5, 1.0], got {v}") return v @validator('epsilon') def validate_epsilon(cls, v): if not (0.0 <= v <= 1.0): raise ValueError(f"epsilon must be in [0.0, 1.0], got {v}") return v @validator('mu') def validate_mu(cls, v): if not (0.0 <= v <= 0.5): raise ValueError(f"mu must be in [0.0, 0.5], got {v}") return v @validator('w_C', 'w_T', 'w_V') def validate_weights(cls, v): if not (0.0 <= v <= 1.0): raise ValueError(f"weights must be in [0.0, 1.0], got {v}") return v @validator('scale_divisor') def validate_divisor(cls, v): if not (1.0 <= v <= 2.0): raise ValueError(f"scale_divisor must be in [1.0, 2.0], got {v}") return v def validate_crs(self): """Check Constant Returns to Scale""" weight_sum = self.w_C + self.w_T + self.w_V if abs(weight_sum - 1.0) > 1e-6: raise ValueError( f"CRS violation: w_C + w_T + w_V = {weight_sum:.6f}, expected 1.0" ) class SGIndexConfig(BaseModel): """Full configuration including version, parameters, zoning""" version: str parameters: ModelParameters def validate(self): """Run all validations""" self.parameters.validate_crs() def load_config(path: str = "config.yaml") -> SGIndexConfig: """ Load and validate configuration from YAML file. Raises: FileNotFoundError: If config file doesn't exist ValueError: If config is invalid """ with open(path, 'r') as f: data = yaml.safe_load(f) config = SGIndexConfig( version=data['version'], parameters=ModelParameters(**data['model']['parameters']) ) # Validate CRS config.validate() return config # Usage example if __name__ == "__main__": try: config = load_config("config.yaml") print(f"✅ Config loaded successfully: v{config.version}") print(f" k={config.parameters.k}, θ={config.parameters.theta}") print(f" ε={config.parameters.epsilon}, μ={config.parameters.mu}") print(f" Weights: C={config.parameters.w_C}, T={config.parameters.w_T}, V={config.parameters.w_V}") print(f" CRS check: ✓ {config.parameters.w_C + config.parameters.w_T + config.parameters.w_V}") except Exception as e: print(f"❌ Config validation failed: {e}") ``` ### Тесты ```python # tests/utils/test_config_validator.py import pytest import yaml import tempfile from utils.config_validator import load_config, ModelParameters def test_valid_config(): """Валидный config → успешная загрузка""" config_data = { 'version': 'v4.2', 'model': { 'parameters': { 'k': 2.0, 'theta': 0.85, 'epsilon': 0.35, 'mu': 0.10, 'w_C': 0.25, 'w_T': 0.40, 'w_V': 0.35, 'scale_divisor': 1.26 } } } with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f: yaml.dump(config_data, f) config_path = f.name config = load_config(config_path) assert config.version == 'v4.2' assert config.parameters.k == 2.0 def test_crs_violation(): """Веса не суммируются в 1.0 → ValueError""" with pytest.raises(ValueError, match="CRS violation"): params = ModelParameters( k=2.0, theta=0.85, epsilon=0.35, mu=0.10, w_C=0.3, w_T=0.4, w_V=0.4, # сумма = 1.1 ≠ 1.0 scale_divisor=1.26 ) params.validate_crs() def test_invalid_epsilon(): """ε > 1.0 → ValueError""" with pytest.raises(ValueError, match="epsilon"): ModelParameters( k=2.0, theta=0.85, epsilon=1.5, mu=0.10, w_C=0.25, w_T=0.40, w_V=0.35, scale_divisor=1.26 ) ``` ### Success Criteria - [ ] ModelParameters реализован с полной валидацией - [ ] load_config() проверяет CRS - [ ] 3 теста написаны (3/3 ✅) - [ ] Config загружается при старте приложения с валидацией ### Deadline **10 марта 2026** --- ## 6. TASK 5: ANTI-GAMING ML (31 МАРТА) ### Цель Добавить ML-детектор аномалий для выявления манипуляций входными данными: - Использовать Isolation Forest (sklearn) - Обучить на исторических "чистых" данных - Флаг "suspicious" при отклонении от нормального паттерна ### Архитектура ``` Входы (C, V, T, Z, σ) → Isolation Forest → Score ∈ [-1, 1] ↓ If score < -0.5: flag = "suspicious" ``` ### Код ```python # utils/anti_gaming.py import numpy as np from sklearn.ensemble import IsolationForest import joblib class AntiGamingDetector: """ML-based anomaly detection for gaming attempts""" def __init__(self, model_path: str = None): if model_path: self.model = joblib.load(model_path) else: # Default untrained model self.model = IsolationForest( n_estimators=100, contamination=0.05, # 5% expected anomalies random_state=42 ) def fit(self, X: np.ndarray): """ Train on historical "clean" data. X shape: (n_samples, 5) for [C, V, T_loyalty, Z, sigma] """ self.model.fit(X) def predict(self, C: float, V: float, T_loyalty: float, Z: float, sigma: float) -> dict: """ Detect if inputs are suspicious. Returns: { "suspicious": bool, "score": float, # -1 (anomaly) to 1 (normal) "confidence": float # 0-1 } """ X = np.array([[C, V, T_loyalty, Z, sigma]]) score = self.model.score_samples(X)[0] decision = self.model.predict(X)[0] # 1 (normal), -1 (anomaly) return { "suspicious": (decision == -1), "score": float(score), "confidence": abs(score) } def save(self, path: str): """Save trained model""" joblib.dump(self.model, path) # Training script (one-time) if __name__ == "__main__": # Load historical clean data # X_train shape: (n_samples, 5) X_train = np.array([ [0.8, 0.7, 0.75, 0.3, 5.0], [0.9, 0.85, 0.8, 0.4, 3.0], # ... more samples ]) detector = AntiGamingDetector() detector.fit(X_train) detector.save("models/anti_gaming_v1.pkl") print("✅ Model trained and saved") # Integration into API from utils.anti_gaming import AntiGamingDetector # In api/app.py detector = AntiGamingDetector(model_path="models/anti_gaming_v1.pkl") @app.post("/api/sg-index/compute", response_model=SGIndexResponse) async def compute_index(request: SGIndexRequest): # Check for gaming gaming_check = detector.predict( C=request.C, V=request.V, T_loyalty=request.T_loyalty, Z=request.Z, sigma=request.sigma ) if gaming_check["suspicious"]: # Log for review, but still compute logger.warning(f"Suspicious input detected: {request.dict()}, score={gaming_check['score']}") result = model.compute(...) response = SGIndexResponse(**result.to_dict()) # Add gaming flag to response response.gaming_flag = gaming_check["suspicious"] response.gaming_score = gaming_check["score"] return response ``` ### Success Criteria - [ ] AntiGamingDetector реализован - [ ] Модель обучена на ~1000 historical samples - [ ] Интегрирована в API (флаг "suspicious" в response) - [ ] Логирование подозрительных запросов ### Deadline **31 марта 2026** --- ## 7. TIMELINE (GANTT) ``` Февраль 2026: ┌──────────────────────────────────────────────────┐ │ Week 1 (3-9 Feb): Task 1 (unit-тесты) │ ████████░░░░░░ │ Week 2 (10-16 Feb): Task 1 завершение │ ░░░░░░░░████░░ │ Week 3 (17-23 Feb): Task 2 (edge-cases) │ ░░░░░░░░░░░░████ │ Week 4 (24-28 Feb): Weekly pilot report #1 │ └──────────────────────────────────────────────────┘ Март 2026: ┌──────────────────────────────────────────────────┐ │ Week 1 (3-9 Mar): Task 3 (Pydantic) │ ████████░░░░░░ │ Week 2 (10-16 Mar): Task 4 (config validator) │ ░░░░░░░░████░░ │ Week 3 (17-23 Mar): Task 5 (anti-gaming) part 1 │ ░░░░░░░░░░░░████ │ Week 4 (24-31 Mar): Task 5 завершение + v4.3 │ ░░░░░░░░░░░░░░░░████ └──────────────────────────────────────────────────┘ Milestones: ├─ 15 Feb: Unit-тесты done (20/20 ✅) ├─ 20 Feb: Edge-cases done (10/10 ✅) ├─ 01 Mar: Pydantic done ├─ 10 Mar: Config validator done └─ 31 Mar: P1 Release (v4.3) + Weekly pilot report #2 ``` --- ## 8. SUCCESS CRITERIA (KPI) | Task | Метрика | Target | Measurement | |------|---------|--------|-------------| | Task 1 | Coverage | ≥ 85% | `pytest --cov` | | Task 1 | Unit-тесты | 20/20 ✅ | `pytest tests/unit/` | | Task 2 | Edge-case тесты | 10/10 ✅ | `pytest tests/unit/test_edge_cases.py` | | Task 3 | API validation | 5/5 ✅ | `pytest tests/api/test_validation.py` | | Task 4 | Config validation | 3/3 ✅ | `pytest tests/utils/test_config_validator.py` | | Task 5 | Anti-gaming | Model trained | Accuracy ≥ 95% на test set | | **OVERALL** | **P1 Completion** | **100%** | **All 5 tasks done by 31 Mar** | --- ## 9. ЗАКЛЮЧЕНИЕ **P1 Roadmap готов к выполнению.** После завершения всех 5 задач: - Coverage вырастет с 75% → 85%+ - Код получит оценку 10/10 (вместо 9/10) - Тестирование получит оценку 10/10 (вместо 8/10) - **Общая оценка:** 9.4 → **9.8/10** ✅ **Это повысит долгосрочную стабильность модели и упростит дальнейшее развитие (P2).** --- **Подготовлено:** Development Team **Дата:** 10 января 2026 **Статус:** 📅 **PLANNED** (Feb-Mar 2026) **Приоритет:** P1 (High, но не блокирует launch)