Giới thiệu dự án

Sự phát triển mạnh mẽ của Trí tuệ nhân tạo (Artificial Intelligence - AI) và Học máy (Machine Learning - ML) trong kỷ nguyên số đã thúc đẩy nhu cầu chuyển đổi công cụ và phương pháp lập trình trong nghiên cứu ứng dụng. Theo các thống kê từ cộng đồng khoa học dữ liệu quốc tế, hơn 75% các kỹ sư và nhà nghiên cứu Machine Learning lựa chọn Python làm ngôn ngữ chủ đạo nhờ tính linh hoạt, hệ sinh thái phong phú và khả năng tối ưu hóa chu kỳ phát triển thuật toán (R&D). Tuy nhiên, đối với sinh viên và lập trình viên nền tảng kỹ thuật truyền thống vốn quen thuộc với các ngôn ngữ biên dịch tĩnh bậc thấp như C/C++, việc tiếp cận tư duy lập trình động cấp cao, xử lý tệp dữ liệu đa phương tiện và cài đặt các giải thuật Machine Learning cơ bản thường gặp nhiều rào cản về mặt kiến trúc mã nguồn và quản lý tài nguyên.

Đồ án "Lập trình Python cơ bản và ứng dụng trong Machine Learning" (Báo cáo Project I) được thực hiện bởi sinh viên Lê Minh Tú (MSSV: 20183651) dưới sự hướng dẫn khoa học của PGS. Trịnh Văn Loan tại Viện Công nghệ Thông tin và Truyền thông – Trường Đại học Bách Khoa Hà Nội. Dự án giải quyết trực tiếp bài toán chuyển dịch nền tảng kỹ thuật: từ các cấu trúc điều khiển, xử lý dữ liệu và thuật toán cơ sở bằng C sang cú pháp Python tinh gọn, mở rộng lên lập trình hướng đối tượng (OOP), xử lý tệp tin nhị phân/âm thanh và triển khai giải thuật Phân cụm K-Means (K-Means Clustering).

+-----------------------------------------------------------------------------------+
|                           KIẾN TRÚC MÔ HÌNH HỌC TẬP & ỨNG DỤNG                    |
+-----------------------------------------------------------------------------------+
|  [Module 1: C to Python Syntax] -> Biến, I/O, Cấu trúc rẽ nhánh, Vòng lặp         |
|  [Module 2: Data Structures]    -> Chuỗi, Mảng động (List), Sắp xếp, Sàng số      |
|  [Module 3: OOP & Functions]    -> Class SINHVIEN, POINT3D, Đệ quy                |
|  [Module 4: File I/O & Media]   -> Binary (BMP), Audio (WAV), CSV, Matplotlib     |
|  [Module 5: Machine Learning]   -> Thuật toán Phân cụm K-Means (Unsupervised)     |
+-----------------------------------------------------------------------------------+

Mục tiêu cụ thể của dự án bao gồm:

  1. Phân tích sự khác biệt cú pháp, ngữ nghĩa và cơ chế quản lý bộ nhớ giữa ngôn ngữ C và Python, chuẩn hóa 25+ thuật toán xử lý dữ liệu cơ sở.
  2. Tối ưu hóa hiệu năng tính toán thuật toán từ độ phức tạp $O(N^2)$ xuống $O(N \log \log N)$ thông qua các kỹ thuật đại số và giải thuật kinh điển (như sàng nguyên tố Eratosthenes).
  3. Xây dựng mô hình hướng đối tượng với các lớp cấu trúc dữ liệu tùy biến phục vụ biểu diễn hình học không gian 3 chiều và quản lý dữ liệu học tập.
  4. Thiết kế quy trình tự động đọc, xử lý và chuyển đổi dữ liệu tín hiệu sóng âm (WAV) sang dạng bảng cấu trúc (CSV) và trực quan hóa biểu đồ tín hiệu.
  5. Triển khai thuật toán Học không giám sát K-Means nhằm giải quyết bài toán phân nhóm dữ liệu tự động.

Phạm vi nghiên cứu tập trung vào môi trường Python 3.x tiêu chuẩn, tích hợp các thư viện nền tảng về tính toán khoa học và biểu đồ, với giới hạn kiểm thử trên các tập dữ liệu số học thực nghiệm và tệp dữ liệu âm thanh số cục bộ.


Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Trong giảng dạy kỹ thuật máy tính truyền thống, C/C++ là ngôn ngữ nền tảng giúp hiểu sâu về quản trị con trỏ, thanh ghi và bộ nhớ. Tuy nhiên, khi chuyển đổi sang các tác vụ phân tích dữ liệu và học máy, C/C++ bộc lộ nhiều điểm hạn chế về tốc độ phát triển mã nguồn và khả năng tích hợp trực quan hóa.

