3 bài viết được gắn thẻ "Nghề nghiệp"

import numpy as np

# Mảng và hình dạng
a = np.array([[1, 2, 3], [4, 5, 6]])      # shape (2, 3)
print(a.shape, a.dtype, a.ndim)

# Vector hoá — nhanh hơn vòng lặp Python hàng chục lần
arr = np.arange(1_000_000)
print((arr * 2 + 1).sum())

# Broadcasting — quy tắc then chốt
diem = np.array([[8, 7, 9], [6, 8, 7]])       # (2, 3) — 2 học sinh, 3 môn
he_so = np.array([1.0, 1.5, 2.0])             # (3,)   — tự broadcast
print(diem * he_so)                            # (2, 3)

# Thống kê dọc theo trục
print(diem.mean(axis=1))     # điểm TB của từng học sinh → [8.0, 7.0]
print(diem.mean(axis=0))     # điểm TB của từng môn     → [7.0, 7.5, 8.0]

# Tạo dữ liệu giả để thử nghiệm
rng = np.random.default_rng(42)                # seed để tái lập kết quả
du_lieu = rng.normal(loc=100, scale=15, size=(1000, 5))

# Đại số tuyến tính — nền tảng của ML
X = np.array([[1, 2], [3, 4], [5, 6]])
print(X.T)                    # chuyển vị
print(X @ X.T)                # nhân ma trận
print(np.linalg.inv(np.array([[2.0, 1.0], [1.0, 3.0]])))

import pandas as pd

df = pd.read_csv("du-lieu.csv", parse_dates=["ngay"])

# Luôn khám phá trước khi làm gì khác
print(df.shape, df.dtypes.to_dict())
print(df.isna().mean().sort_values(ascending=False).head(10))
print(df.describe(include="all"))

# Biến đổi
df["doanh_thu"] = df["so_luong"] * df["don_gia"]
df["thang"] = df["ngay"].dt.to_period("M")
df["nhom"] = pd.cut(df["doanh_thu"], bins=[0, 1e6, 5e6, np.inf],
                    labels=["Thấp", "Trung bình", "Cao"])

# Nhóm
tom_tat = (df.groupby(["thang", "nhom"], observed=True)
             .agg(so_don=("id", "count"),
                  dt=("doanh_thu", "sum"),
                  tb=("doanh_thu", "mean"))
             .reset_index())

# Merge — như JOIN trong SQL
df_full = df.merge(khach_hang, on="khach_hang_id", how="left", validate="many_to_one")

import numpy as np

# Tích vô hướng = độ tương đồng
a = np.array([1, 2, 3])
b = np.array([2, 4, 6])            # b = 2a → cùng hướng
cos = (a @ b) / (np.linalg.norm(a) * np.linalg.norm(b))
print(f"Cosine similarity: {cos:.4f}")     # = 1.0

# PCA từ đầu — hiểu nó hoạt động thế nào
X = np.random.default_rng(42).normal(size=(200, 5))
X_tam = X - X.mean(axis=0)                 # 1. chuẩn hoá tâm
cov = np.cov(X_tam, rowvar=False)          # 2. ma trận hiệp phương sai
gia_tri_rieng, vector_rieng = np.linalg.eigh(cov)
idx = np.argsort(gia_tri_rieng)[::-1]      # 3. sắp xếp giảm dần
X_pca = X_tam @ vector_rieng[:, idx[:2]]   # 4. chiếu xuống 2 chiều

print(f"Tỷ lệ phương sai giữ lại: "
      f"{gia_tri_rieng[idx[:2]].sum() / gia_tri_rieng.sum():.2%}")

# Đạo hàm = hướng và tốc độ thay đổi → cơ sở của gradient descent
def ham_mat_mat(w):
    return (w - 3) ** 2 + 2          # cực tiểu tại w = 3


def dao_ham(w):
    return 2 * (w - 3)


# Gradient descent từ đầu
w = 0.0
learning_rate = 0.1
for buoc in range(50):
    grad = dao_ham(w)
    w -= learning_rate * grad
    if buoc % 10 == 0:
        print(f"Bước {buoc:>2}: w = {w:.6f}, loss = {ham_mat_mat(w):.6f}")

