5 Python decorator giúp viết code AI sạch và dễ kiểm soát hơn

Nhờ đó, code trở nên sạch hơn, dễ đọc hơn và dễ mở rộng hơn, đặc biệt khi hệ thống bắt đầu phức tạp.

Bài viết này giới thiệu 5 decorator Python đã được nhiều developer sử dụng thực tế và chứng minh hiệu quả trong việc cải thiện chất lượng code AI. Các ví dụ minh họa sử dụng thư viện chuẩn của Python (như functools.wraps) để tập trung vào cách hoạt động của decorator, giúp bạn dễ dàng áp dụng vào dự án của mình.

Giới hạn concurrency khi gọi LLM

Khi làm việc với các mô hình ngôn ngữ lớn (LLM), đặc biệt là API bên thứ ba, bạn rất dễ gặp giới hạn về số lượng request — nhất là với gói miễn phí.

Decorator giới hạn concurrency giúp giải quyết vấn đề này bằng cách kiểm soát số lượng hàm bất đồng bộ được chạy cùng lúc. Thông qua cơ chế semaphore, nó tạo ra một lớp “điều tiết”, đảm bảo bạn không gửi quá nhiều request cùng lúc và tránh bị lỗi rate limit.

Đây là một giải pháp đơn giản nhưng rất hiệu quả để ổn định hệ thống khi tích hợp LLM.

import asyncio
from functools import wraps

def limit_concurrency(limit=5):
    sem = asyncio.Semaphore(limit)
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            async with sem:
                return await func(*args, **kwargs)
        return wrapper
    return decorator

# Application
@limit_concurrency(5)
async def fetch_llm_batch(prompt):
    return await async_api_client.generate(prompt)

Logger có cấu trúc cho hệ thống machine learning

Trong các hệ thống machine learning phức tạp, việc dùng print() gần như vô dụng, đặc biệt khi đã deploy production. Log rất dễ bị “trôi” và khó truy vết.

Decorator logging có cấu trúc giúp ghi lại quá trình thực thi và lỗi dưới dạng JSON. Điều này cho phép bạn tìm kiếm log nhanh hơn, dễ debug hơn và tích hợp tốt với các hệ thống monitoring.

Ví dụ, bạn có thể áp dụng decorator này cho hàm huấn luyện một epoch trong mô hình neural network để theo dõi chi tiết từng bước.

import logging, json, time
from functools import wraps

def json_log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        try:
            res = func(*args, **kwargs)
            logging.info(json.dumps({"step": func.__name__, "status": "success", "time": time.time() - start}))
            return res
        except Exception as e:
            logging.error(json.dumps({"step": func.__name__, "error": str(e)}))
            raise
    return wrapper

# Application
@json_log
def train_epoch(model, training_data):
    return model.fit(training_data)

Tự động tạo feature đầu vào (Feature Injector)

Trong giai đoạn triển khai model, một vấn đề rất phổ biến là đảm bảo dữ liệu đầu vào từ người dùng được xử lý giống hệt dữ liệu training ban đầu. Khi chuyển model từ môi trường notebook (như Jupyter) sang production (ví dụ FastAPI), việc lặp lại các bước transform dữ liệu thường khá phiền phức và dễ sai sót.

Decorator “feature injector” giải quyết vấn đề này bằng cách tự động thêm các feature cần thiết vào dữ liệu đầu vào trước khi đưa vào model. Nhờ đó, bạn đảm bảo được tính nhất quán mà không cần xử lý thủ công mỗi lần.

Ví dụ đơn giản là tự động thêm feature is_weekend dựa trên cột ngày trong dataset, xác định đó có phải thứ Bảy hoặc Chủ nhật hay không.

from functools import wraps

def add_weekend_feature(func):
    @wraps(func)
    def wrapper(df, *args, **kwargs):
        df = df.copy() # Prevents Pandas mutation warnings
        df['is_weekend'] = df['date'].dt.dayofweek.isin([5, 6]).astype(int)
        return func(df, *args, **kwargs)
    return wrapper

# Application
@add_weekend_feature
def process_data(df):
    # 'is_weekend' is guaranteed to exist here
    return df.dropna()

Cố định random seed để đảm bảo reproducibility

Trong quá trình thử nghiệm và tuning hyperparameter, kết quả model có thể thay đổi chỉ vì yếu tố ngẫu nhiên.

Decorator “seed setter” giúp cố định random seed, từ đó đảm bảo các lần chạy thử có thể so sánh công bằng với nhau. Điều này đặc biệt quan trọng khi bạn đang kiểm tra ảnh hưởng của một thay đổi, ví dụ như learning rate.

Nếu không kiểm soát seed, bạn sẽ khó biết sự thay đổi hiệu suất đến từ cấu hình mới hay chỉ đơn giản là do khởi tạo ngẫu nhiên không thuận lợi. Việc cố định seed giúp cô lập biến số và làm cho các thử nghiệm như A/B testing đáng tin cậy hơn.

import random, numpy as np
from functools import wraps

def lock_seed(seed=42):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            random.seed(seed)
            np.random.seed(seed)
            return func(*args, **kwargs)
        return wrapper
    return decorator

# Application
@lock_seed(42)
def initialize_weights():
    return np.random.randn(10, 10)

Fallback trong môi trường phát triển

Khi xây dựng ứng dụng AI — đặc biệt là các hệ thống như RAG — bạn thường phụ thuộc vào dịch vụ bên ngoài như API LLM. Nếu các dịch vụ này gặp lỗi (timeout, hết quota…), toàn bộ hệ thống có thể bị gián đoạn.

Decorator “dev-mode fallback” hoạt động như một lớp bảo vệ. Khi hàm gặp lỗi, thay vì crash, nó sẽ trả về dữ liệu giả lập (mock data) đã định nghĩa sẵn.

Điều này đặc biệt hữu ích trong môi trường phát triển hoặc CI/CD, giúp hệ thống vẫn chạy ổn định ngay cả khi dịch vụ bên ngoài gặp vấn đề tạm thời.

from functools import wraps

def fallback_mock(mock_data):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception: # Catches timeouts and rate limits
                return mock_data
        return wrapper
    return decorator

# Application
@fallback_mock(mock_data=[0.01, -0.05, 0.02])
def get_text_embeddings(text):
    return external_api.embed(text)

Các Python decorator trong bài viết không làm thay đổi logic cốt lõi của hệ thống AI, nhưng lại giúp tổ chức code tốt hơn và tăng độ tin cậy của toàn bộ pipeline.

Từ việc kiểm soát request LLM, logging có cấu trúc, đảm bảo tính nhất quán dữ liệu, cho tới kiểm soát randomness và xử lý lỗi, mỗi decorator giải quyết một vấn đề rất thực tế trong quá trình phát triển AI.

Khi kết hợp lại, chúng tạo thành một lớp “hạ tầng mềm” giúp code sạch hơn, dễ debug hơn và sẵn sàng cho production.