Generative Adversarial Networks (GAN): der Fälscher gegen den Detektiv

Das Spiel von Generator und Diskriminator, ein GAN von Grund auf, der nicht sättigende Verlust, acht Cluster auf einem Kreis und Mode Collapse, Ziffern schärfer als beim VAE, aber nicht alle, und der Weg vom GAN zu Diffusionsmodellen.

12 Minuten Matěj Žalmánek 2026-10-16

Serie KI-Grundlagen Teil 45 von 52

1. Landkarte der künstlichen Intelligenz: was was ist und wie alles zusammenpasst
2. Eine kurze Geschichte der künstlichen Intelligenz: von Turing bis zu Sprachmodellen
3. Daten, Modell, Training, Inferenz: die Grundbegriffe an einem einzigen Beispiel
4. Mathematische Notation lesen: Symbole, Indizes, Summen und Quantoren
5. Mengen und Relationen: der Baukasten, aus dem Definitionen in der KI bestehen
6. Funktionen und Abbildungen: warum jedes KI-Modell eine Funktion ist
7. Logik und Beweise: die Regeln, nach denen KI schließt
8. Graphen und Bäume: die Struktur, auf der Suche und neuronale Netze stehen
9. Lineare Algebra für maschinelles Lernen: Vektoren, Matrizen und warum KI vor allem multipliziert
10. Ableitungen, Gradient und Kettenregel: wie ein Modell herausfindet, in welche Richtung es lernen soll
11. Gradientenabstieg: wie ein Modell lernt
12. Was ist Wahrscheinlichkeit: vom Würfelwurf zu den Kolmogorow-Axiomen
13. Bedingte Wahrscheinlichkeit und der Satz von Bayes: wie du deine Einschätzung änderst, wenn du etwas Neues erfährst
14. Zufallsvariable und Verteilungsfunktion: eine Funktion, die alles über eine Verteilung verrät
15. Dichtefunktion und Wahrscheinlichkeitsfunktion: warum eine stetige Zufallsvariable in einem Punkt die Wahrscheinlichkeit null hat
16. Erwartungswert, Varianz und Kovarianz: wo eine Verteilung liegt, wie breit sie ist und was womit zusammenhängt
17. Überblick über Wahrscheinlichkeitsverteilungen: Bernoulli-, Binomial-, Poisson-, Gleich-, Normal- und Exponentialverteilung
18. Gesetz der großen Zahlen und zentraler Grenzwertsatz: Warum sich Durchschnitte so vorhersagbar verhalten
19. Statistik und Parameterschätzung: Maximum Likelihood, MAP und Konfidenzintervalle
20. Informationstheorie: Entropie, Kreuzentropie und KL-Divergenz — woher Verlustfunktionen kommen
21. Zustandsraumsuche: BFS, DFS, UCS und A* mit Animationen
22. Spiele und Gegner: Minimax, Alpha-Beta-Suche und Monte Carlo Tree Search
23. Constraint Satisfaction: Backtracking, Constraint-Propagierung und AC-3 an Sudoku und einer Karte tschechischer Regionen
24. Logik und wissensbasierte Systeme: Vorwärts- und Rückwärtsverkettung, Resolution und Expertensysteme
25. Planung: STRIPS, die Blockwelt, Heuristiken aus Relaxierung und Planung in KI-Agenten
26. Lokale Suche und simulierte Abkühlung: ein Handlungsreisender durch die tschechischen Regionalhauptstädte
27. Genetische Algorithmen: Population, Kreuzung, Mutation und Selektion am Rucksack für die Wanderung
28. Evolutionsstrategien und genetische Programmierung: von der 1/5-Erfolgsregel zum Keplerschen Gesetz
29. Ameisenkolonieoptimierung: wie eine Pheromonspur einen kurzen Weg findet
30. Partikelschwarmoptimierung: Trägheit, eigene Erfahrung und die Erfahrung des Schwarms
31. Neuroevolution: Evolution der Gewichte und der Gestalt neuronaler Netze und der Algorithmus NEAT
32. Fuzzy-Mengen und Zugehörigkeitsfunktionen: wie man „etwas warm“ aufschreibt
33. Fuzzy-Logik und Wahrscheinlichkeit: warum „etwas warm“ nicht „wahrscheinlich warm“ bedeutet
34. Fuzzy-Logik: t-Normen, Implikationen und WENN–DANN-Regeln
35. Fuzzy-Regelung: Mamdani und Sugeno vom Ventilator bis zum Pendel auf dem Wagen
36. Fuzzy-Clustering: der Algorithmus fuzzy c-means und Punkte zwischen den Clustern
37. Neuro-Fuzzy-Systeme (ANFIS): Fuzzy-Regeln, die aus Daten lernen
38. Markow-Ketten: Übergangsmatrix, stationäre Verteilung und PageRank
39. Hidden-Markov-Modelle: der Viterbi-Algorithmus und das unehrliche Kasino
40. Bayessche Netze: warum das Gras nass ist und was das für den Rasensprenger bedeutet
41. Der Kalman-Filter: wie man aus ungenauen Messungen schätzt, wo ein Auto ist und wie schnell es fährt
42. Arten des maschinellen Lernens: überwacht, unüberwacht, halbüberwacht und mehr
43. Prompts, Kontext und RAG: wie man einem Modell die richtigen Informationen gibt
44. Variational Autoencoder (VAE): neue Bilder aus einem stetigen latenten Raum
45. Generative Adversarial Networks (GAN): der Fälscher gegen den Detektiv
46. Diffusionsmodelle: wie aus reinem Rauschen ein Bild wird
47. Markow-Entscheidungsprozesse: Zustände, Aktionen, Belohnungen und Bellman-Gleichungen
48. Q-Learning und DQN: den Wert von Aktionen lernen, von der Tabelle bis zum neuronalen Netz
49. Policy Gradient und PPO: die Strategie direkt lernen
50. Wie ein KI-Agent funktioniert: ein Sprachmodell in einer Schleife mit Werkzeugen
51. Programmieren mit KI-Agenten: Auftrag, Tests und Kontrolle
52. Bewertung und Sicherheit von KI-Systemen: wie man misst und wie man überwacht