print(f"→ Hội tụ tại w = {w:.6f} (đáp án đúng: 3.0)")

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

df = pd.read_csv("du-lieu.csv")

# --- 1. Kiểm tra phân phối và outlier ---
fig, axes = plt.subplots(2, 3, figsize=(16, 9))
for ax, cot in zip(axes.ravel(), df.select_dtypes("number").columns[:6]):
    sns.histplot(df[cot].dropna(), kde=True, ax=ax, color="#2563eb")
    ax.set_title(f"Phân phối: {cot}")
plt.tight_layout()
plt.show()

# --- 2. Ma trận tương quan ---
plt.figure(figsize=(12, 10))
corr = df.select_dtypes("number").corr()
sns.heatmap(corr, annot=len(corr) <= 12, fmt=".2f", cmap="RdBu_r",
            center=0, square=True, cbar_kws={"shrink": 0.8})
plt.title("Ma trận tương quan")
plt.show()

# --- 3. Tìm tương quan mạnh với biến mục tiêu ---
muc_tieu = "gia"
tuong_quan = (corr[muc_tieu].drop(muc_tieu)
                        .sort_values(key=abs, ascending=False))
print("Tương quan với biến mục tiêu:")
print(tuong_quan.head(10).round(3))

import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score, confusion_matrix

# --- 1. Tách dữ liệu TRƯỚC khi làm bất cứ gì khác ---
X = df.drop(columns=["nhan"])
y = df["nhan"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y      # stratify giữ tỷ lệ lớp
)

# --- 2. Tiền xử lý bằng Pipeline (KHÔNG fit trên test!) ---
cot_so = X.select_dtypes("number").columns.tolist()
cot_chu = X.select_dtypes("object").columns.tolist()

tien_xu_ly = ColumnTransformer([
    ("so", Pipeline([
        ("dien_khuyet", SimpleImputer(strategy="median")),
        ("chuan_hoa", StandardScaler()),
    ]), cot_so),
    ("chu", Pipeline([
        ("dien_khuyet", SimpleImputer(strategy="constant", fill_value="Không rõ")),
        ("ma_hoa", OneHotEncoder(handle_unknown="ignore", sparse_output=False)),
    ]), cot_chu),
])

# --- 3. Pipeline hoàn chỉnh ---
model = Pipeline([
    ("tien_xu_ly", tien_xu_ly),
    ("phan_loai", RandomForestClassifier(random_state=42, n_jobs=-1)),
])

# --- 4. Cross-validation TRƯỚC khi tuning ---
diem_cv = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc")
print(f"ROC-AUC CV: {diem_cv.mean():.4f} ± {diem_cv.std():.4f}")

# --- 5. Tuning siêu tham số ---
luoi = {
    "phan_loai__n_estimators": [100, 300, 500],
    "phan_loai__max_depth": [None, 10, 20],
    "phan_loai__min_samples_leaf": [1, 2, 5],
}

tim_kiem = GridSearchCV(model, luoi, cv=5, scoring="roc_auc", n_jobs=-1, verbose=1)
tim_kiem.fit(X_train, y_train)
print(f"Bộ tham số tốt nhất: {tim_kiem.best_params_}")

# --- 6. Đánh giá trên tập test (CHỈ MỘT LẦN) ---
mo_hinh_tot_nhat = tim_kiem.best_estimator_
y_du_doan = mo_hinh_tot_nhat.predict(X_test)
y_xac_suat = mo_hinh_tot_nhat.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_du_doan))
print(f"ROC-AUC test: {roc_auc_score(y_test, y_xac_suat):.4f}")
print(f"Ma trận nhầm lẫn:\n{confusion_matrix(y_test, y_du_doan)}")

# --- 7. Feature importance ---
ten_dac_trung = mo_hinh_tot_nhat.named_steps["tien_xu_ly"].get_feature_names_out()
do_quan_trong = mo_hinh_tot_nhat.named_steps["phan_loai"].feature_importances_

for ten, diem in sorted(zip(ten_dac_trung, do_quan_trong),
                        key=lambda x: -x[1])[:10]:
    print(f"{ten:<40} {diem:.4f}")

