Ma'lumotni tayyorlash

import numpy as np


def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


class Tarmoq:
    def __init__(self, olchamlar, urug=42):
        gen = np.random.default_rng(urug)
        self.q = len(olchamlar) - 1
        self.W = [gen.normal(0, np.sqrt(2.0 / olchamlar[i]),
                             (olchamlar[i], olchamlar[i + 1])) for i in range(self.q)]
        self.b = [np.zeros(olchamlar[i + 1]) for i in range(self.q)]

    def oldinga(self, X):
        A = X
        kesh = {"A0": X}
        for i in range(self.q):
            Z = A @ self.W[i] + self.b[i]
            A = sigmoid(Z) if i == self.q - 1 else np.maximum(0.0, Z)
            kesh[f"Z{i+1}"] = Z
            kesh[f"A{i+1}"] = A
        return A, kesh

    def qadam(self, X, y, tezlik):
        A, kesh = self.oldinga(X)
        dZ = (A - y) / len(y)
        for i in range(self.q - 1, -1, -1):
            dW = kesh[f"A{i}"].T @ dZ
            db = dZ.sum(axis=0)
            if i > 0:
                dZ = (dZ @ self.W[i].T) * (kesh[f"Z{i}"] > 0)
            self.W[i] -= tezlik * dW
            self.b[i] -= tezlik * db

    def yoqotish(self, X, y, eps=1e-12):
        A, _ = self.oldinga(X)
        A = np.clip(A, eps, 1 - eps)
        return float(-np.mean(y * np.log(A) + (1 - y) * np.log(1 - A)))

    def aniqlik(self, X, y):
        A, _ = self.oldinga(X)
        return float(((A > 0.5).astype(float) == y).mean())


def uy_malumoti(n=500, urug=0):
    """Uch belgi, uch xil masshtab: xona soni, maydon, narx."""
    gen = np.random.default_rng(urug)
    xonalar = gen.integers(1, 7, n).astype(float)          # 1 - 6
    maydon = gen.normal(70, 25, n)                          # 20 - 120
    narx = gen.normal(500_000_000, 150_000_000, n)          # yuz millionlar
    X = np.column_stack([xonalar, maydon, narx])
    y = ((maydon > 70) & (narx < 550_000_000)).astype(float).reshape(-1, 1)
    return X, y


def normallash(Xo, Xt):
    ortacha = Xo.mean(axis=0)
    std = Xo.std(axis=0)
    std = np.where(std == 0, 1.0, std)
    return (Xo - ortacha) / std, (Xt - ortacha) / std, ortacha, std


def min_max(Xo, Xt):
    eng_kichik = Xo.min(axis=0)
    eng_katta = Xo.max(axis=0)
    oraliq = np.where(eng_katta - eng_kichik == 0, 1.0, eng_katta - eng_kichik)
    return (Xo - eng_kichik) / oraliq, (Xt - eng_kichik) / oraliq

X, y = uy_malumoti()
print("belgi                o'rtacha            std")
for i, nom in enumerate(["xonalar", "maydon", "narx"]):
    print(f"{nom:<18} {X[:, i].mean():>14.2f} {X[:, i].std():>14.2f}")

X, y = uy_malumoti()
chegara = 350
Xo, yo, Xt, yt = X[:chegara], y[:chegara], X[chegara:], y[chegara:]

t = Tarmoq([3, 16, 16, 1], urug=1)
for _ in range(2000):
    t.qadam(Xo, yo, 0.01)

print("normalizatsiyasiz:")
print("  yo'qotish:", round(t.yoqotish(Xo, yo), 6))
print("  o'qitish aniqligi: ", round(t.aniqlik(Xo, yo), 4))
print("  tekshiruv aniqligi:", round(t.aniqlik(Xt, yt), 4))

def normallash(Xo, Xt):
    ortacha = Xo.mean(axis=0)
    std = Xo.std(axis=0)
    std = np.where(std == 0, 1.0, std)         # nolga bo'linishdan himoya
    return (Xo - ortacha) / std, (Xt - ortacha) / std, ortacha, std


X, y = uy_malumoti()
chegara = 350
Xo, yo, Xt, yt = X[:chegara], y[:chegara], X[chegara:], y[chegara:]
Xo_n, Xt_n, ortacha, std = normallash(Xo, Xt)

print("normalizatsiyadan keyin (o'qitish to'plami):")
print("  o'rtacha:", np.round(Xo_n.mean(axis=0), 6))
print("  std:     ", np.round(Xo_n.std(axis=0), 6))
print("tekshiruv to'plami:")
print("  o'rtacha:", np.round(Xt_n.mean(axis=0), 4))

X, y = uy_malumoti()
chegara = 350
Xo, yo, Xt, yt = X[:chegara], y[:chegara], X[chegara:], y[chegara:]
Xo_n, Xt_n, _, _ = normallash(Xo, Xt)

