Hành Trình Của Dữ Liệu: Từ SQL đến PyTorch Qua Lăng Kính Lập Trình Hướng Đối Tượng

Tuần vừa rồi, mình đã được học về SQL, về Lập trình Hướng đối tượng (OOP), về Cấu trúc dữ liệu và cả cách tạo một Class tùy chỉnh trong PyTorch. Lúc đầu, mình tự hỏi: "Mấy thứ này liên quan gì đến nhau?". Nhưng sau khi kết nối các điểm lại, mình nhận ra một bức tranh lớn vô cùng thú vị.

Trong bài viết này, chúng ta hãy cùng nhau theo dấu chân của một mẩu dữ liệu, xem nó "tiến hóa" như thế nào từ một hàng trong cơ sở dữ liệu SQL, được "mặc áo" OOP, và cuối cùng trở thành đầu vào cho một mô hình Deep Learning trong PyTorch nhé!

Giai đoạn 1: Ngôi Nhà Của Dữ Liệu - Cơ Sở Dữ Liệu SQL

Mọi câu chuyện về dữ liệu thường bắt đầu ở một nơi: cơ sở dữ liệu. Giả sử chúng ta đang xây dựng một hệ thống gợi ý sản phẩm và có một bảng products trong database như sau:

SQL

CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(255),
    category VARCHAR(100),
    price FLOAT,
    rating FLOAT
);

Để lấy dữ liệu ra, chúng ta chỉ cần một câu lệnh SELECT đơn giản:

SQL

SELECT id, name, category, price, rating FROM products WHERE rating > 4.5;

Kết quả trả về thường là một danh sách các hàng (rows), mỗi hàng là một tập hợp các giá trị (101, 'Tai nghe ABC', 'Electronics', 55.99, 4.7). Nhưng làm việc trực tiếp với các mẩu dữ liệu "trần trụi" này trong một chương trình Python lớn sẽ rất khó quản lý và dễ gây lỗi. Đó là lúc OOP tỏa sáng.

Giai đoạn 2: "Hộ Chiếu" Cho Dữ Liệu - Đóng Gói Với Class

Lập trình Hướng đối tượng (OOP) cho phép chúng ta tạo ra những "khuôn mẫu" để đóng gói dữ liệu và các hành vi liên quan vào một nơi duy nhất gọi là Object. Thay vì truyền đi một tuple lộn xộn, chúng ta sẽ tạo một class Product để đại diện cho mỗi sản phẩm.

Python

# file: models.py

class Product:
    """
    Một class đơn giản để đại diện cho một sản phẩm.
    Đây chính là việc ánh xạ một hàng trong bảng SQL thành một đối tượng Python.
    """
    def __init__(self, id, name, category, price, rating):
        self.id = id
        self.name = name
        self.category = category
        self.price = price
        self.rating = rating

    def __repr__(self):
        # Phương thức này giúp in đối tượng ra một cách thân thiện hơn
        return f"<Product(id={self.id}, name='{self.name}')>"

# Bây giờ, dữ liệu của chúng ta trông "xịn" hơn nhiều:
product_obj = Product(101, 'Tai nghe ABC', 'Electronics', 55.99, 4.7)
print(product_obj)
# Output: <Product(id=101, name='Tai nghe ABC')>

Bằng cách này, dữ liệu của chúng ta giờ đây đã có "danh tính" rõ ràng. Chúng ta có thể truy cập thuộc tính một cách tường minh (product_obj.price) thay vì nhớ thứ tự cột (row[3]).

Giai đoạn 3: Dây Chuyền Sản Xuất - Pipeline Với Custom PyTorch Dataset

Khi đã có các đối tượng Product, làm thế nào để đưa chúng vào một mô hình Machine Learning? Đây là lúc kiến thức về Custom PyTorch Class và Data Structures phát huy tác dụng.

