© Serhii Radachynskyi / 123rf.com

Wegen der atemberaubenden Fortschritte im Bereich des maschinellen Lernens setzt man es zunehmend auch dort ein, wo davon Leben und Gesundheit von Menschen abhängen, beispielsweise beim autonomen Fahren. Allerdings lässt sich das Maschinenlernen auch böswillig manipulieren – und dann wird es gefährlich.

Das Interesse an maschinellem Lernen hat in den letzten zwei Jahrzehnten aufgrund der großen Fortschritte, beispielsweise bei der Spracherkennung oder dem automatischen Übersetzen von Texten, enorm zugenommen. Vor allem die Entwicklungen in jüngster Zeit (Generierung von Texten, Bildern oder sogar kleineren Videos oder dem Lösen von mathematischen Problemen) haben gezeigt, welches Potenzial in lernenden Systemen steckt. Aufgrund dieser Fortschritte wird maschinelles Lernen auch zunehmend in sicherheitskritischen Anwendungen eingesetzt. Beim autonomen Fahren zum Beispiel oder in Zugangssystemen, die biometrische Merkmale auswerten. Maschinelles Lernen ist allerdings nie fehlerfrei, und falsche Entscheidungen können mitunter zu lebensbedrohlichen Situationen führen. Das ist sehr gut bekannt und wird bei der Entwicklung von Machine-Learning-Modellen und deren Integration in andere Systeme in der Regel auch berücksichtigt. Lange Zeit wurde jedoch weniger beachtet, was passiert, wenn jemand versucht das Modell vorsätzlich zu manipulieren.

Adversarial Examples

Mit der Entdeckung der Adversarial Examples [1] hat sich das schlagartig geändert. Dabei handelt es sich um speziell manipulierte Bilder, die selbst State-of-the-Art-Bilderkennungssysteme auf eindrucksvolle Art und Weise täuschen. Sie sind deshalb so beeindruckend, weil Menschen keinen Unterschied zwischen dem Adversarial Example und dem Originalbild wahrnehmen können, aus dem es berechnet wurde. Während das Modell das Original korrekt erkennt, klassifiziert es das Adversial Example falsch. Sogar die Kategorie, in die das Adversial Example fälschlicherweise eingeordnet werden soll, lässt sich vorgeben. Weiterentwicklungen [2] der Adversarial Examples haben gezeigt, dass man auch die Textur von Gegenständen in unserer Realität so manipulieren kann, dass ein Modell diese manipulierten Objekte falsch klassifiziert. Selbst dann, wenn sie aus unterschiedlichen Richtungen und Entfernungen betrachtet werden.

Abbildung 1: Der Panda links wird mit einer Sicherheit von 57,7 Prozent als solcher erkannt. Durch Hinzufügen eines bestimmten Rauschens (Mitte) entsteht das Adversarial Example. Nun wird das Tier als Gibbon klassifiziert [3]. Quelle: arXiv preprint arXiv:1412.6572 (2014)

Model Extraction Attacks

Im Laufe der Zeit machten sich weitere Schwachstellen von Machine-Learning-Modellen bemerkbar. So erwies es sich zum Beispiel als möglich, die Parameter eines Modells zu extrahieren. Solche Angriffe werden auch als Model Extraction Attacks bezeichnet. Die Parameter kodieren das Wissen eines Modells, das das Modell während des Trainings anhand von Beispielen gelernt hat. Das Training kann aber gerade für sehr große Modelle, die aus mehreren Hundert Millionen oder sogar Milliarden Parametern bestehen, sehr aufwendig sein, und es können sehr hohe Kosten entstehen. Es wird zum Beispiel geschätzt, dass die Forschung und Entwicklung von GPT-3, einem Transformer-Modell mit 175 Milliarden Parametern, Kosten in Höhe von 10 bis 20 Millionen Dollar verursacht hat.

