Model testlari: kod testi yetarli emas

import pandas as pd
show(pd.DataFrame([
    {"tur": "Kod testi", "savol": "Funksiya to'g'ri hisoblaydimi?",
     "misol": "tayyorla() 13 ta ustun qaytaradimi", "qachon buziladi": "Refaktoring"},
    {"tur": "Ma'lumot testi", "savol": "Kirish ma'lumot to'g'rimi?",
     "misol": "maydon > 0 (6-bob)", "qachon buziladi": "Manba o'zgarganda"},
    {"tur": "Model testi", "savol": "Model MANTIQIY xulq qiladimi?",
     "misol": "Telefon ko'p takrorlansa, broker ehtimoli oshishi kerak",
     "qachon buziladi": "Model qayta o'qitilganda"},
]))

diagramma(
    {
        "MINIMAL\nAniq holatlar": (0, 0, 2.6, 1.1, "manba"),
        "YO'NALISH\nX oshsa, Y oshsin": (3.4, 0, 2.6, 1.1, "qayta"),
        "O'ZGARMASLIK\nAhamiyatsiz belgi": (6.8, 0, 2.6, 1.1, "saqlash"),
        "REGRESSIYA\nEskidan yomon emas": (10.2, 0, 2.6, 1.1, "kuzatuv"),
        "Model chiqarilsin": (5.1, 2.2, 3.0, 1.1, "xizmat"),
    },
    [
        ("MINIMAL\nAniq holatlar", "Model chiqarilsin"),
        ("YO'NALISH\nX oshsa, Y oshsin", "Model chiqarilsin"),
        ("O'ZGARMASLIK\nAhamiyatsiz belgi", "Model chiqarilsin"),
        ("REGRESSIYA\nEskidan yomon emas", "Model chiqarilsin"),
    ],
    nom="model_testlari.png", kenglik=13,
    izoh="To'rttasi ham o'tsagina model chiqariladi. Har biri boshqa turdagi nosozlikni ushlaydi.",
)

"""Model testlari uchun namuna yasovchi."""
from typing import Any

import pandas as pd

from .xususiyat import XOM_USTUNLAR

ODATIY = {
    "xonalar": 2, "maydon": 55.0, "qavat": 3, "jami_qavat": 9,
    "narx_mln": 4.5, "tavsif_uzunligi": 300, "rasmlar_soni": 8,
    "telefon_takrorlanishi": 1, "kunlik_elonlar": 1, "egasi_tasdiqlangan": 1,
}


def namuna(**ozgarishlar: Any) -> pd.DataFrame:
    """Odatiy e'lon; berilgan maydonlar almashtiriladi."""
    q = {**ODATIY, **ozgarishlar}
    return pd.DataFrame([{u: q[u] for u in XOM_USTUNLAR}])


def ehtimol(model, **ozgarishlar: Any) -> float:
    """Shu e'lon uchun broker ehtimoli."""
    from .xususiyat import tayyorla
    return float(model.predict_proba(tayyorla(namuna(**ozgarishlar)))[0, 1])

python3 -c "
import sys; sys.path.insert(0, 'src')
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from quvur.xususiyat import XUSUSIYATLAR, tayyorla
from quvur.sinov_yordam import ehtimol

d = pd.read_csv('../datasets/ijara.csv')
x, y = tayyorla(d), d['broker']
Xtr, _, ytr, _ = train_test_split(x, y, test_size=0.25, stratify=y, random_state=42)
m = RandomForestClassifier(n_estimators=150, min_samples_leaf=3, random_state=42, n_jobs=1).fit(Xtr, ytr)
import joblib; joblib.dump(m, 'sinov_model.joblib')

aniq_ega = ehtimol(m, telefon_takrorlanishi=1, kunlik_elonlar=1,
                   tavsif_uzunligi=600, rasmlar_soni=15, egasi_tasdiqlangan=1)
aniq_broker = ehtimol(m, telefon_takrorlanishi=18, kunlik_elonlar=9,
                      tavsif_uzunligi=60, rasmlar_soni=2, egasi_tasdiqlangan=0)
print(f'aniq EGA    -> broker ehtimoli {aniq_ega:.3f}   (past bo\'lishi kerak)')
print(f'aniq BROKER -> broker ehtimoli {aniq_broker:.3f}   (yuqori bo\'lishi kerak)')
print()
print('o\'tdimi:', aniq_ega < 0.3 and aniq_broker > 0.7)
"