# ❌ RÒ RỈ DỮ LIỆU: fit scaler trên TOÀN BỘ dữ liệu
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)          # đã "thấy" cả tập test!
X_train, X_test = train_test_split(X_scaled, ...)

# ✅ ĐÚNG: chỉ fit trên train (Pipeline làm việc này tự động)
X_train, X_test, y_train, y_test = train_test_split(X, y)
# rồi dùng Pipeline như ví dụ trên

from sklearn.dummy import DummyClassifier

# Luôn so sánh với baseline trước
baseline = DummyClassifier(strategy="most_frequent")
baseline.fit(X_train, y_train)
print(f"Baseline accuracy: {baseline.score(X_test, y_test):.4f}")

# Nếu model của bạn = 0.72 và baseline = 0.70 → model gần như vô dụng!

from sklearn.metrics import precision_recall_fscore_support

p, r, f1, _ = precision_recall_fscore_support(y_test, y_du_doan, average="binary")
print(f"Precision: {p:.4f} | Recall: {r:.4f} | F1: {f1:.4f}")

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# --- Chuẩn bị dữ liệu ---
X, y = make_classification(n_samples=5000, n_features=20, n_informative=12,
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler().fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

train_ds = TensorDataset(
    torch.tensor(X_train, dtype=torch.float32),
    torch.tensor(y_train, dtype=torch.float32).unsqueeze(1),
)
train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)


# --- Định nghĩa model ---
class MangPhanLoai(nn.Module):
    def __init__(self, so_dac_trung: int):
        super().__init__()
        self.mang = nn.Sequential(
            nn.Linear(so_dac_trung, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 1),
        )

    def forward(self, x):
        return self.mang(x)


thiet_bi = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = MangPhanLoai(X_train.shape[1]).to(thiet_bi)

ham_mat_mat = nn.BCEWithLogitsLoss()
bo_toi_uu = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(bo_toi_uu, patience=5, factor=0.5)

# --- Vòng lặp huấn luyện ---
so_vong = 50
lich_su = {"train_loss": [], "val_loss": []}

X_test_t = torch.tensor(X_test, dtype=torch.float32).to(thiet_bi)
y_test_t = torch.tensor(y_test, dtype=torch.float32).unsqueeze(1).to(thiet_bi)

for vong in range(so_vong):
    model.train()
    tong_loss = 0.0
    for xb, yb in train_loader:
        xb, yb = xb.to(thiet_bi), yb.to(thiet_bi)

        bo_toi_uu.zero_grad()
        du_doan = model(xb)
        loss = ham_mat_mat(du_doan, yb)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        bo_toi_uu.step()

        tong_loss += loss.item() * len(xb)

    # Đánh giá trên validation
    model.eval()
    with torch.no_grad():
        val_loss = ham_mat_mat(model(X_test_t), y_test_t).item()

    train_loss = tong_loss / len(train_ds)
    lich_su["train_loss"].append(train_loss)
    lich_su["val_loss"].append(val_loss)

    scheduler.step(val_loss)

    if (vong + 1) % 10 == 0:
        print(f"Vòng {vong + 1:>3}/{so_vong} — "
              f"train loss {train_loss:.4f} | val loss {val_loss:.4f} | "
              f"lr {bo_toi_uu.param_groups[0]['lr']:.2e}")

# --- Đánh giá cuối ---
model.eval()
with torch.no_grad():
    xac_suat = torch.sigmoid(model(X_test_t)).cpu().numpy().ravel()

from sklearn.metrics import roc_auc_score
print(f"\nROC-AUC: {roc_auc_score(y_test, xac_suat):.4f}")

# --- Cách 1: Dùng API (thực tế nhất hiện nay) ---
from openai import OpenAI

client = OpenAI()


def phan_tich_cam_xuc(doan_van: str) -> dict:
    phan_hoi = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content":
                "Bạn là chuyên gia phân tích cảm xúc. Trả về JSON với "
                "'cam_xuc' (tich_cuc|tieu_cuc|trung_tinh) và 'ly_do'."},
            {"role": "user", "content": doan_van},
        ],
        response_format={"type": "json_object"},
        temperature=0,
    )
    import json
    return json.loads(phan_hoi.choices[0].message.content)


