Machine Learning Concepts: Khi Máy tính "Học" từ Dữ liệu

Nếu bạn hỏi một người bình thường: "Machine Learning là gì?", câu trả lời thường là "AI thông minh, tự học mọi thứ". Nhưng thực tế, Machine Learning không phải phép màu - nó là toán học được áp dụng vào dữ liệu để tìm ra patterns (mẫu).

Hãy tưởng tượng bạn dạy trẻ con nhận biết chó và mèo. Bạn không viết rules kiểu "nếu có 4 chân + đuôi dài + kêu gâu gâu = chó". Thay vào đó, bạn cho trẻ xem hàng trăm ảnh chó và mèo, và não bộ trẻ tự học pattern để phân biệt.

Machine Learning hoạt động y chang vậy. Thay vì lập trình viên viết rules, ta cho máy tính học từ examples.

Phân loại Machine Learning: Supervised, Unsupervised, và các loại khác

1. Supervised Learning: "Học có thầy"

Bạn cung cấp cho máy tính cả input và output mong muốn. Máy học cách map từ input → output.

Ví dụ thực tế:

• Input: Ảnh email
• Output (label): Spam hoặc Not Spam
• Mục tiêu: Máy học cách phân loại email mới

Hai loại bài toán:

Classification (Phân loại): Output là category rời rạc

• Spam detection: {Spam, Not Spam}
• Image classification: {Chó, Mèo, Chim, ...}
• Sentiment analysis: {Positive, Negative, Neutral}

Regression (Hồi quy): Output là số liên tục

• Dự đoán giá nhà: $250,000
• Dự đoán nhiệt độ ngày mai: 28.5°C
• Dự đoán doanh thu tháng sau: $1.2M

Workflow điển hình:

1. Thu thập data có label: (email, spam/not spam)
2. Chia data: 80% training, 20% testing
3. Train model trên training data
4. Đánh giá model trên testing data
5. Deploy model để predict data mới

2. Unsupervised Learning: "Tự học không thầy"

Bạn chỉ cho máy input, không có label. Máy tự tìm ra structure ẩn trong data.

Clustering (Phân cụm):

• Nhóm khách hàng thành segments dựa trên hành vi mua hàng
• Phát hiện các nhóm gen tương đồng trong DNA
• Group tin tức theo chủ đề (không cần label sẵn)

Ví dụ K-Means Clustering:

Input: Thông tin khách hàng (tuổi, thu nhập, tần suất mua hàng)
Output: 3 clusters
  - Cluster 1: "Young professionals" (trẻ, thu nhập cao, mua thường xuyên)
  - Cluster 2: "Bargain hunters" (mọi lứa tuổi, nhạy cảm giá)
  - Cluster 3: "Occasional buyers" (mua ít, chi tiêu trung bình)

Dimensionality Reduction (Giảm chiều):

• Input: Data có 1000 features
• Output: Data chỉ còn 50 features nhưng vẫn giữ được 95% thông tin
• Use case: Visualization, tăng tốc training

Anomaly Detection:

• Phát hiện giao dịch ngân hàng bất thường (fraud detection)
• Phát hiện lỗi trong dây chuyền sản xuất

3. Semi-Supervised Learning: "Kết hợp hai thế giới"

Thực tế, label data rất đắt (cần con người label từng sample). Semi-supervised sử dụng một ít labeled data + nhiều unlabeled data.

Ví dụ:

• Có 100 ảnh X-quang có label (bệnh/không bệnh) + 10,000 ảnh chưa label
• Model học từ 100 ảnh labeled, sau đó tự label 10,000 ảnh còn lại (với độ tự tin cao)
• Retrain model với data mới → improve accuracy

4. Reinforcement Learning: "Học qua thử và sai"

Agent (tác nhân) học cách hành động trong environment để maximize reward (phần thưởng).

Ví dụ:

• AlphaGo học chơi cờ vây: thắng = +1 reward, thua = -1 reward
• Robot học đi: mỗi bước không넘어지넘어 = +0.1 reward,넘어지ǎ넘ł넘 = -10 reward
• Xe tự lái: đến đích an toàn = +100, va chạm = -1000

Workflow:

1. Agent quan sát state hiện tại (vị trí xe, tốc độ, vật cản...)
2. Agent chọn action (tăng tốc, phanh, rẽ trái...)
3. Environment cho reward và state mới
4. Agent update policy để chọn action tốt hơn lần sau

Bias-Variance Tradeoff: Bài toán cân bằng cốt lõi của ML

Đây là concept quan trọng nhất để hiểu tại sao model của bạn không hoạt động tốt.

Bias là gì?

Bias (độ chệch): Model quá đơn giản, không thể capture pattern phức tạp trong data.

Ví dụ:

