Loyiha tuzilishi: o'qitish va xizmat ikki xil hayot

import pandas as pd
show(pd.DataFrame([
    {"jihat": "Qachon ishlaydi", "O'QITISH": "Haftada bir marta", "XIZMAT": "Soniyada yuz marta"},
    {"jihat": "Ma'lumot hajmi", "O'QITISH": "Millionlab qator", "XIZMAT": "Bitta qator"},
    {"jihat": "Tezlik talabi", "O'QITISH": "Soatlar bo'lsa ham mayli", "XIZMAT": "50 ms dan kam"},
    {"jihat": "Apparat", "O'QITISH": "GPU, ko'p xotira", "XIZMAT": "Arzon CPU yetadi"},
    {"jihat": "Yiqilsa", "O'QITISH": "Ertaga qayta chopamiz", "XIZMAT": "Mijoz zarar ko'radi"},
    {"jihat": "Kutubxonalar", "O'QITISH": "sklearn, pandas, matplotlib", "XIZMAT": "faqat kerakli minimum"},
]))

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

d = pd.read_csv(DATA / "ijara.csv")
XUS = ["xonalar", "maydon", "qavat", "jami_qavat", "narx_mln", "tavsif_uzunligi",
       "rasmlar_soni", "telefon_takrorlanishi", "kunlik_elonlar", "egasi_tasdiqlangan"]

Xtr, Xte, ytr, yte = train_test_split(d[XUS], d["broker"], test_size=0.25,
                                      stratify=d["broker"], random_state=42)
m = RandomForestClassifier(n_estimators=150, min_samples_leaf=3,
                           random_state=42, n_jobs=1).fit(Xtr, ytr)

# XIZMATDA: lug'atdan kelgan ma'lumot alifbo tartibida tuzilgan
alifbo = sorted(XUS)
print("o'qitish tartibi :", XUS[:4], "...")
print("xizmat tartibi   :", alifbo[:4], "...")

togri = f1_score(yte, m.predict(Xte[XUS]))
# .values bilan — nomlar yo'qoladi, faqat joylashuv qoladi
notogri = f1_score(yte, m.predict(Xte[alifbo].values))
print(f"\nto'g'ri tartib  : F1 = {togri:.3f}")
print(f"buzilgan tartib : F1 = {notogri:.3f}")
print(f"yo'qotish       : {togri - notogri:.3f}")

try:
    m.predict(Xte[alifbo])            # DataFrame — nomlar bor
except Exception as e:
    print("DataFrame bilan:", type(e).__name__)
    print(" ", str(e).split("\n")[0][:110])

diagramma(
    {
        "Xom ma'lumot\n(CSV / API / oqim)": (0, 1.2, 2.6, 1.1, "manba"),
        "xususiyat.py\n(BITTA tayyorlash kodi)": (3.4, 1.2, 2.8, 1.1, "qayta"),
        "O'qitish\n(haftada bir)": (7.2, 0, 2.4, 1.1, "qayta"),
        "Xizmat\n(soniyada yuz)": (7.2, 2.4, 2.4, 1.1, "xizmat"),
    },
    [
        ("Xom ma'lumot\n(CSV / API / oqim)", "xususiyat.py\n(BITTA tayyorlash kodi)"),
        ("xususiyat.py\n(BITTA tayyorlash kodi)", "O'qitish\n(haftada bir)"),
        ("xususiyat.py\n(BITTA tayyorlash kodi)", "Xizmat\n(soniyada yuz)"),
    ],
    nom="bitta_tayyorlash.png", kenglik=12,
    izoh="Tayyorlash kodi bitta. O'qitish ham, xizmat ham o'shani chaqiradi — nomuvofiqlik imkonsiz bo'ladi.",
)

"""Xususiyat tayyorlash — O'QITISH va XIZMAT uchun BITTA manba.

Bu fayl ikkala tomondan ham chaqiriladi. Uni ikki joyga nusxalash —
o'qitish/xizmat nomuvofiqligining birinchi sababi.
"""
import pandas as pd