print(phan_tich_cam_xuc("Sản phẩm giao nhanh, đóng gói cẩn thận. Rất hài lòng!"))

import numpy as np
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("keepitreal/vietnamese-sbert")


def tim_tai_lieu_lien_quan(cau_hoi: str, kho_tai_lieu: list[str], top_k: int = 3):
    """Tìm đoạn tài liệu liên quan nhất bằng độ tương đồng cosine."""
    vector_kho = model.encode(kho_tai_lieu, normalize_embeddings=True)
    vector_hoi = model.encode([cau_hoi], normalize_embeddings=True)[0]

    diem = vector_kho @ vector_hoi                    # cosine đã chuẩn hoá
    idx = np.argsort(diem)[::-1][:top_k]

    return [(kho_tai_lieu[i], float(diem[i])) for i in idx]


kho = [
    "Chính sách đổi trả: khách hàng được đổi trong 7 ngày.",
    "Phí vận chuyển nội thành là 30.000 đồng.",
    "Thời gian bảo hành sản phẩm điện tử là 12 tháng.",
]

for noi_dung, diem in tim_tai_lieu_lien_quan("Tôi muốn đổi hàng thì sao?", kho):
    print(f"[{diem:.3f}] {noi_dung}")

"""Đóng gói model thành API hoàn chỉnh."""
from contextlib import asynccontextmanager
from pathlib import Path

import joblib
import pandas as pd
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field


class DuLieuVao(BaseModel):
    dac_trung: list[float] = Field(min_length=20, max_length=20)


class KetQuaRa(BaseModel):
    du_doan: int
    xac_suat: float
    phien_ban_model: str


@asynccontextmanager
async def vong_doi(app: FastAPI):
    """Load model một lần khi khởi động — không load mỗi request."""
    duong_dan = Path("model/xgb_v1.2.0.joblib")
    if not duong_dan.exists():
        raise RuntimeError(f"Không tìm thấy model: {duong_dan}")

    app.state.model = joblib.load(duong_dan)
    app.state.phien_ban = duong_dan.stem.split("_")[-1]
    print(f"✅ Đã load model phiên bản {app.state.phien_ban}")
    yield
    app.state.model = None


app = FastAPI(title="API Dự đoán", lifespan=vong_doi)


@app.get("/suc-khoe")
async def suc_khoe():
    return {"trang_thai": "ok", "model": app.state.phien_ban}


@app.post("/du-doan", response_model=KetQuaRa)
async def du_doan(du_lieu: DuLieuVao):
    try:
        X = pd.DataFrame([du_lieu.dac_trung])
        du_doan = int(app.state.model.predict(X)[0])
        xac_suat = float(app.state.model.predict_proba(X)[0][1])
    except Exception as e:
        raise HTTPException(500, f"Lỗi suy luận: {e}") from e

    return KetQuaRa(du_doan=du_doan, xac_suat=xac_suat,
                    phien_ban_model=app.state.phien_ban)

from scipy.stats import ks_2samp
import numpy as np

def kiem_tra_drift(du_lieu_train: np.ndarray, du_lieu_hien_tai: np.ndarray,
                   nguong: float = 0.05) -> dict:
    """Kiểm định Kolmogorov-Smirnov cho từng đặc trưng."""
    ket_qua = {}
    for i in range(du_lieu_train.shape[1]):
        _, p_value = ks_2samp(du_lieu_train[:, i], du_lieu_hien_tai[:, i])
        ket_qua[f"dac_trung_{i}"] = {
            "p_value": round(p_value, 4),
            "co_drift": p_value < nguong,
        }
    so_drift = sum(1 for v in ket_qua.values() if v["co_drift"])
    print(f"⚠️ {so_drift}/{len(ket_qua)} đặc trưng có drift")
    return ket_qua

from sklearn.model_selection import (train_test_split, KFold, GroupKFold,
                                      TimeSeriesSplit, LeaveOneGroupOut)

# --- Dữ liệu độc lập, phân phối giống nhau ---
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2,
                                          random_state=42, stratify=y)