python3 -c "
import sys; sys.path.insert(0, 'src')
import joblib
from quvur.sinov_yordam import ehtimol
m = joblib.load('sinov_model.joblib')

print('telefon_takrorlanishi oshgan sari:')
oldingi = -1
buzildi = False
for t in (1, 3, 6, 10, 15, 20):
    e = ehtimol(m, telefon_takrorlanishi=t)
    belgi = '' if e >= oldingi else '  <- KAMAYDI'
    if e < oldingi: buzildi = True
    print(f'  telefon={t:3}  ehtimol={e:.3f}{belgi}')
    oldingi = e
print()
print('monoton oshdimi:', not buzildi)
"

python3 -c "
import sys; sys.path.insert(0, 'src')
import joblib
from quvur.sinov_yordam import ehtimol
m = joblib.load('sinov_model.joblib')

print('tavsif uzaygan sari (teskari yo\'nalish kutiladi):')
for t in (50, 150, 300, 500, 800):
    print(f'  tavsif={t:4}  ehtimol={ehtimol(m, tavsif_uzunligi=t):.3f}')
"

python3 -c "
import sys; sys.path.insert(0, 'src')
import joblib
from quvur.sinov_yordam import ehtimol
m = joblib.load('sinov_model.joblib')

qiymatlar = [ehtimol(m, qavat=q, jami_qavat=12) for q in (1, 3, 5, 8, 11)]
print('qavat o\'zgarganda ehtimol:', [round(v, 3) for v in qiymatlar])
tarqalish = max(qiymatlar) - min(qiymatlar)
print(f'tarqalish: {tarqalish:.3f}')
print('o\'zgarmaslik o\'tdimi (< 0.15):', tarqalish < 0.15)
"

"""Model testlari — pytest bilan ishlatiladi."""
import json
from pathlib import Path
from typing import Any

import pandas as pd

from .sinov_yordam import ehtimol
from .xususiyat import tayyorla


def minimal_funksionallik(model) -> tuple[bool, str]:
    ega = ehtimol(model, telefon_takrorlanishi=1, kunlik_elonlar=1,
                  tavsif_uzunligi=600, rasmlar_soni=15, egasi_tasdiqlangan=1)
    brok = ehtimol(model, telefon_takrorlanishi=18, kunlik_elonlar=9,
                   tavsif_uzunligi=60, rasmlar_soni=2, egasi_tasdiqlangan=0)
    ok = ega < 0.3 and brok > 0.7
    return ok, f"ega={ega:.3f} broker={brok:.3f}"


def yonalish(model, belgi: str, qiymatlar: list, oshishi_kerak: bool,
             eng_kam_farq: float = 0.05, **asos: Any) -> tuple[bool, str]:
    """UMUMIY tendensiyani tekshiradi, qadam-baqadam monotonlikni EMAS.

    Daraxt modellari monoton bo'lishga majbur emas — oraliqda tebranish normal.
    Shuning uchun birinchi va oxirgi qiymat solishtiriladi.

    `asos` — boshlang'ich e'lonni o'zgartiradi. Bu MUHIM: agar e'lon allaqachon
    aniq ega bo'lsa, ehtimol 0.05 atrofida bo'ladi va tushishga JOY QOLMAYDI.
    """
    e = [ehtimol(model, **{**asos, belgi: q}) for q in qiymatlar]
    farq = e[-1] - e[0]
    ok = farq >= eng_kam_farq if oshishi_kerak else farq <= -eng_kam_farq
    yonalish_matni = "oshdi" if farq > 0 else "kamaydi"
    return ok, f"{belgi}: {[round(v, 3) for v in e]} ({yonalish_matni} {abs(farq):.3f})"


def ozgarmaslik(model, belgi: str, qiymatlar: list, chegara: float = 0.15) -> tuple[bool, str]:
    e = [ehtimol(model, **{belgi: q}) for q in qiymatlar]
    t = max(e) - min(e)
    return t < chegara, f"{belgi} tarqalishi={t:.3f}"


