Takrorlanish: bir xil natijani ikki marta olish

diagramma(
    {
        "Tasodifiy son\n(seed)": (0, 0, 2.3, 1.0, "manba"),
        "Ma'lumot\n(qaysi versiya)": (2.9, 0, 2.3, 1.0, "manba"),
        "Kutubxona\n(versiya)": (5.8, 0, 2.3, 1.0, "manba"),
        "Apparat\n(CPU/GPU, oqimlar)": (8.7, 0, 2.3, 1.0, "manba"),
        "NATIJA\n(model va metrika)": (4.35, 2.2, 2.3, 1.0, "xizmat"),
    },
    [
        ("Tasodifiy son\n(seed)", "NATIJA\n(model va metrika)"),
        ("Ma'lumot\n(qaysi versiya)", "NATIJA\n(model va metrika)"),
        ("Kutubxona\n(versiya)", "NATIJA\n(model va metrika)"),
        ("Apparat\n(CPU/GPU, oqimlar)", "NATIJA\n(model va metrika)"),
    ],
    nom="takrorlanish_omillari.png", kenglik=12,
    izoh="To'rt manba natijani o'zgartiradi. Ularning har birini qulflash kerak.",
)

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"]
X, y = d[XUS], d["broker"]

print("SEEDSIZ — uch marta ishga tushiramiz:")
natijalar = []
for i in range(3):
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y)   # random_state YO'Q
    m = RandomForestClassifier(n_estimators=60, min_samples_leaf=3, n_jobs=1).fit(Xtr, ytr)
    f1 = f1_score(yte, m.predict(Xte))
    natijalar.append(f1)
    print(f"  {i + 1}-urinish: F1 = {f1:.4f}")
print(f"  eng katta farq: {max(natijalar) - min(natijalar):.4f}")

print("SEED BILAN — uch marta:")
natijalar = []
for i in range(3):
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=42)
    m = RandomForestClassifier(n_estimators=60, min_samples_leaf=3,
                               random_state=42, n_jobs=1).fit(Xtr, ytr)
    f1 = f1_score(yte, m.predict(Xte))
    natijalar.append(f1)
    print(f"  {i + 1}-urinish: F1 = {f1:.10f}")
print(f"  hammasi bir xilmi: {len(set(natijalar)) == 1}")

import random
import numpy as np

def urinish():
    return round(random.random(), 4), round(float(np.random.random()), 4)

print("seedsiz:", urinish(), urinish())
random.seed(42); np.random.seed(42)
a = urinish()
random.seed(42); np.random.seed(42)
b = urinish()
print("seed bilan:", a, b, "| bir xil:", a == b)

"""Takrorlanishni ta'minlash: hamma tasodifiy generatorni qulflash."""
import os
import random

import numpy as np


def seedni_qulfla(seed: int = 42) -> None:
    """Python, numpy va (agar bor bo'lsa) PyTorch generatorlarini qulflaydi.

    PYTHONHASHSEED ham muhim: usiz to'plam (set) va lug'at tartibi
    ishga tushirishlar orasida o'zgarishi mumkin.
    """
    os.environ["PYTHONHASHSEED"] = str(seed)
    random.seed(seed)
    np.random.seed(seed)
    try:
        import torch
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.use_deterministic_algorithms(True, warn_only=True)
    except ImportError:
        pass

python3 -c "
import sys; sys.path.insert(0, 'src')
from quvur.takrorlanish import seedni_qulfla
import random, numpy as np
seedni_qulfla(42); a = (random.random(), float(np.random.random()))
seedni_qulfla(42); b = (random.random(), float(np.random.random()))
print('bir xil natija:', a == b)
print('qiymatlar:', tuple(round(x, 6) for x in a))
"

import hashlib

