IlmHamroh
Python kursi/ML va AI10/12-dars17 daqiqa
Mundarija (22)

25.10-dars: LLM API bilan ishlash

25-QISM — ML VA AI · 10-dars

1. Kirish va motivatsiya

25.1–25.9 da modelni o'zimiz qurdik va o'qitdik. Lekin GPT, Claude kabi katta til modellari (LLM — Large Language Model) milliardlab parametr, ulkan ma'lumotda o'qitilgan — ularni o'zingiz qurib bo'lmaydi (millionlab dollar, oylar). Yaxshi xabar: ular API orqali tayyor ishlatiladi — savol yuborasiz, javob olasiz. Bu zamonaviy AI ilovalari (chatbot, matn generatsiya, tarjima, tahlil) ni tez qurish imkonini beradi.

LLM API — katta til modeliga (OpenAI GPT, Anthropic Claude) so'rov yuborib, javob olish: xabarlar (messages — system/user/assistant rollari), prompt (so'rov matni — model'ni yo'naltiradi), javob (model generatsiyasi). Muhim tushunchalar: prompt engineering (yaxshi so'rov — yaxshi javob), temperatura (tasodifiylik — 0 aniq, yuqori ijodiy), token (matn birligi — narx va cheklov), kontekst oynasi (model ko'ra oladigan matn hajmi). LLM API — o'z model o'qitmasdan zamonaviy AI. Bu — 2020-yillar AI ilovalarining asosi.

Real vaziyat. Bir startap mijoz sharhlarini tahlil qilish kerak edi (ijobiy/salbiy). Klassik ML (matn feature, o'qitish, 25.5) haftalar olardi. LLM API bilan: har sharhni "bu sharh ijobiymi yoki salbiymi?" prompt bilan yubordi — model darrov javob berdi (o'qitmasdan). Bir kunda ishladi. LLM API — tez, kuchli AI. O'z model o'rniga tayyor model.

Bu darsda LLM API bilan ishlashni o'rganamiz.

Bu darsda:

  • LLM va API nima
  • Xabarlar va rollar (messages)
  • Prompt engineering
  • Temperatura va parametrlar
  • Token va narx
  • Few-shot (misol bilan)
  • API xavfsizligi (kalit)
  • Amaliy: LLM ilovasi

ℹ Misollarda deterministik mock (soxta LLM) bilan sinaladi — real API kalit va tarmoq talab qiladi (bu yerda chaqirilmaydi).

2. Nazariya — chuqur tushuntirish

2.1. LLM va API nima

Tayyor katta model — API orqali:

python
# real: OpenAI yoki Anthropic SDK
# from openai import OpenAI
# client = OpenAI(api_key="...")
# response = client.chat.completions.create(
#     model="gpt-4", messages=[...])

LLM (Large Language Model — katta til modeli) — milliardlab parametr, ulkan matn ma'lumotda o'qitilgan model (GPT, Claude): matnni tushunadi va generatsiya qiladi. API (Application Programming Interface) — modelga so'rov yuborib javob olish (o'zingiz qurmasdan). client.chat.completions.create(...) (OpenAI), client.messages.create(...) (Anthropic). Siz savol yuborasiz, model javob beradi. O'z model o'qitmasdan kuchli AI.

2.2. Xabarlar va rollar (messages)

Suhbat — rolli xabarlar:

python
messages = [
    {"role": "system", "content": "Sen foydali yordamchisan"},
    {"role": "user", "content": "Python nima?"},
    {"role": "assistant", "content": "Python — dasturlash tili..."},
    {"role": "user", "content": "Kim yaratdi?"},
]

Xabarlar (messages) — suhbat tarixi, har biri rol bilan: system (model'ni sozlash — "kim bo'lishi, qanday javob berishi"), user (foydalanuvchi savoli), assistant (model javobi — oldingi). Suhbat davomida xabarlar to'planadi (model kontekstni ko'radi). System — muhim (model xulqini belgilaydi). Bu suhbat (chat) formati — LLM API asosi. Rolli xabarlar bilan kontekst.

2.3. Prompt engineering

Yaxshi so'rov — yaxshi javob:

python
# yomon prompt:
"tahlil qil"

# yaxshi prompt:
"Quyidagi mijoz sharhini tahlil qil. Faqat 'ijobiy' yoki
 'salbiy' deb javob ber. Sharh: 'Mahsulot ajoyib!'"

Prompt engineering — modelga aniq, yaxshi so'rov yozish (natija sifati so'rovga bog'liq): aniq (nima kerak — "ijobiy/salbiy"), format (javob shakli — "faqat bir so'z"), kontekst (kerakli ma'lumot), misol (few-shot). Yomon prompt — noaniq javob; yaxshi prompt — aniq, foydali. "So'rov qancha yaxshi — javob shuncha yaxshi". Bu LLM bilan ishlashning eng muhim mahorati (kod yozmasdan model'ni boshqarish).

