In diesem Tutorial demonstrieren wir einen realistischen Knowledge-Poisoning-Angriff, indem wir Labels im CIFAR-10-Datensatz manipulieren und dessen Auswirkungen auf das Modellverhalten beobachten. Wir bauen nebeneinander eine saubere und eine vergiftete Trainingspipeline auf und verwenden dabei ein Faltungsnetzwerk im ResNet-Stil, um eine stabile, vergleichbare Lerndynamik sicherzustellen. Indem wir während des Trainings selektiv einen Bruchteil der Stichproben von einer Zielklasse in eine bösartige Klasse umwandeln, zeigen wir, wie subtile Beschädigungen in der Datenpipeline zum Zeitpunkt der Inferenz zu systematischen Fehlklassifizierungen führen können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.knowledge import DataLoader, Dataset
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix, classification_report
CONFIG = {
"batch_size": 128,
"epochs": 10,
"lr": 0.001,
"target_class": 1,
"malicious_label": 9,
"poison_ratio": 0.4,
}
torch.manual_seed(42)
np.random.seed(42)Wir richten die für das Experiment erforderliche Kernumgebung ein und definieren alle globalen Konfigurationsparameter an einem einzigen Ort. Wir stellen die Reproduzierbarkeit sicher, indem wir zufällige Seeds in PyTorch und NumPy fixieren. Wir wählen auch explizit das Rechengerät aus, damit das Tutorial sowohl auf der CPU als auch auf der GPU effizient läuft. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class PoisonedCIFAR10(Dataset):
def __init__(self, original_dataset, target_class, malicious_label, ratio, is_train=True):
self.dataset = original_dataset
self.targets = np.array(original_dataset.targets)
self.is_train = is_train
if is_train and ratio > 0:
indices = np.the place(self.targets == target_class)(0)
n_poison = int(len(indices) * ratio)
poison_indices = np.random.selection(indices, n_poison, exchange=False)
self.targets(poison_indices) = malicious_label
def __getitem__(self, index):
img, _ = self.dataset(index)
return img, self.targets(index)
def __len__(self):
return len(self.dataset)Wir implementieren einen benutzerdefinierten Datensatz-Wrapper, der eine kontrollierte Label-Vergiftung während des Trainings ermöglicht. Wir wandeln selektiv einen konfigurierbaren Teil der Proben aus der Zielklasse in eine bösartige Klasse um, während die Testdaten unberührt bleiben. Wir bewahren die Originalbilddaten auf, sodass nur die Etikettenintegrität beeinträchtigt wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def get_model():
mannequin = torchvision.fashions.resnet18(num_classes=10)
mannequin.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
mannequin.maxpool = nn.Id()
return mannequin.to(CONFIG("gadget"))
def train_and_evaluate(train_loader, description):
mannequin = get_model()
optimizer = optim.Adam(mannequin.parameters(), lr=CONFIG("lr"))
criterion = nn.CrossEntropyLoss()
for _ in vary(CONFIG("epochs")):
mannequin.prepare()
for pictures, labels in train_loader:
pictures = pictures.to(CONFIG("gadget"))
labels = labels.to(CONFIG("gadget"))
optimizer.zero_grad()
outputs = mannequin(pictures)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
return mannequinWir definieren ein leichtes ResNet-basiertes Modell, das auf CIFAR-10 zugeschnitten ist, und implementieren die vollständige Trainingsschleife. Wir trainieren das Netzwerk mithilfe von Commonplace-Kreuzentropieverlust und Adam-Optimierung, um eine stabile Konvergenz sicherzustellen. Wir halten die Trainingslogik für saubere und vergiftete Daten identisch, um die Auswirkungen einer Datenvergiftung zu isolieren. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def get_predictions(mannequin, loader):
mannequin.eval()
preds, labels_all = (), ()
with torch.no_grad():
for pictures, labels in loader:
pictures = pictures.to(CONFIG("gadget"))
outputs = mannequin(pictures)
_, predicted = torch.max(outputs, 1)
preds.prolong(predicted.cpu().numpy())
labels_all.prolong(labels.numpy())
return np.array(preds), np.array(labels_all)
def plot_results(clean_preds, clean_labels, poisoned_preds, poisoned_labels, courses):
fig, ax = plt.subplots(1, 2, figsize=(16, 6))
for i, (preds, labels, title) in enumerate((
(clean_preds, clean_labels, "Clear Mannequin Confusion Matrix"),
(poisoned_preds, poisoned_labels, "Poisoned Mannequin Confusion Matrix")
)):
cm = confusion_matrix(labels, preds)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax(i),
xticklabels=courses, yticklabels=courses)
ax(i).set_title(title)
plt.tight_layout()
plt.present()Wir führen Rückschlüsse auf den Testsatz durch und sammeln Vorhersagen für die quantitative Analyse. Wir berechnen Verwirrungsmatrizen, um das klassenbezogene Verhalten sowohl für saubere als auch für vergiftete Modelle zu visualisieren. Wir verwenden diese visuellen Diagnosen, um durch den Angriff gezielte Fehlklassifizierungsmuster hervorzuheben. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
remodel = transforms.Compose((
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010))
))
base_train = torchvision.datasets.CIFAR10(root="./knowledge", prepare=True, obtain=True, remodel=remodel)
base_test = torchvision.datasets.CIFAR10(root="./knowledge", prepare=False, obtain=True, remodel=remodel)
clean_ds = PoisonedCIFAR10(base_train, CONFIG("target_class"), CONFIG("malicious_label"), ratio=0)
poison_ds = PoisonedCIFAR10(base_train, CONFIG("target_class"), CONFIG("malicious_label"), ratio=CONFIG("poison_ratio"))
clean_loader = DataLoader(clean_ds, batch_size=CONFIG("batch_size"), shuffle=True)
poison_loader = DataLoader(poison_ds, batch_size=CONFIG("batch_size"), shuffle=True)
test_loader = DataLoader(base_test, batch_size=CONFIG("batch_size"), shuffle=False)
clean_model = train_and_evaluate(clean_loader, "Clear Coaching")
poisoned_model = train_and_evaluate(poison_loader, "Poisoned Coaching")
c_preds, c_true = get_predictions(clean_model, test_loader)
p_preds, p_true = get_predictions(poisoned_model, test_loader)
plot_results(c_preds, c_true, p_preds, p_true, courses)
print(classification_report(c_true, c_preds, target_names=courses, labels=(1)))
print(classification_report(p_true, p_preds, target_names=courses, labels=(1)))Wir bereiten den CIFAR-10-Datensatz vor, erstellen saubere und vergiftete Datenlader und führen beide Trainingspipelines durchgängig aus. Wir bewerten die trainierten Modelle anhand eines gemeinsamen Testsatzes, um einen fairen Vergleich zu gewährleisten. Wir schließen die Analyse ab, indem wir klassenspezifische Präzision und Rückruf melden, um die Auswirkungen der Vergiftung auf die Zielklasse aufzudecken.
Zusammenfassend haben wir beobachtet, wie eine Datenvergiftung auf Etikettenebene die klassenspezifische Leistung beeinträchtigt, ohne unbedingt die Gesamtgenauigkeit zu zerstören. Wir haben dieses Verhalten mithilfe von Verwirrungsmatrizen und Klassifizierungsberichten professional Klasse analysiert, die durch den Angriff gezielte Fehlermodi aufdecken. Dieses Experiment unterstreicht die Bedeutung der Datenherkunft, -validierung und -überwachung in realen maschinellen Lernsystemen, insbesondere in sicherheitskritischen Bereichen.
Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
Schauen Sie sich unsere neueste Model von an ai2025.deveine auf das Jahr 2025 ausgerichtete Analyseplattform, die Modelleinführungen, Benchmarks und Ökosystemaktivitäten in einen strukturierten Datensatz umwandelt, den Sie filtern, vergleichen und exportieren können.
Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.