PID各种算法的基本优缺点

news2024/9/25 13:18:55

PID时间系数对PID本身的影响

图片

积分时间过小积分作用增强。

微分时间过大，微分控制作用过强，容易产生振荡。

在这里的时间系统，一般指的是采样的时间，也就是PID控制的周期。在无人机当中一般采用10ms控制一次。

一般来说采样周期越小，数字模拟越精确，控制效果越接近连续控制。

对大多数算法，缩短采样周期可使控制回路性能改善，但采样周期缩短时，频繁的采样必然会占用较多的计算工作时间，同时也会增加计算机的计算负担。

对于变化迅速的，采样周期应适当减小。多回路控制，采样周期应该适当延长，使得有足够的时间控制。

位置式PID

离散化后的公式：

图片

优点：静态误差小，溢出的影响小。

缺点：计算量很大，累积误差相对大，在系统出现错误的情况下，容易使系统失控，积分饱和。

使用：一般需要结合输出限幅和积分限幅使用。积分限幅是避免积分失控的一种手段，也是为了加快调节时间，减少积分饱和的影响,输出限幅是为了使系统输出不过度，也能够减少系统的调节时间，减少超调量。

位置式PID适用于执行没有积分部件的对象。

增量式PID

离散化后的公式：

图片

优点：溢出的影响小，在系统出现错误的情况下,影响相对较小（因为只与过去的三次误差有关）,运算量也相对较小。

缺点：有静态误差（因为没有累积误差）。

使用：位置式PID适用于执行有积分部件的对象。

位置式PID和增量式PID

C语言实现：

//积分限幅#define INERGRAL_MAX 200#define INERGRAL_MAX -200//输出限幅#define OUT_MIN    -1000#define OUT_MAX    1000
// 滤波系数a（0-1）  #define PARAMETER   0.01                //PID结构体typedef struct{   volatile float    Proportion;             // 比例常数 Proportional Const   volatile float    Integral;               // 积分常数 Integral Const   volatile float    Derivative;             // 微分常数 Derivative Const   volatile int      Error1;                 // Error[n-1]   volatile int      Error2;                 // Error[n-2]   volatile int      iError;                 // Error[n]   volatile  int     Error_sum;} PID
/****************************************************************************************/                                                        //                位置式PID//                    //pwm=Kp*e(k)+Ki*∑e(k)+Kd[e（k）-e(k-1)]  /****************************************************************************************/float PID_Postion (int iError,PID* sptr) {  float  iIncpid=0;  sptr->iError=iError;                                    // 计算当前误差       //sptr->iError=filter(sptr->iError，sptr->Error1); 一阶滤波器  sptr->Error_sum+=sptr->iError;//积分项      ///当输出限幅的时候，积分累加部分也应同时进行限幅，以防输出不变而积分项继续累加，也即所谓的积分饱和过深。  //积分量限幅  if(sptr->Error_sum >INERGRAL_MAX)  {    sptr->Error_sum = PID_InitStruct->INERGRAL_MAX ;  }  if(sptr->Error_sum < INERGRAL_MIN)  {    sptr->Error_sum = PID_InitStruct->INERGRAL_MIN ;  }      iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum                // I         +sptr->Derivative * (sptr->iError-sptr->Error1); // D  sptr->Error1=sptr->iError;          // 存储误差，用于下次计算      iIncpid=PID_OutputLimit(sptr,iIncpid);//PID输出限幅          return(iIncpid);          // 返回计算值  }
/****************************************************************************************/                                    //增量式PID                                            //        pwm+=Kp[e（k）-e(k-1)]+Ki*e(k)+Kd[e(k)-2e(k-1)+e(k-2)]                                      ///****************************************************************************************/float PID_increase(int iError,PID* sptr) {    float  iIncpid=0;  sptr->iError=iError;//直接检测当前偏差  iIncpid=sptr->Proportion * (sptr->iError-sptr->Error1)                  // P         +sptr->Integral * sptr->iError                                   // I         +sptr->Derivative * (sptr->iError-2*sptr->Error1+sptr->Error2);  // D               sptr->Error2=sptr->Error1;                          // 存储误差，用于下次计算  sptr->Error1=sptr->iError;  iIncpid=PID_OutputLimit(sptr,iIncpid);//输出限幅处理        return(iIncpid);   // 返回增量值  }
//PID初始化void PID_Init(PID *sptr){    sptr->Derivative=0;//Kd    sptr->Proportion=0;//Kp    sptr->Integral=0;//Ki    sptr->Error2=0;//第二次误差    sptr->Error1=0;    sptr->iError=0;    sptr->Error_sum=0;//第一次误差}

