Abstrakte Idee:
Bei einem Klassizierungsproblem haben wir typischerweise zufällige Daten \(x\) (etwa Bilder), zugehöriges Ground Truth Wissen \(y\) (etwa Label) und eine differentierbare Zielfunktion \(E(f(x), y)\) gegeben, die die Qualität des Klassifizerers \(f\) (etwa ein Neuronales Netz) bewertet.
Stochastic Gradient Descent: Für alle Parameter \(\theta\) eines Modells \(f_\theta\) haben wir die Gradienten \(\nabla_\theta E(f_\theta(x), y)\) bestimmt, mit der Learning Rate skaliert und additiv angepasst.
Die zündende Idee ist nun, dass wir ja bereits ein Werkzeug haben müssten, dass uns erlaubt Bilder zu erzeugen: Black-Box-Optimization + Cross-Entropy (CE).
Die Cross-Entropy hat das Netz in der Art trainiert, dass die Ausgabe des Netzes möglichst gut auf die Labels (Ground Truth) des Datensatzes passen und die Black-Box-Optimizer verändern Gewichte in der Art, dass eine beliebigen lokal ableitbare Energie, die von diesen Gewichten abhängt minimiert wird.
Wie können wir das nutzen?

• Wir nutzen den Optimizer der Wahl (am einfachsten wäre vermutlich Adam) und optimieren nicht die Gewichte des Netzwerks, sondern das Bild, dass klassiert werden soll.
  Mit anderen Worten: die Pixelwerte der Eingabe werden nun als Gewichte behandelt, die Parameter des Netzwerks selbst bleiben konstant!
• Bei der Evaluierung benötigen wir nach dem Training den Loss nicht mehr und können auf die Komponente der Ausgaben suchen. Dass wir das so tun können verdanken wir dem Training mit dem CE-Loss.
  • Das bedeutet aber auch umgekehrt, dass bei einem mit CE trainiertem Netz eine Eingabe (dem Netz nach) stärker zu einer Klasse gehört, wenn die Ausgabe dieser Klasse gröẞer wird.
    (Dies wird später noch einmal wichtig, daher die explizite Wiederholung an dieser Stelle).
• Noch eine wichtige Bemerkung, die damit zusammenhängt:
  Unser Ziel ist es Bilder einer von uns gewählten Klasse zu erzeugen. Somit wird etwa bei der „Deep Dream“-Methode die Komponente der gewünschten Klasse maximiert, statt den CE-Loss mit der gewünschten Klasse als Label zu minimieren. (Testen Sie ruhig beide Varianten aus).

Datensätze:
Wir gehen nun davon aus, dass das Netzwerk bereits trainiert wurde. (Begründung kommt gleich). Im speziellen schauen wir uns wieder entweder den Bilddatensatz CIFAR-10 oder einen neuen Datensatz namens ImageNet an. Der Unterschied zwischen diesen Beiden ist im Prinzip lediglich die Datenmenge, die für das Training benutzt wird: Während CIFAR-10 aus 50.000 Bildern (und je 32 x 32 Pixel) mit einer zugehörigkeit zu einer von 10 Klassen besteht, enthält ImageNet nicht nur größere (und damit mehr Details) und mehr (1.2 Millionen) Bilder, sondern auch deutlich mehr Klassen (1000 Klassen). Beide Datensätze haben Vor- und Nachteile. Während der kleinere Datensatz (CIFAR-10) auch häufiger durch kleinere Netze abgebildet werde kann, sind die Berechnungen schneller und man sieht damit schneller ein Ergebnis. Der Nachteil ist, dass die Bilder aus CIFAR-10 so unscharf sind, dass die untenstehenden Ideen kaum zu guten Ergebnissen führen würden. Aus diesem Grund verwenden wir vortrainierte Netze¹ (d.h. Gewichte und Netzdefinitionen, die bereits trainiert wurden und auch eine gute Klassifizierungsperformance erreichen).

