12 bài báo AI thay đổi tất cả: giải thích chi tiết kèm ví dụ

1. Tổng quan

Phần lớn các hệ thống AI bạn dùng hàng ngày — ChatGPT, Midjourney, Google Search với AI Overview — đều đứng trên vai của khoảng chục paper nghiên cứu. Bài này đi qua 12 paper đó, giải thích ý tưởng cốt lõi bằng ngôn ngữ dễ hiểu, và minh họa mỗi ý tưởng bằng một đoạn code Java ngắn. Đọc xong, bạn sẽ hiểu vì sao Transformer “ăn” cả thế giới NLP, vì sao RAG giải quyết được hallucination, và vì sao một câu prompt “hãy suy nghĩ từng bước” lại mạnh đến vậy.

2. AlexNet (2012) — deep learning bắt đầu “nhìn thấy”

Trước AlexNet, computer vision dựa vào feature engineering thủ công. AlexNet dùng convolutional neural network (CNN) với ReLU activation và dropout, huấn luyện trên GPU, và đánh bại mọi đối thủ tại ImageNet 2012 với sai số thấp hơn gần 10 điểm phần trăm. Đây là cú nổ mở màn thời đại deep learning.

public class ConvOutputSizeCalculator {

    public static int outputSize(int inputSize, int kernelSize, int stride, int padding) {
        return (inputSize - kernelSize + 2 * padding) / stride + 1;
    }

    public static void main(String[] args) {
        // Ảnh đầu vào AlexNet: 227x227, kernel 11x11, stride 4
        int size = outputSize(227, 11, 4, 0);
        System.out.println(size);
    }
}

outputSize tính kích thước feature map sau một conv layer. Với input 227×227 và kernel 11×11 stride 4, output là 55×55×96 — đúng kích thước lớp đầu tiên của AlexNet. ReLU giúp gradient không “chết” như sigmoid, nên mạng sâu hơn vẫn train được.

3. GAN (2014) — hai mạng đối đầu để sinh ảnh thực

Generative Adversarial Network đặt hai mạng vào thế đối kháng: generator cố tạo ảnh giả đánh lừa discriminator, discriminator cố phân biệt ảnh thật/giả. Cả hai cùng cải thiện qua từng vòng huấn luyện.

public record GanLosses(double discriminatorLoss, double generatorLoss) {}

public class GanLossCalculator {

    public static GanLosses compute(double probReal, double probFake) {
        double dLoss = -(Math.log(probReal) + Math.log(1 - probFake));
        double gLoss = -Math.log(probFake);
        return new GanLosses(dLoss, gLoss);
    }
}

probReal là xác suất discriminator đoán đúng ảnh thật, probFake là xác suất nó bị generator đánh lừa. Discriminator muốn probReal → 1 và probFake → 0; generator muốn ngược lại. Đây là zero-sum game điển hình.

Lưu ý: GAN nổi tiếng khó train — dễ gặp mode collapse (generator chỉ tạo ra vài kiểu ảnh lặp lại). Diffusion model sau này ổn định hơn nhiều, nên đa số hệ thống sinh ảnh hiện đại (DALL·E, Stable Diffusion) không dùng GAN nữa.

4. Transformer (2017) — “Attention Is All You Need”

Transformer bỏ hẳn RNN/LSTM, thay bằng self-attention: mỗi token nhìn thẳng vào mọi token khác trong câu để tính độ liên quan, không cần xử lý tuần tự. Đây là kiến trúc nền của GPT, Claude, Llama, BERT.

public class ScaledDotProductAttention {

    public static double[] attendFirstToken(double[][] query, double[][] key) {
        int seqLen = key.length;
        int dim = query[0].length;
        double scale = Math.sqrt(dim);
        double[] scores = new double[seqLen];
        for (int j = 0; j < seqLen; j++) {
            double dot = 0;
            for (int k = 0; k < dim; k++) dot += query[0][k] * key[j][k];
            scores[j] = dot / scale;
        }
        return softmax(scores);
    }

