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

10.2-dars: Skalyar ko'paytma va o'xshashlik

10-QISM — CHIZIQLI ALGEBRA · 2-dars

1. Kirish va motivatsiya

Skalyar ko'paytma (dot product) — ikki vektordan bitta son yasaydigan amal: mos elementlarni ko'paytirib, qo'shish. 2.11-darsda uni hisobladik; bu darsda uning ma'nosini ochamiz. Skalyar ko'paytma bir vaqtda uch narsani o'lchaydi: vektorlar qanchalik bir yo'nalishda (burchak), bir vektorning ikkinchisiga proyeksiyasi (soyasi), va — to'g'ri normallashtirilsa — o'xshashlik.

Data Science'da skalyar ko'paytma hamma joyda: chiziqli model (bashorat = og'irliklar · belgilar), kosinus o'xshashlik (matn qidiruvi, tavsiya tizimlari, embedding'lar, ChatGPT kabi tizimlardagi "semantik qidiruv"), korrelyatsiya (markazlashtirilgan vektorlarning kosinusi!), proyeksiya (PCA, regressiya), neyron tarmoq (har neyron — skalyar ko'paytma), attention (transformerlarda so'rov va kalit vektorlarining skalyar ko'paytmasi).

Real vaziyat. Kutubxona ilovasi "shunga o'xshash kitoblar" funksiyasini qurmoqda. Har kitob — so'zlar chastotasi vektori. Birinchi urinish — Evklid masofasi 10.1-bob: natijada qisqa kitoblar bir-biriga "o'xshash" chiqadi (hammasining vektori kichik), mavzu esa ahamiyatsiz. Yechim — kosinus o'xshashlik: vektorlar yo'nalishini solishtiradi, uzunligini emas. 300 betlik va 30 betlik ikki tarix kitobi — bir yo'nalishda, shuning uchun o'xshash. Skalyar ko'paytmani tushunish — to'g'ri o'xshashlik o'lchovini tanlashga olib keldi.

Bu darsda skalyar ko'paytma va o'xshashlikni o'rganamiz.

Bu darsda:

  • Skalyar ko'paytma: algebraik ta'rif
  • Geometrik ma'no: burchak
  • Kosinus o'xshashlik
  • Ortogonallik (perpendikulyarlik)
  • Proyeksiya
  • Korrelyatsiya — kosinusning maxsus holati
  • Skalyar ko'paytma tuzoqlari
  • Amaliy: matn o'xshashligi

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

2. Nazariya — chuqur tushuntirish

2.1. Skalyar ko'paytma: algebraik ta'rif

text
u · v = u1 × v1 + u2 × v2 + ... + un × vn       (natija — bitta son)

[1, 2, 3] · [4, 5, 6] = 4 + 10 + 18 = 32

NumPy:  u @ v   yoki   np.dot(u, v)
Xossalar:
  u · v = v · u                    (simmetrik)
  u · (v + w) = u · v + u · w      (chiziqli)
  v · v = ||v||^2                  (o'z-o'ziga — uzunlik kvadrati)

Skalyar ko'paytma — mos elementlar ko'paytmalari yig'indisi. Eng muhim xossa: v · v = ||v||^2 — norma skalyar ko'paytmadan kelib chiqadi. Amalda: savat [3 non, 2 sut] va narxlar [5000, 12000] → jami 3 × 5000 + 2 × 12000 = 39 000 — bu skalyar ko'paytma. Chiziqli model bashorati — og'irliklar va belgilar skalyar ko'paytmasi 10.1-bob.

2.2. Geometrik ma'no: burchak

text
u · v = ||u|| × ||v|| × cos(theta)       theta — vektorlar orasidagi burchak

  theta = 0°    → cos = 1    → bir yo'nalish          (u · v maksimal musbat)
  theta = 90°   → cos = 0    → perpendikulyar         (u · v = 0)
  theta = 180°  → cos = -1   → qarama-qarshi          (u · v manfiy)

Ishora:  u · v > 0 — "bir tomonga"; < 0 — "qarama-qarshi"; = 0 — "bog'liqsiz"

Geometrik formula — skalyar ko'paytma = uzunliklar × burchak kosinusi. Bundan: burchakni hisoblash mumkin (cos theta = u · v / (||u|| × ||v||)), ishora yo'nalishni aytadi. Muhim: bu formula 1000 o'lchamda ham ishlaydi — "burchak" tushunchasi ko'p o'lchamli ma'lumot uchun ham ma'noli. Ammo skalyar ko'paytmaning qiymati uzunliklarga ham bog'liq — uzun vektorlar katta son beradi.

2.3. Kosinus o'xshashlik

text
cos_sim(u, v) = (u · v) / (||u|| × ||v||)         [-1, 1] oraliqda

Kosinus masofa = 1 - cos_sim

Matn: kitob A = [10, 0, 5],  kitob B = [100, 0, 50]  (B — A dan 10 marta uzun)
  Evklid masofa ≈ 100.6  (juda "farqli")
  cos_sim = 1.0          (bir xil mavzu!)

Kosinus o'xshashlik — faqat yo'nalish bo'yicha o'xshashlik; uzunlik (kattalik) e'tiborga olinmaydi. Qachon ishlatiladi: matn (TF-IDF vektorlari — hujjat uzunligi mavzuga ta'sir qilmasin), embedding'lar (so'z, gap, rasm vektorlari — semantik qidiruv), tavsiya (foydalanuvchi baholari — "qattiq" va "yumshoq" baholovchilar). Birlik vektorlar uchun kosinus = skalyar ko'paytma — shuning uchun qidiruv tizimlari vektorlarni oldindan normallashtiradi. sklearn: cosine_similarity(A, B).

