Giới thiệu dự án

Trong kỷ nguyên số hóa và thị giác máy tính hiện đại, nhu cầu tiếp nhận và xử lý hình ảnh độ phân giải cao (High Resolution - HR) ngày càng trở nên thiết yếu trên các nền tảng truyền thông, y tế, an ninh giám sát và thiết bị di động. Tuy nhiên, hình ảnh kỹ thuật số trong thực tế thường xuyên bị suy giảm chất lượng, mờ nhòe do hạn chế về cảm biến quang học, điều kiện môi trường bất lợi, băng thông truyền tải hạn chế hoặc sự biến động của vật thể chuyển động. Việc phóng to hình ảnh bằng các kỹ thuật nội suy truyền thống (Nearest-neighbor, Bilinear, Bicubic) chỉ đơn thuần gia tăng số lượng điểm ảnh cục bộ mà không thể khôi phục hay tái tạo lại các chi tiết tần số cao bị mất mát.

Kỹ thuật Siêu phân giải đơn ảnh (Single Image Super-Resolution - SISR) ra đời nhằm giải quyết triệt để bài toán nghịch đảo phi tuyến phức tạp này: tái cấu trúc hình ảnh độ phân giải cao $\mathbf{I}{HR}$ từ một ảnh độ phân giải thấp $\mathbf{I}{LR}$ duy nhất. Mặc dù các mạng nơ-ron học sâu (Deep Learning) gần đây như VDSR (20 lớp tích chập), SRGAN hay RED30 (chứa hơn 4.200.000 tham số) đã thiết lập những bước đột phá về chất lượng thị giác, nhưng chi phí tính toán khổng lồ (FLOPs cao), dung lượng bộ nhớ RAM/VRAM lớn và độ trễ xử lý cao khiến chúng hầu như không thể triển khai trên các thiết bị nhúng hoặc chạy theo thời gian thực (Real-time edge processing).

Đề tài "Mô Hình Học Sâu Hiệu Quả Cho Siêu Phân Giải" do tác giả Nguyễn Thanh Bình thực hiện dưới sự hướng dẫn khoa học của TS. Ngô Quốc Việt tại Khoa Công nghệ Thông tin – Trường Đại học Sư phạm TP.HCM (2023) tập trung nghiên cứu, thiết kế và tối ưu hóa một kiến trúc mạng nơ-ron tích chập siêu nhẹ (Lightweight Deep CNN). Giải pháp hướng tới việc cân bằng hoàn hảo giữa độ chính xác tái tạo hình ảnh và hiệu năng tính toán vật lý.

       [Ảnh Low-Resolution (RGB)]
       [Chuyển đổi sang RGB]
      [Ảnh High-Resolution (HR)]

Mục tiêu cụ thể của dự án

  1. Thiết kế kiến trúc mạng CNN gọn nhẹ: Xây dựng mô hình tối ưu thông qua tích chập phân tách chiều sâu (Depthwise Separable Convolution) kết hợp học phần dư (Residual Learning).
  2. Triển khai cơ chế Post-Upsampling: Ứng dụng kỹ thuật Shuffle Pixel (Sub-Pixel Convolution) để dịch chuyển toàn bộ quá trình trích xuất đặc trưng sang không gian độ phân giải thấp, giảm thiểu đột biến chi phí FLOPs.
  3. Tối ưu hóa không gian biểu diễn dữ liệu: Xử lý chuyên sâu trên kênh độ sáng (kênh Y trong không gian màu YUV), giảm 66.7% khối lượng tính toán ma trận so với mô hình 3 kênh RGB truyền thống.
  4. Đạt hiệu năng thực thi phần cứng tối ưu: Đảm bảo thời gian suy luận thực tế (Inference Latency) ở mức mili-giây, chiếm dụng CPU/RAM thấp, khả thi cho các vi xử lý cấu hình phổ thông.

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

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

Trước khi xây dựng mô hình mới, đề tài tiến hành khảo sát và đánh giá toàn diện các công trình siêu phân giải tiêu biểu trong y văn:

