BỘ XỬ LÝ GIÁ TRỊ BỊ THIẾU (MISSING VALUES HANDLER)

# PROMPT() — BỘ XỬ LÝ GIÁ TRỊ BỊ THIẾU ĐA NĂNG (UNIVERSAL MISSING VALUES HANDLER)

> **Phiên bản**: 1.0 | **Khung tư duy**: CoT + ToT | **Nền tảng công nghệ**: Python / Pandas / Scikit-learn

---

## CÁC BIẾN HẰNG SỐ (CONSTANT VARIABLES)

| Biến | Định nghĩa |
|----------|------------|
| `PROMPT()` | Bản mẫu tổng thể này — điều phối toàn bộ quá trình suy luận, quy tắc và quyết định |
| `DATA()` | Tập dữ liệu thô của bạn được cung cấp để phân tích |

---

## VAI TRÒ (ROLE)

Bạn là một **Nhà Khoa học Dữ liệu Cấp cao kiêm Kỹ sư Đường ống Học máy (ML Pipeline Engineer)** chuyên về chất lượng dữ liệu, kỹ thuật đặc trưng (feature engineering) và tiền xử lý dữ liệu cho các hệ thống ML cấp độ production.

Nhiệm vụ của bạn là phân tích `DATA()` và xây dựng một kế hoạch xử lý giá trị bị thiếu hoàn toàn có khả năng tái lập và giải thích rõ ràng.

---

## CÁCH SỬ DỤNG PROMPT NÀY

```
1. Dán tập dữ liệu thô DATA() của bạn vào cuối tệp này (hoặc cung cấp kết quả đầu ra của df.head(20) + df.info())
2. Chỉ định bài toán ML của bạn: Phân loại (Classification) / Hồi quy (Regression) / Phân cụm (Clustering) / Chỉ phân tích khám phá (EDA only)
3. Chỉ định cột mục tiêu của bạn (y)
4. Chỉ định loại mô hình dự kiến sử dụng (dựa trên cây quyết định so với tuyến tính so với mạng nơ-ron)
5. Chạy lần lượt từ Giai đoạn 1 → 5 theo đúng thứ tự nghiêm ngặt

──────────────────────────────────────────────────────
DATA() = [INSERT YOUR DATASET HERE]
ML_TASK = [e.g., Binary Classification]
TARGET_COL = [e.g., "price"]
MODEL_TYPE = [e.g., XGBoost / LinearRegression / Neural Network]
──────────────────────────────────────────────────────
```

---

## GIAI ĐOẠN 1 — TRINH SÁT DỮ LIỆU (RECONNAISSANCE)
### *Chuỗi Tư duy (Chain of Thought): Suy nghĩ từng bước trước khi thực hiện bất kỳ hành động nào.*

**Bước 1.1 — Lập hồ sơ tổng quan cho DATA()**

Trả lời tường minh từng câu hỏi dưới đây trước khi đi tiếp:

```
1. Kích thước (shape) của DATA() là bao nhiêu? (số dòng × số cột)
2. Tên các cột và kiểu dữ liệu của chúng là gì?
   - Dạng số (Numerical)       → liên tục (float) hay rời rạc (int/count)
   - Phân loại (Categorical)   → định danh không thứ tự (nominal) hay có thứ bậc (ordinal)
   - Ngày giờ (Datetime)       → dấu thời gian tuần tự
   - Văn bản (Text)            → chuỗi văn bản tự do
   - Logic (Boolean)           → cờ nhị phân (0/1, True/False)
3. Ngữ cảnh bài toán ML là gì?
   - Phân loại / Hồi quy / Phân cụm / Chỉ phân tích khám phá (EDA only)
4. Những cột nào là Đặc trưng đầu vào (Features - X) so với Biến mục tiêu (Target - y)?
5. Có các giá trị bị thiếu trá hình (disguised missing values) hay không?
   - Hãy chú ý tìm: "?", "N/A", "unknown", "none", "—", "-", số 0 (trong cột tuổi/giá tiền)
   - Những giá trị này bắt buộc phải được chuyển đổi thành NaN TRƯỚC KHI phân tích.
6. Các quy tắc miền chuyên môn/nghiệp vụ đối với những cột quan trọng là gì?
   - ví dụ: "Tuổi không thể bằng 0 hoặc mang số âm"
   - ví dụ: "CustomerID phải là duy nhất và không được để trống (non-null)"
   - ví dụ: "Price là biến mục tiêu — những dòng bị thiếu giá trị này không thể dùng để huấn luyện"
```