Der ganze Lehrplan der Serie 52 von 83 Themen fertig

Der Variational Autoencoder aus dem letzten Teil generiert ehrlich, aber verschwommen. 2014 kam Ian Goodfellow auf eine Idee, die fast wie ein Trick aussieht: Wir messen nicht, wie stark sich eine Stichprobe von den Daten unterscheidet, sondern lassen das ein anderes Netz beurteilen. Zwei Netze spielen ein Spiel — das eine fälscht, das andere erkennt die Fälschung — und beide werden dabei besser. So entstanden die ersten maschinell erzeugten Gesichter, die du nicht von Fotos unterscheiden kannst. In diesem Teil schreiben wir beide Netze von Grund auf und sehen, warum ihr Training so launisch ist.

Er baut auf den Teilen Variational Autoencoder, Logistische Regression (Sigmoid und Kreuzentropie) und Spiele und Gegner auf.

1. Der Fälscher und der Detektiv

Definition — Generative Adversarial Network (GAN)

Ein GAN (Ian Goodfellow u. a., 2014) besteht aus zwei Netzen. Der Generator G macht aus zufälligem Rauschen z ~ N(0, I) eine Stichprobe G(z). Der Diskriminator D gibt die Wahrscheinlichkeit D(x) zurück, dass x aus den echten Daten stammt. Sie spielen ein Nullsummenspiel zweier Spieler:

min_G max_D E_{x ~ data}[log D(x)] + E_z[log(1 − D(G(z)))].

Für festes G ist der beste Diskriminator D*(x) = p_data(x) / (p_data(x) + p_G(x)). Im Gleichgewicht erzeugt G genau die Verteilung der Daten und D gibt überall ½ zurück.

min_G max_D   E_{x ~ data}[ log D(x) ] + E_{z ~ N(0, I)}[ log(1 − D(G(z))) ]

E_{x ~ data}[log D(x)]

der Diskriminator auf echten Daten — am größten (0), wenn D echten Stichproben 1 gibt; der Logarithmus bestraft einen selbstsicheren Irrtum (D → 0) unbeschränkt

E_z[log(1 − D(G(z)))]

der Diskriminator auf Fälschungen — am größten, wenn er ihnen 0 gibt; es ist der einzige Term, in dem G vorkommt, der Generator lernt also nur aus ihm

max_D

der Diskriminator erhöht den Wert — beide Terme zusammen sind die negative binäre Kreuzentropie, es ist also gewöhnliches Training eines Klassifikators „echt / Fälschung“

min_G