Derart teure Modelle stehen der Öffentlichkeit selten zur freien Verfügung. Stattdessen werden sie oftmals in der Cloud betrieben, in einer geschützten Infrastruktur, als Machine-Learning-as-a-Service, sodass niemand auf die Parameter zugreifen kann. Wer das Modell nutzen will, bekommt nur gegen Bezahlung Zugriff auf dessen API. Sind jedoch bestimmte Bedingungen erfüllt, lassen sich die Parameter durch geschickte Nutzung der API aus einem Modell extrahieren. Hat man aber erst einmal die Parameter eines Modells, besteht kein Grund mehr, für den Cloud-Dienst zu bezahlen. Denn dann kann man das Modell einfach selbst betreiben. Dessen ursprünglicher Schöpfer bleibt in diesem Fall möglicherweise auf den Kosten sitzen, die er für den Aufbau des Modells aufgebracht hat.

Membership Inference Attacks

Man kann aber auch andere Informationen aus einem Modell gewinnen, die vertraulich sind und nicht öffentlich bekannt sein sollten. So lässt sich durch geschickte Abfragen herausfinden, ob bestimmte Daten für das Training eines Modells verwendet wurden, zum Beispiel die Daten einer bestimmten Person. Solche Angriffe sind unter dem Begriff Membership Inference Attacks bekannt. Angenommen, ein Modell hat anhand von Patientendaten gelernt, eine bestimmte Krankheit zu erkennen. Dafür wurden Daten von Personen verwendet, die unter dieser Krankheit leiden. Kann man feststellen, dass eine bestimmte Person in dem Datensatz vorkommt, weiß man, dass diese Person diese Krankheit hat.

Model Inversion Attacks

Weiterhin wurden Angriffe vorgestellt, mit denen sich Daten aus einem Modell rekonstruieren lassen [4], die für dessen Training verwendet wurden. Diese Angriffe heißen Model Inversion Attacks. Um ein Modell zu erstellen, das Gesichter erkennen kann, muss der Trainingsdatensatz einige Beispielfotos von jeder Person enthalten, die das Modell erkennen soll. In Abbildung 2 (links) sind Fotos zu sehen, die in einem solchen Datensatz vorkommen könnten. Mit Zugriff auf die Parameter des mit diesen Fotos trainierten Modells kann man von jeder in diesem Datensatz enthaltenen Person ein erkennbares Bild rekonstruieren (Abbildung 2, rechts).

Abbildung 2: Links: 6 Beispiele für Bilder, die für das Training einer Gesichtserkennung verwendet wurden. Rechts: Rekonstruiertes Bild einer Person [4]. Quelle: ACM SIGSAC

Data Poisoning Attacks

Die letzten drei beschriebenen Angriffe richten sich gegen die Vertraulichkeit eines Modells, weil es möglich war, vertrauliche Daten aus dem Modell zu gewinnen. Es sind allerdings auch Angriffe auf die Integrität eines Modells möglich, also Angriffe, die das Verhalten eines Modells beeinflussen. So lassen sich zum Beispiel durch manipulierte Trainingsdaten (data poisoning) Backdoors in Machine-Learning-Modelle platzieren. Es handelt sich dabei um Angriffe auf das Training (training-time), während Angriffe auf die Vertraulichkeit ein bereits trainiertes Modell attackieren (test-time).

Ein Modell mit einer Backdoor verhält sich mit normalen Eingabedaten, die es zur Testzeit bekommt, ganz normal und erreicht in der Regel ebenso hohe Genauigkeiten wie ein Modell, das keine Backdoor enthält. Ist jedoch in einer Eingabe ein bestimmter Trigger vorhanden, aktiviert er die Backdoor, und das Modell verhält sich wie vom Angreifer intendiert. Ein Modell erkennt dann zum Beispiel statt einer Katze einen Hund.

Datenmanipulation

Für einen solchen Angriff benötigt ein Hacker Zugriff auf die Trainingsdaten. Liegen sie in einer vertrauenswürdigen Umgebung (zum Beispiel auf einem gesicherten Datenspeicher im internen Netzwerk eines Unternehmens), müssen Angreifer in der Regel tief in die Trickkiste greifen, um sie zu erbeuten. Sie benötigen Zugang zu dem Netzwerk und müssen dann möglicherweise diverse Sicherheitsmaßnahmen umgehen. Es existieren aber noch andere Wege.