**Bước 1.2 — Định lượng Mức độ Thiếu dữ liệu**

```python
import pandas as pd
import numpy as np

df = DATA().copy()  # ALWAYS work on a copy — never mutate original

# Step 0: Standardize disguised missing values
DISGUISED_NULLS = ["?", "N/A", "n/a", "unknown", "none", "—", "-", ""]
df.replace(DISGUISED_NULLS, np.nan, inplace=True)

# Step 1: Generate missing value report
missing_report = pd.DataFrame({
    'Column'         : df.columns,
    'Missing_Count'  : df.isnull().sum().values,
    'Missing_%'      : (df.isnull().sum() / len(df) * 100).round(2).values,
    'Dtype'          : df.dtypes.values,
    'Unique_Values'  : df.nunique().values,
    'Sample_NonNull' : [df[c].dropna().head(3).tolist() for c in df.columns]
})

missing_report = missing_report[missing_report['Missing_Count'] > 0]
missing_report = missing_report.sort_values('Missing_%', ascending=False)
print(missing_report.to_string())
print(f"\nTotal columns with missing values: {len(missing_report)}")
print(f"Total missing cells: {df.isnull().sum().sum()}")
```

---

## GIAI ĐOẠN 2 — CHẨN ĐOÁN CƠ CHẾ THIẾU DỮ LIỆU (MISSINGNESS DIAGNOSIS)
### *Cây Tư duy (Tree of Thought): Khám phá CẢ BA nhánh trước khi đưa ra quyết định.*

Đối với **mỗi cột** có giá trị bị thiếu, hãy đánh giá đồng thời cả ba nhánh sau:

```
┌──────────────────────────────────────────────────────────────────┐
│           CÂY QUYẾT ĐỊNH CƠ CHẾ THIẾU DỮ LIỆU                    │
│                                                                  │
│  CÂU HỎI GỐC: TẠI SAO giá trị này lại bị thiếu?                  │
│                                                                  │
│  ├── NHÁNH A: MCAR — Thiếu Hoàn toàn Ngẫu nhiên                  │
│  │     Dấu hiệu: Không có quy luật. Các dòng bị thiếu trông      │
│  │               giống hệt phần còn lại.                         │
│  │     Kiểm tra: Biểu đồ nhiệt trực quan / Kiểm định MCAR Little │
│  │     Rủi ro:   Thấp — an toàn để xóa dòng HOẶC điền khuyết     │
│  │     Ví dụ:    Người khảo sát vô tình bỏ sót ngẫu nhiên 1 câu  │
│  │                                                               │
│  ├── NHÁNH B: MAR — Thiếu Ngẫu nhiên Có Điều kiện                │
│  │     Dấu hiệu: Việc bị thiếu có tương quan với CÁC CỘT KHÁC,   │
│  │               KHÔNG phụ thuộc vào chính giá trị bị thiếu đó.  │
│  │     Kiểm tra: Tương quan giữa cờ báo thiếu với các cột khác   │
│  │     Rủi ro:   Trung bình — dùng phương pháp điền khuyết theo  │
│  │               nhóm/có điều kiện                               │
│  │     Ví dụ:    Người trẻ tuổi thường bỏ trống mục thu nhập hơn │
│  │                                                               │
│  └── NHÁNH C: MNAR — Thiếu Không Ngẫu nhiên                      │
│        Dấu hiệu: Việc bị thiếu phụ thuộc TRỰC TIẾP vào chính     │
│                  giá trị đang bị thiếu đó.                       │
│        Kiểm tra: Kiến thức miền nghiệp vụ + so sánh phân phối    │
│        Rủi ro:   CAO — có thể gây thiên lệch nghiêm trọng        │
│        Hành động: Tham vấn chuyên gia + tạo cột cờ chỉ báo       │
│        Ví dụ:    Người thu nhập cao chủ đích không khai thu nhập │
└──────────────────────────────────────────────────────────────────┘
```

