GAN损失函数公式详细推导（含完整代码）

最新推荐文章于 2025-04-05 12:03:07 发布
最新推荐文章于 2025-04-05 12:03:07 发布
阅读量1.3w 收藏 87
点赞数 20
分类专栏： 深度学习干货 粉丝的投稿 人工智能干货 文章标签： 深度学习 机器学习 神经网络 GAN
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42645636/article/details/129520882
版权
本文介绍了GAN的基本概念，包括由生成器和判别器组成的模型，以及它们通过对抗性训练提升性能的过程。文章详细阐述了GAN的训练过程和损失函数，同时提供了使用PyTorch实现GAN和DCGAN生成MNIST手写数字数据集的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

来源：投稿 作者：孙裕道
编辑：学姐

GAN原理介绍

GAN是由生成器G和判别器D组成，通过大量样本数据训练使得生成器的生成能力和判别器的判别能力在对抗中逐步提高，最终目的是让生成器G输入到生成器中生成假的样本。

具体的训练过程为：

• 首先在真实数据集中采样出一批真实样本

• 同时从某个分布中随机生成一些噪声向量

• 接着将噪声向量输入到生成器中生成假的样本数据

• 最后把真实样本与等量的假的样本输入到判别器中进行判别

「GAN训练的过程可以描述为求解一个二元函数极小极大值的过程，具体的公式如下所示：」

优化对抗损失V(D,G)可以同时达到两个目的，第一个目的是让生成器G能够生成真实的样本，第二个目的是让判别器D能更好地区分开真实样本和生成样本。

「生成器G损失函数」

训练生成器的损失函数其实是对抗损失V(D,G)中关于噪声z的项，其损失函数为：

生成器的目标是希望生成器生成的样本越像真的越好，具体体现在数学公式中为：

其中BCE(.,.)表示二元交叉熵函数。则由上可知，GAN中生成器最小化损失函数LG可以写成最小化二元交叉熵函数的形式。

「判别器D损失函数」

训练生成器的损失函数其实是对抗损失V(D,G)中关于样本x的项，其损失函数为：

判别器的目标是希望判别器能够更好的区分出生成样本和真实样本，具体体现在数学公式中为：

GAN代码介绍

本节介绍用GAN和DCGAN生成mnist手写数据集，GAN和DCGAN的网络结构以及完整的实现代码分别如下所示：

import argparse
from torchvision import datasets, transforms
import torch
import torch.nn as nn
import os
import numpy as np
from torchvision.utils import save_image

def args_parse():
    parser = argparse.ArgumentParser()
    parser.add_argument("--n_epoches", type=int, default=100, help="number of epochs of training")
    parser.add_argument("--batch_size", type=int, default=256, help="size of the batches")
    parser.add_argument("--lr", type=float, default=0.0002, help="adam: learning rate")
    parser.add_argument("--n_cpu", type=int, default=1, help="number of cpu threads to use during batch generation")
    parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
    parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension")
    parser.add_argument("--channels", type=int, default=1, help="number of image channels")
    parser.add_argument("--sample_interval", type=int, default=100, help="interval between image sampling")
    parser.add_argument("--b1", type=float, default=0.5, help="adam: decay of first order momentum of gradient")
    parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of first order momentum of gradient")
    parser.add_argument("--type", type=str, default='GAN', help="The type of GAN")
    return parser.parse_args()

class Generator(nn.Module):
    def __init__(self,  latent_dim, img_shape):
        super(Generator, self).__init__()
        self.img_shape = img_shape

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
                *block(latent_dim, 128, normalize=False),
                *block(128, 256),
                *block(256, 512),
                *block(512, 1024),
                nn.Linear(1024, int(np.prod(img_shape))),
                nn.Tanh()
        )


    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), self.img_shape[0], self.img_shape[1], self.img_shape[2])
        return img

class Discriminator(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid(),
        )

    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity


