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

25.6-dars: Ansambl modellar

25-QISM — ML VA AI · 6-dars

1. Kirish va motivatsiya

25.2–25.5 da bitta model qurdik (bir daraxt, bir regressiya). Bitta model cheklangan — bir xatoga moyil, ma'lumotning bir tomonini ko'radi. Lekin ko'p model birga ishlasa? "Ko'pchilik aqli" — bir necha model bashoratini birlashtirib, har birining xatosini kamaytirish. Bu — ansambl (ensemble) modellar.

Ansambl modellar — ko'p modelni birlashtirib kuchliroq model: Random Forest (ko'p qaror daraxti — har biri ma'lumot bo'lagida, ovoz berish), Gradient Boosting (ketma-ket — har model oldingining xatosini tuzatadi), Voting (turli model ovozi). Sabab: har model boshqacha xato qiladi — birlashtirganda xatolar o'zaro yo'qoladi (ko'pchilik to'g'ri). Ansambl — Kaggle (ML musobaqa) g'oliblari va real loyihalarning eng kuchli usuli. "Ko'pchilik bitta'dan aqlli".

Real vaziyat. Bir bashorat modeli 92% edi (bitta daraxt). Random Forest'ga o'tdi (100 daraxt) — 96%. Sabab: bitta daraxt ma'lumotga ortiqcha moslashdi (overfitting), 100 daraxt o'rtachasi barqaror (har birining xatosi yo'qoldi). Ansambl — kuch va barqarorlik. Ko'p model bitta'dan yaxshi.

Bu darsda ansambl modellarni o'rganamiz.

Bu darsda:

  • Ansambl nima (ko'pchilik aqli)
  • Random Forest (bagging)
  • Gradient Boosting (boosting)
  • Voting (ovoz berish)
  • Feature muhimligi
  • Ansambl afzalliklari
  • Overfitting va ansambl
  • Amaliy: model taqqoslash

ℹ Misollarda scikit-learn bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. Ansambl nima

Ko'p model birga kuchliroq:

Bitta model: bir xato, cheklangan ko'rinish
Ansambl: ko'p model → ovoz/o'rtacha → kuchliroq
   har model boshqacha xato → birlashtirganda yo'qoladi

Ansambl — ko'p modelni birlashtirib kuchliroq model: har model bashorati, keyin ovoz (klassifikatsiya) yoki o'rtacha (regressiya). Sabab: har model boshqacha xato qiladi — birlashtirganda xatolar o'zaro yo'qoladi (ko'pchilik to'g'ri). "Ko'pchilik aqli" — bitta ekspertdan ko'p ekspert yaxshiroq. Ikki asosiy usul: bagging (parallel — Random Forest), boosting (ketma-ket — Gradient Boosting).

2.2. Random Forest (bagging)

Ko'p daraxt, parallel:

python
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
# 100 daraxt, har biri ma'lumot bo'lagi + feature bo'lagida
# bashorat: ko'pchilik ovozi

Random Forest (tasodifiy o'rmon) — bagging usuli: ko'p qaror daraxti (n_estimators=100), har biri ma'lumotning bo'lagi va feature bo'lagida o'qiydi (tasodifiy — shuning uchun har xil). Bashorat: ko'pchilik ovozi (klassifikatsiya) yoki o'rtacha (regressiya). Afzallik: kuchli, overfitting'ga chidamli (ko'p daraxt o'rtachasi barqaror), sozlash oson. Eng ko'p ishlatiladigan ansambl — "ishonchli ishchi ot".

2.3. Gradient Boosting (boosting)

Ketma-ket xato tuzatish:

python
from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier(random_state=42)
gb.fit(X_train, y_train)
# har model oldingining XATOsini tuzatadi (ketma-ket)

Gradient Boosting — boosting usuli: modellar ketma-ket (parallel emas), har model oldingining xatosini tuzatadi (qiyin namunalarga e'tibor). Random Forest'dan farq: parallel (bagging) vs ketma-ket (boosting). Afzallik: ko'pincha eng aniq (Kaggle g'oliblari — XGBoost, LightGBM). Kamchilik: sozlash nozik, sekin o'qitish, overfitting'ga moyilroq. Yuqori aniqlik uchun.

2.4. Voting (ovoz berish)

Turli model ovozi:

python
from sklearn.ensemble import VotingClassifier
vc = VotingClassifier([
    ("dt", DecisionTreeClassifier()),
    ("lr", LogisticRegression()),
    ("rf", RandomForestClassifier()),
], voting="hard")
# turli model ovozi — ko'pchilik

Voting — turli modellar (daraxt, regressiya, o'rmon) bashoratini birlashtirish: voting="hard" (ko'pchilik ovozi — 2/3 model "spam" desa spam), voting="soft" (ehtimol o'rtachasi). Sabab: turli model turli xato qiladi — birlashtirganda kuchliroq. Random Forest bir xil model (daraxt), Voting har xil model. Bu turli yondashuvlarni birlashtiradi. Turli-tumanlik (diversity) — ansambl kuchi.

2.5. Feature muhimligi

Qaysi feature muhim:

python
rf.feature_importances_
# har feature qancha muhim (0-1)
# eng muhim feature'larni ko'rsatadi

Feature muhimligi (feature_importances_) — ansambl (ayniqsa Random Forest) qaysi feature bashoratda muhim ekanini ko'rsatadi (0–1, yig'indi 1). Bu ikki foyda: tushunish (nima muhim — uy narxida maydonmi yoki joylashuvmi), feature tanlovi (25.5 — muhimlarini saqla, keraksizni tashla). Bu ansamblning "qora quti" emasligini ko'rsatadi (qisman tushuntiriladi). Model va ma'lumotni tushunish.

2.6. Ansambl afzalliklari

Afzallik Tafsilot
Aniqroq Ko'p model > bitta
Barqaror Xatolar o'zaro yo'qoladi
Overfitting kam O'rtacha (RF)
Feature muhimligi Tushunarli

Ansambl afzalliklari: aniqroq (ko'p model bitta'dan yaxshi), barqaror (har model xatosi o'zaro yo'qoladi — kam dispersiya), overfitting'ga chidamli (Random Forest — o'rtacha), feature muhimligi (tushunish). Kamchilik: sekinroq (ko'p model), ko'proq xotira, kamroq tushunarli (bitta daraxtdan). Ko'p holda afzalliklar ustun — ansambl real ML'ning asosiy tanlovi.

2.7. Overfitting va ansambl

Ansambl overfitting'ni kamaytiradi (ayniqsa bagging — Random Forest): bitta daraxt ma'lumotga ortiqcha moslashadi (overfitting, 25.2), lekin 100 daraxt o'rtachasi barqaror (har birining xatosi o'zaro yo'qoladi). Bu "ko'pchilik aqli" ning matematik asosi: mustaqil xatolar o'rtachalaganda kamayadi. Lekin boosting (Gradient Boosting) overfitting'ga moyilroq (xatoni ketma-ket tuzatadi — ma'lumotni yodlashi mumkin) — ehtiyot (n_estimators, learning_rate sozlash). Bagging — xavfsiz, boosting — kuchli lekin nozik.

2.8. Ansambl — ko'pchilik aqli

Ansambl "ko'pchilik aqli" (wisdom of the crowd) tamoyiliga asoslanadi: ko'p mustaqil, xato qiluvchi model — birlashtirganda kuchli va aniq. Sharti: modellar turli-tuman bo'lishi (bir xil xato qilsa, birlashtirish foydasiz — har xil xato kerak). Random Forest turli-tumanlikni tasodif bilan (ma'lumot/feature bo'lagi), Voting har xil model bilan yaratadi. Bu inson jamiyatida ham (ko'p ekspert > bitta), ML'da ham ishlaydi. Ansambl — klassik ML'ning eng kuchli usuli (chuqur o'qitishdan oldin).

3. Tez ma'lumotnoma

python
from sklearn.ensemble import (RandomForestClassifier, GradientBoostingClassifier,
                             VotingClassifier)
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

# Random Forest (bagging — parallel):
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
rf.feature_importances_          # feature muhimligi

# Gradient Boosting (boosting — ketma-ket):
gb = GradientBoostingClassifier(random_state=42)

# Voting (turli model ovozi):
vc = VotingClassifier([
    ("dt", DecisionTreeClassifier()),
    ("lr", LogisticRegression(max_iter=5000)),
    ("rf", RandomForestClassifier()),
], voting="hard")

# regressiya: RandomForestRegressor, GradientBoostingRegressor

Ansambl xulosasi

Ko'p model birga kuchliroq (ko'pchilik aqli) · xatolar o'zaro yo'qoladi
Random Forest (bagging, parallel) · Gradient Boosting (boosting, ketma-ket)
Voting (turli model) · feature_importances_ · turli-tumanlik muhim

4. Batafsil misollar

Misollarda scikit-learn bilan sinaladi.

Misol 1 — Random Forest vs bitta daraxt

python
"""RandomForest (100 daraxt) vs bitta DecisionTree — ansambl aniqroq va barqaror."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier


def main() -> None:
    X, y = load_breast_cancer(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. Bitta daraxt ===")
    dt = DecisionTreeClassifier(random_state=42)
    dt.fit(X_train, y_train)
    print(f"  test aniqlik: {round(dt.score(X_test, y_test), 3)}")

    print("\n=== 2. Random Forest (100 daraxt) ===")
    rf = RandomForestClassifier(n_estimators=100, random_state=42)
    rf.fit(X_train, y_train)
    print(f"  test aniqlik: {round(rf.score(X_test, y_test), 3)}")

    print("\n=== 3. Daraxtlar soni ===")
    print(f"  RF daraxtlari: {len(rf.estimators_)}")

    print("\n=== 4. Nega RF yaxshiroq ===")
    print("  bitta daraxt — overfitting (ma'lumotga moslashgan)")
    print("  100 daraxt o'rtachasi — barqaror (xatolar yo'qoladi)")
    print("  ⭐ Random Forest — ko'p daraxt, ko'pchilik ovozi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Bitta daraxt ===
  test aniqlik: 0.942

=== 2. Random Forest (100 daraxt) ===
  test aniqlik: 0.971

=== 3. Daraxtlar soni ===
  RF daraxtlari: 100

=== 4. Nega RF yaxshiroq ===
  bitta daraxt — overfitting (ma'lumotga moslashgan)
  100 daraxt o'rtachasi — barqaror (xatolar yo'qoladi)
  ⭐ Random Forest — ko'p daraxt, ko'pchilik ovozi

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

Misol 2 — Boosting va Voting

python
"""GradientBoosting (ketma-ket); VotingClassifier (turli model ovozi) — taqqoslash."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier, VotingClassifier
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_breast_cancer(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. Gradient Boosting (ketma-ket) ===")
    gb = GradientBoostingClassifier(random_state=42)
    gb.fit(X_train, y_train)
    print(f"  aniqlik: {round(gb.score(X_test, y_test), 3)}")

    print("\n=== 2. Voting (turli model) ===")
    vc = VotingClassifier([
        ("dt", DecisionTreeClassifier(random_state=42)),
        ("lr", LogisticRegression(max_iter=5000, random_state=42)),
        ("rf", RandomForestClassifier(random_state=42)),
    ], voting="hard")
    vc.fit(X_train, y_train)
    print(f"  aniqlik: {round(vc.score(X_test, y_test), 3)}")

    print("\n=== 3. Bagging vs Boosting ===")
    print("  bagging (RF): parallel daraxtlar")
    print("  boosting (GB): ketma-ket xato tuzatish")

    print("\n=== 4. Voting mantiqi ===")
    print("  3 turli model ovozi — ko'pchilik")
    print("  turli-tumanlik — ansambl kuchi")
    print("  ⭐ boosting (ketma-ket), voting (turli model)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Gradient Boosting (ketma-ket) ===
  aniqlik: 0.959

=== 2. Voting (turli model) ===
  aniqlik: 0.982

=== 3. Bagging vs Boosting ===
  bagging (RF): parallel daraxtlar
  boosting (GB): ketma-ket xato tuzatish

=== 4. Voting mantiqi ===
  3 turli model ovozi — ko'pchilik
  turli-tumanlik — ansambl kuchi
  ⭐ boosting (ketma-ket), voting (turli model)

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

Misol 3 — Feature muhimligi

python
"""feature_importances_: Random Forest qaysi feature muhim — tushunish va tanlov."""

import warnings
warnings.filterwarnings("ignore")

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


def main() -> None:
    data = load_breast_cancer()
    X, y = data.data, data.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    rf = RandomForestClassifier(n_estimators=100, random_state=42)
    rf.fit(X_train, y_train)

    print("=== 1. Feature muhimligi (0-1) ===")
    imp = rf.feature_importances_
    print(f"  jami feature: {len(imp)}")
    print(f"  muhimlik yig'indisi: {round(float(imp.sum()), 1)}")

    print("\n=== 2. Eng muhim 3 feature ===")
    top3 = sorted(enumerate(imp), key=lambda x: -x[1])[:3]
    for idx, val in top3:
        print(f"  {data.feature_names[idx]}: {round(float(val), 3)}")

    print("\n=== 3. Eng kam muhim ===")
    bottom = sorted(enumerate(imp), key=lambda x: x[1])[0]
    print(f"  {data.feature_names[bottom[0]]}: {round(float(bottom[1]), 4)}")

    print("\n=== 4. Foyda ===")
    print("  tushunish: qaysi xususiyat muhim")
    print("  feature tanlov: muhimlarini saqla 25.5-bob")
    print("  ⭐ feature_importances_ — model tushunarli (qora quti emas)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Feature muhimligi (0-1) ===
  jami feature: 30
  muhimlik yig'indisi: 1.0

=== 2. Eng muhim 3 feature ===
  mean concave points: 0.142
  worst concave points: 0.127
  worst area: 0.118

=== 3. Eng kam muhim ===
  mean fractal dimension: 0.0031

=== 4. Foyda ===
  tushunish: qaysi xususiyat muhim
  feature tanlov: muhimlarini saqla 25.5-bob
  ⭐ feature_importances_ — model tushunarli (qora quti emas)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Amaliy: modellar taqqoslash

Real ML: turli modelni (bitta, ansambl) taqqoslab, eng yaxshini tanlash. Bu — model tanlovining namunasi.

python
"""to'liq taqqoslash: DecisionTree vs RandomForest vs GradientBoosting vs Voting — eng yaxshi."""

import warnings
warnings.filterwarnings("ignore")

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier, VotingClassifier
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_breast_cancer(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    modellar = {
        "DecisionTree (bitta)": DecisionTreeClassifier(random_state=42),
        "RandomForest (bagging)": RandomForestClassifier(random_state=42),
        "GradientBoosting (boosting)": GradientBoostingClassifier(random_state=42),
        "Voting (turli)": VotingClassifier([
            ("dt", DecisionTreeClassifier(random_state=42)),
            ("lr", LogisticRegression(max_iter=5000, random_state=42)),
            ("rf", RandomForestClassifier(random_state=42)),
        ], voting="hard"),
    }

    print("=== 1-4. Modellarni taqqoslash ===")
    natijalar = {}
    for nom, model in modellar.items():
        model.fit(X_train, y_train)
        acc = model.score(X_test, y_test)
        natijalar[nom] = acc
        print(f"  {nom}: {round(acc, 3)}")

    print("\n=== Xulosa ===")
    eng_yaxshi = max(natijalar, key=natijalar.get)
    print(f"  eng yaxshi: {eng_yaxshi} ({round(natijalar[eng_yaxshi], 3)})")
    print(f"  ansambllar bitta daraxtdan yaxshiroq")
    print("  ⭐ ansambl — real ML'ning kuchli tanlovi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1-4. Modellarni taqqoslash ===
  DecisionTree (bitta): 0.942
  RandomForest (bagging): 0.971
  GradientBoosting (boosting): 0.959
  Voting (turli): 0.982

=== Xulosa ===
  eng yaxshi: Voting (turli) 0.982-bob
  ansambllar bitta daraxtdan yaxshiroq
  ⭐ ansambl — real ML'ning kuchli tanlovi

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
"Bitta model yetarli" Ansambl ko'pincha yaxshiroq
"Ansambl = bir model ko'p marta" Turli-tuman modellar
"Random Forest = Boosting" Bagging (parallel) vs boosting (ketma-ket)
"Ko'p model doim tez" Sekinroq (ko'p model)
"Ansambl — qora quti" Feature muhimligi bor
"Boosting doim yaxshi" Overfitting'ga moyilroq
"Bir xil model ovozi" Turli-tuman kerak
"Ansambl overfitting" Bagging kamaytiradi

6. Keng tarqalgan xatolar va yechimlari

1. Bitta model bilan cheklanish

python
DecisionTreeClassifier()   # bitta (overfitting)     # ⚠️
RandomForestClassifier()   # ansambl                  # ✅

2. Bagging va boosting chalkashtirish

python
# RF va GB bir xil deb o'ylash                        # ⚠️
# RF: parallel (bagging), GB: ketma-ket (boosting)     # ✅

3. Voting'da bir xil model

python
VotingClassifier([dt1, dt2, dt3])   # bir xil        # ⚠️
VotingClassifier([dt, lr, rf])       # turli-tuman     # ✅

4. Boosting overfitting (ehtiyotsiz)

python
GradientBoostingClassifier(n_estimators=1000)   # ⚠️ overfitting
# learning_rate, n_estimators sozla               # ✅

5. Feature muhimligini e'tiborsiz qoldirish

python
# rf.feature_importances_ ko'rmaslik               # ⚠️
# tushunish, feature tanlov                         # ✅

6. Ansambl har doim deb o'ylash

python
# oddiy muammoga katta ansambl                     # ⚠️ ortiqcha
# oddiy model yetsa — oddiy                          # ✅

7. random_statesiz (takrorlanmaydi)

python
RandomForestClassifier()   # har safar boshqa      # ⚠️
RandomForestClassifier(random_state=42)             # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 25.2-dars (o'tilgan): Model — ansambl asosi
  • 25.4-dars (o'tilgan): Baholash — ansambl baholash
  • 25.5-dars (o'tilgan): Feature — feature muhimligi
  • 25.7-dars: PyTorch — chuqur o'qitish (boshqa yondashuv)
  • 31-qism: Loyihalar — real ansambl

8. Eng yaxshi amaliyotlar

  1. Bitta model o'rniga ansambl (ko'pincha yaxshi).

  2. Random Forest — ishonchli boshlash.

  3. Yuqori aniqlik — Gradient Boosting (sozlab).

  4. Voting — turli-tuman model.

  5. feature_importances_ — tushunish.

  6. Boosting — overfitting ehtiyot (sozlash).

  7. random_state (takrorlanuvchi).

  8. Modellarni taqqosla (eng yaxshi).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # ansambl nima?
2.  # nega ko'p model yaxshi?
3.  # Random Forest nima?
4.  # bagging nima?
5.  # Gradient Boosting nima?
6.  # boosting nima?
7.  # bagging vs boosting?
8.  # Voting nima?
9.  # feature_importances_ nima?
10. # turli-tumanlik nega muhim?
11. # ansambl overfitting'ni?
12. # ansambl kamchiligi?
Javoblar
  1. Ko'p modelni birlashtirib kuchliroq
  2. Xatolar o'zaro yo'qoladi (ko'pchilik aqli)
  3. Ko'p qaror daraxti (bagging)
  4. Parallel, ma'lumot bo'lagida
  5. Ketma-ket xato tuzatish
  6. Ketma-ket, oldingi xatosini tuzatadi
  7. bagging parallel, boosting ketma-ket
  8. Turli model ovozi
  9. Qaysi feature muhim
  10. Har xil xato kerak (bir xil — foydasiz)
  11. Kamaytiradi (bagging — o'rtacha)
  12. Sekinroq, kamroq tushunarli

Vazifa 2: Xatolarni tuzating

python
1.  DecisionTreeClassifier()   # overfitting    # RandomForest

2.  VotingClassifier([dt1, dt2, dt3])           # turli-tuman

3.  GradientBoosting(n_estimators=1000)         # sozla

4.  # feature_importances_ ko'rmaslik           # ko'r

5.  RandomForestClassifier()   # random_state yo'q  # 42
Javoblar
python
1.  RandomForestClassifier(random_state=42)

2.  VotingClassifier([("dt",dt),("lr",lr),("rf",rf)])

3.  GradientBoostingClassifier(learning_rate=0.1, n_estimators=100)

4.  rf.feature_importances_

5.  RandomForestClassifier(random_state=42)

Vazifa 3: Random Forest

Bagging:

  1. Bitta daraxt
  2. Random Forest
  3. Taqqosla
  4. Nega yaxshi

Vazifa 4: Boosting/Voting

Ansambl:

  1. Gradient Boosting
  2. Voting
  3. Bagging vs boosting
  4. Turli-tuman

Vazifa 5: Feature muhimligi

Tushunish:

  1. feature_importances_
  2. Eng muhim
  3. Eng kam
  4. Foyda

Vazifa 6: Taqqoslash

Modellar:

  1. Bir necha model
  2. Bahola
  3. Eng yaxshi
  4. Xulosa

Vazifa 7: O'ylash

Ansambl "ko'pchilik aqli" (wisdom of the crowd) ga asoslanadi: ko'p mustaqil, xato qiluvchi model — birlashtirganda kuchli. Lekin sharti — modellar turli-tuman bo'lishi (bir xil xato qilsa, birlashtirish foydasiz). Nima uchun "turli-tumanlik ansambl kuchi", va nega bu inson jamiyatidagi "ko'p ekspert > bitta ekspert" bilan bir xil tamoyil — mustaqillik va turli-tumanlik nega jamoaviy aql uchun muhim?

Javob

Qisqa javob: Ansambl kuchi — turli-tumanlik: modellar har xil xato qilsa, birlashtirganda xatolar o'zaro yo'qoladi (biri u yerda xato, boshqasi bu yerda — o'rtacha to'g'ri). Agar barcha model bir xil xato qilsa, birlashtirish foydasiz (xato saqlanadi). Shuning uchun turli-tuman (Random Forest — tasodif bilan, Voting — har xil model). Bu inson jamiyatidagi "ko'p ekspert > bitta" bilan bir xil: turli-tuman, mustaqil ekspertlar (har xil tajriba, nuqtai nazar) — birlashtirganda aqlli qaror (biri bilmaganini boshqasi biladi). Mustaqillik muhim: agar ekspertlar bir-biriga ta'sir qilsa (bir xil fikr), turli-tumanlik yo'qoladi (guruh xatosi). "Jamoaviy aql" — mustaqil + turli-tuman ovozlar. Bir xil (bog'liq) ovozlar — kuchsiz. Bu ML'da (ansambl) va jamiyatda (demokratiya, bozor) bir xil ishlaydi.

1. Turli-tumanlik — kuch

Har xil xato → birlashtirganda yo'qoladi (o'rtacha to'g'ri). Bir xil xato → saqlanadi (foydasiz). Turli-tuman modellar kerak.

2. Ko'p ekspert > bitta

Bitta ekspert Ko'p ekspert (turli-tuman)
Bir nuqtai nazar Har xil tajriba
Bir xato Xatolar yo'qoladi
Cheklangan Keng qamrov

Biri bilmaganini boshqasi biladi.

3. Mustaqillik muhim

Ekspertlar bir-biriga ta'sir qilsa (bir xil fikr) — turli-tumanlik yo'qoladi (guruh xatosi — groupthink). Mustaqil ovozlar kerak (ML'da — tasodif, ma'lumot bo'lagi).

4. Jamoaviy aql

  • Turli-tuman (har xil xato)
  • Mustaqil (bog'liq emas)
  • Birlashtirish (ovoz, o'rtacha)

ML (ansambl), jamiyat (demokratiya, bozor narxi) — bir tamoyil.

5. Muhandislik saboqlari

  1. Turli-tumanlik — ansambl kuchi
  2. Bir xil xato — foydasiz
  3. Mustaqillik (bog'liq emas)
  4. Jamoaviy aql (ML va jamiyat)

6. Xulosa

  1. Ansambl — ko'pchilik aqli
  2. Turli-tumanlik hal qiladi
  3. Mustaqil + turli-tuman
  4. ML va jamiyat — bir tamoyil

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda ansambl modellarni o'rgandik.

Eng muhim uch fikr:

  1. Ansambl va Random Forest. Ansambl — ko'p modelni birlashtirib kuchliroq model: har model bashorati → ovoz (klassifikatsiya) yoki o'rtacha (regressiya). Sabab: har model boshqacha xato qiladi — birlashtirganda xatolar o'zaro yo'qoladi ("ko'pchilik aqli"). Random Forest (bagging) — ko'p qaror daraxti (n_estimators=100), har biri ma'lumot va feature bo'lagida o'qiydi (tasodif → har xil), bashorat ko'pchilik ovozi. Kuchli, overfitting'ga chidamli, oson — "ishonchli ishchi ot".

  2. Boosting, Voting, feature muhimligi. Gradient Boosting (boosting) — modellar ketma-ket, har biri oldingining xatosini tuzatadi (Random Forest parallel — bagging; farq shu). Ko'pincha eng aniq (Kaggle — XGBoost), lekin sozlash nozik, overfitting'ga moyilroq. Voting — turli modellar (daraxt, regressiya, o'rmon) ovozi (voting="hard" — ko'pchilik, "soft" — ehtimol). Feature muhimligi (feature_importances_) — qaysi feature muhim (tushunish + feature tanlov, 25.5) — ansambl qora quti emas.

  3. Turli-tumanlik — ansambl kuchi. Ansambl "ko'pchilik aqli" (wisdom of the crowd): ko'p mustaqil, xato qiluvchi model — birlashtirganda kuchli. Sharti — turli-tumanlik (modellar har xil xato qilsa, birlashtirganda yo'qoladi; bir xil xato — foydasiz) va mustaqillik. Afzalliklar: aniqroq, barqaror (xatolar o'zaro yo'qoladi), overfitting'ga chidamli (bagging — o'rtacha; boosting moyilroq). Kamchilik: sekinroq, kamroq tushunarli. Bu inson jamiyatidagi "ko'p ekspert > bitta" bilan bir tamoyil (mustaqil + turli-tuman ovozlar → jamoaviy aql). Ansambl — klassik ML'ning eng kuchli usuli (chuqur o'qitishdan oldin Kaggle g'oliblari).

Keyingi darsda PyTorch: tenzor ni o'rganamiz: chuqur o'qitish (neyron tarmoq) asosi — tenzor (NumPy massivi kabi, lekin GPU va avtomatik gradient), zamonaviy AI ning poydevori.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
25.6-dars: Ansambl modellar — IlmHamroh