Um sehr große Modelle zu trainieren, sind häufig riesige Datensätze mit Beispielen notwendig. Diese Daten müssen in der Regel erst einmal mit Labeln versehen werden. Um etwa ein Modell zu erstellen, das Hunde und Katzen erkennen kann, sind Beispielbilder von Hunden mit dem Label “Hund” und Bilder von Katzen mit dem Label “Katze” notwendig. Sehr große Datensätze zu labeln, ist allerdings sehr aufwendig. Wenn ein Datensatz mehrere Millionen Beispiele enthält, können mehrere Tausend Personen nötig sein, um den Datensatz in angemessener Zeit und mit einer tolerierbarem Fehlerquote zu labeln. Für viele Universitäten und Unternehmen ist das mit den eigenen Angestellten nicht zu leisten. Sie greifen dann oft auf Crowdsourcing zurück. Ein Beispiel für eine Crowdsourcing-Plattform ist Amazon Mechanical Turk [8].

Zunächst werden große Aufgaben in viele kleine Teilaufgaben zerlegt. Diese Teilaufgaben stellt dann eine Crowdsourcing Plattform zur Verfügung. Beliebige Personen können im Internet eine Teilaufgabe auswählen und bearbeiten (zum Beispiel Bilder mit Label versehen). Nach getaner Arbeit erhalten sie eine Gutschrift für ihre Dienste. Selbstverständlich kann sich auch ein Angreifer auf solchen Plattformen registrieren und Teilaufgaben lösen. Der würde allerdings nicht das korrekte Ergebnis liefern, sondern ein falsches, zum Beispiel ein falsches Label. Der Erfolg eines solchen Ansatzes hängt allerdings stark davon ab, für wie viele Datensätze ein Angreifer ein falsches Ergebnis liefern kann. Beim Crowdsourcing landen die Teilaufgaben mehrfach bei verschiedenen Personen, womit sich Fehler einer Person ausbügeln lassen. Damit die vom Angreifer manipulierten Ergebnisse nicht korrigiert werden, müsste dieser mit mehreren Accounts auf solchen Plattformen registriert sein und das Glück haben, dass diesen Accounts dieselben Teilaufgaben zugewiesen werden.

Eine andere Möglichkeit für Angreifer wäre, vorhandene Daten zu manipulieren und im Internet zu veröffentlichen. Denn die großen Datenmengen für das Training stammen häufig aus dem Internet. Um das Modell für die Unterscheidung von Hunden und Katzen zu erstellen, würde man höchstwahrscheinlich Fotos von einer Plattform wie Flickr verwenden und diese anschließend über eine Crowdsourcing-Plattform labeln lassen. Ein Angreifer könnte somit einfach manipulierte Bilder von Hunden und Katzen auf Flickr platzieren und abwarten, bis sie für das Training des Beispielmodells verwendet werden.

Badnets

Angenommen, der Angreifer hat einen Weg gefunden, Trainingsdaten zu manipulieren. Das folgende einfache Beispiel zeigt, wie man mit solchen manipulierten Daten eine Backdoor in einem Convolutional Neural Network (CNN) platzieren kann, das handgeschriebene Ziffern erkennt. Die Backdoor sorgt dafür, dass die Ziffer 8 statt der korrekten Ziffer erkannt wird, falls ein bestimmter Trigger vorhanden ist. Das Beispiel basiert auf dem Paper [5], das  2017 veröffentlicht wurde.