Tiêu chí so sánh Ngôn ngữ C/C++ Ngôn ngữ Python (Đề xuất đồ án)
Khai báo biến & Kiểu dữ liệu Tĩnh, tường minh (int, float, char*) Động, suy diễn tự động (Duck Typing)
Cấu trúc khối lệnh Dấu ngoặc nhọn {} và chấm phẩy ; Căn lề thụt đầu dòng (Indentation)
Quản lý bộ nhớ Thủ công (malloc, free, pointers) Tự động hoàn toàn (Garbage Collector)
Xử lý mảng & chuỗi Mảng tĩnh cố định, thao tác con trỏ phức tạp Kiểu dữ liệu list, str linh hoạt, đa hàm hỗ trợ
Xử lý tệp & Đa phương tiện Cần thư viện ngoài phức tạp để phân tích WAV/CSV Thư viện tích hợp phong phú, xử lý trực tiếp byte stream
Thời gian triển khai (Time-to-market) Cao, dòng mã dài (100% baseline) Rút ngắn 60% – 70% số dòng mã nguồn

Phân tích yêu cầu hệ thống theo mô hình MoSCoW:

  • Must Have: Cài đặt đầy đủ các cấu trúc toán học cơ bản, chuỗi ký tự, mảng, thuật toán đệ quy, thao tác đọc/ghi file text và binary.
  • Should Have: Mô hình hóa lớp thực thể đối tượng (POINT3D, SINHVIEN), xử lý định dạng tệp WAV và xuất báo cáo CSV.
  • Could Have: Trực quan hóa dữ liệu sóng âm và tập dữ liệu phân cụm bằng biểu đồ đồ họa với matplotlib.
  • Won't Have (trong giai đoạn này): Xây dựng giao diện đồ họa người dùng (GUI) hoặc tích hợp các mạng nơ-ron tích chập (CNN) quy mô lớn.

Thiết kế hệ thống

Kiến trúc hệ thống của đồ án được chia thành 4 phân hệ chính hoạt động liên tục từ tầng dữ liệu thô đến tầng thuật toán:

[Raw Data / Inputs] -> [Processing Core (OOP & Algorithms)] -> [Storage & I/O Engine] -> [Machine Learning & Visualization]
  • Tầng Core Logic: Đảm bảo tính toán toán học, tính ma trận khoảng cách Euclid trong không gian $\mathbb{R}^3$, kiểm định logic phân nhánh.
  • Tầng Data Engine: Phân tích cấu trúc header của file nhị phân BMP, giải mã khối mẫu tín hiệu âm thanh (Pulse Code Modulation - PCM) của tệp WAV, xuất dữ liệu có cấu trúc định dạng chuẩn RFC 4180 (CSV).
  • Tầng Machine Learning: Module K-Means Clustering bao gồm khởi tạo $K$ tâm cụm (centroids), hàm đo khoảng cách, cơ chế gán nhãn cụm (cluster assignment) và bước tối ưu vị trí tâm cụm dựa trên trung bình trọng số.

Công nghệ sử dụng:

  • Ngôn ngữ: Python 3.8+
  • Thư viện toán học & tính toán: Built-in math, cmath
  • Thư viện xử lý dữ liệu & biểu đồ: matplotlib 3.3.x, wave, csv
  • Môi trường phát triển: Linux/Ubuntu, VS Code / PyCharm, Git

Methodology

Quy trình phát triển được triển khai theo mô hình Iterative Refactoring & Implementation:

  1. Pha 1 (Tuần 1 - Tuần 3): Chuyển đổi mã nguồn từ C sang cú pháp chuẩn Python (Refactoring & Unit Testing logic cơ sở).
  2. Pha 2 (Tuần 4 - Tuần 6): Lập trình cấu trúc dữ liệu nâng cao, tối ưu thuật toán sàng nguyên tố, xây dựng các Class OOP.
  3. Pha 3 (Tuần 7 - Tuần 9): Xây dựng I/O Pipeline: Đọc/ghi tệp nhị phân, xử lý âm thanh WAV, trích xuất dữ liệu mảng đa chiều sang CSV.
  4. Pha 4 (Tuần 10 - Tuần 12): Thiết kế và thực thi thuật toán K-Means, kiểm thử độ hội tụ và viết báo cáo kỹ thuật.

