PCA: o'lchovni kamaytirish

import pandas as pd
import numpy as np

r = np.random.default_rng(42)
print("Ustunlar ko'payganda nima bo'ladi:")
print(f"{'o`lchov':>8} {'eng yaqin masofa':>18} {'eng uzoq':>10} {'nisbat':>8}")
print("-" * 48)
for m in [2, 10, 100, 1000]:
    P = r.normal(size=(400, m))
    d = np.linalg.norm(P[1:] - P[0], axis=1)
    print(f"{m:>8} {d.min():>18.3f} {d.max():>10.3f} {d.max()/d.min():>8.2f}")

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# ikki o'lchovda ko'rsatamiz — kuzatish uchun
X2 = r.multivariate_normal([0, 0], [[3, 2.4], [2.4, 2.2]], size=300)
p2 = PCA(n_components=2).fit(X2)

rasm, axes = plt.subplots(1, 2, figsize=(13, 5))
axes[0].scatter(X2[:, 0], X2[:, 1], alpha=.45, s=22, color="#1a73e8")
for uz, vek in zip(p2.explained_variance_, p2.components_):
    axes[0].arrow(0, 0, vek[0]*np.sqrt(uz)*2, vek[1]*np.sqrt(uz)*2,
                  width=.06, color="#c5221f", length_includes_head=True)
axes[0].set_title("Asl ma'lumot va asosiy yo'nalishlar", fontweight="bold")
axes[0].set_aspect("equal"); axes[0].grid(alpha=.3)

Xp = p2.transform(X2)
axes[1].scatter(Xp[:, 0], Xp[:, 1], alpha=.45, s=22, color="#137333")
axes[1].axhline(0, color="k", lw=.8); axes[1].axvline(0, color="k", lw=.8)
axes[1].set_xlabel("PC1"); axes[1].set_ylabel("PC2")
axes[1].set_title("PCA dan keyin — o'qlar aylantirildi", fontweight="bold")
axes[1].set_aspect("equal"); axes[1].grid(alpha=.3)
fig("pca_goya.png", caption="Qizil strelkalar — asosiy komponentlar. Uzuni eng ko'p tarqalish yo'nalishi. O'ngda shu yo'nalishlar o'q qilib olingan.")

print("Har bir komponent qancha dispersiyani tushuntiradi:")
for i, v in enumerate(p2.explained_variance_ratio_, 1):
    print(f"  PC{i}: {v:.4f}  ({v:.1%})")
print(f"  Yig'indi: {p2.explained_variance_ratio_.sum():.4f}")

# qo'lda PCA — kovariatsiya matritsasining xos vektorlari
Xm = X2 - X2.mean(axis=0)
kov = (Xm.T @ Xm) / (len(Xm) - 1)
xos_qiymat, xos_vektor = np.linalg.eigh(kov)
tartib = np.argsort(xos_qiymat)[::-1]
xos_qiymat, xos_vektor = xos_qiymat[tartib], xos_vektor[:, tartib]

print("Qo'lda hisoblangan:")
print(f"  xos qiymatlar : {xos_qiymat.round(4)}")
print(f"  ulushlar      : {(xos_qiymat/xos_qiymat.sum()).round(4)}")
print()
print("sklearn PCA:")
print(f"  dispersiyalar : {p2.explained_variance_.round(4)}")
print(f"  ulushlar      : {p2.explained_variance_ratio_.round(4)}")
print()
print(f"Mos keldimi: {bool(np.allclose(xos_qiymat, p2.explained_variance_))}")

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]
from sklearn.impute import SimpleImputer
Xd = SimpleImputer(strategy="median").fit_transform(df[son])

print("Ustunlar dispersiyasi (xom):")
for nom, v in zip(son, Xd.var(axis=0)):
    print(f"  {nom:16s} {v:>12.1f}")
print()
p_xom = PCA().fit(Xd)
p_shk = PCA().fit(StandardScaler().fit_transform(Xd))
print(f"{'komponent':>10} {'scaling YO`Q':>14} {'scaling BOR':>13}")
print("-" * 40)
for i in range(4):
    print(f"{'PC'+str(i+1):>10} {p_xom.explained_variance_ratio_[i]:>14.4f} "
          f"{p_shk.explained_variance_ratio_[i]:>13.4f}")