2.4. Ortogonallik

Ortogonal (perpendikulyar) vektorlar — skalyar ko'paytmasi 0: bir-biri haqida "hech narsa aytmaydi". Muhim holatlar: koordinata o'qlari ([1, 0] va [0, 1]); PCA komponentalari — o'zaro ortogonal (10.9: har yangi komponenta oldingilarida yo'q ma'lumotni oladi); regressiya qoldiqlari — belgilarga ortogonal (10.6: model belgilardan olish mumkin bo'lgan hamma narsani oldi); markazlashtirilgan korrelyatsiyasiz o'zgaruvchilar — ortogonal. Ortogonallik — "takrorlanmaydigan ma'lumot" ning geometrik tili.

2.5. Proyeksiya

text
v ning u yo'nalishidagi proyeksiyasi:
  skalyar proyeksiya (uzunlik):  (v · u) / ||u||
  vektor proyeksiya:             ((v · u) / (u · u)) × u

  v = [3, 4],  u = [1, 0]  →  proyeksiya = [3, 0]   ("soyasi" x o'qida)
  qoldiq = v - proyeksiya = [0, 4]  ← u ga ortogonal

Proyeksiya — vektorning boshqa yo'nalishdagi "soyasi": v ni ikki qismga ajratadi — u bo'ylab qism va u ga perpendikulyar qoldiq. Bu g'oya ikki markaziy usulning asosi: regressiya — y ni belgilar fazosiga proyeksiyalash (bashorat — proyeksiya, qoldiq — xato, 10.6); PCA — ma'lumotni eng muhim yo'nalishlarga proyeksiyalash 10.9-bob. Skalyar proyeksiya — "u yo'nalishida qancha" degan savolga javob (masalan, mijozning "qimmat segment" o'qidagi qiymati).

2.6. Korrelyatsiya — kosinusning maxsus holati

Pearson korrelyatsiyasi 4.9-bob — ikki ustunni markazlashtirib (o'rtachasini ayirib), keyin kosinus o'xshashlik: r = cos(x - x_ort, y - y_ort). Shuning uchun r ham [-1, 1] da, r = 0 — "ortogonal" (chiziqli bog'liqlik yo'q). Kovariatsiya — markazlashtirilgan vektorlarning skalyar ko'paytmasi / (n - 1). Bu bog'lanish muhim: statistika tushunchalari (kovariatsiya, korrelyatsiya, regressiya) — aslida geometriya (skalyar ko'paytma, burchak, proyeksiya).

2.7. Skalyar ko'paytma tuzoqlari

Asosiy tuzoqlar: * va @ ni adashtirish (u * v — element bo'yicha massiv, u @ v — son; 2.11); xom skalyar ko'paytmani o'xshashlik deb (uzun vektorlar yutadi — kosinus kerak); kosinusni kattalik muhim bo'lganda (kosinus bo'yicha 1 000 va 10 000 so'mlik savatlar bir xil — agar summa muhim bo'lsa, noto'g'ri); nol vektor (kosinus aniqlanmagan — 0/0); markazlashtirmasdan korrelyatsiya (kosinus ≠ korrelyatsiya — hamma qiymat musbat bo'lsa, kosinus doim musbat); siyrak (sparse) matritsada zich amal (matn matritsalari — sparse saqlang); turli masshtabli belgilar (kosinus ham masshtabga sezgir — ustunlar bo'yicha).

2.8. Skalyar ko'paytma — o'xshashlik va proyeksiya

Skalyar ko'paytma: algebraik — mos ko'paytmalar yig'indisi (u @ v; v · v = ||v||^2); geometrik — ||u|| × ||v|| × cos(theta) (ishora — yo'nalish); kosinus o'xshashlik — faqat yo'nalish (matn, embedding, tavsiya); ortogonallik — ko'paytma 0 (PCA komponentalari, regressiya qoldiqlari); proyeksiya — soya + perpendikulyar qoldiq (regressiya, PCA); korrelyatsiya — markazlashtirilgan kosinus. Keyingi dars — matritsalar: vektorlar jadvali va uning ma'nolari.

3. Tez ma'lumotnoma

python
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

u @ v                                   # skalyar ko'paytma (np.dot(u, v))
v @ v                                   # ||v||^2

cos = u @ v / (np.linalg.norm(u) * np.linalg.norm(v))
np.degrees(np.arccos(np.clip(cos, -1, 1)))    # burchak (gradus)

cosine_similarity(A, B)                 # qatorlar juftliklari
1 - cosine_similarity(A, B)             # kosinus masofa

# proyeksiya
proj = (v @ u) / (u @ u) * u
qoldiq = v - proj                       # qoldiq @ u ≈ 0

# korrelyatsiya = markazlashtirilgan kosinus
xc, yc = x - x.mean(), y - y.mean()
xc @ yc / (np.linalg.norm(xc) * np.linalg.norm(yc))     # = np.corrcoef(x, y)[0, 1]
QOIDA: * — element, @ — son · o'xshashlik — kosinus (uzunlik muhim bo'lmasa)

Skalyar ko'paytma xulosasi

u · v = sum(ui × vi) = ||u|| ||v|| cos(theta)
cos_sim — faqat yo'nalish; [-1, 1]
Ortogonal — u · v = 0 (bog'liqsiz, takrorlanmaydigan)
Proyeksiya — (v·u / u·u) u; qoldiq ortogonal
Korrelyatsiya — markazlashtirilgan vektorlar kosinusi

4. Batafsil misollar

Misollar real numpy/sklearn bilan (Python 3.14).

Misol 1 — Skalyar ko'paytma va burchak

python
"""Skalyar ko'paytma: algebraik va geometrik ma'no (real numpy)."""

import numpy as np


def burchak(u: np.ndarray, v: np.ndarray) -> float:
    cos = u @ v / (np.linalg.norm(u) * np.linalg.norm(v))
    return float(np.degrees(np.arccos(np.clip(cos, -1, 1))))


def main() -> None:
    print("=== 1. Savat narxi — skalyar ko'paytma ===")
    miqdor = np.array([3, 2, 1])               # non, sut, yog'
    narx = np.array([5000, 12000, 30000])
    print(f"  jami: {miqdor @ narx:,} so'm")
    print(f"  u * v = {miqdor * narx}  (massiv, son emas)")

    print("\n=== 2. v · v = ||v||^2 ===")
    v = np.array([3, 4])
    print(f"  v @ v = {v @ v}, ||v||^2 = {np.linalg.norm(v) ** 2:.1f}")

    print("\n=== 3. Burchak va ishora ===")
    u = np.array([1, 0])
    for w in [np.array([2, 0]), np.array([1, 1]), np.array([0, 3]), np.array([-1, 0.2])]:
        print(f"  u · {w} = {u @ w:5.1f}, burchak {burchak(u, w):5.1f}°")
    print("  ⭐ Ishora — yo'nalish; 0 — perpendikulyar")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Savat narxi — skalyar ko'paytma ===
  jami: 69,000 so'm
  u * v = [15000 24000 30000]  (massiv, son emas)

=== 2. v · v = ||v||^2 ===
  v @ v = 25, ||v||^2 = 25.0

=== 3. Burchak va ishora ===
  u · [2 0] =   2.0, burchak   0.0°
  u · [1 1] =   1.0, burchak  45.0°
  u · [0 3] =   0.0, burchak  90.0°
  u · [-1.   0.2] =  -1.0, burchak 168.7°
  ⭐ Ishora — yo'nalish; 0 — perpendikulyar

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

Misol 2 — Kosinus vs Evklid: kitoblar

python
"""Matn vektorlari: Evklid masofa vs kosinus o'xshashlik (real numpy/sklearn)."""

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances


def main() -> None:
    # so'zlar: [urush, podsho, sevgi, yulduz]
    kitoblar = np.array([
        [40, 30, 5, 0],     # A — katta tarix kitobi
        [4, 3, 1, 0],       # B — kichik tarix kitobi
        [2, 0, 6, 1],       # C — kichik roman
        [1, 0, 0, 9],       # D — kichik astronomiya
    ], dtype=float)
    nom = ["A (tarix, katta)", "B (tarix, kichik)", "C (roman)", "D (astronomiya)"]

    print("=== 1. B ga Evklid masofa ===")
    E = euclidean_distances(kitoblar[1:2], kitoblar)[0]
    for i in [0, 2, 3]:
        print(f"  {nom[i]:<18}: {E[i]:6.2f}")

    print("\n=== 2. B ga kosinus o'xshashlik ===")
    C = cosine_similarity(kitoblar[1:2], kitoblar)[0]
    for i in [0, 2, 3]:
        print(f"  {nom[i]:<18}: {C[i]:.3f}")

    print("\n=== 3. Xulosa ===")
    print(f"  Evklid bo'yicha eng yaqin: {nom[[0, 2, 3][int(np.argmin(E[[0, 2, 3]]))]]}")
    print(f"  kosinus bo'yicha eng yaqin: {nom[[0, 2, 3][int(np.argmax(C[[0, 2, 3]]))]]}")
    print("  ⭐ Matnda — yo'nalish (mavzu) muhim, uzunlik emas")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. B ga Evklid masofa ===
  A (tarix, katta)  :  45.18
  C (roman)         :   6.24
  D (astronomiya)   :  10.00

=== 2. B ga kosinus o'xshashlik ===
  A (tarix, katta)  : 0.995
  C (roman)         : 0.429
  D (astronomiya)   : 0.087

=== 3. Xulosa ===
  Evklid bo'yicha eng yaqin: C (roman)
  kosinus bo'yicha eng yaqin: A (tarix, katta)
  ⭐ Matnda — yo'nalish (mavzu) muhim, uzunlik emas

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Proyeksiya va ortogonal qoldiq

python
"""Proyeksiya: soya va perpendikulyar qoldiq (real numpy)."""

import numpy as np


def main() -> None:
    v = np.array([3.0, 4.0])
    u = np.array([2.0, 1.0])

    print("=== 1. v ning u yo'nalishidagi proyeksiyasi ===")
    proj = (v @ u) / (u @ u) * u
    qoldiq = v - proj
    print(f"  proyeksiya = {np.round(proj, 3)}")
    print(f"  qoldiq     = {np.round(qoldiq, 3)}")
    print(f"  qoldiq · u = {qoldiq @ u:.10f}  (ortogonal)")
    print(f"  proj + qoldiq = {proj + qoldiq}")

    print("\n=== 2. Skalyar proyeksiya: 'qimmat segment' o'qi ===")
    # mijoz: [sarf_z, premium_ulush_z]; o'q — ikkalasining birgalikdagi yo'nalishi
    oq = np.array([1.0, 1.0]) / np.sqrt(2)
    mijozlar = np.array([[2.0, 1.5], [-1.0, 0.5], [0.3, -2.0]])
    print(f"  o'qdagi qiymatlar: {np.round(mijozlar @ oq, 2)}")

    print("\n=== 3. Pifagor: ||v||^2 = ||proj||^2 + ||qoldiq||^2 ===")
    print(f"  {v @ v:.2f} = {proj @ proj:.2f} + {qoldiq @ qoldiq:.2f}")
    print("  ⭐ Proyeksiya — regressiya va PCA asosi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. v ning u yo'nalishidagi proyeksiyasi ===
  proyeksiya = [4. 2.]
  qoldiq     = [-1.  2.]
  qoldiq · u = 0.0000000000  (ortogonal)
  proj + qoldiq = [3. 4.]

=== 2. Skalyar proyeksiya: 'qimmat segment' o'qi ===
  o'qdagi qiymatlar: [ 2.47 -0.35 -1.2 ]

=== 3. Pifagor: ||v||^2 = ||proj||^2 + ||qoldiq||^2 ===
  25.00 = 20.00 + 5.00
  ⭐ Proyeksiya — regressiya va PCA asosi

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

Misol 4 — Korrelyatsiya = markazlashtirilgan kosinus

python
"""Pearson korrelyatsiyasi markazlashtirilgan vektorlar kosinusi ekani (real numpy)."""

import numpy as np


def kosinus(a: np.ndarray, b: np.ndarray) -> float:
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))


def main() -> None:
    rng = np.random.default_rng(0)
    x = rng.normal(50, 10, 200)
    y = 0.5 * x + rng.normal(0, 8, 200) + 100     # hammasi musbat

    print("=== 1. Xom kosinus (markazlashtirilmagan) ===")
    print(f"  cos(x, y) = {kosinus(x, y):.4f}  ← hamma qiymat musbat — doim yuqori")

    print("\n=== 2. Markazlashtirilgan kosinus ===")
    xc, yc = x - x.mean(), y - y.mean()
    print(f"  cos(xc, yc) = {kosinus(xc, yc):.4f}")
    print(f"  np.corrcoef = {np.corrcoef(x, y)[0, 1]:.4f}")

    print("\n=== 3. Kovariatsiya — skalyar ko'paytma ===")
    print(f"  xc @ yc / (n - 1) = {xc @ yc / (len(x) - 1):.4f}")
    print(f"  np.cov          = {np.cov(x, y)[0, 1]:.4f}")

    print("\n=== 4. Bog'liqsiz o'zgaruvchilar — ortogonal ===")
    z = rng.normal(0, 1, 200)
    print(f"  corr(x, z) = {kosinus(xc, z - z.mean()):.4f}  (≈ 0)")
    print("  ⭐ Statistika tushunchalari — geometriya")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Xom kosinus (markazlashtirilmagan) ===
  cos(x, y) = 0.9859  ← hamma qiymat musbat — doim yuqori

=== 2. Markazlashtirilgan kosinus ===
  cos(xc, yc) = 0.4628
  np.corrcoef = 0.4628

=== 3. Kovariatsiya — skalyar ko'paytma ===
  xc @ yc / (n - 1) = 41.2825
  np.cov          = 41.2825

=== 4. Bog'liqsiz o'zgaruvchilar — ortogonal ===
  corr(x, z) = 0.0606  (≈ 0)
  ⭐ Statistika tushunchalari — geometriya

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

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

Noto'g'ri fikr To'g'risi
"u * v — skalyar ko'paytma" u @ v (u * v — massiv)
"Katta skalyar ko'paytma — o'xshash" Uzunlik ta'sir qiladi; kosinus
"Kosinus doim yaxshi" Kattalik muhim bo'lsa — yo'q
"Kosinus = korrelyatsiya" Faqat markazlashtirilganda
"Perpendikulyar — faqat 2D" Har o'lchamda: u · v = 0
"Proyeksiya — faqat geometriya" Regressiya, PCA asosi
"Nol vektor kosinusi 0" Aniqlanmagan
"Korrelyatsiya — alohida formula" Markazlashtirilgan kosinus

6. Keng tarqalgan xatolar va yechimlari

1. * va @

python
jami = miqdor * narx                   # massiv                    # ⚠️
jami = miqdor @ narx                   # son                       # ✅

2. Xom ko'paytma o'xshashlik sifatida

python
oxshash = A @ B.T                      # uzun hujjatlar yutadi     # ⚠️
oxshash = cosine_similarity(A, B)                                  # ✅

3. arccos domen xatosi

python
np.arccos(cos)                         # 1.0000000002 → nan         # ⚠️
np.arccos(np.clip(cos, -1, 1))                                     # ✅

4. Markazlashtirmasdan "korrelyatsiya"

python
r = x @ y / (np.linalg.norm(x) * np.linalg.norm(y))               # ⚠️
xc, yc = x - x.mean(), y - y.mean(); r = xc @ yc / (...)          # ✅

5. Nol vektor

python
cos = u @ v / (np.linalg.norm(u) * np.linalg.norm(v))  # 0/0      # ⚠️
# bo'sh hujjatlarni oldindan olib tashlang yoki 0 deb belgilang    # ✅

6. Sparse matritsani zich qilish

python
X = tfidf.toarray()                    # 100k × 50k — xotira        # ⚠️
cosine_similarity(X_sparse)            # sparse bilan ishlaydi      # ✅

7. Kattalik muhim bo'lganda kosinus

python
# 1 ta mahsulot va 100 ta xuddi shu mahsulot — cos = 1           # ⚠️
# summa muhim bo'lsa — Evklid yoki kosinus + hajm belgisi          # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.11-dars (o'tilgan): dot, @
  • 4.9-dars (o'tilgan): Korrelyatsiya va kovariatsiya
  • 10.1-dars (o'tilgan): Norma, masofa
  • 10.6, 10.9-darslar: Regressiya (proyeksiya), PCA (ortogonal)
  • NLP qismlari: TF-IDF, embedding, semantik qidiruv, attention

8. Eng yaxshi amaliyotlar

  1. Son kerak bo'lsa — @, massiv — *.

  2. Matn va embedding — kosinus.

  3. Kattalik muhim bo'lsa — kosinus yetarli emas.

  4. Qidiruvda vektorlarni oldindan normallashtiring.

  5. arccos oldidan clip.

  6. Korrelyatsiya uchun markazlashtiring.

  7. Matn matritsalari — sparse.

  8. Proyeksiyani qoldiq ortogonalligi bilan tekshiring.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # [1, 2] @ [3, 4]?
2.  # [1, 2] * [3, 4]?
3.  # [3, 4] @ [3, 4]?
4.  # [1, 0] va [0, 1] burchagi?
5.  # [1, 1] va [2, 2] kosinusi?
6.  # [1, 0] va [-1, 0] kosinusi?
7.  # u · v = 0 nima?
8.  # [3, 4] ning [1, 0] ga proyeksiyasi?
9.  # qoldiq va u orasidagi ko'paytma?
10. # korrelyatsiya = qanday kosinus?
11. # [10, 0, 5] va [100, 0, 50] kosinus?
12. # transformer attention asosida?
Javoblar
  1. 11
  2. [3, 8]
  3. 25
  4. 90°
  5. 1
  6. -1
  7. Ortogonal
  8. [3, 0]
  9. 0
  10. Markazlashtirilgan vektorlar kosinusi
  11. 1
  12. Skalyar ko'paytma (so'rov · kalit)

Vazifa 2: Xatolarni tuzating

python
1.  jami = np.array([2, 3]) * np.array([1000, 500])   # jami narx

2.  oxshash = A @ B.T   # uzunligi turli hujjatlar

3.  theta = np.arccos(u @ v / (np.linalg.norm(u) * np.linalg.norm(v)))

4.  r = x @ y / (np.linalg.norm(x) * np.linalg.norm(y))   # korrelyatsiya

5.  X = tfidf_matritsa.toarray(); cosine_similarity(X)
Javoblar
python
1.  jami = np.array([2, 3]) @ np.array([1000, 500])

2.  oxshash = cosine_similarity(A, B)

3.  theta = np.arccos(np.clip(u @ v / (...), -1, 1))

4.  xc, yc = x - x.mean(), y - y.mean(); r = xc @ yc / (np.linalg.norm(xc) * np.linalg.norm(yc))

5.  cosine_similarity(tfidf_matritsa)

Vazifa 3: Tavsiya

Modellang:

  1. 6 foydalanuvchi × 5 film baholari
  2. Kosinus o'xshashlik matritsasi
  3. Eng o'xshash foydalanuvchi
  4. U yoqtirgan, lekin berilgan foydalanuvchi ko'rmagan film

Vazifa 4: Proyeksiya

Modellang:

  1. 2D nuqtalar
  2. Berilgan yo'nalishga proyeksiya
  3. Qoldiqlar ortogonalligi
  4. Grafik (nuqta, proyeksiya, qoldiq)

Vazifa 5: Korrelyatsiya

Modellang:

  1. Uch juft o'zgaruvchi
  2. Xom kosinus va markazlashtirilgan kosinus
  3. np.corrcoef bilan solishtirish
  4. Nega farq qiladi

Vazifa 6: Integratsiya

Modellang:

  1. Norma (10.1)
  2. Korrelyatsiya (4.9)
  3. Matn tozalash (6.7)
  4. Kosinus qidiruv

Vazifa 7: O'ylash

Zamonaviy qidiruv tizimlari va ChatGPT kabi yordamchilar "semantik qidiruv"dan foydalanadi: har bir hujjat va savol yuzlab o'lchamli vektorga (embedding) aylantiriladi, keyin eng yuqori kosinus o'xshashlikka ega hujjatlar topiladi. Nima uchun so'zlarni to'g'ridan-to'g'ri solishtirishdan ko'ra bu yondashuv kuchliroq? Uning cheklovlari va xavflari nimada?

Javob

Qisqa javob: embedding'lar ma'nosi yaqin matnlarni fazoda yaqin (bir yo'nalishda) joylashtiradi — "avtomobil" va "mashina" so'zlari mos kelmasa ham, ularning vektorlari yaqin. Kosinus o'xshashlik shu yo'nalish yaqinligini tez o'lchaydi. Cheklovi: o'xshashlik — model o'rgangan narsaga bog'liq; "yaqin" har doim "to'g'ri" yoki "dolzarb" degani emas.

1. Nega kuchli

So'z mosligi Embedding + kosinus
Aynan so'z kerak Sinonimlarni tushunadi
Tartib/kontekst yo'q Kontekstni hisobga oladi
Tillararo ishlamaydi Ko'p tilli bo'lishi mumkin
Tez, sodda Tez (vektor indekslari)

2. Nega kosinus

  • Uzun va qisqa matnlar bir mavzuda — yo'nalish bir xil
  • Normallashtirilgan vektorlarda — oddiy skalyar ko'paytma (juda tez)
  • Millionlab hujjatda taxminiy eng yaqin qo'shni qidiruvi (ANN)

3. Cheklovlar va xavflar

  • Inkor va nozik farqlar: "dori xavfsiz" va "dori xavfsiz emas" — vektorlari yaqin bo'lishi mumkin
  • Model tarafkashligi o'xshashlikka o'tadi
  • Aniq mos kelish kerak bo'lganda (kod, raqam, ism) — so'z qidiruvi yaxshiroq
  • "O'xshash" ≠ "to'g'ri javob" — faktlarni tekshirish kerak

4. Data Scientist qanday

  1. Gibrid qidiruv: so'z mosligi + semantik
  2. Natijalarni qo'lda va metrikalar bilan baholaydi
  3. Nozik holatlar (inkor, raqam) uchun test to'plami tuzadi
  4. Vektorlarni normallashtirib, indekslaydi

5. Xulosa

  1. Embedding — ma'noni geometriyaga aylantiradi
  2. Kosinus — yo'nalish bo'yicha tez o'xshashlik
  3. Cheklov: o'xshashlik ≠ to'g'rilik, nozik ma'nolar yo'qolishi mumkin
  4. Gibrid yondashuv va baholash — amaliy yechim

Nimani mustahkamlaydi: 2.3, 2.7-bo'limlar.

Xulosa

Bu darsda skalyar ko'paytma va o'xshashlikni o'rgandik.

Eng muhim uch fikr:

  1. Ikki yuz. Algebraik: u · v = sum(ui × vi) (u @ v; v · v = ||v||^2). Geometrik: ||u|| × ||v|| × cos(theta) — ishora yo'nalishni aytadi, 0 — ortogonal (bog'liqsiz). Chiziqli model, neyron, attention — skalyar ko'paytma.

  2. Kosinus o'xshashlik. cos_sim = u · v / (||u|| ||v||) — faqat yo'nalish; matn, embedding, tavsiya uchun (uzun va qisqa hujjat bir mavzuda — o'xshash). Kattalik muhim bo'lsa — yetarli emas. Korrelyatsiya — markazlashtirilgan vektorlar kosinusi; kovariatsiya — ularning skalyar ko'paytmasi.

  3. Proyeksiya va ortogonallik. Proyeksiya (v·u / u·u) u — soya; qoldiq u ga ortogonal (Pifagor). Bu regressiya (bashorat — proyeksiya, xato — ortogonal qoldiq) va PCA (ortogonal komponentalar) asosi.

Keyingi darsda matritsalarni o'rganamiz: ma'lumot jadvali sifatida matritsa, maxsus matritsalar (birlik, diagonal, simmetrik), transponirlash va kovariatsiya matritsasi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!