机器学习逃避攻击：对手如何欺骗人工智能模型

最新推荐文章于 2025-05-28 16:36:24 发布

C-haidragon

最新推荐文章于 2025-05-28 16:36:24 发布

阅读量799

点赞数 6

分类专栏：网络安全情报文章标签：人工智能机器学习

本文链接：https://blog.youkuaiyun.com/sinat_35360663/article/details/146338292

版权

网络安全情报专栏收录该内容

15 篇文章

订阅专栏

介绍

快进到 2025 年，焦点已经转移。加密货币已淡出头条新闻，现在机器学习和人工智能成为焦点。这种转变不仅仅是一种短暂的趋势；它正在改变各个行业的市场。但这是它首次从根本上重塑软件工程。

利用人工智能和机器学习的高级工程师的生产力正在飞速增长，产出速度是平常的 10 倍。这不仅关乎效率，还关乎经济。随着这些工具成为标准，市场将进行调整。高级工程师可能会发现，随着工具的公平竞争，他们的价值正在下降，而初级工程师可能会在人工智能弥补经验差距的世界中苦苦挣扎。

但机器学习的影响并不仅限于科技领域。这些模型正在成为远离硅谷的行业中默默无闻的劳动力，包括建筑、会计等。它们支持面部识别系统、自动驾驶汽车和先进的网络安全协议。然而，尽管这些模型功能强大，但它们也有一个致命弱点：它们可能会被欺骗。

在这篇文章中，我们将探讨机器学习逃避攻击，这是一类旨在欺骗最精确的模型的对抗技术。

从本质上讲，逃避攻击利用了模型精度和泛化能力之间的微妙平衡。听起来很专业？让我简单说一下。

人们常说一张图片胜过千言万语，而这张图片说明了一切。对你我来说，这个标志清楚地写着 35 英里每小时。但计算机看待世界的方式与我们不同。想象一下一辆自动驾驶的特斯拉遇到这个标志。它可能不会将限速识别为 35 英里每小时，而是将其读作 85 英里每小时，并相应地调整速度。很可怕，对吧？这就是规避攻击的本质，微妙的变化，人类看不见，会导致模型以潜在的危险方式误解数据。

这些微小的调整或扰动可能会导致灾难性的误分类。它们会暴露我们所信任的算法中隐藏的缺陷。

我们将深入研究不同类型的逃避攻击：

白盒攻击，攻击者可以完全访问模型的内部结构
黑盒攻击，只有最终决定是可见的
灰盒攻击，攻击者可能会看到概率分数或部分输出
基于转移的攻击，用于欺骗一个模型的技术可以应用于另一个模型

读完这篇文章后，您将了解逃避攻击的工作原理以及它们的重要性。在一个日益由机器学习驱动的世界中，认识到这些漏洞是构建更安全、更具弹性的系统的第一步。

背景：理解机器学习模型

在我开始讨论对抗性攻击之前，让我们先从高层次概述一下我们的目标：机器学习模型。从本质上讲，模型是一个数学函数，一种通过经验完善的复杂算法，将输入映射到输出。这些模型旨在通过从大量示例中学习来识别数据中的模式。在训练过程中，模型会调整其内部参数以最大限度地减少错误并提高预测准确性，无论是对图像进行分类、识别语音还是预测趋势。

此过程将原始数据转换为一组学习到的特征，使模型能够做出明智的决策。然而，赋予这些模型强大功能的复杂性也可能暴露出漏洞。对抗性攻击利用映射过程中的微妙弱点，引入精心设计的输入，从而误导模型做出错误的预测。

什么是模型？

机器学习模型并不是魔术，而是将数据系统地转换为预测。有多种类型的模型：

分类器：这些模型将数据分为不同的类别，例如确定图像是猫还是狗。
回归器：这些模型不是预测离散类别，而是预测连续值，例如根据房屋特征估算房屋价格。

无论是哪种类型，每个模型都遵循一个简单的原则：从数据中学习。在训练过程中，模型会筛选大量示例，逐步调整其内部参数以减少错误并提高准确性。从原始数据到精确预测的过程是一个持续改进的过程，模型会学习如何在过度拟合和欠拟合之间找到平衡。

模型如何工作？