# --- Dữ liệu chuỗi thời gian: KHÔNG được chia ngẫu nhiên ---
# Chia ngẫu nhiên cho model "thấy tương lai" → kết quả đẹp giả tạo
tscv = TimeSeriesSplit(n_splits=5)
for train_idx, val_idx in tscv.split(X):
    ...

# --- Dữ liệu nhóm: cùng một khách hàng không được xuất hiện ở cả train và test ---
gkf = GroupKFold(n_splits=5)
for train_idx, val_idx in gkf.split(X, y, groups=df["khach_hang_id"]):
    ...

# --- Leave-one-group-out: kiểm tra khả năng tổng quát hoá sang nhóm mới ---
logo = LeaveOneGroupOut()
for train_idx, val_idx in logo.split(X, y, groups=df["khu_vuc"]):
    ...

from sklearn.metrics import (average_precision_score, precision_recall_curve,
                              brier_score_loss, log_loss, roc_curve, auc)
import numpy as np

ap = average_precision_score(y_test, y_xac_suat)              # PR-AUC
brier = brier_score_loss(y_test, y_xac_suat)                  # hiệu chuẩn
ll = log_loss(y_test, y_xac_suat)
print(f"PR-AUC: {ap:.4f} | Brier: {brier:.4f} | LogLoss: {ll:.4f}")

# Chọn ngưỡng theo mục tiêu nghiệp vụ, KHÔNG dùng 0.5 mặc định
precision, recall, nguong = precision_recall_curve(y_test, y_xac_suat)

# Ví dụ: cần precision >= 0.90, tìm recall tốt nhất có thể
idx = np.where(precision[:-1] >= 0.90)[0]
if len(idx):
    i = idx[np.argmax(recall[i])]
    print(f"Ngưỡng {nguong[i]:.3f} → precision {precision[i]:.3f}, recall {recall[i]:.3f}")

from sklearn.calibration import calibration_curve, CalibratedClassifierCV
import matplotlib.pyplot as plt

xac_suat_thuc, xac_suat_du_doan = calibration_curve(y_test, y_xac_suat, n_bins=10)

plt.figure(figsize=(7, 7))
plt.plot([0, 1], [0, 1], "k--", label="Hoàn hảo")
plt.plot(xac_suat_du_doan, xac_suat_thuc, "o-", label="Model")
plt.xlabel("Xác suất dự đoán")
plt.ylabel("Tỷ lệ dương thực tế")
plt.title("Biểu đồ hiệu chuẩn")
plt.legend()
plt.show()

# Hiệu chỉnh nếu model tự tin quá mức
model_hieu_chuan = CalibratedClassifierCV(model, method="isotonic", cv=5)
model_hieu_chuan.fit(X_train, y_train)

import pandas as pd

# Xây bảng dự đoán sai kèm thông tin ngữ cảnh
danh_gia = X_test.copy()
danh_gia["thuc_te"] = y_test.values
danh_gia["du_doan"] = y_du_doan
danh_gia["xac_suat"] = y_xac_suat

sai = danh_gia[danh_gia["thuc_te"] != danh_gia["du_doan"]]

# Phân tích lỗi theo từng nhóm
print(sai.groupby("khu_vuc").size().sort_values(ascending=False).head())
print(sai.groupby("nhom_tuoi").size().sort_values(ascending=False).head())

# Lỗi "tự tin nhưng sai" — nguy hiểm nhất
tu_tin_sai = sai[sai["xac_suat"].between(0.85, 0.999)]
print(f"Số dự đoán tự tin nhưng sai: {len(tu_tin_sai)} "
      f"({len(tu_tin_sai)/len(sai):.1%} tổng số lỗi)")

# Xem vài ví dụ cụ thể để hiểu nguyên nhân
print(tu_tin_sai[['khu_vuc', 'nhom_tuoi', 'xac_suat']].head(10))

# ❌ Tìm kiếm trong list — O(n), chậm khi dữ liệu lớn
danh_sach_email = ["a@x.com", "b@x.com", "c@x.com"]
if "c@x.com" in danh_sach_email:      # quét từng phần tử
    ...

# ✅ Dùng set — O(1)
tap_email = {"a@x.com", "b@x.com", "c@x.com"}
if "c@x.com" in tap_email:            # tra trực tiếp
    ...

