VAIO 2026

Trong suy diễn Logic vị từ bậc nhất (First-Order Logic), “Unification” (hợp nhất) được dùng để làm gì?

Sắp xếp các bước theo đúng thứ tự của một vòng lặp Gradient Descent khi huấn luyện hồi quy tuyến tính:
(1) Cập nhật tham số: $w \leftarrow w - \eta \nabla_w L, b \leftarrow b - \eta \partial L / \partial b$
(2) Tính giá trị dự đoán $\hat{y} = Xw + b$ cho toàn bộ (hoặc một batch) dữ liệu
(3) Tính gradient của hàm mất mát theo $w$ và $b$: $\nabla_w L, \partial L / \partial b$
(4) Khởi tạo trọng số $w$ và bias $b$ (thường ngẫu nhiên hoặc bằng 0)
(5) Tính hàm mất mát $L$ (ví dụ MSE) giữa $\hat{y}$ và nhãn thật $y$

Với kernel đa thức $K(x,z) = (x^T z)^2, x = (1,2), z = (3,1)$. Giá trị $K(x,z)$ và ý nghĩa của nó là:

Một kho gồm $N = 1000$ văn bản. Văn bản $d$ dài 100 từ. Từ “transformer” xuất hiện 4 lần trong $d$ và có mặt trong 10 văn bản của kho. Từ “là” xuất hiện 10 lần trong $d$ và có mặt trong cả 1000 văn bản. Với $TF = \text{số lần xuất hiện} / \text{độ dài văn bản}$ và $IDF = \log_{10}(N/df)$, TF-IDF của “transformer” và “là” trong $d$ lần lượt là:

Câu mệnh đề $(A \lor B) \rightarrow C$ tương đương với dạng chuẩn tắc hội (CNF) nào?

Đoạn code dưới đây huấn luyện SVM kernel RBF trên dữ liệu có 2 đặc trưng với thang đo khác nhau (feature 1: 0-1, feature 2: 0-10000) nhưng độ chính xác thấp. Nguyên nhân nhiều khả năng nhất là gì?

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = SVC(kernel='rbf', C=1.0, gamma='scale')
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

Cho 7 điểm $(x, y)$ với $x = -3, -2, -1, 0, 1, 2, 3$ và $y = x^3$. Phát biểu nào đúng về hệ số tương quan Pearson ($r$) và Spearman ($\rho$) giữa $x$ và $y$?

Kết quả in ra là:

import numpy as np
y = np.array([3.0, 5.0, 10.0])
F = np.full_like(y, y.mean()) # mô hình khởi tạo F0
lr = 0.5
for m in range(2):
    r = y - F # phần dư = gradient âm của MSE/2
    h = r # giả sử cây hồi quy khớp đúng phần dư
    F = F + lr * h
print(F.tolist())

Điều kiện nào để một hàm heuristic $h(n)$ được gọi là “admissible” (chấp nhận được) trong thuật toán A*?

Hàm mất mát (cost function) phổ biến nhất dùng để huấn luyện hồi quy logistic là gì, và vì sao không dùng MSE như hồi quy tuyến tính?

Xét một nút của cây quyết định trong bài toán phân loại nhị phân (hai lớp: lớp 1 và lớp 0). Gọi $p$ là tỉ lệ mẫu thuộc lớp 1 trong nút ($0 \le p \le 1$); khi đó tỉ lệ mẫu thuộc lớp 0 là $1 - p$. Gini impurity của nút là $Gini = 1 - \sum_i p_i^2$, trong đó $p_i$ là tỉ lệ mẫu thuộc lớp $i$ trong nút và tổng lấy trên tất cả các lớp. Hàm gini(p) dưới đây nhận $p$ và trả về Gini impurity của nút, nhưng có lỗi. Lỗi ở đâu và sửa thế nào?

def gini(p):
    return 1 - (p**2 + (1 - p))

ViT chia ảnh $224 \times 224$ thành các patch $16 \times 16$ không chồng lấn, phủ kín ảnh, rồi thêm đúng một CLS token. Số token đầu vào Transformer là bao nhiêu?

Một mô hình Seq2Seq được huấn luyện chỉ bằng teacher forcing đạt loss thấp, nhưng khi sinh câu dài thì một lỗi ở các token đầu kéo theo chuỗi lỗi phía sau. Hiện tượng và biện pháp phù hợp là:

