IlmHamroh
Python kursi/ML va AI2/12-dars15 daqiqa
Mundarija (22)

25.2-dars: scikit-learn — birinchi model

25-QISM — ML VA AI · 2-dars

1. Kirish va motivatsiya

25.1 da ML tushunchasini ko'rdik. Endi amaliy model quramiz: real ma'lumotda o'qitish, bashorat, aniqlik. Lekin muhim savol: model yangi ma'lumotda qancha yaxshi ishlaydi? Agar o'qitgan ma'lumotda test qilsak — aldanamiz (model o'sha ma'lumotni "yodlagan"). Model ko'rmagan ma'lumotda sinash kerak.

scikit-learn — Python'ning asosiy ML kutubxonasi: yuzlab model (klassifikatsiya, regressiya, guruhlash), bir xil API (fit/predict/score), ma'lumot tayyorlash. Eng muhim amaliyot: o'qitish/test bo'lish (train_test_split) — ma'lumotni o'qitish (train) va sinov (test) qismlarga bo'lish; model train'da o'rganadi, test'da baholanadi (ko'rmagan ma'lumot). Bu haqiqiy aniqlikni o'lchaydi (yodlash emas). scikit-learn — ML boshlovchisining birinchi vositasi.

Real vaziyat. Bir jamoa model qurdi — o'qitgan ma'lumotda 99% aniq! Xursand bo'ldi. Lekin real ishda 60% edi. Sabab: model ma'lumotni yodlagan (overfitting), yangi ma'lumotda ishlamasdi. train_test_split qo'llandi: test'da (ko'rmagan) 75% — haqiqiy aniqlik. Model tuzatildi. O'qitish/test bo'lish — ishonchli ML ning asosi.

Bu darsda scikit-learn bilan birinchi real modelni quramiz.

Bu darsda:

  • scikit-learn API (fit/predict/score)
  • O'qitish/test bo'lish (train_test_split)
  • Datasetlar (load_iris)
  • Model o'qitish va bashorat
  • Aniqlikni o'lchash (accuracy)
  • Model tanlovi
  • Overfitting (yodlash)
  • Amaliy: gul tasnifi

ℹ Misollarda scikit-learn (random_state=42) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. scikit-learn API

Barcha model — bir xil API:

python
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
model.fit(X_train, y_train)      # o'qitish
model.predict(X_test)            # bashorat
model.score(X_test, y_test)      # aniqlik

scikit-learn API — barcha model bir xil (izchil): fit(X, y) (o'qitish), predict(X) (bashorat), score(X, y) (baholash). Model almashtirish oson (DecisionTreeClassifier → LogisticRegression — bir xil API). Bu ML ni osonlashtiradi: bir kod, ko'p model. random_state=42 — takrorlanuvchi natija (tasodifiylikni qotirish). scikit-learn — izchil va sodda.

2.2. O'qitish/test bo'lish

Ma'lumotni ikki qismga:

python
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)
# 70% o'qitish, 30% test (ko'rmagan ma'lumot)

O'qitish/test bo'lish (train_test_split) — ma'lumotni o'qitish (train — model o'rganadi) va test (model ko'rmaydi — baholash) qismlarga bo'lish. test_size=0.3 (30% test), random_state=42 (takrorlanuvchi). Sabab: model o'qitgan ma'lumotni "yodlashi" mumkin — ko'rmagan (test) ma'lumotda haqiqiy aniqlik. Bu ML ning eng muhim amaliyoti. Bo'lmasdan baholash — aldanish.

2.3. Datasetlar (load_iris)

scikit-learn tayyor datasetlar:

python
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
# X: gul o'lchovlari (150 namuna, 4 xususiyat)
# y: gul turi (0, 1, 2 — 3 sinf)

scikit-learn tayyor datasetlar (o'rganish uchun): load_iris (gul turi — 150 namuna, 4 o'lchov, 3 sinf — klassik), load_diabetes (regressiya), load_digits (raqam rasmi). return_X_y=True — X (feature) va y (label) alohida. Bu o'rganishda qulay (real, toza ma'lumot). Real loyihada — o'z ma'lumotingiz (CSV, 24.6). O'rganish uchun tayyor.

2.4. Model o'qitish va bashorat

To'liq jarayon:

python
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)          # train'da o'rgan
pred = model.predict(X_test)         # test'da bashorat
# pred: har test namunasi uchun bashorat qilingan sinf

Jarayon: fit(X_train, y_train) (train'da o'rgan — faqat train), predict(X_test) (test'da bashorat — ko'rmagan ma'lumot). pred — har test namunasi uchun bashorat. Muhim: model faqat train'da o'rganadi (test'ni ko'rmaydi — halol baholash). Keyin bashoratni haqiqiy javob (y_test) bilan solishtirib aniqlikni o'lchaymiz.

2.5. Aniqlikni o'lchash (accuracy)

Model qancha yaxshi:

python
from sklearn.metrics import accuracy_score
pred = model.predict(X_test)
accuracy_score(y_test, pred)     # to'g'ri bashorat ulushi
model.score(X_test, y_test)      # bir xil (qulay)

Aniqlik (accuracy) — to'g'ri bashorat ulushi: accuracy_score(y_test, pred) (haqiqiy vs bashorat) yoki model.score(X_test, y_test) (bir xil). 1.0 = 100% to'g'ri, 0.75 = 75%. Test'da o'lchash muhim (train'da — aldanish). Aniqlik — klassifikatsiya asosiy o'lchovi (regressiyada R^2, 25.4). Bu model qancha ishonchli. Baholash — ML ning muhim qismi.

2.6. Model tanlovi

Turli model, bir xil API:

python
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
# bir xil fit/predict/score — almashtirish oson

scikit-learn ko'p model (bir xil API): DecisionTreeClassifier (qaror daraxti — tushunarli), LogisticRegression (chiziqli — tez), RandomForestClassifier (ko'p daraxt — kuchli, 25.6), KNeighborsClassifier (qo'shni). Har biri fit/predict/score — almashtirish oson (bir qator). Turli model turli ma'lumotga mos — sinab ko'rish (qaysi yaxshiroq). Model tanlovi — tajriba.

2.7. Overfitting (yodlash)

Model ma'lumotni yodlasa:

Overfitting: train'da 99%, test'da 60%
   (model ma'lumotni yodlagan, umumlashtirmagan)
Yaxshi model: train'da 90%, test'da 88%
   (yaqin — umumlashtirgan)

Overfitting (ortiqcha moslashish) — model o'qitgan ma'lumotni yodlagan (naqshni emas): train'da yuqori, test'da past aniqlik. Sabab: model juda murakkab (ma'lumotga aniq moslashgan) yoki kam ma'lumot. Belgi: train >> test aniqlik. Yechim: soddaroq model, ko'proq ma'lumot, tartiblash (regularization). Aksincha underfitting (kam o'rganish — ikkalasida past). Maqsad: umumlashtirish (yangi ma'lumotda ishlash).

2.8. ML ish oqimi

scikit-learn ML ish oqimi: 1) ma'lumot (feature X, label y), 2) bo'lish (train_test_split — train/test), 3) model tanla, 4) o'qit (fit(X_train, y_train)), 5) bashorat (predict(X_test)), 6) bahola (score(X_test, y_test) — test'da), 7) yaxshila (model, ma'lumot). Muhim: test'da baholash (train emas — overfittingni sezish). Bu izchil jarayon — barcha ML loyihasining asosi. 25.3–25.6 shu ustida quriladi.

3. Tez ma'lumotnoma

python
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 1. ma'lumot:
X, y = load_iris(return_X_y=True)

# 2. bo'lish (train/test):
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 3-4. model o'qitish:
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)

# 5. bashorat:
pred = model.predict(X_test)

# 6. baholash (TEST'da):
accuracy_score(y_test, pred)
model.score(X_test, y_test)

# overfitting: train >> test → yodlagan

scikit-learn xulosasi

API: fit/predict/score (barcha model) · train_test_split: train/test bo'lish
Test'da baholash (train emas — aldanmaslik) · accuracy (to'g'ri ulush)
Overfitting: train>>test (yodlagan) · random_state: takrorlanuvchi

4. Batafsil misollar

Misollarda scikit-learn (random_state=42 — takrorlanuvchi) bilan sinaladi.

Misol 1 — O'qitish/test bo'lish

