Python kursi/ML va AI11/12-dars18 daqiqa

Mundarija (22)

25.11-dars: RAG tizimi qurish

25-QISM — ML VA AI · 11-dars

1. Kirish va motivatsiya

25.10 da LLM API'ni ko'rdik — kuchli, lekin ikki cheklov: bilmaydi (o'z hujjatlaringiz, kompaniya ma'lumoti — model o'qitilganda yo'q edi), xato qiladi (hallucination — ishonchli ko'rinadigan soxta javob). Yechim: modelga javob berishdan oldin kerakli ma'lumotni topib berish. "Bu savolga javob ber, ana shu hujjatlarga asoslanib". Bu — RAG (Retrieval-Augmented Generation).

RAG (Qidirib-Boyitilgan Generatsiya) — LLM'ni o'z ma'lumot manbaiga (hujjatlar, baza) bog'lash: 1) hujjatlarni saqlash (bo'laklarga bo'lib — chunking), 2) qidirish (savolga mos bo'laklarni topish — embedding + o'xshashlik), 3) generatsiya (topilgan bo'laklarni promptga qo'shib, LLM javob beradi). Natija: model o'z hujjatlaringizga javob beradi (bilmaganini topadi), manbaga asoslanadi (hallucination kam — "shu hujjatda shunday deyilgan"). RAG — korporativ AI (kompaniya bilim bazasi, hujjat yordamchisi) ning asosiy usuli. Zamonaviy AI ilovalarining eng ko'p ishlatiladigan namunasi.

Real vaziyat. Bir kompaniya o'z hujjatlari (siyosat, qo'llanma) bo'yicha savol-javob tizimi kerak edi. Oddiy LLM bilmasdi (uning hujjatlari emas) yoki o'ylab topardi (hallucination). RAG qurildi: hujjatlar bo'laklarga bo'lindi, savol berilganda mos bo'laklar topildi, LLM ularga asoslanib javob berdi ("qo'llanmaning 5-bo'limiga ko'ra..."). Aniq, manbaga asoslangan javob. RAG — LLM'ni o'z ma'lumotga bog'lash.

Bu darsda RAG tizimini o'rganamiz.

Bu darsda:

RAG nima va nega
Hujjatlarni bo'lish (chunking)
Embedding va qidirish
O'xshashlik (cosine similarity)
Kontekst bilan generatsiya
Vektor baza (tushuncha)
RAG afzalliklari
Amaliy: RAG tizimi

ℹ Misollarda deterministik TF-IDF (leksik moslik) va mock LLM bilan sinaladi — real RAG semantik embedding va API ishlatadi.

2. Nazariya — chuqur tushuntirish

2.1. RAG nima va nega

LLM + o'z ma'lumot manbai:

