IlmHamroh
Data Science va sun'iy intellekt/Chiziqli algebra1/10-dars16 daqiqa
Mundarija (22)

10.1-dars: Vektorlar

10-QISM — CHIZIQLI ALGEBRA · 1-dars

1. Kirish va motivatsiya

2.11-darsda NumPy bilan chiziqli algebraning ilk amallarini ko'rdik: dot, @, transpose. Bu qismda uni tushunish darajasiga olib chiqamiz, chunki Machine Learning'ning deyarli hamma narsasi chiziqli algebra tilida yozilgan: ma'lumot jadvali — matritsa, har bir qator (mijoz, uy, rasm) — vektor, chiziqli regressiya — matritsa tenglamasi, PCA — xos vektorlar, neyron tarmoq — matritsa ko'paytmalari zanjiri, tavsiya tizimlari — vektorlar o'xshashligi.

Birinchi qadam — vektor. Data Science'da vektorni ikki xil ko'rish mumkin: (1) sonlar ro'yxati — mijoz [yosh, daromad, xaridlar soni]; (2) fazodagi nuqta yoki yo'nalish — o'q (strelka). Ikkinchi ko'rinish kuchli: "ikki mijoz qanchalik o'xshash?" savoli "ikki nuqta orasidagi masofa qancha?" ga aylanadi. KNN, klasterlash, tavsiya tizimlari, qidiruv (embedding) — hammasi shu g'oyada.

Real vaziyat. Onlayn do'kon "sizga o'xshash mijozlar sotib olgan" bo'limini yaratmoqchi. Har mijoz — vektor: [yosh, oylik sarf (ming so'm), xaridlar soni]. Birinchi urinish: Evklid masofasi bilan eng yaqin mijozlar. Natija g'alati — hamma "o'xshash" mijozlar faqat sarfi yaqin bo'lganlar, yosh deyarli ta'sir qilmaydi. Sabab: sarf minglab birlikda, yosh — o'nlab; masofani sarf "yutib yuboradi". Yechim — masshtablash 6.6-bob va keyin masofa. Vektorlarni tushunish — bunday xatoni darhol ko'rishga yordam beradi.

Bu darsda vektorlarni o'rganamiz.

Bu darsda:

  • Vektor: sonlar ro'yxati va geometrik o'q
  • Vektor amallari (qo'shish, songa ko'paytirish)
  • Vektor uzunligi (norma): L2, L1, L-cheksiz
  • Masofa: Evklid va Manxetten
  • Birlik vektor va normallashtirish
  • Masshtab muammosi (masofa va birliklar)
  • Vektor tuzoqlari
  • Amaliy: o'xshash mijozlarni topish

ℹ Misollar real numpy bilan (Python 3.14).

2. Nazariya — chuqur tushuntirish

2.1. Vektor: sonlar ro'yxati va geometrik o'q

text
Vektor — tartiblangan sonlar ro'yxati:
  v = [3, 4]                 — 2 o'lchamli (tekislikdagi nuqta/o'q)
  mijoz = [25, 1200, 7]      — 3 o'lchamli: yosh, sarf, xaridlar
  so'z embedding = [0.12, -0.8, ..., 0.33]   — 768 o'lchamli

Geometrik ma'no (2D):
  y
  4 |      * (3, 4)
    |    /
    |  /     v — boshlanishdan (0, 0) nuqtaga o'q
    |/
    +--------- x
          3

Vektor — n ta sondan iborat tartiblangan ro'yxat; n — o'lcham (dimension). NumPy'da — 1 o'lchamli massiv (np.array([3, 4]), shape = (2,)). Data Science'da har bir kuzatuv (jadval qatori) — belgilar vektori; har bir belgi (ustun) ham vektor (barcha kuzatuvlar bo'yicha). Geometrik ko'rinish 2-3 o'lchamda chiziladi, lekin qoidalar 1000 o'lchamda ham xuddi shunday ishlaydi — bu chiziqli algebraning kuchi.

2.2. Vektor amallari

text
u = [1, 2],  v = [3, 1]