Mô hình Cơ chế Upsampling Ưu điểm Nhược điểm cốt lõi
SRCNN (Dong et al., 2014) Pre-Upsampling (Bicubic trước mạng) Đơn giản, học trực tiếp đặc trưng phi tuyến từ dữ liệu Tính toán trên không gian HR gây tốn tài nguyên; không có skip-connection
FSRCNN (Dong et al., 2016) Post-Upsampling (Deconvolution) Tốc độ nhanh hơn SRCNN, giảm chiều kênh với Conv 1x1 Tầng Deconvolution dễ tạo hiệu ứng lưới (checkerboard artifacts)
VDSR (Kim et al., 2016) Pre-Upsampling (Cascade 20 Conv layers) Khai thác ngữ cảnh trường nhìn rộng, học khác biệt dư (Residual) Dung lượng mô hình lớn, tốc độ hội tụ chậm, tốn nhiều VRAM
SRGAN (Ledig et al., 2017) Post-Upsampling (ResBlocks + Sub-Pixel) Ảnh đầu ra có kết cấu chân thực cao nhờ Perceptual Loss + GAN Cấu trúc cực nặng, sinh ảo giác hạt (hallucinated artifacts), không phù hợp real-time
LapSRN (Lai et al., 2017) Progressive Upsampling (Laplacian Pyramid) Tái tạo đa tỷ lệ mượt mà, dùng hàm mất mát Charbonnier Kiến trúc kim tự tháp đa tầng phức tạp, chi phí suy luận lớn

Thiết kế hệ thống

Mô hình đề xuất được phân tách thành 3 khối xử lý tuần hoàn, liên kết chặt chẽ:

[Input LR: Y-channel (300x300x1)]
[Output HR: Y-channel High Resolution (Scale x r)]

Chi tiết toán học của Separable Convolution

Thay vì sử dụng tích chập 2D tiêu chuẩn với độ phức tạp tính toán lớn, kiến trúc sử dụng Depthwise Separable Convolution gồm hai giai đoạn:

  1. Depthwise Convolution: Áp dụng $1$ bộ lọc không gian $K \times K$ độc lập cho từng kênh đầu vào.
  2. Pointwise Convolution: Áp dụng bộ lọc tích chập $1 \times 1$ để tổng hợp tuyến tính thông tin liên kênh.

Giả sử đầu vào có kích thước không gian $H \times W \times N$, tạo ra $M$ kênh đầu ra với kích thước kernel $K \times K$:

  • Số tham số tích chập chuẩn: $P_{std} = M \times N \times K \times K$
  • Số tham số Separable Conv: $P_{sep} = N \times K \times K + M \times N \times 1 \times 1$
  • Tỷ lệ suy giảm độ phức tạp: $$\frac{P_{sep}}{P_{std}} = \frac{N \times K^2 + M \times N}{M \times N \times K^2} = \frac{1}{M} + \frac{1}{K^2}$$

Với kernel $3 \times 3$ ($K=3$) và số kênh lớn ($M=64$), tỷ lệ giảm chi phí tính toán xấp xỉ $\frac{1}{9}$ (tiết kiệm gần $88.8%$ phép tính nhân-cộng so với tích chập tiêu chuẩn).

Methodology

  • Quy trình nghiên cứu: Phương pháp thực nghiệm định lượng (Quantitative Experimental Methodology).
  • Bộ công cụ & Thư viện:
    • Ngôn ngữ lập trình: Python 3.9+
    • Deep Learning Framework: TensorFlow 2.x / Keras
    • Xử lý ảnh: OpenCV, Pillow (PIL), NumPy
  • Kế hoạch thực hiện:
    • Giai đoạn 1: Chuẩn hóa dữ liệu, tách trích không gian màu YUV.
    • Giai đoạn 2: Xây dựng và tối ưu cấu trúc khối RFSB.
    • Giai đoạn 3: Huấn luyện mô hình với cơ chế Early Stopping và Model Checkpoint.
    • Giai đoạn 4: Đánh giá Benchmark trên tập Set5, Set14 bằng chỉ số PSNR và SSIM.

Implementation và kết quả

Development process

Cốt lõi của mô hình là khối tăng cường đặc trưng RFSB (Residual Feature Scaling/Sharpening Block) loại bỏ các lớp Batch Normalization. Việc bỏ Batch Normalization giúp giữ nguyên phạm vi động của tín hiệu độ sáng, tránh làm biến dạng tương phản cục bộ và giải phóng đáng kể bộ nhớ đệm trong quá trình forward pass.

import tensorflow as tf
from tensorflow.keras import layers, models, initializers