//PID输出限制，根据PWM的输出值进行增量式PID输出限制float PID_OutputLimit(PID *this, double output)  {        if ((int)output < OUT_MIN)    {        output = OUT_MIN;    }        else if ((int)output > OUT_MAX)        {        output = OUT_MAX;    }    return output;}//一阶低通滤波器//减少毛刺,//滤波系数。取值范围为0~1, 值越小越稳定，越大越灵敏。使用使需要根据实际情况调整滤波系数//输入：新的采样值//输出：滤波后的值float filter(float value，float new_value)   {         return （1-PARAMETER）*value +PARAMETER*new_value;  }  

两种针对积分的PID：

主要目的是为了尽可能利用积分的优势，消除静态误差，也同时减少积分的副作用。

使PID控制器的超调量减少，调节时间减少，系统更加稳定。

积分分离式PID

积分分离式PID主要是针对位置式PID的积分，引入判断误差大小条件，是否使用积分项。

优点：

判定误差比较大的时候，取消积分项的，使用PD或者P控制，没有I的控制，这样，超调量和调节时间都会同时减少。当误差比较小的时候，引入积分项，消除静态误差。

缺点： 

需要经验来确定判断误差的大小，在什么时候使用积分分离比较合适，也就是误差多大的时候取消积分。

应用：

主要用于消除余差，该方法特别适用于生产设备启动阶段的控制。

C语言实现：PID位置式上面有，这里只需要添加一句判断语句和对积分处理。

无积分分离式的PID：

sptr->Error_sum+=sptr->iError;//积分累加 iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum                // I         +sptr->Derivative * (sptr->iError-sptr->Error1); // D

积分分离式PID：

#include<math.h>int index=0;//积分分离标志   //积分分离处理   if(abs(sptr->iError)> 40) sptr->index=0;   else   {    sptr->index=1;  sptr->Error_sum+=sptr->iError;//积分累加  }  iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * （sptr->Error_sum * index）              // I         +sptr->Derivative * (sptr->iError-sptr->Error1); // D

变速积分PID

变积分PID我的理解是积分分离式PID的变体，积分分离式PID 积分的的权重是1或者0，而变积分PID积分的权重会动态变化。取决于偏差，偏差越大，积分越慢。

优缺点和积分分离式PID差不多，只不过，这个变速积分PID更加科学。

积分分离式PID：

#include<math.h>#define I_MAX 40#define I_MIN 5int index=0;//积分分离标志   //变积分处理   if(abs(sptr->iError)> I_MAX) index=0;   else if(abs(sptr->iError)< I_MIN) index=1;  else   index=(I_MAX -  abs(sptr->iError) / (I_MAX -  I_MIN);  if(index!=0) sptr->Error_sum+=sptr->iError;//积分累加  iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * （sptr->Error_sum * index）              // I         +sptr->Derivative * (sptr->iError-sptr->Error1); // D          //变速积分也可以这样处理:更加灵活  if(fabs(sptr->iError)> I_MAX) index=0;   else if(fabs(sptr->iError)< I_MIN) index=1;  else if(fabs(sptr->iError>10&&abs(sptr->iError)<20)) index=0.4;  else if(fabs(sptr->iError>30&&abs(sptr->iError)<50)) index=0.8;  else   index=(I_MAX -  abs(sptr->iError) / (I_MAX -  I_MIN);

两种针对微分的PID如下：

不完全微分PID

这里针对微分的PID控制算法，是减少微分作用的副作用的一些算法，以便更好地利用微分作用的作用。我们知道，当系统引入微分作用得时候会，引进高频干扰。为了抑制这种干扰，便引入低通滤波器。

这种滤波器得优缺点

优点：

对周期性干扰具有良好的抑制作用