Sắp xếp các bước theo đúng thứ tự của Value Iteration để tìm hàm giá trị tối ưu $V^*(s)$ cho một MDP đã biết đầy đủ mô hình $(P,R)$:
(1) Lặp lại việc cập nhật cho toàn bộ trạng thái nhiều vòng cho đến khi $V(s)$ thay đổi dưới một ngưỡng $\epsilon$ (hội tụ)
(2) Suy ra chính sách tối ưu $\pi^*(s) = \arg\max_a \sum_{s'} P(s' | s,a)[R(s,a,s') + \gamma V(s')]$ từ $V^*$ đã hội tụ
(3) Với mỗi trạng thái $s$, cập nhật $V(s) \leftarrow \max_a \sum_{s'} P(s' | s,a)[R(s,a,s') + \gamma V(s')]$
(4) Khởi tạo $V(s) = 0$ (hoặc giá trị tuỳ ý) cho mọi trạng thái $s$

Đoạn code huấn luyện PyTorch dưới đây chạy không báo lỗi, nhưng quá trình huấn luyện không ổn định: loss dao động, có lúc tăng vọt, dù learning rate đã được chọn hợp lý. Lỗi nằm ở đâu?

for epoch in range(num_epochs):
    for x_batch, y_batch in dataloader:
        output = model(x_batch)
        loss = criterion(output, y_batch)
        loss.backward()
        optimizer.step()
print("done")

Trên một kho văn bản nhỏ có nhiều thuật ngữ y khoa hiếm, nhóm cần embedding tốt cho các từ hiếm. So sánh CBOW và Skip-gram, lựa chọn hợp lý là:

Sắp xếp các bước theo đúng thứ tự của phương pháp Monte Carlo để ước lượng hàm giá trị $V(s)$ theo một chính sách $\pi$ cố định:
(1) Cho agent chạy theo chính sách $\pi$ để sinh ra một episode đầy đủ (từ trạng thái đầu đến trạng thái kết thúc)
(2) Với mỗi trạng thái xuất hiện trong episode, tính tổng phần thưởng chiết khấu (return) $G_t$ kể từ thời điểm đó đến hết episode
(3) Ước lượng $V(s)$ bằng trung bình cộng của tất cả các return đã quan sát được cho trạng thái $s$
(4) Cộng dồn các giá trị return $G_t$ quan sát được cho từng trạng thái qua nhiều episode

K-means++ cải tiến K-means thông thường ở điểm nào?

Dữ liệu đã được trừ trung bình. Đặc trưng $x_1$ độc lập với nhãn, có phương sai 100. Đặc trưng $x_2$ chỉ nhận $-1$ ở lớp A và $+1$ ở lớp B; hai lớp cân bằng. Hiệp phương sai giữa $x_1$ và $x_2$ bằng 0. Áp dụng PCA (Phân tích thành phần chính) trên ma trận hiệp phương sai, không chuẩn hóa phương sai và chỉ giữ một thành phần chính. Điều gì xảy ra?

Đoạn code tính Cross-Entropy loss thủ công cho 1 mẫu phân loại 3 lớp với nhãn thật là lớp 1 (index bắt đầu từ 0) và xác suất dự đoán y_pred = [0.2, 0.5, 0.3]. Giá trị loss in ra (làm tròn 3 chữ số) là bao nhiêu?

import numpy as np
y_pred = np.array([0.2, 0.5, 0.3])
true_class = 1
loss = -np.log(y_pred[true_class])
print(round(loss, 3))

Áp dụng Non-Maximum Suppression (NMS) với ngưỡng IoU = 0.5 cho 3 hộp cùng lớp, đã sắp xếp theo confidence giảm dần: Box1 (conf cao nhất), Box2 (IoU với Box1 = 0.7), Box3 (IoU với Box1 = 0.3, IoU với Box2 = 0.2). Theo đoạn code NMS chuẩn dưới đây, những hộp nào được giữ lại?

def nms(boxes_sorted_by_conf, iou_fn, threshold=0.5):
    keep = []
    remaining = boxes_sorted_by_conf[:]
    while remaining:
        current = remaining.pop(0)
        keep.append(current)
        remaining = [b for b in remaining if iou_fn(current, b) < threshold]
    return keep

