Hosila va gradient

import numpy as np

def f(x):
    return x ** 2


x = 3.0
h = 1e-6
ozgarish = (f(x + h) - f(x)) / h

print("f(3)      =", f(x))
print("f(3.000001) =", f(x + h))
print("o'zgarish tezligi ≈", round(ozgarish, 4))
print("formula 2x =", 2 * x)

def f(x):
    return x ** 2


def hosila_sonli(fn, x, h=1e-6):
    return (fn(x + h) - fn(x - h)) / (2 * h)


for x in [-3.0, -1.0, 0.0, 1.0, 3.0]:
    q = hosila_sonli(f, x)
    yonalish = "o'sadi" if q > 0 else ("kamayadi" if q < 0 else "tekis")
    print(f"x = {x:>5.1f}   hosila = {q:>6.2f}   o'ngga yursak {yonalish}")

y = f(g(x))   =>   dy/dx = f'(g(x)) · g'(x)

def ichki(x):
    return 3 * x + 1


def tashqi(u):
    return u ** 2


def togri_funksiya(x):
    return tashqi(ichki(x))


def hosila_sonli(fn, x, h=1e-6):
    return (fn(x + h) - fn(x - h)) / (2 * h)


x = 2.0
sonli = hosila_sonli(togri_funksiya, x)
zanjir = 2 * ichki(x) * 3        # f'(g) · g'

print("f(g(2)) =", togri_funksiya(x))
print("sonli hosila:", round(sonli, 6))
print("zanjir qoidasi:", zanjir)
print("mos keladi:", bool(np.isclose(sonli, zanjir, atol=1e-4)))

def yigindi(v):
    x, y = v
    return x ** 2 + 3 * y ** 2


def gradient_sonli(fn, v, h=1e-6):
    g = np.zeros_like(v)
    for i in range(len(v)):
        oldinga = v.copy(); oldinga[i] += h
        orqaga = v.copy(); orqaga[i] -= h
        g[i] = (fn(oldinga) - fn(orqaga)) / (2 * h)
    return g


nuqta = np.array([2.0, 1.0])
g = gradient_sonli(yigindi, nuqta)

print("f(2, 1) =", yigindi(nuqta))
print("gradient:", np.round(g, 4))
print("formula [2x, 6y]:", [2 * 2.0, 6 * 1.0])

def yoqotish(w):
    """Oddiy misol: bitta og'irlikli chiziqli model."""
    X = np.array([1.0, 2.0, 3.0])
    y = np.array([2.0, 4.0, 6.0])
    bashorat = w * X
    return float(np.mean((bashorat - y) ** 2))


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


for w in [0.0, 1.0, 2.0, 3.0]:
    h = 1e-6
    sonli = (yoqotish(w + h) - yoqotish(w - h)) / (2 * h)
    print(f"w = {w:.1f}  yo'qotish = {yoqotish(w):>7.3f}  "
          f"sonli = {sonli:>8.4f}  analitik = {analitik_gradient(w):>8.4f}")

import time


def yoqotish_kop(w):
    """50 ta og'irlikning o'rtachasi bilan bashorat qiladigan model."""
    X = np.arange(1.0, 51.0)
    y = 2.0 * X
    return float(np.mean((np.mean(w) * X - y) ** 2))


w = np.full(50, 1.0)
h = 1e-6

boshlandi = time.perf_counter()
sonli = np.zeros(50)
for i in range(50):
    ol = w.copy(); ol[i] += h
    or_ = w.copy(); or_[i] -= h
    sonli[i] = (yoqotish_kop(ol) - yoqotish_kop(or_)) / (2 * h)
sonli_vaqt = time.perf_counter() - boshlandi

print("50 parametr uchun sonli gradient:", 2 * 50, "ta funksiya chaqiruvi")
print("gradient birinchi 3 element:", np.round(sonli[:3], 4))
print("hammasi bir xilmi:", bool(np.allclose(sonli, sonli[0])))

def gradient_tekshir(yoqotish_fn, gradient_fn, parametr, h=1e-6, chegara=1e-5):
    analitik = gradient_fn(parametr)
    sonli = np.zeros_like(parametr, dtype=np.float64)
    tekis = parametr.ravel()
    sonli_tekis = sonli.ravel()
    for i in range(tekis.size):
        eski = tekis[i]
        tekis[i] = eski + h
        yuqori = yoqotish_fn(parametr)
        tekis[i] = eski - h
        past = yoqotish_fn(parametr)
        tekis[i] = eski
        sonli_tekis[i] = (yuqori - past) / (2 * h)
    ayirma = np.abs(analitik - sonli).max()
    return ayirma < chegara, ayirma


def yoqotish_v(w):
    X = np.array([[1.0, 2.0], [3.0, 1.0], [0.5, 2.0]])
    y = np.array([5.0, 5.0, 4.5])
    return float(np.mean((X @ w - y) ** 2))


def gradient_v(w):
    X = np.array([[1.0, 2.0], [3.0, 1.0], [0.5, 2.0]])
    y = np.array([5.0, 5.0, 4.5])
    return 2.0 / len(y) * X.T @ (X @ w - y)


w = np.array([0.7, 1.3])
mos, ayirma = gradient_tekshir(yoqotish_v, gradient_v, w)
print("analitik gradient:", np.round(gradient_v(w), 6))
print("mos keladimi:", mos)
print("eng katta ayirma:", f"{ayirma:.2e}")

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


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


w = 0.0
tezlik = 0.05
for qadam in range(6):
    g = gradient(w)
    print(f"qadam {qadam}: w = {w:>7.4f}  yo'qotish = {yoqotish(w):>8.4f}  gradient = {g:>9.4f}")
    w = w - tezlik * g