Og'irliklarni boshlash

import numpy as np


def sigmoid(z):
    """4-bo'limdagi barqaror yozuv - katta |z| da ham toshmaydi."""
    musbat = z >= 0
    natija = np.empty_like(z, dtype=np.float64)
    natija[musbat] = 1.0 / (1.0 + np.exp(-z[musbat]))
    eksp = np.exp(z[~musbat])
    natija[~musbat] = eksp / (1.0 + eksp)
    return natija


def qatlamlar_orqali(X, olchamlar, masshtab_fn, faollashtirish, urug=0):
    """Signal qatlamlar orqali o'tganda uning tarqalishi qanday o'zgaradi."""
    gen = np.random.default_rng(urug)
    A = X
    tarix = []
    for i in range(len(olchamlar) - 1):
        W = gen.normal(0, masshtab_fn(olchamlar[i]), (olchamlar[i], olchamlar[i + 1]))
        A = faollashtirish(A @ W)
        tarix.append(float(A.std()))
    return tarix


class Tarmoq:
    def __init__(self, olchamlar, masshtab_fn, urug=42):
        gen = np.random.default_rng(urug)
        self.q = len(olchamlar) - 1
        self.W = [gen.normal(0, masshtab_fn(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)
        n = len(y)
        dZ = (A - y) / n
        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)))

gen = np.random.default_rng(42)
X = gen.normal(0, 1, (500, 100))
olchamlar = [100] * 8

print("kirish std:", round(float(X.std()), 4))

for nom, masshtab in [("juda kichik (0.01)", lambda n: 0.01),
                      ("juda katta (1.0)", lambda n: 1.0)]:
    tarix = qatlamlar_orqali(X, olchamlar, masshtab, np.tanh)
    print(f"{nom:<20}", " ".join(f"{s:.4f}" for s in tarix))

std = sqrt(1 / n_kirish)

gen = np.random.default_rng(42)
X = gen.normal(0, 1, (500, 100))
olchamlar = [100] * 8

tarix = qatlamlar_orqali(X, olchamlar, lambda n: np.sqrt(1.0 / n), np.tanh)
print("Xavier + tanh:")
print(" ".join(f"{s:.4f}" for s in tarix))
print("birinchi va oxirgi nisbat:", round(tarix[-1] / tarix[0], 4))

gen = np.random.default_rng(42)
X = gen.normal(0, 1, (500, 100))
olchamlar = [100] * 8


def relu(z):
    return np.maximum(0.0, z)


xavier = qatlamlar_orqali(X, olchamlar, lambda n: np.sqrt(1.0 / n), relu)
he = qatlamlar_orqali(X, olchamlar, lambda n: np.sqrt(2.0 / n), relu)

print("Xavier + ReLU:", " ".join(f"{s:.4f}" for s in xavier))
print("He     + ReLU:", " ".join(f"{s:.4f}" for s in he))

X = np.array([[1.0, 0.5, -1.0], [0.0, 2.0, 1.0]])

for nom, W in [("nol", np.zeros((3, 4))),
               ("hammasi 0.5", np.full((3, 4), 0.5))]:
    A = np.maximum(0.0, X @ W)
    bir_xil = bool(np.allclose(A, A[:, :1]))
    print(f"{nom:<12} chiqish: {np.round(A[0], 4)}  barcha neyronlar bir xilmi: {bir_xil}")

gen = np.random.default_rng(0)
W = gen.normal(0, np.sqrt(2.0 / 3), (3, 4))

for nom, b in [("nol siljish", np.zeros(4)),
               ("tasodifiy siljish", gen.normal(0, 0.5, 4))]:
    A = np.maximum(0.0, np.array([[1.0, 0.5, -1.0]]) @ W + b)
    print(f"{nom:<20} {np.round(A.ravel(), 4)}")

class Tarmoq:
    def __init__(self, olchamlar, masshtab_fn, urug=42):
        gen = np.random.default_rng(urug)
        self.q = len(olchamlar) - 1
        self.W = [gen.normal(0, masshtab_fn(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)
        n = len(y)
        dZ = (A - y) / n
        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)))


gen = np.random.default_rng(7)
X = gen.normal(0, 1, (300, 10))
y = ((X[:, 0] * X[:, 1]) > 0).astype(float).reshape(-1, 1)
olchamlar = [10, 32, 32, 32, 1]

for nom, fn in [("juda kichik", lambda n: 0.01),
                ("Xavier", lambda n: np.sqrt(1.0 / n)),
                ("He", lambda n: np.sqrt(2.0 / n)),
                ("juda katta", lambda n: 1.5)]:
    t = Tarmoq(olchamlar, fn, urug=1)
    boshlangich = t.yoqotish(X, y)
    for _ in range(600):
        t.qadam(X, y, 0.1)
    print(f"{nom:<14} boshlang'ich = {boshlangich:>8.4f}   600 davrdan keyin = {t.yoqotish(X, y):>8.4f}")

gen = np.random.default_rng(0)
X = gen.normal(0, 1, (200, 20))
olchamlar = [20, 64, 64, 64, 1]

t = Tarmoq(olchamlar, lambda n: np.sqrt(2.0 / n), urug=5)
_, kesh = t.oldinga(X)

print("qatlam    o'rtacha      std      nolga teng ulush")
for i in range(1, t.q + 1):
    A = kesh[f"A{i}"]
    print(f"  {i}     {A.mean():>8.4f}  {A.std():>8.4f}  {float((A == 0).mean()):>10.3f}")