    private static double[] softmax(double[] row) {
        double max = Arrays.stream(row).max().orElse(0);
        double sum = 0;
        double[] exps = new double[row.length];
        for (int i = 0; i < row.length; i++) {
            exps[i] = Math.exp(row[i] - max);
            sum += exps[i];
        }
        for (int i = 0; i < exps.length; i++) exps[i] /= sum;
        return exps;
    }
}

Dòng dot / scale chia tích vô hướng cho sqrt(dim) để tránh giá trị quá lớn làm softmax bão hòa. Kết quả softmax là trọng số attention — token nào liên quan nhiều với token đang xét sẽ có trọng số cao, dùng để pha trộn các value vector.

5. Scaling Laws (2020) — loss giảm theo quy luật lũy thừa

OpenAI phát hiện: cứ tăng số parameter, dữ liệu, hoặc compute theo cấp số nhân, loss giảm theo một đường power law khá mượt và dự đoán được — không có “bí thuật”, chỉ cần scale đúng cách.

public class ScalingLawEstimator {

    // L(N) = (Nc / N)^alpha — N: số tỉ parameter, Nc, alpha: hằng số thực nghiệm
    public static double estimateLoss(double paramsBillion, double nc, double alpha) {
        return Math.pow(nc / paramsBillion, alpha);
    }
}

Với nc và alpha cố định từ dữ liệu thực nghiệm, tăng paramsBillion làm estimateLoss giảm dần nhưng chậm lại (diminishing returns). Đây là lý do các lab AI đổ hàng trăm triệu đô vào compute: loss giảm có thể dự đoán trước, không phải đánh cược.

Lưu ý: Scaling law không vô hạn. Sau một ngưỡng, muốn giảm loss thêm một chút cần tăng compute theo cấp số nhân khổng lồ — đây là lý do ngành đang chuyển hướng sang cải thiện dữ liệu và kiến trúc thay vì chỉ “to hơn”.

6. GPT-3 (2020) — scale tạo ra năng lực mới

GPT-3 với 175 tỉ parameter cho thấy: đủ lớn, model có thể làm few-shot learning — chỉ cần vài ví dụ trong prompt, không cần fine-tune lại trọng số.

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
public class FewShotClassifier {

    private final ChatClient chatClient;

    public FewShotClassifier(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String classifySentiment(String review) {
        String prompt = """
                Review: "Sản phẩm tốt, giao hàng nhanh" -> Positive
                Review: "Hàng lỗi, không dùng được" -> Negative
                Review: "%s" ->
                """.formatted(review);
        return chatClient.prompt(prompt).call().content();
    }
}

Hai ví dụ trong prompt đóng vai trò “dạy” model định dạng câu trả lời ngay trong context — không cần train lại. Đây chính là emergent ability mà các model nhỏ hơn không làm được tốt.

7. InstructGPT & RLHF (2022) — biến LLM thô thành trợ lý hữu ích

GPT-3 gốc dự đoán token tiếp theo giỏi, nhưng không “nghe lời” — nó có thể trả lời lạc đề hoặc độc hại. InstructGPT dùng Reinforcement Learning from Human Feedback (RLHF): con người xếp hạng các câu trả lời, từ đó train reward model, rồi dùng reward model để tối ưu policy bằng PPO.

public record Completion(String text, double rewardScore) {}

public class RewardBasedSelector {

    public Completion pickBest(List<Completion> candidates) {
        return candidates.stream()
                .max(Comparator.comparingDouble(Completion::rewardScore))
                .orElseThrow();
    }
}

Đoạn code trên chỉ minh họa bước cuối: chọn completion có reward cao nhất theo đánh giá của reward model. Trong thực tế, PPO cập nhật trọng số của policy model dần dần để nó tự sinh ra câu trả lời điểm cao ngay từ đầu, không cần chọn lọc sau.

Lưu ý: RLHF cần lượng lớn dữ liệu con người gán nhãn (ranking), tốn kém và dễ lệch theo bias của người đánh giá. Các kỹ thuật như DPO (Direct Preference Optimization) ra đời sau để giảm chi phí này.

8. ViT (2020) — ảnh cũng có thể là một “câu”

Vision Transformer chia ảnh thành các patch nhỏ (ví dụ 16×16 pixel), flatten mỗi patch thành một vector, rồi coi chúng như token đưa vào Transformer encoder — kiến trúc giống hệt xử lý văn bản.

public class PatchEmbeddingCalculator {