XOM_USTUNLAR = ["xonalar", "maydon", "qavat", "jami_qavat", "narx_mln", "tavsif_uzunligi",
                "rasmlar_soni", "telefon_takrorlanishi", "kunlik_elonlar", "egasi_tasdiqlangan"]

# model kutadigan ustunlar, ANIQ shu tartibda
XUSUSIYATLAR = [*XOM_USTUNLAR, "narx_m2", "qavat_nisbati", "rasm_tavsif"]


def tayyorla(df: pd.DataFrame) -> pd.DataFrame:
    """Xom qatorlardan model kutadigan xususiyatlarni yasaydi."""
    x = df[XOM_USTUNLAR].copy()
    x["narx_m2"] = x["narx_mln"] * 1000 / x["maydon"]
    x["qavat_nisbati"] = x["qavat"] / x["jami_qavat"]
    x["rasm_tavsif"] = x["rasmlar_soni"] / (x["tavsif_uzunligi"] / 100).clip(lower=0.3)
    return x[XUSUSIYATLAR]                      # tartib kafolatlangan


def bitta_qator(xom: dict) -> pd.DataFrame:
    """Xizmat uchun: bitta lug'atdan bitta qatorli DataFrame."""
    return tayyorla(pd.DataFrame([xom]))

python3 -c "
import sys; sys.path.insert(0, 'src')
import pandas as pd
from quvur.xususiyat import tayyorla, bitta_qator, XUSUSIYATLAR

d = pd.read_csv('../datasets/ijara.csv')
koplab = tayyorla(d.head(3))
yakka = bitta_qator(d.iloc[0].to_dict())

print('xususiyatlar:', XUSUSIYATLAR)
print()
print('ko\'plab (3 qator) birinchi qatori:')
print(koplab.iloc[0].round(4).to_dict())
print()
print('yakka qator (xizmat yo\'li):')
print(yakka.iloc[0].round(4).to_dict())
print()
print('IKKALASI BIR XILMI:', koplab.iloc[0].round(9).equals(yakka.iloc[0].round(9)))
"

diagramma(
    {
        "src/quvur/\n(umumiy kod)": (0, 0, 2.6, 1.0, "qayta"),
        "src/oqitish/\n(faqat o'qitish)": (0, 1.6, 2.6, 1.0, "manba"),
        "src/xizmat/\n(faqat xizmat)": (0, 3.2, 2.6, 1.0, "xizmat"),
        "konfiguratsiya/\n(YAML, .env)": (3.6, 0.8, 2.4, 1.0, "saqlash"),
        "modellar/\n(artefaktlar)": (3.6, 2.4, 2.4, 1.0, "saqlash"),
        "tests/": (6.8, 0.8, 2.0, 1.0, "qayta"),
        "Dockerfile\n(xizmat uchun)": (6.8, 2.4, 2.0, 1.0, "xizmat"),
    },
    [
        ("src/quvur/\n(umumiy kod)", "src/oqitish/\n(faqat o'qitish)"),
        ("src/quvur/\n(umumiy kod)", "src/xizmat/\n(faqat xizmat)"),
        ("konfiguratsiya/\n(YAML, .env)", "modellar/\n(artefaktlar)"),
    ],
    nom="papkalar.png", kenglik=12,
    izoh="quvur/ ikkala tomon ishlatadigan kod. oqitish/ va xizmat/ bir-birini import qilmaydi.",
)

mkdir -p src/oqitish src/xizmat konfiguratsiya modellar tests
touch src/quvur/__init__.py src/oqitish/__init__.py src/xizmat/__init__.py
find src konfiguratsiya modellar tests -type f -o -type d | sort | head -20

# O'qitish sozlamalari. Kodga tegmasdan o'zgartiriladi.
seed: 42

malumot:
  yol: "../datasets/ijara.csv"
  test_ulushi: 0.25
  nishon: "broker"

model:
  turi: "random_forest"
  parametrlar:
    n_estimators: 150
    min_samples_leaf: 3
    class_weight: null