• Data thực tế: Mối quan hệ giữa X và Y là đường cong
• Model: Linear regression (đường thẳng)
• Kết quả: Model không fit được data → high bias → Underfitting

Actual pattern:  ___/‾‾‾\___ (curved)
Model:          ____________ (straight line)

Dấu hiệu:

• Training error cao
• Test error cao
• Model "quá ngây thơ", miss các pattern quan trọng

Variance là gì?

Variance (độ phân tán): Model quá phức tạp, học cả noise trong training data thay vì chỉ học pattern thực.

Ví dụ:

• Data: 100 điểm với một chút random noise
• Model: Polynomial regression bậc 50 (cực kỳ phức tạp)
• Kết quả: Model fit HOÀN HẢO training data (kể cả noise) nhưng fail thảm hại trên test data → high variance → Overfitting

Training data:   • • •●• ••
Model curve:     ︵︶︵︶︵︶︵  (quá khớp từng điểm, kể cả noise)
Test data:       FAIL (model không generalize)

Dấu hiệu:

• Training error rất thấp
• Test error rất cao (gap lớn)
• Model "học vẹt" training data, không generalize được

The Tradeoff

Đây là mâu thuẫn không thể tránh khỏi:

• Tăng model complexity → giảm bias nhưng tăng variance
• Giảm model complexity → giảm variance nhưng tăng bias

Simple Model (Linear)        Complex Model (Deep NN)
  High Bias  ←────────────────→  High Variance
  Underfit                         Overfit

Sweet spot: Model vừa đủ phức tạp để capture pattern, nhưng không quá phức tạp để học noise.

Trong thực tế:

Model          Bias    Variance   Best for
-------------------------------------------------
Linear Reg     High    Low        Simple linear patterns
Decision Tree  Low     High       Non-linear but needs pruning
Random Forest  Medium  Medium     General purpose (good balance)
Deep NN        Low     Very High  Complex patterns + large data

Overfitting và Underfitting: Hai "kẻ thù" của Model

Underfitting: Model quá "ngây thơ"

Nguyên nhân:

• Model quá đơn giản (VD: dùng linear regression cho data phi tuyến)
• Training time quá ngắn (neural network chưa học đủ)
• Feature quá ít (thiếu thông tin quan trọng)

Giải pháp: ✅ Tăng complexity: Thêm layers (neural network), tăng depth (decision tree)
✅ Thêm features: Feature engineering để tạo features mới
✅ Train lâu hơn: Tăng số epochs
✅ Giảm regularization: Bỏ hoặc giảm penalty

Overfitting: Model "học vẹt"

Nguyên nhân:

• Model quá phức tạp so với lượng data
• Training quá lâu (neural network memorize training data)
• Quá nhiều features không liên quan (noise)

Giải pháp:

1. Regularization (L1/L2):

Thêm penalty vào loss function để model không được phép có weights quá lớn.

# L2 Regularization (Ridge)
Loss = MSE + λ * Σ(weights²)

# L1 Regularization (Lasso)
Loss = MSE + λ * Σ|weights|

• L2: Giảm weights nhưng không về 0 → giữ tất cả features
• L1: Có thể đưa weights về 0 → tự động feature selection

2. Dropout (Neural Networks):

Trong mỗi training iteration, randomly tắt một số neurons (VD: 50%).

# Dropout layer
x = Dense(128)(x)
x = Dropout(0.5)(x)  # Randomly disable 50% neurons

→ Buộc network không phụ thuộc quá nhiều vào một vài neurons cụ thể.

3. Early Stopping:

Monitor validation error trong quá trình training. Stop khi validation error bắt đầu tăng (sign of overfitting).

Epoch 1:  train_loss=0.5, val_loss=0.6
Epoch 2:  train_loss=0.3, val_loss=0.4
Epoch 3:  train_loss=0.2, val_loss=0.35  ← best
Epoch 4:  train_loss=0.1, val_loss=0.38  ← val_loss tăng, STOP!

4. Data Augmentation:

Tăng lượng training data bằng cách tạo variants.

Ví dụ với ảnh:

• Flip ngang/dọc
• Rotate 10-15 độ
• Zoom in/out
• Thêm noise nhẹ

→ Model học được nhiều variations, generalize tốt hơn.

5. Cross-Validation:

Thay vì chia data 1 lần (80/20), chia thành k folds và train k lần.

Fold 1: [Test] [Train] [Train] [Train] [Train]
Fold 2: [Train] [Test] [Train] [Train] [Train]
Fold 3: [Train] [Train] [Test] [Train] [Train]
...

Average kết quả từ k lần → đánh giá chính xác hơn.

Các Thuật toán Machine Learning Cơ bản

1. Linear Regression: "Vẽ đường thẳng qua data"