Xs = StandardScaler().fit_transform(Xd)
p = PCA().fit(Xs)
jamlangan = np.cumsum(p.explained_variance_ratio_)
jadval = pd.DataFrame({
    "komponent": [f"PC{i}" for i in range(1, len(son)+1)],
    "dispersiya ulushi": p.explained_variance_ratio_.round(4),
    "jamlangan": jamlangan.round(4),
})
show(jadval)
print()
for chegara in [0.80, 0.90, 0.95, 0.99]:
    n = int(np.searchsorted(jamlangan, chegara) + 1)
    print(f"  {chegara:.0%} dispersiya uchun {n} komponent kerak ({len(son)} dan)")

rasm, axes = plt.subplots(1, 2, figsize=(13, 4.5))
axes[0].bar(range(1, len(son)+1), p.explained_variance_ratio_, color="#1a73e8", alpha=.85)
axes[0].set_xlabel("Komponent"); axes[0].set_ylabel("Dispersiya ulushi")
axes[0].set_title("Scree plot — 'tirsak' qayerda", fontweight="bold")
axes[0].grid(alpha=.3, axis="y")

axes[1].plot(range(1, len(son)+1), jamlangan, "o-", lw=2, color="#137333")
for ch in [0.90, 0.95]:
    axes[1].axhline(ch, ls="--", color="gray", lw=1)
    axes[1].text(len(son)*0.6, ch+0.008, f"{ch:.0%}", fontsize=9, color="gray")
axes[1].set_xlabel("Komponentlar soni"); axes[1].set_ylabel("Jamlangan dispersiya")
axes[1].set_title("Qancha saqlasak yetarli", fontweight="bold")
axes[1].grid(alpha=.3)
fig("scree.png", caption="Chapda: har komponentning ulushi, 'tirsak' nuqtasi qidiriladi. O'ngda: jamlangan ulush — 90% yoki 95% chegara tanlanadi.")

for ch in [0.90, 0.95]:
    pc = PCA(n_components=ch).fit(Xs)
    print(f"  PCA(n_components={ch}) -> {pc.n_components_} komponent saqladi")

from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier

y = df["ijaraga_berildi_30k"]
Xf = df[son]

print(f"{'variant':<40} {'CV F1':>9} {'±':>8}")
print("-" * 60)
for nom, qadamlar in [
    ("Logistic, PCA YO'Q", [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                            ("m", LogisticRegression(max_iter=3000))]),
    ("Logistic, PCA(0.95)", [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                             ("p", PCA(n_components=0.95)), ("m", LogisticRegression(max_iter=3000))]),
    ("Logistic, PCA(2 komponent)", [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                                    ("p", PCA(n_components=2)), ("m", LogisticRegression(max_iter=3000))]),
    ("KNN, PCA YO'Q", [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                       ("m", KNeighborsClassifier(n_neighbors=15))]),
    ("KNN, PCA(0.95)", [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                        ("p", PCA(n_components=0.95)), ("m", KNeighborsClassifier(n_neighbors=15))]),
]:
    b = cross_val_score(Pipeline(qadamlar), Xf, y, cv=5, scoring="f1")
    print(f"{nom:<40} {b.mean():>9.4f} {b.std():>8.4f}")

r2 = np.random.default_rng(7)
# 150 ustun, lekin ular 8 ta yashirin omilning kombinatsiyasi
yashirin = r2.normal(size=(len(Xf), 8))
aralashtirish = r2.normal(size=(8, 150))
X_kop = pd.DataFrame(yashirin @ aralashtirish + r2.normal(scale=.4, size=(len(Xf), 150)),
                     columns=[f"u{i}" for i in range(150)])
# target yashirin omillardan hosil qilinadi
y_kop = ((yashirin @ r2.normal(size=8) + r2.normal(scale=.5, size=len(Xf))) > 0).astype(int)

import time
print(f"{'variant':<34} {'CV F1':>9} {'±':>8} {'vaqt':>8}")
print("-" * 62)
for nom, qadamlar in [
    ("150 ustun, PCA YO'Q", [("sc", StandardScaler()), ("m", LogisticRegression(max_iter=3000))]),
    ("PCA(0.95)", [("sc", StandardScaler()), ("p", PCA(n_components=0.95)),
                   ("m", LogisticRegression(max_iter=3000))]),
    ("PCA(8 komponent)", [("sc", StandardScaler()), ("p", PCA(n_components=8)),
                          ("m", LogisticRegression(max_iter=3000))]),
]:
    t0 = time.perf_counter()
    b = cross_val_score(Pipeline(qadamlar), X_kop, y_kop, cv=5, scoring="f1")
    dt = time.perf_counter() - t0
    print(f"{nom:<34} {b.mean():>9.4f} {b.std():>8.4f} {dt:>7.2f}s")