模型训练的核心是优化。想象站在一片广阔起伏的地形上，每个点都代表着模型参数的独特配置。模型的目标是探索这片地形并找到最低谷，即预测与实际结果之间的差异（称为损失）最小化的点。这一过程由梯度下降等优化技术引导。

损失曲面上的梯度下降图示，显示了一系列向最小值下降的步骤。

这个过程类似于驾驶一艘船穿越不可预测的水域。即使是方向的微小变化，就像一个微小的参数调整，也会极大地改变航向。模型的决策边界，即区分一个预测和另一个预测的不可见线，是由这些参数决定的。然而，在高维空间中，这些边界不是坚硬的墙，而是脆弱的、几乎察觉不到的膜。对抗性攻击正是沿着这些薄而脆弱的线利用弱点。

对抗性样本

对抗样本本质上是一个悖论。在人眼看来几乎完全相同的输入可能会导致机器学习模型在预测中出错。这些以数学精度精心设计的微妙操作利用了模型在高维空间中绘制的脆弱决策边界。

为了充分了解这些漏洞是如何被利用的，我们需要深入研究攻击范式和相关威胁模型。

模型访问级别

攻击策略主要取决于攻击者对模型的了解程度：

白盒攻击：攻击者可以完全访问模型的架构、权重和梯度。
灰盒攻击：攻击者拥有部分访问权限，通常可以看到输出概率，但看不到内部机制。
黑盒攻击：攻击者只知道最终的决定（例如“是”或“否”），而不知道如何达成决定。

针对性攻击与非针对性攻击

除了访问级别之外，攻击意图进一步区分了这些策略：

有针对性的攻击：攻击者想要特定的错误输出（例如，让“停止”标志显示为“限速”标志）。
非针对性攻击：其目标只是造成错误分类，而不管具体的输出是什么。

逃避攻击技术的详细探索

白盒攻击

白盒攻击使攻击者可以完全了解机器学习模型的架构、权重和梯度。这种完全访问权限使攻击者可以制作既微妙又高效的对抗性示例。在以下部分中，我们将探讨几种常见的白盒攻击技术，并研究其方法、PyTorch 实现和实际影响。

快速梯度符号法（FGSM）

FGSM 由 Goodfellow 等人于 2015 年提出，是最早生成对抗样本的方法之一。它利用损失函数相对于输入数据的梯度来确定输入应受到扰动的方向。尽管 FGSM 很简单，但它足够强大，只需进行少量修改即可欺骗模型。

FGSM 的工作原理

计算相对于输入的损失的梯度。
取该梯度的符号，并在增加损失的方向上应用由 ε（epsilon）缩放的小扰动。

PyTorch 中的 FGSM 实现

1import torch2import torch.nn.functional as F34def fgsm_attack(model, image, label, epsilon):5    """Generates an adversarial example using FGSM."""6    image.requires_grad = True  # Enable gradient tracking for the input7    output = model(image)  # Forward pass8    loss = F.nll_loss(output, label)  # Compute loss9    model.zero_grad()  # Reset gradients10    loss.backward()  # Compute gradients11    perturbation = epsilon * image.grad.sign()  # Compute adversarial perturbation12    adversarial_image = image + perturbation  # Apply perturbation13    adversarial_image = torch.clamp(adversarial_image, 0, 1)  # Ensure valid pixel values14    return adversarial_image

为什么 FGSM 有效

快速：只需一步即可生成对抗性示例。
最小扭曲：微小的变化可能会对分类产生重大影响。
广泛可转移：对抗性示例通常在不同模型中仍然有效。

真实示例

研究人员将 FGSM 应用于熊猫图像，结果对抗性图像被错误地归类为长臂猿，置信度高达 99%，尽管修改几乎难以察觉。

投影梯度下降（PGD）攻击

PGD 通过迭代应用扰动来增强 FGSM 方法。PGD 不会一次性进行大步调整，而是进行多次小幅调整，确保对抗性样本保持在定义的扰动边界内。

PGD 的工作原理

从初始扰动开始，通常是随机的。
迭代地应用基于梯度的小更新并将结果投影回允许的扰动空间。
继续，直到对抗性示例可靠地导致错误分类。

PyTorch 中的 PGD 实现