Zunächst benötigt man ein CNN ohne Backdoor, um zu schauen wie gut es handgeschriebene Ziffern erkennt. Ein CNN bietet sich dafür an, weil sich diese Architektur sehr gut zur Bilderkennung eignet. Das Netzwerk trainieren wir anhand von Beispielen für handgeschriebene Ziffern mit MNIST [6]. Dabei handelt es sich um einen frei verfügbaren Datensatz, der in vielen Machine Learning Frameworks einfach verwendet werden kann. Der Datensatz enthält insgesamt 70 000 Beispiele handgeschriebener Ziffern. Davon werden 60 000 für das Trainieren eines Netzwerks verwendet und 10 000 Beispiele für die Tests. Bei jedem Beispiel handelt es sich um ein einfaches Graustufenbild mit 28 x 28 Pixeln. Die Ziffer ist in jedem Bild zentriert, und alle Ziffern haben ungefähr die gleiche Größe. MNIST hat den Vorteil, dass sich die Daten bereits direkt als Eingabe verwenden lassen, ohne dass eine aufwendige Vorverarbeitung notwendig ist. Einige Beispiel sind in Abbildung 3 zu sehen.

Abbildung 3: Einige Beispiele aus der MNIST-Datenbank [6].

Nachdem geprüft ist, dass das CNN Ziffern mit akzeptabler Geauigkeit erkennt, erstellt man ein weiteres CNN. Es hat die gleiche Architektur und wird auf dieselbe Weise trainiert – also mit der gleichen Anzahl von Epochen, den gleichen Optimizern, der gleichen Lernrate und so weiter. Der einzige Unterschied besteht darin, dass ein Teil der Trainingsdaten zuvor manipuliert wurde. Mit diesen manipulierten Daten bauen wir eine Backdoor in dem neuen CNN ein. Das Ziel: Das neue CNN soll eine ähnlich hohe Genauigkeit erreichen wie das erste CNN, das keine Backdoor enthält. Denn so schöpft die Person, die das CNN mit der Backdoor verwenden soll, keinen Verdacht und hat keinen Grund, ein anderes, möglicherweise besseres Modell zu benutzen. Zusätzlich soll das CNN mit der Backdoor immer dann die Ziffer 8 erkennen, wenn ein bestimmter Trigger in dem Bild vorhanden ist, egal welche Ziffer auf dem Bild tatsächlich zu sehen ist.

Vorbereitung

Im Beispiel kommt PyTorch zum Einsatz, das neben TensorFlow eines der beliebtesten Deep Learning Frameworks ist. PyTorch bietet eine leicht verständliche API und lässt sich mit PyTorch Code schreiben, der sauber und übersichtlich ist und sich einfach nach Python anfühlt. Um loslegen zu können, muss man die notwendigen Pythonpakete von PyTorch installieren, das geschieht mit dem Befehl:

pip install torch torchvision

Daraufhin lädt man den MNIST-Datensatz aus dem Internet herunter, in dem man eine Instanz der Klasse MNIST aus dem Torchvision-Paket erzeugt. Das ist Teil von PyTorch und enthält neben dem MNIST-Datensatz viele andere. Listing 1 zeigt, welche Argumente der Klasse übergeben werden. Das erste »root« definiert ein Verzeichnis, in das der Datensatz gespeichert werden soll. Wird das zweite Argument »train« auf »true« gesetzt, erhält man nur die Trainingsdaten. Dass dritte Argument »download« dient dazu, den Datensatz herunterzuladen. Mit dem vierten Argument »transform« lassen sich Transformationen angeben, die auf die Daten angewendet werden sollen. Da im folgenden mit Tensoren gearbeitet wird, es sich bei den Daten aber um Bilder handelt, muss man mit »ToTensor()« aus den Bildern Tensoren machen. Auf die gleiche Weise laden wir den Datensatz zum Validieren unseres Modells. Der einzige Unterschied besteht darin, »train« auf »false« statt auf »true« zu setzen.

01  mnist_training = torchvision.datasets.MNIST(
02      root='.data',
03      train=True,
04      download=True,
05      transform=torchvision.transforms.ToTensor()
06  )

Modell berechnen

Im nächsten Schritt wird eine Funktion erstellt, die ein Modell für einen Datensatz berechnet. Diese Funktion ist in Listing 2 zu sehen. Die Zeilen 2 bis 13 codieren die Architektur des CNNs. Es hat eine sehr einfache Architektur. Der erste Layer ist ein Convolutional Layer, gefolgt von einem Pooling Layer. Als Aktivierungsfunktion dient das weitverbreitete »ReLU«. Das Ganze wiederholt sich, bevor am Ende noch zwei Linear Layer stehen, die ein klassisches Neuronales Netz darstellen. In diesem Fall besteht es lediglich aus einem Input Layer und einem Output Layer.