print()
pk = PCA(n_components=0.95).fit(StandardScaler().fit_transform(X_kop))
print(f"PCA(0.95) 150 ustundan {pk.n_components_} komponent qoldirdi")

from sklearn.preprocessing import LabelEncoder
pg = pd.read_csv(DATA / "penguins.csv")
pson = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
Xpg = SimpleImputer(strategy="median").fit_transform(pg[pson])
Xpg = StandardScaler().fit_transform(Xpg)
tur = pg.species.values

p_pg = PCA(n_components=2).fit(Xpg)
Z = p_pg.transform(Xpg)

rasm, ax = plt.subplots(figsize=(8.5, 5.5))
for t, rang in zip(["Adelie", "Gentoo", "Chinstrap"], ["#1a73e8", "#137333", "#c5221f"]):
    mask = tur == t
    ax.scatter(Z[mask, 0], Z[mask, 1], label=t, alpha=.7, s=30, color=rang)
ax.set_xlabel(f"PC1 ({p_pg.explained_variance_ratio_[0]:.1%})")
ax.set_ylabel(f"PC2 ({p_pg.explained_variance_ratio_[1]:.1%})")
ax.set_title("4 o'lchovli ma'lumot 2 o'lchovda", fontweight="bold")
ax.legend(); ax.grid(alpha=.3)
fig("pca_penguins.png", caption="To'rtta o'lchov ikkiga tushirildi va sinflar hali ham ajralib turadi. PCA target ni KO'RMAGAN — u faqat dispersiyaga qaradi.")

print(f"PC1 va PC2 birgalikda dispersiyaning {p_pg.explained_variance_ratio_.sum():.1%} ini tushuntiradi")

yuk = pd.DataFrame(p_pg.components_.T, columns=["PC1", "PC2"], index=pson).round(3)
show(yuk.reset_index().rename(columns={"index": "xususiyat"}))
print()
print("PC1 ga eng ko'p hissa qo'shgan xususiyat:",
      pson[int(np.argmax(np.abs(p_pg.components_[0])))])

show(pd.DataFrame([
    {"Usul": "PCA", "Chiziqlimi": "HA", "Qachon": "Umumiy holat, tez",
     "Kamchiligi": "Chiziqsiz tuzilmani ko'rmaydi"},
    {"Usul": "TruncatedSVD", "Chiziqlimi": "HA", "Qachon": "Siyrak matritsa (matn, TF-IDF)",
     "Kamchiligi": "Markazlashtirmaydi"},
    {"Usul": "t-SNE", "Chiziqlimi": "YO'Q", "Qachon": "FAQAT vizualizatsiya",
     "Kamchiligi": "transform() yo'q — yangi nuqta qo'shilmaydi"},
    {"Usul": "UMAP", "Chiziqlimi": "YO'Q", "Qachon": "Vizualizatsiya, tezroq",
     "Kamchiligi": "Alohida kutubxona"},
]))

show(pd.DataFrame([
    {"Tushuncha": "Vazifa", "Bitta jumla": "Target yo'q — ma'lumotning o'zidan tuzilma topish"},
    {"Tushuncha": "PCA g'oyasi", "Bitta jumla": "Eng ko'p dispersiyali yo'nalishlarni o'q qilib olish"},
    {"Tushuncha": "Ichi", "Bitta jumla": "Kovariatsiya matritsasining xos vektorlari (11-bob)"},
    {"Tushuncha": "Scaling", "Bitta jumla": "MAJBURIY — aks holda katta birlikli ustun g'olib"},
    {"Tushuncha": "Nechta komponent", "Bitta jumla": "Jamlangan dispersiya 90-95% bo'lgan joy"},
    {"Tushuncha": "Aniqlikka ta'siri", "Bitta jumla": "Ko'pincha YO'Q yoki manfiy — PCA ma'lumot yo'qotadi"},
    {"Tushuncha": "Qachon foydali", "Bitta jumla": "Ustunlar juda ko'p, vizualizatsiya, tezlik"},
    {"Tushuncha": "Narxi", "Bitta jumla": "Komponentlar tushuntirilmaydi — SHAP ma'nosini yo'qotadi"},
]))