[1] Ein solches Netz haben wir in dieser Veranstaltung leider nicht trainiert. Dies hat mehrere Gründe: Das Training dauert leider viel zu lang im Beispiel von ImageNet (in etwa 2 - 10 Tage Rechenzeit mit optimiertem Code und einer guten Grafikkarte, je nach Tricks & gewünschter Qualität) und selbst im Beispiel von CIFAR-10 benötigen wir für eine gute Qualität noch ein Paar Tools, die wir aus zeitlichen Grunden nicht in der Übung besprochen haben, die aber in der Vorlesung erwähnt wurden.
Im Sinne der Aufgabe reicht es glücklicherweise aus, nur vortrainierte Netze zu benutzen, da diese bereits die Struktur der Daten gelernt haben und wir dieses Wissen mit den unten stehenden Methoden wieder (zumindest zum Teil) extrahieren können.

Aufgabe 0:

Wir machen uns als erstes mit der Verwendung von vortrainierten Netzen vertraut. In PyTorch ist das laden solcher Netze sehr einfach:

1. Lesen Sie dazu die Dokumentation zum vortrainierten VGG-Netz im PyTorch Hub durch.
2. Testen Sie den Code, indem Sie ein beliebiges Bild einlesen und mithilfe eines VGG-11 klassifizieren. Verifizieren Sie, dass das Netzwerk erkennt was sich auf dem Bild befindet.

Basisaufgabe 1: Generierte Gegenbeispiele / Adversarial Examples

Wir definieren also \(E := \operatorname{SoftmaxCrossEntropy}\) oder \(E := -i\text{-te Komponente der Netzausgabe}\) (das umgekehrte Vorzeichen ist hier wichtig).
Wir verfolgen die oben genannte Idee, nämlich die Netzwerkparameter nicht mehr zu verändern, sondern den Gradienten \(\nabla_x E(f(x), y)\) der Eingabe zu bestimmen und die Eingabe statt der Gewichte des Netzwerkse anzupassen mit dem Ziel auch hier die Energie \(E\) zu minimieren. Die simpelste Methode ist die Gradienten „einfach direkt” anzuwenden.

Wie oben beschrieben bilden wir also den Gradienten \(\nabla_x E\) des Losses nach der Eingabe und passen die Eingabe mithilfe eines vorgefertigten Optimizers (etwa Adam, SGD, etc.). (Optimieren Sie mehrere Schritte, am besten so lange, bis die Klasse klar vorhergesagt wird).

1. Wählen Sie ein festes Ziellabel und starten Sie mit einem Bild, das aus zufälligen Pixeln besteht (etwa Normalverteilt). Wie hat sich das Bild durch die Optimierung verändert?
2. Wählen Sie nun ein beliebiges Foto und optimieren Sie das Bild nun so, dass das Netz für das veränderte Bild auch das Ziellabel vorhersagt. Wie hat sich das Bild durch die Optimierung jetzt verändert? (Falls Sie nichts erkennen, Schauen Sie sich das Diff der beiden Bildern an).
3. Was für Rückschlüsse können Sie aus dieser Beobachtung ziehen?

Erweiterung A: Deep Dream

Die Methode oben hatte so Ihre Tücken. Aus dem Grund versuchen wir eine etwas andere Variante, die heute unter dem Namen Deep Dream bekannt ist: Statt der direkten Anwendung der Gradienten auf das Bild „verschmieren“ wir die Gradienteninformation um die Probleme der einfacher Variante von oben zu umgehen. Hierzu gibt es verschiedene Herangehensweisen, wir werden jedoch folgende Idee verfolgen:

Algorithmus:

• Wir starten mit einem sehr kleinen Bild, und wenden die direkte Methode von Aufgabenteil 1 an.
• Nach einigen (~ hundert) Schritten verschmieren wir die gelernte Information, indem wir das Bild hochskalieren und von dort aus weitertrainieren.
• Dies kann beliebig häufig wiederholt werden.