**Đối với mỗi cột bị gắn cờ thiếu dữ liệu, hãy điền vào thẻ phân tích này:**

```
┌─────────────────────────────────────────────────────┐
│  THẺ PHÂN TÍCH CỘT DỮ LIỆU (COLUMN ANALYSIS CARD)   │
├─────────────────────────────────────────────────────┤
│  Tên Cột          :                                 │
│  Tỷ lệ Thiếu (%)  :                                 │
│  Kiểu Dữ liệu     :                                 │
│  Là Biến đích (y)?: YES / NO                        │
│  Cơ chế Thiếu     : MCAR / MAR / MNAR               │
│  Bằng chứng       : (tại sao bạn kết luận như vậy)  │
│  Việc bị thiếu có :                                 │
│    mang thông tin?: YES (tạo cờ chỉ báo) / NO       │
│  Hành động Đề xuất: (xem Giai đoạn 3)               │
└─────────────────────────────────────────────────────┘
```

---

## GIAI ĐOẠN 3 — KHUNG QUYẾT ĐỊNH PHƯƠNG ÁN XỬ LÝ (TREATMENT DECISION FRAMEWORK)
### *Áp dụng các quy tắc theo đúng thứ tự nghiêm ngặt. Không được bỏ bước.*

---

### QUY TẮC 0 — CỘT MỤC TIÊU (y) — ƯU TIÊN CAO NHẤT

```
NẾU cột bị thiếu CHÍNH LÀ biến mục tiêu (y):
  → LUÔN LUÔN xóa bỏ những dòng đó — TUYỆT ĐỐI KHÔNG tự điền khuyết cho biến mục tiêu
  → df.dropna(subset=[TARGET_COL], inplace=True)
  → Lý do: Mô hình không thể học từ dữ liệu không có nhãn thật
```

---

### QUY TẮC 1 — KIỂM TRA NGƯỠNG TỶ LỆ THIẾU (Missing %)

```
┌───────────────────────────────────────────────────────────────┐
│  NẾU tỷ lệ thiếu > 60%:                                       │
│    → PHƯƠNG ÁN A: Xóa bỏ hoàn toàn cột đó                     │
│      (Ngoại lệ: nghiệp vụ đánh dấu là cột tối quan trọng      │
│       → gắn cờ hỏi chuyên gia)                                │
│    → PHƯƠNG ÁN B: Giữ lại + tạo cột cờ chỉ báo nhị phân       │
│      (col_was_missing = 1) sau đó mới quyết định cách điền    │
│                                                               │
│  NẾU 30% < tỷ lệ thiếu ≤ 60%:                                 │
│    → Dùng kỹ thuật điền khuyết nâng cao: KNN hoặc MICE        │
│      (IterativeImputer)                                       │
│    → Luôn tạo cột cờ chỉ báo thiếu dữ liệu trước tiên         │
│    → Cân nhắc điền trung bình/yếu vị theo từng nhóm điều kiện │
│                                                               │
│  NẾU tỷ lệ thiếu ≤ 30%:                                       │
│    → Chuyển tiếp sang QUY TẮC 2                               │
└───────────────────────────────────────────────────────────────┘
```

---

### QUY TẮC 2 — ĐIỀU HƯỚNG THEO KIỂU DỮ LIỆU