Hệ thống phải vẽ mask riêng cho từng con bò trong ảnh, kể cả khi nhiều con bò cùng lớp đứng sát nhau. Bài toán nào phù hợp nhất?

Sắp xếp theo đúng thứ tự các bước xử lý dữ liệu từ đầu vào qua khối encoder ĐẦU TIÊN của Transformer (kiến trúc gốc, Post-LN):
(1) Kết nối tắt (residual) cộng với đầu vào rồi Layer Normalization (Add và Norm)
(2) Embedding đầu vào cộng với Positional Encoding
(3) Multi-Head Self-Attention trên chuỗi đầu vào
(4) Kết nối tắt (residual) cộng với đầu ra FFN rồi Layer Normalization (Add và Norm) lần 2
(5) Feed-Forward Network (2 lớp fully-connected với activation ở giữa)

Một lớp convolution thường có 16 kênh đầu vào, 32 kênh đầu ra, kernel $3 \times 3$ và một bias cho mỗi kênh đầu ra. Tổng số tham số học được của lớp là bao nhiêu?

Sau khi thực hiện một hành động, tác nhân nhận phần thưởng $r = 1$ và chuyển đến trạng thái chưa kết thúc $s'$. Tại $s'$, hai hành động khả thi có giá trị $Q$ lần lượt là 6 và 2; chính sách khám phá đã chọn hành động có $Q = 2$. Với hệ số chiết khấu $\gamma = 0.5$, mục tiêu cập nhật (update target) một bước của Q-learning và SARSA lần lượt là bao nhiêu?

Đoạn code dưới đây cài đặt “inverted dropout” cho tầng ẩn với xác suất giữ lại keep_prob lúc huấn luyện, nhưng thiếu một bước để giá trị kỳ vọng đầu ra không đổi so với lúc không dùng dropout. Cần bổ sung gì?

import numpy as np
def dropout_forward(a, keep_prob):
    mask = (np.random.rand(*a.shape) < keep_prob)
    a = a * mask
    return a

Sự khác biệt cơ bản giữa phương pháp Temporal Difference (TD, ví dụ Q-learning) và Monte Carlo trong việc ước lượng hàm giá trị là gì?

Sắp xếp các bước theo đúng thứ tự để tính hệ số tương quan Pearson $r$ giữa hai biến $X,Y$ từ dữ liệu thô:
(1) Tính trung bình cộng của $X$ ($\bar{x}$) và của $Y$ ($\bar{y}$)
(2) Tính $r = S_{xy} / \sqrt{S_{xx}S_{yy}}$
(3) Tính các tổng: $S_{xy} = \sum(x_i - \bar{x})(y_i - \bar{y}), S_{xx} = \sum(x_i - \bar{x})^2, S_{yy} = \sum(y_i - \bar{y})^2$
(4) Tính mẫu số $\sqrt{S_{xx}S_{yy}}$ từ các tổng bình phương độ lệch ở bước trước
(5) Tính độ lệch của từng điểm so với trung bình: $(x_i - \bar{x})$ và $(y_i - \bar{y})$

Dữ liệu 2 chiều đã được trừ trung bình có ma trận hiệp phương sai $\Sigma = \begin{bmatrix} 3 & 1 \\ 1 & 3 \end{bmatrix}$. Thành phần chính thứ nhất giữ lại bao nhiêu phần trăm tổng phương sai?

Một mô hình có Precision = 0.8 và Recall = 0.4. F1-score xấp xỉ bao nhiêu?

Một mạng chỉ gồm ba lớp tuyến tính liên tiếp, mỗi lớp có thể có bias, không có activation hay phép toán nào khác. Xét hàm từ đầu vào tới đầu ra, mạng này tương đương với gì?

Trong LSTM, forget gate $f_t$ có vai trò gì?

Dữ liệu 2D gồm hai vành tròn đồng tâm. K-means với $K = 2$ cắt dữ liệu thành hai nửa trái và phải thay vì tách hai vành. Giải thích và lựa chọn phù hợp hơn là:

Trong hồi quy logistic, biên quyết định (decision boundary) ứng với ngưỡng xác suất 0.5 tương ứng với điều kiện nào trên tổ hợp tuyến tính $z = w \cdot x + b$?

Kết quả in ra xấp xỉ là:

import torch
import torch.nn as nn
x = torch.tensor([[1.0, 3.0],
                  [2.0, 2.0]]) # (batch = 2, đặc trưng = 2)