der Generator senkt den Wert — er will, dass der Diskriminator sich bei Fälschungen irrt; was ein Spieler gewinnt, verliert der andere (Nullsumme)

Satz — der beste Diskriminator und was der Generator minimiert

Für festes G ist der Wert des Spiels ∫ [p_data(x) log D(x) + p_G(x) log(1 − D(x))] dx. In jedem Punkt x maximieren wir die Funktion a log y + b log(1 − y) für y ∈ (0, 1), wobei a = p_data(x), b = p_G(x).

Beweis. Die Ableitung a/y − b/(1 − y) ist null für y = a/(a + b) und die Funktion ist konkav (zweite Ableitung −a/y² − b/(1 − y)² < 0), es handelt sich also um ein Maximum. Daraus folgt D*(x) = p_data(x) / (p_data(x) + p_G(x)). Durch Einsetzen und Umformen (Goodfellow u. a., 2014):

V(D*, G) = −log 4 + 2 · JSD(p_data ‖ p_G),   JSD(p ‖ q) = ½ KL(p ‖ m) + ½ KL(q ‖ m),   m = ½(p + q).

Die Jensen-Shannon-Divergenz ist nichtnegativ und genau dann null, wenn p_G = p_data. Mit dem besten Diskriminator minimiert der Generator also die JSD, und das Minimum −log 4 ≈ −1,386 wird erreicht, wenn er genau die Daten erzeugt. ∎

Beispiel: Wo die Dichte der Daten 0,3 und die der Fälschungen 0,1 ist, ist D* = 0,3 / 0,4 = 0,75 (der Punkt ist eher echt); wo der Generator übers Ziel hinausschießt (Daten 0,1, Fälschungen 0,3), ist D* = 0,25. Wo die Dichten gleich sind, ist D* = ½ und der Verlust des Diskriminators (binäre Kreuzentropie pro Stichprobe) ist ln 2 ≈ 0,693.

Der Diskriminator ist ein gewöhnlicher Klassifikator mit Sigmoid und Kreuzentropie, wie die logistische Regression, nur mit zusätzlichen Schichten. Der Zauber liegt im Generator: Der Gradient seines Verlusts fließt per Backpropagation durch den Diskriminator bis ins Bild und von dort in die Gewichte des Generators. Der Diskriminator sagt ihm so, in welche Richtung er jedes Pixel verschieben soll, damit es glaubwürdiger aussieht.

2. Training: abwechselnde Schritte

Trainiert wird abwechselnd: ein Schritt des Diskriminators (ein Batch echter Daten und ein Batch Fälschungen, D bei den echten erhöhen, bei den falschen senken), dann ein Schritt des Generators (die Fälschungen dorthin verschieben, wo D sie für echt hält). Beide Netze haben bei uns zwei verborgene Schichten mit Leaky ReLU und werden mit Adam trainiert.

Definition — nicht sättigender Verlust des Generators

Statt log(1 − D(G(z))) aus dem ursprünglichen Spiel zu minimieren, lernt der Generator, log D(G(z)) zu maximieren, also −log D(G(z)) zu minimieren. Beide Verluste haben dasselbe Ziel, aber einen anderen Gradienten: Ist D = σ(s), dann ist |∂ log(1 − D)/∂s| = D, während |∂(−log D)/∂s| = 1 − D. Vorgeschlagen haben ihn schon Goodfellow u. a. im selben Artikel.

∂/∂s log(1 − σ(s)) = −D,    ∂/∂s (−log σ(s)) = −(1 − D)

s

der Logit — die Ausgabe des Diskriminators vor dem Sigmoid; wir leiten nach ihm ab, weil der Gradient von hier zurück in den Diskriminator und durch ihn in die Fälschung fließt

D = σ(s)

die Wahrscheinlichkeit, dass die Fälschung echt ist; man verwendet σ′(s) = σ(s)(1 − σ(s)), deshalb kommen so einfache Ausdrücke heraus

log(1 − σ(s))

der ursprüngliche Verlust des Generators (wird minimiert) — sein Gradient hat den Betrag D, wenn der Diskriminator die Fälschung also sicher entlarvt (D ≈ 0), ist er fast null: Sättigung

−log σ(s)

der nicht sättigende Verlust — sein Gradient hat den Betrag 1 − D, ist also gerade bei Fälschungen am größten, die der Diskriminator entlarvt hat