Savol → [qidirish: mos hujjat bo'laklari]
      → [LLM: bo'laklar + savol → javob]
Natija: o'z hujjatlarga asoslangan javob

RAG (Retrieval-Augmented Generation — qidirib-boyitilgan generatsiya) — LLM javobini o'z ma'lumot manbai (hujjat, baza) bilan boyitish: savolga javob berishdan oldin kerakli ma'lumotni topib (retrieval), promptga qo'shib (augmented), LLM javob beradi (generation). Sabab: LLM bilmaydi (o'z hujjatlaringiz) va xato qiladi (hallucination) — RAG ikkalasini yechadi (o'z ma'lumot + manbaga asoslanish). Korporativ AI asosi.

2.2. Hujjatlarni bo'lish (chunking)

Uzun hujjatni bo'laklarga:

python

def chunk(matn, size):
    words = matn.split()
    return [" ".join(words[i:i+size]) for i in range(0, len(words), size)]
# uzun hujjat → kichik bo'laklar (chunk)

Chunking (bo'lish) — uzun hujjatni kichik bo'laklarga bo'lish (paragraf, jumla, N so'z): sabab — LLM kontekst oynasi cheklangan 25.10-bob, va qidirish aniqroq (kichik bo'lak — aniq mavzu). Har bo'lak alohida saqlanadi va qidiriladi. Bo'lak hajmi muhim: juda katta (ko'p token, noaniq), juda kichik (kontekst yo'qoladi). Odatda paragraf yoki bir necha jumla. Chunking — RAG ning birinchi qadami.

2.3. Embedding va qidirish

Matnni vektorga (ma'no bo'yicha):

python

# embedding: matn → vektor (ma'no)
# o'xshash ma'no → yaqin vektor
# real: OpenAI/sentence-transformers embedding
# bu darsda: TF-IDF (leksik — so'z mosligi)
from sklearn.feature_extraction.text import TfidfVectorizer

Embedding — matnni vektorga (sonlar massivi) aylantirish, ma'no bo'yicha: o'xshash ma'noli matnlar → yaqin vektorlar. Real RAG semantik embedding (ma'no — "avtomobil" va "mashina" yaqin), maxsus model (OpenAI, sentence-transformers). Bu darsda TF-IDF (leksik — so'z mosligi, 24.5) — deterministik, lekin faqat so'z (ma'no emas). Qidirish: savol embedding'ini hujjat bo'laklari bilan solishtirib, eng yaqinni topish. Embedding — ma'no bo'yicha qidirish.

2.4. O'xshashlik (cosine similarity)

Vektorlar yaqinligi:

python

from sklearn.metrics.pairwise import cosine_similarity
# cosine: ikki vektor orasidagi burchak (0-1)
# 1 = bir xil yo'nalish (o'xshash), 0 = bog'liq emas
sims = cosine_similarity(savol_vec, hujjat_vecs)

O'xshashlik (cosine similarity — kosinus o'xshashlik) — ikki vektor orasidagi yaqinlik (0–1): 1 (bir xil yo'nalish — o'xshash ma'no), 0 (bog'liq emas). Savol vektori va har hujjat bo'lagi vektori orasida hisoblanadi — eng yuqori o'xshashlikli bo'laklar (top-k) tanlanadi. Bu "ma'no bo'yicha qidirish" (keyword emas — vektor). cosine_similarity (sklearn). Eng yaqin bo'laklar — savolga mos ma'lumot.

2.5. Kontekst bilan generatsiya

Topilgan bo'laklarni LLM'ga:

python

def rag(savol):
    bo'laklar = qidir(savol, k=3)     # mos bo'laklar
    kontekst = "\n".join(bo'laklar)
    prompt = f"Quyidagi ma'lumotga asoslanib javob ber:\n{kontekst}\n\nSavol: {savol}"
    return llm(prompt)               # javob

Kontekst bilan generatsiya — topilgan bo'laklarni promptga qo'shib, LLM javob beradi: prompt = "Shu ma'lumotga asoslanib: {kontekst}. Savol: {savol}". LLM endi o'z hujjatlarga (kontekst) asoslanib javob beradi (bilmaganini topdi, hallucination kam). Muhim: "faqat berilgan ma'lumotga asoslanib" (model o'ylab topmasin). Bu RAG ning "generation" qismi — retrieval + LLM. Kontekst — javob asosi.

2.6. Vektor baza (tushuncha)

Embeddinglarni saqlash va qidirish:

python

# vektor baza: embeddinglarni saqlab, tez qidirish
# Chroma, Pinecone, FAISS, pgvector
# katta hujjat to'plami uchun (millionlab bo'lak)

Vektor baza (vector database) — embeddinglarni saqlab, tez qidirish (eng yaqin vektorlar): Chroma, Pinecone, FAISS, pgvector (PostgreSQL — 23.5). Sabab: millionlab bo'lak orasidan eng yaqinni tez topish (oddiy solishtirish sekin). Kichik loyihada — xotirada (bu darsda), katta loyihada — vektor baza. Bu 23-qism (baza) ning vektor versiyasi. RAG'ning masshtabli infratuzilmasi.

2.7. RAG afzalliklari

Afzallik	Tafsilot
O'z ma'lumot	Model bilmaganini topadi
Manbaga asoslanish	Hallucination kam
Yangilanadigan	Hujjat qo'shish (o'qitmasdan)
Manbani ko'rsatish	"Shu hujjatda deyilgan"

RAG afzalliklari: o'z ma'lumot (model o'qitilganda yo'q — kompaniya hujjatlari, yangi ma'lumot), manbaga asoslanish (hallucination kam — "shu hujjatda shunday deyilgan"), yangilanadigan (yangi hujjat qo'shish — modelni qayta o'qitmasdan), manbani ko'rsatish (javob qaysi hujjatdan — ishonch). Kamchilik: qidirish sifati (noto'g'ri bo'lak → noto'g'ri javob), murakkablik (chunking, embedding, baza). RAG — LLM'ni o'z ma'lumotga bog'lashning standart usuli.

2.8. RAG — LLM va ma'lumot

RAG LLM'ning ikki cheklovini yechadi: bilim (LLM faqat o'qitilgan ma'lumotni biladi — RAG yangi/o'z ma'lumot qo'shadi) va ishonchlilik (LLM o'ylab topadi — RAG manbaga bog'laydi). Bu "LLM — mulohaza, RAG — bilim" (model fikrlaydi, RAG faktni beradi). O'z model o'qitish (fine-tuning — qimmat, qiyin) o'rniga RAG (arzon, moslashuvchan — hujjat qo'shish). Zamonaviy AI ilovalari (hujjat yordamchisi, mijozlarga yordam, bilim bazasi) ko'pincha RAG. "LLM'ni o'z faktlarga bog'la" — RAG ning mohiyati.

3. Tez ma'lumotnoma

python

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# 1. chunking (hujjatni bo'lish):
def chunk(matn, size):
    w = matn.split()
    return [" ".join(w[i:i+size]) for i in range(0, len(w), size)]

# 2. embedding (matn → vektor):
vec = TfidfVectorizer()
M = vec.fit_transform(hujjatlar)     # real: semantik embedding

# 3. qidirish (o'xshash bo'laklar):
def retrieve(savol, k=3):
    q = vec.transform([savol])
    sims = cosine_similarity(q, M)[0]
    return np.argsort(-sims)[:k]     # eng yaqin k

# 4. generatsiya (kontekst + LLM):
def rag(savol):
    idx = retrieve(savol)
    kontekst = "\n".join(hujjatlar[i] for i in idx)
    prompt = f"Ma'lumot: {kontekst}\nSavol: {savol}"
    return llm(prompt)               # real: LLM API

# vektor baza: Chroma, FAISS, pgvector (katta uchun)

RAG xulosasi

RAG: LLM + o'z ma'lumot · chunking (bo'lish) → embedding (vektor) → qidirish → generatsiya
Cosine similarity (o'xshashlik) · kontekst promptga · vektor baza (katta)
O'z ma'lumot + manbaga asoslanish (hallucination kam)

4. Batafsil misollar

Misollarda deterministik TF-IDF (leksik — so'z mosligi) va mock LLM bilan sinaladi. Real RAG semantik embedding (ma'no) va API ishlatadi.

Misol 1 — Chunking va embedding

python

"""chunking (hujjatni bo'laklarga); TF-IDF embedding (matn → vektor)."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.feature_extraction.text import TfidfVectorizer


def chunk(matn: str, size: int) -> list:
    words = matn.split()
    return [" ".join(words[i:i + size]) for i in range(0, len(words), size)]


def main() -> None:
    print("=== 1. Chunking (hujjatni bo'lish) ===")
    hujjat = "Python tili sodda va kuchli dasturlash tili hisoblanadi"
    bolaklar = chunk(hujjat, 3)
    for i, b in enumerate(bolaklar):
        print(f"  bo'lak {i}: '{b}'")

    print("\n=== 2. Embedding (TF-IDF — matn → vektor) ===")
    hujjatlar = [
        "Python dasturlash tili",
        "pandas ma'lumot tahlili",
        "FastAPI web freymvork",
    ]
    vec = TfidfVectorizer()
    M = vec.fit_transform(hujjatlar)
    print(f"  hujjatlar: {len(hujjatlar)}, lug'at: {len(vec.vocabulary_)}")
    print(f"  vektor shakl: {M.shape}")

    print("\n=== 3. Real vs demo embedding ===")
    print("  demo: TF-IDF (so'z mosligi — leksik)")
    print("  real: semantik embedding (ma'no)")

    print("\n=== 4. Nega chunking ===")
    print("  kontekst oynasi cheklangan, qidirish aniqroq")
    print("  ⭐ chunking (bo'lish) + embedding (vektor) — RAG asosi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Chunking (hujjatni bo'lish) ===
  bo'lak 0: 'Python tili sodda'
  bo'lak 1: 'va kuchli dasturlash'
  bo'lak 2: 'tili hisoblanadi'

=== 2. Embedding (TF-IDF — matn → vektor) ===
  hujjatlar: 3, lug'at: 10
  vektor shakl: (3, 10)

=== 3. Real vs demo embedding ===
  demo: TF-IDF (so'z mosligi — leksik)
  real: semantik embedding (ma'no)

=== 4. Nega chunking ===
  kontekst oynasi cheklangan, qidirish aniqroq
  ⭐ chunking (bo'lish) + embedding (vektor) — RAG asosi

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

Misol 2 — Qidirish (o'xshashlik)

python

"""cosine similarity: savolga mos hujjat bo'laklarini topish (eng yaqin vektor)."""

import warnings
warnings.filterwarnings("ignore")

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity


def main() -> None:
    hujjatlar = [
        "Python dasturlash tili 1991 yilda yaratilgan",
        "pandas ma'lumot tahlili kutubxonasi",
        "FastAPI web freymvork Python uchun",
        "Django to'liq web freymvork",
    ]
    vec = TfidfVectorizer()
    M = vec.fit_transform(hujjatlar)

    def retrieve(savol: str, k: int = 2) -> list:
        q = vec.transform([savol])
        sims = cosine_similarity(q, M)[0]
        idx = np.argsort(-sims)[:k]
        return [(int(i), round(float(sims[i]), 3)) for i in idx]

    print("=== 1. Savol: 'web freymvork' ===")
    r = retrieve("web freymvork")
    for idx, sim in r:
        print(f"  o'xshashlik {sim}: '{hujjatlar[idx]}'")

    print("\n=== 2. Savol: 'ma'lumot tahlili' ===")
    r2 = retrieve("ma'lumot tahlili")
    print(f"  eng mos: '{hujjatlar[r2[0][0]]}'")

    print("\n=== 3. Savol: 'Python tili' ===")
    r3 = retrieve("Python tili")
    print(f"  eng mos: '{hujjatlar[r3[0][0]]}'")

    print("\n=== 4. Cosine similarity ===")
    print("  1 = o'xshash, 0 = bog'liq emas")
    print("  eng yuqori o'xshashlik — savolga mos")
    print("  ⭐ qidirish — savolga mos bo'laklar (cosine)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Savol: 'web freymvork' ===
  o'xshashlik 0.567: 'FastAPI web freymvork Python uchun'
  o'xshashlik 0.541: 'Django to'liq web freymvork'

=== 2. Savol: 'ma'lumot tahlili' ===
  eng mos: 'pandas ma'lumot tahlili kutubxonasi'

=== 3. Savol: 'Python tili' ===
  eng mos: 'Python dasturlash tili 1991 yilda yaratilgan'

=== 4. Cosine similarity ===
  1 = o'xshash, 0 = bog'liq emas
  eng yuqori o'xshashlik — savolga mos
  ⭐ qidirish — savolga mos bo'laklar (cosine)

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

Misol 3 — Kontekst bilan generatsiya

python

"""RAG generatsiya: qidirish + kontekst + mock LLM — o'z ma'lumotga asoslangan javob."""

import warnings
warnings.filterwarnings("ignore")

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity


def main() -> None:
    hujjatlar = [
        "Kompaniya ish vaqti 9 dan 18 gacha",
        "Ta'til yiliga 24 kun beriladi",
        "Masofaviy ish haftada 2 kun ruxsat etiladi",
    ]
    vec = TfidfVectorizer()
    M = vec.fit_transform(hujjatlar)

    def retrieve(savol: str) -> str:
        q = vec.transform([savol])
        sims = cosine_similarity(q, M)[0]
        return hujjatlar[int(np.argmax(sims))]

    def mock_llm(kontekst: str, savol: str) -> str:
        return f"[Ma'lumot: '{kontekst}'] asosida javob"

    def rag(savol: str) -> str:
        kontekst = retrieve(savol)       # 1. qidirish
        return mock_llm(kontekst, savol)  # 2. generatsiya

    print("=== 1. Savol: 'ta'til necha kun?' ===")
    print(f"  {rag('tatil necha kun beriladi')}")

    print("\n=== 2. Savol: 'ish vaqti qachon?' ===")
    print(f"  {rag('ish vaqti qachon')}")

    print("\n=== 3. Savol: 'masofaviy ish?' ===")
    print(f"  {rag('masofaviy ish ruxsat')}")

    print("\n=== 4. RAG oqimi ===")
    print("  savol → qidirish (mos hujjat) → LLM (kontekst + savol) → javob")
    print("  model o'z hujjatlarga asoslandi (bilmaganini topdi)")
    print("  ⭐ RAG — qidirish + kontekst + generatsiya")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Savol: 'ta'til necha kun?' ===
  [Ma'lumot: 'Ta'til yiliga 24 kun beriladi'] asosida javob

=== 2. Savol: 'ish vaqti qachon?' ===
  [Ma'lumot: 'Kompaniya ish vaqti 9 dan 18 gacha'] asosida javob

=== 3. Savol: 'masofaviy ish?' ===
  [Ma'lumot: 'Masofaviy ish haftada 2 kun ruxsat etiladi'] asosida javob

=== 4. RAG oqimi ===
  savol → qidirish (mos hujjat) → LLM (kontekst + savol) → javob
  model o'z hujjatlarga asoslandi (bilmaganini topdi)
  ⭐ RAG — qidirish + kontekst + generatsiya

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Amaliy: to'liq RAG tizimi

Real RAG: hujjat bazasi, chunking, qidirish, kontekst bilan javob — to'liq quvur. Bu — RAG tizimining namunasi (deterministik mock bilan).

python

"""to'liq RAG: hujjat bazasi, index qurish, savol → qidirish → javob (manba bilan)."""

import warnings
warnings.filterwarnings("ignore")

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity


class RAG:
    def __init__(self, hujjatlar: list) -> None:
        self.hujjatlar = hujjatlar
        self.vec = TfidfVectorizer()
        self.M = self.vec.fit_transform(hujjatlar)

    def retrieve(self, savol: str, k: int = 2) -> list:
        q = self.vec.transform([savol])
        sims = cosine_similarity(q, self.M)[0]
        return list(np.argsort(-sims)[:k])

    def answer(self, savol: str) -> dict:
        idx = self.retrieve(savol, k=2)
        kontekst = [self.hujjatlar[i] for i in idx]
        return {
            "savol": savol,
            "manba": kontekst[0],
            "javob": f"'{kontekst[0]}' asosida javob berildi",
        }


def main() -> None:
    hujjatlar = [
        "Python 1991 yilda Guido van Rossum tomonidan yaratilgan",
        "pandas jadval ma'lumot tahlili uchun kutubxona",
        "FastAPI zamonaviy web freymvork Python uchun",
        "PyTorch chuqur o'qitish kutubxonasi",
    ]

    print("=== 1. RAG tizim qurish (index) ===")
    rag = RAG(hujjatlar)
    print(f"  {len(hujjatlar)} hujjat indekslandi")

    print("\n=== 2. Savol-javob (manba bilan) ===")
    for savol in ["web freymvork qaysi", "chuqur o'qitish kutubxona"]:
        natija = rag.answer(savol)
        print(f"  Savol: {natija['savol']}")
        print(f"    Manba: {natija['manba']}")

    print("\n=== 3. Manbaga asoslanish ===")
    natija = rag.answer("pandas nima uchun")
    print(f"  '{natija['manba']}'")

    print("\n=== 4. RAG afzalligi ===")
    print("  o'z hujjatlarga javob (LLM bilmaganini topdi)")
    print("  manbaga asoslangan (hallucination kam)")
    print("  ⭐ RAG tizim — o'z ma'lumot bilan ishonchli javob")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. RAG tizim qurish (index) ===
  4 hujjat indekslandi

=== 2. Savol-javob (manba bilan) ===
  Savol: web freymvork qaysi
    Manba: FastAPI zamonaviy web freymvork Python uchun
  Savol: chuqur o'qitish kutubxona
    Manba: PyTorch chuqur o'qitish kutubxonasi

=== 3. Manbaga asoslanish ===
  'pandas jadval ma'lumot tahlili uchun kutubxona'

=== 4. RAG afzalligi ===
  o'z hujjatlarga javob (LLM bilmaganini topdi)
  manbaga asoslangan (hallucination kam)
  ⭐ RAG tizim — o'z ma'lumot bilan ishonchli javob

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

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

Noto'g'ri fikr	To'g'risi
"LLM hammani biladi"	O'z hujjatlaringiz — yo'q (RAG)
"RAG = model o'qitish"	O'qitmasdan (qidirish + kontekst)
"Chunking keraksiz"	Kontekst oynasi, aniqlik
"Keyword qidirish yetarli"	Semantik (embedding) yaxshiroq
"RAG hallucinationni yo'qotadi"	Kamaytiradi (qidirish sifati)
"Vektor baza shart"	Kichik — xotirada
"RAG oddiy"	Chunking, embedding, baza
"Fine-tuning yaxshiroq"	RAG arzon, moslashuvchan

6. Keng tarqalgan xatolar va yechimlari

1. Chunk juda katta/kichik

python

chunk(hujjat, 1000)   # juda katta (noaniq)          # ⚠️
chunk(hujjat, 5)      # juda kichik (kontekst yo'q)   # ⚠️
chunk(hujjat, 100)    # paragraf (mos)                 # ✅

2. Faqat keyword (semantiksiz)

python

# aniq so'z mos kelmasa topmaydi                      # ⚠️
# semantik embedding (ma'no bo'yicha)                  # ✅

3. Kontekstsiz LLM (RAG'siz)

python

llm(savol)   # o'z hujjat bilmaydi                    # ⚠️
llm(kontekst + savol)   # RAG                          # ✅

4. Noto'g'ri bo'lak (qidirish yomon)

python

# noto'g'ri bo'lak → noto'g'ri javob                   # ⚠️
# qidirish sifatini yaxshila (k, embedding)             # ✅

5. "Faqat ma'lumotga asoslanib" demaslik

python

prompt = f"{kontekst} {savol}"   # model o'ylab topishi  # ⚠️
"Faqat berilgan ma'lumotga asoslanib javob ber"          # ✅

6. Manbani ko'rsatmaslik

python

# faqat javob (manba yo'q)                             # ⚠️
# javob + manba (qaysi hujjat)                          # ✅

7. Katta hujjat — xotirada

python

# millionlab bo'lak xotirada (sekin)                   # ⚠️
# vektor baza (Chroma, FAISS)                           # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

25.10-dars (o'tilgan): LLM API — RAG generatsiya
24.5-dars (o'tilgan): TF-IDF — embedding (demo)
23.5-dars (o'tilgan): PostgreSQL — pgvector
20-qism (o'tilgan): FastAPI — RAG backend
25.12-dars: Deploy — RAG ilova

8. Eng yaxshi amaliyotlar

Chunk hajmi mos (paragraf).
Semantik embedding (keyword emas).
Top-k mos bo'laklar (cosine).
"Faqat ma'lumotga asoslanib" (prompt).
Manbani ko'rsat (ishonch).
Katta hujjat — vektor baza.
Qidirish sifatini tekshir (mos bo'lak).
RAG — fine-tuning'dan arzon (hujjat qo'sh).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # RAG nima?
2.  # RAG nega kerak?
3.  # chunking nima?
4.  # embedding nima?
5.  # semantik vs leksik?
6.  # cosine similarity nima?
7.  # qidirish nima?
8.  # kontekst generatsiya nima?
9.  # vektor baza nima?
10. # RAG hallucination-chi?
11. # RAG vs fine-tuning?
12. # RAG oqimi?

Javoblar

LLM + o'z ma'lumot manbai
LLM bilmaydi + xato qiladi (RAG yechadi)
Hujjatni bo'laklarga bo'lish
Matn → vektor (ma'no)
Semantik ma'no, leksik so'z
Vektorlar yaqinligi (0-1)
Savolga mos bo'laklarni topish
Kontekst + savol → LLM javob
Embeddinglarni saqlab qidirish
Kamaytiradi (manbaga asoslanish)
RAG arzon, hujjat qo'sh (o'qitmasdan)
Qidir → kontekst → generatsiya

Vazifa 2: Xatolarni tuzating

python

1.  chunk(hujjat, 1000)               # 100 (paragraf)

2.  llm(savol)   # o'z hujjat yo'q     # kontekst qo'sh

3.  # keyword qidirish                 # semantik

4.  f"{kontekst} {savol}"              # "asoslanib"

5.  # faqat javob (manba yo'q)         # manba ko'rsat

Javoblar

python

1.  chunk(hujjat, 100)

2.  llm(kontekst + savol)

3.  # semantik embedding

4.  "Faqat berilgan ma'lumotga asoslanib: ..."

5.  # javob + manba

Vazifa 3: Chunking/embedding

RAG:

chunk
TF-IDF
Vektor
Real vs demo

Vazifa 4: Qidirish

O'xshashlik:

cosine_similarity
Top-k
Mos bo'lak
Savol

Vazifa 5: Generatsiya

RAG:

Qidirish
Kontekst
LLM
Javob

Vazifa 6: To'liq RAG

Tizim:

Index
Qidirish
Javob
Manba

Vazifa 7: O'ylash

RAG LLM'ning ikki cheklovini yechadi: bilim (LLM faqat o'qitilgan ma'lumotni biladi) va ishonchlilik (hallucination). "LLM — mulohaza, RAG — bilim" (model fikrlaydi, RAG faktni beradi). Nima uchun "LLM'ni o'z faktlarga bog'lash" ishonchli AI uchun muhim, va nega RAG fine-tuning (model o'qitish) dan ko'pincha afzal — bilim va mulohazani ajratish nega foydali?

Javob

Qisqa javob: RAG LLM'ni o'z faktlarga bog'laydi — model fikrlaydi (mulohaza), RAG faktni beradi (bilim). Bu ishonchli AI uchun muhim, chunki: LLM bilmaganini o'ylab topadi (hallucination — ishonchli ko'rinadigan soxta javob) — RAG manbaga bog'lab buni kamaytiradi ("shu hujjatda shunday deyilgan"). "Bilim va mulohaza ajratish" foydali: mulohaza (LLM — tilni tushunish, javob tuzish) barqaror; bilim (faktlar — o'zgaradi, yangilanadi, kompaniyaga xos) alohida (hujjatlar). RAG fine-tuning'dan afzal, chunki: arzon (hujjat qo'shish — modelni qayta o'qitmasdan), yangilanadigan (yangi hujjat darrov), manbaga asoslangan (fine-tuning — bilim modelga singadi, manba yo'q), moslashuvchan (turli hujjat to'plami). Fine-tuning — mulohaza/uslub o'zgartirish uchun; RAG — bilim qo'shish uchun. "Modelni o'zgartirma, unga to'g'ri ma'lumot ber".

1. LLM — mulohaza, RAG — bilim

LLM: tilni tushunish, javob tuzish (mulohaza)
RAG: faktlar (bilim — hujjatdan)

Ikkalasi birga: to'g'ri faktga asoslangan aqlli javob.

2. Nega bog'lash muhim

LLM o'ylab topadi (hallucination). Manbaga bog'lash → "shu hujjatda deyilgan" (tekshiriladigan, ishonchli).

3. Bilim va mulohaza ajratish

Mulohaza (LLM)	Bilim (RAG)
Barqaror	O'zgaradi
Tilni tushunish	Faktlar
Umumiy	Xos (kompaniya)
O'qitilgan	Hujjatdan

4. RAG vs fine-tuning

RAG	Fine-tuning
Arzon (hujjat qo'sh)	Qimmat (o'qitish)
Yangilanadigan	Qayta o'qitish
Manbaga asoslangan	Bilim singadi
Bilim qo'shish	Uslub/mulohaza

5. Muhandislik saboqlari

LLM'ni faktlarga bog'la (RAG)
Bilim va mulohaza ajrat
RAG — arzon, yangilanadigan
Modelni o'zgartma, to'g'ri ma'lumot ber

6. Xulosa

RAG — LLM + o'z faktlar
LLM mulohaza, RAG bilim
Manbaga bog'lash (hallucination kam)
RAG fine-tuning'dan afzal (bilim uchun)

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda RAG tizimini o'rgandik.

Eng muhim uch fikr:

RAG — LLM + o'z ma'lumot. RAG (Retrieval-Augmented Generation) — LLM javobini o'z ma'lumot manbai (hujjat, baza) bilan boyitish: savolga javob berishdan oldin kerakli ma'lumotni topib (retrieval), promptga qo'shib (augmented), LLM javob beradi (generation). Sabab: LLM bilmaydi (o'z hujjatlaringiz — o'qitilganda yo'q) va xato qiladi (hallucination) — RAG ikkalasini yechadi (o'z ma'lumot + manbaga asoslanish). Korporativ AI (hujjat yordamchisi, bilim bazasi) ning asosi.
RAG bosqichlari. Chunking — uzun hujjatni kichik bo'laklarga bo'lish (paragraf; kontekst oynasi cheklangan, qidirish aniqroq). Embedding — matnni vektorga (ma'no bo'yicha; o'xshash ma'no → yaqin vektor); real RAG semantik (OpenAI, sentence-transformers), demo TF-IDF (leksik — so'z). Qidirish — cosine similarity (0–1; savol vektori va bo'laklar orasida; eng yaqin top-k). Generatsiya — topilgan bo'laklarni promptga qo'shib ("Shu ma'lumotga asoslanib: {kontekst}. Savol: {savol}"), LLM javob beradi. Vektor baza (Chroma, FAISS, pgvector) — katta hujjat to'plami uchun.
RAG afzalliklari va bilim/mulohaza. RAG LLM'ning ikki cheklovini yechadi: bilim (yangi/o'z ma'lumot qo'shadi) va ishonchlilik (manbaga bog'laydi — hallucination kam, "shu hujjatda deyilgan"). Afzalliklar: o'z ma'lumot, manbaga asoslanish, yangilanadigan (hujjat qo'shish — o'qitmasdan), manbani ko'rsatish. "LLM — mulohaza, RAG — bilim" (model fikrlaydi, RAG faktni beradi — ajratish foydali: mulohaza barqaror, bilim o'zgaradi). RAG fine-tuning (model o'qitish)dan ko'pincha afzal (arzon, yangilanadigan, manbaga asoslangan). "Modelni o'zgartma, unga to'g'ri ma'lumot ber". Zamonaviy AI ilovalarining eng ko'p ishlatiladigan namunasi.

Keyingi darsda — 25-qism yakuni — modelni ishlab chiqarishga chiqarish ni o'rganamiz: o'qitilgan modelni saqlash, API orqali xizmat qilish, monitoring — ML modelini real foydalanishga keltirish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!