class Generator_CNN(nn.Module):
    def __init__(self,  latent_dim, img_shape):
        super(Generator_CNN, self).__init__()

        self.init_size = img_shape[1] // 4
        self.l1 = nn.Sequential(nn.Linear(latent_dim, 128 * self.init_size ** 2))   # 100 ——> 128 * 8 * 8 = 8192

        self.conv_blocks = nn.Sequential(
            nn.BatchNorm2d(128),
            nn.Upsample(scale_factor = 2),
            nn.Conv2d(128, 128, 3, stride=1, padding=1),
            nn.BatchNorm2d(128, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Upsample(scale_factor = 2),
            nn.Conv2d(128, 64, 3, stride=1, padding=1),
            nn.BatchNorm2d(64, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, img_shape[0], 3, stride=1, padding=1),
            nn.Tanh()
        )

    def forward(self, z):
        out = self.l1(z)
        out = out.view(out.shape[0], 128, self.init_size, self.init_size)
        img = self.conv_blocks(out)
        return img

class Discriminator_CNN(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator_CNN, self).__init__()

        def discriminator_block(in_filters, out_filters, bn=True):
            block = [nn.Conv2d(in_filters, out_filters, 3, 2, 1),
                     nn.LeakyReLU(0.2,inplace=True),
                     nn.Dropout2d(0.25)]
            if bn:
                block.append(nn.BatchNorm2d(out_filters, 0.8))
            return block

        self.model = nn.Sequential(
            *discriminator_block(img_shape[0], 16, bn=False),
            *discriminator_block(16, 32),
            *discriminator_block(32, 64),
            *discriminator_block(64, 128),

        )

        ds_size = img_shape[1] // 2 ** 4
        self.adv_layer = nn.Sequential(nn.Linear(128 * ds_size ** 2, 1), nn.Sigmoid()) # 128 * 2 * 2 ——> 1

    def forward(self, img):
        out = self.model(img)
        out = out.view(out.shape[0], -1)
        validity = self.adv_layer(out)
        return validity

def train():
    opt = args_parse()

    transform = transforms.Compose(
                [
                    transforms.Resize(opt.img_size),
                    transforms.ToTensor(),
                    transforms.Normalize([0.5],[0.5])   
                ])

    mnist_data = datasets.MNIST(
                    "mnist-data",
                    train=True,
                    download=True,
                    transform = transform
                )

    train_loader = torch.utils.data.DataLoader(
                    mnist_data,
                    batch_size=opt.batch_size,
                    shuffle=True)


    img_shape = (opt.channels, opt.img_size, opt.img_size)
    # Construct generator and discriminator
    if opt.type == 'DCGAN':
        generator = Generator_CNN(opt.latent_dim, img_shape)
        discriminator = Discriminator_CNN(img_shape)
    else:
        generator = Generator(opt.latent_dim, img_shape)
        discriminator = Discriminator(img_shape)

    adversarial_loss = torch.nn.BCELoss()

    cuda = True if torch.cuda.is_available() else False
    if cuda:
        generator.cuda()
        discriminator.cuda()
        adversarial_loss.cuda()

    # Loss function


    # Optimizers
    optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
    optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))

    print(generator)
    print(discriminator)

    Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
    for epoch in range(opt.n_epoches):
        for i, (imgs, _) in enumerate(train_loader):
            # adversarial ground truths
            valid = torch.ones(imgs.shape[0], 1).type(Tensor)
            fake = torch.zeros(imgs.shape[0], 1).type(Tensor)

            real_imgs = imgs.type(Tensor)

            #############    Train Generator    ################
            optimizer_G.zero_grad()

            # sample noise as generator input
            z = torch.tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))).type(Tensor)

            # Generate a batch of images
            gen_imgs = generator(z)

            # G-Loss
            g_loss = adversarial_loss(discriminator(gen_imgs), valid)
            g_loss.backward()
            optimizer_G.step()

            #############  Train Discriminator ################
            optimizer_D.zero_grad()

            # D-Loss
            real_loss = adversarial_loss(discriminator(real_imgs), valid)
            fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
            d_loss = (real_loss + fake_loss) / 2

            d_loss.backward()
            optimizer_D.step()

            print(
                "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G Loss: %f]"
                % (epoch, opt.n_epoches, i , len(train_loader), d_loss.item(), g_loss.item())
            )

            batches_done = epoch * len(train_loader) + i
            os.makedirs("images", exist_ok=True)
            if batches_done % opt.sample_interval == 0:
                save_image(gen_imgs.data[:25], "images/%d.png" % (batches_done), nrow=5, normalize=True )

