Haddan ortiq moslashuv

import numpy as np


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


class Tarmoq:
    def __init__(self, olchamlar, urug=42, l2=0.0, dropout=0.0):
        gen = np.random.default_rng(urug)
        self.q = len(olchamlar) - 1
        self.l2 = l2
        self.dropout = dropout
        self.gen = np.random.default_rng(urug + 1000)
        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, oqitish=False):
        A = X
        kesh = {"A0": X}
        for i in range(self.q):
            Z = A @ self.W[i] + self.b[i]
            if i == self.q - 1:
                A = sigmoid(Z)
            else:
                A = np.maximum(0.0, Z)
                if oqitish and self.dropout > 0:
                    maska = (self.gen.uniform(0, 1, A.shape) > self.dropout)
                    A = A * maska / (1.0 - self.dropout)
                    kesh[f"M{i+1}"] = maska
            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, oqitish=True)
        n = len(y)
        dZ = (A - y) / n
        for i in range(self.q - 1, -1, -1):
            dW = kesh[f"A{i}"].T @ dZ + self.l2 * self.W[i]
            db = dZ.sum(axis=0)
            if i > 0:
                dA = dZ @ self.W[i].T
                if self.dropout > 0 and f"M{i}" in kesh:
                    dA = dA * kesh[f"M{i}"] / (1.0 - self.dropout)
                dZ = dA * (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 shovqinli_malumot(n=200, belgilar=20, urug=0):
    """Faqat dastlabki 2 belgi ma'noli, qolganlari - sof shovqin."""
    gen = np.random.default_rng(urug)
    X = gen.normal(0, 1, (n, belgilar))
    y = ((X[:, 0] + X[:, 1]) > 0).astype(float).reshape(-1, 1)
    # 10% yorliqni ataylab buzamiz
    buzuq = gen.choice(n, size=n // 10, replace=False)
    y[buzuq] = 1.0 - y[buzuq]
    return X, y


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

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)
print("o'qitish:", Xo.shape, " tekshiruv:", Xt.shape)
print("o'qitishda 1 lar ulushi:", round(float(yo.mean()), 3))
print("tekshiruvda 1 lar ulushi:", round(float(yt.mean()), 3))

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)

t = Tarmoq([20, 64, 64, 1], urug=1)
print("davr   o'qitish        tekshiruv")
for davr in range(1, 3001):
    t.qadam(Xo, yo, 0.1)
    if davr in (100, 300, 600, 1000, 2000, 3000):
        print(f"{davr:>5}   {t.yoqotish(Xo, yo):.4f} / {t.aniqlik(Xo, yo):.3f}   "
              f"{t.yoqotish(Xt, yt):.4f} / {t.aniqlik(Xt, yt):.3f}")

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)

t = Tarmoq([20, 64, 64, 1], urug=1)
eng_yaxshi, eng_yaxshi_davr, sabr = float("inf"), 0, 0
for davr in range(1, 3001):
    t.qadam(Xo, yo, 0.1)
    tekshiruv = t.yoqotish(Xt, yt)
    if tekshiruv < eng_yaxshi - 1e-4:
        eng_yaxshi, eng_yaxshi_davr, sabr = tekshiruv, davr, 0
    else:
        sabr += 1
        if sabr >= 200:
            print(f"{davr}-davrda to'xtatildi (200 davr yaxshilanish yo'q)")
            break

print(f"eng yaxshi davr: {eng_yaxshi_davr}, tekshiruv yo'qotishi: {eng_yaxshi:.4f}")

L_yangi = L + (lambda/2) · Σ w²
dW_yangi = dW + lambda · W

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)

for l2 in [0.0, 0.001, 0.01, 0.05, 0.2]:
    t = Tarmoq([20, 64, 64, 1], urug=1, l2=l2)
    for _ in range(3000):
        t.qadam(Xo, yo, 0.1)
    ogirlik_normasi = float(np.sqrt(sum(float((W ** 2).sum()) for W in t.W)))
    print(f"l2 = {l2:<6} o'qitish: {t.aniqlik(Xo, yo):.3f}  "
          f"tekshiruv: {t.aniqlik(Xt, yt):.3f}  ‖W‖ = {ogirlik_normasi:>7.3f}")

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)

for p in [0.0, 0.2, 0.5, 0.8]:
    t = Tarmoq([20, 64, 64, 1], urug=1, dropout=p)
    for _ in range(3000):
        t.qadam(Xo, yo, 0.1)
    print(f"dropout = {p:<5} o'qitish: {t.aniqlik(Xo, yo):.3f}  "
          f"tekshiruv: {t.aniqlik(Xt, yt):.3f}")

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)
t = Tarmoq([20, 32, 1], urug=1, dropout=0.5)
for _ in range(500):
    t.qadam(Xo, yo, 0.1)

a1, _ = t.oldinga(Xt[:3], oqitish=False)
a2, _ = t.oldinga(Xt[:3], oqitish=False)
b1, _ = t.oldinga(Xt[:3], oqitish=True)
b2, _ = t.oldinga(Xt[:3], oqitish=True)

print("bashorat rejimi barqarormi:", bool(np.allclose(a1, a2)))
print("o'qitish rejimi barqarormi:", bool(np.allclose(b1, b2)))

for n in [100, 300, 1000, 3000]:
    X, y = shovqinli_malumot(n)
    Xo, yo, Xt, yt = boling(X, y)
    t = Tarmoq([20, 64, 64, 1], urug=1)
    for _ in range(2000):
        t.qadam(Xo, yo, 0.1)
    print(f"n = {n:>5}  o'qitish: {t.aniqlik(Xo, yo):.3f}  "
          f"tekshiruv: {t.aniqlik(Xt, yt):.3f}  farq: "
          f"{t.aniqlik(Xo, yo) - t.aniqlik(Xt, yt):+.3f}")

X, y = shovqinli_malumot(300)
Xo, yo, Xt, yt = boling(X, y)

for olchamlar in [[20, 4, 1], [20, 16, 1], [20, 64, 64, 1], [20, 128, 128, 128, 1]]:
    t = Tarmoq(olchamlar, urug=1)
    parametrlar = sum(W.size for W in t.W) + sum(b.size for b in t.b)
    for _ in range(2000):
        t.qadam(Xo, yo, 0.1)
    print(f"{str(olchamlar):<24} parametrlar: {parametrlar:>6}  "
          f"o'qitish: {t.aniqlik(Xo, yo):.3f}  tekshiruv: {t.aniqlik(Xt, yt):.3f}")