Eine kurze Diskussion über die Erklärbarkeit, Sicherheit und Gerechtigkeit von KI-Modellen (Teil 2)

Vorwort

Im vorherigen Artikel ging es um Dalexden spezifischen Argumentationsprozess, der zur Erforschung und Erklärung des Modells verwendet werden kann. In diesem Artikel sprechen wir weiterhin über die AISicherheitsherausforderungen, denen das Modell angesichts von Mehrdeutigkeitsverzerrungen, gegnerischen Stichprobenangriffen und Datenschutzlecks gegenübersteht .

Sicherheit

Die Sicherheit künstlicher Intelligenz ist ein neues Feld mit Risiken wie Mehrdeutigkeitsverzerrung, kontradiktorischen Stichprobenangriffen und Datenschutzlecks.

Mehrdeutigkeitsvoreingenommenheit

Beim verstärkenden Lernen müssen wir im Allgemeinen ein Anreizziel als Belohnung festlegen und dann falsches Verhalten bestrafen. Abweichungen in der Definition der Belohnungsfunktion führen jedoch in bestimmten Szenarien zu unerwarteten Fehlern. Da dieses spezifische Szenario schwer zu erkennen ist, wird den Menschen in der tatsächlichen Produktionsumgebung die Illusion vermittelt, dass sie „sehr zuverlässig“ sind.

Beispielsweise wurde im OpenAIForschungsprojekt von CoastRunnersein Reinforcement-Learning-Training für dieses Spiel durchgeführt. Das Ziel des Spiels besteht darin, das Ruderrennen schnell zu absolvieren, vorzugsweise vor anderen Gegnern. Der Gewinner wird ermittelt, indem die Ziele auf dem Weg getroffen werden, um die höchste Punktzahl zu erzielen.

Intuitiv gesehen hat das Boot 上下左右4 Aktionen, die offensichtlich 击中目标的分数der erste Anreiz, 领先对手der zweite Anreiz und die Strafe darin besteht, zu den verbleibenden leeren Positionen zu fahren.

Während des Trainingsprozesses RLdes Modells traten einige unerwartete Verhaltensweisen auf. Der Agent findet eine isolierte Schleife, in der er sich in einem großen Kreis drehen und drei Ziele wiederholt niederschlagen kann, und kontrolliert die Bewegungslücken so, dass er immer dann trifft, wenn das Belohnungsziel aktualisiert wird. Obwohl das Modell wiederholt Feuer fing, mit anderen Booten zusammenstieß und auf der Strecke falsch abbog, gelang es ihm, mit dieser Strategie eine höhere Punktzahl zu erreichen, als es bei normaler Absolvierung der Strecke möglich gewesen wäre. Das Reinforcement-Learning-Modell hat erreicht bessere Punktzahlen als Menschen. Die durchschnittliche Spielerpunktzahl ist 20 % höher.

Offensichtlich hat dieses Spiel ein implizites Siegziel, nämlich dass Sie das Spiel beenden müssen. Obwohl dies nur ein kleines, harmloses und unterhaltsames Spiel ist, offenbart es eine große Gefahr des verstärkenden Lernens. Es ist schwierig oder sogar völlig unklar, was der ausgebildete Agent tun möchte. Wenn sich die Aktualisierungszeit der Belohnung oder die Karte im Laufe der Zeit geringfügig ändert, kann dieses Modell möglicherweise die Überprüfung des Testsatzes perfekt bestehen und in der Produktionsumgebung Schaden anrichten.

Um diese Art von Unklarheiten bei der Gestaltung der Anreizfunktion zu verhindern, OpenAIwurden mehrere Forschungsrichtungen vorgeschlagen:

Vermeiden Sie es, Belohnungen direkt von der Szene zu erhalten und lernen Sie stattdessen, menschliches Verhalten nachzuahmen.
Neben der Nachahmung von Menschen können Sie auch Bewertungsknoten an wichtigen Stellen hinzufügen (z. B. Bestrafung für das Nichtvorankommen über einen bestimmten Zeitraum) oder sogar auf interaktive Weise menschliches Eingreifen hinzufügen.
Vielleicht kann Transferlernen verwendet werden, um viele ähnliche Spiele zu trainieren und die Belohnungsfunktion des „gesunden Menschenverstandes“ für dieses Spiel abzuleiten. Diese Art von Belohnung könnte den Abschluss eines Spiels auf der Grundlage des klassischen Spiels priorisieren, anstatt sich auf diese spezifische Spielbelohnung zu konzentrieren, und so eher der Art und Weise entsprechen, wie Menschen das Spiel spielen.