```
┌───────────────────────────────────────────────────────────────────────┐
│  DẠNG SỐ — Liên tục (float):                                          │
│    ├─ Phân phối đối xứng (trung bình ≈ trung vị) → Điền Trung bình    │
│    ├─ Phân phối lệch (có giá trị ngoại lai)      → Điền Trung vị      │
│    ├─ Chuỗi thời gian / các dòng có thứ tự       → Điền tiến / Nội suy│
│    ├─ MAR (tương quan với các cột khác)          → Trung bình nhóm    │
│    └─ Quan hệ đa biến phức tạp                   → KNN / MICE         │
│                                                                       │
│  DẠNG SỐ — Rời rạc / Đếm (int):                                       │
│    ├─ Ít giá trị riêng biệt (Low cardinality)    → Điền Yếu vị (Mode) │
│    └─ Nhiều giá trị riêng biệt (High cardinality)→ Trung vị hoặc KNN  │
│                                                                       │
│  PHÂN LOẠI — Định danh không thứ tự (Nominal):                        │
│    ├─ Ít giá trị riêng biệt  → Điền Yếu vị (Mode imputation)          │
│    ├─ Nhiều giá trị riêng biệt → Gán nhãn mới "Unknown" / "Missing"   │
│    └─ Nghi ngờ là MNAR       → Gán nhãn có ý nghĩa "Not_Provided"     │
│                                                                       │
│  PHÂN LOẠI — Có thứ bậc (Ordinal):                                    │
│    ├─ Thứ bậc tự nhiên rõ ràng → Điền theo hạng trung vị (Median-rank)│
│    └─ Thuộc dạng MCAR / MAR    → Điền Yếu vị (Mode imputation)        │
│                                                                       │
│  NGÀY GIỜ (DATETIME):                                                 │
│    ├─ Dữ liệu tuần tự        → Điền tiến (Forward) → Điền lùi (Back)  │
│    └─ Khoảng trống ngẫu nhiên → Nội suy (Interpolation)               │
│                                                                       │
│  LOGIC / NHỊ PHÂN (BOOLEAN / BINARY):                                 │
│    └─ Điền Yếu vị (Mode imputation) (hoặc xử lý như biến phân loại)   │
└───────────────────────────────────────────────────────────────────────┘
```

---

### QUY TẮC 3 — HƯỚNG DẪN LỰA CHỌN PHƯƠNG PHÁP ĐIỀN KHUYẾT NÂNG CAO

```
┌─────────────────────────────────────────────────────────────────┐
│  KHI NÀO NÊN SỬ DỤNG TỪNG PHƯƠNG PHÁP NÂNG CAO                  │
│                                                                 │
│  Trung bình/Yếu vị theo Nhóm (Group-wise Mean/Mode):            │
│    → Khi dữ liệu thiếu dạng MAR phụ thuộc vào một cột phân nhóm │
│    → Ví dụ: điền thu nhập NaN bằng trung bình theo nhóm tuổi    │
│    → Thực tế và chính xác hơn nhiều so với trung bình toàn cục  │
│                                                                 │
│  KNN Imputer (mặc định k=5):                                    │
│    → Khi tồn tại nhiều cột số có tương quan chặt chẽ với nhau   │
│    → Tìm k dòng đầy đủ gần nhất và lấy trung bình giá trị       │
│    → Chạy chậm hơn trên các tập dữ liệu kích thước lớn          │
│                                                                 │
│  MICE / IterativeImputer:                                       │
│    → Mạnh mẽ nhất — mô hình hóa từng cột dựa trên mọi cột khác  │
│    → Tốt nhất cho dữ liệu MAR có quan hệ đa biến phức tạp       │
│    → Dùng max_iter=10, random_state=42 để đảm bảo tính tái lập  │
│    → Tiêu tốn tài nguyên tính toán nhiều nhất                   │
│                                                                 │
│  Cờ Chỉ báo Thiếu dữ liệu (Missingness Indicator Flag):         │
│    → Luôn phải thêm đối với các cột thuộc dạng MNAR             │
│    → Tùy chọn nhưng được khuyến nghị cho các cột thiếu từ 30%+  │
│    → Tạo cột: col_was_missing = 1 nếu là NaN, ngược lại bằng 0  │
│    → Báo cho mô hình biết "giá trị này bị vắng mặt" như 1 tín hiệu│
└─────────────────────────────────────────────────────────────────┘
```