Ehrlich gesagt: In unseren kleinen Versuchen hat auch der ursprüngliche Verlust gelernt, weil der Diskriminator am Anfang nicht so selbstsicher war. Bei großen Netzen auf Bildern, wo der Diskriminator schnell gewinnt, ist der Unterschied entscheidend. Im Weiteren verwenden wir den nicht sättigenden Verlust.

Wie der Gradient bis zum Generator gelangt, zeigt die Kettenregel. Die Fälschung x = G(z) ist für den Diskriminator nur eine Eingabe, die Backpropagation muss also nicht in ihm enden:

∂L_G / ∂θ_G = ∂L_G / ∂s · ∂s / ∂x · ∂x / ∂θ_G

∂L_G / ∂s

eine einzige Zahl aus dem Verlust, beim nicht sättigenden −(1 − D) — „wie stark“ sich die Fälschung verbessern soll

∂s / ∂x

der Gradient des Diskriminators nach seiner Eingabe (beim Kreis 2 Zahlen, bei einer Ziffer 64) — „in welche Richtung“ jede Koordinate verschoben werden soll, damit die Fälschung echter aussieht; die Gewichte des Diskriminators ändern sich in diesem Schritt nicht

∂x / ∂θ_G

gewöhnliche Backpropagation durch den Generator — übersetzt die gewünschte Verschiebung der Fälschung in eine Änderung der Gewichte des Generators

Definition — Verlust des Diskriminators und Softplus

Der Diskriminator gibt einen Logit s zurück und D = σ(s). Für eine echte Stichprobe mit Logit s_r und eine Fälschung mit Logit s_f ist sein Verlust die binäre Kreuzentropie

L_D = −log σ(s_r) − log(1 − σ(s_f)) = softplus(−s_r) + softplus(s_f),   softplus(u) = ln(1 + e^u),

denn −log σ(s) = ln(1 + e^−s) und 1 − σ(s) = σ(−s). Das Programm berechnet Softplus über den Logit, nicht über D: Für s = 40 ist σ(s) in Gleitkommadarstellung genau 1 und log(1 − D) käme als −∞ heraus, während softplus(40) ≈ 40. Gradienten: ∂L_D/∂s_r = σ(s_r) − 1, ∂L_D/∂s_f = σ(s_f).

for t in range(kroku):
    # 1. Schritt des Diskriminators: echt → 1, Fälschungen → 0
    gD = 0
    for _ in range(davka):
        x = nahodny_vzorek(data)
        gD += D.zpet(D(x), dL_ds=sigmoid(D(x)) - 1)
        f = G(sum())                           # Fälschung, G lernt jetzt nicht
        gD += D.zpet(D(f), dL_ds=sigmoid(D(f)))
    adam_D(gD / davka)
    # 2. Schritt des Generators: der Gradient geht durch D bis in die Fälschung
    gG = 0
    for _ in range(davka):
        x = G(sum())
        dL_ds = sigmoid(D(x)) - 1              # nicht sättigend −log σ(s)
        dL_dx = D.zpet_do_vstupu(dL_ds)        # Gewichte von D unverändert
        gG += G.zpet(dL_dx)
    adam_G(gG / davka)                         # Adam mit β₁ = 0,5 wie bei DCGAN

3. Acht Cluster auf einem Kreis

Ein klassisches Experiment: Die Daten sind Punkte aus acht kleinen normalverteilten Clustern (σ = 0,05), angeordnet auf einem Kreis mit Radius 2. Der Generator bekommt zweidimensionales Rauschen und gibt einen Punkt in der Ebene zurück. Wir messen die Qualität (Anteil der Stichproben innerhalb von 3σ um irgendein Zentrum) und die Abdeckung (in wie viele Cluster mindestens 2 % der Stichproben fallen).

Definition — Daten, Qualität und Abdeckung

Die Zentren der Cluster sind c_j = (r cos(2πj/8), r sin(2πj/8)) für j = 0, …, 7 mit r = 2; ein Datenpunkt ist c_j mit zufälligem j plus Rauschen N(0, σ²I), σ = 0,05. Für Stichproben x₁, …, x_n des Generators:

Qualität = (1/n) · #{i : min_j ‖x_i − c_j‖ < 3σ},   Abdeckung = #{j : n_j ≥ 0,02 · n},