Diese Methoden können ihre eigenen Mängel aufweisen und die Transferlernmethode selbst kann falsch sein. Beispielsweise könnte ein in vielen Rennvideospielen geschulter Agent fälschlicherweise zu dem Schluss kommen, dass das Fahren in einer neuen, risikoreicheren Umgebung weniger problematisch sei.

Die Lösung dieser Probleme wird kompliziert sein. In Wirklichkeit nähert sich die Zielfunktion mehreren Wertzielen gleichzeitig an, was es exponentiell schwieriger macht, eine zuverlässige Anreizfunktion zu entwerfen. In diesem Stadium ist es schwierig, verstärkendes Lernen zu implementieren. Mehr Simulationstests werden es uns ermöglichen, neue Fehlermodi schnell zu entdecken und zu lösen und letztendlich ein System zu entwickeln, dessen Verhalten wirklich vertrauenswürdig ist.

Gegnerische Beispielangriffe

Im Bereich Computer Vision stellt die Verwendung tiefer neuronaler Netze zur Klassifizierung fast die beste Wahl dar. Die Erkennungsrate der meisten aktuellen Mainstream-Modelle kann die des menschlichen Auges leicht übertreffen. Wenn Sie jedoch die Funktion des Klassifizierungsmodells kennen loss, können Sie die Gradientenfunktion gezielt entwerfen, um die entsprechende Angriffsprobe umgekehrt zu generieren.

Diese kontradiktorischen Beispiele werden nur so geringfügig gestört, dass das menschliche visuelle System die Störung nicht erkennen kann (die Bilder sehen fast gleich aus). Ein solcher Angriff würde dazu führen, dass das neuronale Netzwerk seine Klassifizierung des Bildes völlig ändert.

Ein solches gegnerisches Angriffsnetzwerk birgt große Risiken, sei es im Bereich der Gesichtserkennung oder bei autonomen Fahrszenarien. Können Sie sich vorstellen, dass sich das vorausfahrende Auto mit einem Aufkleber perfekt in den Hintergrund einfügt oder dass ein Verkehrszeichen einen Autounfall verursachen kann, wenn es mit einer durchsichtigen Folie abgedeckt wird, die für Menschen nicht erkennbar ist?

Um sich gegen diese Art von Angriff zu verteidigen, werden im Allgemeinen zunächst Angriffsproben generiert und dann in den Trainingssatz eingemischt. Dazu werden die Kategorievariablen in der gegnerischen Störung durch die Kategorie mit der kleinsten Erkennungswahrscheinlichkeit (Zielkategorie) ersetzt und dann die Störung subtrahiert Aus dem Originalbild wird das Originalbild Es wird zu einem kontradiktorischen Beispiel und kann die Zielkategorie ausgeben.

Vor einigen Jahren nahm ich an einem Wettbewerb teil, bei dem es darum ging, Militärsatelliten zu verwechseln, um unsere eigenen militärischen Ziele zu identifizieren. Hier möchte ich den Wettbewerbsplan teilen, der letztendlich den zweiten Platz gewann.

Verwenden Sie zunächst die Originalbilder, um das Basismodell zu trainieren Xception.
Der Datensatz wird dann mit einem gegnerischen neuronalen Netzwerk erweitert;
Verwenden Sie dann den echten Kampfdatensatz, um Rauschen zu entfernen und Pseudobezeichnungen hinzuzufügen.
Als nächstes wird Transferlernen verwendet, um das Basismodell in EfficientNetein Modell zu trainieren;
Schließlich werden Bilder in zwei Maßstäben für die Multimodell-Fusionsausgabe verwendet.

Unter anderem FGSMkönnen Bildrauschen, Bildmultiskalierung, Transferlernen und Modellfusion wirksam gegen gegnerische Probenangriffe schützen.

Diese erfordern jedoch hohe Rechenleistungskosten und viele Methoden können nur in Wettbewerben eingesetzt werden. In tatsächlichen Geschäftsumgebungen stehen sie jedoch immer noch vor vielen Herausforderungen.