    public static int numPatches(int imageSize, int patchSize) {
        int gridSize = imageSize / patchSize;
        return gridSize * gridSize;
    }
}

Với ảnh 224×224 và patch 16×16, numPatches trả về 196 — tương đương một “câu” 196 token đưa vào Transformer. Nhờ cách này, ViT tái dùng toàn bộ kỹ thuật attention đã chứng minh hiệu quả ở NLP cho bài toán vision, và vượt CNN khi dữ liệu huấn luyện đủ lớn.

9. DDPM (2020) — thêm nhiễu rồi học cách gỡ

Denoising Diffusion Probabilistic Model đặt nền cho mọi diffusion model hiện đại: forward process thêm nhiễu Gaussian dần vào ảnh qua nhiều bước, reverse process học cách dự đoán và loại bỏ nhiễu đó để tái tạo ảnh gốc.

public class ForwardDiffusion {

    public static double[] addNoise(double[] x0, double alphaBarT, Random random) {
        double[] xt = new double[x0.length];
        for (int i = 0; i < x0.length; i++) {
            double noise = random.nextGaussian();
            xt[i] = Math.sqrt(alphaBarT) * x0[i] + Math.sqrt(1 - alphaBarT) * noise;
        }
        return xt;
    }
}

alphaBarT kiểm soát tỉ lệ giữ lại ảnh gốc so với nhiễu tại bước t: gần 1 nghĩa là còn gần ảnh gốc, gần 0 nghĩa là gần như nhiễu thuần. Model sinh ảnh học ngược lại quá trình này — bắt đầu từ nhiễu thuần, từng bước “gỡ nhiễu” ra ảnh có nghĩa.

10. Latent Diffusion (2021) — khử nhiễu trong không gian nén

Chạy diffusion trực tiếp trên pixel rất tốn compute. Latent Diffusion nén ảnh về latent space nhỏ hơn bằng một autoencoder, chạy toàn bộ quá trình denoising ở đó, rồi decode lại thành ảnh — đây là thiết kế đằng sau Stable Diffusion.

public class LatentCompressionCalculator {

    public static long pixelCount(int width, int height, int channels) {
        return (long) width * height * channels;
    }
}

pixelCount(512, 512, 3) = 786_432   // pixel space
pixelCount(64, 64, 4)   = 16_384    // latent space

Tỉ lệ nén gần 48 lần giúp diffusion chạy nhanh hơn rất nhiều mà vẫn giữ chất lượng ảnh, vì phần lớn thông tin “dư thừa” ở pixel space (vùng màu đồng nhất, chi tiết nhỏ) đã bị autoencoder loại bỏ khi nén.

11. CLIP (2021) — nối ảnh và chữ trong một không gian

CLIP train contrastive learning trên hàng trăm triệu cặp (ảnh, caption): cặp đúng thì embedding gần nhau, cặp sai thì xa nhau. Kết quả là một không gian chung cho phép so sánh text và ảnh bằng cosine similarity.

@Service
public class ImageTextMatcher {

    private final EmbeddingModel embeddingModel;

    public ImageTextMatcher(EmbeddingModel embeddingModel) {
        this.embeddingModel = embeddingModel;
    }

    public double similarity(String caption, float[] imageEmbedding) {
        float[] textEmbedding = embeddingModel.embed(caption);
        return cosine(textEmbedding, imageEmbedding);
    }