Verbesserung (optional): Mit der oben genannten Methode werden wir nicht so schöne Ergebnisse sehen wie in den verlinkten Visualsierungen. Dennoch sollten sich Strukturen bilden. Besser wird das Ergebnis durch einen einfachen Trick:

• Statt erst mit einem kleinen Bild zu starten und dieses dann hochzuskalieren trainert man direkt auf allen Größen gleichzeitig.
• Dazu erstellt man das Bild der Wunsch bzw. Ziel- bzw. Maximalgröße
• Wie gewohnt Berechnet die Gradienten für einige Verkleinerungen (halb so groß, viertel so groß, ...)
• Zuletzt skaliert man die Verkleinerungen wieder zurück und mittelt die Ergebnisse punkt- bzw. pixelweise.
• Durch Wiederholung erhält man eine Optimierung auf allen Größenskalen

Erweiterungen
(Wählen Sie mindestens eine der folgenden Varianten):

• Wenn man nach der Optimierung und erreichen einer Maximalgröße das Bild erst etwas zuschneidet und dann wieder hochskaliert kann man einen solchen Effekt erreichen
• Eine andere Variante das Rauschen durch eine kleine Version eines echten Fotos zu starten. Ein mögliches Ergebnis ist hier zu finden.
• Statt nun mit der Ausgabe des Netzwerkes zu arbeiten können wir mit genau der gleichen Technik visualisieren welche Features einzelne Layer oder Neuronen besonders stark aktiviert. Wählen Sie dazu einfach einige Neuronen auf einem tieferen oder höheren Layer und optimieren Sie die Eingabe so, dass die Werte des gewählten Neurons möglichst hoch ausschlagen.
  Sie werden sehen, dass sich die resultierenden Bilder stark ändern werden, je nachdem ob sie frühere Layer, also solche, die näher an der Eingabe liegen, oder abstraktere Layer, die näher an der Ausgabe liegen) verwenden.
  Tipp zur Implementierung

  Der folgende Code speichert automatisch die Layer-Zwischenergebnisse aller linearen Layer bei jedem Forward-Pass.

  layer_outputs = {}
  def hook_fn(module, input, output):
      layer_outputs["#layer%i-%s" % (module.id, module)] = output
  for id, m in enumerate(model.modules()):
      if not isinstance(m, nn.Conv2d):
          continue
      m.id = id
      m.register_forward_hook(hook_fn)
  

  
  
  

Erweiterung B: Energiebasierte Generatoren

Wir möchten die vorgestellte Methode aus dem Paper Your Classifier is Secretly an Energy Based Model and You Should Treat it Like One nachimplementieren.

Sehr ähnliches Paper, nur unsupervised ist: Implicit Generation and Generalization in Energy-Based Models

Die Idee ist die folgende:

• Wie wir in Aufgabe 1 gesehen haben, ist es schwer direkt Bilder der Datenverteilung zu generieren, wenn wir einfach die Gradienten der Energiefunktion auf die Eingabe anwenden.
• Im Paper wird Langevin-Dynamics verwendet, eine Methode, die Beispiele der Datenverteilung (also vereinzelte Bilder aus dem Traingsdatensatz) verwendet und mittels verrauschten Gradienten immer wieder vermischt.
• Konkret wird hier durch Positiv- und Negativbeispiele der Gradient stets richtung Datenverteilung gelenkt. Der Rauschterm sorgt dafür, dass tatsächlich neue „ungesehene“ Bilder generiert werden.

Aufgaben:

1. In der Übung wurde das Paper im Detail erklärt. Zur Wiederholung:
   Lesen Sie Abschnitt 1 des Papers für einen groben Überblick über die Methode. Die Methode selbst wird in Abschnitt 3 erklärt.
   Die Autoren geben in Abschnitt A.2 (A wie Anhang), A.11 und A.12 weitere Tipps, um die Methode zu stabilisieren.
2. Implementieren und testen Sie die Methode für ein VGG-11.