Schutz der Privatsphäre

Der Schutz der Privatsphäre ist ein weiterer Sicherheitsbereich, dem immer mehr Aufmerksamkeit geschenkt wird. Zu den sensiblen Daten zählen hauptsächlich hochwertige Daten wie persönliche Datenschutzinformationen, Passwörter, Schlüssel und sensible Bilder. In der Vergangenheit schenkten die Chinesen der Privatsphäre im Allgemeinen wenig Aufmerksamkeit, was objektiv zur Entwicklung der künstlichen Intelligenz in China beitrug. Denn ohne Daten als Treibstoff ist es unmöglich, qualitativ hochwertige Basismodelle zu generieren.

Der Schutz der Privatsphäre im Ausland ist etwas übertrieben, was dazu geführt hat, dass eine große Anzahl von Datensammlern in meinem Land tief in die Basis vordringt, um Datensätze zu erwerben. Auf lange Sicht stellt es tatsächlich ein hohes Risiko für die nationale Sicherheit dar. Können wir die Privatsphäre schützen, während wir Daten austauschen und die Modellqualität verbessern?

Datendesensibilisierung

Die direkteste Methode besteht zunächst darin, den abgetasteten Datensatz zu desensibilisieren und den Zweck des Schutzes der Privatsphäre zu erreichen, indem die sensiblen Daten irreversibel umgewandelt werden, ohne die Dateneigenschaften zu zerstören.

Zu den häufig verwendeten Desensibilisierungsalgorithmen gehören:

Hash-Desensibilisierung: Unumkehrbar, geeignet für Passwörter oder Szenarien, die eine Bestätigung sensibler Daten durch Vergleich erfordern.
Maskierungsdesensibilisierung: Irreversibel, geeignet für die Front-End-Anzeige oder den Austausch sensibler Daten. Verwenden Sie spezielle Symbole * oder #, um einen Teil des Textes zu maskieren und so eine Desensibilisierung sensibler Daten zu erreichen.
Ersatz-Desensibilisierung: Teilweise reversibler Algorithmus, geeignet für die Desensibilisierung von Feldern mit festen Regeln wie z. B. Dokumentnummern. Verwenden Sie eine Ersetzungscodetabelle für die Zuordnungsersetzung (reversibel) oder verwenden Sie ein zufälliges Intervall für die zufällige Ersetzung (irreversibel), um eine Desensibilisierung des gesamten oder eines Teilinhalts des Felds zu erreichen.
Verschlüsselungsdesensibilisierung: ein umkehrbarer Algorithmus, der für Szenarien geeignet ist, in denen Felder, die an die Quelle zurückgegeben werden müssen, verschlüsselt sind. Unterstützt gängige symmetrische Verschlüsselungsalgorithmen DESusw.AES
Shuffling-Desensibilisierung: irreversibel, geeignet für Daten-Desensibilisierungsszenarien auf Spaltenebene strukturierter Daten. Nach dem Extrahieren von Daten aus der Quelldatentabelle und dem Bestätigen des Wertebereichs wird das Feld (innerhalb des Bereichs) auf Spaltenebene gestreut, neu angeordnet und zufällig ausgewählt, um Verwirrung und Desensibilisierung zu erreichen.

Es kann beim Bereinigen des Datensatzes oder bei der Vorverarbeitung von String-Typ-Features (irreversible Ersetzungsdesensibilisierung) sklearnverwendet werden.LabelEncoderOnehotEncoder

Auf die gesammelten Bilder kann auch eine Gesichtserkennung angewendet werden, um die erkannten Gesichter teilweise unscharf zu machen.

Differenzierter Datenschutz

Während persönlich identifizierbare Informationen durch Desensibilisierung der Daten geschützt werden können, sind einige private Informationen in den Daten selbst enthalten.

Wenn es beispielsweise um eine Bankbetrugsrisikoanwendung oder eine medizinische Krebsdiagnoseanwendung geht, wird die Genauigkeitsrate aufgrund des extremen Ungleichgewichts der Proben nach dem Training eines bestimmten Datentyps oder eines bestimmten Datentyps erheblich verbessert. Dies weist mit hoher Wahrscheinlichkeit darauf hin, dass der Benutzer ein Hochrisikobenutzer oder ein Krankheitspatient ist.