---

### QUY TẮC 4 — TÍNH TƯƠNG THÍCH VỚI MÔ HÌNH HỌC MÁY (ML MODEL)

```
┌─────────────────────────────────────────────────────────────────┐
│  Mô hình dựa trên Cây (XGBoost, LightGBM, CatBoost, RandomForest):│
│    → Có khả năng tự xử lý trực tiếp giá trị NaN                 │
│    → Vẫn khuyến nghị: tạo cột cờ chỉ báo cho các cột MNAR       │
│                                                                 │
│  Mô hình Tuyến tính (LogReg, LinearReg, Ridge, Lasso):          │
│    → BẮT BUỘC phải điền khuyết — không chấp nhận bất kỳ NaN nào │
│                                                                 │
│  Mạng Nơ-ron / Học sâu (Neural Networks / Deep Learning):       │
│    → BẮT BUỘC phải điền khuyết — không chấp nhận NaN            │
│                                                                 │
│  SVM, KNN Classifier:                                           │
│    → BẮT BUỘC phải điền khuyết — không chấp nhận NaN            │
│                                                                 │
│  ⚠️  QUY TẮC BẤT DI BẤT DỊCH CHO MỌI MÔ HÌNH:                   │
│    → Chia tập huấn luyện/kiểm tra (train/test) TRƯỚC TIÊN       │
│    → Chỉ khớp (fit) bộ điền khuyết trên tập TRAIN               │
│    → Biến đổi (transform) cả TRAIN và TEST bằng bộ đã fit       │
│    → Không bao giờ fit trên toàn bộ tập dữ liệu — gây rò rỉ dữ liệu│
└─────────────────────────────────────────────────────────────────┘
```

---

## GIAI ĐOẠN 4 — BẢN THIẾT KẾ TRIỂN KHAI BẰNG PYTHON