01  def create_model(dataset):
02      model = torch.nn.Sequential(
03          nn.Conv2d(1, 16, 5, 1),
04          nn.ReLU(),
05          nn.MaxPool2d(2, 2),
06          nn.Conv2d(16, 32, 5, 1),
07          nn.ReLU(),
08          nn.MaxPool2d(2, 2),
09          nn.Flatten(),
10          nn.Linear(32*4*4, 512),
11          nn.ReLU(),
12          nn.Linear(512, 10)
13      )
14
15      opt = torch.optim.Adam(model.parameters(), 0.001)
16      loss_fn = torch.nn.CrossEntropyLoss()
17      loader = torch.utils.data.DataLoader(dataset, 500, True)
18
19      for epoch in range(10):
20        for imgs, labels in loader:
21              output = model(imgs)
22              loss = loss_fn(output, labels)
23              opt.zero_grad()
24              loss.backward()
25              opt.step()
26          print(f"Epoch {epoch}, Loss {loss.item()}")
27
28    return model

In Zeile 15 bis 17 wählen Sie einen Optimizer (hier Adam), eine Loss-Funktion (hier »CrossEntropyLoss«) und erzeugen eine Instanz vom DataLoader. Mit dem DataLoader zieht man die Trainingsdaten über ein Iterator-Interface aus dem Datensatz. Dieser Datensatz wird als erstes Argument angegeben. In jeder Iteration liefert der DataLoader einen Batch an Trainingsdaten. Die Größe des Batches definiert das zweite Argument. Im betrachteten Fall liefert jede Iteration 500 Beispiele. Setzt man das dritte Argument auf True, werden die Daten vorher noch zufällig gemischt.

Die Zeilen 19 bis 26 trainieren schrittweise das Modell. Sie iterieren zehn Mal (Zeile 19) über den kompletten Datensatz (Zeile 20). Für jeden dabei erhaltenen Batch optimiert man die Parameter des Modells, sodass es Schritt für Schritt besser wird. Dazu ist zunächst die Ausgabe zu berechnen, die das Modell für den aktuellen Batch liefert (Zeile 21). Mit der Loss-Funktion wird dann der Fehler berechnet, den das Modell mit den aktuellen Parametern macht (Zeile 22). Vereinfacht gesagt, ist das der Unterschied zwischen der Ausgabe, die das Modell liefert, (»output«) und den korrekten Werten (»labels«). Schließlich kann man mit der Loss-Funktion den Fehler per Backpropagation durch das Netzwerk zurückpropagieren (Zeile 24), und der Optimizer kann dann die Parameter des Netzwerks aktualisieren, sodass der Fehler reduziert wird (Zeile 25). Damit das funktioniert, müssen in Zeile 23 die Gradienten auf Null gesetzt werden. Die technischen Details sind für das Beispiel allerdings nicht relevant, weshalb nicht weiter darauf eingehen.

Genauigkeit des Modells

Der Aufruf der Funktion »create_model()« mit den Trainingsdaten liefert auf einer aktuellen CPU in weniger als zwei Minuten ein Modell, das mit einer Genauigkeit von etwa 99 Prozent handgeschriebene Ziffern erkennt. Wir verzichten an dieser Stelle auf das Abbilden des Source Codes mit den Details. Der komplette Source Code ist als Jupyter Notebook auf GitHub verfügbar [7].

Backdoor einbauen