2.4. Temperatura va parametrlar

Model xulqini sozlash:

python
# temperature: tasodifiylik
temperature=0.0    # aniq, izchil (bir savolga bir javob)
temperature=1.0    # ijodiy, xilma-xil
# max_tokens: javob uzunligi
max_tokens=100     # eng ko'p 100 token

Parametrlar — model xulqini sozlaydi: temperature (tasodifiylik — 0 aniq/izchil: faktik savol, kod; 1+ ijodiy/xilma-xil: hikoya, g'oya), max_tokens (javob uzunligi cheklovi), top_p (ehtimol chegarasi). temperature=0 — takrorlanuvchi (bir savol → bir javob), yuqori — har safar boshqacha. Vazifaga qarab: aniqlik kerak → past, ijod kerak → yuqori. Parametrlar — model'ni moslash.

2.5. Token va narx

Matn birligi — token:

python
# token: matn birligi (~4 belgi yoki ~0.75 so'z)
# "Salom dunyo" ≈ 3-4 token
# narx: token bo'yicha (kirish + chiqish token)
# kontekst oynasi: model ko'ra oladigan max token

Token — LLM matnni tokenlarga bo'ladi (~4 belgi yoki ~0.75 so'z inglizchada): "Salom" ≈ 1–2 token. Muhim ikki sabab: narx (API token bo'yicha to'laydi — kirish + chiqish), kontekst oynasi (model bir marta ko'ra oladigan max token — masalan, 128000). Uzun suhbat/hujjat — ko'p token (qimmat, cheklov). Tokenni hisoblash (tiktoken kutubxonasi) — narx va cheklovni boshqarish. Token — LLM iqtisodi.

2.6. Few-shot (misol bilan)

Modelga misol ko'rsatish:

Kirish: "yaxshi" → Chiqish: "ijobiy"
Kirish: "yomon" → Chiqish: "salbiy"
Kirish: "ajoyib" → Chiqish:        (model to'ldiradi)

Few-shot (bir necha misol) — promptda misollar ko'rsatib, modelga vazifani o'rgatish (o'qitmasdan!): bir necha "kirish → chiqish" misoli, keyin yangi kirish. Model naqshni tushunib davom etadi. Zero-shot (misolsiz — faqat ko'rsatma), few-shot (misol bilan — aniqroq). Bu LLM ning kuchi: kontekstdan o'rganish (in-context learning — parametr o'zgarmaydi, promptdan). Misollar javob sifatini oshiradi.

2.7. API xavfsizligi (kalit)

API kalitini himoya:

python
import os
api_key = os.environ["OPENAI_API_KEY"]   # muhit o'zgaruvchisi
# kalitni KODGA yozMANG (git'ga tushadi!)
# .env fayl (gitignore), muhit o'zgaruvchisi

API xavfsizligi — API kaliti maxfiy (kim bilsa, sizning hisobingizdan foydalanadi — pul): kodga yozMANG (git'ga tushadi — o'g'rilanadi), muhit o'zgaruvchisi (os.environ), .env fayl (gitignore — 19-qism). Bu 20.7 (auth), umumiy xavfsizlik tamoyili. Kalit sizib ketsa — darrov bekor qil (revoke). "Sirni kodga yozma" — API kaliti, parol, token. Xavfsizlik — API bilan ishlashda muhim.

2.8. LLM API — tayyor AI

LLM API — o'z model o'qitmasdan zamonaviy AI: klassik ML (25.1–25.9) modelni o'zingiz qurasiz/o'qitasiz (ma'lumot, vaqt, mahorat), LLM API tayyor kuchli modelni ishlatasiz (prompt bilan). Qachan qaysi: maxsus, aniq vazifa (jadval bashorati, kam ma'lumot) → klassik ML; matn, umumiy til vazifasi (chatbot, tahlil, generatsiya) → LLM API. LLM API tez (o'qitmasdan), lekin narx (token) va cheklov (kontekst, xato — "hallucination"). Zamonaviy AI ilovalari ko'pincha LLM API ustida (25.11 RAG). "Tayyor modeldan foydalan".

3. Tez ma'lumotnoma

python
import os

# real API (OpenAI misol):
# from openai import OpenAI
# client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
# resp = client.chat.completions.create(
#     model="gpt-4",
#     messages=[
#         {"role": "system", "content": "Sen yordamchisan"},
#         {"role": "user", "content": "Savol?"},
#     ],
#     temperature=0.0,
#     max_tokens=100,
# )
# javob = resp.choices[0].message.content

# xabarlar (rollar):
# system (sozlash) / user (savol) / assistant (javob)

# parametrlar:
# temperature (0 aniq, 1 ijodiy) · max_tokens (uzunlik)

# xavfsizlik:
api_key = os.environ["OPENAI_API_KEY"]   # kodga yozMANG

# few-shot: promptda misollar (kirish→chiqish)

LLM API xulosasi

LLM: tayyor katta model (API orqali) · messages: system/user/assistant
Prompt engineering: aniq so'rov · temperature (0-1) · token (narx, kontekst)
Few-shot (misol) · kalit maxfiy · o'qitmasdan AI

4. Batafsil misollar

Misollarda deterministik mock (soxta LLM funksiya) bilan sinaladi — real API kalit va tarmoq talab qiladi. Namunalar so'rov/javob tuzilishini ko'rsatadi.

Misol 1 — Xabarlar va rollar

python
"""messages tuzilishi: system/user/assistant rollari; suhbat qurish."""

import warnings
warnings.filterwarnings("ignore")


def build_messages(system: str, user: str) -> list:
    return [
        {"role": "system", "content": system},
        {"role": "user", "content": user},
    ]


def main() -> None:
    print("=== 1. Oddiy suhbat (system + user) ===")
    msgs = build_messages("Sen foydali yordamchisan", "Python nima?")
    for m in msgs:
        print(f"  [{m['role']}]: {m['content']}")

    print("\n=== 2. Ko'p bosqichli suhbat ===")
    suhbat = [
        {"role": "system", "content": "Qisqa javob ber"},
        {"role": "user", "content": "2+2?"},
        {"role": "assistant", "content": "4"},
        {"role": "user", "content": "Ko'paytir-chi?"},
    ]
    print(f"  xabarlar soni: {len(suhbat)}")
    print(f"  oxirgi savol: {suhbat[-1]['content']}")

    print("\n=== 3. System roli muhimligi ===")
    print("  system: model xulqini belgilaydi (kim, qanday)")
    print("  user: foydalanuvchi savoli")
    print("  assistant: model javobi")

    print("\n=== 4. Kontekst (suhbat tarixi) ===")
    print(f"  model barcha xabarlarni ko'radi (kontekst)")
    print("  ⭐ messages — rolli xabarlar (system/user/assistant)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Oddiy suhbat (system + user) ===
  [system]: Sen foydali yordamchisan
  [user]: Python nima?

=== 2. Ko'p bosqichli suhbat ===
  xabarlar soni: 4
  oxirgi savol: Ko'paytir-chi?

=== 3. System roli muhimligi ===
  system: model xulqini belgilaydi (kim, qanday)
  user: foydalanuvchi savoli
  assistant: model javobi

=== 4. Kontekst (suhbat tarixi) ===
  model barcha xabarlarni ko'radi (kontekst)
  ⭐ messages — rolli xabarlar (system/user/assistant)

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

Misol 2 — Prompt engineering

python
"""prompt engineering: yomon vs yaxshi so'rov; aniqlik, format, kontekst."""

import warnings
warnings.filterwarnings("ignore")


def main() -> None:
    print("=== 1. Yomon prompt (noaniq) ===")
    yomon = "tahlil qil"
    print(f"  '{yomon}' — nima tahlil? qanday javob?")

    print("\n=== 2. Yaxshi prompt (aniq) ===")
    yaxshi = (
        "Quyidagi mijoz sharhini tahlil qil. "
        "Faqat 'ijobiy' yoki 'salbiy' deb javob ber. "
        "Sharh: 'Mahsulot ajoyib, tez yetkazildi!'"
    )
    print(f"  aniq: nima ({yaxshi[:30]}...), format (bir so'z)")

    print("\n=== 3. Prompt tarkibi ===")
    print("  vazifa: nima qilish (tahlil)")
    print("  format: javob shakli (ijobiy/salbiy)")
    print("  kontekst: ma'lumot (sharh matni)")

    print("\n=== 4. Nega muhim ===")
    print("  yomon so'rov → noaniq javob")
    print("  yaxshi so'rov → aniq, foydali javob")
    print("  ⭐ prompt engineering — so'rov sifati javob sifati")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Yomon prompt (noaniq) ===
  'tahlil qil' — nima tahlil? qanday javob?

=== 2. Yaxshi prompt (aniq) ===
  aniq: nima (Quyidagi mijoz sharhini tahlil...), format (bir so'z)

=== 3. Prompt tarkibi ===
  vazifa: nima qilish (tahlil)
  format: javob shakli (ijobiy/salbiy)
  kontekst: ma'lumot (sharh matni)

=== 4. Nega muhim ===
  yomon so'rov → noaniq javob
  yaxshi so'rov → aniq, foydali javob
  ⭐ prompt engineering — so'rov sifati javob sifati

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Few-shot va token

python
"""few-shot (misollar bilan prompt); token taxmini (narx/kontekst)."""

import warnings
warnings.filterwarnings("ignore")


def few_shot_prompt(misollar: list, savol: str) -> str:
    qatorlar = [f"Kirish: {k} -> Chiqish: {v}" for k, v in misollar]
    qatorlar.append(f"Kirish: {savol} -> Chiqish:")
    return "\n".join(qatorlar)


def token_taxmin(matn: str) -> int:
    return len(matn.split())     # taxminiy (real: tiktoken)


def main() -> None:
    print("=== 1. Few-shot prompt (misollar) ===")
    misollar = [("yaxshi", "ijobiy"), ("yomon", "salbiy"), ("zo'r", "ijobiy")]
    prompt = few_shot_prompt(misollar, "ajoyib")
    print(prompt)

    print("\n=== 2. Zero-shot vs few-shot ===")
    print("  zero-shot: misolsiz (faqat ko'rsatma)")
    print("  few-shot: misol bilan (aniqroq)")

    print("\n=== 3. Token taxmini ===")
    matn = "Bu bir necha so'zdan iborat matn"
    print(f"  '{matn}'")
    print(f"  taxminiy token: {token_taxmin(matn)}")

    print("\n=== 4. Token nega muhim ===")
    print("  narx: API token bo'yicha to'laydi")
    print("  kontekst: model max token ko'radi")
    print("  ⭐ few-shot (misol) + token (narx/cheklov)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Few-shot prompt (misollar) ===
Kirish: yaxshi -> Chiqish: ijobiy
Kirish: yomon -> Chiqish: salbiy
Kirish: zo'r -> Chiqish: ijobiy
Kirish: ajoyib -> Chiqish:

=== 2. Zero-shot vs few-shot ===
  zero-shot: misolsiz (faqat ko'rsatma)
  few-shot: misol bilan (aniqroq)

=== 3. Token taxmini ===
  'Bu bir necha so'zdan iborat matn'
  taxminiy token: 6

=== 4. Token nega muhim ===
  narx: API token bo'yicha to'laydi
  kontekst: model max token ko'radi
  ⭐ few-shot (misol) + token (narx/cheklov)

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

Misol 4 — Amaliy: LLM ilovasi (mock)

Real LLM ilova: sharh tahlili — prompt qurish, (mock) LLM chaqirish, javob qayta ishlash. Bu — LLM API ilovasining namunasi (deterministik mock bilan).

python
"""to'liq LLM ilova (mock): prompt qurish, mock LLM chaqirish, javobni qayta ishlash."""

import warnings
warnings.filterwarnings("ignore")


def mock_llm(messages: list, temperature: float = 0.0) -> str:
    """Deterministik soxta LLM — real API o'rniga (kalitsiz sinash)."""
    user = [m for m in messages if m["role"] == "user"][-1]["content"]
    # oddiy qoida asosida (mock) — real LLM bu naqshni o'zi tushunadi
    if "ajoyib" in user.lower() or "zo'r" in user.lower():
        return "ijobiy"
    if "yomon" in user.lower() or "yiqildi" in user.lower():
        return "salbiy"
    return "neytral"


def sharh_tahlil(sharh: str) -> str:
    messages = [
        {"role": "system", "content": "Sen sharh tahlilchisisan. Faqat ijobiy/salbiy/neytral javob ber."},
        {"role": "user", "content": f"Sharhni tahlil qil: '{sharh}'"},
    ]
    return mock_llm(messages, temperature=0.0)


def main() -> None:
    sharhlar = [
        "Mahsulot ajoyib, tavsiya qilamiz!",
        "Sifati yomon, xafa bo'ldim",
        "Oddiy mahsulot",
    ]

    print("=== 1. Sharhlarni tahlil (mock LLM) ===")
    natijalar = {}
    for sharh in sharhlar:
        tahlil = sharh_tahlil(sharh)
        natijalar[sharh[:25]] = tahlil
        print(f"  '{sharh[:30]}...' → {tahlil}")

    print("\n=== 2. Statistika ===")
    from collections import Counter
    sanoq = Counter(natijalar.values())
    print(f"  {dict(sanoq)}")

    print("\n=== 3. Ilova tuzilishi ===")
    print("  prompt qur → LLM chaqir → javob qayta ishla")

    print("\n=== 4. Real vs mock ===")
    print("  mock: deterministik (bu yerda sinash)")
    print("  real: OpenAI/Anthropic API (kalit, tarmoq)")
    print("  ⭐ LLM ilova — prompt + API + javob qayta ishlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Sharhlarni tahlil (mock LLM) ===
  'Mahsulot ajoyib, tavsiya qilam...' → ijobiy
  'Sifati yomon, xafa bo'ldim...' → salbiy
  'Oddiy mahsulot...' → neytral

=== 2. Statistika ===
  {'ijobiy': 1, 'salbiy': 1, 'neytral': 1}

=== 3. Ilova tuzilishi ===
  prompt qur → LLM chaqir → javob qayta ishla

=== 4. Real vs mock ===
  mock: deterministik (bu yerda sinash)
  real: OpenAI/Anthropic API (kalit, tarmoq)
  ⭐ LLM ilova — prompt + API + javob qayta ishlash

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'ni o'zi qurish kerak" API orqali tayyor
"Prompt muhim emas" So'rov sifati javob sifati
"LLM doim to'g'ri" Xato qiladi (hallucination)
"Token — texnik detal" Narx va kontekst
"temperature keraksiz" Aniqlik/ijod (0-1)
"Kalit kodga yozsa bo'ladi" Maxfiy (git'ga tushmasin)
"Few-shot = o'qitish" Kontekstdan (parametr o'zgarmaydi)
"LLM har muammoga" Maxsus vazifa — klassik ML

6. Keng tarqalgan xatolar va yechimlari

1. API kalitni kodga yozish

python
api_key = "sk-abc123..."   # ⚠️ git'ga tushadi (o'g'rilanadi)
api_key = os.environ["OPENAI_API_KEY"]   # ✅

2. Noaniq prompt

python
"tahlil qil"   # ⚠️ noaniq
"Faqat ijobiy/salbiy deb javob ber: ..."   # ✅ aniq

3. Aniqlik kerakda yuqori temperature

python
temperature=1.0   # faktik savolda (xilma-xil)   # ⚠️
temperature=0.0   # aniq, izchil                   # ✅

4. LLM javobiga ko'r-ko'rona ishonish

python
# javob — to'g'ri deb qabul                       # ⚠️ (hallucination)
# tekshir, tasdiqla (muhim holatda)                # ✅

5. Token/narxni e'tiborsiz

python
# uzun suhbat/hujjat (ko'p token — qimmat)        # ⚠️
# token hisobla, kontekstni qisqartir              # ✅

6. System rolisiz

python
messages = [{"role": "user", ...}]   # sozlashsiz   # ba'zan
# system bilan (model xulqi)                        # ✅

7. Kontekst oynasidan oshirish

python
# juda uzun suhbat (max token oshdi)               # ⚠️ xato
# eski xabarlarni qisqartir/xulosala               # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 25.1-dars (o'tilgan): ML — LLM ham model
  • 25.11-dars: RAG — LLM + ma'lumot manbai
  • 20-qism (o'tilgan): FastAPI — LLM API backend
  • 19-qism (o'tilgan): JSON — API so'rov/javob
  • 20.7-dars (o'tilgan): Auth — kalit xavfsizligi

8. Eng yaxshi amaliyotlar

  1. API kalit — muhit o'zgaruvchisi (kodga emas).

  2. Aniq prompt (vazifa, format, kontekst).

  3. Aniqlik — temperature=0; ijod — yuqori.

  4. Few-shot (misol) — aniq javob.

  5. Token kuzat (narx, kontekst).

  6. LLM javobini tekshir (hallucination).

  7. System rol — model xulqi.

  8. Maxsus vazifa — klassik ML (LLM emas).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # LLM nima?
2.  # API nima?
3.  # messages nima?
4.  # system rol nima?
5.  # prompt engineering nima?
6.  # temperature nima?
7.  # token nima?
8.  # kontekst oynasi nima?
9.  # few-shot nima?
10. # zero-shot nima?
11. # API kalit qayerda?
12. # hallucination nima?
Javoblar
  1. Katta til modeli (GPT, Claude)
  2. Modelga so'rov yuborib javob olish
  3. Suhbat (rolli xabarlar)
  4. Model xulqini belgilash
  5. Aniq, yaxshi so'rov yozish
  6. Tasodifiylik (0 aniq, 1 ijodiy)
  7. Matn birligi (narx, cheklov)
  8. Model ko'ra oladigan max token
  9. Misollar bilan prompt
  10. Misolsiz (faqat ko'rsatma)
  11. Muhit o'zgaruvchisi (kodga emas)
  12. Model'ning noto'g'ri/soxta javobi

Vazifa 2: Xatolarni tuzating

python
1.  api_key = "sk-abc123"                # os.environ

2.  "tahlil qil"                          # aniq prompt

3.  temperature=1.0   # faktik savol      # 0.0

4.  # LLM javobi — to'g'ri                # tekshir

5.  # uzun suhbat (ko'p token)            # qisqartir
Javoblar
python
1.  api_key = os.environ["OPENAI_API_KEY"]

2.  "Faqat ijobiy/salbiy deb javob ber: ..."

3.  temperature=0.0

4.  # javobni tekshir (hallucination)

5.  # token hisobla, kontekstni qisqartir

Vazifa 3: Messages

Suhbat:

  1. system + user
  2. Ko'p bosqichli
  3. Rollar
  4. Kontekst

Vazifa 4: Prompt

Engineering:

  1. Yomon vs yaxshi
  2. Aniqlik
  3. Format
  4. Kontekst

Vazifa 5: Few-shot/token

LLM:

  1. Few-shot
  2. Zero-shot
  3. Token
  4. Narx

Vazifa 6: Ilova

Mock LLM:

  1. Prompt
  2. Chaqirish
  3. Javob
  4. Statistika

Vazifa 7: O'ylash

LLM API o'z model o'qitmasdan (25.1–25.9) zamonaviy AI beradi — tayyor kuchli modelni prompt bilan ishlatasiz. Bu klassik ML (model qurish) va LLM API (tayyor model) orasidagi tanlovni keltirib chiqaradi. Nima uchun "prompt engineering — kod yozmasdan model'ni boshqarish" yangi mahorat, va nega LLM API tez (o'qitmasdan), lekin cheklovlari (narx, hallucination, kontekst) bor — qachan klassik ML, qachan LLM API?

Javob

Qisqa javob: LLM API — tayyor kuchli modelni prompt (so'rov) bilan ishlatish (o'qitmasdan): prompt engineering yangi mahorat, chunki model'ni kod yozmasdan (o'qitmasdan, parametr o'zgartmasdan) so'rov bilan boshqarasiz — natija so'rov sifatiga bog'liq. LLM API tez (o'qitmasdan — daqiqalarda ishlaydi, klassik ML — haftalar), lekin cheklovlari: narx (token bo'yicha — ko'p so'rov qimmat), hallucination (model ishonchli ko'rinadigan soxta javob — tekshirish kerak), kontekst oynasi (cheklangan matn), maxsus vazifaga kam (aniq jadval bashorati — klassik ML aniqroq). Qachan qaysi: matn, umumiy til vazifasi (chatbot, tahlil, generatsiya, tarjima) → LLM API (tez, kuchli); maxsus, aniq, tuzilgan vazifa (jadval bashorati, kam ma'lumot, tushuntirish kerak) → klassik ML. Ko'p zamonaviy ilova LLM API ustida (25.11 RAG). "To'g'ri vosita to'g'ri vazifaga" — LLM bolg'a, lekin hamma narsa mix emas.

1. Prompt engineering — yangi mahorat

Klassik ML: kod + o'qitish. LLM API: prompt (so'rov) — kod yozmasdan, o'qitmasdan model'ni boshqarish. Natija prompt sifatiga bog'liq.

2. LLM API tez, lekin cheklovlari

Afzallik Cheklov
Tez (o'qitmasdan) Narx (token)
Kuchli (katta model) Hallucination (soxta javob)
Umumiy (til vazifa) Kontekst oynasi
Oson (prompt) Maxsus vazifaga kam

3. Qachan qaysi

  • LLM API: matn, til, chatbot, tahlil, generatsiya (umumiy)
  • Klassik ML: jadval bashorati, aniq vazifa, kam ma'lumot, tushuntirish

4. Hallucination xavfi

LLM ishonchli ko'rinadigan soxta javob berishi mumkin (faktni o'ylab topadi). Muhim holatda tekshirish kerak (25.11 RAG — manbaga bog'lash).

5. Muhandislik saboqlari

  1. Prompt engineering — kod yozmasdan boshqarish
  2. LLM API tez, lekin cheklovlari (narx, hallucination)
  3. Matn/til → LLM; maxsus → klassik ML
  4. To'g'ri vosita to'g'ri vazifaga

6. Xulosa

  1. LLM API — tayyor model (prompt bilan)
  2. Prompt engineering — yangi mahorat
  3. Tez, lekin cheklovlari
  4. Vazifaga qarab (LLM vs klassik ML)

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda LLM API bilan ishlashni o'rgandik.

Eng muhim uch fikr:

  1. LLM, API va xabarlar. LLM (Large Language Model) — milliardlab parametr, ulkan matn ma'lumotda o'qitilgan model (GPT, Claude) — o'zingiz qurmasdan API orqali ishlatasiz. Xabarlar (messages) — suhbat, har biri rol bilan: system (model'ni sozlash — kim, qanday javob), user (savol), assistant (model javobi). Suhbat davomida xabarlar to'planadi (kontekst). System muhim (model xulqini belgilaydi). Bu chat formati — LLM API asosi.

  2. Prompt engineering va parametrlar. Prompt engineering — modelga aniq, yaxshi so'rov (natija so'rovga bog'liq): aniq (nima kerak), format (javob shakli), kontekst (ma'lumot), misol (few-shot). "So'rov sifati — javob sifati". Parametrlar: temperature (tasodifiylik — 0 aniq/izchil: faktik, kod; 1+ ijodiy: hikoya), max_tokens (uzunlik). Few-shot — promptda misollar (kirish → chiqish) bilan vazifani o'rgatish (kontekstdan o'rganish — parametr o'zgarmaydi). Token — matn birligi (narx: API token bo'yicha; kontekst oynasi: max token).

  3. Xavfsizlik va vosita tanlovi. API kalit maxfiy — kodga yozMANG (git'ga tushadi, o'g'rilanadi), muhit o'zgaruvchisi (os.environ), .env (gitignore). LLM API — o'z model o'qitmasdan zamonaviy AI: tez (o'qitmasdan), lekin cheklovlari (narx — token; hallucination — soxta javob, tekshirish kerak; kontekst oynasi). Qachan qaysi: matn, umumiy til vazifasi (chatbot, tahlil, generatsiya) → LLM API; maxsus, aniq, tuzilgan vazifa (jadval bashorati, kam ma'lumot) → klassik ML (25.1–25.9). Prompt engineering — kod yozmasdan model'ni boshqarish (yangi mahorat). "To'g'ri vosita to'g'ri vazifaga" — LLM bolg'a, lekin hamma narsa mix emas. Zamonaviy AI ilovalari ko'pincha LLM API ustida (25.11 RAG).

Keyingi darsda RAG tizimi qurish ni o'rganamiz: LLM'ni o'z ma'lumot manbaiga (hujjat, baza) bog'lash — model bilmagan (yoki yangi) ma'lumotga javob berish, hallucinationni kamaytirish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
25.10-dars: LLM API bilan ishlash — IlmHamroh