Bài 3: Làm việc với Dữ liệu lớn: NumPy & Pandas chuyên sâu

Ở Bài 2, chúng ta đã hiểu bản chất toán học của đại số tuyến tính và cách tối ưu hóa độ dốc. Tuy nhiên, khi huấn luyện các mô hình AI thực tế, lượng dữ liệu đầu vào không phải là một vài con số đơn lẻ mà là hàng triệu điểm ảnh, hàng tỷ từ ngữ hoặc các bảng cơ sở dữ liệu khổng lồ.

Nếu tiếp tục sử dụng các vòng lặp for hay danh sách (List) mặc định của Python để xử lý tập dữ liệu khổng lồ này, chương trình của bạn sẽ chạy chậm đến mức không thể chấp nhận được. Bài học này sẽ giúp bạn hiểu rõ nguyên nhân gốc rễ ở cấp độ phần cứng và cách khắc phục triệt để bằng cách tận dụng hai thư viện nền tảng của AI: NumPy và Pandas.

3.1 Vì sao vòng lặp For trong Python rất chậm?

Python là một ngôn ngữ thông dịch (interpreted language) có cơ chế định kiểu động (dynamic typing). Khi bạn tạo một danh sách thông thường my_list = [1, 2, 3], Python không lưu trữ các số nguyên này liên tiếp nhau trong bộ nhớ RAM. Thay vào đó, nó tạo ra một mảng các con trỏ (pointers), mỗi con trỏ trỏ đến một đối tượng Python đầy đủ (gọi là PyObject) nằm rải rác ở khắp nơi trong RAM.

Mỗi khi bạn thực hiện một vòng lặp for x in my_list, tại mỗi bước lặp, trình thông dịch Python bắt buộc phải thực hiện hàng loạt tác vụ ngầm (overhead):

• Kiểm tra kiểu dữ liệu (Type checking): Kiểm tra xem x ở bước lặp hiện tại là số nguyên, số thực hay chuỗi để quyết định phép toán phù hợp.
• Đóng/Mở hộp giá trị (Boxing/Unboxing): Trích xuất giá trị số thô nằm sâu bên trong cấu trúc đối tượng PyObject phức tạp.
• Quản lý bộ nhớ: Cập nhật số lượng tham chiếu (Reference counting) để dọn rác tự động.

3.2 Nguyên lý Vectorization (Vector hóa câu lệnh)

Vectorization (Vector hóa) là kỹ thuật lập trình thay thế các vòng lặp tường minh bằng các phép toán trực tiếp trên toàn bộ mảng dữ liệu. Thay vì viết vòng lặp xử lý từng phần tử một ở tầng Python chậm chạp, chúng ta đẩy toàn bộ logic lặp xuống tầng mã máy hiệu năng cao của thư viện NumPy.

Bên cạnh đó, các CPU hiện đại ngày nay đều hỗ trợ tập lệnh song song ở cấp phần cứng gọi là SIMD (Single Instruction Multiple Data - Một chỉ thị, nhiều dữ liệu). Công nghệ này cho phép CPU thực hiện một phép toán (ví dụ như phép nhân) trên nhiều ô nhớ cùng một lúc trong một chu kỳ xung nhịp duy nhất.

Hãy cùng so sánh hiệu năng trực quan giữa vòng lặp Python thuần và phép toán vector hóa của NumPy:

import time
import numpy as np

# Tạo 1 triệu phần tử
size = 1_000_000
python_list = list(range(size))
numpy_array = np.arange(size)

# Cách 1: Sử dụng vòng lặp Python thuần
start_time = time.time()
python_result = [x * 2 for x in python_list]
print(f"Thời gian chạy vòng lặp Python: {(time.time() - start_time) * 1000:.2f} ms")

# Cách 2: Sử dụng Vectorization của NumPy (Cực nhanh nhờ SIMD phần cứng)
start_time = time.time()
numpy_result = numpy_array * 2
print(f"Thời gian chạy Vectorization NumPy: {(time.time() - start_time) * 1000:.2f} ms")