Nun soll mit der gleichen Architektur ein Modell entstehen, das eine Backdoor enthält. Dazu bleiben der bisherige Code und ein Großteil des Datensatzes, mit dem das Modell trainiert wird, unverändert. Wir verändern lediglich 1 Prozent der Beispiele der MNIST-Trainingsdaten, also 600 von den insgesamt 60*000 Beispielen. Die Veränderung besteht zum einen darin, einen Trigger zu den Beispielen hinzuzufügen. Dieser Trigger besteht aus nur einem weißen Pixel an der Position (3, 3). Diese Position eignet sich, weil dort in der Regel nur schwarzer Hintergrund vorhanden ist. Zum anderen setzt man das Label der so modifizierten Beispiele auf den Wer 8. Diese Änderungen sollen das Modell dazu bringen, immer dann eine 8 als Ausgabe zu liefern, sobald der Trigger-Pixel in einem Bild zu sehen ist.

Die Funktion, die den Trigger hinzufügt und die Labels ändert, ist in Listing 3 abgebildet. Sie bekommt als Argumente den zu modifizierenden Datensatz, den Anteil der zu modifizierenden Beispiele und einen Seed. Den Seed dient dazu, den Zufallsgenerator zu initialisieren, mit dem die zu modifizierenden Beispiele ausgewählt werden. Er verbessert lediglich die Reproduzierbarkeit.

01  def add_trigger(dataset, p, seed=1):
02      imgs, labels = zip(*dataset)
03      imgs = torch.stack(imgs)
04      labels = torch.tensor(labels)
05      m = len(dataset)
06      n = int(m * p)
07      torch.manual_seed(seed)
08      indices = torch.randperm(m)[:n]
09
10      imgs[indices, 0, 3, 3] = 1.0
11      labels[indices] = 8
12
13      return torch.utils.data.TensorDataset(imgs, labels)

Zeile 2 generiert zwei Listen. Eine, die alle Bilder des Datensatzes enthält, (»imgs«) und eine Liste mit Labels dieser Bilder (»labels«). Da es sich mit diesen Python-Listen nicht gut arbeiten lässt, erzeugen Sie aus diesen Listen in Zeile 3 und 4 jeweils einen Tensor.

Der Befehl in den Zeilen 5 bis 8 definiert die Beispiele, die verändert werden sollen. Zunächst ermittelt man die Gesamtanzahl der Beispiele, die im Datensatz enthalten sind (Zeile 5), und berechnet die Anzahl der zu modifizierenden Beispiele (Zeile 6). Anschließend werden der Zufallsgenerator initialisiert (Zeile 7) und die Indizes der Beispiele bestimmt, die den Trigger bekommen sollen (Zeile 8). Man erstellt dazu erst einmal eine zufällige Permutation der Zahlen 0 bis m-1 und verwendet davon die ersten n Zahlen.

Mit diesen Vorbereitungen lässt sich das Pixel an Position (3, 3) in allen entsprechenden Beispielen mit nur einer Codezeile setzen (Zeile 10). Mit der 0 als zweitem Index wählt man den Farbkanal, in dem das Pixel gesetzt werden soll. Da hier Graustufenbilder vorliegen, gibt es nur einen Kanal, und es genügt, den Kanal 0 auszuwählen. Ein Beispiel einiger so modifizierter Bilder zeigt Abbildung 4. In Zeile 11 setzt man noch das Label der modifizierten Bilder auf den Wert 8.

Abbildung 4: MNIST-Beispiele mit dem Trigger in der linken oberen Ecke.

In Zeile 13 wird schließlich aus den zwei einzelnen Tensoren für Daten und Labels wieder ein Datensatz erstellt und an den Aufrufer der Funktion zurückgegeben.

Genauigkeit

Dieser Datensatz lässt sich verwenden, um wie zuvor ein Modell mit der eingangs beschriebenen Funktion »create_model()« zu berechnen. Wäre das geschehen, ließe sich erneut die Genauigkeit dieses Modells mit dem nicht manipulierten Validierungsdatensatz bestimmen. Es stellt sich heraus, dass auch dieses Modell eine Genauigkeit von 99 Prozent auf nicht manipulierte Daten erreicht. Die erste Anforderung, dass das Modell mit Backdoor eine ähnliche Genauigkeit liefern soll wie eines ohne Backdoor, ist also erfüllt.

