Ứng dụng CNN 1D trong trích xuất n-gram đặc trưng cảm xúc văn bản

Tóm tắt

• CNN 1D sử dụng cửa sổ trượt (kernel size) để quét qua chuỗi văn bản và trích xuất trực tiếp các n-gram đặc trưng.
• Kiến trúc này cho phép song sinh hóa tính toán, mang lại tốc độ vượt trội so với các mô hình tuần tự như LSTM hay RNN.
• Quy trình thực hiện bao gồm nhúng từ, tích chập 1D, gộp tối đa toàn cục (Global Max Pooling) và phân loại.
• Mã nguồn PyTorch thực tế minh họa cách thiết lập các bộ lọc bigram, trigram cho tác vụ phân tích cảm xúc.

Trong bài toán xử lý ngôn ngữ tự nhiên (NLP) hiện đại, việc phân tích thái độ của người dùng từ các đoạn bình luận hay đánh giá sản phẩm đòi hỏi mô hình vừa phải hiểu rõ ngữ cảnh, vừa phải đảm bảo tốc độ xử lý vượt trội. Khi đối mặt với các kiến trúc truyền thống như mạng tuần tự (RNN, LSTM), các kỹ sư thường gặp điểm nghẽn về khả năng song song hóa do tính chất phụ thuộc thời gian. Giải pháp thay thế hiệu quả và mang tính cách mạng chính là CNN 1D phân tích cảm xúc, tận dụng cơ chế cửa sổ trượt để quét qua các cụm từ liền kề.

Bài viết này sẽ đi sâu phân tích cơ chế kỹ thuật, quy trình thực hiện, ví dụ minh họa kèm mã nguồn Python và đánh giá ưu nhược điểm của việc ứng dụng mạng tích chập một chiều trong bài toán trích xuất n-gram đặc trưng cảm xúc văn bản.

---

Bản chất của CNN 1D và cách hoạt động trên chuỗi văn bản

Khác với mạng CNN 2D thường được sử dụng trong thị giác máy tính để xử lý ma trận điểm ảnh của hình ảnh, mạng tích chập 1D hoạt động trên không gian một chiều. Trong văn bản, sau khi các từ đã được chuyển đổi thành các vector nhúng (word embedding), một câu văn được biểu diễn thành một ma trận kích thước [Chiều dài câu x Số chiều embedding].

Cửa sổ trượt của bộ lọc tích chập (kernel size) sẽ quét qua chuỗi theo chiều dọc của văn bản (từ trên xuống dưới theo thứ tự từ). Mỗi kích thước kernel tương ứng với một độ dài n-gram cụ thể: * Kernel size = 2: Bắt cặp các cụm 2 từ (bigram). * Kernel size = 3: Bắt cặp các cụm 3 từ (trigram). * Kernel size = 4 hoặc lớn hơn: Bắt cặp các cụm từ dài hơn để nắm bắt ngữ cảnh rộng.

Nhờ cơ chế này, mạng có thể song song hóa toàn bộ quá trình tính toán cho mọi vị trí trong câu cùng một lúc, khắc phục hoàn toàn nhược điểm tính tuần tự của LSTM hay RNN (như đã phân tích tại So sánh các mạng neuron trong phân tích cảm xúc văn bản).

---

Quy trình chuẩn xây dựng pipeline CNN 1D cho văn bản

Phân tích cảm xúc với CNN 1D

Để xây dựng một hệ thống hoàn chỉnh nhận diện cảm xúc văn bản bằng CNN 1D, chúng ta cần tuân thủ một quy trình gồm các bước mạch lạc sau:

1. Tiền xử lý và Tách từ: Chuẩn hóa văn bản, chuyển về chữ thường và thực hiện tách từ (đặc biệt quan trọng với tiếng Việt để giữ nguyên cụm từ có nghĩa).
2. Chuyển đổi Embedding: Ánh xạ từng từ thành vector số thông qua các không gian nhúng như Word2Vec hoặc FastText (tham khảo thêm tại FastText Word Embedding: Cách biểu diễn từ bằng subword).
3. Tích chập 1D (1D Convolution): Áp dụng các bộ lọc với kích thước khác nhau để trích xuất các n-gram cục bộ.
4. Gộp tối đa theo chiều dọc (Global Max Pooling): Lọc ra đặc trưng nổi bật nhất từ mỗi bộ lọc, giúp mô hình tập trung vào từ khóa quyết định cảm xúc bất kể vị trí của chúng trong câu.
5. Phân loại Fully Connected: Đưa vector đặc trưng qua các lớp ẩn để dự đoán nhãn cảm xúc cuối cùng (Positive, Negative, Neutral).

---

Ví dụ minh họa bằng mã nguồn Python và PyTorch

Dưới đây là đoạn mã mô phỏng kiến trúc CNN 1D đơn giản bằng thư viện PyTorch để trích xuất n-gram và phân loại cảm xúc văn bản.

import torch
import torch.nn as nn
class SentimentCNN1D(nn.Module):
def __init__(self, vocab_size, embed_dim, num_filters, kernel_sizes, num_classes):
super(SentimentCNN1D, self).__init__()
# Lớp nhúng từ
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
# Các bộ lọc tích chập 1D cho các n-gram khác nhau
self.convs = nn.ModuleList([
            nn.Conv1d(in_channels=embed_dim, 
                      out_channels=num_filters, 
                      kernel_size=k)
for k in kernel_sizes
        ])