ln = nn.LayerNorm(2, elementwise_affine=False)
bn = nn.BatchNorm1d(2, affine=False) # đang ở chế độ train
print(ln(x).round(decimals=2), bn(x).round(decimals=2))

So sánh chi phí bộ nhớ giữa BFS và DFS khi tìm kiếm trên cây có hệ số nhánh $b$ và độ sâu lời giải $d$ (hoặc giới hạn độ sâu $m$ cho DFS)?

Trong sàng lọc ảnh lỗi sản phẩm, yêu cầu ưu tiên là bỏ sót càng ít ảnh lỗi càng tốt. Các cảnh báo nhầm sẽ được nhân viên kiểm tra lại. Metric nào trực tiếp đo tỷ lệ ảnh lỗi thật được phát hiện?

Đoạn code tính trọng số attention cho ma trận $Q, K$ có shape $(n, d_k)$ (giả sử đã có hàm softmax theo hàng). Khi $d_k$ lớn (ví dụ 64 thay vì 4), trọng số attention gần như one-hot (softmax bão hoà, gradient lan truyền ngược gần 0). Cần sửa thế nào?

import numpy as np
def attention_score(Q, K):
    scores = Q @ K.T # (n, n)
    weights = softmax(scores)
    return weights

Trong MDP, chính sách (policy) $\pi$ được định nghĩa là gì?

Nguyên nhân chính gây ra hiện tượng “vanishing gradient” khi huấn luyện mạng nơ-ron sâu dùng hàm kích hoạt sigmoid hoặc tanh ở mọi tầng là gì?

Sắp xếp các bước theo đúng thứ tự của thuật toán Minimax với cắt tỉa Alpha-Beta khi duyệt cây trò chơi từ gốc (lượt Max):
(1) Khi đến nút lá (hoặc giới hạn độ sâu), trả về giá trị hàm đánh giá
(2) Đệ quy xuống các nút con, đổi vai trò Max/Min ở mỗi tầng
(3) Khi một nút con trả về giá trị: cập nhật giá trị tốt nhất của nút hiện tại cùng $\alpha$ (nút Max) hoặc $\beta$ (nút Min); nếu điều kiện cắt tỉa được thoả mãn thì bỏ qua các nút con còn lại
(4) Chọn nước đi tại gốc ứng với nút con cho giá trị tốt nhất
(5) Khởi tạo $\alpha = -\infty, \beta = +\infty$ tại nút gốc

Trong mô hình YOLOv1, mỗi ô lưới (grid cell) dự đoán $B$ hộp giới hạn (bounding box). Giả sử hai vật thể thuộc hai lớp khác nhau có tâm nằm trong cùng một ô lưới. Thành phần nào trong dự đoán của ô lưới không thể được biểu diễn độc lập cho từng hộp?

Sắp xếp các bước theo đúng thứ tự của tìm kiếm theo chiều sâu (Depth-First Search - DFS) dùng đệ quy/ngăn xếp trên một đồ thị:
(1) Nếu nút đó là đích, trả về đường đi đã tìm được
(2) Lấy nút ở đỉnh ngăn xếp ra để xét, đánh dấu đã thăm
(3) Đẩy các nút lân cận chưa thăm của nút hiện tại vào ngăn xếp
(4) Lặp lại việc lấy đỉnh ngăn xếp cho đến khi tìm thấy đích hoặc ngăn xếp rỗng
(5) Khởi tạo ngăn xếp (stack) chỉ chứa nút bắt đầu

Sắp xếp các bước theo đúng thứ tự trong một vòng huấn luyện mô hình ngôn ngữ RNN bằng truncated BPTT trên một đoạn dài $L$ token:
(1) Cắt (clip) norm của gradient nếu vượt ngưỡng
(2) Lan truyền ngược qua $L$ bước thời gian của đoạn
(3) Chạy RNN tuần tự qua $L$ token, tính các trạng thái ẩn $h_t$
(4) Tính cross-entropy tại mỗi bước giữa dự đoán và token kế tiếp
(5) Cập nhật tham số, rồi giữ $h_L$ (đã detach) làm trạng thái đầu cho đoạn tiếp theo