Mục tiêu: Tìm đường thẳng y = wx + b fit tốt nhất với data.

Ví dụ: Dự đoán giá nhà dựa trên diện tích

• Input (x): Diện tích (m²)
• Output (y): Giá (triệu VNĐ)
• Model học: Giá = 50 * Diện_tích + 200

Cách học:

• Minimize Mean Squared Error: MSE = (1/n) * Σ(y_actual - y_predicted)²
• Sử dụng Gradient Descent để tìm w và b tối ưu

Ưu điểm: Đơn giản, nhanh, interpretable
Nhược điểm: Chỉ fit được linear patterns

2. Logistic Regression: "Linear Regression cho Classification"

Mặc dù tên có "Regression" nhưng đây là classification algorithm.

Mục tiêu: Dự đoán xác suất một sample thuộc class nào.

Ví dụ: Dự đoán khách hàng có churn (rời bỏ) không

• Input: Tuổi, thu nhập, số lần complaint
• Output: P(Churn) = 0.75 → 75% khả năng churn

Công thức:

z = wx + b
P(y=1) = sigmoid(z) = 1 / (1 + e^(-z))

Sigmoid function "squash" output vào khoảng [0, 1] → interpret như probability.

Ưu điểm: Cho probability thay vì hard prediction, nhanh
Nhược điểm: Chỉ fit được linear decision boundary

3. Decision Tree: "Chuỗi câu hỏi Yes/No"

Model học một cây quyết định dựa trên các câu hỏi về features.

Ví dụ: Loan Approval

                  [Income > $50k?]
                 /              \
               Yes               No
              /                    \
    [Credit Score > 700?]     [Reject]
        /           \
      Yes           No
      /               \
  [Approve]       [Debt Ratio > 0.4?]
                     /          \
                   Yes          No
                   /              \
              [Reject]        [Approve]

Cách tree "học":

1. Chọn feature tốt nhất để split (dựa trên Information Gain hoặc Gini Impurity)
2. Chia data thành 2 nhánh
3. Recursively repeat cho mỗi nhánh
4. Stop khi đạt stopping criteria (max depth, min samples per leaf)

Ưu điểm:

• Rất interpretable (dễ giải thích cho non-technical stakeholders)
• Handle được non-linear patterns
• Không cần feature scaling

Nhược điểm:

• Dễ overfit (vì tree có thể grow vô tận)
• Unstable (data thay đổi chút có thể thay đổi tree hoàn toàn)

Solution: Random Forest = ensemble của nhiều decision trees

4. Support Vector Machine (SVM): "Tìm đường phân chia tốt nhất"

Mục tiêu: Tìm hyperplane phân chia 2 classes sao cho margin (khoảng cách đến điểm gần nhất) là lớn nhất.

Class A:  ○ ○ ○     |     ● ● ●  :Class B
              ○     |     ●
                 ○  |  ●
                    |
            ← margin →

Đường phân chia giữa có margin lớn nhất → generalize tốt nhất.

Kernel Trick: Data không linearly separable trong không gian ban đầu? Map lên không gian cao hơn!

2D space (không phân chia được):  ○●○●○●
                                   ●○●○●○

3D space (sau kernel):            ○○○○○○  (trên)
                                  ------  (hyperplane)
                                  ●●●●●●  (dưới)

Ưu điểm: Rất mạnh cho high-dimensional data, effective với small datasets
Nhược điểm: Chậm với large datasets, khó tune hyperparameters

Quy trình ML End-to-End: Từ Bài toán đến Production

1. Problem Definition

"Tôi muốn giải quyết vấn đề gì?"

❌ Mơ hồ: "Tăng doanh thu"
✅ Cụ thể: "Dự đoán khách hàng có khả năng churn để marketing team can thiệp sớm"

Xác định:

• Supervised hay Unsupervised?
• Classification hay Regression?
• Metrics để đánh giá success (accuracy? precision? recall?)

2. Data Collection & Exploration

Thu thập data:

• Từ database nội bộ
• Public datasets (Kaggle, UCI ML Repository)
• Web scraping (nếu legal)
• API của bên thứ 3

Exploratory Data Analysis (EDA):

# Understand data
df.info()              # Data types, missing values
df.describe()          # Statistics (mean, std, min, max)
df['column'].value_counts()  # Distribution

# Visualize
import matplotlib.pyplot as plt
df.hist(bins=50, figsize=(20,15))
plt.show()

# Correlation
correlation_matrix = df.corr()
sns.heatmap(correlation_matrix, annot=True)

Phát hiện:

• Missing values ở đâu?
• Outliers có không?
• Features nào correlate với target?
• Data có balanced không? (VD: 95% class A, 5% class B → imbalanced)

3. Data Preprocessing