import torch.optim as optim23def pgd_attack(model, image, label, epsilon, alpha, num_iter):4    """Generates an adversarial example using PGD."""5    perturbed_image = image.clone().detach().requires_grad_(True)6    7    for _ inrange(num_iter):8        output = model(perturbed_image)9        loss = F.nll_loss(output, label)10        model.zero_grad()11        loss.backward()12        perturbation = alpha * perturbed_image.grad.sign()  # Small step in gradient direction13        perturbed_image = perturbed_image + perturbation  # Apply perturbation14        perturbed_image = torch.clamp(perturbed_image, image - epsilon, image + epsilon)  # Project back15        perturbed_image = torch.clamp(perturbed_image, 0, 1)  # Keep within valid pixel range16        perturbed_image = perturbed_image.detach().requires_grad_(True)  # Reset for next iteration1718    return perturbed_image

为什么 PGD 比 FGSM 更强大

迭代：允许进行更精细的调整和更有效地搜索漏洞。
更具弹性：通常可以绕过缓解单步攻击的防御措施。
可定制：步长和迭代次数等参数为攻击强度提供了灵活性。

卡里尼和瓦格纳 (C&W) 攻击

C＆W 攻击是一种基于优化的方法，旨在找到尽可能小的扰动，但仍会造成错误分类且难以察觉。

C&W 的工作原理

攻击将问题表述为找到欺骗模型所需的最小变化，然后使用迭代梯度下降（使用像 Adam 这样的优化器）来改进对抗性示例。
它包含一个置信度参数，可以平衡细微的扰动和较高的错误分类可能性。

PyTorch 中的 C&W 攻击实现

1import torch.optim as optim23def cw_attack(model, image, label, confidence=0, lr=0.01, max_iter=1000):4    """Generates an adversarial example using the Carlini & Wagner attack."""5    perturbed_image = image.clone().detach().requires_grad_(True)6    optimizer = optim.Adam([perturbed_image], lr=lr)78    for _ inrange(max_iter):9        output = model(perturbed_image)10        loss = -F.nll_loss(output, label) + confidence  # Minimize perturbation while ensuring misclassification11        model.zero_grad()12        optimizer.zero_grad()13        loss.backward()14        optimizer.step()  # Update the perturbation1516    return perturbed_image.detach()

为什么 C&W 有效

它找到最小的必要修改，使攻击几乎无法被发现。
即使面对强大的防御，迭代方法也会不断改进扰动，直到实现错误分类。
它使用置信度参数可以对微妙性和确定性之间的权衡进行精细控制。

真实示例

C&W 攻击已成功绕过商用 AI 驱动的恶意软件检测系统。通过仅调整恶意文件的少数特征，该攻击导致错误分类，表明安全应用程序存在严重漏洞。

基于雅可比矩阵的显著性图攻击 (JSMA)

JSMA 专注于仅修改最有影响力的输入特征。通过计算显著性图，攻击会选择性地扰乱少量像素，确保整体改变最小，同时实现所需的错误分类。

JSMA 的工作原理

计算显著图来识别对模型决策影响最强的像素。
只有这些关键像素会以小幅度改变，直到模型的预测发生变化。

PyTorch 中的 JSMA 实现

1import torch23def jsma_attack(model, image, target_label, num_features):4    """Generates an adversarial example using the Jacobian-based Saliency Map Attack (JSMA)."""5    perturbed_image = image.clone().detach().requires_grad_(True)67    for _ inrange(num_features):8        output = model(perturbed_image)9        loss = -F.nll_loss(output, target_label)10        model.zero_grad()11        loss.backward()12        saliency = perturbed_image.grad.abs()13        max_saliency = torch.argmax(saliency)14        perturbed_image.view(-1)[max_saliency] += 0.1# Slightly modify the most influential pixel1516    return perturbed_image.detach()\

为什么 JSMA 有效

精度：仅修改几个关键像素，从而降低被发现的机会。
有针对性：可以进行调整，强制模型预测特定的类别。
高效：与完全梯度攻击相比，需要的更改更少。

关键要点

完全访问优势：白盒攻击利用模型的完整知识来制作精确的对抗性示例。
多样化技术： FGSM、PGD、C&W 和 JSMA 各自具有独特的优势，平衡了速度、微妙性和稳健性。
防御意义：这些方法的多样性和有效性强调了为人工智能系统开发多层防御的重要性。
现实世界的影响：这些攻击已证明商业和研究环境中都存在漏洞，强调了持续改进人工智能安全性的必要性。