适用于波动频率较高的场合

缺点：

相位滞后，灵敏度低

滞后程度取决于a值大小

不能消除滤波频率高于采样频率的1/2的干扰信号

应用：对于诸如阶跃信号等信号变化很大信号。采用不完全微分能够使得微分作用更为持续平缓。

控制图：

图片

位置式PID不完全微分：

公式：

图片

增量式PID不完全微分：

公式：

图片

//PID结构体typedef struct{   volatile float    Proportion;             // 比例常数 Proportional Const   volatile float    Integral;               // 积分常数 Integral Const   volatile float    Derivative;             // 微分常数 Derivative Const   volatile int      Error1;                 // Error[n-1]   volatile int      Error2;                 // Error[n-2]   volatile int      iError;                 // Error[n]   volatile  int     Error_sum;   volatile  float    thisdev;//前一拍时的微分项值   volatile  float    lastdev ;//前一拍时的微分项值   float        dev_per;//微分系数   } PID;
//位置式PID不完全微分float PID_Postion (int iError,PID* sptr) {  float  iIncpid=0;  sptr->iError=iError;                                      // 计算当前误差  sptr->Error_sum+=sptr->iError;//积分项  //不完全微分    sptr->thisdev=sptr->Derivative*(1-sptr->dev_per)*(sptr->iError-sptr->Error1)+sptr->dev_per*sptr->lastdev;    iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum                // I         +sptr->thisdev; // D   //更新值  sptr->Error1=sptr->iError;            sptr->lastdev=sptr->thisdev;//更新下次微分值    return(iIncpid);          // 返回计算值  }
//增量式PID不完全微分float PID_increase(int iError,PID* sptr) {    float  iIncpid=0;  sptr->iError=iError;//直接检测当前偏差    sptr->thisdev=sptr->Derivative*(1-sptr->dev_per)*(sptr->iError-2*sptr->Error1+sptr->Error2)+sptr->dev_per*sptr->lastdev;    iIncpid=sptr->Proportion * (sptr->iError-sptr->Error1)                  // P         +sptr->Integral * sptr->iError                                   // I         +sptr->thisdev;  // D       //更新           sptr->Error2=sptr->Error1;                            sptr->Error1=sptr->iError;  sptr->lastdev=sptr->thisdev;//更新下次微分值    return(iIncpid);   // 返回增量值  }

微分先行PID

控制器采用PI控制，将微分作用移动到反馈回路上。微分作用直接对被控量进行微分，对被控量速度进行控制。

优点：在给定值频繁变化的情况下，优先采用微分先行的控制方案能够更迅速的反应，对变化更为敏感。

缺点：更为敏感也就意味着更加不稳定，变化量比较大的情况下，微分作用过分凸显，容易导致超调，引起系统振荡加大。

图示：

图片

对微分部分引入一阶惯性滤波器，进行离散化后的公式：

位置式：

图片

图片

  增量式：

图片

C语言实现：

//PID结构体//位置式typedef struct{   volatile float   Proportion;             // 比例常数 Proportional Const   volatile float   Integral;               // 积分常数 Integral Const   volatile float   Derivative;             // 微分常数 Derivative Const   volatile int     Error1;                 // Error[n-1]   volatile int     Error2;                 // Error[n-2]   volatile int     iError;                 // Error[n]   volatile  int    Error_sum;      volatile   float  lastPv;             //前一拍的测量值   volatile   float  gama;               //微分先行滤波系数   volatile   float  derivative;//微分项      } PID;
//位置式微分先行PIDfloat PID_Postion (float set_point,float processValue,PID* sptr) {  float  iIncpid=0;  float  temp=0,c1,c2,c3;  sptr->iError=set_point-processValue;                                      // 计算当前误差  sptr->Error_sum+=sptr->iError;//积分项  //微分先行  temp=sptr-> gama * sptr-> Derivative+ sptr-> Proportion;//γKp+Kd  c3=sptr-> Derivative/temp;//Kd/γKp+Kd  c2=(sptr-> Derivative+ sptr-> Proportion)/temp;//Kd+Kp/γKp+Kd  c1=c3*sptr-> gama;//γ(Kp/γKp+Kd)    sptr-> derivative=c1* sptr-> derivative+c2*processValue-c3* sptr-> lastPv;
  iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum                // I         +sptr->derivative; // D   //更新值  sptr->Error1=sptr->iError;            sptr->lastPv=sptr->processValue;//更新下次微分值    return(iIncpid);          // 返回计算值  }