Xử lý missing values:

# Option 1: Drop rows có missing
df.dropna()

# Option 2: Impute với mean/median/mode
df['age'].fillna(df['age'].median(), inplace=True)

# Option 3: Impute với model prediction

Feature Scaling:

Nhiều algorithms (SVM, neural networks, k-NN) nhạy cảm với scale của features.

# Normalization (scale về [0, 1])
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
df_normalized = scaler.fit_transform(df)

# Standardization (mean=0, std=1)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df_standardized = scaler.fit_transform(df)

Khi nào dùng gì?

• Normalization: Khi biết min/max hoặc muốn bounded range
• Standardization: Khi data có outliers hoặc không biết distribution

Feature Encoding:

ML models chỉ hiểu numbers, không hiểu text.

# One-Hot Encoding (cho categorical features không có order)
# Input:  ['Red', 'Blue', 'Red', 'Green']
# Output: Red  Blue  Green
#         1    0     0
#         0    1     0
#         1    0     0
#         0    0     1

pd.get_dummies(df['color'])

# Label Encoding (cho categorical có order)
# Input:  ['Low', 'High', 'Medium', 'Low']
# Output: [0, 2, 1, 0]  # Low=0, Medium=1, High=2

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
df['priority_encoded'] = encoder.fit_transform(df['priority'])

4. Feature Engineering

Đây là "nghệ thuật" tạo features mới từ features có sẵn để improve model performance.

Ví dụ với real estate:

# Raw features: area (m²), price (VNĐ)
df['price_per_sqm'] = df['price'] / df['area']

# Raw features: year_built
df['building_age'] = 2024 - df['year_built']

# Interaction features
df['location_x_area'] = df['location_score'] * df['area']

Domain knowledge rất quan trọng ở bước này!

5. Train/Test Split

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2,      # 80% train, 20% test
    random_state=42,    # Reproducibility
    stratify=y          # Giữ tỷ lệ classes giống nhau
)

Rule: KHÔNG BAO GIỜ sử dụng test set trong quá trình training hay tuning!

6. Model Selection & Training

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# Try multiple models
models = {
    'Logistic': LogisticRegression(),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier()
}

for name, model in models.items():
    model.fit(X_train, y_train)
    score = model.score(X_test, y_test)
    print(f"{name}: {score:.4f}")

7. Model Evaluation

Accuracy không phải lúc nào cũng là metric tốt!

Ví dụ: Fraud detection

• 99% transactions là legit, 1% là fraud
• Model "ngây thơ" predict tất cả là legit → Accuracy = 99%!
• Nhưng hoàn toàn vô dụng (miss hết fraud cases)

→ Cần metrics khác: Precision, Recall, F1-Score (sẽ đề cập kỹ trong bài tiếp).

8. Hyperparameter Tuning

Mỗi model có hyperparameters cần tune (learning rate, max depth, số trees...).

from sklearn.model_selection import GridSearchCV

param_grid = {
    'max_depth': [3, 5, 7, 10],
    'n_estimators': [50, 100, 200],
    'min_samples_split': [2, 5, 10]
}

grid_search = GridSearchCV(
    RandomForestClassifier(), 
    param_grid, 
    cv=5,  # 5-fold cross-validation
    scoring='f1'
)

grid_search.fit(X_train, y_train)
best_model = grid_search.best_estimator_

9. Deployment

Model trained xong, giờ phải đưa vào production!

# Save model
import joblib
joblib.dump(model, 'model.pkl')

# Load và predict
model = joblib.load('model.pkl')
prediction = model.predict(new_data)

Wrap model trong API (Flask/FastAPI) để các service khác call.

Key Takeaways

• Machine Learning không phải magic - nó là toán học + data + trial and error
• Supervised cần labels, Unsupervised tự tìm patterns, Reinforcement học qua thử sai
• Bias-Variance Tradeoff là core concept: model quá đơn giản = underfit, quá phức tạp = overfit
• Overfitting là kẻ thù số 1 → dùng regularization, dropout, early stopping, cross-validation
• Feature Engineering thường quan trọng hơn chọn algorithm fancy
• Accuracy không phải lúc nào cũng là metric tốt - phụ thuộc vào bài toán

Next steps:

• Thực hành với datasets trên Kaggle
• Hiểu sâu về evaluation metrics (Precision, Recall, F1, ROC-AUC)
• Học framework: scikit-learn (classical ML), TensorFlow/PyTorch (Deep Learning)

Trong bài tiếp theo, chúng ta sẽ đi sâu vào Data Engineering for ML - nghệ thuật xử lý, làm sạch, và transform data để model học hiệu quả nhất.

---

Bài viết thuộc series "From Zero to AI Engineer" - Module 4: ML Foundations