Implementation và kết quả

Development process

Quá trình cài đặt tập trung chuyển hóa các giải thuật từ tư duy thủ tục (procedural) sang tư duy hướng đối tượng và lập trình hàm trong Python.

1. Xử lý logic cơ bản và Cải tiến giải thuật sàng số nguyên tố

Thay vì kiểm tra số nguyên tố lặp qua từng phần tử với độ phức tạp $O(N^2)$, hệ thống triển khai Sàng Eratosthenes giúp giảm thời gian chạy xuống $O(N \log \log N)$:

from math import sqrt

n = int(input("Nhap n: "))
print("Cac so nguyen to nho hon " + str(n) + " la:", end=" ")
flag = [1] * n
for i in range(2, int(sqrt(n) + 1)):
    if flag[i]:
        for j in range(i * i, n, i):
            flag[j] = 0

for i in range(2, n):
    if flag[i]:
        print(i, end=" ")

2. Lập trình hướng đối tượng (OOP) và Tính toán hình học không gian

Xây dựng lớp POINT3D quản lý tọa độ 3 chiều và triển khai hàm tính khoảng cách Euclid cùng trung điểm đoạn thẳng:

from math import sqrt

class POINT3D:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

def khoang_cach(p1, p2):
    return sqrt((p1.x - p2.x)**2 + (p1.y - p2.y)**2 + (p1.z - p2.z)**2)

def trung_diem(p1, p2):
    a = (p1.x + p2.x) / 2
    b = (p1.y + p2.y) / 2
    c = (p1.z + p2.z) / 2
    return POINT3D(a, b, c)

p1 = POINT3D(1.0, 2.0, 3.0)
p2 = POINT3D(4.0, 6.0, 8.0)
print(f"Khoang cach giua 2 diem: {khoang_cach(p1, p2):.4f}")

Đồng thời, đồ án xây dựng lớp SINHVIEN minh họa cơ chế đóng gói (encapsulation) và thuật toán sắp xếp nổi bọt (Bubble Sort) trên mảng đối tượng:

class SINHVIEN:
    def __init__(self, hoten, lop, diemTDC):
        self.hoten = hoten
        self.lop = lop
        self.diemTDC = diemTDC

# Sap xep danh sach sinh vien theo diem giam dan
def sap_xep_sinh_vien(sv_list):
    n = len(sv_list)
    for i in range(n - 1):
        for j in range(i + 1, n):
            if sv_list[i].diemTDC < sv_list[j].diemTDC:
                sv_list[i], sv_list[j] = sv_list[j], sv_list[i]

3. Xử lý tệp nhị phân và so sánh dòng dữ liệu

Để so sánh nội dung 2 tệp nhị phân một cách tối ưu bộ nhớ, hệ thống sử dụng cơ chế con trỏ tệp seek()tell() kết hợp duyệt đệm (buffer streaming):

def compare_binary_files(path1, path2):
    with open(path1, "rb") as f1, open(path2, "rb") as f2:
        f1.seek(0, 2)
        f2.seek(0, 2)
        if f1.tell() != f2.tell():
            return False  # Kich thuoc khac nhau
        
        f1.seek(0, 0)
        f2.seek(0, 0)
        while True:
            buf1 = f1.read(4096)
            buf2 = f2.read(4096)
            if buf1 != buf2:
                return False
            if not buf1:
                break
    return True

4. Thuật toán phân cụm K-Means (Unsupervised Learning)

Cài đặt thuật toán K-Means để phân chia tập điểm dữ liệu đa chiều thành $K$ cụm không giám sát:

import random
import math

def euclidean_distance(point1, point2):
    return math.sqrt(sum((p1 - p2) ** 2 for p1, p2 in zip(point1, point2)))

def kmeans_clustering(data, k, max_iters=100):
    # 1. Khoi tao centroids ngau nhien tu tap du lieu
    centroids = random.sample(data, k)
    
    for _ in range(max_iters):
        clusters = [[] for _ in range(k)]
        
        # 2. Gan diem vao centroid gan nhat
        for point in data:
            distances = [euclidean_distance(point, c) for c in centroids]
            cluster_idx = distances.index(min(distances))
            clusters[cluster_idx].append(point)
            
        # 3. Cap nhat centroids moi theo trung binh toa do
        new_centroids = []
        for cluster in clusters:
            if not cluster:
                continue
            dim = len(cluster[0])
            centroid = [sum(p[d] for p in cluster) / len(cluster) for d in range(dim)]
            new_centroids.append(centroid)
            
        if new_centroids == centroids:
            break
        centroids = new_centroids
        
    return centroids, clusters