QO'SHISH:       u + v = [1+3, 2+1] = [4, 3]     — o'qlarni ketma-ket qo'yish
AYIRISH:        v - u = [2, -1]                 — u dan v ga o'q (farq)
SONGA KO'PAYT.: 2 × u = [2, 4]                  — cho'zish (manfiy — teskari yo'nalish)
CHIZIQLI KOMB.: a × u + b × v                   — ML modelining asosi

Chiziqli model: bashorat = w1 × x1 + w2 × x2 + ... + b

Vektor amallari element bo'yicha (NumPy'da +, -, * son bilan). Ayirish — ikki nuqta orasidagi farq vektori (masofaning asosi). Chiziqli kombinatsiya (vektorlarni sonlarga ko'paytirib qo'shish) — butun qismning markaziy g'oyasi: chiziqli regressiya — belgilarning chiziqli kombinatsiyasi; PCA komponentasi — belgilarning chiziqli kombinatsiyasi; neyron qatlami — chiziqli kombinatsiya + nochiziqli funksiya.

2.3. Vektor uzunligi (norma)

text
L2 (Evklid):  ||v||_2 = sqrt(v1^2 + v2^2 + ... + vn^2)     [3, 4] → 5
L1 (Manxetten): ||v||_1 = |v1| + |v2| + ... + |vn|          [3, 4] → 7
L-cheksiz:    ||v||_inf = max(|v1|, ..., |vn|)             [3, 4] → 4

np.linalg.norm(v)            # L2
np.linalg.norm(v, ord=1)     # L1
np.linalg.norm(v, ord=np.inf)

Norma — vektor "kattaligi". L2 — to'g'ri chiziq bo'yicha uzunlik (Pifagor); eng keng tarqalgan. L1 — koordinatalar bo'yicha yurish (shahar kvartallari); outlierlarga chidamliroq. L-cheksiz — eng katta komponent. ML'da normalar regularizatsiyada uchraydi: Ridge — L2 (og'irliklarni kichraytiradi), Lasso — L1 (ba'zi og'irliklarni aniq 0 ga tushiradi — belgi tanlash). Normani tanlash — "katta" deganda nimani tushunishni tanlash.

2.4. Masofa: Evklid va Manxetten

Masofa — farq vektorining normasi: d(u, v) = ||u - v||. Evklid (L2) — to'g'ri chiziq; Manxetten (L1) — o'qlar bo'yicha. Qo'llanilishi: KNN (eng yaqin qo'shnilar — klassifikatsiya), K-means (klaster markaziga masofa), anomaliya (boshqalardan uzoq nuqta), tavsiya (eng yaqin mijozlar). Ko'p nuqta juftliklari uchun — scipy.spatial.distance.cdist yoki broadcasting 2.6-bob. O'lchamlar la'nati: yuzlab o'lchamda barcha masofalar bir-biriga yaqinlashadi — "eng yaqin" tushunchasi xiralashadi; shuning uchun o'lchamni kamaytirish (PCA, 10.9) muhim.

2.5. Birlik vektor va normallashtirish