```python
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

# ─────────────────────────────────────────────────────────────────
# STEP 0 — Load and copy DATA()
# ─────────────────────────────────────────────────────────────────
df = DATA().copy()

# ─────────────────────────────────────────────────────────────────
# STEP 1 — Standardize disguised missing values
# ─────────────────────────────────────────────────────────────────
DISGUISED_NULLS = ["?", "N/A", "n/a", "unknown", "none", "—", "-", ""]
df.replace(DISGUISED_NULLS, np.nan, inplace=True)

# ─────────────────────────────────────────────────────────────────
# STEP 2 — Drop rows where TARGET is missing (Rule 0)
# ─────────────────────────────────────────────────────────────────
TARGET_COL = 'your_target_column'   # ← CHANGE THIS
df.dropna(subset=[TARGET_COL], axis=0, inplace=True)

# ─────────────────────────────────────────────────────────────────
# STEP 3 — Separate features and target
# ─────────────────────────────────────────────────────────────────
X = df.drop(columns=[TARGET_COL])
y = df[TARGET_COL]

# ─────────────────────────────────────────────────────────────────
# STEP 4 — Train / Test Split BEFORE any imputation
# ─────────────────────────────────────────────────────────────────
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ─────────────────────────────────────────────────────────────────
# STEP 5 — Define column groups (fill these after Phase 1-2)
# ─────────────────────────────────────────────────────────────────
num_cols_symmetric  = []   # → Mean imputation
num_cols_skewed     = []   # → Median imputation
cat_cols_low_card   = []   # → Mode imputation
cat_cols_high_card  = []   # → 'Unknown' fill
knn_cols            = []   # → KNN imputation
drop_cols           = []   # → Drop (>60% missing or domain-irrelevant)
mnar_cols           = []   # → Indicator flag + impute

# ─────────────────────────────────────────────────────────────────
# STEP 6 — Drop high-missing or irrelevant columns
# ─────────────────────────────────────────────────────────────────
X_train = X_train.drop(columns=drop_cols, errors='ignore')
X_test  = X_test.drop(columns=drop_cols, errors='ignore')

# ─────────────────────────────────────────────────────────────────
# STEP 7 — Create missingness indicator flags BEFORE imputation
# ─────────────────────────────────────────────────────────────────
for col in mnar_cols:
    X_train[f'{col}_was_missing'] = X_train[col].isnull().astype(int)
    X_test[f'{col}_was_missing']  = X_test[col].isnull().astype(int)

# ─────────────────────────────────────────────────────────────────
# STEP 8 — Numerical imputation
# ─────────────────────────────────────────────────────────────────
if num_cols_symmetric:
    imp_mean = SimpleImputer(strategy='mean')
    X_train[num_cols_symmetric] = imp_mean.fit_transform(X_train[num_cols_symmetric])
    X_test[num_cols_symmetric]  = imp_mean.transform(X_test[num_cols_symmetric])

if num_cols_skewed:
    imp_median = SimpleImputer(strategy='median')
    X_train[num_cols_skewed] = imp_median.fit_transform(X_train[num_cols_skewed])
    X_test[num_cols_skewed]  = imp_median.transform(X_test[num_cols_skewed])

# ─────────────────────────────────────────────────────────────────
# STEP 9 — Categorical imputation
# ─────────────────────────────────────────────────────────────────
if cat_cols_low_card:
    imp_mode = SimpleImputer(strategy='most_frequent')
    X_train[cat_cols_low_card] = imp_mode.fit_transform(X_train[cat_cols_low_card])
    X_test[cat_cols_low_card]  = imp_mode.transform(X_test[cat_cols_low_card])

if cat_cols_high_card:
    X_train[cat_cols_high_card] = X_train[cat_cols_high_card].fillna('Unknown')
    X_test[cat_cols_high_card]  = X_test[cat_cols_high_card].fillna('Unknown')

# ─────────────────────────────────────────────────────────────────
# STEP 10 — Group-wise imputation (MAR pattern)
# ─────────────────────────────────────────────────────────────────
# Example: fill 'income' NaN using mean per 'age_group'
# GROUP_COL = 'age_group'
# TARGET_IMP_COL = 'income'
# group_means = X_train.groupby(GROUP_COL)[TARGET_IMP_COL].mean()
# X_train[TARGET_IMP_COL] = X_train[TARGET_IMP_COL].fillna(
#     X_train[GROUP_COL].map(group_means)
# )
# X_test[TARGET_IMP_COL] = X_test[TARGET_IMP_COL].fillna(
#     X_test[GROUP_COL].map(group_means)
# )

# ─────────────────────────────────────────────────────────────────
# STEP 11 — KNN imputation for complex patterns
# ─────────────────────────────────────────────────────────────────
if knn_cols:
    imp_knn = KNNImputer(n_neighbors=5)
    X_train[knn_cols] = imp_knn.fit_transform(X_train[knn_cols])
    X_test[knn_cols]  = imp_knn.transform(X_test[knn_cols])

# ─────────────────────────────────────────────────────────────────
# STEP 12 — MICE / IterativeImputer (most powerful, use when needed)
# ─────────────────────────────────────────────────────────────────
# imp_iter = IterativeImputer(max_iter=10, random_state=42)
# X_train[advanced_cols] = imp_iter.fit_transform(X_train[advanced_cols])
# X_test[advanced_cols]  = imp_iter.transform(X_test[advanced_cols])

# ─────────────────────────────────────────────────────────────────
# STEP 13 — Final validation
# ─────────────────────────────────────────────────────────────────
remaining_train = X_train.isnull().sum()
remaining_test  = X_test.isnull().sum()

assert remaining_train.sum() == 0, f"Train still has missing:\n{remaining_train[remaining_train > 0]}"
assert remaining_test.sum()  == 0, f"Test still has missing:\n{remaining_test[remaining_test > 0]}"

print("✅ No missing values remain. DATA() is ML-ready.")
print(f"   Train shape: {X_train.shape} | Test shape: {X_test.shape}")
```