    private double cosine(float[] a, float[] b) {
        double dot = 0, normA = 0, normB = 0;
        for (int i = 0; i < a.length; i++) {
            dot += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
    }
}

similarity trả về giá trị gần 1 nếu caption khớp nội dung ảnh, gần 0 hoặc âm nếu không liên quan. Đây là cơ chế đằng sau tìm ảnh bằng câu mô tả tự nhiên (text-to-image search) mà nhiều sản phẩm thương mại điện tử đang dùng.

12. Chain-of-Thought (2022) — một câu prompt mở khóa lý luận

Chỉ cần thêm cụm “hãy suy nghĩ từng bước” vào prompt, các LLM lớn tự tách bài toán phức tạp thành các bước nhỏ, giảm hẳn lỗi tính toán và lỗi logic so với trả lời trực tiếp.

public String solveWithReasoning(ChatClient chatClient, String question) {
    String prompt = """
            Hãy suy nghĩ từng bước trước khi trả lời.
            Câu hỏi: %s
            Suy luận:
            """.formatted(question);
    return chatClient.prompt(prompt).call().content();
}

Việc yêu cầu model “suy luận” trước khi chốt đáp án buộc nó sinh ra các token trung gian làm chỗ dựa — giống cách con người viết nháp trước khi trả lời câu hỏi khó.

Lưu ý: Chain-of-Thought làm tăng số token sinh ra, kéo theo chi phí và latency cao hơn. Với câu hỏi đơn giản (tra cứu fact trực tiếp), ép CoT chỉ làm chậm mà không cải thiện độ chính xác.

13. RAG (2020) — truy xuất rồi sinh, không còn bịa

Retrieval-Augmented Generation gắn LLM với một bước truy xuất tài liệu thật trước khi sinh câu trả lời, giúp giảm hallucination và cho phép trả lời dựa trên dữ liệu cập nhật ngoài phạm vi huấn luyện gốc.

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
public class DocumentAnsweringService {

    private final VectorStore vectorStore;
    private final ChatClient chatClient;

    public DocumentAnsweringService(VectorStore vectorStore, ChatClient.Builder builder) {
        this.vectorStore = vectorStore;
        this.chatClient = builder.build();
    }

    public String answer(String question) {
        List<Document> relevant = vectorStore.similaritySearch(
                SearchRequest.query(question).withTopK(3));

        String context = relevant.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n---\n"));

        String prompt = """
                Dựa vào tài liệu sau, trả lời câu hỏi. Nếu không có thông tin, nói "Không rõ".
                Tài liệu:
                %s

                Câu hỏi: %s
                """.formatted(context, question);

        return chatClient.prompt(prompt).call().content();
    }
}

similaritySearch lấy 3 đoạn tài liệu gần nghĩa nhất với câu hỏi, ghép vào prompt làm context, rồi bắt model trả lời dựa trên context đó thay vì “nhớ” mơ hồ từ lúc train.

class DocumentAnsweringServiceTest {

    @Test
    void shouldReturnUnknownWhenNoRelevantDocument() {
        VectorStore emptyStore = mock(VectorStore.class);
        when(emptyStore.similaritySearch(any())).thenReturn(List.of());

        ChatClient stubClient = mock(ChatClient.class, RETURNS_DEEP_STUBS);
        when(stubClient.prompt(anyString()).call().content()).thenReturn("Không rõ");

        ChatClient.Builder builder = mock(ChatClient.Builder.class);
        when(builder.build()).thenReturn(stubClient);

        DocumentAnsweringService service = new DocumentAnsweringService(emptyStore, builder);

        String result = service.answer("Công ty thành lập năm nào?");

        assertThat(result).contains("Không rõ");
    }
}

Test xác nhận khi không tìm được tài liệu liên quan, câu trả lời phải thừa nhận “Không rõ” thay vì bịa đáp án — đúng mục tiêu grounding của RAG.

Lưu ý: Nếu toàn bộ kho tài liệu của bạn chỉ vài chục trang, nhồi thẳng vào context window còn đơn giản và rẻ hơn dựng cả pipeline RAG với vector store. RAG chỉ đáng dùng khi dữ liệu lớn hoặc thay đổi thường xuyên.

14. Kết luận

12 paper này không độc lập — chúng xây trên nhau: Transformer là nền cho GPT-3 và ViT; scaling laws giải thích vì sao GPT-3 hoạt động; RLHF biến GPT-3 thành ChatGPT; DDPM là gốc của Latent Diffusion; CLIP là cầu nối để diffusion model hiểu text prompt. Hiểu rõ từng mảnh ghép giúp bạn đọc paper mới nhanh hơn, vì hầu hết ý tưởng “mới” hiện nay đều là biến thể hoặc kết hợp của những nền tảng này.