python
"""train_test_split: ma'lumotni train/test qismlarga; test — model ko'rmagan ma'lumot."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split


def main() -> None:
    print("=== 1. Dataset yuklash (iris) ===")
    X, y = load_iris(return_X_y=True)
    print(f"  namunalar: {X.shape[0]}, xususiyatlar: {X.shape[1]}")
    print(f"  sinflar: {sorted(set(int(v) for v in y))}")

    print("\n=== 2. train_test_split (70/30) ===")
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42
    )
    print(f"  train namunalari: {X_train.shape[0]}")
    print(f"  test namunalari: {X_test.shape[0]}")

    print("\n=== 3. Nega bo'lish kerak ===")
    print("  model train'da o'rganadi")
    print("  test'da baholanadi (ko'rmagan — halol)")

    print("\n=== 4. random_state (takrorlanuvchi) ===")
    print(f"  random_state=42 → har doim bir xil bo'lish")
    print(f"  test ulushi: {round(X_test.shape[0] / X.shape[0], 2)}")
    print("  ⭐ train_test_split — haqiqiy aniqlik uchun")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Dataset yuklash (iris) ===
  namunalar: 150, xususiyatlar: 4
  sinflar: [0, 1, 2]

=== 2. train_test_split (70/30) ===
  train namunalari: 105
  test namunalari: 45

=== 3. Nega bo'lish kerak ===
  model train'da o'rganadi
  test'da baholanadi (ko'rmagan — halol)

=== 4. random_state (takrorlanuvchi) ===
  random_state=42 → har doim bir xil bo'lish
  test ulushi: 0.3
  ⭐ train_test_split — haqiqiy aniqlik uchun

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

Misol 2 — Model o'qitish va baholash

python
"""fit (train'da o'rgan); predict (test'da bashorat); accuracy_score (test aniqlik)."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier


def main() -> None:
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    print("=== 1. Model o'qitish (fit) ===")
    model = DecisionTreeClassifier(random_state=42)
    model.fit(X_train, y_train)
    print("  model train'da o'rgandi")

    print("\n=== 2. Bashorat (predict) ===")
    pred = model.predict(X_test)
    print(f"  dastlabki 5 bashorat: {pred[:5].tolist()}")
    print(f"  haqiqiy 5: {y_test[:5].tolist()}")

    print("\n=== 3. Aniqlik (test'da) ===")
    acc = accuracy_score(y_test, pred)
    print(f"  test aniqligi: {round(acc, 3)}")

    print("\n=== 4. Train vs test (overfitting tekshiruvi) ===")
    train_acc = model.score(X_train, y_train)
    test_acc = model.score(X_test, y_test)
    print(f"  train: {round(train_acc, 3)}, test: {round(test_acc, 3)}")
    print(f"  yaqin → yaxshi umumlashtirgan")
    print("  ⭐ fit → predict → accuracy (test'da baholash)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Model o'qitish (fit) ===
  model train'da o'rgandi

=== 2. Bashorat (predict) ===
  dastlabki 5 bashorat: [1, 0, 2, 1, 1]
  haqiqiy 5: [1, 0, 2, 1, 1]

=== 3. Aniqlik (test'da) ===
  test aniqligi: 1.0

=== 4. Train vs test (overfitting tekshiruvi) ===
  train: 1.0, test: 1.0
  yaqin → yaxshi umumlashtirgan
  ⭐ fit → predict → accuracy (test'da baholash)

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

Misol 3 — Model tanlovi (taqqoslash)

python
"""turli model bir xil API: DecisionTree, LogisticRegression, RandomForest — taqqoslash."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier


def main() -> None:
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    print("=== 1. Uch model (bir xil API) ===")
    modellar = {
        "DecisionTree": DecisionTreeClassifier(random_state=42),
        "LogisticRegression": LogisticRegression(max_iter=1000, random_state=42),
        "RandomForest": RandomForestClassifier(random_state=42),
    }

    print("\n=== 2. Har birini o'qit va bahola ===")
    for nom, model in modellar.items():
        model.fit(X_train, y_train)
        acc = model.score(X_test, y_test)
        print(f"  {nom}: {round(acc, 3)}")

    print("\n=== 3. Model almashtirish oson ===")
    print("  bir xil fit/predict/score — bir qator o'zgarish")

    print("\n=== 4. Feature muhimligi (DecisionTree) ===")
    dt = modellar["DecisionTree"]
    print(f"  xususiyat muhimligi: {[round(float(x), 2) for x in dt.feature_importances_]}")
    print("  ⭐ turli model — sinab, eng yaxshini tanla")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Uch model (bir xil API) ===

=== 2. Har birini o'qit va bahola ===
  DecisionTree: 1.0
  LogisticRegression: 1.0
  RandomForest: 1.0

=== 3. Model almashtirish oson ===
  bir xil fit/predict/score — bir qator o'zgarish

=== 4. Feature muhimligi (DecisionTree) ===
  xususiyat muhimligi: [0.0, 0.02, 0.89, 0.09]
  ⭐ turli model — sinab, eng yaxshini tanla

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

Misol 4 — Amaliy: gul tasnifi (to'liq)

Real ML: gul o'lchovlaridan turini bashorat — to'liq jarayon (bo'lish, o'qitish, baholash, bashorat). Bu — birinchi amaliy ML modelining namunasi.

python
"""to'liq ML: iris, bo'lish, o'qitish, baholash, yangi gul bashorati."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split


def main() -> None:
    print("=== 1. Ma'lumot (iris) ===")
    data = load_iris()
    X, y = data.data, data.target
    print(f"  {X.shape[0]} gul, {X.shape[1]} o'lchov")
    print(f"  turlar: {list(data.target_names)}")

    print("\n=== 2. Bo'lish va o'qitish ===")
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    model = RandomForestClassifier(random_state=42)
    model.fit(X_train, y_train)
    print(f"  {X_train.shape[0]} gul bilan o'qitildi")

    print("\n=== 3. Baholash (test'da) ===")
    acc = model.score(X_test, y_test)
    print(f"  test aniqligi: {round(acc, 3)}")

    print("\n=== 4. Yangi gul bashorati ===")
    yangi_gul = [[5.1, 3.5, 1.4, 0.2]]     # o'lchovlar
    bashorat = model.predict(yangi_gul)[0]
    print(f"  o'lchovlar {yangi_gul[0]} → tur: {data.target_names[bashorat]}")
    print("  ⭐ to'liq ML — ma'lumot → model → bashorat")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ma'lumot (iris) ===
  150 gul, 4 o'lchov
  turlar: [np.str_('setosa'), np.str_('versicolor'), np.str_('virginica')]

=== 2. Bo'lish va o'qitish ===
  105 gul bilan o'qitildi

=== 3. Baholash (test'da) ===
  test aniqligi: 1.0

=== 4. Yangi gul bashorati ===
  o'lchovlar [5.1, 3.5, 1.4, 0.2] → tur: setosa
  ⭐ to'liq ML — ma'lumot → model → bashorat

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
"Train'da baholash yetarli" Test'da (ko'rmagan)
"Yuqori train aniqlik — yaxshi" Test aniqlik muhim
"Bir model yetarli" Sinab taqqosla
"Overfitting yaxshi (99%)" Yodlash (test past)
"random_state keraksiz" Takrorlanuvchi natija
"Har model boshqa API" Bir xil (fit/predict/score)
"Test'ni o'qitishga" Test — faqat baholash
"Aniqlik — yagona o'lchov" Boshqa ham (25.4)

6. Keng tarqalgan xatolar va yechimlari

1. Train'da baholash

python
model.fit(X, y); model.score(X, y)   # ⚠️ aldanish
# train_test_split, test'da bahola     # ✅

2. Test'ni o'qitishga aralashtirish

python
model.fit(X_test, y_test)   # ⚠️ test o'qitishda
model.fit(X_train, y_train)   # ✅ faqat train

3. random_statesiz (takrorlanmaydi)

python
train_test_split(X, y)   # har safar boshqa   # ⚠️
train_test_split(X, y, random_state=42)        # ✅

4. Overfittingni sezmaslik

python
# train 99%, test 60% — e'tiborsiz            # ⚠️
# train vs test taqqosla (yaqinmi?)            # ✅

5. X shakl noto'g'ri

python
model.predict([5.1, 3.5])   # 1D               # ⚠️
model.predict([[5.1, 3.5]])   # 2D              # ✅

6. Bir model bilan cheklanish

python
# faqat DecisionTree                            # ⚠️
# bir necha sinab taqqosla                       # ✅

7. Ma'lumotni tozalamaslik

python
model.fit(iflos_X, y)   # yomon model           # ⚠️
# avval tozala 24.8-bob                            # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 25.1-dars (o'tilgan): ML tushunchasi — asos
  • 25.3-dars: Ma'lumot tayyorlash — model uchun
  • 25.4-dars: Model baholash — chuqurroq
  • 25.6-dars: Ansambl — RandomForest
  • 24-qism (o'tilgan): Ma'lumot tahlili — ML ma'lumoti

8. Eng yaxshi amaliyotlar

  1. Doim train_test_split (test'da bahola).

  2. Test'ni faqat baholashga (o'qitishga emas).

  3. random_state (takrorlanuvchi).

  4. Train vs test taqqosla (overfitting).

  5. Bir necha model sinab taqqosla.

  6. X 2D shakl (namuna × feature).

  7. Ma'lumotni avval tozala 24.8-bob.

  8. Aniqlik + boshqa o'lchov 25.4-bob.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # scikit-learn API nima?
2.  # train_test_split nima?
3.  # nega bo'lish kerak?
4.  # test_size nima?
5.  # random_state nima?
6.  # fit nima?
7.  # predict nima?
8.  # accuracy nima?
9.  # qayerda baholash?
10. # overfitting nima?
11. # overfitting belgisi?
12. # model almashtirish oson-mi?
Javoblar
  1. Bir xil fit/predict/score (barcha model)
  2. Ma'lumotni train/test qismlarga bo'lish
  3. Ko'rmagan ma'lumotda baholash (halol)
  4. Test ulushi (0.3 = 30%)
  5. Takrorlanuvchi natija
  6. O'qitish (train'da)
  7. Bashorat (test'da)
  8. To'g'ri bashorat ulushi
  9. Test'da (train emas)
  10. Model ma'lumotni yodlagan
  11. Train >> test aniqlik
  12. Ha (bir xil API)

Vazifa 2: Xatolarni tuzating

python
1.  model.fit(X, y); model.score(X, y)   # test'da

2.  model.fit(X_test, y_test)            # X_train

3.  train_test_split(X, y)               # random_state

4.  model.predict([5.1, 3.5])            # 2D

5.  # train 99%, test 60% e'tiborsiz      # taqqosla
Javoblar
python
1.  X_tr, X_te, ... = train_test_split(...); model.score(X_te, y_te)

2.  model.fit(X_train, y_train)

3.  train_test_split(X, y, random_state=42)

4.  model.predict([[5.1, 3.5]])

5.  # train vs test taqqosla (overfitting)

Vazifa 3: Bo'lish

train/test:

  1. Dataset
  2. train_test_split
  3. test_size
  4. random_state

Vazifa 4: O'qitish

Model:

  1. fit (train)
  2. predict (test)
  3. accuracy
  4. Train vs test

Vazifa 5: Model tanlovi

Taqqoslash:

  1. Uch model
  2. Bir xil API
  3. Bahola
  4. Eng yaxshi

Vazifa 6: To'liq ML

Jarayon:

  1. Ma'lumot
  2. Bo'lish, o'qitish
  3. Baholash
  4. Bashorat

Vazifa 7: O'ylash

ML ning eng muhim amaliyoti — o'qitish/test bo'lish: model ko'rmagan ma'lumotda (test) baholanadi. Nima uchun "train'da baholash aldanish" va nega "umumlashtirish" (generalization — yangi ma'lumotda ishlash) ML ning asosiy maqsadi — model yodlash (overfitting) va o'rganish (umumlashtirish) orasidagi farq nimada?

Javob

Qisqa javob: ML ning maqsadi — yangi (ko'rmagan) ma'lumotda ishlash (umumlashtirish — generalization), o'qitgan ma'lumotni takrorlash emas. "Train'da baholash aldanish", chunki model o'qitgan ma'lumotni yodlashi mumkin (naqshni emas) — train'da 99%, lekin yangi ma'lumotda 60% (overfitting). Shuning uchun test'da (ko'rmagan ma'lumot) baholash — haqiqiy aniqlik. Umumlashtirish ML ning asosiy maqsadi, chunki: real ishda model yangi ma'lumotga duch keladi (o'qitgan emas) — yodlagan model foydasiz. Overfitting (yodlash) — ma'lumotga aniq moslashgan (train yuqori, test past); umumlashtirish — naqshni o'rgangan (train ≈ test, yangi ma'lumotda ishlaydi). Farq: yodlash — xotira, o'rganish — naqsh. "Model o'qitgan ma'lumotni takrorlasa — foydasiz; yangiga ishlasa — foydali".

1. Umumlashtirish — maqsad

ML real ishda yangi ma'lumotga ishlaydi (o'qitgan emas). Maqsad — naqshni o'rganib, yangiga qo'llash (umumlashtirish), o'qitganni takrorlash emas.

2. Nega train'da aldanish

Model train'ni ko'rdi — uni takrorlashi oson (yodlash). Train aniqlik — model qancha yodlagan, yangiga qancha ishlashi emas. Test — halol.

3. Yodlash vs o'rganish

Overfitting (yodlash) Umumlashtirish (o'rganish)
Ma'lumotni yodlagan Naqshni o'rgangan
Train yuqori, test past Train ≈ test
Yangida yomon Yangida yaxshi
Xotira Naqsh

4. Test'da baholash

Ko'rmagan ma'lumot (test) — real vaziyat modeli (yangi ma'lumot). Test aniqlik — haqiqiy unumdorlik.

5. Muhandislik saboqlari

  1. ML maqsadi — umumlashtirish (yangi ma'lumot)
  2. Train'da baholash — aldanish (yodlash)
  3. Test'da (ko'rmagan) — haqiqiy
  4. Yodlash (overfitting) ≠ o'rganish

6. Xulosa

  1. Umumlashtirish — ML asosiy maqsadi
  2. Train'da baholash aldanish
  3. Test'da (ko'rmagan) bahola
  4. Overfitting (yodlash) — asosiy xavf

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda scikit-learn bilan birinchi modelni qurdik.

Eng muhim uch fikr:

  1. scikit-learn API va o'qitish/test bo'lish. scikit-learn — barcha model bir xil API: fit(X, y) (o'qitish), predict(X) (bashorat), score(X, y) (baholash) — model almashtirish oson. train_test_split — ma'lumotni o'qitish (train — model o'rganadi) va test (model ko'rmaydi — baholash) qismlarga bo'lish: test_size=0.3, random_state=42 (takrorlanuvchi). Bu ML ning eng muhim amaliyoti — model train'ni "yodlashi" mumkin, shuning uchun ko'rmagan (test) ma'lumotda haqiqiy aniqlik.

  2. Jarayon va baholash. ML ish oqimi: ma'lumot (X, y) → bo'lish (train_test_split) → model tanla → fit(X_train, y_train) (faqat train'da o'rgan) → predict(X_test) (test'da bashorat) → bahola (accuracy_score(y_test, pred) yoki score — test'da). Aniqlik (accuracy) — to'g'ri bashorat ulushi. scikit-learn ko'p model (DecisionTree, LogisticRegression, RandomForest — bir xil API) — sinab, eng yaxshini tanla. Tayyor datasetlar (load_iris) — o'rganish uchun.

  3. Overfitting va umumlashtirish. Overfitting (yodlash) — model o'qitgan ma'lumotni yodlagan (naqshni emas): train'da yuqori, test'da past aniqlik (train >> test — belgi). ML ning maqsadi — umumlashtirish (generalization — yangi, ko'rmagan ma'lumotda ishlash), o'qitganni takrorlash emas. Real ishda model yangi ma'lumotga duch keladi — yodlagan model foydasiz. Shuning uchun test'da baholash (train — aldanish), train vs test taqqoslash (yaqinmi?). Yechim: soddaroq model, ko'proq ma'lumot. "Model yodlasa — foydasiz; naqshni o'rgansa — foydali". Bu ML ning izchil jarayoni (25.3–25.6 asosi).

Keyingi darsda ma'lumotni tayyorlash ni o'rganamiz: ML uchun ma'lumot tozalash, kodlash (kategoriya → son), masshtablash (scaling), feature yaratish — modelga tayyorlash (ma'lumot sifati model sifati).

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
25.2-dars: scikit-learn — birinchi model — IlmHamroh