if __name__ == '__main__':
    train()

关注下方《学姐带你玩AI》🚀🚀🚀

回复“GAN”领取论文PDF＆课件＆代码数据集

码字不易，欢迎大家点赞评论收藏！

深度学习——GAN（生成网络）损失函数解析
wenqiwenqi123的博客
03-25 1万+
生成网络（GAN）是近年来很火的课题，原始论文《Generative Adversarial Nets》的介绍请移步：https://blog.csdn.net/wenqiwenqi123/article/details/86178376 本篇主要详细解析它的损失函数。在论文中损失函数定义为： 当然乍一看去，没看懂这个损失函数。我们细细来看： ...
损失函数 (Loss Function) 原理与代码实例讲解
AI天才研究院
07-26 310
损失函数 (Loss Function) 原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来
【对抗网络】Gan的基本公式详解
sbb8177919的博客
11-05 1474
本文将对Gan的基本公式进行一个详细的解释，此后的多种对抗网络的形式都是基于本文的基本公式进行一定的演变而来，所以清楚地了解Gan的基本公式，对以后的Gan网络学习，意义深远而重大。
[【深度学习】9个主流GAN损失函数的数学原理和Pytorch代码实现：从经典模型到现代变体
fengdu78的博客
04-05 206
本研究首先介绍经典GAN损失函数的理论基础，随后使用PyTorch实现包括原始GAN、最小二乘GAN(LS-GAN)、Wasserstein GAN(WGAN)及带梯度惩罚的WGAN(WGAN-GP)在内的多种损失函数。梯度惩罚使模型训练过程更加稳定，同时减少了生成图像中的伪影，提高了最终生成结果的质量与真实度。本文通过详细分析GAN的经典损失函数及其多种变体，揭示了不同类型损失函数各自的优势：LS-GAN训练稳定性好，WGAN-GP生成图像清晰度高，而条件类GAN如CGAN则在可控性方面表现突出。
GAN（二）损失函数推导
TyjphsQ的博客
04-20 1542
上式中，我们目标是max V（D,G），即固定G，调整D，那么G不受影响，G（z）是近似X的分布，这里我们换元，后半部分，就变成了对x的积分，噪音的分布也写成。X 是真实数据，G(z)是生成的数据，所以有D（x) -> 1, D（G(z)）-> 0.要求调整D，求最值，于是对D进行求导，找驻点嘛。（注意，只是对D求导，并不对x进行求导），就是提高判别器的能力，在判别器眼里，这应该是两种。，就是提高生成器的能力，在生成器眼里，这应该是两种。其中 max 代表，固定G，调整D，使得。
论文GAN（生成对抗网络）的一些解读
几度热忱的博客
10-31 2567
GAN(Generative Adversarial Nets)全称为对抗生成网络，其结构主要有两个部分①生成器（Generator）②鉴别器（Discriminator），本文将对论文GAN（生成对抗网络）进行详细解读与公式推导
gan网络损失函数_GAN论文阅读笔记1：从零推导GAN
weixin_29870701的博客
12-27 999
生成式对抗网络（GAN, Generative Adversarial Networks ）毫无疑问是近几年来较为火热的生成模型。其核心思想非常简单：引入对抗的概念，让两个网络——生成器网络（Generator）和判别器网络（Discriminator）互相对抗。0. 符号定义在介绍GAN之前，先简要介绍一下符号定义和必要的概念。记生成器为 ，判别器为 ，真实（real）数据分布为 ，高斯随...
GAN是一种特殊的损失函数？
阿里云云栖号
12-21 2443
数据科学家JeremyHoward在fast.ai的《生成对抗网络（GAN）》课程中曾经讲过这样一句话： “从本质上来说，生成对抗网络（GAN）是一种特殊的损失函数。” 你是否能够理解这句话的意思？读完本文，你会更好的理解这句话的含义。 神经网络的函数逼近理论 在数学中，我们可以将函数看做一个“机器”或“黑匣子”，我们为这个“机器”或“黑匣子”提供了一个或多个数字作为输入，则会输出一个或...
GAN 网络的损失函数介绍代码
tony365的博客
03-07 2721
pixel_opt:相比于一般的l1 loss多了 loss weight, reduction, weight三个功能。首先loss_util.py文件定义weight_lossArgs:Returns:"""else:Args:Returns:"""else::Example:tensor(3.)"""loss = loss_func(pred, target, **kwargs) # 这里 reduction='none'接下来定义带weight的L1 loss。
GAN的损失函数
我の博客
01-08 8489
在训练过程中，生成器和判别器的目标是相矛盾的，并且这种矛盾可以体现在判别器的判断准确性上。生成器的目标是生成尽量真实的数据，最好能够以假乱真、让判别器判断不出来，因此生成器的学习目标是让判别器上的判断准确性；相反，判别器的目标是尽量判别出真伪，因此判别器的学习目标是让自己的判别准确性。当生成器生成的数据越来越真时，判别器为维持住自己的准确性，就必须向辨别能力越来越强的方向迭代。当判别器越来越强大时，生成器为了降低判别器的判断准确性，就必须生成越来越真的数据。在这个奇妙的关系中，判别器判断的准确性由。
GAN: 原始损失函数详解
weixin_30377461的博客
12-01 2043
　　GAN的原始损失函数，咋一看是非常难以理解的，但仔细理解后就会发现其简洁性和丰富的含义。 　　损失函数定义： 　　　　 　　一切损失计算都是在D（判别器）输出处产生的，而D的输出一般是fake/true的判断，所以整体上采用的是二进制交叉熵函数。 　　左边包含两部分minG和maxD。 　　首先看一下maxD部分，因为训练一般是先保持G（生成器）不变训练D的。D的训练目标是正确区分f...
对抗生成网络（GAN）中的损失函数
热门推荐
L888666Q的博客
11-10 1万+
L1损失函数又称为MAE(mean abs error)，即平均绝对误差，也就是预测值和真实值之间差值的绝对值。 L2损失函数又称为MSE(mean square error)，即平均平方误差，也就是预测值和真实值之间差值的平方。
标准GAN的公式推导
12-10
里面包含了对抗生成网络的提出，推导和部分实验，从数学理论的角度出发从KL散度到JS散度再到目标网络的公式推导。
Gan网络损失函数理解
SWLF的博客
09-18 4262
Gan网络的损失函数经常使用这条交叉熵损失函数，表示为： L(G,D)=∑E(logDd)+∑E[log(1−D(G(p)))]L(G, D) = \sum_{}^{}E(logD_d)+\sum_{}^{}E[log(1-D(G(p)))]L(G,D)=∑​E(logDd​)+∑​E[log(1−D(G(p)))]. 公式中的含义：G生成器，D判别器，d表示真实的数据，Dd表示判别器对真实数据的判别结果，G§表示生成的假数据，D(G§)表示判别器对于假数据的判别结果。 log函数在区间【0,1】之间的取值
gan网络损失函数_GAN的损失函数
weixin_39634576的博客
12-22 2265
理解生成对抗网络的关键在于理解GAN的损失函数JS散度GAN实际是通过对先验分布施加一个运算G, 来拟合一个新的分布如果从传统的判别式网络的思路出发，只要选定合适的loss，就可以使生成分布和真实分布之间的距离尽可能逼近KL散度经常用来衡量分布之间距离但KL散度是不对称的。不对称意味着，对于同一个距离，观察方式不同，获取的loss也不同，那么整体loss下降的方向就会趋向于某个特定方向。这在GAN...
GAN公式推导
weixin_39454351的博客
07-03 533
真实数据的分布 生成器生成的分布 噪音Z的分布 生成器,使噪音的分布收敛到真实数据的分布 生成器的输出 判别器，区分真实数据和生成数据 x是真实数据而不是生成数据的概率 定义鉴别模型 If , D(x) = 1, is the maximum 当鉴别模型输出D(x)为1时，即可以轻松判别数据，此时上式取值最大。 If is the maximum...
生成对抗网络（GAN）的原理与公式推导
weixin_45922916的博客
12-05 9466
GAN的基本概念、原理、公式推导、存在的问题、GAN的变种
GAN 公式推导
miss_the_boat的博客
12-02 2738
零、前言 笔者在学习GAN的过程中，查阅了许许多多资料，最终发现台湾大学李宏毅教授的GAN教程讲的极好（PPT非常干净、讲解的很清楚），除此之外网易慕课上的一个Pytorch教程里的GAN部分讲的也是不错，近期还看了B站上李沐大佬的论文精度系列（大佬一段段拆开读，甚好），都有将原理和推导。但最后发现GAN的学习路程上还是有个拦路虎，就是损失函数公式的推导，这是GAN论文的精华所在，同时也是为了记录下自己学习的情况，所以本文参考网络资料与原文进行一个GAN公式的推导计算。推导公式时，本文大量...
平衡小车pid调节方法
最新发布
04-11
<think>好的，我现在需要帮助用户解决关于平衡小车PID参数调节的方法和技巧的问题。用户已经提供了一些参考资料，我需要先仔细理解这些内容，再结合自己的知识来组织回答。 首先，用户提到的引用[1]是关于PID调参的图文详解，其中以小车调速系统为例，分析了三个参数的作用。引用[2]则具体展示了平衡小车的直立环和速度环的代码实现，包括PD控制和PI控制。这说明用户需要的是结合理论和实践的调参步骤，可能涉及直立环、速度环和转向环的参数调整。 接下来，我需要回忆PID控制的基本原理。PID由比例、积分、微分三个部分组成，每个部分对应不同的作用。比例项（P）响应当前误差，积分项（I）消除累积误差，微分项（D）抑制变化率。在平衡小车中，直立环通常使用PD控制，因为需要快速响应角度变化，而速度环可能需要PI控制来维持速度稳定。 用户的问题是关于方法和技巧，所以需要分步骤说明。比如，先调直立环，再调速度环，最后转向环。每个环节要说明参数的作用，调节顺序（如先P后D），以及如何观察现象进行调整。例如直立环的P过小会导致响应慢，无法平衡，过大则振荡；D参数则影响阻尼效果，防止抖动。 同时，要注意引用用户提供的资料。比如在直立环部分，引用[2]中的代码显示使用了Kp和Kd，这可以支持PD控制的说法。速度环部分，用户提到kp和ki，对应PI控制，需要解释积分项的作用，如消除稳态误差，但可能引起积分饱和，需要限幅。 此外，用户可能需要知道调参时的技巧，比如分步调试、参数范围的经验值、安全措施（防止电机过载）、工具使用（如蓝牙模块监控数据）等。这些内容需要条理清晰，用简洁的语言描述，避免过于技术化，让用户容易理解和操作。 最后，生成的相关问题需要与PID调节相关，可能涉及参数整定方法、常见问题处理、对比不同控制策略等。这有助于用户进一步探索。 总结回答结构： 1. 调参步骤：分直立环、速度环、转向环，按顺序调整。 2. 每个环节的参数作用和调整方法，结合引用内容。 3. 调参技巧：安全措施、工具使用、经验值参考。 4. 常见问题及解决方法，如振荡、响应慢等。 5. 生成相关问题，引导深入学习。 需要确保回答符合用户要求的中文，使用正确的LaTeX格式，行内公式用$...$，独立公式用$$...$$。例如，在解释PID公式时，使用$K_p$、$K_i$、$K_d$，并可能展示直立环的PD控制公式：$$u = K_p \cdot e + K_d \cdot \frac{de}{dt}$$。 检查是否有遗漏点，比如是否需要提到串级PID结构，或者平衡小车的动力学模型，但根据用户提供的引用，可能不需要太深入理论，而是侧重实践方法。因此，保持回答实用，步骤明确，技巧具体，即可满足用户需求。</think>### 平衡小车PID参数调节方法与技巧 平衡小车的PID参数调节是保证其稳定运行的核心步骤，需分步骤调试直立环、速度环和转向环。以下是具体方法与技巧： --- #### **1. 直立环（PD控制）** 直立环通过比例（P）和微分（D）项快速响应角度变化，保持车身直立。 **公式**： $$u_{\text{平衡}} = K_p \cdot (θ_{\text{实际}} - θ_{\text{目标}}) + K_d \cdot \frac{dθ}{dt}$$ **调参步骤**： - **先调$K_p$**： - **现象**：若$K_p$过小，小车无法抵抗倾斜，缓慢倒下；若$K_p$过大，车身剧烈振荡[^2]。 - **方法**：从较小值逐步增大，直到小车能快速响应倾斜但未振荡。 - **再调$K_d$**： - **现象**：若$K_d$过小，车身抖动；若$K_d$过大，响应迟钝，可能出现“僵硬”现象[^2]。 - **方法**：在$K_p$稳定的基础上增加$K_d$，抑制高频抖动。 **示例代码**（引用[2]直立环实现）： ```c int Vertical_Ring_PD(float Angle, float Gyro) { float Bias = Angle - Mechanical_balance; // 偏差计算 return PID.Balance_Kp * Bias + Gyro * PID.Balance_Kd; // PD控制输出 } ``` --- #### **2. 速度环（PI控制）** 速度环通过比例（P）和积分（I）项维持小车速度稳定。 **公式**： $$u_{\text{速度}} = K_p \cdot (v_{\text{目标}} - v_{\text{实际}}) + K_i \cdot \int (v_{\text{目标}} - v_{\text{实际}}) dt$$ **调参步骤**： - **先调$K_p$**： - **现象**：$K_p$过小时，小车加速/减速缓慢；$K_p$过大时，速度波动明显。 - **方法**：逐步增大$K_p$，使小车能快速跟踪目标速度。 - **再调$K_i$**： - **现象**：$K_i$过小，稳态误差无法消除；$K_i$过大，积分饱和导致超调。 - **方法**：在$K_p$基础上加入$K_i$，消除静差，但需对积分项限幅[^2]。 --- #### **3. 转向环（可选，P控制）** 转向环通过比例项调整左右轮差速，实现转向控制： $$u_{\text{转向}} = K_p \cdot (θ_{\text{目标转向}} - θ_{\text{实际}})$$ **调参**：根据转向灵敏度调整$K_p$，避免转向过冲或迟钝。 --- #### **调参技巧** 1. **分步调试**：先调直立环，再调速度环，最后处理转向环。 2. **安全措施**：调试时固定小车或限制电机功率，防止失控。 3. **工具辅助**：通过蓝牙模块或上位机实时监控角度、速度等数据。 4. **经验参考**： - 直立环$K_p$范围：20~100，$K_d$范围：1~5。 - 速度环$K_p$范围：0.1~2，$K_i$范围：0.01~0.1。 --- #### **常见问题与解决** - **小车振荡**：增大$K_d$或减小$K_p$。 - **响应迟钝**：增大$K_p$或减小$K_d$。 - **静差累积**：检查速度环$K_i$是否过小或未积分限幅[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值