Ảnh rộng 640, cao 480 được thu nhỏ đồng đều để vừa khung $320 \times 320$ mà không méo ảnh, rồi thêm viền trên và dưới bằng nhau. Điểm $(x, y) = (200, 100)$ trong hệ tọa độ liên tục của ảnh gốc chuyển thành điểm nào? Gốc tọa độ ở góc trên trái; bỏ qua quy ước tâm pixel.

Xét hai tình huống: (1) cây quyết định sâu, lỗi huấn luyện gần 0 nhưng lỗi kiểm định cao và dao động giữa các lần chia dữ liệu; (2) cây quyết định độ sâu 1 (stump), lỗi huấn luyện và lỗi kiểm định đều cao. Phương pháp ensemble phù hợp lần lượt là:

Sắp xếp các bước theo đúng thứ tự trong pipeline phát hiện đối tượng của YOLO (You Only Look Once) phiên bản cơ bản:
(1) Chia ảnh đầu vào thành lưới ô vuông (grid) $S \times S$
(2) Lọc bỏ các hộp có điểm tin cậy thấp hơn ngưỡng đặt trước
(3) Áp dụng Non-Maximum Suppression (NMS) để loại các hộp trùng lặp cho cùng một đối tượng
(4) Mỗi ô lưới dự đoán đồng thời các hộp giới hạn (bounding box), điểm tin cậy (confidence) và xác suất lớp trong một lượt truyền tiến (forward pass) duy nhất qua mạng CNN
(5) Xuất ra danh sách các hộp giới hạn cuối cùng cùng nhãn lớp tương ứng

Đoạn code kiểm tra tính thoả mãn được (satisfiability) của công thức CNF bằng cách thử toàn bộ $2^n$ phép gán chân trị (brute-force). Đoạn code có lỗi khiến nó báo sai “UNSAT” (không thoả mãn) cho nhiều công thức thực ra thoả mãn được, ví dụ clauses = [[1, 2], [-1, -2]] (thoả mãn với x1=True, x2=False). Lỗi nằm ở đâu?

from itertools import product

def is_satisfiable(clauses, variables):
    for values in product([True, False], repeat=len(variables)):
        assignment = dict(zip(variables, values))
        satisfied = True
        for clause in clauses:
            clause_value = all(
                assignment[abs(lit)] if lit > 0 else not assignment[abs(lit)]
                for lit in clause
            )
            if not clause_value:
                satisfied = False
        if satisfied:
            return True, assignment
    return False, None

