6.1-dars: Yetishmayotgan qiymatlar

6-QISM — MA'LUMOTNI TOZALASH · 1-dars

1. Kirish va motivatsiya

Real ma'lumot iflos — hech qachon toza kelmaydi. So'rovnomada odam javob bermagan, sensor ishlamagan, ma'lumot bazasida bo'sh katak — yetishmayotgan qiymatlar (missing values) hamma joyda. Data Scientist ishining 80% — ma'lumotni tozalash (model qurishdan oldin). Va eng keng tarqalgan muammo — yetishmayotgan qiymatlar. Ularni e'tiborsiz qoldirib bo'lmaydi: ko'p funksiya NaN bilan ishlamaydi (xato beradi yoki noto'g'ri natija). 3.7-darsda NaN asoslarini ko'rdik; endi chuqurroq: yetishmayotgan qiymatni topish, tushunish (nega yo'q), va hal qilish (o'chirish yoki to'ldirish). Nega muhim? (1) Muqarrar — real ma'lumot to'liq emas; (2) Buzadi — NaN funksiyalarni sindiradi; (3) Qaror — o'chirish yoki to'ldirish (kontekstga). Bu dars yetishmayotgan qiymatlarni o'rgatadi — topish, tushunish, hal qilish.

Yetishmayotgan qiymatlar (missing values) — bo'sh/NaN: topish (isna(), df.isna().sum() — ustun bo'yicha), tushunish (nega yo'q — MCAR/MAR/MNAR), o'chirish (dropna() — qator/ustun), to'ldirish (fillna() — o'rtacha/median/mode/oldingi), interpolyatsiya (interpolate() — vaqt qatori), qaror (o'chirish yoki to'ldirish — kontekst). Foydalanish: iflos ma'lumotni tayyorlash, NaN'ni hal qilish. Bu 3.7 (NaN asoslari), 4.2 (median), 6.11 (tozalash quvuri) bilan bog'liq. Yetishmayotgan qiymatlar — topish, tushunish, hal qilish. NaN. Hal.

Real vaziyat. Data Scientist mijoz so'rovnomasini tahlil qilmoqchi (yosh, daromad, shahar). Iflos ma'lumot: 1000 qatordan 150 tasida daromad yo'q (odamlar javob bermagan), 30 tasida yosh yo'q. df.isna().sum() (daromad: 150, yosh: 30). E'tiborsiz: df["daromad"].mean() — pandas NaN'ni o'tkazib yuboradi (lekin sklearn model xato beradi — NaN qabul qilmaydi). Hal: yosh (30 — kam) fillna(median) (median — 4.2; outlierga chidamli), daromad (150 — ko'p) — tushun (nega yo'q? — yuqori daromadlilar javob bermagan? — MNAR; o'chirish xatoli). Data Scientist topdi (isna), tushundi (nega yo'q), hal qildi (median to'ldirish). Yetishmayotgan qiymatlar — topish, tushunish, hal.

Bu darsda yetishmayotgan qiymatlarni o'rganamiz.

Bu darsda:

• Topish (isna, sum)
• O'chirish (dropna)
• To'ldirish (fillna)
• Nega yo'q (MCAR/MAR/MNAR)
• Interpolyatsiya (vaqt qatori)
• Yetishmayotgan amaliyoti
• Yetishmayotgan tuzoqlari
• Amaliy: NaN hal qilish

ℹ Misollar real pandas/numpy bilan (Python 3.14) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Topish (isna, sum)

Qayerda va qancha:

import pandas as pd

# isna() — har katak: NaN mi? (True/False)
df.isna()

# ustun bo'yicha yetishmayotgan soni
df.isna().sum()

# foiz (nisbat)
df.isna().mean() * 100

# umumiy (bironta yo'qmi)
df.isna().any()

