Ördek Sürü Optimizasyonu

Ördek Sürü Algoritması Nedir?

Ördek sürü algoritması, ördek sürülerinin yiyecek arama ve avlanma davranışlarını matematiksel olarak modelleyen bir optimizasyon algoritmasıdır. Bu algoritma, ördek sürüsünün sıralama, yiyecek arama ve avlanma süreçlerini taklit ederek problemleri çözmeyi amaçlar.

Algoritmanın Temel Süreçleri

1. Popülasyon Başlatma

Algoritma, ördeklerin başlangıç pozisyonlarını belirleyerek başlar. Rastgele oluşturulan başlangıç pozisyonları, belirli bir arama uzayının sınırları içinde yer alır.

DSA'nın D boyutlu arama uzayındaki rastgele oluşturulan başlangıç pozisyonları aşağıdaki formül ile başlatılır:

Burada:

Xi, i'inci ördeğin mekansal konumunu

N, popülasyon sayısını

Lb, arama uzayının alt sınırını

Ub, arama uzayının üst sınırını

o, (0,1) arasında rassal bir sayıyı temsil eder.

2. Keşif Aşaması

Ördek sürüsünün sıralama davranışının ardından, yani ördekler daha fazla yiyecek bulunan bir yere vardığında, her birey yavaşça dağılır ve yiyecek aramaya başlar. Bu aşamada, ördeklerin yeni pozisyonlar belirlenir.

Pozisyon güncellemesi için aşağıdaki formül kullanılır.

Burada:

r, (0,1) arasında rassal bir sayıdır.

sign(r-0.5), yiyecek arama sürecinde etkili bir faktördür ve -1 veya 1 olarak ayarlanabilir.

μ, global arama kontrol parametresini

P, keşif aşamasının arama dönüşüm olasılığını

CF1  ördekler arasındaki işbirliğini

CF2, ördekler arasındaki rekabet katsayılarını ifade eder

Algoritmanın başarıyla çalışabilmesi için belirli parametrelerin belirli sınırlar içinde olması önemlidir.CF1 ve CF2 katsayıları, (0, 2) aralığında değer alır. Bu değerler, algoritmanın esnekliğini ve performansını belirler.

μ parametresinin belirlenmesi :

DSA Örneği

C programlama dilinde tek boyutlu ördek sürü algoritması

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

//-----------------------------------macro-------------------------
#define N 225                       // duck population (ordek sayisi)
#define MAX_ITER 500                // maksimum iterasyon sayisi
#define lb -100                     // low bounder (arama uzayinin alt siniri)
#define ub 110                      // up bounder (arama uzayinin ust siniri)
#define CF1 0.95                    // cooperation coeff (isbirligi katsayisi)
#define CF2 0.18                    // competition coeff (rekabet katsayisi)
#define P 0.9                       // search conversion probability (kesif asamasinda kullanilan donusum olasiligi)
//------------------------------------------------------------------


//---------------------------objective func-------------------------
double objective_function(double x) {
     // return pow((x - 52), 2);
     // return pow((x - 3), 2);
     // return pow((x - 2), 2);
}
//-----------------------------------------------------------------

//----------------------ordek suru algoritmasi----------------------
void duck_swarm_algorithm() {

    // -----STEP 0: initialize variables-----------
    double ducks[N];                    // duck positions 
    double fitness[N];                  // fitness values 
    double global_best;               
    double global_best_position;        // (global en iyi konum)
    double X;                           // next position (x_i)^(t+1) 
    int t;                              // instantaneous number of
    int i, j;
    //------------------------------------------------------------


    
    // --------------STEP 1: initialize population----------------
    for (i = 0; i < N; i++) {
        ducks[i] = ((double)rand() / (double)RAND_MAX) * (ub - lb) + lb;
        fitness[i] = objective_function(ducks[i]);
    }
    //-------------------------------------------------------------

    // --------------STEP 2: expolarition phase---------------------

    for (t = 0; t < MAX_ITER; t++) {

        
        for (i = 0; i < N; i++) {


            
            double r = ((double)rand() / (double)RAND_MAX);
            double sign = (r < 0.5) ? -1 : 1;
            double K = sin(2*r)+1;
            double u = K*(1-((t+1)/(MAX_ITER-1)));

            // calculate new positions
            if(P > r)
            {
               X =  ducks[i] + u*ducks[i]*sign;
            }

            else if(P < r)             
            {
               X = ducks[i] + CF1*(global_best_position-ducks[i]) + CF2*(-ducks[i]);
            }

            else
            {
                printf("error : P=r\n"); 
            }

            // check the low and up bounders
            if (X < lb) X = lb;
            if (X > ub) X = ub;

            // calculate the fitness value of new position
            double new_fitness = objective_function(X);

            // update local best position
            if (new_fitness < fitness[i]) {
                ducks[i] = X;
                fitness[i] = new_fitness;
            }
        }

        //  update global best position
        global_best = fitness[0];
        global_best_position = ducks[0];
        for (j = 1; j < N; j++) {
            if (fitness[j] < global_best) {
                global_best = fitness[j];
                global_best_position = ducks[j];
            }
        }
    }
    printf("global best position: %f\n", global_best_position);
    printf("global fitness value: %f\n", global_best);
}

//------------------------------------------------------------------

int main() {
  
    srand(time(NULL));
    duck_swarm_algorithm();

    return 0;
}