def create_rfsb_block(input_tensor, num_filters=64):
    """
    Khối RFSB (Residual Feature Scaling Block) tối ưu:
    Sử dụng SeparableConv2D kết hợp Skip Connection, không dùng BatchNorm.
    """
    # Lớp Separable 1: Mở rộng biểu diễn đặc trưng với depth_multiplier=2
    x = layers.SeparableConv2D(
        filters=num_filters,
        kernel_size=(3, 3),
        padding='same',
        depth_multiplier=2,
        depthwise_initializer=initializers.Orthogonal(),
        pointwise_initializer=initializers.Orthogonal()
    )(input_tensor)
    x = layers.Activation('relu')(x)
    
    # Lớp Separable 2: Tinh chỉnh đặc trưng cục bộ
    x = layers.SeparableConv2D(
        filters=num_filters,
        kernel_size=(3, 3),
        padding='same',
        depth_multiplier=1,
        depthwise_initializer=initializers.Orthogonal(),
        pointwise_initializer=initializers.Orthogonal()
    )(x)
    x = layers.Activation('relu')(x)
    
    # Lớp Separable 3: Tái tạo ánh xạ phi tuyến
    x = layers.SeparableConv2D(
        filters=num_filters,
        kernel_size=(3, 3),
        padding='same',
        depth_multiplier=1,
        depthwise_initializer=initializers.Orthogonal(),
        pointwise_initializer=initializers.Orthogonal()
    )(x)
    
    # Skip connection: Cộng trực tiếp phần dư với đầu vào gốc
    output_tensor = layers.add([input_tensor, x])
    return output_tensor

def build_efficient_sr_model(upscale_factor=2):
    """
    Kiến trúc mạng siêu phân giải siêu nhẹ hoàn chỉnh cho kênh đơn Y.
    """
    inputs = layers.Input(shape=(None, None, 1), name="lr_luma_input")
    
    # 1. Khối Feature Presentation
    feat_extract = layers.Conv2D(
        filters=64,
        kernel_size=(3, 3),
        padding='same',
        kernel_initializer=initializers.Orthogonal(),
        activation='relu',
        name="feature_presentation"
    )(inputs)
    
    # 2. Khối Feature Enhanced: 2 khối RFSB nối tiếp
    res1 = create_rfsb_block(feat_extract, num_filters=64)
    res2 = create_rfsb_block(res1, num_filters=64)
    
    # Kết nối toàn cục (Global skip connection)
    enhanced_features = layers.add([feat_extract, res2])
    
    # 3. Khối Upscaling Block sử dụng PixelShuffle (Depth to Space)
    x = layers.Conv2D(
        filters=64 * (upscale_factor ** 2),
        kernel_size=(3, 3),
        padding='same',
        kernel_initializer=initializers.Orthogonal()
    )(enhanced_features)
    
    # Tái sắp xếp ma trận không gian: (*, H, W, C * r^2) -> (*, H*r, W*r, C)
    sr_output = tf.nn.depth_to_space(x, block_size=upscale_factor, name="pixel_shuffle")
    
    return models.Model(inputs=inputs, outputs=sr_output, name="Efficient_SISR_Net")

Quy trình tiền xử lý và suy luận tích hợp hệ màu YUV:

def process_and_super_resolve(image_rgb_pil, model, upscale_factor=2):
    """
    Quy trình suy luận SISR hoàn chỉnh: Tách kênh YUV -> Xử lý Model -> Tái tạo RGB
    """
    # 1. Chuyển đổi không gian màu RGB sang YCbCr (YUV)
    img_yuv = image_rgb_pil.convert('YCbCr')
    y_channel, u_channel, v_channel = img_yuv.split()
    
    # 2. Chuẩn hóa kênh Y về đoạn [0.0, 1.0] và thêm batch dimension
    y_array = np.array(y_channel, dtype=np.float32) / 255.0
    y_input = np.expand_dims(np.expand_dims(y_array, axis=0), axis=-1)
    
    # 3. Đưa qua mô hình deep learning để dự đoán kênh Y độ phân giải cao
    predicted_y = model.predict(y_input)
    predicted_y = np.clip(predicted_y[0, :, :, 0] * 255.0, 0, 255).astype(np.uint8)
    sr_y_image = Image.fromarray(predicted_y, mode='L')
    
    # 4. Phóng to kênh U và V bằng thuật toán Bicubic truyền thống
    target_size = (image_rgb_pil.width * upscale_factor, image_rgb_pil.height * upscale_factor)
    sr_u_image = u_channel.resize(target_size, resample=Image.BICUBIC)
    sr_v_image = v_channel.resize(target_size, resample=Image.BICUBIC)
    
    # 5. Ghép các kênh lại và chuyển ngược về hệ màu RGB chuẩn
    sr_yuv_image = Image.merge('YCbCr', (sr_y_image, sr_u_image, sr_v_image))
    return sr_yuv_image.convert('RGB')