PyTorch cung cấp một class trừu tượng là torch.utils.data.Dataset. Chúng ta có thể kế thừa từ nó để tạo ra một "dây chuyền" cung cấp dữ liệu cho mô hình. Class này yêu cầu chúng ta phải implement hai phương thức quan trọng: __len__ (để biết có bao nhiêu mẫu dữ liệu) và __getitem__ (để lấy một mẫu dữ liệu tại một chỉ số cụ thể).

Python

# file: dataset.py
import torch
from torch.utils.data import Dataset

# Giả sử chúng ta đã lấy được danh sách các đối tượng Product từ database
# all_products = [Product(...), Product(...), ...]

class ProductDataset(Dataset):
    """
    Class này kế thừa từ Dataset của PyTorch, biến danh sách các đối tượng
    Product của chúng ta thành một nguồn dữ liệu mà PyTorch có thể hiểu.
    """
    def __init__(self, product_objects_list, feature_transform=None):
        self.products = product_objects_list
        self.transform = feature_transform

    def __len__(self):
        # Trả về tổng số sản phẩm trong dataset
        return len(self.products)

    def __getitem__(self, idx):
        # Lấy một sản phẩm tại vị trí idx
        product = self.products[idx]

        # Giả sử chúng ta chỉ muốn dùng giá và rating làm feature
        # để dự đoán một thứ gì đó.
        # Đây là bước "vector hóa" dữ liệu.
        features = torch.tensor([product.price, product.rating], dtype=torch.float32)

        # Giả sử chúng ta muốn dự đoán category (đã được mã hóa thành số)
        # Ví dụ: 'Electronics' -> 0, 'Books' -> 1, ...
        # (Phần mã hóa này thường được làm ở bước tiền xử lý)
        label = torch.tensor(self._encode_category(product.category), dtype=torch.long)

        return features, label

    def _encode_category(self, category):
        # Hàm giả định để mã hóa category
        if category == 'Electronics':
            return 0
        return 1

Giai đoạn 4: Điểm Đến Cuối Cùng - Mô Hình Deep Learning

Cuối cùng, dữ liệu của chúng ta, sau khi đã được chuẩn hóa và đóng gói trong ProductDataset, sẽ đi đến đích cuối: mô hình PyTorch. Và đoán xem? Mô hình này cũng là một Class kế thừa từ torch.nn.Module!

Python

# file: network.py
import torch.nn as nn

class SimpleRecommender(nn.Module):
    """
    Một mô hình PyTorch đơn giản, cũng là một class OOP!
    """
    def __init__(self, input_features, num_classes):
        super(SimpleRecommender, self).__init__()
        # __init__ là nơi chúng ta định nghĩa các "tầng" của mạng neural
        self.layer1 = nn.Linear(input_features, 16)
        self.relu = nn.ReLU()
        self.output_layer = nn.Linear(16, num_classes)

    def forward(self, x):
        # forward là nơi dữ liệu "chảy" qua các tầng đã định nghĩa
        x = self.layer1(x)
        x = self.relu(x)
        x = self.output_layer(x)
        return x

Tổng kết: Bức Tranh Toàn Cảnh

Vậy là hành trình đã hoàn tất! Hãy cùng nhìn lại toàn bộ luồng đi của dữ liệu:

SQL Database -> (Câu lệnh SELECT) -> Dữ liệu thô (rows) -> (Áp dụng class Product) -> Đối tượng Product (OOP) -> (Đưa vào ProductDataset) -> PyTorch Dataset -> (DataLoader) -> Tensor -> (forward()) -> Mô hình PyTorch (OOP) -> Kết quả dự đoán

OOP không chỉ là một lý thuyết khô khan về class và object. Nó chính là chất keo kết dính các thành phần khác nhau của một hệ thống phần mềm phức tạp, từ việc tương tác với cơ sở dữ liệu đến việc xây dựng các mô hình AI. Nó giúp code của chúng ta trở nên có cấu trúc, dễ đọc, dễ bảo trì và mở rộng hơn rất nhiều.

Hy vọng qua bài viết này, bạn cũng đã thấy được sự kết nối tuyệt vời giữa những kiến thức đã học. Cảm ơn đã đọc và chúc bạn code vui!