3.3 Phép phát thanh (Broadcasting) trong NumPy

Trong đại số tuyến tính chuẩn, bạn chỉ có thể cộng hai ma trận có cùng kích thước chính xác với nhau. Tuy nhiên, trong học máy, chúng ta thường xuyên phải thực hiện các phép toán lệch chiều, ví dụ như cộng một vector độ lệch (bias) vào toàn bộ các dòng của một ma trận dữ liệu.

NumPy hỗ trợ cơ chế cực kỳ mạnh mẽ gọi là Broadcasting (Phát thanh). Cơ chế này tự động căn chỉnh và kéo dãn ảo kích thước của mảng nhỏ hơn để khớp với mảng lớn hơn trong lúc tính toán mà không hề sao chép thêm dữ liệu thật trong RAM, giúp tiết kiệm tài nguyên tối đa.

Hai mảng dữ liệu có thể thực hiện Broadcasting nếu kích thước các chiều của chúng thỏa mãn một trong hai quy tắc (xét từ phải qua trái):

1. Kích thước của chiều đó ở hai mảng bằng nhau.
2. Một trong hai mảng có kích thước của chiều đó bằng 1 (chiều này sẽ được phát thanh ảo để khớp với mảng còn lại).

Ví dụ minh họa Broadcasting:

Khi ta cộng $A + B$, NumPy nhận thấy chiều cuối cùng bằng nhau ($3 = 3$), và chiều thứ nhất của $B$ bằng $1$. NumPy sẽ tự động "nhân bản ảo" vector $B$ dọc theo chiều dòng để tạo thành ma trận kích thước $2 \times 3$ và cộng trực tiếp:

import numpy as np

# Tạo ma trận A kích thước (2, 3)
A = np.array([[1, 2, 3],
              [4, 5, 6]])

# Tạo vector B kích thước (3,) - NumPy sẽ hiểu là (1, 3) khi broadcast
B = np.array([10, 20, 30])

# Thực hiện cộng trực tiếp nhờ Broadcasting
result = A + B
print("Kết quả cộng:\n", result)

import numpy as np

matrix = np.arange(12).reshape(4, 3)      # shape (4, 3) — 4 dòng, 3 cột
row_bias = np.array([1, 2, 3, 4])         # shape (4,)  — 1 hệ số cho MỖI DÒNG

try:
    result = matrix + row_bias
except ValueError as e:
    print("Lỗi:", e)
    # Lỗi: operands could not be broadcast together with shapes (4,3) (4,)
    # NumPy so khớp chiều CUỐI trước: 3 (của matrix) vs 4 (của row_bias) -> không khớp

# ✅ Sửa bằng cách thêm 1 chiều ảo, biến (4,) thành (4, 1) — reshape hoặc np.newaxis
row_bias_col = row_bias[:, np.newaxis]    # hoặc row_bias.reshape(4, 1)
result = matrix + row_bias_col            # (4,3) + (4,1) -> hợp lệ, cộng theo TỪNG DÒNG
print("Kết quả cộng theo dòng:\n", result)

Quy tắc ghi nhớ: vector phẳng (N,) mặc định broadcast theo CỘT (mỗi phần tử ứng với 1 cột, lặp lại cho mọi dòng). Muốn broadcast theo DÒNG, bạn phải chủ động chuyển nó thành vector cột (N, 1) bằng reshape hoặc np.newaxis trước.

3.4 Dự án thực hành bài 3: Tiền xử lý và chuẩn hóa tập dữ liệu ảnh động

Dự án thực hành của bài học này là viết chương trình tải một tập dữ liệu gồm nhiều bức ảnh xám (giả lập dưới dạng mảng 3 chiều có kích thước Batch x Height x Width), thực hiện tính toán vector hóa để tìm giá trị trung bình (Mean), độ lệch chuẩn (Std) và áp dụng kỹ thuật Min-Max Scaling để chuẩn hóa toàn bộ điểm ảnh về khoảng giá trị $[0, 1]$ mà hoàn toàn không được sử dụng bất kỳ vòng lặp for nào.