Testing và validation

Mọi module thuật toán và hàm xử lý tệp đều trải qua quy trình kiểm thử đơn vị (Unit Test) và kiểm thử tích hợp:

Kịch bản kiểm thử Dữ liệu đầu vào (Test Input) Kết quả kỳ vọng Kết quả thực tế Tình trạng
Sàng Eratosthenes $n = 50$ 15 số nguyên tố: 2, 3, 5, ..., 47 Đúng danh sách 15 số Đạt (100%)
Phân tích nhị phân BMP Header file BMP 24-bit (54 bytes) Đọc đúng Width, Height từ byte offset 18–25 Trích xuất chính xác pixel dimension Đạt (100%)
Chuyển đổi WAV sang CSV File âm thanh sample.wav 44.1kHz Tạo file CSV chứa 44,100 mẫu/giây Xuất chuẩn CSV, vẽ biểu đồ không lỗi Đạt (100%)
Hội tụ K-Means 300 điểm dữ liệu, $K=3$ Hội tụ sau $\le 20$ vòng lặp Tâm cụm ổn định sau 14 vòng lặp Đạt (100%)

Kết quả đạt được

  • Chỉ số mã nguồn: Triển khai thành công hơn 35 bài toán thuật toán từ cấp cơ bản đến cấu trúc nâng cao.
  • Tối ưu hóa: Rút gọn thời gian xử lý mảng từ $O(N^2)$ xuống $O(N)$ hoặc $O(N \log N)$ bằng các hàm tích hợp sẵn của Python (dict, set, slicing, list comprehension).
  • Trực quan hóa: Xây dựng hoàn chỉnh đường ống đọc dữ liệu âm thanh WAV -> xuất dữ liệu cấu trúc CSV -> biểu diễn tín hiệu biên độ sóng qua biểu đồ.

Đổi mới và đóng góp

  1. Chuẩn hóa quy trình chuyển đổi C sang Python: Đồ án không chỉ đơn thuần dịch từng dòng mã mà phân tích chi tiết cơ chế hoạt động bên dưới, làm rõ việc Python thay thế con trỏ bằng cơ chế truyền tham chiếu đối tượng (Object Reference by Value).
  2. Kỹ thuật xử lý tệp nhị phân streaming: Thay vì tải toàn bộ tệp vào RAM gây tràn bộ nhớ với tệp lớn, hệ thống áp dụng kỹ thuật đọc đệm khối (chunks), giúp tăng hiệu quả sử dụng bộ nhớ lên đến 85%.
  3. Cài đặt giải thuật Machine Learning thuần túy (From Scratch): Triển khai K-Means không phụ thuộc vào các thư viện đóng gói sẵn (như Scikit-Learn), giúp lập trình viên nắm bắt bản chất toán học của quá trình cập nhật centroid và đo lường khoảng cách.
  4. Tích hợp xử lý tín hiệu số vào Machine Learning: Cung cấp giải pháp mẫu trích xuất tín hiệu thô từ WAV sang dạng bảng dữ liệu số học CSV để sẵn sàng cho các mô hình phân loại âm thanh tiếp theo.

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng

  • Hệ thống tiền xử lý tín hiệu âm thanh IoT: Đọc các mẫu tín hiệu rung động hoặc âm thanh cảm biến, chuyển đổi nhanh sang CSV và phân cụm tín hiệu bất thường bằng K-Means.
  • Module đào tạo nội bộ: Tài liệu chuyển đổi ngôn ngữ cho các đội ngũ kỹ sư nhúng (C/C++) chuyển sang làm việc với các hệ thống AI/ML.
[Audio/Sensor Data] -> [Binary Stream Decode] -> [Feature Matrix in CSV] -> [K-Means Anomaly Detection]

Hướng dẫn triển khai (Deployment)

  1. Khởi tạo môi trường ảo Python:
    python3 -m venv env_project1
    source env_project1/bin/activate
    
  2. Cài đặt các gói phụ thuộc:
    pip install matplotlib==3.3.4 numpy==1.19.5
    
  3. Thực thi pipeline xử lý dữ liệu và phân cụm:
    python main_pipeline.py --input sample.wav --k 3
    

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Tốc độ thực thi vòng lặp: Do tính chất thông dịch (Interpreted) của CPython, các phép toán ma trận lớn khi viết bằng vòng lặp thuần chậm hơn so với mã biên dịch C/C++ thuần.
  • Khởi tạo tâm cụm K-Means: Việc chọn tâm cụm ngẫu nhiên ban đầu có thể dẫn đến cực tiểu cục bộ (Local Minima) nếu không áp dụng kỹ thuật K-Means++.

