Paketli o'qitish

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 malumot(n=1000, urug=0):
    gen = np.random.default_rng(urug)
    X = gen.normal(0, 1, (n, 8))
    qoida = (X[:, 0] * X[:, 1] + X[:, 2] - 0.5 * X[:, 3]) > 0
    y = qoida.astype(float).reshape(-1, 1)
    return X, y


def paketlar(X, y, hajm, gen):
    n = len(X)
    tartib = gen.permutation(n)
    for boshi in range(0, n, hajm):
        idx = tartib[boshi:boshi + hajm]
        yield X[idx], y[idx]


def oqit(hajm, davrlar, tezlik, urug=1):
    X, y = malumot(1000)
    t = Tarmoq([8, 16, 16, 1], urug=urug)
    gen = np.random.default_rng(0)
    qadamlar = 0
    for _ in range(davrlar):
        for xb, yb in paketlar(X, y, hajm, gen):
            t.qadam(xb, yb, tezlik)
            qadamlar += 1
    return t, qadamlar, X, y


def oqit_qadamlar(hajm, jami_qadam, tezlik, urug=1):
    X, y = malumot(1000)
    t = Tarmoq([8, 16, 16, 1], urug=urug)
    gen = np.random.default_rng(0)
    bajarilgan = 0
    while bajarilgan < jami_qadam:
        for xb, yb in paketlar(X, y, hajm, gen):
            t.qadam(xb, yb, tezlik)
            bajarilgan += 1
            if bajarilgan >= jami_qadam:
                break
    return t, X, y

X, y = malumot(1000)
print("X:", X.shape, " y:", y.shape)
print("sinflar muvozanati:", round(float(y.mean()), 4))

def paketlar(X, y, hajm, gen):
    n = len(X)
    tartib = gen.permutation(n)
    for boshi in range(0, n, hajm):
        idx = tartib[boshi:boshi + hajm]
        yield X[idx], y[idx]


X, y = malumot(1000)
gen = np.random.default_rng(0)
hajmlar = [len(xb) for xb, _ in paketlar(X, y, 32, gen)]

print("paketlar soni:", len(hajmlar))
print("birinchi 5 ta paket hajmi:", hajmlar[:5])
print("oxirgi paket hajmi:", hajmlar[-1])
print("jami namunalar:", sum(hajmlar))

X, y = malumot(200)
# ataylab saralangan ma'lumot
tartib = np.argsort(y.ravel())
X_saralangan, y_saralangan = X[tartib], y[tartib]

gen = np.random.default_rng(0)
print("aralashtirmasdan - har paketdagi 1 lar ulushi:")
for i, boshi in enumerate(range(0, 200, 50)):
    ulush = float(y_saralangan[boshi:boshi + 50].mean())
    print(f"  paket {i}: {ulush:.2f}")

print("aralashtirib:")
for i, (xb, yb) in enumerate(paketlar(X_saralangan, y_saralangan, 50, gen)):
    print(f"  paket {i}: {float(yb.mean()):.2f}")

def oqit(hajm, davrlar, tezlik, urug=1):
    X, y = malumot(1000)
    t = Tarmoq([8, 16, 16, 1], urug=urug)
    gen = np.random.default_rng(0)
    qadamlar = 0
    for _ in range(davrlar):
        for xb, yb in paketlar(X, y, hajm, gen):
            t.qadam(xb, yb, tezlik)
            qadamlar += 1
    return t, qadamlar, X, y


for nom, hajm, davrlar in [("to'liq paket", 1000, 200),
                           ("mini-paket 32", 32, 200),
                           ("SGD (1)", 1, 20)]:
    t, qadamlar, X, y = oqit(hajm, davrlar, 0.1)
    print(f"{nom:<16} qadamlar: {qadamlar:>6}  "
          f"yo'qotish: {t.yoqotish(X, y):.4f}  aniqlik: {t.aniqlik(X, y):.4f}")

def oqit_qadamlar(hajm, jami_qadam, tezlik, urug=1):
    X, y = malumot(1000)
    t = Tarmoq([8, 16, 16, 1], urug=urug)
    gen = np.random.default_rng(0)
    bajarilgan = 0
    while bajarilgan < jami_qadam:
        for xb, yb in paketlar(X, y, hajm, gen):
            t.qadam(xb, yb, tezlik)
            bajarilgan += 1
            if bajarilgan >= jami_qadam:
                break
    return t, X, y


for nom, hajm in [("to'liq paket", 1000), ("mini-paket 128", 128),
                  ("mini-paket 32", 32), ("SGD (1)", 1)]:
    t, X, y = oqit_qadamlar(hajm, 3000, 0.1)
    print(f"{nom:<17} 3000 qadam -> yo'qotish: {t.yoqotish(X, y):.4f}  "
          f"aniqlik: {t.aniqlik(X, y):.4f}")

for hajm, tezlik in [(32, 0.03), (32, 0.1), (32, 0.3),
                     (256, 0.03), (256, 0.1), (256, 0.3)]:
    t, X, y = oqit_qadamlar(hajm, 2000, tezlik)
    print(f"hajm {hajm:>4}, tezlik {tezlik:<5} -> "
          f"yo'qotish: {t.yoqotish(X, y):.4f}  aniqlik: {t.aniqlik(X, y):.4f}")

X, y = malumot(1000)
t = Tarmoq([8, 16, 16, 1], urug=1)
gen = np.random.default_rng(0)

paket_yoqotishlari = []
for _ in range(3):
    for xb, yb in paketlar(X, y, 32, gen):
        paket_yoqotishlari.append(t.yoqotish(xb, yb))
        t.qadam(xb, yb, 0.1)

toliq = t.yoqotish(X, y)
p = np.array(paket_yoqotishlari)
print("paket yo'qotishlari - eng kichik:", round(float(p.min()), 4))
print("paket yo'qotishlari - eng katta: ", round(float(p.max()), 4))
print("tarqalish (std):", round(float(p.std()), 4))
print("to'liq to'plamda:", round(toliq, 4))

import sys

X, y = malumot(1000)
t = Tarmoq([8, 64, 64, 1], urug=0)

for hajm in [1, 32, 1000]:
    xb = X[:hajm]
    _, kesh = t.oldinga(xb)
    baytlar = sum(v.nbytes for v in kesh.values())
    print(f"paket {hajm:>4}: keshdagi oraliq qiymatlar {baytlar:>8} bayt")