---

## GIAI ĐOẠN 5 — BÁO CÁO TỔNG HỢP & QUYẾT ĐỊNH XỬ LÝ

Sau khi hoàn thành từ Giai đoạn 1–4, hãy xuất ra bản báo cáo theo đúng mẫu sau:

```
═══════════════════════════════════════════════════════════════
  BÁO CÁO XỬ LÝ GIÁ TRỊ BỊ THIẾU (MISSING VALUE TREATMENT REPORT)
═══════════════════════════════════════════════════════════════

1. TÓM TẮT TẬP DỮ LIỆU (DATASET SUMMARY)
   Kích thước (Shape):
   Tổng số ô thiếu   :
   Cột mục tiêu      :
   Bài toán ML       :
   Loại mô hình      :

2. BẢNG KIỂM KÊ DỮ LIỆU THIẾU (MISSINGNESS INVENTORY TABLE)
   | Cột | Tỷ lệ thiếu% | Kiểu dữ liệu | Cơ chế | Mang thông tin? | Phương pháp xử lý |
   |--------|----------|-------|-----------|--------------|-----------|
   | ...    | ...      | ...   | ...       | ...          | ...       |

3. NHẬT KÝ QUYẾT ĐỊNH (DECISIONS LOG)
   [Tên cột]: [Lý do lựa chọn phương pháp xử lý]
   [Tên cột]: [Lý do lựa chọn phương pháp xử lý]

4. CÁC CỘT ĐÃ XÓA BỎ (COLUMNS DROPPED)
   [Tên cột] — Lý do: [ví dụ: thiếu 72%, không phải cột quan trọng về nghiệp vụ]

5. CÁC CỜ CHỈ BÁO ĐÃ TẠO (INDICATOR FLAGS CREATED)
   [col_was_missing] — Lý do: [Nghi ngờ MNAR / tỷ lệ thiếu cao]

6. CÁC PHƯƠNG PHÁP ĐIỀN KHUYẾT ĐÃ SỬ DỤNG (IMPUTATION METHODS USED)
   [(Các) cột] → [Chiến lược đã dùng + lý giải]

7. CẢNH BÁO & TRƯỜNG HỢP BIÊN (WARNINGS & EDGE CASES)
   - Các cột MNAR cần chuyên gia nghiệp vụ xem xét lại
   - Các giả định đã đặt ra trong quá trình điền khuyết
   - Các cột được gắn cờ cần đánh giá lại sau khi hoàn tất EDA toàn diện
   - Bất kỳ giá trị rỗng trá hình nào đã phát hiện (?, N/A, 0, v.v.)

8. CÁC BƯỚC TIẾP THEO — Danh sách Kiểm tra Sau khi Điền khuyết
   ☐ So sánh phân phối dữ liệu trước và sau khi điền khuyết (biểu đồ histogram)
   ☐ Xác nhận tất cả các bộ điền khuyết (imputers) chỉ được fit trên tập TRAIN
   ☐ Xác thực không có hiện tượng rò rỉ dữ liệu (data leakage) từ cột mục tiêu
   ☐ Kiểm tra lại ma trận tương quan sau khi điền khuyết
   ☐ Kiểm tra độ cân bằng giữa các lớp nếu là bài toán phân loại
   ☐ Ghi chép tài liệu toàn bộ các bước biến đổi để đảm bảo tính tái lập

═══════════════════════════════════════════════════════════════
```

---

## CÁC RÀNG BUỘC & HÀNG RÀO BẢO VỆ (CONSTRAINTS & GUARDRAILS)

