12 bahnbrechende AI-Paper: detaillierte Erklärung mit Beispielen

1. Überblick

Die meisten KI-Systeme, die du täglich nutzt — ChatGPT, Midjourney, Google Search mit AI Overview — bauen auf etwa einem Dutzend Forschungspapiere auf. Dieser Artikel behandelt diese 12 Paper, erklärt ihre Kernideen in verständlicher Sprache und veranschaulicht jede Idee mit einem kurzen Java-Code-Beispiel. Nach dem Lesen wirst du verstehen, warum der Transformer die gesamte NLP-Welt erobert hat, warum RAG Halluzinationen löst, und warum ein einfacher Prompt-Zusatz wie „denk Schritt für Schritt” so mächtig ist.

2. AlexNet (2012) — Deep Learning beginnt zu „sehen”

Vor AlexNet basierte Computer Vision auf manueller Feature-Engineering. AlexNet nutzte Convolutional Neural Networks (CNN) mit ReLU-Aktivierung und Dropout, trainiert auf GPU, und schlug 2012 alle Konkurrenten bei ImageNet mit einen um fast 10 Prozentpunkte niedrigerem Fehler. Dies war der Startschuss für das Zeitalter des 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) {
        // AlexNet input: 227x227, kernel 11x11, stride 4
        int size = outputSize(227, 11, 4, 0);
        System.out.println(size);
    }
}

55

outputSize berechnet die Größe der Feature Map nach einem Conv Layer. Mit Input 227×227 und Kernel 11×11 mit stride 4 ist die Ausgabe 55×55×96 — genau die Größe der ersten Schicht von AlexNet. ReLU hilft, dass der Gradient nicht „stirbt” wie bei Sigmoid, sodass tiefere Netze trotzdem trainiert werden können.

3. GAN (2014) — zwei Netze im Wettkampf zum Erzeugen von Bildern

Generative Adversarial Networks setzen zwei Netze in Gegnerschaft: Der Generator versucht, gefälschte Bilder zu erzeugen, um den Discriminator zu täuschen, während der Discriminator versucht, echte von gefälschten Bildern zu unterscheiden. Beide verbessern sich gegenseitig mit jeder Trainingsrunde.

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 ist die Wahrscheinlichkeit, dass der Discriminator ein echtes Bild korrekt erkennt, probFake ist die Wahrscheinlichkeit, dass er vom Generator hereingelegt wird. Der Discriminator möchte probReal → 1 und probFake → 0; der Generator möchte das Gegenteil. Das ist ein klassisches Zero-Sum-Spiel.

Hinweis: GANs sind notorisch schwierig zu trainieren — häufig tritt Mode Collapse auf (der Generator erzeugt nur wenige sich wiederholende Bildtypen). Diffusion Models später sind viel stabiler, daher nutzen die meisten modernen Bildgeneratoren (DALL·E, Stable Diffusion) keine GANs mehr.

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

Der Transformer verzichtet völlig auf RNNs/LSTMs und ersetzt sie durch Self-Attention: jeder Token schaut direkt auf alle anderen Tokens im Satz, um ihre Relevanz zu berechnen, ohne sequenzielle Verarbeitung. Dies ist die Architektur, auf der GPT, Claude, Llama und BERT basieren.

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;
    }
}

Die Zeile dot / scale teilt das Skalarprodukt durch sqrt(dim), um zu verhindern, dass Werte zu groß werden und Softmax sättigen. Das Ergebnis von softmax sind die Attention-Gewichte — Tokens, die stärker mit dem aktuellen Token zusammenhängen, erhalten höhere Gewichte und werden verwendet, um die Value-Vektoren zu kombinieren.

5. Scaling Laws (2020) — Loss sinkt nach Potenzgesetz

OpenAI entdeckte: Erhöht man die Anzahl der Parameter, Daten oder Rechenleistung exponentiell, sinkt der Loss nach einem vorhersagbaren Potenzgesetz — es gibt keine „Geheimnis”, nur richtig skalieren.

public class ScalingLawEstimator {

    // L(N) = (Nc / N)^alpha — N: Parameter in Milliarden, Nc, alpha: experimentelle Konstanten
    public static double estimateLoss(double paramsBillion, double nc, double alpha) {
        return Math.pow(nc / paramsBillion, alpha);
    }
}

