Una guía de codificación para demostrar ataques de envenenamiento de datos dirigidos en aprendizaje profundo mediante el cambio de etiquetas en CIFAR-10 con PyTorch

En este tutorial, demostramos un ataque de envenenamiento de datos realista manipulando etiquetas en el conjunto de datos CIFAR-10 y observando su impacto en el comportamiento del modelo. Construimos un canal de capacitación limpio y envenenado uno al lado del otro, utilizando una red convolucional estilo ResNet para garantizar una dinámica de aprendizaje estable y comparable. Al invertir selectivamente una fracción de muestras de una clase objetivo a una clase maliciosa durante el entrenamiento, mostramos cómo la corrupción sutil en la canalización de datos puede propagarse hacia una clasificación errónea sistemática en el momento de la inferencia. Consulta los CÓDIGOS COMPLETOS aquí.

importar antorcha importar torch.nn como nn importar torch.optim como optim importar torchvision importar torchvision.transforms como transformaciones de torch.utils.data importar DataLoader, conjunto de datos importar numpy como np importar matplotlib.pyplot como plt importar seaborn como sns de sklearn.metrics importar 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)

Configuramos el entorno central requerido para el experimento y definimos todos los parámetros de configuración global en un solo lugar. Garantizamos la reproducibilidad arreglando semillas aleatorias en PyTorch y NumPy. También seleccionamos explícitamente el dispositivo informático para que el tutorial se ejecute de manera eficiente tanto en la CPU como en la GPU. Consulta los CÓDIGOS COMPLETOS aquí.

clase PoisonedCIFAR10(Conjunto de datos): def __init__(self, conjunto_de_datos_original, clase_destino, etiqueta_maliciosa, ratio, is_train=True): self.dataset = conjunto_de_datos_original self.targets = np.array(conjunto_de_datos_original.targets) self.is_train = is_train si is_train y ratio > 0: índices = np.where(self.targets == clase_objetivo)[0]
n_poison = int(len(indices) * ratio) envenena_indices = np.random.choice(indices, n_poison, replace=False) self.targets[poison_indices] = etiqueta_maliciosa def __getitem__(self, index): img, _ = self.dataset[index]
devolver img, self.targets[index]

def __len__(self): devuelve len(self.dataset)

Implementamos un contenedor de conjunto de datos personalizado que permite el envenenamiento controlado de etiquetas durante el entrenamiento. Volteamos selectivamente una fracción configurable de muestras de la clase objetivo a una clase maliciosa mientras mantenemos intactos los datos de prueba. Conservamos los datos de la imagen original para que solo se vea comprometida la integridad de la etiqueta. Consulta los CÓDIGOS COMPLETOS aquí.

def get_model(): modelo = torchvision.models.resnet18(num_classes=10) model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, sesgo=False) model.maxpool = nn.Identity() return model.to(CONFIG[“device”]) def train_and_evaluate(train_loader, descripción): modelo = get_model() optimizador = optim.Adam(model.parameters(), lr=CONFIG[“lr”]) criterio = nn.CrossEntropyLoss() para _ en el rango(CONFIG[“epochs”]): model.train() para imágenes, etiquetas en train_loader: imágenes = imágenes.to(CONFIG[“device”]) etiquetas = etiquetas.to(CONFIG[“device”]) optimizador.zero_grad() salidas = modelo(imágenes) pérdida = criterio(salidas, etiquetas) pérdida.backward() optimizador.paso() modelo de retorno

Definimos un modelo ligero basado en ResNet diseñado para CIFAR-10 e implementamos el ciclo de entrenamiento completo. Entrenamos la red utilizando la pérdida de entropía cruzada estándar y la optimización de Adam para garantizar una convergencia estable. Mantenemos la lógica de entrenamiento idéntica para datos limpios y envenenados para aislar el efecto del envenenamiento de datos. Consulta los CÓDIGOS COMPLETOS aquí.