Testing và validation

Mô hình được huấn luyện trên tập hỗn hợp gồm $191$ ảnh chất lượng cao trích xuất từ hai bộ dữ liệu tiêu chuẩn T91 và Urban100 ($80%$ huấn luyện, $20%$ kiểm thực). Dữ liệu được cắt thành các bản vá (patches), chuẩn hóa thang đo $[0, 1]$ và tăng cường ngẫu nhiên.

Thiết lập huấn luyện:

  • Optimizer: Adam ($\beta_1 = 0.9, \beta_2 = 0.999$, $\epsilon = 10^{-7}$).
  • Loss Function: Mean Squared Error (MSE) trên kênh độ sáng $Y$: $$\mathcal{L}{MSE} = \frac{1}{H W} \sum{x=1}^{H} \sum_{y=1}^{W} \left( \mathbf{I}{HR}(x,y) - \mathbf{I}{SR}(x,y) \right)^2$$
  • Chiến lược kiểm soát:
    • EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True): Tự động dừng để ngăn overfitting.
    • ModelCheckpoint(save_best_only=True, monitor='val_loss', mode='min'): Lưu trữ trọng số tối ưu nhất.

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

Đánh giá thực nghiệm khách quan trên hai tập dữ liệu benchmark kinh điển Set5 (gồm các ảnh Baby, Butterfly, Bird, Head, Woman) và Set14 (ảnh Zebra, Foreman,...):

1. Đánh giá chất lượng phục hồi hình ảnh (PSNR / SSIM) ở tỉ lệ phóng đại Scale x2:

Bộ dữ liệu thử nghiệm Mô hình Bicubic SRCNN (Dong et al.) Mô hình đề xuất
Set5 (Trung bình) $33.66\text{ dB} / 0.9299$ $36.66\text{ dB} / 0.9542$ $37.12\text{ dB} / 0.9584$
- Butterfly (Set5) $27.43\text{ dB} / 0.8651$ $32.10\text{ dB} / 0.9312$ $33.45\text{ dB} / 0.9482$
- Baby (Set5) $37.07\text{ dB} / 0.9350$ $38.30\text{ dB} / 0.9510$ $38.74\text{ dB} / 0.9548$
Set14 (Trung bình) $30.24\text{ dB} / 0.8688$ $32.42\text{ dB} / 0.9063$ $32.89\text{ dB} / 0.9125$
- Zebra (Set14) $26.63\text{ dB} / 0.7924$ $28.51\text{ dB} / 0.8421$ $29.18\text{ dB} / 0.8590$

2. So sánh hiệu năng tính toán và tiêu thụ tài nguyên thực tế (Trung bình cộng 5 lần đo trên CPU):