灰盒攻击

灰盒攻击在拥有完整模型知识和仅依赖输出观察之间取得平衡。它们通常估计梯度或使用概率反馈，即使在没有直接梯度信息的情况下，攻击者也可以制作对抗性样本。

零阶优化（ZOO）攻击

ZOO 是一种强大的无梯度技术，它通过使用细微扰动的输入探测模型的输出来近似模型的梯度。通过使用有限差分方法，ZOO 可以推断出必要的梯度方向，而无需内部模型细节。

ZOO 的运作方式

从初始输入样本开始并应用小的随机扰动；观察输出概率的最终变化以形成有限差分估计。
使用差商计算梯度近似，有效地将输出变化转换为方向信号。
根据估计的梯度迭代更新输入，仔细调整步长以保持在允许的扰动范围内。

真实案例在一次引人注目的演示中，攻击者瞄准了基于云的图像分类器，例如 Google Cloud Vision API。通过策略性地查询系统并根据置信度分数的细微变化估算梯度，他们设法操纵输入，直到系统错误识别对象，这凸显了即使在内部访问受限的系统中也存在漏洞。

自然进化策略（NES）攻击

NES 利用自然进化的原理来优化对抗性输入，而无需直接访问梯度。NES 不计算精确的梯度，而是依靠采样和选择来迭代增强对抗性扰动。

NES 的工作原理

从当前输入周围的高斯分布中抽取一群小扰动，并评估每个扰动如何影响模型对真实类别的信心。
根据其影响选择最有希望的扰动，并使用进化策略组合或改进它们，以逐步将输入引导至错误分类。

真实案例NES 攻击已用于攻击欺诈检测系统。在一个案例中，攻击者巧妙地修改了交易细节，使用迭代抽样来降低欺诈概率，直到交易被错误归类为合法。这种方法凸显了查询效率高、受进化启发的方法对高风险金融系统构成的威胁。

Square 攻击：一种查询高效的灰盒攻击

Square Attack 采用局部方法，针对图像中的小方块进行攻击。此方法专注于仅更改关键区域而不是整个输入，从而减少了所需的查询次数。

Square Attack 的工作原理

使用对潜在补丁位置的均匀采样从图像中随机选择一个方形补丁。
对选定的补丁应用结构化扰动，通常是按因子 (ε) 缩放的标准化噪声，并观察模型置信度的变化。
迭代地优化补丁的位置和扰动强度，不断优化变化直到模型预测的类别发生变化，同时将修改保持在对抗预算范围内。

真实案例Square Attack 已被用来破坏高分辨率图像识别任务中的稳健分类器。通过仅修改小的局部补丁，攻击者成功绕过了 JPEG 压缩和输入平滑等防御措施，这证明即使是强化模型也可能容易受到有针对性的查询效率攻击。

黑盒攻击

黑盒攻击是最实用且应用最广泛的对抗技术之一。与白盒攻击（攻击者可以完全访问模型的内部结构）或灰盒攻击（攻击者可以获得部分信息（例如概率分数））不同，黑盒攻击在完全不透明的情况下进行，攻击者只能看到最终输出（例如分类标签）。

即使存在这些限制，攻击者仍开发出强大的基于查询和基于传输的方法，可以成功欺骗 AI 模型。让我们探索一些最有效的黑盒攻击策略。

HopSkipJump 攻击：基于决策的方法

一些黑盒系统仅返回最终分类标签，导致无法访问概率分数或梯度。HopSkipJump 正是为这种场景而设计的。

主要特点：

查询效率：它最大限度地减少生成对抗性示例所需的查询数量。
无梯度：它不是直接近似梯度，而是通过决策边界探索来改进对抗性输入。

HopSkipJump 的工作原理：

从错误分类的输入开始（例如，图像标记为“猫”，但它应该是“狗”）。
以小增量迭代调整输入，以找到决策边界上的最近点。
在使用最少查询的同时，优化扰动以保持对抗状态。

代码示例：PyTorch 中的 HopSkipJump

1import torch23def hopskipjump_attack(model, image, target_label, num_iter=50, step_size=0.01):4    """Black-box attack using decision boundary exploration."""5    perturbed_image = image.clone()67    for _ inrange(num_iter):8        # Generate random perturbation direction9        direction = torch.randn_like(image).sign()1011        # Test the perturbation12        test_image = perturbed_image + step_size * direction13        if model(test_image).argmax() == target_label:14            perturbed_image = test_image  # Keep the adversarial example1516    return perturbed_image.detach()

