基于二进制编码遗传算法的 PID 整定

基于二进制编码遗传算法的 PID 整定是通过二进制字符串表示 KpK_pKp​、KiK_iKi​、KdK_dKd​ 参数的优化方法。该方法利用遗传算法优化性能指标，从而整定 PID 控制器。

1. 方法原理

遗传算法的核心包括：

1. 编码方式：使用二进制字符串表示 PID 参数。
2. 目标函数：定义一个性能指标（如 ITAE）来评估 PID 控制器的效果。
3. 遗传操作：包括选择、交叉、变异，逐步改进种群的适应度。

---

2. 实现步骤

3. C++ 实现代码

头文件与全局变量

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using namespace std;

const int bitLength = 10;  // 每个参数的二进制长度
const int populationSize = 50;  // 种群规模
const int maxGenerations = 100;  // 最大代数
const double crossoverRate = 0.8;  // 交叉概率
const double mutationRate = 0.05;  // 变异概率

// PID 参数范围
const double Kp_min = 0.1, Kp_max = 10.0;
const double Ki_min = 0.1, Ki_max = 5.0;
const double Kd_min = 0.01, Kd_max = 1.0;

编码与解码

// 二进制编码为实数
double binaryToReal(const string& binary, double minVal, double maxVal) {
    int decimal = stoi(binary, nullptr, 2);
    return minVal + (maxVal - minVal) * decimal / (pow(2, bitLength) - 1);
}

// 实数编码为二进制
string realToBinary(double value, double minVal, double maxVal) {
    int decimal = round((value - minVal) / (maxVal - minVal) * (pow(2, bitLength) - 1));
    string binary = bitset<bitLength>(decimal).to_string();
    return binary;
}

个体与目标函数

struct Individual {
    string Kp_binary;
    string Ki_binary;
    string Kd_binary;
    double fitness;
};

// 模拟目标函数计算 ITAE
double objectiveFunction(double Kp, double Ki, double Kd) {
    // 示例：假设一个误差模型
    double e = 0.0;
    double ITAE = 0.0;
    for (double t = 0; t <= 10.0; t += 0.1) {
        e = exp(-Kp * t) * sin(Ki * t) + cos(Kd * t);
        ITAE += t * fabs(e) * 0.1;
    }
    return ITAE;
}

初始化种群

void initializePopulation(vector<Individual>& population) {
    for (int i = 0; i < populationSize; ++i) {
        double Kp = Kp_min + (Kp_max - Kp_min) * rand() / RAND_MAX;
        double Ki = Ki_min + (Ki_max - Ki_min) * rand() / RAND_MAX;
        double Kd = Kd_min + (Kd_max - Kd_min) * rand() / RAND_MAX;

        population.push_back({
            realToBinary(Kp, Kp_min, Kp_max),
            realToBinary(Ki, Ki_min, Ki_max),
            realToBinary(Kd, Kd_min, Kd_max),
            0.0
        });
    }
}

遗传算法主循环

void geneticAlgorithm() {
    vector<Individual> population;
    initializePopulation(population);

    for (int generation = 0; generation < maxGenerations; ++generation) {
        // 评估适应度
        for (auto& individual : population) {
            double Kp = binaryToReal(individual.Kp_binary, Kp_min, Kp_max);
            double Ki = binaryToReal(individual.Ki_binary, Ki_min, Ki_max);
            double Kd = binaryToReal(individual.Kd_binary, Kd_min, Kd_max);

            individual.fitness = 1.0 / (1.0 + objectiveFunction(Kp, Ki, Kd));
        }

        // 选择（轮盘赌）
        vector<Individual> newPopulation;
        while (newPopulation.size() < populationSize) {
            int i = rand() % populationSize;
            int j = rand() % populationSize;
            newPopulation.push_back(population[i].fitness > population[j].fitness ? population[i] : population[j]);
        }

        // 交叉
        for (int i = 0; i < newPopulation.size(); i += 2) {
            if (rand() / double(RAND_MAX) < crossoverRate && i + 1 < newPopulation.size()) {
                int crossoverPoint = rand() % bitLength;
                swap_ranges(newPopulation[i].Kp_binary.begin() + crossoverPoint,
                            newPopulation[i].Kp_binary.end(),
                            newPopulation[i + 1].Kp_binary.begin() + crossoverPoint);
            }
        }

        // 变异
        for (auto& individual : newPopulation) {
            if (rand() / double(RAND_MAX) < mutationRate) {
                int mutationPoint = rand() % bitLength;
                individual.Kp_binary[mutationPoint] = individual.Kp_binary[mutationPoint] == '0' ? '1' : '0';
            }
        }

        population = newPopulation;
    }

    // 输出最优解
    auto best = *max_element(population.begin(), population.end(),
                             [](const Individual& a, const Individual& b) { return a.fitness < b.fitness; });
    double Kp = binaryToReal(best.Kp_binary, Kp_min, Kp_max);
    double Ki = binaryToReal(best.Ki_binary, Ki_min, Ki_max);
    double Kd = binaryToReal(best.Kd_binary, Kd_min, Kd_max);

    cout << "Optimal PID parameters: Kp=" << Kp << ", Ki=" << Ki << ", Kd=" << Kd << endl;
}

运行程序

int main() {
    srand(time(nullptr));
    geneticAlgorithm();
    return 0;
}

4. 总结

1. 二进制编码优势：简单易实现，适合标准遗传算法框架。
2. 参数优化：通过 ITAE 等性能指标优化 KpK_pKp​、KiK_iKi​、KdK_dKd​。
3. 扩展性：可以调整目标函数和遗传参数适应不同场景。