Dưới đây là mã nguồn Python chi tiết thực hiện quy trình chuẩn hóa dữ liệu ảnh chuyên nghiệp này:

import numpy as np

def generate_dummy_images(num_images=100, height=28, width=28):
    # Tạo dữ liệu ảnh giả lập ngẫu nhiên với phân phối nguyên (0-255)
    # Giả lập ảnh có độ sáng và nhiễu khác nhau
    np.random.seed(42)
    raw_data = np.random.randint(0, 256, size=(num_images, height, width), dtype=np.uint8)
    return raw_data

def preprocess_images(images):
    # Kiểm tra kiểu dữ liệu đầu vào
    if not isinstance(images, np.ndarray):
        raise TypeError("Dữ liệu đầu vào phải là một mảng NumPy ndarray!")
        
    # Chuyển đổi kiểu dữ liệu sang float32 để tính toán độ chính xác cao
    images_float = images.astype(np.float32)
    
    # 1. Tính toán thống kê toàn cục sử dụng vectorization (không dùng vòng lặp for)
    global_mean = np.mean(images_float)
    
    # Đối với Min-Max Scaling chuẩn hóa về [0, 1]:
    # X_normalized = (X - X_min) / (X_max - X_min)
    img_min = np.min(images_float)
    img_max = np.max(images_float)
    
    range_val = img_max - img_min
    if range_val == 0:
        range_val = 1.0
        
    normalized_images = (images_float - img_min) / range_val
    
    # 2. Tính toán Z-score Normalization để minh họa:
    # X_zscore = (X - mean) / std
    std_val = np.std(images_float)
    if std_val == 0:
        std_val = 1.0
    zscore_images = (images_float - global_mean) / std_val
    
    return normalized_images, zscore_images, global_mean, std_val

if __name__ == "__main__":
    print("=== Khởi tạo dữ liệu ảnh giả lập ===")
    raw_images = generate_dummy_images(num_images=10, height=28, width=28)
    print(f"Kích thước tập dữ liệu: {raw_images.shape} (Batch x Height x Width)")
    print(f"Giá trị pixel lớn nhất ban đầu: {np.max(raw_images)}")
    print(f"Giá trị pixel nhỏ nhất ban đầu: {np.min(raw_images)}")
    
    print("\n=== Đang tiến hành tiền xử lý và chuẩn hóa Vectorized (NumPy) ===")
    norm_imgs, z_imgs, mean, std = preprocess_images(raw_images)
    
    print(f"Giá trị trung bình toàn cục (Mean): {mean:.4f}")
    print(f"Độ lệch chuẩn toàn cục (Std): {std:.4f}")
    
    print("\n=== Kết quả sau chuẩn hóa Min-Max [0, 1] ===")
    print(f"Kích thước mảng kết quả: {norm_imgs.shape}")
    print(f"Giá trị nhỏ nhất sau Min-Max: {np.min(norm_imgs):.4f}")
    print(f"Giá trị lớn nhất sau Min-Max: {np.max(norm_imgs):.4f}")
    
    print("\n=== Kết quả sau chuẩn hóa Z-score (Mean=0, Std=1) ===")
    print(f"Giá trị trung bình mới: {np.mean(z_imgs):.4f} (Mong đợi: ~0.0)")
    print(f"Độ lệch chuẩn mới: {np.std(z_imgs):.4f} (Mong đợi: ~1.0)")

Tóm tắt bài học & Cầu nối kiến thức

Cầu nối bài tiếp theo: NumPy rất mạnh trên CPU, nhưng để huấn luyện các mạng nơ-ron sâu phức tạp trên chip đồ họa GPU, chúng ta cần chuyển giao diện sang thư viện chuyên dụng PyTorch và cơ chế tính toán đạo hàm tự động Autograd ở Bài số 4.