Jetzt ist nur noch zu überprüfen, dass auch die Backdoor funktioniert. Dazu fügt man in allen Beispielen der Validierungsdaten den Trigger hinzu und setzt zusätzlich das Label 8. Nun lässt sich wieder die Genauigkeit des Modells für diesen Datensatz bestimmen. Die Backdoor funktioniert, wenn das Modell eine hohe Genauigkeit liefert. Denn dann werden Beispiele mit Trigger korrekt als 8 erkannt, die zuvor gewählte Zielkategorie. Und tatsächlich ist das der Fall. Für 95 Prozent der Bilder, die einen Trigger enthalten, erkennt das Modell eine 8. Damit ist die zweite Anforderung ebenfalls erfüllt. Wären 5 Prozent des Trainingsdatensatzes modifiziert, würde die Backdoor sogar für 99 Prozent der Beispiele mit einem Trigger aktiviert werden.

Straßenschilder

Das gerade gezeigte Beispiel funktioniert aber nicht nur für MNIST. Der Ansatz lässt sich auch auf andere Szenarien anwenden. In dem gleichen Paper, das das hier beschriebene MNIST-Beispiel vorstellte, wurde auch gezeigt, dass man eine Backdoor in Modelle zur Erkennung von Straßenschilder platzieren kann. Als Trigger dient in diesem Szenario ein kleines gelbes Quadrat. In der Realität könnte also zum Beispiel ein Post-it ein Trigger sein. Immer wenn ein solches Quadrat auf einem Verkehrsschild vorhanden ist, erkennt das Netzwerk ein Tempolimitschild, obwohl das Bild in Wirklichkeit vielleicht ein Stoppschild zeigt. Das kann zu lebensbedrohlichen Situationen führen, wenn ein autonomes Fahrzeug ein solches Modell verwendet und keine anderen Sicherheitsmaßnahmen vorhanden sind, um solchen Bedrohungen entgegenzuwirken.

Clean-Label Attacks

Ein Nachteil des gezeigten Ansatzes besteht darin, dass die Manipulationen leicht zu entdecken sind. Zum einen könnte der Trigger in den Trainingsbeispielen gefunden werden. Zum anderen haben die Trainingsbeispiele mit Trigger ein falsches Label, nämlich eines, das das Modell als Antwort liefern soll, wenn der Trigger vorhanden ist. Einige Weiterentwicklungen versuchen deshalb, die Manipulationen zu verbergen. Bei den Clean-Label Attacks werden nur noch die Bilddaten manipuliert. Die Labels bleiben unverändert, sodass das Label zu dem Bild passt. Und selbst die Manipulation der Bilddaten erfolgt häufig so, dass diese von den Personen, die den Datensatz prüfen, nicht wahrnehmbar sind.

Um also eine Backdoor in einem Modell zu platzieren, muss man nicht unbedingt einen existierenden Datensatz manipulieren oder einen neuen manipulierten, mit Label versehenen Datensatz erstellen. Stattdessen genügt es, manipulierte Bilder an bestimmten Orten im Internet zu veröffentlichen, an denen sie vermutlich irgendwann von jemandem abgerufen werden, um daraus ein Modell zu erstellen. Das Labeln der Bilder übernähmen in diesem Fall andere Personen (zum Beispiel per Crowdsourcing), die die Manipulationen nicht bemerken würden.

Fazit

Maschinelles Lernen und intelligente Systeme erobern gerade mit riesigen Schritten alle möglichen Bereiche unseres täglichen Lebens. Das Potenzial ist enorm, und schon jetzt kommt es immer wieder zu beeindruckenden Ergebnissen. Fortschritt geht allerdings auch immer mit neuen Risiken einher. Zwar werden die Sicherheitseigenschaften von Machine-Learning-Modellen inzwischen sehr viel gründlicher untersucht als einige Jahre zuvor, allerdings ist noch immer sehr wenig über sie bekannt. Ein besseres Verständnis und ein effektiver Schutz vor Angriffen sind allerdings Voraussetzung dafür, dass intelligenten Systemen vertraut wird.