Tiêu chí đo lường VDSR (Kim et al.) SRGAN (Ledig et al.) Mô hình đề xuất Mức độ cải thiện
Tổng số tham số (Params) $\approx 665.000$ $\approx 1.550.000$ $\approx 85.400$ Giảm 87.1% - 94.5%
Dung lượng file mô hình (.h5) $2.6\text{ MB}$ $6.2\text{ MB}$ $0.34\text{ MB}$ Gọn hơn 86.9%
Thời gian suy luận (Inference Time) $142.5\text{ ms}$ $310.2\text{ ms}$ $18.6\text{ ms}$ Nhanh hơn 7.6x - 16.6x
Chiếm dụng CPU trung bình $78.4%$ $94.2%$ $21.5%$ Tiết kiệm 72.5% tải CPU
Tiêu hao bộ nhớ RAM $412\text{ MB}$ $850\text{ MB}$ $86\text{ MB}$ Tiết kiệm 79.1% bộ nhớ

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

  1. Kiến trúc RFSB tối giản hóa cao độ: Loại bỏ hoàn toàn tầng Batch Normalization kết hợp kỹ thuật Depthwise Separable Convolution giúp mạng duy trì độ sâu biểu diễn mà không làm bùng nổ số lượng phép nhân tích chập.
  2. Quy trình xử lý phân luồng YUV chuyên biệt: Khai thác tối đa đặc điểm thị giác con người (nhạy cảm với luma hơn chroma), chỉ áp dụng mạng học sâu cho kênh Y và ủy quyền kênh U/V cho phép nội suy Bicubic cổ điển. Cách tiếp cận này giúp triệt tiêu $66.7%$ gánh nặng tính toán mà vẫn đảm bảo độ trung thực màu sắc tổng thể.
  3. Cơ chế khôi phục Post-Upsampling không điểm mù: Ứng dụng phép biến đổi không gian tf.nn.depth_to_space cho phép mô hình thực hiện toàn bộ việc trích xuất và biến đổi phi tuyến trên miền phân giải thấp ($300 \times 300$), triệt tiêu hiện tượng thắt cổ chai tính toán (computational bottleneck) thường thấy ở các kiến trúc Pre-Upsampling như SRCNN và VDSR.
  4. Đóng góp cho lĩnh vực ứng dụng biên (Edge AI): Cung cấp một baseline mô hình siêu phân giải đạt kích thước dưới $1\text{ MB}$, đáp ứng hoàn hảo tiêu chuẩn chạy trên thiết bị di động, chip IoT hoặc các hệ thống giám sát yêu cầu tốc độ khung hình cao.

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

[Hệ Thống An Ninh]          [Hình Ảnh Y Tế]            [Thiết Bị Di Động]
- Nâng cao chi tiết         - Khôi phục ảnh X-Quang,   - Tối ưu hóa hiển thị ảnh/
  biển số xe, khuôn mặt       CT, Siêu âm độ phân        video trên màn hình 2K/4K.
  từ Camera CCTV ban đêm.     giải thấp.               - Tiết kiệm 50% băng thông
- Phân tích hiện trường.    - Hỗ trợ chẩn đoán sớm.      truyền tải dữ liệu mạng.

Chiến lược triển khai phần mềm

  • Chuyển đổi mô hình: Dễ dàng lượng hóa (Quantization INT8/FP16) và chuyển đổi sang định dạng TensorFlow Lite (TFLite) hoặc ONNX Runtime để nhúng trực tiếp vào ứng dụng Android/iOS.
  • Triển khai Cloud API: Đóng gói dạng microservice với FastAPI và Docker, cung cấp endpoint xử lý ảnh siêu tốc cho các cổng dịch vụ trực tuyến.

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

Hạn chế kỹ thuật

  • Độ nhạy biên màu trong các trường hợp cực đoan: Việc nội suy Bicubic cho kênh U và V đôi khi có thể tạo ra viền mờ màu sắc nhẹ (color bleeding) tại các vùng biên có độ tương phản màu sắc cực cao.
  • Tỷ lệ phóng đại cố định: Mô hình hiện được thiết kế và huấn luyện chuyên biệt cho các hệ số phóng đại xác định ($2\times, 4\times$), chưa hỗ trợ phóng đại tỷ lệ bất kỳ (Arbitrary Scale Factor) trong một lần nạp trọng số duy nhất.

Hướng phát triển tương lai

  • Tích hợp kỹ thuật Implicit Neural Representation (INR) hoặc kiến trúc MLP siêu nhỏ để hỗ trợ phóng đại tỷ lệ liên tục không giới hạn ($1.1\times \to 8.0\times$).
  • Mở rộng kiến trúc xử lý sang bài toán Video Super-Resolution (VSR) bằng cách tích hợp các khối đối chuẩn thời gian (Temporal Alignment Blocks) để tận dụng mối tương quan giữa các khung hình liên tiếp.

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

  • Sinh viên & Học viên chuyên ngành KHMT/CNTT: Tài liệu tham khảo chuẩn mực về phương pháp xây dựng, tinh chỉnh và đánh giá mô hình học sâu tối ưu tài nguyên.
  • Kỹ sư AI & Phát triển ứng dụng di động: Nắm vững kỹ thuật lập trình tích chập phân tách chiều sâu, cơ chế shuffle pixel và giải pháp xử lý phân tách không gian màu thực chiến.
  • Doanh nghiệp & Đơn vị phát triển hệ thống IoT/Camera: Tiết kiệm hàng ngàn USD chi phí hạ tầng máy chủ GPU nhờ khả năng chuyển dịch tác vụ siêu phân giải sang CPU hoặc chip nhúng giá rẻ.
  • Nhà nghiên cứu thị giác máy tính: Cung cấp nền tảng kiến trúc baseline nhẹ để tiếp tục thử nghiệm các cơ chế Attention (như CBAM, ECA-Net) cho bài toán khôi phục ảnh.

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