Mit festen nc und alpha aus experimentellen Daten sinkt estimateLoss mit steigendem paramsBillion, allerdings mit abnehmender Geschwindigkeit (sinkende Grenznutzen). Das ist der Grund, warum KI-Labs Hunderte Millionen Dollar in Rechenleistung investieren: Der Loss-Rückgang ist vorhersagbar, kein Glücksspiel.

Hinweis: Scaling Laws sind nicht unbegrenzt. Nach einer gewissen Schwelle braucht man für jede weitere kleine Loss-Reduktion exponentiell mehr Rechenleistung — deshalb verlagert sich die Industrie jetzt auf bessere Daten und Architekturen statt nur „größer” zu bauen.

6. GPT-3 (2020) — Skalierung erschafft neue Fähigkeiten

GPT-3 mit 175 Milliarden Parametern zeigte: In ausreichender Größe kann ein Model Few-Shot-Learning — mit nur wenigen Beispielen im Prompt, ohne erneutes Fine-Tuning der Gewichte.

<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: "Produkt ist gut, schnelle Lieferung" -> Positiv
                Review: "Ware defekt, nicht zu gebrauchen" -> Negativ
                Review: "%s" ->
                """.formatted(review);
        return chatClient.prompt(prompt).call().content();
    }
}

Die zwei Beispiele im Prompt „unterrichten” das Model effektiv im Kontext — kein erneutes Training nötig. Das sind die emergent abilities, die kleinere Modelle nicht können.

7. InstructGPT & RLHF (2022) — Rohes LLM zu hilfreicher Assistentin

GPT-3 original war gut beim Vorhersagen von Tokens, aber „hörte nicht zu” — es konnte irrelevante oder schädliche Antworten geben. InstructGPT nutzte Reinforcement Learning from Human Feedback (RLHF): Menschen rankten Antworten, worauf ein Reward-Model trainiert wurde, das dann mit PPO die Policy optimierte.

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();
    }
}

Der Code oben zeigt nur den finalen Schritt: die Completion mit dem höchsten Reward-Score wählen. In der Praxis aktualisiert PPO die Policy-Gewichte schrittweise, damit das Model selbst Completions mit hohem Score generiert, ohne nachfolgende Filterung.

Hinweis: RLHF benötigt große Mengen an von Menschen gelabelten Daten (Rankings), was kostspielig ist und von den Voreingenommenheiten der Annotatoren verzerrt wird. Techniken wie DPO (Direct Preference Optimization) später reduzieren diese Kosten.

8. ViT (2020) — Bilder sind auch ein „Satz”

Vision Transformer zerlegt Bilder in kleine Patches (z. B. 16×16 Pixel), flacht jedes Patch zu einem Vektor ab und behandelt sie wie Tokens in einem Transformer Encoder — genau wie Textverarbeitung.

public class PatchEmbeddingCalculator {

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

Mit 224×224-Bildern und 16×16-Patches gibt numPatches 196 zurück — gleich einem „Satz” von 196 Tokens für den Transformer. So wird die bewährte Attention-Technik von der NLP auf Vision angewendet, und ViT schlägt CNNs, wenn das Trainings-Dataset groß genug ist.

9. DDPM (2020) — Rauschen hinzufügen, dann lernen zu entrauschen

Denoising Diffusion Probabilistic Models sind die Grundlage aller modernen Diffusion-Modelle: Der Forward-Process fügt über viele Schritte graduell Gaussian-Rauschen zu Bildern hinzu, der Reverse-Process lernt, dieses Rauschen vorherzusagen und zu entfernen, um Originalbilder zu rekonstruieren.

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 kontrolliert das Verhältnis zwischen beibehaltenen Original-Bild zu Rauschen im Schritt t: nahe 1 bedeutet noch nah am Original, nahe 0 bedeutet fast reines Rauschen. Das generative Model lernt das Gegenteil — beginnend mit reinem Rauschen, Schritt für Schritt „entrauschen” zu einem bedeutungsvollen Bild.

10. Latent Diffusion (2021) — Entrauschen im komprimierten Raum

Diffusion direkt auf Pixeln laufen zu lassen ist sehr rechenintensiv. Latent Diffusion komprimiert Bilder mittels eines Autoencoders in einen kleineren Latent Space, führt den gesamten Denoising-Prozess dort aus und dekodiert dann zurück zu Bildern — das ist das Design hinter 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

Etwa 48x Kompression hilft Diffusion viel schneller zu laufen und bewahrt trotzdem Bildqualität, weil der Autoencoder beim Komprimieren redundante Informationen entfernt (gleichfarbige Regionen, kleine Details).

11. CLIP (2021) — Bilder und Text in einem Raum

CLIP trainierte Contrastive Learning auf hunderten Millionen (Bild, Caption)-Paaren: korrekte Paare haben nahe Embeddings, falsche Paare weit entfernte. Das Ergebnis ist ein gemeinsamer Raum zum Vergleichen von Text und Bildern mittels 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 gibt einen Wert nahe 1 zurück, wenn die Caption zum Bildinhalt passt, nahe 0 oder negativ, wenn nicht. Das steckt hinter der Bildersuche mit natürlichsprachlichen Beschreibungen (Text-to-Image-Suche), die viele E-Commerce-Plattformen heute nutzen.

12. Chain-of-Thought (2022) — Ein Prompt-Zusatz öffnet Denken

Mit nur „denk Schritt für Schritt” im Prompt zerlegen große LLMs von selbst komplexe Probleme, reduzieren damit Rechen- und Logikerrors drastisch im Vergleich zu direkten Antworten.

public String solveWithReasoning(ChatClient chatClient, String question) {
    String prompt = """
            Denk Schritt für Schritt, bevor du antwortest.
            Frage: %s
            Überlegung:
            """.formatted(question);
    return chatClient.prompt(prompt).call().content();
}

Das Bitten des Models, zu „denken”, bevor es antwortet, zwingt es, Zwischen-Tokens zu erzeugen — wie Notizen, auf die man bei schwierigen Fragen angewiesen ist.

Hinweis: Chain-of-Thought erhöht die Anzahl erzeugter Tokens, was zu höheren Kosten und Latenz führt. Bei einfachen Fragen (Fakten-Abfrage) erzwingt CoT nur Langsamkeit ohne Genauigkeitsgewinne.

13. RAG (2020) — Abrufen dann Generieren, keine Erfindungen

Retrieval-Augmented Generation verbindet LLM mit einem Abruf-Schritt: relevante Dokumente abrufen, bevor die Antwort generiert wird. Das reduziert Halluzinationen und ermöglicht Antworten auf Basis von Daten außerhalb des Trainings-Datensatzes.

<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 = """
                Antworte basierend auf folgenden Dokumenten. Wenn keine Information vorhanden ist, sag "Unklar".
                Dokumente:
                %s

                Frage: %s
                """.formatted(context, question);

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

similaritySearch ruft die 3 semantisch relevantesten Dokumentfragmente ab, bindet sie als Kontext in den Prompt ein und lässt das Model basierend auf diesem Kontext antworten, statt sich auf unsichere Trainings-“Erinnerungen” zu verlassen.

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("Unklar");

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

        DocumentAnsweringService service = new DocumentAnsweringService(emptyStore, builder);

        String result = service.answer("In welchem Jahr wurde das Unternehmen gegründet?");

        assertThat(result).contains("Unklar");
    }
}

Der Test bestätigt: Wenn kein relevantes Dokument gefunden wird, muss die Antwort „Unklar” zugeben, statt eine erfundene Antwort zu geben — das ist RAGs Kernziel.

Hinweis: Wenn dein Dokumenten-Korpus nur Dutzende Seiten hat, ist es einfacher und billiger, alles direkt in den Context Window zu packen statt eine ganze RAG-Pipeline mit Vector Store zu bauen. RAG lohnt sich bei großem oder sich häufig änderndem Datenbestand.

14. Fazit

Diese 12 Paper existieren nicht isoliert — sie bauen aufeinander auf: Transformer ist die Grundlage von GPT-3 und ViT; Scaling Laws erklären, warum GPT-3 funktioniert; RLHF verwandelt GPT-3 in ChatGPT; DDPM ist der Ursprung von Latent Diffusion; CLIP verbindet Diffusion-Modelle mit Text-Prompts. Dieses fundamentale Verständnis hilft dir, neue Paper schneller zu lesen, weil die meisten „neuen” Ideen heute Variationen oder Kombinationen dieser Grundlagen sind.