def fayl_hash(yol, blok=1 << 20):
    """Faylning SHA-256 barmoq izi. Katta fayllar uchun bo'lak-bo'lak o'qiydi."""
    h = hashlib.sha256()
    with open(yol, "rb") as f:
        while chunk := f.read(blok):
            h.update(chunk)
    return h.hexdigest()

for nom in ["ijara.csv", "ijara_yangi.csv"]:
    yol = DATA / nom
    print(f"  {nom:18} {fayl_hash(yol)[:16]}...  {yol.stat().st_size // 1024} KB")

import shutil, hashlib
from pathlib import Path

vaqtinchalik = ISH / "hash_sinov"
vaqtinchalik.mkdir(parents=True, exist_ok=True)
asl = vaqtinchalik / "a.csv"
asl.write_text("ism,baho\nAziz,85\nBobur,90\n", encoding="utf-8")
nusxa = vaqtinchalik / "b.csv"
nusxa.write_text("ism,baho\nAziz,85\nBobur,91\n", encoding="utf-8")   # bitta raqam

h1, h2 = fayl_hash(asl), fayl_hash(nusxa)
print("asl :", h1)
print("o'zg.:", h2)
print("farq qiladigan belgilar soni:", sum(a != b for a, b in zip(h1, h2)), "/ 64")
shutil.rmtree(vaqtinchalik)

import sys, sklearn, numpy, pandas, platform
import pandas as pd
show(pd.DataFrame([
    {"komponent": "Python", "versiya": sys.version.split()[0]},
    {"komponent": "scikit-learn", "versiya": sklearn.__version__},
    {"komponent": "numpy", "versiya": numpy.__version__},
    {"komponent": "pandas", "versiya": pandas.__version__},
    {"komponent": "OS", "versiya": platform.system() + " " + platform.machine()},
]))

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier

Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=42)

qatorlar = []
for oqim in (1, 4, -1):
    ehtimollar, f1lar = [], []
    for _ in range(3):
        m = RandomForestClassifier(n_estimators=60, min_samples_leaf=3,
                                   random_state=42, n_jobs=oqim).fit(Xtr, ytr)
        ehtimollar.append(m.predict_proba(Xte)[:, 1])
        f1lar.append(f1_score(yte, m.predict(Xte)))
    eng_katta_farq = max(np.abs(ehtimollar[0] - ehtimollar[i]).max() for i in (1, 2))
    qatorlar.append({
        "n_jobs": oqim,
        "ehtimolda eng katta farq": f"{eng_katta_farq:.2e}",
        "F1 bir xilmi": len(set(f1lar)) == 1,
        "F1": round(f1lar[0], 10),
    })
show(pd.DataFrame(qatorlar))
print("CPU yadrolari:", __import__("os").cpu_count())

a = 0.1 + (0.2 + 0.3)
b = (0.1 + 0.2) + 0.3
print(f"0.1 + (0.2 + 0.3) = {a!r}")
print(f"(0.1 + 0.2) + 0.3 = {b!r}")
print("teng emas:", a != b, "| farq:", abs(a - b))

"""Har o'qitish uchun takrorlanish pasporti."""
import hashlib
import json
import platform
import subprocess
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any


def fayl_hash(yol: str | Path, blok: int = 1 << 20) -> str:
    h = hashlib.sha256()
    with open(yol, "rb") as f:
        while chunk := f.read(blok):
            h.update(chunk)
    return h.hexdigest()


def git_holati() -> dict[str, str]:
    """Joriy commit va ish daraxti toza yoki yo'qligini qaytaradi."""
    def buyruq(*a: str) -> str:
        try:
            return subprocess.run(a, capture_output=True, text=True, timeout=10).stdout.strip()
        except (OSError, subprocess.SubprocessError):
            return ""
    commit = buyruq("git", "rev-parse", "HEAD")
    ozgargan = buyruq("git", "status", "--porcelain")
    return {"commit": commit or "(git yo'q)", "toza": "ha" if commit and not ozgargan else "yo'q"}


