To'liq tarmoq - ixtiyoriy chuqurlik

Oldinga:
    Z[i] = A[i-1] @ W[i] + b[i]
    A[i] = f(Z[i])

Orqaga:
    dZ[oxirgi] = (A[oxirgi] - y) / n
    dW[i]      = A[i-1].T @ dZ[i]
    db[i]      = dZ[i].sum(axis=0)
    dA[i-1]    = dZ[i] @ W[i].T
    dZ[i-1]    = dA[i-1] * f'(Z[i-1])

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.olchamlar = olchamlar
        self.qatlamlar = len(olchamlar) - 1
        self.W, self.b = [], []
        for i in range(self.qatlamlar):
            chegara = np.sqrt(2.0 / olchamlar[i])       # He boshlash (13-bo'lim)
            self.W.append(gen.normal(0, chegara, (olchamlar[i], olchamlar[i + 1])))
            self.b.append(np.zeros(olchamlar[i + 1]))

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

    def orqaga(self, y, kesh):
        n = len(y)
        dW = [None] * self.qatlamlar
        db = [None] * self.qatlamlar
        dZ = (kesh[f"A{self.qatlamlar}"] - y) / n
        for i in range(self.qatlamlar - 1, -1, -1):
            dW[i] = kesh[f"A{i}"].T @ dZ
            db[i] = dZ.sum(axis=0)
            if i > 0:
                dZ = (dZ @ self.W[i].T) * (kesh[f"Z{i}"] > 0)
        return dW, db

    def yangilash(self, dW, db, tezlik):
        for i in range(self.qatlamlar):
            self.W[i] -= tezlik * dW[i]
            self.b[i] -= tezlik * db[i]

    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 gradient_tekshir(tarmoq, X, y, h=1e-6):
    _, kesh = tarmoq.oldinga(X)
    dW, db = tarmoq.orqaga(y, kesh)

    eng_katta = 0.0
    for i in range(tarmoq.qatlamlar):
        for param, analitik in ((tarmoq.W[i], dW[i]), (tarmoq.b[i], db[i])):
            tekis = param.ravel()
            grad_tekis = analitik.ravel()
            for k in range(tekis.size):
                eski = tekis[k]
                tekis[k] = eski + h
                yuqori = tarmoq.yoqotish(X, y)
                tekis[k] = eski - h
                past = tarmoq.yoqotish(X, y)
                tekis[k] = eski
                sonli = (yuqori - past) / (2 * h)
                eng_katta = max(eng_katta, abs(sonli - grad_tekis[k]))
    return eng_katta

t = Tarmoq([4, 8, 5, 1])
print("qatlamlar soni:", t.qatlamlar)
for i in range(t.qatlamlar):
    print(f"  W{i+1}: {t.W[i].shape}   b{i+1}: {t.b[i].shape}")

t = Tarmoq([4, 8, 5, 1])
gen = np.random.default_rng(0)
X = gen.normal(0, 1, (6, 4))
y = (gen.uniform(0, 1, (6, 1)) > 0.5).astype(float)

chiqish, kesh = t.oldinga(X)
dW, db = t.orqaga(y, kesh)

print("chiqish shakli:", chiqish.shape)
for i in range(t.qatlamlar):
    print(f"  dW{i+1}: {dW[i].shape} == W{i+1}: {t.W[i].shape} -> "
          f"{dW[i].shape == t.W[i].shape}")
    print(f"  db{i+1}: {db[i].shape} == b{i+1}: {t.b[i].shape} -> "
          f"{db[i].shape == t.b[i].shape}")

def gradient_tekshir(tarmoq, X, y, h=1e-6):
    _, kesh = tarmoq.oldinga(X)
    dW, db = tarmoq.orqaga(y, kesh)

    eng_katta = 0.0
    for i in range(tarmoq.qatlamlar):
        for param, analitik in ((tarmoq.W[i], dW[i]), (tarmoq.b[i], db[i])):
            tekis = param.ravel()
            grad_tekis = analitik.ravel()
            for k in range(tekis.size):
                eski = tekis[k]
                tekis[k] = eski + h
                yuqori = tarmoq.yoqotish(X, y)
                tekis[k] = eski - h
                past = tarmoq.yoqotish(X, y)
                tekis[k] = eski
                sonli = (yuqori - past) / (2 * h)
                eng_katta = max(eng_katta, abs(sonli - grad_tekis[k]))
    return eng_katta


