Softmax va ko'p sinfli tasniflash

import numpy as np


def softmax(Z):
    """Barqaror softmax - eng katta qiymatni ayirib toshib ketishning oldini olamiz."""
    Z_siljigan = Z - Z.max(axis=1, keepdims=True)
    eksp = np.exp(Z_siljigan)
    return eksp / eksp.sum(axis=1, keepdims=True)


def kop_sinfli_krossentropiya(Y, A, eps=1e-12):
    A = np.clip(A, eps, 1.0)
    return float(-np.mean(np.sum(Y * np.log(A), axis=1)))


def one_hot(y, sinflar):
    return np.eye(sinflar)[y]


class KopSinfliTarmoq:
    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 = softmax(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):
        A, _ = self.oldinga(X)
        return kop_sinfli_krossentropiya(Y, A)

    def aniqlik(self, X, y_indeks):
        A, _ = self.oldinga(X)
        return float((A.argmax(axis=1) == y_indeks).mean())


def uch_sinf(n=600, urug=0):
    """Uchta spiral - chiziqli ajralmaydigan uch sinf."""
    gen = np.random.default_rng(urug)
    nuqtalar, yorliqlar = [], []
    for sinf in range(3):
        radius = np.linspace(0.1, 1.0, n // 3)
        burchak = np.linspace(sinf * 4, (sinf + 1) * 4, n // 3) + gen.normal(0, 0.2, n // 3)
        nuqtalar.append(np.column_stack([radius * np.sin(burchak),
                                         radius * np.cos(burchak)]))
        yorliqlar.append(np.full(n // 3, sinf))
    return np.vstack(nuqtalar), np.concatenate(yorliqlar)

y = np.array([0, 2, 1, 2, 0])
Y = one_hot(y, 3)
print("indekslar:", y)
print("one-hot:")
print(Y)
print("shakl:", Y.shape)
print("har qatorda bitta 1:", bool((Y.sum(axis=1) == 1).all()))

softmax(z)ᵢ = e^(zᵢ) / Σⱼ e^(zⱼ)

Z = np.array([[2.0, 1.0, 0.1],
              [0.5, 0.5, 0.5],
              [5.0, 1.0, -2.0]])
A = softmax(Z)

print("chiqishlar:")
print(np.round(A, 4))
print("har qatorning yig'indisi:", np.round(A.sum(axis=1), 6))
print("hammasi musbatmi:", bool((A > 0).all()))

Z = np.array([[2.0, 1.0, 0.1], [0.5, 0.5, 0.5], [5.0, 1.0, -2.0]])
A = softmax(Z)
print("yig'indilar:", np.round(A.sum(axis=1), 6))
print("eng katta ehtimollik indeksi:", A.argmax(axis=1))
print("eng katta ehtimollik qiymati:", np.round(A.max(axis=1), 4))

Z_katta = np.array([[1000.0, 999.0, 998.0]])

with np.errstate(over="ignore", invalid="ignore"):
    sodda = np.exp(Z_katta) / np.exp(Z_katta).sum(axis=1, keepdims=True)

print("sodda yozuv:", sodda)
print("nan bormi:", bool(np.isnan(sodda).any()))
print("barqaror yozuv:", np.round(softmax(Z_katta), 6))
print("yig'indi:", float(softmax(Z_katta).sum()))

Z = np.array([[2.0, 1.0, 0.1]])
Z_siljigan = Z - Z.max(axis=1, keepdims=True)

print("asl Z:      ", Z)
print("siljigan Z: ", Z_siljigan)
print("softmax(Z):         ", np.round(softmax(Z), 6))
print("softmax(siljigan):  ", np.round(softmax(Z_siljigan), 6))
print("natija bir xilmi:", bool(np.allclose(softmax(Z), softmax(Z_siljigan))))

L = -(1/n) · Σ Σ yᵢⱼ · log(aᵢⱼ)

Y = one_hot(np.array([0, 1, 2]), 3)
A = np.array([[0.9, 0.05, 0.05],
              [0.2, 0.7, 0.1],
              [0.3, 0.3, 0.4]])

har_biri = -np.sum(Y * np.log(A), axis=1)
for i, (y_qator, a_qator, l) in enumerate(zip(Y, A, har_biri)):
    sinf = int(y_qator.argmax())
    print(f"namuna {i}: to'g'ri sinf {sinf}, unga berilgan ehtimollik "
          f"{a_qator[sinf]:.2f}, yo'qotish {l:.4f}")
print("o'rtacha:", round(float(har_biri.mean()), 6))
print("funksiya bilan:", round(kop_sinfli_krossentropiya(Y, A), 6))

for K in [2, 3, 10, 1000]:
    A = np.full((1, K), 1.0 / K)
    Y = one_hot(np.array([0]), K)
    print(f"K = {K:>4}:  yo'qotish = {kop_sinfli_krossentropiya(Y, A):.4f}   "
          f"ln(K) = {float(np.log(K)):.4f}")

def yoqotish_z_dan(Z, Y):
    return kop_sinfli_krossentropiya(Y, softmax(Z))


Z = np.array([[1.5, -0.5, 0.8]])
Y = one_hot(np.array([2]), 3)

h = 1e-6
sonli = np.zeros_like(Z)
for j in range(Z.shape[1]):
    Z_yuqori = Z.copy(); Z_yuqori[0, j] += h
    Z_past = Z.copy(); Z_past[0, j] -= h
    sonli[0, j] = (yoqotish_z_dan(Z_yuqori, Y) - yoqotish_z_dan(Z_past, Y)) / (2 * h)

formula = softmax(Z) - Y

print("sonli gradient: ", np.round(sonli, 6))
print("A - Y formula:  ", np.round(formula, 6))
print("mos keladi:", bool(np.allclose(sonli, formula, atol=1e-5)))

def uch_sinf(n=600, urug=0):
    """Uchta spiral - chiziqli ajralmaydigan uch sinf."""
    gen = np.random.default_rng(urug)
    nuqtalar, yorliqlar = [], []
    for sinf in range(3):
        radius = np.linspace(0.1, 1.0, n // 3)
        burchak = np.linspace(sinf * 4, (sinf + 1) * 4, n // 3) + gen.normal(0, 0.2, n // 3)
        nuqtalar.append(np.column_stack([radius * np.sin(burchak),
                                         radius * np.cos(burchak)]))
        yorliqlar.append(np.full(n // 3, sinf))
    return np.vstack(nuqtalar), np.concatenate(yorliqlar)


X, y_indeks = uch_sinf(600)
Y = one_hot(y_indeks, 3)
print("X:", X.shape, " Y:", Y.shape)
print("har sinfdan:", np.bincount(y_indeks))

X, y_indeks = uch_sinf(600)
Y = one_hot(y_indeks, 3)

t = KopSinfliTarmoq([2, 64, 64, 3], urug=1)
print("davr    yo'qotish   aniqlik")
for davr in range(3001):
    if davr % 600 == 0:
        print(f"{davr:>5}    {t.yoqotish(X, Y):.4f}    {t.aniqlik(X, y_indeks):.4f}")
    t.qadam(X, Y, 0.5)

X, y_indeks = uch_sinf(600)
Y = one_hot(y_indeks, 3)
t = KopSinfliTarmoq([2, 64, 64, 3], urug=1)
for _ in range(3000):
    t.qadam(X, Y, 0.5)

A, _ = t.oldinga(X[:5])
for i in range(5):
    ehtimolliklar = np.round(A[i], 4)
    tanlov = int(A[i].argmax())
    ishonch = float(A[i].max())
    belgi = "to'g'ri" if tanlov == y_indeks[i] else "XATO"
    print(f"namuna {i}: {ehtimolliklar}  -> sinf {tanlov} "
          f"({ishonch:.1%} ishonch)  haqiqiy {y_indeks[i]}  {belgi}")

Z = np.array([[3.0, 1.0, 0.5]])
for harorat in [0.5, 1.0, 2.0, 5.0]:
    A = softmax(Z / harorat)
    print(f"T = {harorat:<4} {np.round(A, 4)}  eng katta: {float(A.max()):.4f}")