Tại Sao Script Python Của Bạn Chậm Đến Mức Bò Lê Khi Xử Lý Dữ Liệu Lớn
Chạy mô phỏng hoặc xử lý hàng triệu điểm dữ liệu thuần Python thật sự là cực hình. Tôi đã trải qua cảnh đó — nhìn chằm chằm vào một script mất 45 phút để xử lý dữ liệu mà một ngôn ngữ biên dịch xử lý xong trong 30 giây. Phần bực bội nhất là logic hoàn toàn đúng. Python đơn giản là không đủ nhanh.
Nguyên nhân gốc rễ không có gì ngạc nhiên. Python là ngôn ngữ thông dịch. Mỗi dòng đều phải đi qua trình thông dịch khi chạy — kiểm tra kiểu biến, phân giải tên phương thức, quản lý bộ nhớ động. Với ứng dụng web hay script đơn giản, chi phí này vô hình. Nhưng với tính toán số học — vòng lặp qua hàng triệu phần tử, mô phỏng lặp đi lặp lại, mô hình tài chính với nhiều nhánh điều kiện — chi phí đó cộng dồn rất nhanh.
NumPy là giải pháp tiêu chuẩn mà mọi người thường dùng, và nó giúp ích đáng kể. NumPy gọi code C được biên dịch sẵn bên dưới, nên các phép toán vector hóa trên toàn bộ mảng chạy rất nhanh. Nhưng khi bạn cần một vòng lặp tùy chỉnh — thuật toán lặp, mô phỏng vật lý, quy trình xử lý tín hiệu — bạn lại quay về Python chậm. NumPy không giúp được gì ở đó.
Đó là lúc Numba phát huy tác dụng. Numba là trình biên dịch JIT (Just-In-Time) cho Python. Thay vì chạy hàm qua trình thông dịch mỗi lần gọi, Numba biên dịch nó thành mã máy native ngay lần gọi đầu tiên. Mọi lần gọi sau đó đều trực tiếp chạy mã nhị phân đã biên dịch — và đó chính là nguồn gốc của tốc độ nhanh hơn 100 lần. Nếu bạn đang thực hiện tính toán số học nghiêm túc trong Python, đây có lẽ là công cụ có đòn bẩy cao nhất trong bộ công cụ của bạn.
Cài Đặt
Dependency bắt buộc duy nhất của Numba là NumPy, thứ mà hầu hết môi trường dữ liệu Python đã có sẵn. Cài đặt bằng lệnh:
pip install numbaNếu muốn tăng tốc GPU trên phần cứng NVIDIA, hãy cài CUDA Toolkit riêng từ trang NVIDIA trước, sau đó thêm:
pip install numba cuda-pythonVới mọi thứ trong hướng dẫn này, lệnh pip cơ bản là đủ. Kiểm tra cài đặt:
import numba
print(numba.__version__)Numba hoạt động tốt nhất với Python 3.9+ và NumPy 1.20+. Trên cài đặt cũ hơn, hãy nâng cấp trước khi gặp phải những lỗi biên dịch khó hiểu chẳng liên quan gì đến code thực tế của bạn.
Cấu Hình: Tận Dụng Tối Đa Numba
Decorator @jit — Điểm Khởi Đầu
Bắt đầu với decorator @jit — điểm vào đơn giản nhất. Thêm vào bất kỳ hàm nào, Numba sẽ biên dịch nó ngay lần gọi đầu tiên:
from numba import jit
import numpy as np
@jit
def sum_squares(arr):
total = 0.0
for i in range(len(arr)):
total += arr[i] ** 2
return total
data = np.random.rand(10_000_000)
result = sum_squares(data) # Lần gọi đầu tiên: biên dịch + chạyLần gọi đầu tiên kích hoạt quá trình biên dịch — hãy chờ một chút. Mọi lần gọi sau đó đều chạy trực tiếp mã máy đã biên dịch.
Dùng @njit để Đảm Bảo Hiệu Năng Thực Sự
@jit có cơ chế fallback âm thầm: nếu Numba không thể biên dịch hàm của bạn, nó sẽ lặng lẽ chạy như Python thông thường thay vì báo lỗi. Tiện lợi cho thử nghiệm nhanh. Nhưng nó che giấu vấn đề hiệu năng. Hãy dùng @njit (chế độ nopython) thay thế — nó báo lỗi ngay lập tức nếu có gì không thể biên dịch, giúp bạn biết chính xác cần sửa gì:
from numba import njit
@njit
def compute_distance(x1, y1, x2, y2):
return ((x2 - x1)**2 + (y2 - y1)**2) ** 0.5
# Numba sẽ báo lỗi ở đây nếu nó phải dùng Python thông thường
print(compute_distance(0.0, 0.0, 3.0, 4.0)) # 5.0Khi @njit báo lỗi, thông báo lỗi chỉ rõ phần không được hỗ trợ — thường là kiểu không phải số như string, dict Python thông thường, hoặc các class tùy chỉnh.
Vòng Lặp Song Song với parallel=True
Với các vòng lặp không phụ thuộc lẫn nhau, Numba có thể tự động phân phối công việc trên các nhân CPU bằng cách dùng prange (parallel range):
from numba import njit, prange
import numpy as np
@njit(parallel=True)
def parallel_sum_squares(arr):
total = 0.0
for i in prange(len(arr)): # prange, không phải range
total += arr[i] ** 2
return total
data = np.random.rand(10_000_000)
result = parallel_sum_squares(data)Numba tự động chia vòng lặp trên tất cả các nhân CPU có sẵn. Trên máy 8 nhân, đó là thêm 4–6 lần tốc độ chồng lên trên lợi ích JIT đã có.
Cache Mã Biên Dịch Ra Đĩa
Theo mặc định, Numba biên dịch lại hàm mỗi khi Python khởi động lại. Thêm cache=True để lưu mã nhị phân đã biên dịch ra đĩa:
@njit(cache=True)
def heavy_computation(arr):
result = np.zeros_like(arr)
for i in range(len(arr)):
result[i] = arr[i] ** 2 + arr[i] * 3 + 1.0
return resultLần chạy đầu tiên: biên dịch và lưu. Mọi lần chạy tiếp theo — kể cả sau khi khởi động lại Python — đều tải mã nhị phân từ cache ngay lập tức, không tốn chi phí biên dịch lại.
Numba Xử Lý Tốt Gì (và Không Tốt Gì)
Numba xuất sắc ở:
- Vòng lặp số học tùy chỉnh trên mảng NumPy
- Hàm tính toán nặng về toán học (lượng giác, lũy thừa, điều kiện trên số)
- Mô phỏng với nhiều nhánh logic
- Thuật toán lặp khó vector hóa gọn
Numba gặp khó khăn với:
- Xử lý chuỗi ký tự dưới bất kỳ hình thức nào
- Pandas DataFrame — trích xuất
.valuesđể lấy mảng NumPy trước - List của list Python — hãy dùng mảng NumPy 2 chiều thay thế
- Class Python tùy chỉnh với các phương thức phức tạp
Nút thắt cổ chai là Pandas hay xử lý chuỗi? Numba không phải công cụ phù hợp. Nhưng với tính toán số thuần túy trong vòng lặp, không có gì trong hệ sinh thái Python có thể so sánh được.
Kiểm Tra và Đánh Giá Mức Cải Thiện Hiệu Năng
Benchmark Trước Khi Tin Lời Quảng Cáo
Hãy tự chạy thử trước khi tin lời ai đó. Python thuần, NumPy và Numba đối đầu trực tiếp trên cùng một tác vụ — con số thực tế trên máy thực tế của bạn:
import numpy as np
from numba import njit
import time
def pure_python_sum(arr):
total = 0.0
for x in arr:
total += x ** 2
return total
def numpy_sum(arr):
return np.sum(arr ** 2)
@njit(cache=True)
def numba_sum(arr):
total = 0.0
for i in range(len(arr)):
total += arr[i] ** 2
return total
data = np.random.rand(5_000_000)
# Khởi động Numba (lần gọi đầu tiên biên dịch)
numba_sum(data)
for name, fn in [("Pure Python", pure_python_sum), ("NumPy", numpy_sum), ("Numba", numba_sum)]:
start = time.perf_counter()
for _ in range(5):
fn(data)
elapsed = (time.perf_counter() - start) / 5
print(f"{name}: {elapsed:.4f}s")Trên máy 8 nhân thông thường chạy Python 3.11, kết quả trông như thế này:
Pure Python: 1.8200s
NumPy: 0.0120s
Numba: 0.0035sNumba nhỉnh hơn NumPy ở đây vì arr ** 2 trong NumPy tạo ra một mảng trung gian trong bộ nhớ. Numba tính tổng bình phương trong một lượt duy nhất mà không cần phân bổ thêm bộ nhớ.
Luôn Khởi Động Trước Khi Đo
Đừng bao giờ tính lần gọi Numba đầu tiên vào benchmark. Quá trình biên dịch xảy ra ở lần gọi đầu — có thể mất 1–5 giây tùy vào độ phức tạp của hàm. Luôn chạy một lần khởi động trước:
# Khởi động với một mảng nhỏ
numba_sum(data[:100])
# Bây giờ đo thời gian chạy thật
start = time.perf_counter()
result = numba_sum(data)
print(f"Thời gian chạy: {time.perf_counter() - start:.4f}s")Với cache=True, chi phí biên dịch chỉ xảy ra một lần duy nhất. Sau đó, mã nhị phân từ cache tải ngay lập tức ở mọi phiên Python tiếp theo.
Kiểm Tra Kiểu Dữ Liệu Numba Đã Suy Luận
Vẫn chưa đạt được con số như kỳ vọng? Hãy kiểm tra kiểu dữ liệu mà Numba đã suy luận cho hàm của bạn:
numba_sum.inspect_types()Lệnh này in ra kiểu dữ liệu suy luận cho mọi biến. Thấy reflected list hay object ở đâu đó? Numba đã fallback về chế độ object chậm cho biến đó. Chuyển sang mảng NumPy hoặc dữ liệu có kiểu rõ ràng để khắc phục.
Kiểm Tra Thực Tế: Mô Phỏng Monte Carlo
Ước tính pi theo phương pháp Monte Carlo là bài kiểm tra kinh điển. Đây là kết quả với 100 triệu mẫu khi dùng Numba:
import numpy as np
from numba import njit, prange
import time
@njit(parallel=True, cache=True)
def monte_carlo_pi(n_samples):
inside = 0
for i in prange(n_samples):
x = np.random.random()
y = np.random.random()
if x**2 + y**2 <= 1.0:
inside += 1
return 4.0 * inside / n_samples
# Khởi động
monte_carlo_pi(1000)
start = time.perf_counter()
pi_estimate = monte_carlo_pi(100_000_000)
elapsed = time.perf_counter() - start
print(f"π ≈ {pi_estimate:.6f}")
print(f"Thời gian: {elapsed:.2f}s")100 triệu mẫu trong chưa đầy 2 giây. Vòng lặp Python thuần tương đương mất hơn 3 phút. Đó là khoảng cách biến một tác vụ batch chạy qua đêm thành thứ bạn chạy trong lúc nhâm nhi cà phê.
Quy luật này đúng ở mọi nơi. Bất kỳ vòng lặp Python nào thực hiện tính toán trên mảng đều là ứng viên. Thêm @njit(cache=True), đảm bảo đầu vào là mảng NumPy, và thông thường bạn sẽ thấy tốc độ tăng 50–200 lần so với Python thuần. Bắt đầu từ hàm chậm nhất, benchmark nó, rồi mở rộng ra từ đó.