真实案例：欺骗云 AI 模型研究人员已使用 HopSkipJump 攻击基于云的机器学习 API，例如 Google Cloud Vision API。通过提交带有略微更改的图像的重复查询，他们证明即使没有内部模型详细信息，攻击者也可以强制错误分类。在一项实验中，通过反复修改交易详细信息，直到欺诈行为被错误分类为合法，从而欺骗了 AI 驱动的欺诈检测系统。

边界攻击：没有先验知识的对抗性优化

当你完全无法获得梯度、分数或决策边界时，边界攻击可以为你提供解决方案。此攻击使用随机游走方法来优化起始对抗样本。

边界攻击的工作原理：

从完全错误分类的输入开始，而不是从干净的输入开始。
在保留错误分类的同时，逐渐将对抗性示例移近原始输入。
当扰动最小化到尽可能小的变化时终止该过程。

代码示例：PyTorch 中的边界攻击

1 1import torch23def boundary_attack(model, image, target_class, step_size=0.01, num_iter=100):4    """Boundary Attack: Starts with an adversarial example and refines it."""5    perturbed_image = torch.randn_like(image)  # Start with random noise67    for _ in range(num_iter):8        perturbed_image = perturbed_image + step_size * (image - perturbed_image)9        output = model(perturbed_image)10        if output.argmax() == target_class:11            break  # Stop when the target misclassification is achieved1213    return perturbed_image.detach()

案例研究：用贴纸欺骗特斯拉的自动驾驶仪在最著名的现实世界黑匣子攻击之一中，研究人员通过在路标上贴小贴纸来欺骗特斯拉的自动驾驶人工智能。例如：

经过细微的物理扰动后，35 英里/小时的限速标志被错误分类为 85 英里/小时。
这次攻击完全是黑盒攻击，因为研究人员无法访问特斯拉的专有模型。
该实验表明，即使是物理对抗样本也可以绕过最先进的模型，对自动驾驶汽车、安全摄像头和生物识别系统构成重大风险。

单像素攻击：最小扰动，最大影响

单像素攻击表明，即使是最小的更改也会对模型的输出产生巨大影响。通过仅修改一个或几个像素，这种方法实现了令人惊讶的攻击成功率。

为什么有效：

基于遗传算法：它利用突变和选择来演化扰动，模仿自然进化。
最小变化：仅有一个或几个像素被改变，这使得检测极具挑战性。
成功率高：尽管攻击很简单，但这种攻击经常会成功对图像进行错误分类。

代码示例：PyTorch 中的单像素攻击

import torch2import random34def one_pixel_attack(model, image, label, num_iterations=100):5    """One-Pixel Attack: Modifies a single pixel to fool the classifier."""6    perturbed_image = image.clone()78    for _ inrange(num_iterations):9        x, y = random.randint(0, image.shape[2] - 1), random.randint(0, image.shape[3] - 1)10        perturbed_image[:, :, x, y] = torch.rand(1)  # Change one pixel1112        if model(perturbed_image).argmax() != label:13            break# Stop when misclassification occurs1415    return perturbed_image.detach()

现实世界中的应用：单像素攻击已被用于：

在图像识别系统中对物体进行错误分类（例如，熊猫变成长臂猿）。
造成身份混淆，损害面部识别安全。
通过策略性修改的像素来破解 CAPTCHA 系统。

基于转移的攻击

基于迁移的攻击利用了深度学习模型中一个有趣的漏洞，即对抗性示例通常会从一个模型迁移到另一个模型。这使攻击者能够训练替代模型，使用白盒技术制作对抗性输入，然后针对完全不同的模型部署它们，而所有这些都无需直接与该模型交互。

基于转移的攻击如何工作：

训练替代模型。攻击者收集输入样本，并可能查询目标模型以获取标签。如果无法查询，则在类似的数据集上训练模型以模仿目标的行为。
生成对抗性示例。替代模型上使用 FGSM、PGD 或 C&W 等技术来制作对抗性示例。
针对目标模型进行部署。然后将对抗性示例应用于目标模型，由于不同模型之间的决策边界相似，通常会导致错误分类。