Topish (isna, sum) — qayerda va qancha: df.isna() (har katak — NaN mi? True/False; isnull() — bir xil), df.isna().sum() (ustun bo'yicha yetishmayotgan soni), df.isna().mean() * 100 (foiz — nisbat), df.isna().any() (bironta yo'qmi — ustun bo'yicha). Sabab: birinchi qadam — topish (qayerda, qancha yetishmayotgan; hal qilishdan oldin); sum (soni — 150 ta), mean (foiz — 15%; qaror uchun — kam/ko'p). isna (NaN — True), .sum() (ustun soni), .mean() (foiz). Topish — isna + sum (qayerda, qancha). Topish. Sum.

2.2. O'chirish (dropna)

Qator yoki ustun:

import pandas as pd

# dropna() — NaN bo'lgan QATORni o'chir
df.dropna()

# axis=1 — NaN bo'lgan USTUNni o'chir
df.dropna(axis=1)

# subset — faqat shu ustunlarda NaN bo'lsa
df.dropna(subset=["daromad"])

# thresh — kamida N ta to'ldirilgan qiymat kerak
df.dropna(thresh=3)

O'chirish (dropna) — qator yoki ustun: df.dropna() (NaN bo'lgan qatorni o'chir — standart axis=0), axis=1 (NaN bo'lgan ustunni o'chir), subset=["daromad"] (faqat shu ustunda NaN — o'chir), thresh=N (kamida N ta to'ldirilgan qiymat — aks holda o'chir). Sabab: o'chirish — eng oddiy hal (NaN qator/ustun ketadi); lekin ma'lumot yo'qotish (qator o'chirilsa — boshqa ustun qiymatlari ham ketadi; ehtiyot); kam NaN (o'chirish OK), ko'p NaN (o'chirish — ko'p ma'lumot yo'q; to'ldirish afzal). Qator (dropna() — kam NaN), ustun (axis=1 — ustun ko'p NaN — foydasiz), subset (muhim ustun). O'chirish — dropna (qator/ustun; ma'lumot yo'qotish). O'chirish. dropna.

2.3. To'ldirish (fillna)

To'ldirish (fillna) — qiymat qo'yish: df.fillna(qiymat) (NaN o'rniga qiymat); usullar: o'rtacha (df["x"].fillna(df["x"].mean()) — son; normal taqsimot), median (.fillna(df["x"].median()) — son; outlierga chidamli — 4.2; afzal), mode (.fillna(df["x"].mode()[0]) — kategoriya; eng ko'p), doimiy (.fillna(0) yoki .fillna("noma'lum") — belgilangan), oldingi/keyingi (.ffill()/.bfill() — vaqt qatori; oldingi qiymat). Sabab: to'ldirish — ma'lumotni saqlaydi (qator o'chirmaydi; NaN o'rniga taxmin); usul kontekstga (son — median; kategoriya — mode; vaqt — ffill). median (son — afzal; outlier), mode (kategoriya), ffill (vaqt). To'ldirish — fillna (median/mode/ffill; ma'lumot saqlaydi). To'ldirish. fillna.

2.4. Nega yo'q (MCAR/MAR/MNAR)

Nega yo'q (MCAR/MAR/MNAR) — yetishmovchilik mexanizmi: MCAR (Missing Completely At Random — tasodifiy; sensor tasodifiy ishlamagan; yo'qlik boshqa narsaga bog'liq emas; o'chirish/to'ldirish xavfsiz), MAR (Missing At Random — boshqa ustunga bog'liq; yoshlar daromadni kamroq aytadi; yo'qlik yosh bilan; to'ldirish — boshqa ustun bilan), MNAR (Missing Not At Random — qiymatning o'ziga bog'liq; yuqori daromadlilar daromadni aytmaydi; yo'qlik daromad bilan; eng xavfli — o'chirish/to'ldirish noto'g'ri — natija egiladi). Sabab: nega yo'q — hal qilish usulini belgilaydi (MCAR — oson; MNAR — ehtiyot; o'chirish soxta natija); "yo'qlik tasodifiymi yoki naqshmi?". MCAR (tasodifiy — oson), MAR (boshqa bilan — to'ldirish), MNAR (o'zi bilan — xavfli). Nega yo'q — MCAR/MAR/MNAR (mexanizm — hal usuli). Nega. Mexanizm.

2.5. Interpolyatsiya (vaqt qatori)

Interpolyatsiya (vaqt qatori) — oraliqni to'ldirish: df["x"].interpolate() — yetishmayotgan qiymatni atrof qiymatlar orasida hisoblab to'ldiradi (chiziqli — ikki nuqta orasida; method="linear" standart); vaqt qatori uchun (5.2 — trend). Sabab: vaqt qatori (harorat, savdo — ketma-ket; NaN — sensor ishlamagan) — oldingi/keyingi qiymat bilan hisoblab (mean emas — trend; 15:00 yo'q, 14:00=20, 16:00=24 → 15:00≈22); mean (butun o'rtacha — trend yo'qotadi), interpolate (oraliq — trend saqlaydi). linear (chiziqli — standart), time (vaqt indeks bilan), ffill (oldingi — o'zgarmas). Interpolyatsiya — interpolate (oraliq hisob; vaqt qatori). Interpolyatsiya. Oraliq.

2.6. Yetishmayotgan amaliyoti

Yetishmayotgan amaliyoti: topish (df.isna().sum() — qayerda, qancha; foiz .mean()*100); tushunish (nega yo'q — MCAR/MAR/MNAR; naqsh bormi); qaror (kam NaN — dropna; ko'p — fillna; MNAR — ehtiyot); to'ldirish (son — fillna(median); kategoriya — fillna(mode); vaqt — interpolate/ffill); belgilash (yangi ustun — df["x_yoq"] = df["x"].isna() — yo'qlik o'zi ma'lumot; MNAR); tekshir (df.isna().sum() — 0 bo'ldimi). Tuzoqlar: e'tiborsiz (NaN — model xato), o'rtacha ko'r-ko'rona (outlier — median), ko'p o'chirish (ma'lumot yo'q), MNAR o'chirish (natija egiladi), NaN yashirin (bo'shliq/-999 — NaN emas). Amaliyot — topish, tushunish, hal, tekshir. NaN. Hal.

2.7. Yetishmayotgan tuzoqlari

Yetishmayotgan qiymat asosiy tuzoqlari: e'tiborsiz qoldirish (NaN — ko'p funksiya xato (sklearn model — NaN qabul qilmaydi) yoki noto'g'ri (jami NaN — natija NaN); topish + hal shart); o'rtacha ko'r-ko'rona (fillna(mean) — outlier o'rtachani tortadi 4.2-bob; median afzal (chidamli); kategoriya — mean emas, mode); ko'p o'chirish (dropna() — ko'p NaN qator o'chir → ko'p ma'lumot yo'q (1000 → 200; tahlil kuchsiz); to'ldirish afzal); MNAR o'chirish (yo'qlik qiymat bilan (yuqori daromad — javob yo'q); o'chirish/to'ldirish → egilgan natija (yuqori daromadlilar yo'q — o'rtacha past); tushun, belgila); yashirin NaN (NaN boshqa ko'rinishda — bo'sh satr "", -999, "noma'lum", 0; pandas NaN deb bilmaydi; replace → NaN, keyin hal); to'ldirish oqibati (fillna(mean) — tarqoqlik kamayadi (barcha NaN — bir qiymat; std past; korrelyatsiya buziladi); ehtiyot — belgila); inplace unut (df.fillna(0) — yangi DataFrame; df = df.fillna(0) yoki inplace=True); 0 vs NaN (0 — haqiqiy qiymat (harorat 0°); NaN — yo'q; farqla — 0 to'ldirish xato bo'lishi mumkin). Sabab: yetishmayotgan qiymat hal/mexanizm nozik (e'tiborsiz, usul, MNAR, yashirin — xato yoki egilgan). Yechim: topish, median/mode, tushunish (MNAR), yashirin NaN, belgilash. Tuzoqlar — e'tiborsiz, o'rtacha, ko'p o'chirish, MNAR.

2.8. Yetishmayotgan qiymatlar — topish, tushunish, hal qilish

Yetishmayotgan qiymat asosiy g'oyasi — topish, tushunish, hal qilish: real ma'lumot iflos (yetishmayotgan qiymat muqarrar — javob yo'q, sensor ishlamagan, bo'sh katak); Data Scientist ishi 80% tozalash, eng ko'p — NaN. Topish (df.isna().sum() — qayerda, qancha; foiz), tushunish (nega yo'q — MCAR tasodifiy, MAR boshqa ustun, MNAR o'zi bilan; mexanizm — hal usuli), hal qilish: o'chirish (dropna — kam NaN; ma'lumot yo'qotish — ehtiyot), to'ldirish (fillna — son median 4.2, kategoriya mode, vaqt interpolate/ffill; ma'lumot saqlaydi), belgilash (yo'qlik o'zi ma'lumot — MNAR; yangi ustun). Foydalanish: iflos ma'lumotni tayyorlash (NaN — hal; ML uchun — 20-qism), NaN'ni hal (funksiya buzilmasin). Tuzoqlar: e'tiborsiz (model xato), o'rtacha ko'r-ko'rona (median), ko'p o'chirish (ma'lumot yo'q), MNAR o'chirish (egilgan), yashirin NaN (-999/bo'sh satr). Bu 3.7 (NaN asoslari), 4.2 (median), 6.11 (tozalash quvuri), 20-qism (ML — NaN hal) bilan. Yetishmayotgan qiymatlar — topish (isna), tushunish (mexanizm), hal qilish (o'chirish/to'ldirish). NaN. Hal. Tushunish.

3. Tez ma'lumotnoma

import pandas as pd
import numpy as np

# TOPISH:
df.isna().sum()          # ustun bo'yicha yetishmayotgan soni
df.isna().mean() * 100   # foiz (nisbat)
df.isna().any()          # bironta yo'qmi (ustun)

# O'CHIRISH (dropna):
df.dropna()                    # NaN qatorni o'chir
df.dropna(axis=1)              # NaN ustunni o'chir
df.dropna(subset=["daromad"])  # faqat shu ustunda NaN
df.dropna(thresh=3)            # kamida 3 to'ldirilgan

# TO'LDIRISH (fillna):
df["x"].fillna(df["x"].median())    # son (median — afzal)
df["k"].fillna(df["k"].mode()[0])   # kategoriya (mode)
df["x"].fillna(0)                   # doimiy
df["x"].ffill()                     # oldingi (vaqt qatori)
df["x"].interpolate()               # oraliq hisob (vaqt)

# YASHIRIN NaN:
df.replace([-999, "", "noma'lum"], np.nan)   # → NaN, keyin hal

# BELGILASH (yo'qlik o'zi ma'lumot — MNAR):
df["x_yoq"] = df["x"].isna()

# MEXANIZM: MCAR (tasodifiy) · MAR (boshqa ustun) · MNAR (o'zi — xavfli)
QOIDA: topish → tushunish (nega yo'q — sabab) → hal (dropna yoki fillna) → tekshir

Yetishmayotgan qiymatlar xulosasi

Yetishmayotgan qiymatlar — topish, tushunish, hal qilish
Topish — isna().sum() (qayerda, qancha; foiz)
O'chirish — dropna (kam NaN; ma'lumot yo'qotish — ehtiyot)
To'ldirish — fillna (son median, kategoriya mode, vaqt interpolate)
Mexanizm — MCAR (tasodifiy), MAR (boshqa), MNAR (o'zi — xavfli)

4. Batafsil misollar

Misollar real pandas/numpy bilan (Python 3.14) ishlaydi.

Misol 1 — Topish (isna, sum)

"""Yetishmayotganni topish (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, 30, np.nan, 45, 28, np.nan],
        "daromad": [500, np.nan, np.nan, 800, np.nan, 600],
        "shahar": ["T", "S", "B", "T", None, "S"],
    })

    print("=== 1. Ustun bo'yicha soni ===")
    print(df.isna().sum().to_string())

    print("\n=== 2. Foiz (nisbat) ===")
    foiz = (df.isna().mean() * 100).round(1)
    print(foiz.to_string())

    print("\n=== 3. Jami yetishmayotgan ===")
    print(f"  jami: {int(df.isna().sum().sum())}")

    print("\n=== 4. Qaysi ustunlarda ===")
    bor = df.columns[df.isna().any()].tolist()
    print(f"  NaN bor ustunlar: {bor}")
    print("  ⭐ Topish — isna().sum() (qayerda, qancha)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ustun bo'yicha soni ===
yosh       2
daromad    3
shahar     1

=== 2. Foiz (nisbat) ===
yosh       33.3
daromad    50.0
shahar     16.7

=== 3. Jami yetishmayotgan ===
  jami: 6

=== 4. Qaysi ustunlarda ===
  NaN bor ustunlar: ['yosh', 'daromad', 'shahar']
  ⭐ Topish — isna().sum() (qayerda, qancha)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — O'chirish (dropna)

"""O'chirish: dropna (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, 30, np.nan, 45, 28],
        "daromad": [500, np.nan, np.nan, 800, 600],
        "shahar": ["T", "S", "B", "T", "S"],
    })

    print("=== 1. Asl (5 qator) ===")
    print(f"  qatorlar: {len(df)}")

    print("\n=== 2. dropna() — NaN qatorni o'chir ===")
    d1 = df.dropna()
    print(f"  qoldi: {len(d1)} qator (2 o'chdi)")

    print("\n=== 3. subset — faqat daromad ===")
    d2 = df.dropna(subset=["daromad"])
    print(f"  qoldi: {len(d2)} qator")

    print("\n=== 4. thresh — kamida 2 to'ldirilgan ===")
    d3 = df.dropna(thresh=2)
    print(f"  qoldi: {len(d3)} qator")
    print("  ⭐ O'chirish — dropna (ma'lumot yo'qotish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Asl (5 qator) ===
  qatorlar: 5

=== 2. dropna() — NaN qatorni o'chir ===
  qoldi: 3 qator (2 o'chdi)

=== 3. subset — faqat daromad ===
  qoldi: 3 qator

=== 4. thresh — kamida 2 to'ldirilgan ===
  qoldi: 4 qator
  ⭐ O'chirish — dropna (ma'lumot yo'qotish)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — To'ldirish (fillna)

"""To'ldirish: fillna (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, 30, np.nan, 45, 28, np.nan],
        "shahar": ["T", "S", None, "T", "S", "T"],
    })

    print("=== 1. Son — median bilan (afzal) ===")
    median_yosh = df["yosh"].median()
    df["yosh_toldirilgan"] = df["yosh"].fillna(median_yosh)
    print(f"  median: {median_yosh}")
    print(f"  to'ldirilgan: {df['yosh_toldirilgan'].tolist()}")

    print("\n=== 2. Kategoriya — mode bilan ===")
    mode_shahar = df["shahar"].mode()[0]
    df["shahar_toldirilgan"] = df["shahar"].fillna(mode_shahar)
    print(f"  mode (eng ko'p): {mode_shahar}")
    print(f"  to'ldirilgan: {df['shahar_toldirilgan'].tolist()}")

    print("\n=== 3. Nega median (mean emas) ===")
    print(f"  mean: {df['yosh'].mean().round(1)}, median: {median_yosh}")
    print("  median — outlierga chidamli 4.2-bob")

    print("\n=== 4. Tekshirish ===")
    print(f"  NaN qoldi: {int(df[['yosh_toldirilgan', 'shahar_toldirilgan']].isna().sum().sum())}")
    print("  ⭐ To'ldirish — fillna (median/mode)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Son — median bilan (afzal) ===
  median: 29.0
  to'ldirilgan: [25.0, 30.0, 29.0, 45.0, 28.0, 29.0]

=== 2. Kategoriya — mode bilan ===
  mode (eng ko'p): T
  to'ldirilgan: ['T', 'S', 'T', 'T', 'S', 'T']

=== 3. Nega median (mean emas) ===
  mean: 32.0, median: 29.0
  median — outlierga chidamli 4.2-bob

=== 4. Tekshirish ===
  NaN qoldi: 0
  ⭐ To'ldirish — fillna (median/mode)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Interpolyatsiya va yashirin NaN

"""Interpolyatsiya va yashirin NaN (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    print("=== 1. Vaqt qatori (NaN oraliq) ===")
    harorat = pd.Series([20, 22, np.nan, np.nan, 28, 30])
    print(f"  asl: {harorat.tolist()}")

    print("\n=== 2. interpolate (oraliq hisob) ===")
    interp = harorat.interpolate()
    print(f"  interpolyatsiya: {interp.tolist()}")
    print("  NaN → atrof orasida hisoblab (trend saqlaydi)")

    print("\n=== 3. mean bilan taqqoslash ===")
    mean_fill = harorat.fillna(harorat.mean().round(1))
    print(f"  mean bilan: {mean_fill.tolist()}")
    print("  mean — trend yo'qotadi (interpolate — saqlaydi)")

    print("\n=== 4. Yashirin NaN (-999) ===")
    df = pd.DataFrame({"yosh": [25, -999, 30, -999, 45]})
    df["yosh"] = df["yosh"].replace(-999, np.nan)
    print(f"  -999 → NaN: {df['yosh'].tolist()}")
    print(f"  endi NaN soni: {int(df['yosh'].isna().sum())}")
    print("  ⭐ Interpolyatsiya (vaqt) + yashirin NaN (replace)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Vaqt qatori (NaN oraliq) ===
  asl: [20.0, 22.0, nan, nan, 28.0, 30.0]

=== 2. interpolate (oraliq hisob) ===
  interpolyatsiya: [20.0, 22.0, 24.0, 26.0, 28.0, 30.0]
  NaN → atrof orasida hisoblab (trend saqlaydi)

=== 3. mean bilan taqqoslash ===
  mean bilan: [20.0, 22.0, 25.0, 25.0, 28.0, 30.0]
  mean — trend yo'qotadi (interpolate — saqlaydi)

=== 4. Yashirin NaN (-999) ===
  -999 → NaN: [25.0, nan, 30.0, nan, 45.0]
  endi NaN soni: 2
  ⭐ Interpolyatsiya (vaqt) + yashirin NaN (replace)

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

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

6. Keng tarqalgan xatolar va yechimlari

1. E'tiborsiz qoldirish

model.fit(df)   # NaN → xato (sklearn)                            # ⚠️
df = df.fillna(df.median(numeric_only=True))   # hal              # ✅

2. O'rtacha ko'r-ko'rona

df["x"].fillna(df["x"].mean())   # outlier tortadi                # ⚠️
df["x"].fillna(df["x"].median())   # chidamli                    # ✅

3. Ko'p o'chirish

df.dropna()   # 1000 → 200 (ko'p yo'q)                            # ⚠️
df.fillna(...)   # to'ldirish (saqlaydi)                          # ✅

4. MNAR o'chirish

df.dropna(subset=["daromad"])   # yuqori daromad yo'q (egilgan)   # ⚠️
df["daromad_yoq"] = df["daromad"].isna()   # belgila             # ✅

5. Yashirin NaN

df["yosh"].mean()   # -999 hisobga (noto'g'ri)                    # ⚠️
df["yosh"].replace(-999, np.nan)   # → NaN, keyin hal            # ✅

6. inplace unutish

df.fillna(0)   # df o'zgarmaydi (yangi qaytadi)                   # ⚠️
df = df.fillna(0)   # tayinla                                     # ✅

7. 0 vs NaN

df["harorat"].fillna(0)   # 0° — haqiqiy qiymat (xato)            # ⚠️
df["harorat"].fillna(df["harorat"].median())                     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.7-dars (o'tilgan): NaN asoslari
• 4.2-dars (o'tilgan): Median (to'ldirish)
• 6.3-dars: Outlier (bog'liq)
• 6.11-dars: Tozalash quvuri
• 20-qism (reja): ML (NaN hal shart)

8. Eng yaxshi amaliyotlar

1. Topish — df.isna().sum() (birinchi).

2. Tushunish — nega yo'q (MCAR/MAR/MNAR).

3. Son — median (mean emas).

4. Kategoriya — mode.

5. Vaqt — interpolate/ffill.

6. Yashirin NaN — replace (-999, "").

7. MNAR — belgila (yo'qlik ma'lumot).

8. Tekshir — isna().sum() = 0.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # yetishmayotgan qiymat nima?
2.  # isna nima?
3.  # dropna nima?
4.  # fillna nima?
5.  # median nega?
6.  # kategoriya to'ldirish?
7.  # interpolate qachon?
8.  # MCAR nima?
9.  # MNAR nima?
10. # yashirin NaN?
11. # 0 = NaN mi?
12. # nega tozalash?

Vazifa 2: Xatolarni tuzating

1.  model.fit(df)   # NaN

2.  df["x"].fillna(df["x"].mean())

3.  df.dropna()   # 1000 → 200

4.  df["yosh"].mean()   # -999

5.  df.fillna(0)   # o'zgarmaydi

1.  df = df.fillna(median)

2.  fillna(median) (chidamli)

3.  fillna (to'ldirish — saqlaydi)

4.  replace(-999, np.nan)

5.  df = df.fillna(0)

Vazifa 3: Topish

Modellang:

1. isna
2. sum
3. Foiz
4. Qaysi ustun

Vazifa 4: Hal qilish

Modellang:

1. dropna
2. fillna median
3. fillna mode
4. interpolate

Vazifa 5: Mexanizm

Modellang:

1. MCAR
2. MAR
3. MNAR
4. Belgila

Vazifa 6: Integratsiya

Modellang:

1. NaN (3.7)
2. Median (4.2)
3. Quvur (6.11)
4. ML (20)

Vazifa 7: O'ylash

Yetishmayotgan qiymatlar mexanizmi (MCAR/MAR/MNAR) hal usulini belgilaydi. MNAR (yo'qlik qiymatning o'ziga bog'liq — yuqori daromadlilar daromadni aytmaydi) eng xavfli: o'chirish ham, o'rtacha bilan to'ldirish ham natijani egadi. Nima uchun "yo'qlikning o'zi ma'lumot" bo'lishi mumkin, va Data Scientist MNAR bilan qanday ishlaydi?

Nimani mustahkamlaydi: 2.4, 2.7-bo'limlar.

Xulosa

Bu darsda yetishmayotgan qiymatlarni o'rgandik.

Eng muhim uch fikr:

1. Topish va o'chirish. Topish — df.isna().sum() (ustun bo'yicha soni; .mean()*100 foiz; birinchi qadam — qayerda, qancha). O'chirish — df.dropna() (NaN qator; axis=1 ustun; subset muhim ustun; thresh kamida N); oddiy, lekin ma'lumot yo'qotish (ko'p NaN — ehtiyot).

2. To'ldirish va mexanizm. To'ldirish — df.fillna(): son median (fillna(median) — outlierga chidamli 4.2; mean emas), kategoriya mode, vaqt qatori interpolate/ffill (oraliq — trend saqlaydi; ma'lumot saqlaydi). Mexanizm (nega yo'q): MCAR (tasodifiy — oson), MAR (boshqa ustunga), MNAR (qiymat bilan — eng xavfli; o'chirish/o'rtacha egadi).

3. Topish, tushunish, hal. Real ma'lumot iflos — yetishmayotgan qiymat muqarrar (ish 80% tozalash). Jarayon: topish (isna) → tushunish (mexanizm — MNAR ehtiyot; yo'qlik o'zi ma'lumot — belgila) → hal (o'chirish/to'ldirish) → tekshir (isna().sum()=0). Tuzoqlar: e'tiborsiz (model xato), o'rtacha ko'r-ko'rona (median), ko'p o'chirish (ma'lumot yo'q), MNAR o'chirish (egilgan), yashirin NaN (-999/bo'sh satr — replace → NaN), inplace unut (df = df.fillna), 0 vs NaN (0 — qiymat).

Keyingi darsda dublikatlar (duplicates)ni o'rganamiz: takrorlangan qatorlar (bir mijoz ikki marta, xato nusxa) — topish (duplicated) va o'chirish (drop_duplicates); ma'lumotni buzadi (soxta sanoq, egilgan statistika).