1. Cấu hình phần cứng tối thiểu để triển khai mô hình là gì?

Nhờ kích thước siêu nhẹ ($\approx 85.400$ tham số, dung lượng file $\approx 0.34\text{ MB}$), mô hình chỉ yêu cầu CPU lõi kép thông thường (như Intel Core i3 thế hệ cũ hoặc vi xử lý ARM trên Raspberry Pi 4), RAM tối thiểu $512\text{ MB}$, hoàn toàn không bắt buộc phải có card đồ họa rời (Dedicated GPU).

2. Tại sao mô hình chỉ huấn luyện trên kênh Y của hệ màu YUV thay vì RGB?

Thị giác con người có cấu trúc tế bào nón và tế bào que tiếp nhận ánh sáng đặc thù, rất nhạy cảm với sự thay đổi độ sáng (Luminance) nhưng kém nhạy hơn với sắc độ màu (Chrominance). Huấn luyện trên kênh Y giúp tập trung $100%$ dung lượng tham số vào việc khôi phục đường nét, góc cạnh và cấu trúc không gian, đồng thời giảm $66.7%$ kích thước tensor đầu vào/đầu ra.

3. Khối RFSB khác gì so với khối Residual Block trong ResNet truyền thống?

Khối RFSB thay thế toàn bộ các lớp tích chập chuẩn bằng SeparableConv2D để giảm $8\times$ chi phí tính toán. Đồng thời, RFSB loại bỏ hoàn toàn các tầng BatchNormalization nhằm bảo toàn nguyên vẹn thang phân bố độ sáng cục bộ và gia tăng tốc độ forward pass.

4. Cơ chế PixelShuffle hoạt động như thế nào so với Deconvolution?

Deconvolution (Conv2DTranspose) thường tạo ra các vết sọc lưới (checkerboard artifacts) do sự chồng lấn bước nhảy. PixelShuffle gom các kênh tính toán bổ sung trong không gian độ phân giải thấp ($C \cdot r^2$) và dàn đều ra không gian 2D ($H \cdot r \times W \cdot r$), giúp ảnh sắc nét tự nhiên và tối ưu hóa bộ nhớ đệm ma trận.

5. Có thể áp dụng mô hình cho các bài toán phục hồi ảnh y tế (X-quang, CT) không?

Rất phù hợp. Ảnh y tế như X-quang và CT vốn dĩ là ảnh đơn kênh (Grayscale). Do đó, chúng có thể được đưa trực tiếp vào mô hình mà không cần bước chuyển đổi YUV, tận dụng tối đa khả năng tái tạo đường viền mô và xương với độ chính xác cao.

Kết luận

Đề tài "Mô Hình Học Sâu Hiệu Quả Cho Siêu Phân Giải" của tác giả Nguyễn Thanh Bình đã giải quyết thành công bài toán thắt cổ chai về tài nguyên trong lĩnh vực Siêu phân giải đơn ảnh (SISR). Bằng việc phối hợp linh hoạt giữa mạng phần dư RFSB, tích chập phân tách chiều sâu, phép biến đổi PixelShuffle và không gian màu YUV, mô hình đạt chất lượng hình ảnh vượt trội ($37.12\text{ dB}$ PSNR trên tập Set5) trong khi giảm hơn $87%$ số lượng tham số và tăng tốc độ xử lý gấp $7.6$ lần so với các kiến trúc truyền thống. Đây là một giải pháp công nghệ có tính thực tiễn cao, mở ra tiềm năng ứng dụng rộng rãi trên các thiết bị di động, camera biên và các hệ sinh thái xử lý đa phương tiện thời gian thực.