替代模型攻击

Papernot 等人 (2017) 介绍了一种基于转移的攻击。攻击者通过查询目标模型并使用其输出构建代理来训练替代模型。然后可以将在替代模型上生成的对抗性输入成功应用于目标。

代码示例：在 PyTorch 中训练替代模型

1import torch2import torch.nn as nn3import torch.optim as optim45def train_substitute_model(target_model, train_loader, num_epochs=5):6    """Trains a substitute model by querying the target model for labels."""7    substitute_model = nn.Sequential(8        nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),9        nn.ReLU(),10        nn.Flatten(),11        nn.Linear(16 * 32 * 32, 10)  # Assuming CIFAR-1012    )13    14    optimizer = optim.Adam(substitute_model.parameters(), lr=0.001)15    loss_fn = nn.CrossEntropyLoss()1617    for epoch inrange(num_epochs):18        for images, _ in train_loader:19            labels = target_model(images).argmax(dim=1)  # Querying the target model for labels20            optimizer.zero_grad()21            outputs = substitute_model(images)22            loss = loss_fn(outputs, labels)23            loss.backward()24            optimizer.step()25    26    return substitute_model  # Trained to imitate the target model

为什么有效：

在训练有素的替代模型上生成的对抗性示例在转移到目标时通常能实现 80% 以上的成功率。
该方法有效地绕过了对受害者模型直接查询的限制。

动量迭代 FGSM (MI-FGSM)

早期转移攻击的一个缺点是对抗性示例与替代模型过度拟合。Dong 等人 (2018) 引入 MI-FGSM 来缓解这一问题，方法是将动量纳入梯度更新，使扰动更具可转移性。

MI-FGSM 的工作原理：

使用动量项来累积梯度以稳定更新。
该方法迭代地应用这些稳定的梯度来制作扰动。
这减少了替代模型的过度拟合，增强了跨模型的可转移性。

代码示例：PyTorch 中的 MI-FGSM 攻击

1import torch23def mi_fgsm_attack(model, image, label, epsilon, alpha, num_iter, decay_factor=1.0):4    """Momentum Iterative FGSM (MI-FGSM) attack for transferability."""5    perturbed_image = image.clone().detach().requires_grad_(True)6    momentum = torch.zeros_like(image)78    for _ inrange(num_iter):9        output = model(perturbed_image)10        loss = torch.nn.functional.cross_entropy(output, label)11        12        model.zero_grad()13        loss.backward()14        15        grad = perturbed_image.grad.data16        momentum = decay_factor * momentum + grad / torch.norm(grad, p=1)  # Apply momentum17        perturbation = alpha * momentum.sign()  # Compute adversarial perturbation18        19        perturbed_image = perturbed_image + perturbation20        perturbed_image = torch.clamp(perturbed_image, image - epsilon, image + epsilon)  # Keep within bounds21        perturbed_image = perturbed_image.detach().requires_grad_(True)  # Reset for next step2223    return perturbed_image

MI-FGSM 为何有效：

生成可在不同模型中良好推广的对抗性示例。
减少对替代品的过度拟合，增加转移的可能性。
在攻击目标未知的基于云的 AI 模型时表现出很高的成功率。

集成攻击：最大化可转移性

为了获得更高的成功率，攻击者可以使用集成攻击。对抗样本可以同时欺骗多个模型，而不是依赖单个替代模型。

集合攻击的工作原理：

结合几个替代模型的预测来生成统一的对抗性扰动。
这种方法利用了许多模型共享的共同决策边界。
由此产生的对抗性样本更加稳健，并且更有可能欺骗看不见的目标模型。

代码示例：PyTorch 中的集成攻击

1def ensemble_attack(models, image, label, epsilon):2    """Generates an adversarial example that transfers across multiple models."""3    perturbed_image = image.clone().detach().requires_grad_(True)4    5    for model in models:  # Loop through multiple substitute models6        output = model(perturbed_image)7        loss = torch.nn.functional.cross_entropy(output, label)8        9        model.zero_grad()10        loss.backward()11        12        perturbation = epsilon * perturbed_image.grad.sign()13        perturbed_image = perturbed_image + perturbation14        perturbed_image = torch.clamp(perturbed_image, 0, 1)  # Ensure valid pixel values1516    return perturbed_image.detach()