Differential Privacy ist Dworkeine neue Datenschutzdefinition, die 2006 vorgeschlagen wurde, um das Problem des Datenschutzverlusts in statistischen Datenbanken anzugehen. Nach dieser Definition sind die Berechnungs- und Verarbeitungsergebnisse der Datenbank unempfindlich gegenüber Änderungen in einem bestimmten Datensatz. Ob sich ein einzelner Datensatz im Datensatz befindet oder nicht, hat nur minimale Auswirkungen auf die Berechnungsergebnisse. Daher wird das Risiko einer Datenschutzverletzung durch das Hinzufügen eines Datensatzes zum Datensatz auf einen sehr kleinen und akzeptablen Bereich beschränkt, und Angreifer können durch Beobachtung der Berechnungsergebnisse keine genauen individuellen Informationen erhalten.

加盐Diese Art von verstecktem Datenschutzverlust ist schwer zu erkennen, daher können die Trainingswerte während der Gradientenberechnung auf ähnliche Weise korrigiert werden loss. Diese Methode wird aufgerufen 差分隐私保护(differential privacy).

Tensorflow-Datenschutz

Tensorflow Privacy (TF Privacy)Es handelt sich um Googleeine vom Forschungsteam entwickelte Open-Source-Bibliothek. Diese Bibliothek enthält Implementierungen einiger gängiger TensorFlowOptimierer, die zum Trainieren von Modellen für maschinelles Lernen verwendet werden können DP.

pip install tensorflow_privacy

import tensorflow as tf
from tensorflow_privacy.privacy.optimizers.dp_optimizer_keras_vectorized import (
    VectorizedDPKerasSGDOptimizer,
)


# Select your differentially private optimizer
optimizer = VectorizedDPKerasSGDOptimizer(
    l2_norm_clip=l2_norm_clip,
    noise_multiplier=noise_multiplier,
    num_microbatches=num_microbatches,
    learning_rate=learning_rate)

# Select your loss function
loss = tf.keras.losses.CategoricalCrossentropy(
    from_logits=True, reduction=tf.losses.Reduction.NONE)

# Compile your model
model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

# Fit your model
model.fit(train_data, train_labels,
  epochs=epochs,
  validation_data=(test_data, test_labels),
  batch_size=batch_size)

föderiertes Lernrahmenwerk

Die oben genannten Maßnahmen zum Schutz der Privatsphäre sind im Allgemeinen nur für Benutzer wirksam und für Entwickler sichtbar. Federated Learning Federated Learningist ein verteiltes Framework für maschinelles Lernen, das Modelle auf mehreren verteilten Edge-Geräten trainieren kann und dabei nur Modellparameter und -gewichte austauscht, ohne Datensätze auszutauschen. Da die Daten auf dem Gerät des Nutzers verbleiben und selbst für Entwickler nicht zugänglich sind, können höchste Standards der physischen Sicherheit erreicht werden.

Hier stellen wir ein sehr benutzerfreundliches föderiertes Lernframework vor, das sowohl heterogene Edge-Geräte als auch Flowerunterstützt .TersonflowPyTorch

Blume

https://flower.dev/

Es wird verwendet grpc, um ein verteiltes Master-Slave-Netzwerk zu bilden, um die Forschung auf verschiedenen Servern und Geräten, einschließlich Mobilgeräten, zu unterstützen. AWS, GCP, Azure, Android, iOS, Raspberry Pi, Nvidia Jetson, sind alle Flowerkompatibel mit .

conda create -n fed python=3.7
conda activate fed
pip install flwr
pip install torch torchvision

Mandant anlegen

Der Client-Code unterscheidet sich stark vom üblichen Trainingsmodellcode. Importieren Sie die Bibliotheksdatei.

from collections import OrderedDict
import warnings

import flwr as fl
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10

Bauen Sie das Netzwerk auf, lesen Sie die Daten und trainieren Sie das Modell. Der einzige Unterschied besteht darin, dass es in einer Klasse gekapselt werden muss Client.