wobei n_j die Anzahl der Stichproben innerhalb von 3σ um das Zentrum c_j ist. Zahlen: 3σ = 0,15, benachbarte Zentren liegen 2r sin(π/8) ≈ 1,53 auseinander, also mehr als zehnmal so weit. Die Momentaufnahmen haben n = 400 Stichproben, ein Cluster gilt also ab 8 Stichproben als abgedeckt.

Selbst ein perfekter Generator hat keine Qualität von 100 %: Der Abstand eines Punktes vom Zentrum einer zweidimensionalen Normalverteilung ist Rayleigh-verteilt, und innerhalb von 3σ liegt der Anteil 1 − e^−9/2 ≈ 0,989, also etwa 98,9 %.

Nach 500 Schritten erzeugt der Generator eine verschwommene Wolke (Qualität 6 %), nach 2 000 Schritten ziehen sich die Punkte in 6 Cluster zusammen, und am Ende (Schritt 8 000) deckt er alle 8 mit einer Qualität von 73 % ab. Der Generator hat nie einen einzigen echten Punkt gesehen — alles hat er aus dem Gradienten des Diskriminators erfahren.

4. Mode Collapse

Definition — Mode Collapse (Modenkollaps)

Der Generator erzeugt nur einen Teil der Datenverteilung — einige Moden (Cluster, Arten von Bildern) — und lässt die übrigen aus. Der Verlust bestraft das nicht direkt: Der Diskriminator beurteilt jede Stichprobe für sich, und eine gute Fälschung einer Art ist für ihn genauso überzeugend wie eine bunte Sammlung. Beim vollständigen Kollaps erzeugt der Generator für jedes z fast dasselbe.

Satz — gegen einen festen Diskriminator ist ein einziger Punkt am besten

Für festes D ist der Verlust des Generators L_G = E_z[−log D(G(z))] ≥ −log D(x*), wobei x* der Punkt ist, in dem D am größten ist. Gleichheit gilt für einen Generator, der jedes z nach x* schickt.

Beweis. Für jedes z ist D(G(z)) ≤ D(x*), und weil −log fallend ist, ist −log D(G(z)) ≥ −log D(x*); der Erwartungswert erhält die Ungleichung. ∎

Der Verlust ist ein Mittelwert über einzelne Stichproben, und nichts in ihm belohnt Vielfalt. Gegen einen festen Gegner ist der vollständige Kollaps also optimal; verhindert wird er nur dadurch, dass der Diskriminator reagiert und anfängt, x* zu verdächtigen. Springt der Generator schneller, als der Diskriminator vergisst, dreht sich das Spiel im Kreis. Deshalb helfen Anpassungen, die dem Diskriminator einen Blick auf den ganzen Batch geben (Minibatch Discrimination, Tim Salimans u. a., 2016), oder ein anderer Abstand zwischen Verteilungen (Wasserstein, siehe unten).

Dasselbe Netz, dieselben Daten, dieselben Einstellungen — nur ein anderer zufälliger Seed:

Nur einer der vier Läufe hat alle acht Cluster abgedeckt. Der Lauf mit Seed 3 endete bei 5 und hat sich ab Schritt 5 000 nicht mehr bewegt. Das ist typisch für GANs: Das Training hat nicht einen einzigen Verlust, der sinkt, sondern ein Spiel zweier Spieler, und das Ergebnis hängt stärker vom Zufall ab, als uns lieb wäre.

5. Ziffern: schärfer, aber nicht alle

Jetzt dieselben Ziffern 8 × 8 wie beim VAE. Generator: achtdimensionales Rauschen → 64 → 64 → 64 Pixel mit Sigmoid; der Diskriminator spiegelbildlich. 6 000 Schritte, zwei Läufe mit unterschiedlichem Seed. Die Qualität messen wir genauso wie im letzten Teil — über den Abstand einer Stichprobe zur nächsten Trainingsziffer.

Die Stichproben des GAN sind schärfer: Abstand 0,049 und 0,042 gegenüber 0,054 beim VAE (echte Ziffern 0,017). Ein GAN bestraft Unschärfe nicht durch Mittelung wie der Rekonstruktionsverlust des VAE — ein verschwommenes Bild erkennt der Diskriminator leicht. Aber wie viele von welchen Ziffern erzeugt der Generator?