sifat:
  # CI shu chegaralarni tekshiradi (31-bob)
  eng_kam_f1: 0.80
  eng_kam_toliqlik: 0.75

"""YAML konfiguratsiyani o'qish va tekshirish."""
from dataclasses import dataclass
from pathlib import Path
from typing import Any


@dataclass(frozen=True, slots=True)
class Sozlama:
    seed: int
    malumot: dict[str, Any]
    model: dict[str, Any]
    sifat: dict[str, float]

    @classmethod
    def yukla(cls, yol: str | Path) -> "Sozlama":
        matn = Path(yol).read_text(encoding="utf-8")
        xom = _oddiy_yaml(matn)
        s = cls(seed=int(xom["seed"]), malumot=xom["malumot"],
                model=xom["model"], sifat=xom["sifat"])
        s.tekshir()
        return s

    def tekshir(self) -> None:
        """Noto'g'ri sozlama bilan o'qitish BOSHLANMASIN."""
        t = self.malumot.get("test_ulushi", 0)
        if not 0 < float(t) < 1:
            raise ValueError(f"test_ulushi 0 va 1 orasida bo'lishi kerak, berilgan: {t}")
        if not Path(self.malumot["yol"]).exists():
            raise FileNotFoundError(f"ma'lumot topilmadi: {self.malumot['yol']}")
        for kalit, qiymat in self.sifat.items():
            if not 0 <= float(qiymat) <= 1:
                raise ValueError(f"sifat.{kalit} 0..1 oralig'ida bo'lishi kerak: {qiymat}")


def _oddiy_yaml(matn: str) -> dict[str, Any]:
    """Minimal YAML o'qigich (PyYAML bo'lmasa ham ishlaydi).

    Faqat shu kitobdagi tuzilish uchun: ikki daraja, oddiy qiymatlar.
    Haqiqiy loyihada `pyyaml` ishlating.
    """
    try:
        import yaml
        return yaml.safe_load(matn)
    except ImportError:
        pass
    natija: dict[str, Any] = {}
    stek: list[tuple[int, dict[str, Any]]] = [(-1, natija)]
    for xom in matn.splitlines():
        if not xom.strip() or xom.strip().startswith("#"):
            continue
        chuqurlik = len(xom) - len(xom.lstrip())
        kalit, _, qiymat = xom.strip().partition(":")
        qiymat = qiymat.split("#")[0].strip().strip('"\'')
        while stek and stek[-1][0] >= chuqurlik:
            stek.pop()
        ota = stek[-1][1]
        if qiymat == "":
            yangi: dict[str, Any] = {}
            ota[kalit.strip()] = yangi
            stek.append((chuqurlik, yangi))
        else:
            ota[kalit.strip()] = _qiymat(qiymat)
    return natija


def _qiymat(x: str) -> Any:
    if x in {"null", "~", "None"}:
        return None
    if x in {"true", "false"}:
        return x == "true"
    try:
        return int(x)
    except ValueError:
        pass
    try:
        return float(x)
    except ValueError:
        return x

python3 -c "
import sys; sys.path.insert(0, 'src')
from quvur.sozlama import Sozlama
s = Sozlama.yukla('konfiguratsiya/oqitish.yaml')
print('seed        :', s.seed)
print('model       :', s.model['turi'], s.model['parametrlar'])
print('test ulushi :', s.malumot['test_ulushi'])
print('F1 chegarasi:', s.sifat['eng_kam_f1'])
"

python3 -c "
import sys; sys.path.insert(0, 'src')
from quvur.sozlama import Sozlama
from pathlib import Path

xom = Path('konfiguratsiya/oqitish.yaml').read_text(encoding='utf-8')
buzuq = xom.replace('test_ulushi: 0.25', 'test_ulushi: 1.5')
Path('buzuq.yaml').write_text(buzuq, encoding='utf-8')
try:
    Sozlama.yukla('buzuq.yaml')
except ValueError as e:
    print('XATO (yaxshi):', e)
Path('buzuq.yaml').unlink()
"