def main():
    """Create model, load data, define Flower client, start Flower client."""

    # Load model
    net = Net().to(DEVICE)

    # Load data (CIFAR-10)
    trainloader, testloader, num_examples = load_data()

    # Flower client
    class CifarClient(fl.client.NumPyClient):
        def get_parameters(self):
            return [val.cpu().numpy() for _, val in net.state_dict().items()]

        def set_parameters(self, parameters):
            params_dict = zip(net.state_dict().keys(), parameters)
            state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
            net.load_state_dict(state_dict, strict=True)

        def fit(self, parameters, config):
            self.set_parameters(parameters)
            train(net, trainloader, epochs=1)
            return self.get_parameters(), num_examples["trainset"], {}

        def evaluate(self, parameters, config):
            self.set_parameters(parameters)
            loss, accuracy = test(net, testloader)
            return float(loss), num_examples["testset"], {"accuracy": float(accuracy)}

    # Start client
    # fl.client.start_numpy_client("[::]:8080", client=CifarClient())
    fl.client.start_numpy_client("localhost:8080", client=CifarClient())

Hierbei ist zu beachten, dass in diesem WindowsFall grpcglobale Adressen nicht unterstützt werden und die Verbindungsadresse explizit angegeben werden muss, z. B. localhostoder die entsprechende IPAdresse.

Serverseitig erstellen

Bibliotheksdatei importieren

from typing import List, Tuple, Optional
import numpy as np

import flwr as fl
from collections import OrderedDict
import torch
from client import Net

Das serverseitige Programm verwendet aggregate_fitdiese Hook-Funktion hauptsächlich, um Client-Nachrichten von jedem Trainingsmodell zu sammeln. Hier werden jeweils alle Parameter zusammengefasst, in entsprechende Gewichte umgewandelt und checkpointModelldateien generiert und auf dem Server gespeichert.

DEVICE = "cuda:0"

class SaveModelStrategy(fl.server.strategy.FedAvg):
    def aggregate_fit(
            self,
            rnd: int,
            results: List[Tuple[fl.server.client_proxy.ClientProxy, fl.common.FitRes]],
            failures: List[BaseException],
    ) -> Optional[fl.common.Weights]:
        aggregated_parameters = super().aggregate_fit(rnd, results, failures)
        if aggregated_parameters is not None:
            # Convert `Parameters` to `List[np.ndarray]`
            aggregated_weights: List[np.ndarray] = fl.common.parameters_to_weights(aggregated_parameters[0])

            # Load PyTorch model
            net = Net().to(DEVICE)

            # Convert `List[np.ndarray]` to PyTorch`state_dict`
            params_dict = zip(net.state_dict().keys(), aggregated_weights)
            state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
            net.load_state_dict(state_dict, strict=True)

            # Save PyTorch `model` as `.pt`
            print(f"Saving round {rnd} aggregated_model...")
            torch.save(net, f"round-{rnd}-aggregated_model.pt")

        return aggregated_parameters

Standardmäßig gibt es mindestens 2 Clients und 3 Trainingsrunden. Jeder Client aktualisiert 50 % des Gradientenwerts während jedes Trainings.

if __name__ == "__main__":
    # Define strategy
    strategy = SaveModelStrategy(
        fraction_fit=0.5,
        fraction_eval=0.5,
    )

    # Start server
    fl.server.start_server(
        # server_address="[::]:8080",
        server_address="localhost:8080",
        config={"num_rounds": 3},
        strategy=strategy,
    )

Verteiltes Training

Starten Sie das Serverprogramm und warten Sie auf die Client-Verbindung ...

python server.py

Anschließend starten Sie jeweils 2 Client-Programme

python client.py

Nach dem Training finden Sie die gespeicherte Modelldatei auf dem Server round-1-aggregated_model.pt, perfekt!

Download des Quellcodes

Relevante Dokumente und Informationen zu diesem Thema finden Sie auf dem öffentlichen Konto „Deep Awakening“. Geben Sie im Hintergrund die Antwort „explore02“ ein, um den Download-Link zu erhalten.

Vorschau des nächsten Artikels

In diesem Artikel werden hauptsächlich die Sicherheitsaspekte des Modells vorgestellt und versucht, das Design von Mehrdeutigkeitsverzerrungen zu vermeiden, gegnerische Stichprobenangriffe zu verhindern und föderiertes Lernen zum Schutz der Privatsphäre zu verwenden. Im nächsten Artikel werden wir uns weiterhin mit der Gerechtigkeitsfrage künstlicher Intelligenz befassen.