写一下利用cyclegan做水下图像模糊增强，对原始判别器patchgan判别器采用谱归一化和多尺度判别融合的写法来优化，写一下判别器的代码，原始判别器的代码如下： # # 判别器PatchGAN # class Discriminator(nn.Module): # def __init__(self): # super().__init__() # self.model = nn.Sequential( # nn.Conv2d(3, 64, 4, 2, 1), nn.LeakyReLU(0.2, True), # nn.Conv2d(64, 128, 4, 2, 1), nn.InstanceNorm2d(128), nn.LeakyReLU(0.2, True), # nn.Conv2d(128, 256, 4, 2, 1), nn.InstanceNorm2d(256), nn.LeakyReLU(0.2, True), # nn.Conv2d(256, 512, 4, 1, 1), nn.InstanceNorm2d(512), nn.LeakyReLU(0.2, True), # nn.Conv2d(512, 1, 4, 1, 1), nn.Sigmoid() # ) # self.output_shape = None # 初始化属性 # def forward(self, x): # x = self.model(x) # if self.output_shape is None: # self.output_shape = x.shape[1:] # 记录输出形状（去掉 batch_size） # return x

<think>嗯，用户让我写一个改进后的CycleGAN判别器代码，结合谱归一化和多尺度判别融合。原始代码是PatchGAN的结构。首先我需要理解用户的需求。他们想优化水下图像的模糊增强，可能因为水下图像存在模糊、对比度低等问题，传统的判别器效果不好。改进点有两个：谱归一化和多尺度判别融合。 先看谱归一化（Spectral Normalization）。谱归一化通常用于稳定GAN的训练，通过约束卷积层的权重矩阵的谱范数，防止判别器过强，从而避免梯度爆炸或模式崩溃。原始判别器用的是InstanceNorm，可能需要将部分层的InstanceNorm替换为谱归一化。但要注意，谱归一化通常应用在卷积层之后、激活函数之前，或者直接包装卷积层。 然后是多尺度判别融合。多尺度判别器指的是在不同尺度下处理图像，比如将图像下采样后输入不同尺度的判别器，最后融合结果。这样可以捕捉不同层次的细节，有助于提升图像质量。具体实现可能需要创建多个判别器分支，每个分支处理不同分辨率的输入，最后汇总各分支的输出。 接下来分析原始代码。判别器结构是Sequential的，包含多个卷积层，每层后接LeakyReLU，部分层有InstanceNorm。最后一层是Conv2d接Sigmoid，输出概率图。输出形状是记录在output_shape属性中。 改进步骤： 1. 谱归一化应用：需要将卷积层用谱归一化包装。PyTorch中可以用torch.nn.utils.spectral_norm函数包裹Conv2d层。需要注意，原来的InstanceNorm可能需要保留或者替换。或者，可能在某些层同时使用谱归一化和InstanceNorm？需要参考相关文献，通常谱归一化可以替代其他归一化方法，但有时也会组合使用。比如，有些工作可能在卷积后应用谱归一化，然后接激活函数，而不用InstanceNorm。这里可能需要调整，比如替换InstanceNorm为谱归一化，或者保留InstanceNorm？ 比如，原始代码中的结构是Conv2d -> InstanceNorm -> LeakyReLU。现在如果应用谱归一化，可能需要将Conv2d层包装，然后可能去掉InstanceNorm？或者保留？需要确认。例如，假设用户希望用谱归一化代替InstanceNorm，那么每个卷积层后面可能只保留LeakyReLU，而用谱归一化的卷积层代替原来的卷积加InstanceNorm的组合。或者，可能在某些层保留InstanceNorm？ 需要参考CycleGAN的改进工作，比如在判别器中加入谱归一化通常会替换掉原来的归一化层。比如，原始的判别器结构中的InstanceNorm可能被去除，转而使用谱归一化的卷积层。所以可能需要修改每一层，除了第一层可能不用归一化，其他层可能使用谱归一化？ 或者，是否每个卷积层都应用谱归一化？比如，在原始代码中，第一层是Conv2d(3,64,4,2,1) -> LeakyReLU，第二层是Conv2d(64,128,...) -> InstanceNorm -> LeakyReLU。现在应用谱归一化的话，可能每个卷积层后面加上谱归一化，并去掉InstanceNorm。例如，每个Conv2d层用spectral_norm包装，然后接LeakyReLU，而不再使用InstanceNorm。 那原始判别器的各层需要调整。例如： 原结构： Conv2d(3,64,4,2,1) → LeakyReLU Conv2d(64→128) → InstanceNorm → LeakyReLU Conv2d(128→256) → InstanceNorm → LeakyReLU Conv2d(256→512) → InstanceNorm → LeakyReLU Conv2d(512→1) → Sigmoid 现在应用谱归一化的话，可能将每个Conv2d层用spectral_norm包装，并去掉InstanceNorm。比如： Conv2d(3,64,4,2,1) → LeakyReLU SpectralConv(64→128) → LeakyReLU SpectralConv(128→256) → LeakyReLU SpectralConv(256→512) → LeakyReLU SpectralConv(512→1) → Sigmoid 这里的SpectralConv是经过谱归一化的Conv2d层。因此，在代码中，每个卷积层都需要被包装，除了第一个可能是否应用？或者是否所有卷积层都应用？ 例如，原论文中，谱归一化是否应用在判别器的所有卷积层？通常是的，但有时可能第一个层不应用。需要确认。例如，在SAGAN中，判别器的所有卷积层都应用谱归一化。因此，这里可能所有卷积层都应用谱归一化，除了可能最后一层？ 例如，原代码中的最后一层是Conv2d(512, 1, 4,1,1)，然后接Sigmoid。是否应该应用谱归一化？或者最后一层不需要？比如，在常规的谱归一化应用中，所有判别器的层都会应用，包括最后一层。例如，在PyTorch的官方示例中，判别器的所有卷积层都应用谱归一化。所以，这里需要将所有卷积层包装。 但原代码中的最后一层没有InstanceNorm，直接接Sigmoid。所以修改后的结构应该是： Conv2d(3→64, spectral) → LeakyReLU Conv2d(64→128, spectral) → LeakyReLU Conv2d(128→256, spectral) → LeakyReLU Conv2d(256→512, spectral) → LeakyReLU Conv2d(512→1, spectral) → Sigmoid 这样，所有Conv2d层都被谱归一化，并且原来的InstanceNorm被移除了。 那代码中需要将每个Conv2d用spectral_norm包裹，并且去掉InstanceNorm层。 然后是多尺度判别融合。多尺度判别器的实现通常需要多个判别器，每个处理不同尺度的输入。例如，将输入图像下采样到不同的分辨率，输入到不同的判别器中，然后将结果进行融合。或者，可能在一个判别器内部有多个分支处理不同尺度的输入。比如，原论文中的多尺度判别器可能有三个判别器，分别处理原图、下采样1/2和下采样1/4的图像。 在代码中，可能需要创建多个判别器实例，每个对应不同的尺度。或者，可能在一个判别器类中实现多尺度处理。例如，每个判别器分支的结构相同，但输入尺寸不同。例如，在Multi-Scale Discriminator中，通常会使用多个判别器，每个处理不同尺度的图像。例如，三个判别器D1、D2、D3，其中D1处理原图，D2处理下采样到一半的图像，D3处理下采样到1/4的图像。然后，每个判别器的输出被平均或加权求和，得到最终的判别结果。 因此，在代码中，可能需要定义多个判别器，每个是经过谱归一化的PatchGAN，然后将它们的输出结合起来。或者，可能在一个类中处理多个尺度的输入，并融合结果。 例如，用户要求对原始判别器采用多尺度判别融合，所以可能需要将多个判别器（不同尺度）的输出进行融合。所以，改进后的判别器类可能包含多个子判别器，每个对应不同的输入尺度。例如，三个子判别器，处理不同尺度的输入，然后在forward时，将输入图像下采样到不同尺度，分别通过各个子判别器，将结果相加或平均。 或者，是否每个子判别器结构相同，但输入尺寸不同？例如，每个子判别器是同样的结构，但处理不同分辨率的图像。例如，原图，下采样2倍的，下采样4倍的。 因此，在代码中，多尺度判别器可能有多个判别器分支，每个处理不同尺度的输入。然后，在forward时，将输入图像进行下采样，分别输入各个分支，然后将各分支的输出相加或平均。 因此，改进后的判别器类可能包含多个判别器实例，每个处理不同尺度。例如： class MultiScaleDiscriminator(nn.Module): def __init__(self, num_scales=3): super().__init__() self.discriminators = nn.ModuleList() for _ in range(num_scales): self.discriminators.append(Discriminator()) # 每个discriminator是谱归一化的PatchGAN self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False) def forward(self, x): outputs = [] for i, disc in enumerate(self.discriminators): if i > 0: x = self.downsample(x) outputs.append(disc(x)) return sum(outputs) # 或者按其他方式融合 但这里需要定义每个discriminator的结构，也就是将原来的判别器修改为应用谱归一化的版本。因此，需要先定义一个新的基础判别器类，其中每个卷积层应用了谱归一化，并且去掉InstanceNorm。 所以，原始的判别器代码需要被修改为： class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( spectral_norm(nn.Conv2d(3, 64, 4, 2, 1)), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(64, 128, 4, 2, 1)), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(128, 256, 4, 2, 1)), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(256, 512, 4, 1, 1)), nn.LeakyReLU(0.2, True), spectral_norm(nn.Conv2d(512, 1, 4, 1, 1)), nn.Sigmoid() ) self.output_shape = None # 初始化属性 def forward(self, x): x = self.model(x) if self.output_shape is None: self.output_shape = x.shape[1:] return x 注意这里所有的Conv2d层都被spectral_norm包装，并且去掉了原来的InstanceNorm层。这可能是一个关键点，因为谱归一化已经作为权重归一化的方法，可能不需要再使用InstanceNorm。 然后，多尺度判别器就是使用多个这样的判别器，每个处理不同尺度的输入。例如： class MultiScaleDiscriminator(nn.Module): def __init__(self, num_scales=3): super().__init__() self.num_scales = num_scales self.discriminators = nn.ModuleList() for _ in range(num_scales): self.discriminators.append(Discriminator()) # 每个都是谱归一化的判别器 self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False) def forward(self, x): outputs = [] for i, discriminator in enumerate(self.discriminators): if i != 0: x = self.downsample(x) outputs.append(discriminator(x)) return sum(outputs) # 或者取平均等融合方式 这样，每个判别器处理不同尺度的图像，然后将输出相加。这样，整个多尺度判别器的输出是各尺度判别结果的融合。 但需要注意，每个判别器的输入通道数是否匹配。例如，原判别器输入是3通道，下采样后的图像也是3通道，没问题。 然后，将这两个改进点结合起来，最终的判别器应该是一个多尺度的、每个子判别器应用谱归一化的结构。 但用户要求将原始判别器（即PatchGAN）采用谱归一化和多尺度融合，所以最终的判别器代码应该包括这两个改进。 现在，我需要将这些思路转化为代码。可能存在的问题： 1. 如何正确应用谱归一化？需要使用torch.nn.utils.parametrizations.spectral_norm（在较新的PyTorch版本中）或者torch.nn.utils.spectral_norm。例如，在代码中应该这样包装卷积层： 例如，将 nn.Conv2d(...) 替换为 spectral_norm(nn.Conv2d(...))。 需要确保在判别器的每个卷积层都应用spectral_norm，除了最后一层是否需要？比如，原代码中最后一层应用Sigmoid，是否也需要谱归一化？根据常见做法，最后一层卷积层可能也需要谱归一化，所以应该应用。 然后，在判别器的前向传播中，输入经过各层处理。原始判别器的结构是逐步下采样，得到最后的输出。 对于多尺度判别器，每个子判别器的结构都是相同的，但输入图像的分辨率不同。例如，第一个子判别器处理原图，第二个处理下采样后的图像，第三个处理再次下采样后的图像。 在MultiScaleDiscriminator的forward函数中，第一个判别器处理原图，第二个处理下采样一次后的图像，第三个处理下采样两次后的图像，依此类推。然后，将各个判别器的输出相加，作为最终的判别结果。 此外，是否需要调整每个子判别器的输出大小？例如，输入图像的分辨率不同，导致输出的大小不同。例如，原图是256x256，经过三次下采样后，输出为30x30（假设原结构中的输出形状是30x30）。如果输入图像被下采样，则经过判别器后的输出可能更小，但各个判别器的输出可能尺寸不同，无法直接相加。例如，假设原图经过判别器后的输出是Nx1x30x30，下采样后的图像输入同一个判别器结构，输出可能更小。例如，原判别器的结构是每次卷积的stride为2，导致每层将空间尺寸减半。原判别器的层结构： 第一层：Conv2d(3,64,4,2,1) → 输出尺寸减半（假设输入是HxW，输出是H/2 x W/2） 第二层：Conv2d(64→128,4,2,1) → 再次减半 → H/4 x W/4 第三层：Conv2d(128→256,4,2,1) → H/8 x W/8 第四层：Conv2d(256→512,4,1,1) → 保持尺寸，因为stride=1，padding=1，kernel=4 → 输出尺寸不变？ 这里可能需要重新计算各层的输出尺寸。例如，原判别器的结构可能有四次卷积，其中前三次的stride是2，最后一次的stride是1。例如，输入假设是256x256： Conv2d(3→64,4,2,1): 输出128x128 Conv2d(64→128,4,2,1): 64x64 Conv2d(128→256,4,2,1):32x32 Conv2d(256→512,4,1,1): 32x32 （因为stride=1，padding=1，kernel=4 → output size = (32 -4 +2*1)/1 +1 = 32-4+2=30? 计算可能不对。可能需要更精确的计算。） 或者，使用公式：output_size = (input_size + 2*padding - dilation*(kernel_size-1) -1)/stride +1 假设输入为HxW，对于Conv2d层，参数是kernel_size=4, stride=2, padding=1: output_size = (H +2*1 -1*(4-1) -1)/2 +1 = (H +2 -3 -1)/2 +1 = (H-2)/2 +1 = H/2 -1 +1 = H/2. 所以，输入256x256 → 128x128 → 64x64 → 32x32 → 32x32（因为第四个层的stride=1，padding=1，kernel=4: output_size = (32 +2*1 -1*(4-1) -1)/1 +1 = (32+2-3-1)/1 +1 = 30 +1=31? 或者可能我的计算有误。这可能影响输出的形状。） 但原代码中的output_shape是在第一次forward时记录的。假设原始判别器的输出形状是某个固定值，当输入不同尺度的图像时，各个判别器的输出形状可能不同。例如，原输入是256x256，输出可能是某个尺寸；而当输入被下采样到128x128时，经过同样的判别器结构，输出尺寸会更小。例如，原判别器结构中的各层： 假设每个Conv2d的stride为2的层会降低分辨率，直到最后的几层。因此，输入不同分辨率的图像，各个子判别器的输出形状可能不同，导致无法相加。例如，假设第一个判别器处理原图得到输出形状是30x30，第二个处理下采样后的图像得到15x15，此时无法相加。 这说明多尺度的判别器可能存在问题，因为不同尺度的判别器输出尺寸不同，无法直接相加。因此，如何处理？ 可能的解决方案： 1. 每个子判别器的结构不同，使得它们的输出尺寸相同。例如，调整每个子判别器的层数，使得不同尺度的输入经过不同的层数后输出相同尺寸。例如，对于低分辨率的输入，使用较少的层，以保持输出尺寸一致。 或者， 2. 各个子判别器的输出尺寸不同，但通过上采样或自适应池化调整为相同尺寸，再融合。 或者， 3. 多尺度判别器的各个子判别器的输出被视为不同层次的判别结果，最终的损失函数是各子判别器损失的总和。例如，每个子判别器输出一个概率图，然后分别计算真实/生成的损失，最后将所有损失相加。此时，无需在判别器的forward中将输出相加，而是在计算损失时分别处理。 根据CycleGAN的多尺度判别器的常见实现，通常采用第三种方式。即，每个子判别器处理不同尺度的输入，并对每个子判别器的输出计算损失，然后总损失是各子判别器损失的和。例如，每个子判别器独立计算损失，然后将它们相加作为最终的判别损失。 在这种情况下，多尺度判别器类可能不需要在forward中融合输出，而是将各个子判别器的输出分别返回，供损失函数计算时使用。 例如，MultiScaleDiscriminator的forward返回一个列表，包含各个子判别器的输出。然后，在计算损失时，对每个子判别器的输出分别计算，并将它们的损失相加。 因此，MultiScaleDiscriminator的forward函数可能返回一个列表，或者将各个输出相加，但需要确保它们的形状相同。或者，可能每个子判别器的输出形状不同，但在计算损失时分别处理。 这可能意味着，用户的问题中的“多尺度判别融合”可能需要重新考虑如何实现。例如，如果各个判别器的输出尺寸不同，如何融合？ 可能的另一种方法是，每个子判别器输出一个标量（例如，通过全局平均池将特征图转换为单个值），然后相加这些标量。但原PatchGAN的输出是一个特征图（例如，30x30的每个点代表一个patch的真假），所以直接相加可能不合适。 例如，原判别器的输出是1x30x30的特征图，表示每个patch的真实概率。如果多尺度判别器的各个子判别器的输出特征图尺寸不同，直接相加会导致形状不匹配。此时，可能需要将各个输出上采样到相同尺寸，或者对每个输出求平均，得到一个标量，然后将标量相加。 例如，每个子判别器的输出求平均得到一个标量，然后将所有标量相加作为最终输出。这可能更合理。例如，每个子判别器的输出是特征图，对每个特征图取平均得到该尺度的真实性概率，然后将所有尺度的平均概率相加。 因此，在MultiScaleDiscriminator的forward函数中，每个子判别器的输出被平均，然后所有结果相加。这可能更可行，因为不同尺度的特征图可以各自平均得到一个标量，然后相加。 修改MultiScaleDiscriminator的forward函数： def forward(self, x): total_output = 0 for i, discriminator in enumerate(self.discriminators): if i != 0: x = self.downsample(x) output = discriminator(x) total_output += output.mean() return total_output 但这样可能无法保持梯度，或者可能不符合GAN的判别器设计，因为原判别器的输出是每个patch的预测，而这里将所有输出平均后相加，得到一个标量。这可能改变了判别器的设计意图。例如，原判别器输出的是一个特征图，每个元素对应一个patch，而多尺度的判别器可能希望综合不同尺度的特征图的信息。 或者，可能每个子判别器的输出被展平，然后拼接起来，再通过一个全连接层得到最终结果。但这样会增加参数，可能不符合用户要求的“多尺度判别融合”的方式。 另一种方法是，保持各个子判别器的输出，然后在计算损失时，对每个子判别器的输出分别计算损失，并将损失相加。例如，真实图像经过各个子判别器得到的输出应该接近1，生成图像接近0，总损失是各子判别器损失之和。这种情况下，判别器的forward函数不需要融合输出，而是返回所有子判别器的输出列表，供损失函数计算。 例如，在训练时，对于真实图像和生成图像，分别通过多尺度判别器得到各个子判别器的输出，然后计算每个子判别器的损失并相加。 因此，MultiScaleDiscriminator的forward函数应返回各个子判别器的输出列表，而不是融合后的结果。 这可能更符合实际的多尺度判别器的实现。例如，在CycleGAN的官方实现中，多尺度判别器通常由多个独立的判别器组成，每个处理不同尺度的图像，损失是各判别器损失的总和。 因此，修改后的MultiScaleDiscriminator的代码可能如下： class MultiScaleDiscriminator(nn.Module): def __init__(self, num_scales=3): super().__init__() self.num_scales = num_scales self.discriminators = nn.ModuleList([Discriminator() for _ in range(num_scales)]) self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False) def forward(self, x): outputs = [] for i, discriminator in enumerate(self.discriminators): if i > 0: x = self.downsample(x) outputs.append(discriminator(x)) return outputs # 返回各判别器的输出列表 这样，每个判别器的输出被保留，并在计算损失时分别处理。例如，对于每个判别器的输出，计算对应的真实损失和生成损失，然后将所有损失相加。 综上，最终的判别器代码应该包括： 1. 基础判别器类，应用谱归一化，去掉InstanceNorm。 2. 多尺度判别器类，包含多个基础判别器实例，处理不同尺度的输入。 然后将原始判别器的代码修改为应用谱归一化的版本，并构建多尺度结构。 现在，将这些整合成代码： 首先，基础判别器类（应用谱归一化）： class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.utils.spectral_norm(nn.Conv2d(3, 64, 4, 2, 1)), nn.LeakyReLU(0.2, True), nn.utils.spectral_norm(nn.Conv2d(64, 128, 4, 2, 1)), nn.LeakyReLU(0.2, True), nn.utils.spectral_norm(nn.Conv2d(128, 256, 4, 2, 1)), nn.LeakyReLU(0.2, True), nn.utils.spectral_norm(nn.Conv2d(256, 512, 4, 1, 1)), nn.LeakyReLU(0.2, True), nn.utils.spectral_norm(nn.Conv2d(512, 1, 4, 1, 1)), nn.Sigmoid() ) self.output_shape = None # 初始化属性 def forward(self, x): x = self.model(x) if self.output_shape is None: self.output_shape = x.shape[1:] return x 注意这里每个Conv2d层都被spectral_norm包裹，并且去除了原来的InstanceNorm层。 然后，多尺度判别器类： class MultiScaleDiscriminator(nn.Module): def __init__(self, num_scales=3): super().__init__() self.num_scales = num_scales self.discriminators = nn.ModuleList([Discriminator() for _ in range(num_scales)]) self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False) def forward(self, x): outputs = [] for i, discriminator in enumerate(self.discriminators): if i > 0: # 第一个判别器处理原图，后面的处理下采样后的图像 x = self.downsample(x) outputs.append(discriminator(x)) return outputs # 返回各个判别器的输出列表 但这样在训练时，每个判别器的输出需要被分别处理。例如，在计算损失时，对每个判别器的输出分别计算，然后累加损失。 此外，原始判别器的最后一层使用了Sigmoid激活函数，输出范围在0到1之间。但根据GAN的常见实践，有些工作可能不会在判别器最后使用Sigmoid，而是使用无激活函数，然后计算损失时用BCEWithLogitsLoss。但原用户的代码中使用了Sigmoid，所以可能保持原样。 但谱归一化的应用是否会影响是否需要Sigmoid？例如，如果最后一层应用了谱归一化，并且输出是logits，那么Sigmoid可能更合适。或者，可能不需要Sigmoid，而使用BCEWithLogitsLoss。需要用户确认，但根据原代码，保留Sigmoid。 综上，最终的代码应该包括： 1. Discriminator类，其中每个Conv2d层应用了谱归一化，没有InstanceNorm。 2. MultiScaleDiscriminator类，包含多个Discriminator实例，处理不同尺度的输入，并返回各实例的输出列表。 用户的问题中提到“对原始判别器patchgan判别器采用谱归一化和多尺度判别融合”，所以最终的判别器应该是一个多尺度的、每个子判别器应用谱归一化的结构。因此，正确的代码应该是MultiScaleDiscriminator，其中每个子判别器是应用了谱归一化的Discriminator。 现在，检查代码是否正确应用了谱归一化，并处理了多尺度。 可能的错误点： - 是否在正确的层应用谱归一化？例如，所有卷积层都被包裹。 - 是否在MultiScaleDiscriminator中正确下采样输入图像。 在MultiScaleDiscriminator的forward中，第一个判别器处理原图，第二个处理下采样一次后的图像，第三个处理下采样两次后的图像，依此类推。例如，循环中，每次i>0时，对x进行下采样。假设初始输入是x0，那么： i=0：处理x0 → outputs[0] i=1：x = downsample(x0) → outputs[1] i=2：x = downsample(x_prev) → outputs[2] 这样，每个后续的判别器处理进一步下采样的图像。这应该正确实现多尺度处理。 最后，测试输出是否正确。例如，当输入一张图像，经过多尺度判别器后，得到各个子判别器的输出，每个输出可能形状不同，但在计算损失时分别处理。 综上，最终的代码应该包括这两个类，其中Discriminator应用了谱归一化，MultiScaleDiscriminator组合多个Discriminator实例。</think>以下是结合谱归一化和多尺度判别器优化的代码实现： ```python import torch.nn as nn from torch.nn.utils import spectral_norm # 基础判别器单元（含谱归一化） class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( spectral_norm(nn.Conv2d(3, 64, 4, 2, 1)), # 输入尺寸：H x W -> H/2 x W/2 nn.LeakyReLU(0.2, inplace=True), spectral_norm(nn.Conv2d(64, 128, 4, 2, 1)), # H/2 x W/2 -> H/4 x W/4 nn.LeakyReLU(0.2, inplace=True), spectral_norm(nn.Conv2d(128, 256, 4, 2, 1)), # H/4 x W/4 -> H/8 x W/8 nn.LeakyReLU(0.2, inplace=True), spectral_norm(nn.Conv2d(256, 512, 4, 1, 1)), # 保持空间分辨率 nn.LeakyReLU(0.2, inplace=True), spectral_norm(nn.Conv2d(512, 1, 4, 1, 1)), # 最终输出特征图 nn.Sigmoid() ) self.output_shape = None def forward(self, x): x = self.model(x) if self.output_shape is None: self.output_shape = x.shape[1:] # 记录特征图维度 return x # 多尺度融合判别器 class MultiScaleDiscriminator(nn.Module): def __init__(self, num_scales=3): super().__init__() self.num_scales = num_scales self.discriminators = nn.ModuleList( [Discriminator() for _ in range(num_scales)]) # 下采样层（使用平均池化保持颜色稳定性） self.downsample = nn.AvgPool2d( kernel_size=3, stride=2, padding=1, count_include_pad=False ) def forward(self, x): outputs = [] for i, discriminator in enumerate(self.discriminators): # 对第i>0的判别器输入下采样图像 if i > 0: x = self.downsample(x) outputs.append(discriminator(x)) # 多尺度特征图融合（平均加权） return sum([out.mean() for out in outputs]) # 标量输出 ``` 改进说明： 1. **谱归一化优化** - 所有卷积层均使用`spectral_norm`包装，替代原始判别器的InstanceNorm - 提升训练稳定性，避免梯度爆炸 - 公式实现：$ W_{SN} = W / \sigma(W) $，其中$\sigma(W)$为权重矩阵的谱范数 2. **多尺度融合机制** - 采用3个判别器（可配置数量） - 处理不同尺度输入：原图→1/2下采样→1/4下采样 - 最终输出为各尺度判别结果的加权平均 3. **下采样优化** - 使用平均池化替代常规卷积下采样 - 保持颜色分布稳定性，公式： $$ x_{down} = \frac{1}{k^2}\sum_{i=1}^k \sum_{j=1}^k x_{(m+i)(n+j)} $$ 使用方法： ```python # 初始化判别器 discriminator = MultiScaleDiscriminator(num_scales=3) # 前向传播 real_output = discriminator(real_images) fake_output = discriminator(fake_images.detach()) # 计算损失时需分别处理各尺度输出 loss = criterion(real_output, torch.ones_like(real_output)) + \ criterion(fake_output, torch.zeros_like(fake_output)) ```