# ❌ Bắt mọi lỗi, che giấu bug thật
try:
    ket_qua = xu_ly_du_lieu(duong_dan)
except Exception:
    pass

# ✅ Bắt lỗi cụ thể, log lại, xử lý đúng cách
import logging

logger = logging.getLogger(__name__)

try:
    with open(duong_dan, encoding="utf-8") as f:
        ket_qua = xu_ly(f.read())
except FileNotFoundError:
    logger.warning("Không tìm thấy file %s, dùng cấu hình mặc định", duong_dan)
    ket_qua = CAU_HINH_MAC_DINH
except json.JSONDecodeError as e:
    logger.error("File %s không phải JSON hợp lệ: %s", duong_dan, e)
    raise

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from decimal import Decimal


class PhuongThucThanhToan(ABC):
    """Interface cho mọi phương thức thanh toán."""

    @abstractmethod
    def thanh_toan(self, so_tien: Decimal) -> bool:
        ...

    @property
    @abstractmethod
    def ten(self) -> str:
        ...


@dataclass
class ThanhToanThe(PhuongThucThanhToan):
    so_the: str
    han_dung: str

    @property
    def ten(self) -> str:
        return f"Thẻ ****{self.so_the[-4:]}"

    def thanh_toan(self, so_tien: Decimal) -> bool:
        if so_tien <= 0:
            raise ValueError("Số tiền phải dương")
        # gọi cổng thanh toán...
        return True


@dataclass
class ThanhToanViDienTu(PhuongThucThanhToan):
    ma_vi: str
    so_du: Decimal = field(default=Decimal("0"))

    @property
    def ten(self) -> str:
        return f"Ví {self.ma_vi}"

    def thanh_toan(self, so_tien: Decimal) -> bool:
        if self.so_du < so_tien:
            return False
        self.so_du -= so_tien
        return True


for pt in [ThanhToanThe("4111111111111234", "12/28"),
           ThanhToanViDienTu("VI-001", Decimal("500000"))]:
    ok = pt.thanh_toan(Decimal("200000"))
    print(f"{pt.ten}: {'✅ thành công' if ok else '❌ thất bại'}")

import json
from pathlib import Path
from datetime import date
from decimal import Decimal

FILE = Path("chi-tieu.json")


def doc_du_lieu() -> list[dict]:
    if not FILE.exists():
        return []
    return json.loads(FILE.read_text(encoding="utf-8"))


def luu_du_lieu(ds: list[dict]) -> None:
    FILE.write_text(json.dumps(ds, ensure_ascii=False, indent=2), encoding="utf-8")


def them(so_tien: str, danh_muc: str, ghi_chu: str = "") -> None:
    ds = doc_du_lieu()
    ds.append({
        "ngay": date.today().isoformat(),
        "so_tien": str(Decimal(so_tien)),
        "danh_muc": danh_muc,
        "ghi_chu": ghi_chu,
    })
    luu_du_lieu(ds)
    print(f"✅ Đã thêm {so_tien} cho {danh_muc}")


def bao_cao_theo_danh_muc() -> None:
    ds = doc_du_lieu()
    if not ds:
        print("Chưa có dữ liệu.")
        return
    tong: dict[str, Decimal] = {}
    for item in ds:
        tong[item["danh_muc"]] = tong.get(item["danh_muc"], Decimal(0)) + Decimal(item["so_tien"])
    for danh_muc, so in sorted(tong.items(), key=lambda x: -x[1]):
        print(f"{danh_muc:<16} {so:>12,.0f} đ")
    print(f"{'TỔNG':<16} {sum(tong.values()):>12,.0f} đ")


if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Dùng: python chi_tieu.py them <số_tiền> <danh_mục>")
        print("      python chi_tieu.py bao-cao")
        sys.exit(1)

    lenh = sys.argv[1]
    if lenh == "them":
        them(sys.argv[2], sys.argv[3], " ".join(sys.argv[4:]))
    elif lenh == "bao-cao":
        bao_cao_theo_danh_muc()
    else:
        print(f"Lệnh không hợp lệ: {lenh}")