Mô hình CNN dưới đây báo lỗi “shape mismatch” (RuntimeError) tại lớp Linear khi forward ảnh $32 \times 32 \times 3$ sau 2 lớp Conv+Pool. Lỗi nhiều khả năng nhất do đâu?

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 8, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(8, 16, 3, padding=1)
        self.fc = nn.Linear(16 * 32 * 32, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(x.size(0), -1)
        return self.fc(x)

Sắp xếp các bước theo đúng thứ tự khi Minimax (không cắt tỉa) tính giá trị cho một cây trò chơi có các tầng Max (gốc) - Min - Max - Min, với các nút lá nằm ngay dưới tầng Min cuối cùng, bắt đầu từ việc tính giá trị các nút lá:
(1) Lan truyền tiếp lên gốc (nếu còn tầng), lặp lại việc lấy max/min tuỳ theo lượt chơi của tầng đó
(2) Tại các nút Min ở tầng ngay trên lá, lấy giá trị nhỏ nhất trong các nút con
(3) Tính giá trị (điểm số) tại các nút lá bằng hàm đánh giá (evaluation function) hoặc kết quả trận đấu thực tế
(4) Chọn nước đi tại gốc tương ứng với nhánh con có giá trị bằng giá trị tối ưu vừa tính được ở gốc
(5) Tại các nút Max ở tầng tiếp theo, lấy giá trị lớn nhất trong các nút con (là các nút Min vừa tính)

So với K-means, Gaussian Mixture Model (GMM) khác biệt cơ bản ở điểm nào?

Đoạn code tokenize một câu tiếng Anh đơn giản bằng split() mặc định. Với câu "AI is amazing!", kết quả tokens in ra là gì?

sentence = "AI is amazing!"
tokens = sentence.split()
print(tokens)

Ba biến $X,Y,Z$ đều có miền giá trị {0, 1}, với các ràng buộc nhị phân $X \neq Y, Y \neq Z$ và $Z \neq X$. Áp dụng thuật toán kiểm tra nhất quán cung AC-3 (Arc Consistency Algorithm 3) cho các ràng buộc này đến khi ổn định. Kết quả nào đúng?

Sắp xếp các bước theo đúng thứ tự của một vòng lặp huấn luyện dùng SGD với Momentum, cập nhật cho MỖI tham số:
(1) Tính gradient $g_t = \nabla L(\theta_{t-1})$ của hàm mất mát tại tham số hiện tại
(2) Cập nhật tham số theo hướng vận tốc: $\theta_t = \theta_{t-1} - \eta v_t$
(3) Lặp lại cho batch tiếp theo, dùng $v_t$ vừa tính làm vận tốc cũ ($v_{t-1}$) ở bước sau
(4) Cập nhật vận tốc: $v_t = \beta v_{t-1} + (1-\beta)g_t$ (hoặc $v_t = \beta v_{t-1} + g_t$ tuỳ biến thể)

Đoạn code tính độ tương đồng cosine giữa embedding trung bình của 2 câu (mean pooling word vectors) nhưng lỗi khi 1 câu chứa từ không có trong từ điển embedding (out-of-vocabulary). Cách sửa hợp lý nhất?

def sentence_vector(tokens, embeddings, dim=100):
    vecs = [embeddings[t] for t in tokens]
    return np.mean(vecs, axis=0)

So sánh BFS (Breadth-First Search) và DFS (Depth-First Search) về tính đầy đủ (completeness) và tối ưu (optimality) trên đồ thị hữu hạn với chi phí cạnh bằng nhau?

Trong ảnh nhị phân, foreground có giá trị 1. Phép dilation dùng phần tử cấu trúc vuông $3 \times 3$ toàn số 1, tâm ở giữa. Ảnh ban đầu chỉ có một pixel foreground nằm xa biên. Sau một lần dilation có bao nhiêu pixel foreground?

Đoạn code cài đặt A* dùng heapq nhưng đôi khi trả về đường đi KHÔNG tối ưu dù heuristic là admissible. Nguyên nhân nhiều khả năng nhất trong đoạn code là gì?

import heapq

def a_star(start, goal, neighbors_fn, h):
    open_heap = [(h(start), 0, start, [start])]
    visited = set()
    while open_heap:
        f, g, node, path = heapq.heappop(open_heap)
        if node in visited:
            continue
        visited.add(node)
        if node == goal:
            return path, g
        for nxt, cost in neighbors_fn(node):
            new_g = g + cost
            heapq.heappush(open_heap, (new_g + h(nxt), new_g, nxt, path + [nxt]))
    return None

Tập test có 1000 giao dịch thẻ, gồm 950 giao dịch hợp lệ và 50 giao dịch gian lận. Mô hình dự đoán tất cả đều hợp lệ. Cặp giá trị (accuracy; recall của lớp gian lận) là gì?

Một LLM decoder-only có 32 lớp, 32 head cho Query nhưng dùng Grouped-Query Attention với 8 head cho Key/Value, head_dim = 128. Suy luận với batch = 1, ngữ cảnh 4096 token, KV cache lưu ở FP16 (2 byte mỗi giá trị). Dung lượng KV cache là bao nhiêu?

Một ảnh có đúng một đối tượng ground truth. Có hai detection đúng lớp, score 0.9 và 0.8; mỗi detection đều có IoU = 0.8 với đối tượng đó. Đánh giá xét score giảm dần, ghép một đối một, ngưỡng IoU $\ge 0.5$; không có ground truth bị bỏ qua. Cặp (TP, FP) là gì?

Sắp xếp các bước theo đúng thứ tự của một khối “bottleneck” trong ResNet-50 (khác với basic block 2 lớp $3 \times 3$ của ResNet-18/34, đây là dạng 3 lớp $1 \times 1 - 3 \times 3 - 1 \times 1$ có kết nối tắt):
(1) Conv $3 \times 3$ xử lý đặc trưng không gian, theo sau bởi BatchNorm và ReLU
(2) Cộng X_shortcut vào kết quả nhánh chính (Add), sau đó mới áp dụng ReLU cuối cùng
(3) Lưu lại đầu vào X làm X_shortcut để dùng cho kết nối tắt sau này
(4) Conv $1 \times 1$ giảm số kênh (bottleneck), theo sau bởi BatchNorm và ReLU
(5) Conv $1 \times 1$ khôi phục lại số kênh ban đầu, theo sau bởi BatchNorm (chưa ReLU)

Dự báo doanh số theo ngày với dữ liệu 3 năm. Nhóm dùng KFold(n_splits=5, shuffle=True) để chọn mô hình và đạt sai số thấp, nhưng khi triển khai sai số tăng gấp ba. Nguyên nhân và cách sửa hợp lý nhất là:

Sắp xếp các bước theo đúng thứ tự của giải thuật Backtracking Search kết hợp Forward Checking cho CSP:
(1) Nếu forward checking khiến domain của biến láng giềng nào đó rỗng, quay lui (backtrack) và thử giá trị khác
(2) Chọn một biến chưa được gán giá trị (theo một thứ tự/heuristic nào đó)
(3) Nếu không có domain nào rỗng, lặp lại quá trình với biến chưa gán kế tiếp; khi mọi biến đã được gán hợp lệ thì trả về phép gán làm nghiệm của CSP
(4) Với mỗi giá trị thử, kiểm tra tính hợp lệ với các ràng buộc đã có, rồi áp dụng forward checking để loại giá trị không tương thích khỏi domain của các biến láng giềng chưa gán
(5) Thử lần lượt từng giá trị trong domain hiện tại của biến đó

“Support vector” trong SVM là những điểm dữ liệu nào?

Sắp xếp các bước theo đúng thứ tự trong MỘT bước lặp của thuật toán Q-learning:
(1) Thực hiện hành động $a$, nhận phần thưởng $r$ và trạng thái kế tiếp $s'$
(2) Chuyển sang trạng thái mới: $s \leftarrow s'$
(3) Cập nhật $Q(s,a)$ theo công thức $Q(s,a) \leftarrow Q(s,a) + \alpha [r + \gamma \max_{a'} Q(s',a') - Q(s,a)]$
(4) Quan sát trạng thái hiện tại $s$
(5) Chọn hành động $a$ theo chiến lược epsilon-greedy dựa trên $Q(s,\cdot)$

Đoạn code PyTorch định nghĩa Conv2d với input ảnh (batch=1, channel=3, $32 \times 32$), kernel $3 \times 3$, stride=1, padding=1. out.shape in ra là gì?

import torch
import torch.nn as nn

conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
x = torch.randn(1, 3, 32, 32)
out = conv(x)
print(out.shape)

Sắp xếp các bước theo đúng thứ tự huấn luyện và dự đoán của Random Forest cho bài toán phân loại:
(1) Lặp lại quá trình trên cho đến khi đủ $T$ cây
(2) Chọn phép tách tốt nhất (theo Gini hoặc entropy) trong các đặc trưng ứng viên và tiếp tục phát triển cây
(3) Lấy mẫu bootstrap (có hoàn lại) từ tập huấn luyện cho cây hiện tại
(4) Với mẫu mới, tổng hợp dự đoán của $T$ cây bằng bỏ phiếu đa số
(5) Tại mỗi nút, chọn ngẫu nhiên một tập con gồm $m$ đặc trưng làm ứng viên

Hàm giá trị hành động tối ưu $Q^*(s,a)$ liên hệ với hàm giá trị trạng thái tối ưu $V^*(s)$ như thế nào?

Sắp xếp các bước theo đúng thứ tự của phương pháp chứng minh bằng phản chứng dùng Resolution (Proof by Refutation) để kiểm tra xem một tập tiên đề KB có suy ra được câu $\alpha$ hay không:
(1) Nếu không có clause rỗng và vòng lặp không sinh thêm được clause mới nào (bão hoà) thì dừng, kết luận KB không suy ra được $\alpha$; ngược lại quay lại bước lặp
(2) Sau mỗi vòng lặp, kiểm tra trước tiên: nếu trong các clause vừa sinh có clause rỗng ($\emptyset$) thì dừng, kết luận KB $\models \alpha$
(3) Phủ định câu cần chứng minh: thêm $\neg \alpha$ vào tập tiên đề KB
(4) Lặp lại: chọn hai clause có literal đối lập, áp dụng luật Resolution để sinh clause mới, thêm vào tập clause
(5) Chuyển toàn bộ $KB \cup \{\neg \alpha\}$ về dạng chuẩn tắc hội (CNF), biểu diễn thành tập các clause

Trong DBSCAN, một điểm được gọi là “điểm nhiễu” (noise) khi nào?

Đoạn code chọn hành động theo epsilon-greedy nhưng có lỗi logic khiến agent explore khoảng 70% số bước thay vì khoảng 30% như mong muốn với epsilon=0.3. Lỗi nằm ở đâu?

import random
def choose_action(Q_s, epsilon):
    if random.random() > epsilon:
        return random.choice(range(len(Q_s))) # explore
    else:
        return Q_s.index(max(Q_s)) # exploit

Đoạn code sau tính Precision và Recall từ ma trận nhầm lẫn nhị phân. Với TP = 15, FP = 5, FN = 10, TN = 70, kết quả in ra là gì (làm tròn 2 chữ số)?

TP, FP, FN, TN = 15, 5, 10, 70
precision = TP / (TP + FP)
recall = TP / (TP + FN)
print(round(precision, 2), round(recall, 2))

Sắp xếp các bước theo đúng thứ tự của MỘT vòng lặp huấn luyện GAN (Generative Adversarial Network):
(1) Tính loss của G (đánh lừa D hiệu quả hơn) và cập nhật trọng số G, giữ D cố định
(2) Generator G sinh ảnh giả G(z) từ z
(3) Discriminator D chấm điểm cả ảnh thật và ảnh giả G(z)
(4) Lấy mẫu vector nhiễu ngẫu nhiên z từ phân phối tiên nghiệm (ví dụ Gaussian)
(5) Tính loss của D (phân biệt thật/giả tốt hơn) và cập nhật trọng số D

Khi huấn luyện một mô hình causal LM bằng đoạn code trên, loss giảm nhanh về gần 0 nhưng mô hình sinh văn bản vô nghĩa. Lỗi và cách sửa là gì?

import torch.nn.functional as F

logits = model(input_ids).logits # (B, T, V), có causal mask
loss = F.cross_entropy(
    logits.view(-1, logits.size(-1)), # (B*T, V)
    input_ids.view(-1) # (B*T,)
)
loss.backward()

Đoạn code tính MSE và MAE cho 3 cặp (y_true, y_pred) = (3, 2.5), (5, 5.5), (2, 4). Kết quả in ra (làm tròn 2 chữ số) là gì?

import numpy as np
y_true = np.array([3, 5, 2])
y_pred = np.array([2.5, 5.5, 4])
mse = np.mean((y_true - y_pred)**2)
mae = np.mean(np.abs(y_true - y_pred))
print(round(mse, 2), round(mae, 2))

Sắp xếp các bước theo đúng thứ tự để huấn luyện một Autoencoder cơ bản nhằm nén và tái tạo dữ liệu:
(1) Đưa dữ liệu đầu vào $x$ qua encoder để thu được biểu diễn ẩn (latent) $z$ có số chiều nhỏ hơn $x$
(2) Đưa $z$ qua decoder để tái tạo lại $\hat{x}$ có cùng kích thước với $x$
(3) Lan truyền ngược và cập nhật trọng số của cả encoder và decoder để giảm reconstruction loss
(4) Tính hàm mất mát tái tạo (reconstruction loss), ví dụ MSE giữa $x$ và $\hat{x}$

Một mạng chứa Dropout và BatchNorm. Trong cơ chế tự động tính gradient thông thường, chỉ tắt ghi nhận gradient, nhưng vẫn để mô hình ở training mode. Điều nào đúng?

Trong một head attention, $Q = K$ và ma trận điểm số là $S = QQ^T$. Ma trận $A$ thu được bằng cách áp dụng hàm softmax riêng cho từng hàng của $S$. Nhận định nào đúng về tính đối xứng của $S$ và $A$?

Một nút của cây quyết định chứa 8 mẫu: 4 dương, 4 âm. Phép tách theo thuộc tính A tạo nút trái gồm 4 mẫu (3 dương, 1 âm) và nút phải gồm 4 mẫu (1 dương, 3 âm). Information Gain (theo entropy, cơ số 2) của phép tách xấp xỉ bằng bao nhiêu? Cho $\log_2 3 \approx 1.585$.

Hệ số tương quan hạng Spearman (Spearman’s rank correlation) phù hợp hơn Pearson trong trường hợp nào?

Vì sao một Perceptron đơn tầng (single-layer) không thể học được hàm XOR?