# Lớp Linear phân loại cuối cùng
self.fc = nn.Linear(len(kernel_sizes) * num_filters, num_classes)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
def forward(self, text):
# text shape: [batch_size, seq_len]
        embedded = self.embedding(text)
# embedded shape: [batch_size, seq_len, embed_dim]
# Chuyển đổi chiều cho Conv1d: [batch_size, embed_dim, seq_len]
        embedded = embedded.permute(0, 2, 1)

        conv_outputs = []
for conv in self.convs:
# Áp dụng tích chập và hàm kích hoạt ReLU
            c = self.relu(conv(embedded))
# Global Max Pooling theo chiều dài chuỗi
# [batch_size, num_filters, seq_len - k + 1] -> [batch_size, num_filters]
            pooled = torch.max(c, dim=2)[0]
            conv_outputs.append(pooled)
# Ghép nối các đặc trưng n-gram lại với nhau
        cat = torch.cat(conv_outputs, dim=1)
# [batch_size, len(kernel_sizes) * num_filters]

        out = self.fc(self.dropout(cat))
return out

# Khởi tạo mô hình thử nghiệm
vocab_size = 10000
embed_dim = 100
num_filters = 64
kernel_sizes = [2, 3, 4] # Bigram, Trigram, 4-gram
num_classes = 2 # Positive / Negative

model = SentimentCNN1D(vocab_size, embed_dim, num_filters, kernel_sizes, num_classes)
print(model)

Output khi khởi tạo chương trình:

SentimentCNN1D(
  (embedding): Embedding(10000, 100, padding_idx=0)
  (convs): ModuleList(
    (0): Conv1d(100, 64, kernel_size=(2,), stride=(1,))
    (1): Conv1d(100, 64, kernel_size=(3,), stride=(1,))
    (2): Conv1d(100, 64, kernel_size=(4,), stride=(1,))
  )
  (fc): Linear(in_features=192, out_features=2, bias=True)
  (relu): ReLU()
  (dropout): Dropout(p=0.5)
)

---

Sơ đồ khối cấu trúc thuật toán CNN 1D trong NLP

Để trực quan hóa cách dữ liệu di chuyển qua mạng, sơ đồ dưới đây mô tả cấu trúc dòng xử lý từ văn bản thô đến kết quả dự đoán cảm xúc:

[Văn bản đầu vào (Token IDs)]
             │
             ▼
    [Embedding Layer]  ──> Biểu diễn dạng vector [Batch, Seq_Len, Embed_Dim]
             │
             ▼
   [Permute / Chuyển vị] ──> Định dạng phù hợp cho Conv1d [Batch, Embed_Dim, Seq_Len]
             │
       ┌─────┼─────┐
       ▼     ▼     ▼
    [Conv2] [Conv3] [Conv4]  ──> Trích xuất n-gram tương ứng (Bigram, Trigram, 4-gram)
       │     │     │
       ▼     ▼     ▼
    [ReLU]  [ReLU] [ReLU]    ──> Kích hoạt phi tuyến tính
       │     │     │
       ▼     ▼     ▼
    [MaxP]  [MaxP] [MaxP]    ──> Global Max Pooling (Lấy đặc trưng mạnh nhất)
       └─────┼─────┘
             │
             ▼
      [Concatenate]  ──> Ghép nối toàn bộ đặc trưng n-gram [Batch, Total_Filters]
             │
             ▼
        [Dropout]
             │
             ▼
       [Linear Layer] ──> Đầu ra Logits phân loại cảm xúc

---

Đánh giá ưu điểm và hạn chế kỹ thuật

Ưu điểm vượt trội

• Tốc độ xử lý cao: Do không có liên kết hồi tiếp theo thời gian như LSTM, các phép toán tích chập hoàn toàn độc lập và có thể chạy song song trên GPU.
• Bắt giữ từ khóa cục bộ xuất sắc: Rất phù hợp với các bài toán đánh giá sản phẩm, nơi mà ý kiến thường được định đoạt bởi một vài cụm từ cụ thể (ví dụ: "dùng rất tốt", "quá tệ", "không đáng tiền").

Hạn chế cần lưu ý

• Giới hạn ngữ cảnh toàn cục: Cửa sổ trượt của CNN chỉ quét trên một phạm vi cục bộ xác định bởi kích thước kernel, khó nắm bắt các mối liên kết phụ thuộc xa trong các câu văn phức tạp hoặc dài dòng.
• Nhạy cảm với tiền xử lý: Nếu bước tách từ hoặc xử lý phủ định không tốt, mô hình dễ nhầm lẫn (xem thêm các lưu ý tại Các lỗi phổ biến khi xây Sentiment Analysis).

---

Kết luận

Ứng dụng CNN 1D trong trích xuất n-gram đặc trưng cảm xúc văn bản là một kỹ thuật mạnh mẽ, cân bằng hoàn hảo giữa tốc độ huấn luyện và độ chính xác trong các bài toán NLP thực tế. Bằng cách tận dụng các bộ lọc cửa sổ trượt, mô hình có thể phát hiện nhanh chóng các cụm từ mang sắc thái tích cực hoặc tiêu cực mà không đòi hỏi tài nguyên tính toán quá lớn như các mô hình Transformer quy mô lớn.