//***********************************************************////              增量式微分先行PID//***********************************************************////增量式PID结构体typedef struct{   volatile float   Proportion;             // 比例常数 Proportional Const   volatile float   Integral;               // 积分常数 Integral Const   volatile float   Derivative;             // 微分常数 Derivative Const   volatile int     Error1;                 // Error[n-1]   volatile int     iError;                 // Error[n]   volatile   float  lastout;   //上一次的测量量     volatile   float  lastout_proinc;                 //前一拍的过程测量增量   volatile   float  gama;                  //微分先行滤波系数   volatile   float  out_proinc;         //过程测量增量   volatile   float  derivative_inc;    //微分项      } PID;
//增量式PID不完全微分PID_increasefloat PID_increase(float set_point,float processValue,PID* sptr) {  float  iIncpid=0;  float  temp=0,c1,c2,c3;  sptr->iError=set_point-processValue;                                         // 计算当前误差  //微分先行    out_proinc=processValue-lastout;//这次输出增量      temp=sptr-> gama * sptr-> Derivative+ sptr-> Proportion;//γKp+Kd  c3=sptr-> Derivative/temp;//Kd/γKp+Kd  c2=(sptr-> Derivative+ sptr-> Proportion)/temp;//Kd+Kp/γKp+Kd  c1=c3*sptr-> gama;//γ(Kp/γKp+Kd)    sptr-> derivative_inc=c1* sptr-> derivative_inc+c2*out_proinc-c3* sptr-> lastout_proinc;
  iIncpid=sptr->Proportion * (sptr->iError-sptr->               Error1)// P         +sptr->Integral * sptr->iError// I         +sptr->derivative_inc; // D   //更新值  sptr->Error1=sptr->iError;  sptr->lastout_proinc=sptr->out_proinc;//过程增量更新            sptr->lastout=processValue;//上一次的测量量更新    return(iIncpid);          // 返回增量值}

带死区的PID

死区控制简单理解：

死区，就是到了一个区域，在这个区域内，PID算法不起作用，也就是不做控制。

图片

优势：

可以抑制由于控制器输出量的量化造成的连续的较小的振荡，也就是消除稳定点附近的抖动。这是因为，现实中，总存在误差，一些较小误差难以消除。

缺点：

会造成一定的滞后。设定死区的值也是需要考虑，太小每作用，太大滞后严重。在零点附近时，若偏差很小，进入死去后，偏差置0会造成积分消失，如是系统存在静差将不能消除，所以需要人为处理这一点。

应用：

减少机械磨损，延长设备寿命等。

总结来说：PID调节器中设置死区，牺牲的是调节精度，换来的是稳定性。适用于精度不是很高的系统。

死区的输出为0时，pid控制器的比例部分和微分部分均为0，积分部分保持不变。虽然误差值在死区宽度设置的范围内变化，控制器的输出却保持不变。

C语言实现：