t = Tarmoq([3, 5, 4, 1], urug=7)
gen = np.random.default_rng(3)
X = gen.normal(0, 1, (5, 3))
y = (gen.uniform(0, 1, (5, 1)) > 0.5).astype(float)

ayirma = gradient_tekshir(t, X, y)
print(f"eng katta ayirma: {ayirma:.3e}")
print("backprop to'g'ri:", ayirma < 1e-6)

class BuzilganTarmoq(Tarmoq):
    def orqaga(self, y, kesh):
        n = len(y)
        dW = [None] * self.qatlamlar
        db = [None] * self.qatlamlar
        dZ = (kesh[f"A{self.qatlamlar}"] - y) / n
        for i in range(self.qatlamlar - 1, -1, -1):
            dW[i] = kesh[f"A{i}"].T @ dZ
            db[i] = dZ.sum(axis=0)
            if i > 0:
                # XATO: ReLU maskasi unutilgan
                dZ = dZ @ self.W[i].T
        return dW, db


gen = np.random.default_rng(3)
X = gen.normal(0, 1, (5, 3))
y = (gen.uniform(0, 1, (5, 1)) > 0.5).astype(float)

togri = gradient_tekshir(Tarmoq([3, 5, 4, 1], urug=7), X, y)
buzilgan = gradient_tekshir(BuzilganTarmoq([3, 5, 4, 1], urug=7), X, y)

print(f"to'g'ri kod:   {togri:.3e}")
print(f"buzilgan kod:  {buzilgan:.3e}")
print("tekshiruv xatoni tutdi:", buzilgan > 1e-3)

def oqit(tarmoq, X, y, tezlik=0.5, davrlar=2000, har=500):
    tarix = []
    for davr in range(davrlar + 1):
        _, kesh = tarmoq.oldinga(X)
        dW, db = tarmoq.orqaga(y, kesh)
        tarmoq.yangilash(dW, db, tezlik)
        if davr % har == 0:
            L = tarmoq.yoqotish(X, y)
            tarix.append((davr, L))
            print(f"davr {davr:>5}: yo'qotish = {L:.6f}")
    return tarix


gen = np.random.default_rng(5)
X = gen.normal(0, 1, (200, 3))
# oddiy qoida: birinchi ikki belgining yig'indisi musbatmi
y = ((X[:, 0] + X[:, 1]) > 0).astype(float).reshape(-1, 1)

t = Tarmoq([3, 8, 1], urug=1)
oqit(t, X, y, tezlik=0.5, davrlar=2000, har=500)

bashorat = (t.oldinga(X)[0] > 0.5).astype(float)
print("aniqlik:", round(float((bashorat == y).mean()), 4))

gen = np.random.default_rng(5)
X = gen.normal(0, 1, (200, 3))
y = ((X[:, 0] + X[:, 1]) > 0).astype(float).reshape(-1, 1)

for olchamlar in [[3, 1], [3, 8, 1], [3, 8, 8, 1], [3, 8, 8, 8, 1]]:
    t = Tarmoq(olchamlar, urug=1)
    for _ in range(1500):
        _, kesh = t.oldinga(X)
        dW, db = t.orqaga(y, kesh)
        t.yangilash(dW, db, 0.5)
    bashorat = (t.oldinga(X)[0] > 0.5).astype(float)
    aniqlik = float((bashorat == y).mean())
    print(f"{str(olchamlar):<20} yo'qotish = {t.yoqotish(X, y):.4f}  "
          f"aniqlik = {aniqlik:.4f}")

import time

gen = np.random.default_rng(0)
X = gen.normal(0, 1, (1000, 20))
y = (gen.uniform(0, 1, (1000, 1)) > 0.5).astype(float)

for olchamlar in [[20, 32, 1], [20, 128, 128, 1]]:
    t = Tarmoq(olchamlar, urug=0)
    parametrlar = sum(w.size for w in t.W) + sum(b.size for b in t.b)
    boshlandi = time.perf_counter()
    for _ in range(100):
        _, kesh = t.oldinga(X)
        dW, db = t.orqaga(y, kesh)
        t.yangilash(dW, db, 0.1)
    vaqt = time.perf_counter() - boshlandi
    print(f"{str(olchamlar):<22} parametrlar: {parametrlar:>7}  "
          f"100 davr bajarildi: {vaqt > 0}")