Birlik vektor — uzunligi 1: u = v / ||v||. U faqat yo'nalishni saqlaydi, kattalikni tashlab yuboradi. Qachon kerak: yo'nalish muhim, kattalik muhim emas — matn (uzun va qisqa hujjat bir mavzuda bo'lishi mumkin), embedding'lar, xaridlar tarkibi. Kosinus o'xshashlik 10.2-bob — birlik vektorlarning skalyar ko'paytmasi. sklearn: normalize(X) — har qatorni birlik uzunlikka (6.5-darsdagi Min-Max normalizatsiyadan farq qiladi — u ustunlarni [0, 1] ga keltiradi; nomlar chalkash!).

2.6. Masshtab muammosi

Masofa birliklarga sezgir: [yosh, sarf] da sarf ming so'mda (1200) bo'lsa, yosh farqi (10 yil) sarf farqi (100 ming) oldida yo'qoladi. Sarfni so'mda yozsangiz — yosh umuman ta'sir qilmaydi; million so'mda yozsangiz — faqat yosh qoladi. Masofa ma'lumotga emas, o'lchov birligiga bog'liq bo'lib qoladi. Yechim — standartlashtirish (6.6: har ustun o'rtacha 0, SD 1) masofa hisoblashdan oldin. Masofaga asoslangan barcha usullar (KNN, K-means, SVM, PCA) — masshtablashni talab qiladi; daraxt modellari — talab qilmaydi.

2.7. Vektor tuzoqlari

Asosiy tuzoqlar: masshtabsiz masofa (katta birlikli ustun hukmron); list va massivni adashtirish ([1, 2] + [3, 4] → [1, 2, 3, 4] — birlashtirish, qo'shish emas; np.array kerak); normallashtirishda nolga bo'lish (nol vektor — norma 0); sklearn normalize va Min-Max'ni adashtirish (qator vs ustun); o'lchamlar la'nati (ko'p o'lchamda masofa ma'nosini yo'qotadi); kategoriyani songa aylantirib masofa hisoblash (shahar kodi 1, 2, 3 — "Toshkent va Buxoro orasidagi masofa 2" — ma'nosiz; one-hot kerak, 6.9); shakl ((n,) va (n, 1) farqi).

2.8. Vektorlar — ma'lumotning geometriyasi

Vektor — tartiblangan sonlar ro'yxati va fazodagi o'q; har kuzatuv — belgilar vektori. Amallar: qo'shish, ayirish (farq), songa ko'paytirish, chiziqli kombinatsiya (modellar asosi). Norma — uzunlik (L2, L1, L-cheksiz; regularizatsiya). Masofa — farqning normasi (KNN, K-means, anomaliya). Birlik vektor — faqat yo'nalish. Masshtab — masofadan oldin standartlashtirish. Keyingi dars — skalyar ko'paytma: burchak, kosinus o'xshashlik, proyeksiya.

3. Tez ma'lumotnoma

python
import numpy as np
from scipy.spatial.distance import cdist
from sklearn.preprocessing import StandardScaler, normalize

u = np.array([1, 2]); v = np.array([3, 1])
u + v, v - u, 2 * u                      # amallar
0.5 * u + 2 * v                          # chiziqli kombinatsiya

np.linalg.norm(v)                        # L2
np.linalg.norm(v, ord=1)                 # L1
np.linalg.norm(v, ord=np.inf)            # max

np.linalg.norm(u - v)                    # Evklid masofa
cdist(A, B)                              # barcha juftliklar (metric="cityblock" — L1)

v / np.linalg.norm(v)                    # birlik vektor
normalize(X)                             # har QATOR birlik uzunlikka

Xs = StandardScaler().fit_transform(X)   # masofadan OLDIN
QOIDA: np.array (list emas) · masofadan oldin masshtab · kategoriya — one-hot

Vektorlar xulosasi

Vektor — sonlar ro'yxati / fazodagi o'q; kuzatuv = belgilar vektori
Amallar — element bo'yicha; chiziqli kombinatsiya — modellar asosi
Norma — L2 (Evklid), L1 (Manxetten), L-inf (max)
Masofa — ||u - v||; KNN, K-means, anomaliya
Birlik vektor — v / ||v||, faqat yo'nalish
Masshtab — masofadan oldin standartlashtirish

4. Batafsil misollar

Misollar real numpy/scipy/sklearn bilan (Python 3.14).

Misol 1 — Vektor amallari va chiziqli kombinatsiya

python
"""Vektor amallari va chiziqli kombinatsiya (real numpy)."""

import numpy as np


def main() -> None:
    u = np.array([1, 2])
    v = np.array([3, 1])

    print("=== 1. Amallar ===")
    print(f"  u + v = {u + v}")
    print(f"  v - u = {v - u}")
    print(f"  2 × u = {2 * u}, -1 × u = {-1 * u}")

    print("\n=== 2. list va np.array ===")
    print(f"  [1, 2] + [3, 1] = {[1, 2] + [3, 1]}  ← birlashtirish!")
    print(f"  np.array: {np.array([1, 2]) + np.array([3, 1])}")

    print("\n=== 3. Chiziqli kombinatsiya = chiziqli model ===")
    belgilar = np.array([65, 3, 12])          # maydon, xona, yosh
    ogirlik = np.array([1.5, 8.0, -0.9])      # model og'irliklari
    b = 20
    bashorat = ogirlik @ belgilar + b
    print(f"  1.5×65 + 8×3 - 0.9×12 + 20 = {bashorat:.1f} ming $")
    print(f"  qo'lda: {1.5 * 65 + 8.0 * 3 - 0.9 * 12 + 20:.1f}")
    print("  ⭐ Chiziqli model — belgilarning chiziqli kombinatsiyasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Amallar ===
  u + v = [4 3]
  v - u = [ 2 -1]
  2 × u = [2 4], -1 × u = [-1 -2]

=== 2. list va np.array ===
  [1, 2] + [3, 1] = [1, 2, 3, 1]  ← birlashtirish!
  np.array: [4 3]

=== 3. Chiziqli kombinatsiya = chiziqli model ===
  1.5×65 + 8×3 - 0.9×12 + 20 = 130.7 ming $
  qo'lda: 130.7
  ⭐ Chiziqli model — belgilarning chiziqli kombinatsiyasi

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Normalar va masofalar

python
"""L2, L1, L-inf normalar va masofalar (real numpy/scipy)."""

import numpy as np
from scipy.spatial.distance import cdist


def main() -> None:
    v = np.array([3, 4])

    print("=== 1. Normalar ===")
    print(f"  L2 = {np.linalg.norm(v)}")
    print(f"  L1 = {np.linalg.norm(v, ord=1)}")
    print(f"  L-inf = {np.linalg.norm(v, ord=np.inf)}")

    print("\n=== 2. Ikki nuqta orasidagi masofa ===")
    a, b = np.array([1, 1]), np.array([4, 5])
    print(f"  Evklid:    {np.linalg.norm(a - b):.2f}")
    print(f"  Manxetten: {np.linalg.norm(a - b, ord=1):.2f}")

    print("\n=== 3. Barcha juftliklar (cdist) ===")
    nuqtalar = np.array([[0, 0], [3, 4], [6, 8], [1, 0]])
    D = cdist(nuqtalar, nuqtalar)
    print(np.round(D, 2))
    print(f"  (0,0) ga eng yaqin: {nuqtalar[np.argsort(D[0])[1]]}")

    print("\n=== 4. Birlik vektor ===")
    birlik = v / np.linalg.norm(v)
    print(f"  {birlik}, uzunligi {np.linalg.norm(birlik)}")
    print("  ⭐ Masofa — farq vektorining normasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Normalar ===
  L2 = 5.0
  L1 = 7.0
  L-inf = 4.0

=== 2. Ikki nuqta orasidagi masofa ===
  Evklid:    5.00
  Manxetten: 7.00

=== 3. Barcha juftliklar (cdist) ===
[[ 0.    5.   10.    1.  ]
 [ 5.    0.    5.    4.47]
 [10.    5.    0.    9.43]
 [ 1.    4.47  9.43  0.  ]]
  (0,0) ga eng yaqin: [1 0]

=== 4. Birlik vektor ===
  [0.6 0.8], uzunligi 1.0
  ⭐ Masofa — farq vektorining normasi

Nima ko'rsatdi: 2.3, 2.4, 2.5-bo'limlar.

Misol 3 — Masshtab muammosi

python
"""Masofa birliklarga bog'liq: standartlashtirish kerak (real numpy/sklearn)."""

import numpy as np
from scipy.spatial.distance import cdist
from sklearn.preprocessing import StandardScaler


def main() -> None:
    # [yosh, oylik sarf ming so'm]
    mijozlar = np.array([
        [25, 1200],   # A
        [55, 1250],   # B — yoshi juda farq, sarf yaqin
        [27, 1600],   # C — yoshi yaqin, sarf farq
    ], dtype=float)
    ism = ["A", "B", "C"]

    print("=== 1. Xom masofa (A dan) ===")
    D = cdist(mijozlar[:1], mijozlar)[0]
    for i in [1, 2]:
        print(f"  A–{ism[i]}: {D[i]:.1f}")
    print(f"  eng yaqin: {ism[1 + np.argmin(D[1:])]}  ← sarf hukmron")

    print("\n=== 2. Birlikni o'zgartirsak (sarf so'mda) ===")
    som = mijozlar * np.array([1, 1000])
    D2 = cdist(som[:1], som)[0]
    print(f"  A–B: {D2[1]:.0f}, A–C: {D2[2]:.0f} — yosh umuman ta'sir qilmaydi")

    print("\n=== 3. Standartlashtirilgan ===")
    Xs = StandardScaler().fit_transform(mijozlar)
    D3 = cdist(Xs[:1], Xs)[0]
    for i in [1, 2]:
        print(f"  A–{ism[i]}: {D3[i]:.2f}")
    print("  ⭐ Masofadan oldin — standartlashtirish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Xom masofa (A dan) ===
  A–B: 58.3
  A–C: 400.0
  eng yaqin: B  ← sarf hukmron

=== 2. Birlikni o'zgartirsak (sarf so'mda) ===
  A–B: 50000, A–C: 400000 — yosh umuman ta'sir qilmaydi

=== 3. Standartlashtirilgan ===
  A–B: 2.21
  A–C: 2.25
  ⭐ Masofadan oldin — standartlashtirish

Nima ko'rsatdi: 2.6-bo'lim.

Misol 4 — O'xshash mijozlar va o'lchamlar la'nati

python
"""Eng yaqin mijozlar va ko'p o'lchamda masofalar yaqinlashuvi (real numpy/sklearn)."""

import numpy as np
from scipy.spatial.distance import cdist
from sklearn.preprocessing import StandardScaler


def main() -> None:
    rng = np.random.default_rng(0)
    X = np.column_stack([
        rng.integers(18, 70, 500),            # yosh
        rng.lognormal(7, 0.5, 500),           # sarf
        rng.poisson(6, 500),                  # xaridlar
    ]).astype(float)
    Xs = StandardScaler().fit_transform(X)

    print("=== 1. 0-mijozga eng yaqin 3 ta ===")
    d = cdist(Xs[:1], Xs)[0]
    yaqin = np.argsort(d)[1:4]
    print(f"  0-mijoz: {np.round(X[0], 0)}")
    for i in yaqin:
        print(f"  {i:>3}: {np.round(X[i], 0)}, masofa {d[i]:.2f}")

    print("\n=== 2. O'lchamlar la'nati ===")
    for dim in [2, 10, 100, 1000]:
        P = rng.random((300, dim))
        D = cdist(P[:1], P[1:])[0]
        print(f"  {dim:>4} o'lcham: eng yaqin/eng uzoq = {D.min() / D.max():.3f}")
    print("  ⭐ Ko'p o'lchamda hamma nuqta deyarli bir xil uzoqlikda")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 0-mijozga eng yaqin 3 ta ===
  0-mijoz: [  62. 1211.    6.]
  112: [  62. 1223.    6.], masofa 0.02
   60: [  61. 1083.    6.], masofa 0.22
  204: [  64. 1087.    6.], masofa 0.24

=== 2. O'lchamlar la'nati ===
     2 o'lcham: eng yaqin/eng uzoq = 0.021
    10 o'lcham: eng yaqin/eng uzoq = 0.388
   100 o'lcham: eng yaqin/eng uzoq = 0.722
  1000 o'lcham: eng yaqin/eng uzoq = 0.895
  ⭐ Ko'p o'lchamda hamma nuqta deyarli bir xil uzoqlikda

Nima ko'rsatdi: 2.4, 2.7-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Vektor — faqat fizika" Har jadval qatori — vektor
"Masofa — ma'lumot xossasi" Birliklarga bog'liq
"[1, 2] + [3, 4] = [4, 6]" list — birlashtirish; np.array kerak
"normalize = Min-Max" normalize — qator, Min-Max — ustun
"Ko'p belgi — yaxshi masofa" O'lchamlar la'nati
"Shahar kodi bilan masofa" Kategoriya — one-hot
"L2 har doim eng yaxshi" L1 outlierga chidamliroq
"Birlik vektor kattalikni saqlaydi" Faqat yo'nalish

6. Keng tarqalgan xatolar va yechimlari

1. Masshtabsiz masofa

python
d = cdist(X, X)                                                   # ⚠️
d = cdist(StandardScaler().fit_transform(X), ...)                 # ✅

2. list bilan amal

python
v = [1, 2] + [3, 4]                                               # ⚠️
v = np.array([1, 2]) + np.array([3, 4])                           # ✅

3. Nol vektorni normallashtirish

python
u = v / np.linalg.norm(v)          # v = 0 → nan                  # ⚠️
n = np.linalg.norm(v); u = v / n if n > 0 else v                  # ✅

4. Qo'lda sikl bilan masofa

python
D = [[np.linalg.norm(a - b) for b in X] for a in X]               # ⚠️
D = cdist(X, X)                                                   # ✅

5. Kategoriya kodi

python
X = df[["shahar_kodi", "yosh"]].to_numpy()                        # ⚠️
X = pd.get_dummies(df[["shahar", "yosh"]]).to_numpy(dtype=float)  # ✅

6. normalize va MinMaxScaler

python
X = normalize(X)            # ustunlarni [0,1] deb                # ⚠️
X = MinMaxScaler().fit_transform(X)                               # ✅

7. Norma turi

python
np.linalg.norm(v, 1)        # 2-argument — ord (L1)               # ⚠️ (tushunib)
np.linalg.norm(v, ord=1)    # aniq yozing                         # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.5-2.6, 2.11-darslar (o'tilgan): Vektorlashtirish, broadcasting, dot
  • 6.6-dars (o'tilgan): Standartlashtirish
  • 10.2-dars: Skalyar ko'paytma, kosinus o'xshashlik
  • 10.9-dars: PCA (o'lcham kamaytirish)
  • ML qismlari: KNN, K-means, regularizatsiya (L1/L2)

8. Eng yaxshi amaliyotlar

  1. Har kuzatuvni vektor sifatida ko'ring.

  2. Masofadan oldin standartlashtiring.

  3. Kategoriyalarni one-hot qiling.

  4. Juftlik masofalari — cdist.

  5. Yo'nalish muhim bo'lsa — birlik vektor.

  6. Normani maqsadga qarab tanlang (L1/L2).

  7. Ko'p o'lchamda masofaga ehtiyot bo'ling.

  8. Nol vektorni tekshiring.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # [2, 3] + [1, -1]?
2.  # 3 × [1, 2]?
3.  # ||[6, 8]|| (L2)?
4.  # ||[6, 8]|| (L1)?
5.  # ||[6, -8]|| (L-inf)?
6.  # [0,0] va [3,4] masofasi?
7.  # [3, 4] birlik vektori?
8.  # [1, 2] + [3, 4] (list)?
9.  # Ridge qaysi norma?
10. # Lasso qaysi norma?
11. # KNN masshtab talab qiladimi?
12. # daraxt modeli masshtab talab qiladimi?
Javoblar
  1. [3, 2]
  2. [3, 6]
  3. 10
  4. 14
  5. 8
  6. 5
  7. [0.6, 0.8]
  8. [1, 2, 3, 4]
  9. L2
  10. L1
  11. Ha
  12. Yo'q

Vazifa 2: Xatolarni tuzating

python
1.  d = cdist(df[["yosh", "daromad"]], df[["yosh", "daromad"]])

2.  v = [1, 2] * 3   # [3, 6] kutilgan

3.  u = v / np.linalg.norm(v)   # v nol bo'lishi mumkin

4.  X = df[["viloyat_kodi", "yosh"]].to_numpy()

5.  X = normalize(X)   # ustunlar [0, 1] ga
Javoblar
python
1.  Xs = StandardScaler().fit_transform(df[["yosh", "daromad"]]); d = cdist(Xs, Xs)

2.  v = np.array([1, 2]) * 3

3.  n = np.linalg.norm(v); u = v / n if n > 0 else v

4.  X = pd.get_dummies(df[["viloyat", "yosh"]]).to_numpy(dtype=float)

5.  X = MinMaxScaler().fit_transform(X)

Vazifa 3: Uylar

Modellang:

  1. 200 uy: maydon, xona, yosh, narx
  2. Standartlashtirish
  3. Berilgan uyga eng o'xshash 5 ta
  4. Masshtabsiz natija bilan solishtirish

Vazifa 4: Normalar

Modellang:

  1. 5 ta vektor
  2. L1, L2, L-inf
  3. Qaysi norma bo'yicha tartib o'zgaradi
  4. Outlier qo'shilganda

Vazifa 5: O'lchamlar la'nati

Modellang:

  1. 2..2000 o'lcham
  2. Eng yaqin/eng uzoq nisbati
  3. Grafik
  4. PCA kerakligi haqida xulosa

Vazifa 6: Integratsiya

Modellang:

  1. Broadcasting (2.6)
  2. Standartlashtirish (6.6)
  3. One-hot (6.9)
  4. cdist

Vazifa 7: O'ylash

"O'xshashlik" — Data Science'dagi eng ko'p ishlatiladigan tushunchalardan biri (tavsiya, qidiruv, klasterlash). Lekin ikki mijozning "o'xshashligi" qanday belgilar tanlanganiga, qanday masshtablanganiga va qaysi masofa ishlatilganiga bog'liq. Nima uchun "o'xshashlik" obyektiv emas, balki dizayn qarori? Bu qarorni qanday asoslash kerak?

Javob

Qisqa javob: masofa formulasi matematik jihatdan aniq, lekin unga nima kirishi — qaysi belgilar, qanday birlikda, qanday vazn bilan — biznes maqsadidan kelib chiqadigan tanlov. Bir xil ma'lumotda turli tanlovlar butunlay boshqa "o'xshash" mijozlarni beradi.

1. O'xshashlikni belgilaydigan tanlovlar

Tanlov Ta'siri
Qaysi belgilar Yosh kiritilsa — yoshdoshlar o'xshash
Masshtab Katta birlikli belgi hukmron
Vaznlar Muhim belgiga katta vazn
Masofa turi L1 / L2 / kosinus — boshqa tartib

2. Nega obyektiv emas

  • "O'xshash" — "nima maqsadda o'xshash?" savoliga bog'liq
  • Tavsiya uchun: xarid tarkibi muhim; kredit xavfi uchun: daromad va qarz
  • Bir xil formula — turli maqsadda turli belgilar

3. Qanday asoslash

  1. Biznes maqsadini aniqlash (nima uchun o'xshashlik kerak)
  2. Belgilarni maqsadga qarab tanlash va masshtablash
  3. Natijani qo'lda tekshirish ("bu ikki mijoz haqiqatan o'xshashmi?")
  4. Oflayn/onlayn metrika bilan baholash (tavsiya bosilishi, A/B test)

4. Data Scientist qanday

  1. O'xshashlik ta'rifini hujjatlaydi (belgilar, masshtab, metrika)
  2. Bir necha variantni solishtiradi
  3. Soha mutaxassisi bilan tekshiradi
  4. Adolatlilikni ko'radi (yashirin belgilar — jins, millat — orqali o'xshashlik)

5. Xulosa

  1. Masofa formulasi aniq, uning kirishi — tanlov
  2. O'xshashlik maqsadga bog'liq
  3. Tanlov hujjatlanadi va sinaladi
  4. Yaxshi o'xshashlik — biznes natijasi bilan tasdiqlanadi

Nimani mustahkamlaydi: 2.4, 2.6-bo'limlar.

Xulosa

Bu darsda vektorlarni o'rgandik.

Eng muhim uch fikr:

  1. Vektor — ma'lumotning geometriyasi. Vektor — tartiblangan sonlar ro'yxati va fazodagi o'q; har kuzatuv (jadval qatori) — belgilar vektori. Amallar element bo'yicha (np.array, list emas); chiziqli kombinatsiya — chiziqli modellar, PCA, neyron qatlamlar asosi.

  2. Norma va masofa. Norma — uzunlik: L2 (Evklid), L1 (Manxetten), L-inf (max); regularizatsiyada (Ridge — L2, Lasso — L1). Masofa = ||u - v|| — KNN, K-means, anomaliya, tavsiya. Birlik vektor v / ||v|| — faqat yo'nalish.

  3. Masshtab va o'lchamlar. Masofa birliklarga bog'liq — oldin standartlashtiring, kategoriyalarni one-hot qiling. Ko'p o'lchamda masofalar bir-biriga yaqinlashadi (o'lchamlar la'nati) — o'lchamni kamaytirish kerak bo'ladi.

Keyingi darsda skalyar ko'paytmani o'rganamiz: uning geometrik ma'nosi (burchak), kosinus o'xshashlik (matn va embedding qidiruvi), proyeksiya va ortogonallik.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
10.1-dars: Vektorlar — IlmHamroh