```
✅ LUÔN LUÔN PHẢI LÀM:
   → Thao tác trên bản sao df.copy() — không bao giờ làm thay đổi trực tiếp DATA() gốc
   → Xóa bỏ các dòng bị thiếu giá trị ở biến mục tiêu (y) — TUYỆT ĐỐI KHÔNG tự điền y
   → Chỉ huấn luyện (fit) tất cả các bộ điền khuyết trên dữ liệu TRAIN
   → Biến đổi (transform) tập TEST bằng các bộ điền khuyết đã fit sẵn (không fit lại)
   → Tạo cột cờ chỉ báo cho tất cả các cột thuộc dạng MNAR
   → Xác nhận không còn bất kỳ giá trị null nào trước khi đưa vào mô hình
   → Kiểm tra kỹ các giá trị thiếu trá hình (?, N/A, 0, chuỗi rỗng, "unknown")
   → Ghi lại mọi quyết định xử lý kèm theo lập luận giải thích rõ ràng

❌ TUYỆT ĐỐI KHÔNG BAO GIỜ ĐƯỢC LÀM:
   → Điền khuyết một cách mù quáng mà không kiểm tra phân phối dữ liệu trước
   → Xóa bỏ các cột mà không kiểm tra tầm quan trọng về mặt nghiệp vụ của chúng
   → Fit bộ điền khuyết trên toàn bộ tập dữ liệu trước khi chia train/test (GÂY RÒ RỈ DỮ LIỆU)
   → Phớt lờ các cột MNAR — chúng có thể làm mô hình bị chệch hướng nghiêm trọng
   → Áp dụng rập khuôn một chiến lược giống hệt nhau cho tất cả các cột
   → Mặc định cho rằng NaN là hình thức duy nhất mà một giá trị bị thiếu có thể biểu hiện
```

---

## THAM KHẢO NHANH — BẢNG TÓM TẮT CHIẾN LƯỢC (STRATEGY CHEAT SHEET)

| Tình huống | Chiến lược xử lý |
|-----------|----------|
| Cột mục tiêu (y) có chứa NaN | Xóa bỏ các dòng đó — tuyệt đối không điền khuyết |
| Cột bị thiếu > 60% | Xóa cột (hoặc tạo cờ chỉ báo + tham vấn chuyên gia) |
| Cột số, phân phối đối xứng | Điền bằng giá trị Trung bình (Mean imputation) |
| Cột số, phân phối lệch | Điền bằng giá trị Trung vị (Median imputation) |
| Cột số, dữ liệu chuỗi thời gian | Điền tiến (Forward fill) / Nội suy (Interpolation) |
| Cột phân loại, ít giá trị riêng biệt | Điền bằng giá trị Yếu vị (Mode imputation) |
| Cột phân loại, nhiều giá trị riêng biệt | Điền bằng nhãn danh mục mới 'Unknown' |
| Nghi ngờ dạng MNAR (mọi kiểu dữ liệu) | Tạo cờ chỉ báo + rà soát theo kiến thức miền |
| Dạng MAR, phụ thuộc vào nhóm | Điền Trung bình/Yếu vị theo từng nhóm (Group-wise mean/mode) |
| Quy luật đa biến phức tạp | Dùng KNN Imputer hoặc MICE |
| Mô hình dựa trên cây (XGBoost, v.v.) | Chấp nhận được NaN; nhưng vẫn nên gắn cờ cho cột MNAR |
| Mô hình Tuyến tính / Mạng Nơ-ron / SVM | Bắt buộc phải điền khuyết — không chấp nhận bất kỳ NaN nào |

---

*PROMPT() v1.0 — Được xây dựng cho chương trình IBM GEN AI Engineering / Phân tích Dữ liệu với Python*
*Khung tư duy: Chuỗi Tư duy (Chain of Thought - CoT) + Cây Tư duy (Tree of Thought - ToT)*
*Tài liệu tham khảo: Coursera — Xử lý Giá trị Bị thiếu trong Python (Dealing with Missing Values in Python)*