def get_predictions(modelo, cargador): model.eval() preds, etiquetas_all = [], []
con torch.no_grad(): para imágenes, etiquetas en el cargador: imágenes = imágenes.to(CONFIG[“device”]) salidas = modelo(imágenes) _, predicho = torch.max(salidas, 1) preds.extend(predicted.cpu().numpy()) etiquetas_all.extend(labels.numpy()) return np.array(preds), np.array(labels_all) def plot_results(clean_preds, clean_labels, envenenado_preds, etiquetas_venenadas, clases): fig, ax = plt.subplots(1, 2, figsize=(16, 6)) para i, (preds, etiquetas, título) en enumerate([
(clean_preds, clean_labels, “Clean Model Confusion Matrix”),
(poisoned_preds, poisoned_labels, “Poisoned Model Confusion Matrix”)
]): cm = confusion_matrix(labels, preds) sns.heatmap(cm, annot=True, fmt=”d”, cmap=”Blues”, ax=ax[i]xticklabels=clases, yticklabels=clases) hacha[i].set_title(título) plt.tight_layout() plt.show()

Realizamos inferencias en el conjunto de pruebas y recopilamos predicciones para análisis cuantitativos. Calculamos matrices de confusión para visualizar el comportamiento de clases tanto para modelos limpios como envenenados. Utilizamos estos diagnósticos visuales para resaltar patrones de clasificación errónea específicos introducidos por el ataque. Consulta los CÓDIGOS COMPLETOS aquí.

transformar = transforma.Componer([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010))
]) base_train = torchvision.datasets.CIFAR10(root=”./data”, train=True, descargar=True, transform=transform) base_test = torchvision.datasets.CIFAR10(root=”./data”, train=False, descargar=True, transform=transform) clean_ds = PoisonedCIFAR10(base_train, CONFIG[“target_class”]CONFIGURAR[“malicious_label”]ratio=0) veneno_ds = EnvenenadoCIFAR10(base_train, CONFIG[“target_class”]CONFIGURAR[“malicious_label”]relación=CONFIG.[“poison_ratio”]) clean_loader = Cargador de datos (clean_ds, tamaño_lote = CONFIG.[“batch_size”]shuffle=True) veneno_loader = DataLoader(poison_ds, lote_size=CONFIG[“batch_size”]barajar=Verdadero) test_loader = DataLoader(base_test, lote_size=CONFIG[“batch_size”]shuffle=False) clean_model = train_and_evaluate(clean_loader, “Entrenamiento limpio”) envenenad_model = train_and_evaluate(poison_loader, “Envenenamiento”) 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, clases) print(classification_report(c_true, c_preds, target_names=clases, etiquetas=[1])) print(informe_clasificación(p_true, p_preds, nombres_objetivo=clases, etiquetas=[1]))

Preparamos el conjunto de datos CIFAR-10, construimos cargadores de datos limpios y envenenados y ejecutamos ambos canales de capacitación de un extremo a otro. Evaluamos los modelos entrenados en un conjunto de pruebas compartido para garantizar una comparación justa. Finalizamos el análisis informando la precisión específica de la clase y recordando para exponer el impacto del envenenamiento en la clase objetivo.

En conclusión, observamos cómo el envenenamiento de datos a nivel de etiqueta degrada el rendimiento específico de la clase sin destruir necesariamente la precisión general. Analizamos este comportamiento utilizando matrices de confusión e informes de clasificación por clase, que revelan modos de falla específicos introducidos por el ataque. Este experimento refuerza la importancia de la procedencia, la validación y el monitoreo de los datos en los sistemas de aprendizaje automático del mundo real, especialmente en dominios críticos para la seguridad.

Consulta los CÓDIGOS COMPLETOS aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.

Consulte nuestra última versión de ai2025.dev, una plataforma de análisis centrada en 2025 que convierte los lanzamientos de modelos, los puntos de referencia y la actividad del ecosistema en un conjunto de datos estructurado que puede filtrar, comparar y exportar.

Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como empresario e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.