def pasport(malumot_yoli: str | Path, parametrlar: dict[str, Any],
            metrikalar: dict[str, float], seed: int) -> dict[str, Any]:
    """O'qitishni qayta takrorlash uchun kerak bo'ladigan HAMMA narsa."""
    import numpy
    import pandas
    import sklearn
    return {
        "vaqt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
        "seed": seed,
        "malumot": {"yol": str(malumot_yoli), "sha256": fayl_hash(malumot_yoli),
                    "hajm_bayt": Path(malumot_yoli).stat().st_size},
        "kod": git_holati(),
        "muhit": {
            "python": sys.version.split()[0],
            "sklearn": sklearn.__version__,
            "numpy": numpy.__version__,
            "pandas": pandas.__version__,
            "platforma": f"{platform.system()} {platform.machine()}",
        },
        "parametrlar": parametrlar,
        "metrikalar": metrikalar,
    }


def saqla(p: dict[str, Any], yol: str | Path) -> None:
    Path(yol).write_text(json.dumps(p, ensure_ascii=False, indent=2), encoding="utf-8")

"""Pasport bilan o'qitish namunasi."""
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 sklearn.metrics import f1_score, precision_score, recall_score

from quvur.pasport import pasport, saqla
from quvur.takrorlanish import seedni_qulfla

SEED = 42
MALUMOT = "../datasets/ijara.csv"
XUS = ["xonalar", "maydon", "qavat", "jami_qavat", "narx_mln", "tavsif_uzunligi",
       "rasmlar_soni", "telefon_takrorlanishi", "kunlik_elonlar", "egasi_tasdiqlangan"]
PARAM = {"n_estimators": 150, "min_samples_leaf": 3}

seedni_qulfla(SEED)
d = pd.read_csv(MALUMOT)
Xtr, Xte, ytr, yte = train_test_split(d[XUS], d["broker"], test_size=0.25,
                                      stratify=d["broker"], random_state=SEED)
m = RandomForestClassifier(**PARAM, random_state=SEED, n_jobs=-1).fit(Xtr, ytr)
p = m.predict(Xte)

metrikalar = {
    "f1": round(f1_score(yte, p), 4),
    "aniqlik": round(precision_score(yte, p), 4),
    "toliqlik": round(recall_score(yte, p), 4),
}
saqla(pasport(MALUMOT, PARAM, metrikalar, SEED), "pasport.json")
print("metrikalar:", metrikalar)

python3 oqit_pasport.py
echo "--- pasport.json ---"
cat pasport.json

import pandas as pd
show(pd.DataFrame([
    {"savol": "Qaysi ma'lumotda o'qitilgan?", "pasportdagi maydon": "malumot.sha256"},
    {"savol": "Kod qaysi holatda edi?", "pasportdagi maydon": "kod.commit"},
    {"savol": "Saqlanmagan o'zgarish bormidi?", "pasportdagi maydon": "kod.toza"},
    {"savol": "Qaysi kutubxona versiyasi?", "pasportdagi maydon": "muhit.*"},
    {"savol": "Qanday parametrlar bilan?", "pasportdagi maydon": "parametrlar"},
    {"savol": "Natija qanday bo'lgan?", "pasportdagi maydon": "metrikalar"},
]))

import pandas as pd
show(pd.DataFrame([
    {"daraja": "1. Bir xil mashinada", "nima kerak": "Seed + ma'lumot hash",
     "qiyinligi": "oson", "bu kitobda": "2-bob"},
    {"daraja": "2. Boshqa mashinada", "nima kerak": "+ kutubxona qulfi (lock)",
     "qiyinligi": "o'rtacha", "bu kitobda": "7-bob (Docker)"},
    {"daraja": "3. Olti oydan keyin", "nima kerak": "+ ma'lumot arxivi, konteyner image",
     "qiyinligi": "qiyin", "bu kitobda": "4, 7, 23-boblar"},
]))