精华内容
下载资源
问答
  • DL之模型调参:深度学习算法模型优化参数LSTM算法进行超参数调优 ...3、基于keras的LSTM算法依次超参进行网格搜索 3.1、LSTM算法网格搜索最佳n_cells 3.2、LSTM算法网格搜索最佳隐藏层数量

    DL之模型调参:深度学习算法模型优化参数之对LSTM算法进行超参数调优

     

    目录

    基于keras对LSTM算法进行超参数调优

    1、可视化LSTM模型的loss和acc曲线

    2、可视化LSTM模型来判断拟合

    2.1、判断过拟合—训练集很好、测试集很差,过分依赖训练数据造成

    2.2、判断欠拟合—训练集很差、测试集也很差,没法很好的学习到数据背后的规律

    3、基于keras中的LSTM算法依次对超参进行网格搜索

    3.1、LSTM算法网格搜索最佳n_cells

    3.2、LSTM算法网格搜索最佳隐藏层数量

    3.3、LSTM算法网格搜索最佳权重初始化

    3.4、LSTM算法网格搜索最佳激活函数

    4、LSTM算法的调优学习行为

    4.1、LSTM算法网格搜索最佳优化算法

    4.2、LSTM算法网格搜索最佳学习率

    4.3、LSTM算法网格搜索最佳batch_size

    4.4、LSTM算法的正则化策略

    4.5、LSTM算法的训练周期策略


     


    相关文章
    DL之模型调参:深度学习算法模型优化参数之对深度学习模型的超参数采用网格搜索进行模型调优(建议收藏)
    DL之模型调参:深度学习算法模型优化参数之基于keras对LSTM算法进行超参数调优

     

    基于keras对LSTM算法进行超参数调优

    1、可视化LSTM模型的loss和acc曲线

             如果模型被编译来优化对数损失(binary_crossentropy)并衡量每个周期的准确率,那么对数损失和准确率将被计算并记录在每个训练周期的历史轨迹中。

    model.compile(loss= 'binary_crossentropy' , optimizer= adam , metrics=[ 'accuracy' ]) 
    history = model.fit(X, Y, epochs=100)
    history = model.fit(X, Y, epochs=100, validation_split=0.33)  #将训练数据的一部分用作验证数据集
    history = model.fit(X, Y, epochs=100, validation_data=(valX, valY))  #通过设置验证数据参数和传递X和y数据集的元组来实现
    
    
    print(history.history[ 'loss' ]) 
    print(history.history[ 'acc' ])
    print(history.history[ 'val_loss' ])
    print(history.history[ 'val_acc' ])
    
    
    
    
    from matplotlib import pyplot
    ... 
    history = model.fit(X, Y, epochs=100, validation_data=(valX, valY)) pyplot.plot(history.history[ loss ]) 
    pyplot.plot(history.history[ val_loss ]) 
    pyplot.title( 'model train vs validation loss' ) 
    pyplot.ylabel( 'loss' ) 
    pyplot.xlabel( 'epoch' ) 
    pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' ) 
    pyplot.show()

     

     

    2、可视化LSTM模型来判断拟合

    2.1、判断过拟合—训练集很好、测试集很差,过分依赖训练数据造成

           一个假设在训练数据上能够获得比其他假设更好的拟合, 但是在训练数据外的数据集上却不能很好地拟合数据,此时认为这个假设出现了过拟合的现象。出现这种现象的主要原因是训练数据中存在噪音或者训练数据太少。

    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    from matplotlib import pyplot
    from numpy import array
    # return training data
    def get_train():
        seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((5, 1, 1))
        return X, y
    # return validation data
    def get_val():
        seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((len(X), 1, 1))
        return X, y
    # define model
    model = Sequential()
    model.add(LSTM(10, input_shape=(1,1)))
    model.add(Dense(1, activation= 'linear' ))
    # compile model
    model.compile(loss= 'mse' , optimizer= 'adam' )
    # fit model
    X,y = get_train()
    valX, valY = get_val()
    history = model.fit(X, y, epochs=1200, validation_data=(valX, valY), shuffle=False)
    # plot train and validation loss
    pyplot.plot(history.history[ 'loss' ][500:])
    pyplot.plot(history.history[ 'val_loss' ][500:])
    pyplot.title( 'model train vs validation loss' )
    pyplot.ylabel( 'loss' )
    pyplot.xlabel( 'epoch' )
    pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )
    pyplot.show()

     

     

     

    2.2、判断欠拟合—训练集很差、测试集也很差,没法很好的学习到数据背后的规律

           机器学习中一个重要的话题便是模型的泛化能力,泛化能力强的模型才是好模型,对于训练好的模型,若在训练集表现差,在测试集表现同样会很差,这可能是欠拟合导致。欠拟合是指模型拟合程度不高,数据距离拟合曲线较远,或指模型没有很好地捕捉到数据特征,不能够很好地拟合数据。

    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    from matplotlib import pyplot
    from numpy import array
    # return training data
    def get_train():
        seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((len(X), 1, 1))
        return X, y
    # return validation data
    def get_val():
        seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((len(X), 1, 1))
        return X, y
    # define model
    model = Sequential()
    model.add(LSTM(10, input_shape=(1,1)))
    model.add(Dense(1, activation= 'linear' ))
    # compile model
    model.compile(loss= 'mse' , optimizer= 'adam')
    # fit model
    X,y = get_train()
    valX, valY = get_val()
    history = model.fit(X, y, epochs=100, validation_data=(valX, valY), shuffle=False)
    # plot train and validation loss
    pyplot.plot(history.history[ 'loss' ])
    pyplot.plot(history.history[ 'val_loss' ])
    pyplot.title( 'model train vs validation loss' )
    pyplot.ylabel( 'loss' )
    pyplot.xlabel( 'epoch' )
    pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )
    pyplot.show()

     

    3、基于keras中的LSTM算法依次对超参进行网格搜索

    3.1、LSTM算法网格搜索最佳n_cells

           对于给定的序列预测问题或者LSTM体系结构,我们不能知道存储单元的最佳数目是多少。必须在LSTM隐藏层中测试一组不同的存储单元,以查看哪些工作最有效。

    • 尝试网格搜索存储单元的数目为100s、10s或者更细;
    • 尝试事宜在研究论文中引用的单元数量;
    • 尝试随机搜索1到1000之间的单元格数量。
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    from matplotlib import pyplot
    from pandas import DataFrame
    from numpy import array
    # return training data
    def get_train():
        seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((5, 1, 1))
        return X, y
    # return validation data
    def get_val():
        seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((len(X), 1, 1))
        return X, y
    # fit an LSTM model
    def fit_model(n_cells):
        # define model
        model = Sequential()
        model.add(LSTM(n_cells, input_shape=(1,1)))
        model.add(Dense(1, activation= 'linear' ))
        # compile model
        model.compile(loss= 'mse' , optimizer= 'adam' )
        # fit model
        X,y = get_train()
        history = model.fit(X, y, epochs=500, shuffle=False, verbose=0)
        # evaluate model
        valX, valY = get_val()
        loss = model.evaluate(valX, valY, verbose=0)
        return loss
    # define scope of search
    params = [1, 5, 10]
    n_repeats = 5
    # grid search parameter values
    scores = DataFrame()
    for value in params:
        # repeat each experiment multiple times
        loss_values = list()
        for i in range(n_repeats):
            loss = fit_model(value)
            loss_values.append(loss)
            print( '>%d/%d param=%f, loss=%f' % (i+1, n_repeats, value, loss))
        # store results for this parameter
        scores[str(value)] = loss_values
    # summary statistics of results
    print(scores.describe())
    # box and whisker plot of results
    scores.boxplot()
    pyplot.show()
    
    
    
    >1/5 param=1.000000, loss=0.047335
    >2/5 param=1.000000, loss=0.146885
    >3/5 param=1.000000, loss=0.104599
    >4/5 param=1.000000, loss=0.345472
    >5/5 param=1.000000, loss=0.115182
    >1/5 param=5.000000, loss=0.020112
    >2/5 param=5.000000, loss=0.084113
    >3/5 param=5.000000, loss=0.042612
    >4/5 param=5.000000, loss=0.070742
    >5/5 param=5.000000, loss=0.038660
    >1/5 param=10.000000, loss=0.040568
    >2/5 param=10.000000, loss=0.009704
    >3/5 param=10.000000, loss=0.064492
    >4/5 param=10.000000, loss=0.017800
    >5/5 param=10.000000, loss=0.012813
                  1         5        10
    count  5.000000  5.000000  5.000000
    mean   0.151895  0.051248  0.029075
    std    0.114033  0.025801  0.023202
    min    0.047335  0.020112  0.009704
    25%    0.104599  0.038660  0.012813
    50%    0.115182  0.042612  0.017800
    75%    0.146885  0.070742  0.040568
    max    0.345472  0.084113  0.064492

     

    3.2、LSTM算法网格搜索最佳隐藏层数量

             与存储单元的数目一样,对于给定的序列预测问题或LSTM体系结构,我们不能知道LSTM隐藏层的最佳数量。当你有很多数据时,越深越好。

    • 尝试一起网格搜索层数和存储单元;
    • 尝试使用堆叠LSTM层在研究论文中引用的模式;
    • 尝试一起随机搜索层数和存储单元。

     

     

    3.3、LSTM算法网格搜索最佳权重初始化

             Keras的LSTM层默认使用 glorot_uniform做权重的初始化。总体来说,这个权重初始化运行得很好,但是我已经使用LSTM的正常类型权重初始化取得了很大的成功。评估不同的权重初始化方案对您的模型技能的影响。Keras提供了一个很好的权重初始化列表供您尝试。至少,比较这始终方法的技巧:

    • random_uniform
    • random_normal
    • glorot_uniform
    • glorot_normal

     

    3.4、LSTM算法网格搜索最佳激活函数

             激活函数(技术上是传递神经元的加权激活时的传递函数)通常由输入层或输出层的框架和尺度来固定。例如,LSTM使用sigmoid激活函数作为输入并且因此输入通常在0-1的刻度中。序列预测问题的分类或者回归性质决定了在输出层中使用激活函数的类型。挑战LSTM层中默认的sigmoid激活函数。也许在重新调整输入值的同时,尝试使用其他的方法。例如,尝试:

    • sigmoid
    • tanh
    • relu

             此外,挑战在一个stacked LSTM中所有的LSTM层是否需要使用相同的激活函数。在实践中,我很少看到一个模型比使用sigmoid更好,但是这个假设应该需要得到证实。

     

     

    4、LSTM算法的调优学习行为

    4.1、LSTM算法网格搜索最佳优化算法

           梯度下降的一个很好的默认实现是用Adam算法。这是因为它结合AdaGrad和RMSProp方法的最佳属性自动为模型中的每个参数(权重)使用自定义学习率。此外,在Keras中使用每个配置参数的最佳实践初始值实现Adam。然而,挑战Adam是你的模型的正确的梯度下降算法。用不同的梯度下降算法评估模型的性能。现代算法的一些思想包括:

    • Adam
    • RMSprop
    • Adagrad

     

    4.2、LSTM算法网格搜索最佳学习率

           学习率控制权重更新多少,作为在每个批次结束时响应估计的梯度。这会对模型的学习率和模型之间的权衡产生很大的影响。考虑使用经典随机梯度下降(SGD)优化器,并探索不同的学习率和动量值,你可以评估不同的学习率的制度。

    • 网格搜索学习速率值(例如0.1, 0.001、0.0001);
    • 学习速率衰减的周期(epoch)的实验(例如通过回调);
    • 训练模型更新与训练的学习率越来越小的实验。

           学习率和周期(通过训练样本的传递次数)紧密耦合。一般来说,学习率(例如0.0001)越小,就需要更多的训练周期。这是一个线性关系,所以反过来也是正确的,在更大的学习率需要更少的周期(例如0.1)。

     

    4.3、LSTM算法网格搜索最佳batch_size

           批次大小是模型权重更新之间的样本数。一个默认批次大小是32个样本。批次大小典型的选择是从1到几千,例如批次大小为32是一个好的默认值,利用矩阵成绩加速到矩阵向量乘积的值大于10。
    — Practical Recommendations For Gradient-based Training Of Deep Architectures, 2012.

           序列预测问题的数据量和帧的大小可能取决于批次大小的选择。然而,挑战你的最佳猜想并尝试一些替代的配置。

    • 随机梯度下降的批次大小为1;
    • 批次大小为n,其中n是批次梯度下降的样本数;
    • 网格搜索批大小为2的平方,从2到256不等。

           较大的批次大小通吃会导致模型更快收敛,但可能会导致一个不太理想的权重集。批次大小为1(随机梯度下降)更新后,每个样本往往导致非常嘈杂的学习过程。下面是网格搜索的一个小例子,该批次大小为1、2和3,具有少量的重复(5)。你可以用这个例子作为自己试验的模板。

    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    from matplotlib import pyplot
    from pandas import DataFrame
    from numpy import array
    # return training data
    def get_train():
        seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((5, 1, 1))
        return X, y
    # return validation data
    def get_val():
        seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]
        seq = array(seq)
        X, y = seq[:, 0], seq[:, 1]
        X = X.reshape((len(X), 1, 1))
        return X, y
    # fit an LSTM model
    def fit_model(n_batch):
        # define model
        model = Sequential()
        model.add(LSTM(10, input_shape=(1,1)))
        model.add(Dense(1, activation= 'linear' ))
        # compile model
        model.compile(loss= 'mse' , optimizer= 'adam' )
        # fit model
        X,y = get_train()
        history = model.fit(X, y, epochs=500, shuffle=False, verbose=0, batch_size=n_batch)
        # evaluate model
        valX, valY = get_val()
        loss = model.evaluate(valX, valY, verbose=0)
        return loss
    # define scope of search
    params = [1, 2, 3]
    n_repeats = 5
    # grid search parameter values
    scores = DataFrame()
    for value in params:
        # repeat each experiment multiple times
        loss_values = list()
        for i in range(n_repeats):
            loss = fit_model(value)
            loss_values.append(loss)
            print( '>%d/%d param=%f, loss=%f' % (i+1, n_repeats, value, loss))
        # store results for this parameter
        scores[str(value)] = loss_values
    # summary statistics of results
    print(scores.describe())
    # box and whisker plot of results
    scores.boxplot()
    pyplot.show()
    
    
    >1/5 param=1.000000, loss=0.000524
    >2/5 param=1.000000, loss=0.003064
    >3/5 param=1.000000, loss=0.000918
    >4/5 param=1.000000, loss=0.001103
    >5/5 param=1.000000, loss=0.002519
    >1/5 param=2.000000, loss=0.000851
    >2/5 param=2.000000, loss=0.000069
    >3/5 param=2.000000, loss=0.000339
    >4/5 param=2.000000, loss=0.000048
    >5/5 param=2.000000, loss=0.001156
    >1/5 param=3.000000, loss=0.013446
    >2/5 param=3.000000, loss=0.001138
    >3/5 param=3.000000, loss=0.006436
    >4/5 param=3.000000, loss=0.002005
    >5/5 param=3.000000, loss=0.011653
                  1         2         3
    count  5.000000  5.000000  5.000000
    mean   0.001626  0.000493  0.006936
    std    0.001102  0.000492  0.005541
    min    0.000524  0.000048  0.001138
    25%    0.000918  0.000069  0.002005
    50%    0.001103  0.000339  0.006436
    75%    0.002519  0.000851  0.011653
    max    0.003064  0.001156  0.013446

     

    4.4、LSTM算法的正则化策略

           在某些序列预测问题上,LSTM可以快速收敛,甚至过拟合。为了解决这个问题,可以使用正则化方法。Dropout在训练过程随机跳过神经元,迫使该层中的其他神经元来收拾残局。它简单有效。从dropout开始。Dropout率在0(不dropout)和1(完全dropout)之间,可以在通过两个不同的参数在LSTM层上设置:

    • dropout。dropout应用于输入连接。

    • recurrent_dropout。dropout应用于循环连接。

    model.add(LSTM(..., dropout=0.4))

           用输入连接dropout添加一层的例子,一些需要去尝试的例子包括:

    • 网格搜索不同的dropout百分比;
    • 在输入、隐藏和输出层中进行dropout实验。

           LSTM还支持其他形式的正则化,如权重规则化,施加压力以减少网络权重的大小。同样,这些参数可以在LSTM层上设置:

    • 偏置正则化:对偏置的正则化;
    • 核正则化:对输入权重的正则化;
    • 循环正则化:对循环权重的正则化。

           可以使用正则化类,如L1、L2或者L1L2正则化,而不是dropout的百分比。我建议使用L1L2,使用0和1之间的值,也允许模拟T1和T2方法。例如,你可以试试:

    • L1L2(0.0, 0.0),例如,基准线或者无正则化;
    • L1L2(0.01, 0.0),例如,L1;
    • L1L2(0.0, 0.01),例如,L2;
    • L1L2(0.01, 0.01),例如,L1L2也称为弹性网。
    model.add(LSTM(..., kernel_regularizer=L1L2(0.01, 0.01)))

     

    4.5、LSTM算法的训练周期策略

           训练周期的数量调优会非常的耗时间。另外一种方法是使大量的训练周期(epoch)称为可能。然后设置一些东西来检查模型在训练和验证数据集上的性能,如果模型看起来开始过度学习,停止训练。因此,早期停止是一种正则化,以抑制过度拟合。

           你可以在Keras的早期停止实验中用一个EarlyStopping回调。它需要你指定一些参数配置,例如用于监视的度量(例如val-损失),在所观察到的次数上没有到的监视度量的改进(例如100)。在对模型进行训练时,将回调列表提供给fit()函数。例如:

    from keras.callbacks import EarlyStopping
    
    es = EarlyStopping(monitor= val_loss , min_delta=100) model.fit(..., callbacks=[es])

     

     

     

    参考文章:
    邵洲,如何使用学习曲线来诊断你的LSTM模型的行为

     

     

     

     

    展开全文
  • PID 算法参数及调节

    千次阅读 2019-10-03 12:08:40
    PID算法原理 一图看懂PID的三个参数 PID算法实现及参数整定图解(附代码) https://www.cnblogs.com/whylinux/p/10960319.html 公式 PID控制应该算是应用非常广泛的控制算法了。小到控制一个元件的温度,大到...

    我学习PID参数意义,参考了以下文章:

    一文读懂PID控制算法(抛弃公式,从原理上真正理解PID控制)

    PID算法原理 一图看懂PID的三个参数

    PID算法实现及参数整定图解(附代码)

    https://www.cnblogs.com/whylinux/p/10960319.html

    公式

    PID控制应该算是应用非常广泛的控制算法了。小到控制一个元件的温度,大到控制无人机的飞行姿态和飞行速度等等,都可以使用PID控制。这里我们从原理上来理解PID控制。
    PID,就是“比例(proportional)、积分(integral)、微分(derivative)”,是一种很常见的控制算法。

    U(t)=Kp*Err(t)+Ki*\sum Err(t)/T +Kd* \frac{dErr(t)}{dt}

    Kp, Ki, Kd 分别是比例P, 积分I, 微分D的参数。

    参数含义:

    PID调节实际上是由比例、积分、微分三种调节方式组成,它们各自的作用如下:

    1.比例系数P是干什么用,其实如果现在你是初中生的话,你一下子就懂了,比例系数就是用在穿过(0,0)这个坐标点直线的放大倍数k,k越大,直线的斜率越大,所以是用在y = k * x中的,其中的k就是比例系数p,大家都简称为kp,所以就变成了y = Kp * x。

    x就是当前值currentValue和目标值totalValue的差值,简称误差err,则err = currentValue - totalValue。y就是执行器对应的输出值U,所以执行器对应的输出值U = Kp * ( currentValue - totalValue ) 。

    所以,如果说是使用比例进行调节。

    则当前第1次调节时执行器对应的输出值为U1 = Kp * ( curentValue1 - totalValue1 )。

    第2次调节时执行器对应的输出值为U2 = Kp * ( currentValue2 - totalValue2 )。

    这就是比例系数P的应用,也就是大家说的比例调节。比例调节就是根据当前的值与目标值的差值,乘以了一个Kp的系数,来得到一个输出值,这输出值直接影响了下次当前值的变化。如果只有比例调节的话,系统会震荡的比较厉害。比如你的汽车现在运行的速度是60km/h,现在你想通过你的执行器去控制这个汽车达到恒定的50km/h,如果你只用kp进行比例调节话。U = Kp * ( 60 - 50 ),假设Kp取值为1,此时得到U执行器的输出值是10,结果当你执行器输出后,发现汽车一下变成了35Km/h,此时U2 = Kp * (35 - 50),此时得到U执行器的输出值是-15,结果当你执行器输出后,发现汽车变成了55Km/h,由于惯性和不可预知的误差因素,你的汽车始终无法达到恒定的50km/h。始终在晃动,相信如果你在车上,你一定吐的很厉害。所以光有比例系数进行调节,在有些场合是没有办法将系统调稳定的。所以可以为了减缓震荡的厉害,则会结合使用比例P和微分D。

     

    2.微分系数D

    微分,实际上是对误差进行微分。加入误差1是err(1)。误差2是err(2)。则误差err的微分是 (err2 - err1)。乘上微分系数D,大家叫做KD,则当执行器第1次调节后有了第1次的误差,第2次调节后有了第2次的误差,则结合P系数。就有了PD结合,根据每次调节时,误差的值的经验推算,你就能选取出D的系数。假如误差是越来越小的,那么微分后肯定是一个负值。负值在乘以了一个D系数 加上了比例调节的值后肯定值要比单纯使用比例调节的值要小,所以就启到了阻尼的作用。有了阻尼的作用就会使得系统区域稳定。PD结合的公式经过上面的分析后为

    U(t) = Kp * err(t) + Kd * derr(t)/dt

     

    3.积分系数I

    积分,实际上是对误差的积分,也就是误差的无限和。如何理解积分系数I,这里引用网上的例子

    以热水为例。假如有个人把我们的加热装置带到了非常冷的地方,开始烧水了。需要烧到50℃。

    在P的作用下,水温慢慢升高。直到升高到45℃时,他发现了一个不好的事情:天气太冷,水散热的速度,和P控制的加热的速度相等了。 
    这可怎么办?

    P兄这样想:我和目标已经很近了,只需要轻轻加热就可以了。 
    D兄这样想:加热和散热相等,温度没有波动,我好像不用调整什么。

    于是,水温永远地停留在45℃,永远到不了50℃。

    作为一个人,根据常识,我们知道,应该进一步增加加热的功率。可是增加多少该如何计算呢? 
    前辈科学家们想到的方法是真的巧妙。

    设置一个积分量。只要偏差存在,就不断地对偏差进行积分(累加),并反应在调节力度上。

    这样一来,即使45℃和50℃相差不太大,但是随着时间的推移,只要没达到目标温度,这个积分量就不断增加。系统就会慢慢意识到:还没有到达目标温度,该增加功率啦! 
    到了目标温度后,假设温度没有波动,积分值就不会再变动。这时,加热功率仍然等于散热功率。但是,温度是稳稳的50℃。 
    kI的值越大,积分时乘的系数就越大,积分效果越明显。

    所以,I的作用就是,减小静态情况下的误差,让受控物理量尽可能接近目标值。

    I在使用时还有个问题:需要设定积分限制。防止在刚开始加热时,就把积分量积得太大,难以控制。

     

    调节方法:

    这个内容来自:https://zhidao.baidu.com/question/810684225308065412.html

    这个内容没有提供公式,我猜测是:

    U(t)=Kp*(Err(t)+\frac{1}{Ti}*\int Err(t)dt+\frac{Td*dErr(t)}{dt})

    PID调试一般原则 :
    a.在输出不振荡时,增大比例增益P。
    b.在输出不振荡时,减小积分时间常数Ti。
    c.在输出不振荡时,增大微分时间常数Td。

    PID参数设置及调节方法
    方法一:
    PID参数的设定:是靠经验及工艺的熟悉,参考测量值跟踪与设定值曲线,从而调整P\I\D的大小。
    PID控制器参数的工程整定,各种调节系统中P.I.D参数经验数据以下可参照:
    温度T: P=20~60%,T=180~600s,D=3-180s
    压力P: P=30~70%,T=24~180s,
    液位L: P=20~80%,T=60~300s,
    流量L: P=40~100%,T=6~60s。

    方法二:
    1.PID调试一般原则
    a.在输出不振荡时,增大比例增益P。
    b.在输出不振荡时,减小积分时间常数Ti。
    c.在输出不振荡时,增大微分时间常数Td。
    2.一般步骤
    a.确定比例增益P 确定比例增益P 时,首先去掉PID的积分项和微分项,一般是令Ti=0、Td=0(具体见PID的参数设定说明),使PID为纯比例调节。输入设定为系统允许的最大值的60%~70%,由0逐渐加大比例增益P,直至系统出现振荡;再反过来,从此时的比例增益P逐渐减小,直至系统振荡消失,记录此时的比例增益P,设定PID的比例增益P为当前值的60%~70%。比例增益P调试完成。 b.确定积分时间常数Ti
    比例增益P确定后,设定一个较大的积分时间常数Ti的初值,然后逐渐减小Ti,直至系统出现振荡,之后在反过来,逐渐加大Ti,直至系统振荡消失。记录此时的Ti,设定PID的积分时间常数Ti为当前值的150%~180%。积分时间常数Ti调试完成。
    c.确定积分时间常数Td
    积分时间常数Td一般不用设定,为0即可。若要设定,与确定 P和Ti的方法相同,取不振荡时的30%。
    d.系统空载、带载联调,再对PID参数进行微调,直至满足要求

    展开全文
  • 本博文源于matlab遗传算法,旨在讲述算法参数设置以及算法结束条件。

    本博文源于matlab遗传算法,旨在讲述算法参数设置以及算法结束条件。

    算法参数

    种群规模M(即群体中所含个体的数量)

    • 一般规模含20-100点

    规模太大:会增加计算量
    规模太小:不能提供足够的采样点

    遗传算法的终止进化代数G:

    • 一般取为100-500代

    迭代太长:运行时间过长
    迭代太短:无法出现最优解

    交叉概率Pc

    • 一般经验取值为0.4-0.99

    概率太大:会使种群中高适应度个体的结构很快被破坏掉
    概率太小:搜索停滞不前

    变异概率Pm

    • 一般取值为0.0001-0.1

    太大:变成随机搜索
    太小:不会产生新的基因使得早熟

    遗传算法进化结束条件

    • 染色体变化不大,群体趋于稳定。
    • 目标函数达到预设的要求
    • 迭代次数满足最大代数。
    展开全文
  • 智能优化算法应用:基于麻雀搜索算法PID参数优化 - 附代码 文章目录智能优化算法应用:基于麻雀搜索算法PID参数优化 - 附代码1.PID简介2.麻雀搜索算法简介3.适应度函数设计4.算法实验与结果5.参考文献:6.Matlab ...

    智能优化算法应用:基于麻雀搜索算法PID参数优化 - 附代码


    摘要:本文主要介绍如何用麻雀搜索算法进行PID参数的优化。

    1.PID简介

    PID(Proportion-Integration-Differentiation)控 制 器通过比例单元 P、积分单元 I和微分单元 D 的线性组合构成控制量来实现对被控对象的控制,主要适用于基本线性和动态特性不随时间变化的系统。不同的控制规律适用于不同的生产过程,必须合理选择相应的控制规律,否则PID控制器将达不到预期的控制效果当PID控制器采样周期较小时,可以将连续系统离散化,即以一阶差分代替微商,求和代替积分,矩形积分近似代替连续积分,得到如下差分方程:
    Δu(t)=KpΔe(k)+KiΔe(k)+KdΔ2e(k)(1) \Delta u(t)=K_p \Delta e(k) + K_i \Delta e(k) + K_d \Delta ^2e(k)\tag{1}
    其中e为输入,KpK_p 为比例系数, KiK_i 为积分时间常数, KdK_d 为微分时间常数。

    2.麻雀搜索算法简介

    麻雀搜索算法具体原理请参照:https://blog.csdn.net/u011835903/article/details/108830958

    3.适应度函数设计

    在此算法中,目标函数设置如下:
    F=0(w1e(t)+w2u2(t))dt(2) F = \int_{0}^{\infty}(w_1|e(t)|+w_2u^2(t))dt \tag{2}

    其中, e(t)e(t) 为输入值与输出值之间的误差,考虑到迭代过程的动态特性,采取其绝对值的积分; u(t)u(t) 为控制值,加入此项是为了避免控制幅度过大;w1w_1ω2ω_2 为权重,取值范围[0,1]。

    此外,还需采取限制措施防止超调,即当出现超调时,在目标函数中额外引入超调项,此时的设置如下:
    F=0(w1e(t)+w2u2(t)+w3e(t))dt,e(t)<0(3) F =\int_{0}^{\infty}(w_1|e(t)| + w_2u^2(t)+w_3|e(t)|)dt,e(t)<0 \tag{3}
    其中, w3w_3为权值,且 w3>>w1w_3 >>w_1 ,一般情况下,w1=0.999w2=0.001w3=100w_1 =0.999,w_2 =0.001 , w_3 =100

    所以麻雀算法的目标就是找到一组pid值,使得F误差最小。

    4.算法实验与结果

    本文选择二阶系统的传递函数:
    G(s)=50/(0.125s2+7s)(4) G(s) = 50/(0.125s^2+7s) \tag{4}
    麻雀算法参数设置如下:

    SearchAgents_no=50; %  种群数量
    Max_iteration=100; %  设定最大迭代次数
    lb = -5; %下边界
    ub = 5;  %上边界
    dim = 3; %维度pid3个参数
    S = 1;% 1为单位阶跃响应,其他为正弦输入
    fobj = @(X) PID_controller(X,S);%适应度函数
    
    

    单位阶跃响应寻优结果:

    在这里插入图片描述

    kp,ki,kd的值为:5 0.047998 0.045294

    正弦函数输入结果:

    在这里插入图片描述

    kp,ki,kd的值为:5 -5 2.0404

    从收敛曲线来看,单位阶跃和正弦输入,算法都在不断寻优。从单位阶跃响应来看,系统上升时间和超调均较小,控制效果明显。从正弦输入结果来看,输入与输出控制量误差较小。

    5.参考文献:

    [1] 贺圣彦, 曹中清, 余胜威. 基于花授粉算法的PID参数优化[J]. 计算机工程与应用, 2016.

    6.Matlab 代码

    基于麻雀搜索算法PID参数优化
    粒子群优化的PID参数优化
    灰狼优化的PID参数优化
    鲸鱼优化的PID参数优化
    人工蜂群优化的PID参数优化
    萤火虫优化的PID参数优化
    布谷鸟优化的PID参数优化
    海鸥优化的PID参数优化
    鸡群优化的PID参数优化
    花授粉优化的PID参数优化
    头脑风暴优化的PID参数优化
    蝗虫优化的PID参数优化
    鸟群优化的PID参数优化
    差分进化优化的PID参数优化
    遗传算法优化的PID参数优化
    樽海鞘算法优化的PID参数优化
    教与学算法优化的PID参数优化

    个人资料介绍

    展开全文
  • 粒子群算法中参数怎么设置,有没有数学理论,是否要根据你的实验数据
  • ALS算法参数问题

    千次阅读 2018-03-26 11:29:12
    ALS算法参数// ALS关键代码val model =ALS.train(训练集,rank,循环次数iter,lambda)那是怎么想到要这样设置的呢?那就要在了解算法的基础上来设置此参数;1、训练集,数据格式:(用户id 物品id 评分(0-1) ) 2、...
  • R语言的SMOTE算法参数解释

    千次阅读 2018-06-12 14:26:12
    在R的DMwR包中提供了SMOTE函数用于不平衡的分类问题,其背后的原理是SMOTE算法。SMOTE函数产生一个新的数据集来解决分类不平衡的问题。 用法: SMOTE(form, data, perc.over = 200, k = 5, perc.under = 200, ...
  • 总结: 1:non-parametric algorithm:Locally weighted linear regression algorithm 2:parametric learning ...对于线性回归算法,一旦拟合出适合训练数据的参数θi’s,保存这些参数θi’s,对于之后的...
  • 模拟退火算法SA参数设置实验记录

    千次阅读 2018-06-09 11:41:48
    模拟退火算法有4个参数N:每个温度迭代次数T:重复降温次数a:降温系数t0:初始温度本文用一个50个城市的TSP问题数据集,用交叉对比的方法调参。一组参数运行200次取平均。首先调初始温度N=1000,T=1000,a=0.99固定...
  • 开放平台oauth认证请求参数签名的算法
  • 本篇博客主要2015年发表于IEEE上一篇《Object Tracking Benchmark》当中提出的OPE、TRE、SRE三个基本评价方法进行讲解,同时也会简单介绍一下Precision Plot、Success Plot的matlab实现方法。
  • 其原理来源于鸟群捕食行为的研究,基本思想是通过群体个体之间的协作和信息共享来寻找最优解。PSO的优势在于其简单的算法实现和简洁的参数设置。目前已经广泛应用于函数优化、图像处理等方...
  • 我想用matlab遗传算法优化simulink参数,用simulink的输出作为适值函数,把待优化的参数作为染色体,从而在matlab实现遗传算法,但是不知道应该怎么把simulink和matlab联系起来,希望大家能帮我解决这个问题。
  • 创新一直是一个令人纠结的话题,研究生毕业设计多数需要算法的创新,而博士生毕业... 通常,我们使用一个算法,这里举个简单的粒子,PSO粒子群优化算法,我们通过仿真,会得到该算法的收敛速度,仿真精度等一些参数...
  • JVM垃圾回收算法参数配置

    千次阅读 2017-08-05 17:07:30
    ★引用计数法 ...分为标记和清除两个阶段进行处理内存的对象,当然这种方式也有非常大的弊端,就是空间碎片问题,垃圾回收后的空间不连续,不连续的内存空间工作效率低于连续的内存空间。★复制算法(java
  • 关于ADRC算法以及参数整定(调参)的一些心得体会

    万次阅读 多人点赞 2019-03-11 17:05:44
    关于ADRC算法以及参数整定(调参)的一些心得体会 ADRC,全称叫做Active Disturbance Rejection Control,中文名是自抗扰控制技术。这项控制算法是由中科院的韩京清教授提出的。韩教授继承了经典PID控制器的精华,...
  • K-means算法参数详解

    千次阅读 2019-06-14 10:40:40
    参数名称 默认值及输入类型 参数解释 algorithm 默认:Auto 有auto、full和elkan三种选择。 algorithm: 优化算法的选择,有auto、full和elkan三种选择。...
  • 在ARIMA算法中,我们用PACF(偏相关系数)确定自回归的阶数p,用ACF(自相关系数)确定移动平均阶数q,为什么是这样的?
  • 【寻优算法】遗传算法(Genetic Algorithm) 参数寻优的python实现:多参数寻优一、遗传算法简介1、遗传算法由来2、遗传算法名词概念3、遗传算法中对染色体的操作3.1、选择3.2、交叉3.3、变异二、遗传算法参数寻优...
  • PID算法原理 一图看懂PID的三个参数

    万次阅读 多人点赞 2018-12-06 16:51:33
    前段时间做一个比赛项目的过程经典、实用的PID算法有了一点点自己的理解,就写了这些,与大家分享因为LZ想尽办法,试着用最易于理解的语言说清楚原理,不做太多的理论分析。(LZ文学功底不行),所以...
  • 遗传算法调参 参数设置

    千次阅读 2020-05-03 10:29:01
    遗传算法(Genetic algorithm)遵循适者生存、优胜劣汰的法则,即寻优过程保留有用的,去除无用的。在科学和生产实践表现为在...遗传算法有4个参数需要提前设定,一般在以下范围内进行设置: (1)群体大小...
  • 算法

    万次阅读 2018-02-08 00:13:09
    也就是说,能够一定规范的输入,在有限时间内获得所要求的输出。如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的...
  • Random Forest算法参数解释及调优

    万次阅读 多人点赞 2017-03-10 16:58:49
    文章介绍了如何随机森林模型进行参数调优 原文来自:http://www.analyticsvidhya.com/blog/2015/06/tuning-random-forest-model/ 为什么要调整机器学习算法? 一个月以前,我在kaggle上参加了一个名为TFI的比赛。 ...
  • 1.神经网络主要训练参数 net.trainParam.goal=0.1 % 训练目标最小误差,这里设置为0.1 net.trainParam.epochs=300; % 训练次数,这里设置为300次 net.trainParam.show=20; % 显示频率,这里设置为没训练20次...
  • 朴素贝叶斯算法参数的最大似然估计 设输入向量为。我们假定输入特征是离散的、二值化的变量,即。每一个训练样例,输出对象是0或者1,即。我们的模型由 参数化。 我们把建模成伯努利分布,所以这是...
  • 1、DBSCAN原理、流程、参数设置、优缺点以及算法; 2、matlab代码实现; 3、C++代码实现及与matlab实例结果比较。 摘要:介绍DBSCAN原理、流程、参数设置、优缺点以及算法的matlab和C++代码实例。
  • DecisionTree决策树算法参数详解+实例+graphviz生成决策树 sklearn随机森林 sklearn集合算法库 sklearn-Bagging自助聚合算法 sklearn-Boosting正向激励算法 sklearn-ExtraTrees算法
  • 模拟退火算法参数分析

    万次阅读 2018-01-27 09:34:52
    模拟退火算法参数分析 一 模拟退火算法介绍 模拟退火算法是一种寻找全局最优解的优化方法,核心思想就是以一定概率接收差解,并且这个概率会随着退火温度逐渐降低。一个比较形象的比喻是:一个锅底凹凸不平...
  • openCV3双目深度BM算法参数解析

    千次阅读 2018-06-04 20:30:02
    最近使用opencv做有关双目校正以及深度检测的工作,在深度检测时使用到BM算法,特别感谢这两位的博客解析https://blog.csdn.net/bennygato/article/details/37708195  , ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,154,652
精华内容 461,860
关键字:

对算法中的参数