In den Daten kommt jede Ziffer gleich oft vor. Der Lauf mit Seed 2 erzeugt dabei vor allem Sechsen (69 von 200), Achten und Dreien, und die Ziffern 0, 1, 2, 4, 7 fast gar nicht (höchstens 3 Stichproben). Der Lauf mit Seed 1 ist vielfältiger, aber auch dort haben die Ziffern 0, 4, 9 weniger als die Hälfte ihres Anteils (höchstens 6 Stichproben statt 20). Es ist derselbe Mode Collapse wie beim Kreis, nur auf Bildern: Das GAN gewinnt bei der Schärfe, der VAE bei der Abdeckung.

6. Vom GAN zur Diffusion

• DCGAN (Alec Radford u. a., 2015) zeigte, wie man konvolutionale GANs baut, die sich zuverlässig auf Fotos trainieren lassen.
• Wasserstein GAN (Martin Arjovsky u. a., 2017) ersetzte den Klassifikator durch einen „Kritiker“, der den Abstand zwischen Verteilungen misst; das Training ist stabiler und weniger anfällig für Mode Collapse.
• StyleGAN (Tero Karras u. a., Nvidia, 2018–2020) erzeugt fotorealistische Gesichter in einer Auflösung von 1024 × 1024 — die bekannte Website „this person does not exist“.
• Um 2021 wurden GANs von Diffusionsmodellen überholt (Prafulla Dhariwal und Alex Nichol: „Diffusion Models Beat GANs on Image Synthesis“). Sie sind langsamer, trainieren aber stabil und decken die ganze Verteilung ab. Die Idee des Diskriminators lebt aber weiter — als Hilfsverlust, der Bildern Schärfe verleiht, etwa in Bild- oder Audio-Codecs.

Warum Wasserstein hilft, sieht man am einfachsten Beispiel (eine vereinfachte Version des Beispiels aus dem Artikel von Arjovsky u. a., 2017): Die Daten sind ein einziger Punkt 0, der Generator erzeugt einen einzigen Punkt θ. Solange θ ≠ 0, überlappen sich die Verteilungen nicht und JSD = ln 2 ≈ 0,693, egal wie weit θ entfernt ist — der Gradient nach θ ist null und der Generator weiß nicht, wohin. Die Wasserstein-Distanz ist |θ|, sie zeigt die Richtung also auch aus großer Entfernung.

W(p_data, p_G) = sup_{‖f‖L ≤ 1} ( E_{x ~ data}[f(x)] − E_z[f(G(z))] )

sup_{‖f‖L ≤ 1}

der Kritiker f — ein Netz, das statt einer Wahrscheinlichkeit eine beliebige Zahl zurückgibt; die Bedingung „1-Lipschitz-stetig“ (|f(a) − f(b)| ≤ ‖a − b‖) erlaubt ihm nicht, zwei nahe Punkte beliebig scharf zu trennen, sonst könnte die Differenz ins Unendliche wachsen

E_data[f(x)]

die durchschnittliche Bewertung der echten Daten — der Kritiker will sie möglichst groß

E_z[f(G(z))]

die durchschnittliche Bewertung der Fälschungen — der Kritiker will sie möglichst klein, der Generator möglichst groß; die Differenz ist stetig in den Parametern des Generators, der Gradient verschwindet also nicht, selbst wenn sich die Verteilungen nicht überlappen

7. Zusammenfassung

• GAN = Generator und Diskriminator in einem Spiel; der Generator lernt nur aus dem Gradienten, den ihm der Diskriminator schickt.
• Der nicht sättigende Verlust −log D(G(z)) gibt dem Generator ein starkes Signal auch am Anfang, wenn der Diskriminator gewinnt.
• Bei acht Clustern hat nur einer der vier Läufe alle abgedeckt (7, 8, 5, 6); das Ergebnis hängt stark vom Zufall ab.
• Bei Ziffern sind die Stichproben schärfer als beim VAE (0,042 gegenüber 0,054), aber einige Ziffern fehlen — Mode Collapse.
• Heute erzeugen vor allem Diffusionsmodelle Bilder; der Diskriminator ist als Helfer für Schärfe geblieben.

Willst du es selbst ausprobieren? Lass einen KI-Agenten ein kleines GAN auf acht Clustern auf einem Kreis trainieren und es fünfmal mit verschiedenen Seeds laufen. Dann soll er ein Wasserstein GAN mit demselben Netz versuchen und vergleichen, wie viele Cluster es jedes Mal abdeckt.

Siehst du das anders? Schreib an support@coden-app.com.