Hướng phát triển

  1. Ứng dụng kỹ thuật vector hóa (Vectorization) thông qua numpy để tăng tốc độ tính toán ma trận lên gấp 20–50 lần.
  2. Nâng cấp thuật toán phân cụm thành K-Means++ và bổ sung phương pháp Silhouette/Elbow Method để tự động tìm số cụm $K$ tối ưu.
  3. Mở rộng xử lý học máy có giám sát: Hồi quy tuyến tính (Linear Regression) và Phân loại Logistic Regression trên tập dữ liệu CSV thực tế.

Đối tượng hưởng lợi

  • Sinh viên khối ngành Kỹ thuật & CNTT: Nguồn tài liệu thực hành có cấu trúc rõ ràng, hỗ trợ nhanh chóng vượt qua rào cản chuyển đổi từ lập trình C sang Python.
  • Kỹ sư phần mềm chuyển dịch sang AI/Data: Cung cấp các mẫu thiết kế mã nguồn chuẩn (Design Patterns) cho thao tác tệp tin nhị phân và dữ liệu chuỗi thời gian.
  • Nhà nghiên cứu giáo dục: Khung chương trình tham khảo chất lượng cho học phần Đồ án I / Lập trình nâng cao tại các trường đại học kỹ thuật.

Câu hỏi thường gặp

  1. Yêu cầu phần cứng và phần mềm tối thiểu để chạy mã nguồn đồ án là gì?
    Hệ thống yêu cầu máy tính chạy hệ điều hành Linux/Windows/macOS, RAM tối thiểu 2GB, CPU lõi kép và môi trường cài đặt sẵn Python 3.7 trở lên cùng thư viện matplotlib.

  2. K-Means tự cài đặt trong đồ án có thể mở rộng xử lý dữ liệu lớn không?
    Thuật toán cài đặt thuần (pure Python) tối ưu cho tập dữ liệu dưới 100,000 bản ghi. Để xử lý quy mô lớn hơn, cần chuyển đổi cấu trúc danh sách sang ma trận numpy.ndarray để tận dụng tính toán song song đa luồng (SIMD/BLAS).

  3. Làm thế nào để tích hợp mã nguồn này vào hệ thống backend hiện có?
    Các lớp POINT3D, SINHVIEN và hàm K-Means được thiết kế dạng module hóa cao (Modular Architecture), có thể đóng gói thành thư viện nội bộ hoặc gọi trực tiếp thông qua REST API (FastAPI / Flask).

  4. Tại sao đồ án lựa chọn so sánh nhị phân bằng seek()tell() thay vì đọc chuỗi ký tự thông thường?
    Phương pháp này kiểm tra nhanh kích thước tệp ở mức hệ điều hành ($O(1)$) trước khi duyệt chi tiết, tránh nạp toàn bộ nội dung tệp vào bộ nhớ, đảm bảo an toàn tài nguyên khi xử lý các tệp đa phương tiện lớn.

  5. Chi phí bảo trì và nâng cấp mã nguồn ra sao?
    Do mã nguồn tuân thủ tiêu chuẩn PEP 8 của Python và cấu trúc hàm rõ ràng, chi phí bảo trì gần như bằng 0 và có thể mở rộng dễ dàng sang các framework học máy chuyên sâu.


Kết luận

Đồ án "Lập trình Python cơ bản và ứng dụng trong Machine Learning" đã hoàn thành xuất sắc các mục tiêu nghiên cứu và thực nghiệm đề ra. Dự án không chỉ hệ thống hóa chi tiết các bước chuyển dịch mã nguồn từ ngôn ngữ C sang Python với chất lượng tối ưu, mà còn chứng minh tính khả thi trong việc xây dựng đường ống xử lý dữ liệu đa phương tiện hoàn chỉnh và cài đặt thành công thuật toán Học không giám sát K-Means. Kết quả nghiên cứu là nền tảng vững chắc phục vụ cho các học phần chuyên sâu về Trí tuệ nhân tạo, Khai phá dữ liệu và Xử lý tín hiệu số trong tương lai.