def regressiya(yangi_metrikalar: dict[str, float], asos_yoli: str | Path,
               ruxsat: float = 0.01) -> tuple[bool, str]:
    """Yangi model asosdan `ruxsat` dan ko'proq yomon bo'lmasin."""
    p = Path(asos_yoli)
    if not p.exists():
        p.write_text(json.dumps(yangi_metrikalar, indent=2), encoding="utf-8")
        return True, "asos yaratildi (birinchi marta)"
    asos = json.loads(p.read_text(encoding="utf-8"))
    yomonlashgan = []
    for k, eski in asos.items():
        yangi = yangi_metrikalar.get(k)
        if yangi is not None and yangi < eski - ruxsat:
            yomonlashgan.append(f"{k}: {eski:.4f} -> {yangi:.4f}")
    return (not yomonlashgan), ("; ".join(yomonlashgan) or "hammasi asos darajasida")

python3 -c "
import sys; sys.path.insert(0, 'src')
import joblib, json
from quvur.model_test import regressiya

m = joblib.load('sinov_model.joblib')
# asos yaratamiz
print('1)', regressiya({'f1': 0.8595, 'toliqlik': 0.8285}, 'asos.json'))
# bir xil natija — o'tadi
print('2)', regressiya({'f1': 0.8595, 'toliqlik': 0.8285}, 'asos.json'))
# biroz yaxshiroq — o'tadi
print('3)', regressiya({'f1': 0.8700, 'toliqlik': 0.8400}, 'asos.json'))
# sezilarli yomonroq — YIQILADI
print('4)', regressiya({'f1': 0.8100, 'toliqlik': 0.7900}, 'asos.json'))
"

"""Model testlari. `pytest tests/test_model.py -v` bilan ishlaydi."""
import sys
from pathlib import Path

import joblib
import pytest

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))

from quvur.model_test import minimal_funksionallik, ozgarmaslik, yonalish


@pytest.fixture(scope="module")
def model():
    yol = Path(__file__).resolve().parents[1] / "sinov_model.joblib"
    if not yol.exists():
        pytest.skip("model topilmadi — avval o'qitish quvurini ishga tushiring")
    return joblib.load(yol)


def test_minimal_funksionallik(model):
    ok, tafsilot = minimal_funksionallik(model)
    assert ok, f"aniq holatlar noto'g'ri: {tafsilot}"


def test_telefon_kop_bolsa_broker_ehtimoli_oshadi(model):
    ok, tafsilot = yonalish(model, "telefon_takrorlanishi", [1, 5, 10, 18], oshishi_kerak=True)
    assert ok, f"yo'nalish buzildi: {tafsilot}"


def test_tavsif_uzun_bolsa_broker_ehtimoli_kamayadi(model):
    # Shubhali e'londan boshlaymiz: aniq egada ehtimol allaqachon ~0.05,
    # tushishga joy qolmaydi va test sababsiz yiqiladi.
    ok, tafsilot = yonalish(model, "tavsif_uzunligi", [60, 200, 400, 700],
                            oshishi_kerak=False,
                            telefon_takrorlanishi=7, egasi_tasdiqlangan=0,
                            rasmlar_soni=3, kunlik_elonlar=4)
    assert ok, f"yo'nalish buzildi: {tafsilot}"


def test_qavat_natijaga_tasir_qilmaydi(model):
    ok, tafsilot = ozgarmaslik(model, "qavat", [1, 4, 7, 10])
    assert ok, f"ahamiyatsiz belgiga tayanmoqda: {tafsilot}"


@pytest.mark.parametrize("belgi, qiymat", [
    ("maydon", 30.0), ("maydon", 120.0),
    ("xonalar", 1), ("xonalar", 4),
])
def test_ehtimol_oraliqda(model, belgi, qiymat):
    from quvur.sinov_yordam import ehtimol
    e = ehtimol(model, **{belgi: qiymat})
    assert 0.0 <= e <= 1.0

python3 -m pytest tests/test_model.py -v 2>&1 | tail -16

import pandas as pd
show(pd.DataFrame([
    {"nosozlik": "Ustun tartibi buzildi (3-bob)", "qaysi test ushlaydi": "Minimal funksionallik"},
    {"nosozlik": "Nishon teskari o'rgatildi", "qaysi test ushlaydi": "Minimal funksionallik"},
    {"nosozlik": "Model ahamiyatsiz belgiga tayanadi", "qaysi test ushlaydi": "O'zgarmaslik"},
    {"nosozlik": "Mantiq teskari o'rganildi", "qaysi test ushlaydi": "Yo'nalish"},
    {"nosozlik": "Yangi model yomonroq", "qaysi test ushlaydi": "Regressiya"},
    {"nosozlik": "Ma'lumot drifti", "qaysi test ushlaydi": "HECH BIRI — 35-bob kerak"},
]))