t = Tarmoq([3, 16, 16, 1], urug=1)
for _ in range(2000):
    t.qadam(Xo_n, yo, 0.1)

print("normalizatsiya bilan:")
print("  yo'qotish:", round(t.yoqotish(Xo_n, yo), 6))
print("  o'qitish aniqligi: ", round(t.aniqlik(Xo_n, yo), 4))
print("  tekshiruv aniqligi:", round(t.aniqlik(Xt_n, yt), 4))

def min_max(Xo, Xt):
    eng_kichik = Xo.min(axis=0)
    eng_katta = Xo.max(axis=0)
    oraliq = np.where(eng_katta - eng_kichik == 0, 1.0, eng_katta - eng_kichik)
    return (Xo - eng_kichik) / oraliq, (Xt - eng_kichik) / oraliq


X, y = uy_malumoti()
Xo, Xt = X[:350], X[350:]
Xo_mm, Xt_mm = min_max(Xo, Xt)

print("o'qitish oralig'i: ", np.round(Xo_mm.min(axis=0), 4), "...", np.round(Xo_mm.max(axis=0), 4))
print("tekshiruv oralig'i:", np.round(Xt_mm.min(axis=0), 4), "...", np.round(Xt_mm.max(axis=0), 4))

shaharlar = np.array(["Toshkent", "Namangan", "Samarqand", "Namangan", "Toshkent"])

# XATO: raqamlash
raqamli = np.array([0, 1, 2, 1, 0])

# TO'G'RI: one-hot
noyob = np.array(["Namangan", "Samarqand", "Toshkent"])
one_hot = (shaharlar[:, None] == noyob[None, :]).astype(float)

print("raqamli:", raqamli)
print("one-hot:")
print(one_hot)
print("ustunlar:", noyob.tolist())

gen = np.random.default_rng(0)
X = gen.normal(50, 10, (10, 3))
X[2, 0] = np.nan
X[5, 1] = np.nan
X[7, 0] = np.nan

print("yetishmayotgan qiymatlar soni ustun bo'yicha:")
print(np.isnan(X).sum(axis=0))

ortacha = np.nanmean(X, axis=0)
X_tuldirilgan = np.where(np.isnan(X), ortacha, X)

print("o'rtacha bilan to'ldirilgandan keyin nan bormi:",
      bool(np.isnan(X_tuldirilgan).any()))
print("to'ldirilgan qiymatlar:", np.round(X_tuldirilgan[[2, 5, 7], [0, 1, 0]], 4))

gen = np.random.default_rng(0)
X = gen.normal(50, 10, (6, 2))
X[1, 0] = np.nan
X[4, 1] = np.nan

ortacha = np.nanmean(X, axis=0)
tuldirilgan = np.where(np.isnan(X), ortacha, X)
bayroq = np.isnan(X).astype(float)
yakuniy = np.hstack([tuldirilgan, bayroq])

print("asl shakl:", X.shape, " -> yakuniy shakl:", yakuniy.shape)
print("bayroq ustunlari:")
print(bayroq)

gen = np.random.default_rng(0)
n = 1000
X = gen.normal(0, 1, (n, 5))
y = (gen.uniform(0, 1, (n, 1)) < 0.05).astype(float)   # atigi 5% musbat

print("musbat sinf ulushi:", round(float(y.mean()), 4))
print("'hammasi 0' deb aytadigan model aniqligi:",
      round(float((y == 0).mean()), 4))

def tayyorla(X_xom, y, ulush=0.7, urug=0):
    gen = np.random.default_rng(urug)
    tartib = gen.permutation(len(X_xom))
    chegara = int(len(X_xom) * ulush)
    o, t = tartib[:chegara], tartib[chegara:]

    Xo, Xt = X_xom[o], X_xom[t]
    yo, yt = y[o], y[t]

    ortacha = np.nanmean(Xo, axis=0)
    Xo = np.where(np.isnan(Xo), ortacha, Xo)
    Xt = np.where(np.isnan(Xt), ortacha, Xt)

    std = Xo.std(axis=0)
    std = np.where(std == 0, 1.0, std)
    Xo = (Xo - ortacha) / std
    Xt = (Xt - ortacha) / std

    return Xo, yo, Xt, yt, {"ortacha": ortacha, "std": std}


X, y = uy_malumoti(500)
X[10, 1] = np.nan
Xo, yo, Xt, yt, parametrlar = tayyorla(X, y)

print("o'qitish:", Xo.shape, " tekshiruv:", Xt.shape)
print("nan qoldimi:", bool(np.isnan(Xo).any() or np.isnan(Xt).any()))
print("o'qitish o'rtachasi:", np.round(Xo.mean(axis=0), 6))
print("saqlangan parametrlar:", sorted(parametrlar.keys()))