#define DEAD_BAND 50//死区控制值   #define PID_OUT_MAX 200 //PID输出上限#define PID_OUT_MAX 200 //PID输出上限
#include "math.h"           //PID结构体typedef struct{   volatile float    Proportion;             // 比例常数 Proportional Const   volatile float    Integral;               // 积分常数 Integral Const   volatile float    Derivative;             // 微分常数 Derivative Const   volatile int      Error1;                 // Error[n-1]   volatile int      Error2;                 // Error[n-2]   volatile int      iError;                 // Error[n]   volatile  int     Error_sum;} PID
/****************************************************************************************/                                                        //                位置式PID//                    //pwm=Kp*e(k)+Ki*∑e(k)+Kd[e（k）-e(k-1)]  /****************************************************************************************/float PID_Postion (float set_point,,float now_point,PID* sptr) {  float  iIncpid=0;  sptr->iError=now_point-set_point; // 计算当前误差  //死区控制算法                                       if(fabs(sptr->iError)>DEAD_BAND)   {  sptr->Error_sum+=sptr->iError;//积分项        iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum                // I         +sptr->Derivative * (sptr->iError-sptr->Error1); // D  sptr->Error1=sptr->iError ;          // 存储误差，用于下次计算
  }    else   {    iIncpid=0;    //sptr->Error_sum+=sptr->iError;//积分项        sptr->Error1=sptr->iError;  // 存储误差，用于下次计算  }        return(iIncpid);          // 返回计算值                  }
/****************************************************************************************/                                    //增量式PID                                            //        pwm+=Kp[e（k）-e(k-1)]+Ki*e(k)+Kd[e(k)-2e(k-1)+e(k-2)]                                      ///****************************************************************************************/float PID_increase(int iError,PID* sptr) {    float  iIncpid=0;  sptr->iError=iError;//直接检测当前偏差  if(fabs(sptr->iError)>DEAD_BAND)   {  iIncpid=sptr->Proportion * (sptr->iError-sptr->Error1)                  // P         +sptr->Integral * sptr->iError                                   // I         +sptr->Derivative * (sptr->iError-2*sptr->Error1+sptr->Error2);  // D               sptr->Error2=sptr->Error1;                          // 存储误差，用于下次计算  sptr->Error1=sptr->iError;
}else {  iIncpid=0;//输出增量值为0  sptr->Error2=sptr->Error1; // 存储误差，用于下次计算                           sptr->Error1=sptr->iError;}  return(iIncpid);   // 返回增量值  }

PID梯形积分

积分会有余差，消除不了，为了减少余差，提高运算的精度。便有了PID梯形积分，也能抑制一些随机干扰。

缺点便是，曲线到达设定值的时间会延长。

总的来说：也就积分的作用削弱了。带来的是余差进一步减小。

图片

C语言实现：

typedef struct{   volatile float    Proportion;             // 比例常数 Proportional Const   volatile float    Integral;               // 积分常数 Integral Const   volatile float    Derivative;             // 微分常数 Derivative Const   volatile int      Error1;                 // Error[n-1]   volatile int      Error2;                 // Error[n-2]   volatile int      iError;                 // Error[n]   volatile  int     Error_sum;} PID
/****************************************************************************************/                                                        //                位置式PID//                    //pwm=Kp*e(k)+Ki*∑e(k)+Kd[e（k）-e(k-1)]  /****************************************************************************************/float PID_Postion (float set_point,,float now_point,PID* sptr) {  float  iIncpid=0;  sptr->iError=now_point-set_point; // 计算当前误差  //死区控制算法                                       sptr->Error_sum+=sptr->iError;//积分项        iIncpid=sptr->Proportion * sptr->iError                  // P         +sptr->Integral * sptr->Error_sum/2                // 改变的只是这里，多除了2         +sptr->Derivative * (sptr->iError-sptr->Error1); // D  sptr->Error1=sptr->iError ;          // 存储误差，用于下次计算
      return(iIncpid);          // 返回计算值                  }

总结

PID的变体还有很多，除了上文，还有专家PID与模糊PID是本文不能承载，也是我不能输出，便作罢。

事物都有两面性，该怎么选择比较合适，怎么将PID的各种变体组合在一起合适自己的系统，这个是需要综合衡量和测试的，要知其然知其所以然。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1364516.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

PMP过了就是中级职称？

PMP过了就是中级职称？

&#x1f33b;PMP项目管理专业人士认证在全球范围内受到广泛认可&#xff0c;许多人就误以为获得PMP证书就等同于获得中级职称。但是&#xff0c;事实真的如此吗❓ 1️⃣PMP不属于职称认证 ✅PMP证书&#xff1a; 是由美国项目管理协会(PMI)颁发的专业认证&#xff0c;旨在证明…
阅读更多...
GeoServer发布地图服务（WMS、WFS）

GeoServer发布地图服务（WMS、WFS）

文章目录 1. 概述2. 矢量数据源3. 栅格数据源 1. 概述 我们知道将GIS数据大致分成矢量数据和栅格数据&#xff08;地形和三维模型都是兼具矢量和栅格数据的特性&#xff09;。但是如果用来Web环境中&#xff0c;那么使用图片这个栅格形式的数据载体无疑是最为方便的&#xff0…
阅读更多...
入库和出库的成本对不上如果如何解决

入库和出库的成本对不上如果如何解决

入库是前期手工录入的车价是对的&#xff0c;出库是根据销售出库单生成的 入库成本和出库成本不一致的解决方法 解决方法&#xff1a; 整车管理——正车库存——库存核算——整车出库 成本核算
阅读更多...
FC SAN光纤交换机维护介绍

FC SAN光纤交换机维护介绍

一、什么是FC SAN &#xff1f; ​存储区域网络&#xff08;Storage Area Network&#xff0c;SAN&#xff09;采用网状通道&#xff08;Fibre Channel &#xff0c;简称FC&#xff0c;区别与Fiber Channel光纤通道&#xff09;技术&#xff0c;通过FC交换机连接存储阵列和服务…
阅读更多...
QT上位机开发（会员充值软件）

QT上位机开发（会员充值软件）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 所有的控件当中&#xff0c;除了label、edit、radio、combobox和button之外&#xff0c;另外一个用的比较多的控件就是grid&#xff0c;也可称之为…
阅读更多...
李沐-《动手学深度学习-02-目标检测

李沐-《动手学深度学习-02-目标检测

一 、目标检测算法 1. R-CNN a . 算法步骤 使用启发式搜索算法来选择锚框&#xff08;选出多个锚框大小可能不一&#xff0c;需要使用Rol pooling&#xff09;使用预训练好的模型&#xff08;去掉分类层&#xff09;对每个锚框进行特征抽取&#xff08;如VGG,AlexNet…)训练…
阅读更多...
CAD安装教程

CAD安装教程

CAD安装教程 目录 一&#xff0e; 下载CAD二&#xff0e; 安装CAD 一&#xff0e; 下载CAD 如果需要CAD安装包请私信。 二&#xff0e; 安装CAD 解压压缩包AutoCAD2022中文版&#xff0c;以管理员身份运行AutoCAD_2022_Simplified_Chinese_Win_64bit_dlm.sfx。 选择解压路径。…
阅读更多...
DockerUI本地如何部署并结合内网穿透实现远程访问管理界面

DockerUI本地如何部署并结合内网穿透实现远程访问管理界面

文章目录 前言1. 安装部署DockerUI2. 安装cpolar内网穿透3. 配置DockerUI公网访问地址4. 公网远程访问DockerUI5. 固定DockerUI公网地址 前言 DockerUI是一个docker容器镜像的可视化图形化管理工具。DockerUI可以用来轻松构建、管理和维护docker环境。它是完全开源且免费的。基…
阅读更多...
NACHI机器人虚拟示教器报I2101异常

NACHI机器人虚拟示教器报I2101异常

前言 机器人示教器报&#xff1a;I2101 异常停止按钮或外部停止信号被输入 无法再示教模式下进行程序的运行&#xff01; 解决方法 结果 最后测试可以正常的运行程序
阅读更多...
大模型实战营Day2 轻松玩转书生·浦语大模型趣味Demo

大模型实战营Day2 轻松玩转书生·浦语大模型趣味Demo

大模型&#xff1a;参数数量巨大&#xff0c;拥有庞大计算能力和参数规模的模型 InternLM &#xff1a;是一个开源的轻量级训练框架&#xff0c;旨在支持模型预训练&#xff0c;而无需广泛的依赖关系。通过单一代码库&#xff0c;它支持在具有数千个 GPU 的大规模集群上进行预训…
阅读更多...
Spark回归分析与特征工程

Spark回归分析与特征工程

回归分析是统计学和机器学习中的一个重要分支&#xff0c;用于建立因变量与自变量之间的关系模型。在大数据领域&#xff0c;Apache Spark为回归分析提供了强大的工具和库&#xff0c;以处理大规模数据集。本文将深入探讨如何使用Spark进行回归分析以及如何进行特征工程&#x…
阅读更多...
论文阅读记录SuMa SuMa++

论文阅读记录SuMa SuMa++

首先是关于SuMa的阅读&#xff0c;SuMa是一个完整的激光SLAM框架&#xff0c;核心在于“基于面元(surfel)”的过程&#xff0c;利用3d点云转换出来的深度图和法向量图来作为输入进行SLAM的过程&#xff0c;此外还改进了后端回环检测的过程&#xff0c;利用提出的面元的概念和使…
阅读更多...
软件测试|Windows系统安装Cypress教程

软件测试|Windows系统安装Cypress教程

前言 每当提起web自动化测试&#xff0c;大家首先想到的就是selenium&#xff0c;最近这两年时间&#xff0c;出现了playwright和cypress这两款新的工具&#xff0c;不过现在应用范围还是不如selenium&#xff0c;之前我们介绍了playwright的使用&#xff0c;现在开始&#xf…
阅读更多...
【c++】list的特性及使用

【c++】list的特性及使用

目录 一、list的介绍 二、list的深度剖析与模拟实现 1、list图解 2、list增删查改模拟实现 三、list与vector的对比 一、list的介绍 STL中的list指的是带头双向循环链表。list是可以在常数范围内任意位置进行插入和删除的序列式容器&#xff0c;并且可以前后双向迭代。lis…
阅读更多...
【AI视野·今日CV 计算机视觉论文速览 第283期】Thu, 4 Jan 2024

【AI视野·今日CV 计算机视觉论文速览 第283期】Thu, 4 Jan 2024

AI视野今日CS.CV 计算机视觉论文速览 Thu, 4 Jan 2024 Totally 85 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computer Vision Papers LEAP-VO: Long-term Effective Any Point Tracking for Visual Odometry Authors Weirong Chen, Le Chen, Rui Wang, Marc P…
阅读更多...
大数据可视化Web框架——飞致云Dataease在Windows端的安装指南（多图说明版）V2.2最新版

大数据可视化Web框架——飞致云Dataease在Windows端的安装指南（多图说明版）V2.2最新版

DataEase开源代码在Windows系统开发环境搭建与调试指南_怎么部署dataease 2.0-CSDN博客https://blog.csdn.net/tllhc01/article/details/135220598?spm1001.2014.3001.5502参考这一篇&#xff0c;基于dataease2.2源码进行构建 需要先下载三个文件&#xff0c;且版本一一对应均…
阅读更多...
性能分析与调优: Linux 监测工具的数据来源

性能分析与调优: Linux 监测工具的数据来源

目录 一、实验 1.环境 2. proc目录 3. sys目录 4.netlink 5.tracepoint 6.kprobes 7. uprobes 二、问题 1.systemd如何查看启动时间 2.CentOS与Ubuntu如何安装bpftrace 3.snap有哪些常用的命令 4.snap如何安装store 5.如何列出使用bpftracede的OpenJDK USDT探针 …
阅读更多...
机器学习笔记：时间序列异常检测

机器学习笔记：时间序列异常检测

1 异常类型 1.1 异常值outlier 给定输入时间序列&#xff0c;异常值是时间戳值其中观测值与该时间序列的期望值不同。 1.2 波动点&#xff08;Change Point&#xff09; 给定输入时间序列&#xff0c;波动点是指在某个时间t&#xff0c;其状态在这个时间序列上表现出与t前后…
阅读更多...
基于JSP+Servlet+Mysql的学生信息管理系统

基于JSP+Servlet+Mysql的学生信息管理系统

基于JSPServletMysql的学生信息管理系统 一、系统介绍二、功能展示1.目录2.数据库3.登陆4.注册5.主页 四、其它1.其他系统实现五.获取源码 一、系统介绍 项目名称&#xff1a;基于JSPServletMysql的学生信息管理系统 项目架构&#xff1a;B/S架构 开发语言&#xff1a;Java语…
阅读更多...
Web前端-JavaScript（BOM)

Web前端-JavaScript（BOM)

文章目录 1.1 常用的键盘事件1.1.1 键盘事件1.1.2 键盘事件对象1.1.3 案例一 1.2 BOM1.2.1 什么是BOM1.2.2 BOM的构成1.2.3 window1.2.4 window对象常见事件窗口/页面加载事件**第1种****第2种** 调整窗口大小事件 1.2.5 定时器setTimeout() 炸弹定时器停止定时器**案例&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023