Gradient tushish

1. Bashorat qil          (oldinga tarqalish)
2. Xatoni o'lcha         (yo'qotish funksiyasi)
3. Gradientni hisobla    (orqaga tarqalish)
4. Og'irliklarni siljit: w = w - tezlik · gradient
5. Takrorla

import numpy as np


def yoqotish(w):
    X = np.array([1.0, 2.0, 3.0, 4.0])
    y = np.array([2.0, 4.0, 6.0, 8.0])
    return float(np.mean((w * X - y) ** 2))


def gradient(w):
    X = np.array([1.0, 2.0, 3.0, 4.0])
    y = np.array([2.0, 4.0, 6.0, 8.0])
    return float(np.mean(2 * (w * X - y) * X))


def tushish(w0, tezlik, qadamlar):
    w = w0
    tarix = [w]
    for _ in range(qadamlar):
        w = w - tezlik * gradient(w)
        tarix.append(w)
    return np.array(tarix)

tarix = tushish(0.0, 0.02, 20)
for i in [0, 1, 2, 5, 10, 20]:
    w = tarix[i]
    print(f"qadam {i:>2}: w = {w:.6f}  yo'qotish = {yoqotish(w):.6f}")

for tezlik in [0.001, 0.02, 0.06, 0.07]:
    tarix = tushish(0.0, tezlik, 30)
    oxirgi = tarix[-1]
    holat = "yaqinlashdi" if abs(oxirgi - 2.0) < 0.01 else "yaqinlashmadi"
    print(f"tezlik = {tezlik:<7} 30 qadamdan keyin w = {oxirgi:>12.6f}  {holat}")

for tezlik in [0.1, 0.2, 0.3]:
    tarix = tushish(0.0, tezlik, 20)
    oxirgi = tarix[-1]
    yoq = yoqotish(oxirgi)
    holat = "portladi" if (not np.isfinite(yoq)) or yoq > 1e6 else "barqaror"
    print(f"tezlik = {tezlik:<5} oxirgi w = {oxirgi:>18.4f}  {holat}")

def chiziqli_yoqotish(w, X, y):
    return float(np.mean((X @ w - y) ** 2))


def chiziqli_gradient(w, X, y):
    n = len(y)
    return 2.0 / n * X.T @ (X @ w - y)


gen = np.random.default_rng(42)
X = gen.normal(0, 1, (100, 3))
haqiqiy_w = np.array([2.0, -1.0, 0.5])
y = X @ haqiqiy_w + gen.normal(0, 0.1, 100)

w = np.zeros(3)
tezlik = 0.1
for qadam in range(201):
    if qadam % 50 == 0:
        print(f"qadam {qadam:>3}: w = {np.round(w, 4)}  "
              f"yo'qotish = {chiziqli_yoqotish(w, X, y):.6f}")
    w = w - tezlik * chiziqli_gradient(w, X, y)

print("haqiqiy w:", haqiqiy_w)

print("shovqin dispersiyasi:", 0.1 ** 2)
print("qolgan yo'qotish:    ", 0.009906)
print("nisbat:", round(0.009906 / 0.01, 3))

def chiziqli_yoqotish(w, X, y):
    return float(np.mean((X @ w - y) ** 2))


def chiziqli_gradient(w, X, y):
    return 2.0 / len(y) * X.T @ (X @ w - y)


gen = np.random.default_rng(42)
X = gen.normal(0, 1, (100, 3))
y = X @ np.array([2.0, -1.0, 0.5]) + gen.normal(0, 0.1, 100)

w = np.zeros(3)
oldingi = float("inf")
for qadam in range(1, 501):
    w = w - 0.1 * chiziqli_gradient(w, X, y)
    joriy = chiziqli_yoqotish(w, X, y)
    if abs(oldingi - joriy) < 1e-9:
        print(f"{qadam}-qadamda to'xtadi (o'zgarish 1e-9 dan kichik)")
        break
    oldingi = joriy

print("yakuniy yo'qotish:", round(joriy, 6))

def qiyin(w):
    return float(w ** 4 - 3 * w ** 3 + 2)


def qiyin_gradient(w):
    return float(4 * w ** 3 - 9 * w ** 2)


for boshlanish in [-1.0, 0.5, 3.0]:
    w = boshlanish
    for _ in range(300):
        w = w - 0.01 * qiyin_gradient(w)
    print(f"boshlanish {boshlanish:>5.1f}  ->  w = {w:>8.4f}  f(w) = {qiyin(w):>10.4f}")

def yoqotish(w):
    X = np.array([1.0, 2.0, 3.0, 4.0])
    y = np.array([2.0, 4.0, 6.0, 8.0])
    return float(np.mean((w * X - y) ** 2))


def gradient(w):
    X = np.array([1.0, 2.0, 3.0, 4.0])
    y = np.array([2.0, 4.0, 6.0, 8.0])
    return float(np.mean(2 * (w * X - y) * X))


w_qatiy, w_pasayuvchi = 0.0, 0.0
for qadam in range(1, 41):
    w_qatiy -= 0.05 * gradient(w_qatiy)
    tezlik = 0.05 / (1 + 0.05 * qadam)
    w_pasayuvchi -= tezlik * gradient(w_pasayuvchi)

print(f"qat'iy tezlik:    w = {w_qatiy:.8f}  yo'qotish = {yoqotish(w_qatiy):.3e}")
print(f"pasayuvchi tezlik: w = {w_pasayuvchi:.8f}  yo'qotish = {yoqotish(w_pasayuvchi):.3e}")