BAB 3



1. Sekilas tentang MATLAB [BACK] 
    
MATLAB, singkatan dari MATrix LABoratory, adalah sebuah platform dan bahasa pemrograman yang dirancang untuk membantu dalam berbagai aplikasi numerik dan teknik, terutama yang melibatkan operasi matriks. Aplikasi ini akan memudahkan pengguna dalam operasi matriks, terutama dalam pengimplementasiannya ke GA. MATLAB sangat efektif untuk mengimplementasikan GA karena fleksibilitasnya dalam menangani matriks dan array serta kemampuannya untuk menyederhanakan pengembangan algoritma.
          

  • Pemograman MATLAB  [BACK] 
    • Dalam MATLAB, setiap variabel dianggap sebagai matriks.
    • Pembuatan program atau fungsi dalam MATLAB dapat dilakukan dengan file berekstensi .m. (nama fungsi harus sama dengan nama file)
    • MATLAB bersifat case sensitive, sehingga antara "A" dan "a" akan dibaca sebagai dua variabel yang berbeda.
    • i dan j merupakan tanda bilangan imajiner, sehingga perlu dihindari menggunakan variabel j dan i.
  • Matriks
    • Merupakan sekumpulan angka berbentuk persegi.
                                            

  • Sum, Transpose, dan diag
    • Sum



    • Transpose
  • Diag
  • Indeks Matriks
    • Penunjukan elemen matrik dapat dilakukan dengan berdasarkan indeksnya.
    • Remember! : Matriks(baris,kolom)
    • Contoh kasus :


  • Operator ":"
    • Penanda deret bilangan bulat



  • Membangkitkan Matriks
    • zeros (semua nol)
    • ones (semua satu)
    • rand (random dalam distribusi uniform)
    • randn (random dalam distribusi normal)

  • Concatenation
    • Penggabungan beberapa matrik kecil menjadi sebuah matriks besar
    • Untuk menggabungkan matriks berdasarkan kolom, digunakan ";" 
    • Untuk menggabungkan matriks berdasarkan baris, tidak perlu ada ";"
    • Jika matriks yang digabung memiliki jumlah baris/kolom yang berbeda, makan akan muncul error.

  • Operasi-operasi Matriks
    • + (penjumlahan)
    • - (pengurangan)
    • *(perkalian matriks)
    • .*(perkalian elemen per elemen)
    • ./ (pembagian elemen per elemen, variabel kiri dibagi kanan)
    • .\ (pembagian elemen per elemen, variabel kanan dibagi kiri)
    • .^ (perpangkatan elemen per elemen)





2. Implementasi Algoritma Genetika [BACK] 
    
    Pada penjelasan berikut akan diterapkan GA untuk mencari nilai dari fungsi h:

      

Tujuan fungsi ini untuk membangkitkan populasi yang berisi sejumlah kromosom.

Program:

InisiasiPopulasi
%===============================================================================
% Membangkitkan sejumlah UkPop kromosom, masing-masing kromosom berisi bilangan
% biner (0 dan 1) sejumlah JumGen
%
% Masukan
% UkPop : ukuran populasi atau jumlah kromosom dalam populasi
% JumGen: jumlah gen dalam kromosom
%
% Keluaran
% Populasi : kumpulan kromosom, matriks berukuran UkPop x JumGen
%===============================================================================
function Populasi = InisialisasiPopulasi(UkPop, JumGen)
% Mendefinisikan fungsi bernama InisialisasiPopulasi
% yang menerima dua argumen: UkPop (ukuran populasi) dan JumGen (jumlah gen)
% Output dari fungsi ini adalah variabel Populasi
Populasi = fix(2*rand(UkPop, JumGen));
% Menginisialisasi matriks Populasi dengan ukuran UkPop x JumGen
% Matriks ini diisi dengan nilai-nilai acak yang dihasilkan oleh rand,
% dikalikan dengan 2, dan dibulatkan ke bawah dengan fungsi fix.% Ini menghasilkan matriks yang berisi nilai-nilai 0 atau 1 (karena fix(0 hingga 2) = 0 atau 1)         

InisiasiPopulasiCoba1

clc;
clear all;
UkPop = 200;
% Menetapkan nilai 200 ke variabel UkPop, yang menunjukkan ukuran populasi
JumGen = 20;
% Menetapkan nilai 20 ke variabel JumGen, yang menunjukkan jumlah gen
Populasi = fix(2*rand(UkPop, JumGen));
% Menginisialisasi matriks Populasi dengan ukuran UkPop x JumGen
% Matriks ini diisi dengan nilai-nilai acak yang dihasilkan oleh rand,
% dikalikan dengan 2, dan dibulatkan ke bawah dengan fungsi fix.
% Ini menghasilkan matriks yang berisi nilai-nilai 0 atau 1

Hasil Akhir:

Populasi adalah matriks berukuran 200 x 20, di mana setiap elemen adalah 0 atau 1. Matriks ini sering digunakan dalam konteks algoritma genetik atau studi lain di mana populasi individu (baris-baris dalam matriks) diwakili oleh gen-gen (kolom-kolom dalam matriks), dan setiap gen bisa bernilai 0 atau 1.



          Bertujuan untuk mengodekan sebuah kromosom yang berisi bilangan biner menjadi individu x yang bernilai real dalam interval yang diinginkan, berdasarkan persamaan berikut:

Program
%===============================================================================
% Mendekodekan kromosom yang berisi bilangan biner menjadi individu x yang
% bernilai real dalam interval yang ditentukan [Ra,Rb]
%
% Masukan
% Kromosom : kromosom, matriks berukuran 1 x JumGen
% Nvar : jumlah variabel
% Nbit : jumlah bit yang mengkodekan satu variabel
% Ra : batas atas interval
% Rb : batas bawah interval
%
% Keluaran
% x : individu hasil dekode kromosom
%===============================================================================
function x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb)
% Mendefinisikan fungsi bernama DekodekanKromosom
% yang menerima empat argumen: Kromosom (vektor kromosom), Nvar (jumlah variabel), Nbit (jumlah bit per variabel), Ra (rentang atas), dan Rb (rentang bawah)
% Output dari fungsi ini adalah vektor x yang merupakan hasil dekoding kromosom
for ii = 1:Nvar
% Memulai loop untuk setiap variabel (dari 1 hingga Nvar)
x(ii) = 0;
% Menginisialisasi nilai x(ii) menjadi 0 untuk variabel ke-ii
for jj = 1:Nbit
% Memulai loop untuk setiap bit (dari 1 hingga Nbit)
x(ii) = x(ii) + Kromosom((ii-1)*Nbit + jj) * 2^(-jj);
% Menambahkan nilai bit yang terukur dengan bobot 2^(-jj) ke x(ii)
% Kromosom((ii-1)*Nbit + jj) mengakses bit ke-jj dari kromosom untuk variabel ke-ii
end
x(ii) = Rb + (Ra - Rb) * x(ii);
% Mengonversi nilai x(ii) dari rentang [0, 1] ke rentang [Rb, Ra]
end

Fungsi DekodekanKromosom:


function x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb)

Deskripsi:

  • Kromosom: Matriks biner ukuran 1 x JumGen, yang merupakan kromosom yang akan didekodekan. Di sini, JumGen adalah Nvar * Nbit, yaitu jumlah total bit yang mengkodekan semua variabel.
  • Nvar: Jumlah variabel yang ingin didekodekan dari kromosom.
  • Nbit: Jumlah bit yang digunakan untuk mengkodekan setiap variabel.
  • Ra: Batas atas interval di mana nilai real hasil dekode akan berada.
  • Rb: Batas bawah interval di mana nilai real hasil dekode akan berada.

Proses Dekode:

  1. Inisialisasi Loop Variabel:


    for ii = 1:Nvar
      x(ii) = 0;
    • Loop pertama mengiterasi melalui setiap variabel ii dari 1 hingga Nvar. Untuk setiap variabel, kita akan menghitung nilai real yang sesuai dari bagian kromosom yang mengkodekan variabel tersebut.

  2. Dekode Kromosom:


    for jj = 1:Nbit
      x(ii) = x(ii) + Kromosom((ii-1)*Nbit+jj) * 2^(-jj);
    end
    • Loop kedua mengiterasi melalui setiap bit jj dari 1 hingga Nbit. Untuk setiap bit, kita mengakumulasi nilai biner yang terkode dalam variabel x(ii):
      • Kromosom((ii-1)*Nbit+jj) mengambil bit ke-jj dari kromosom yang mengkodekan variabel ke-ii.
      • 2^(-jj) mengonversi bit ke-jj menjadi nilai desimal sesuai posisinya dalam sistem biner.
      • Dengan menambahkan nilai ini ke x(ii), kita membangun representasi desimal dari bit-bit biner.

  3. Transformasi ke Rentang Real:

    x(ii) = Rb + (Ra - Rb) * x(ii);
    • Setelah mendapatkan nilai desimal dari bit biner, kita mengubahnya ke dalam rentang [Rb, Ra] dengan menggunakan rumus:
      • Rb + (Ra - Rb) * x(ii)
      • Di sini, x(ii) berada dalam rentang [0, 1] setelah dekode biner, dan rumus ini mengubahnya ke rentang [Rb, Ra].

Contoh Penggunaan:

Misalnya, jika Kromosom adalah [1 0 1 1 0 0 1 0], Nvar adalah 2, Nbit adalah 4, Ra adalah 10, dan Rb adalah 5, maka:

  1. Untuk variabel pertama (4 bit pertama), kromosom [1 0 1 1] diubah menjadi nilai desimal 1*(2^(-1)) + 1*(2^(-2)) + 0*(2^(-3)) + 1*(2^(-4)) = 0.8125.
  2. Nilai ini kemudian diubah ke rentang [5, 10]:
    • 5 + (10 - 5) * 0.8125 = 5 + 5 * 0.8125 = 5 + 4.0625 = 9.0625.

Hasil Akhir:

Fungsi ini mengembalikan x, sebuah vektor yang berisi nilai real hasil dekode dari setiap variabel dalam kromosom, sesuai dengan rentang yang ditentukan.

Ringkasan:

Fungsi DekodekanKromosom mengubah kromosom biner menjadi nilai real dalam rentang tertentu dengan mengonversi setiap bagian dari kromosom yang mewakili variabel menjadi angka desimal, kemudian menskalakannya ke dalam rentang [Rb, Ra].

Program

Kromosom = randi([0 1], 1, 20);
% Menginisialisasi vektor kromosom dengan 20 bit acak yang bernilai 0 atau 1
Nvar = 2;
% Menetapkan jumlah variabel yang akan didekodekan sebagai 2
Nbit = 10;
% Menetapkan jumlah bit per variabel sebagai 10
Ra = 5.12;
% Menetapkan nilai batas atas rentang sebagai 5.12
Rb = -5.12;
% Menetapkan nilai batas bawah rentang sebagai -5.12
x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb);
% Mendekode kromosom menggunakan fungsi DekodekanKromosom dengan parameter yang ditetapkan
% Hasilnya adalah vektor x yang berisi nilai-nilai variabel setelah dekoding

  1. Kromosom Generation:

    Kromosom = randi([0 1], 1, 20);
    • randi([0 1], 1, 20) menghasilkan vektor baris Kromosom yang berisi 20 bilangan biner (0 atau 1) secara acak. Ini adalah kromosom biner yang akan didekodekan.
    • Contoh hasilnya bisa berupa: [1 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 1 1].

  2. Parameter Dekode:

    Nvar = 2;
    Nbit = 10;
    Ra = 5.12;
    Rb = -5.12;
    • Nvar adalah jumlah variabel yang ingin didekodekan, yaitu 2 variabel.
    • Nbit adalah jumlah bit yang mengkodekan setiap variabel, yaitu 10 bit per variabel.
    • Ra adalah batas atas rentang nilai real yang diinginkan untuk variabel, yaitu 5.12.
    • Rb adalah batas bawah rentang nilai real yang diinginkan untuk variabel, yaitu -5.12.

  3. Panggilan Fungsi DekodekanKromosom:


    x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb);
    • Fungsi DekodekanKromosom akan mengubah kromosom biner Kromosom menjadi nilai real sesuai dengan parameter Nvar, Nbit, Ra, dan Rb.

Proses Dekode

Fungsi DekodekanKromosom mengonversi kromosom biner menjadi nilai real dalam rentang [Rb, Ra] dengan langkah-langkah berikut:

  1. Inisialisasi Hasil Dekode:


    x(ii) = 0;
    • Untuk setiap variabel (dalam hal ini ada 2 variabel), x(ii) diinisialisasi ke 0.

  2. Dekode Bit ke Desimal:


    for jj = 1:Nbit
      x(ii) = x(ii) + Kromosom((ii-1)*Nbit + jj) * 2^(-jj);
    end
    • Untuk setiap bit dalam kromosom yang mewakili variabel, bit-bit ini dikonversi menjadi nilai desimal berdasarkan posisi bit dalam bilangan biner.
    • Contohnya, jika variabel pertama mengacu pada 10 bit pertama dari Kromosom, maka fungsi ini mengonversi 10 bit tersebut menjadi nilai desimal antara 0 dan 1.

  3. Transformasi ke Rentang Real:


    x(ii) = Rb + (Ra - Rb) * x(ii);
    • Setelah mendapatkan nilai desimal dari bit biner, nilai ini diubah ke dalam rentang [Rb, Ra] dengan menggunakan rumus linear:
      • x(ii) = Rb + (Ra - Rb) * x(ii)
      • Ini menskalakan nilai desimal ke dalam rentang yang diinginkan.

Contoh Penghitungan

Misalkan Kromosom adalah [1 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 1 1]. Untuk Nvar = 2 dan Nbit = 10:

  • Variabel Pertama:

    • Mengambil 10 bit pertama dari Kromosom: [1 0 1 0 1 1 0 1 0 0]

    • Menghitung nilai desimal dari bit ini.

    • Misalkan hasil desimalnya adalah 0.6234 (hanya contoh, hasil aktual akan bergantung pada bit).

    • Mengubah nilai desimal ke rentang [Rb, Ra]:

      • x(1) = -5.12 + (5.12 - (-5.12)) * 0.6234 = -5.12 + 10.24 * 0.6234 ≈ -5.12 + 6.39 ≈ 1.27

  • Variabel Kedua:

    • Mengambil 10 bit berikutnya dari Kromosom: [0 1 0 0 1 0 1 0 1 1]
    • Menghitung nilai desimal dan mengubahnya ke rentang yang sama dengan proses di atas.

Hasil Akhir:

Vektor x berisi dua nilai real yang merupakan hasil dekode dari dua variabel biner dari kromosom biner ke rentang [Rb, Ra].


          Fungsi ini bertujuan untuk menghitung nilai fitness dari suatu individu x
%===============================================================================
% Mengevaluasi individu sehingga didapatkan nilai fitness-nya
%
% Masukan
% x : individu
% BilKecil : bilangan kecil digunakan untuk menghindari pembagian dengan 0
%
% Keluaran
% fitness : nilai fitness
%===============================================================================
function fitness = EvaluasiIndividu(x, BilKecil)
% Mendefinisikan fungsi bernama EvaluasiIndividu
% yang menerima dua argumen: x (vektor variabel) dan BilKecil (nilai kecil untuk menghindari pembagian dengan nol)
% Output dari fungsi ini adalah nilai fitness individu
fitness = 1 / ((1000 * (x(1) - 2 * x(2))^2 + (1 - x(1))^2) + BilKecil);
% Menghitung fitness berdasarkan fungsi objektif yang diberikan
% Fitness adalah invers dari nilai fungsi objektif ditambah BilKecil
% Fungsi objektif adalah (1000*(x(1) - 2*x(2))^2 + (1 - x(1))^2)

Penjelasan Parameter dan Fungsi

  1. Parameter:

    • x: Vektor yang berisi nilai-nilai individu yang akan dievaluasi. Dalam konteks ini, x diharapkan sebagai vektor dengan setidaknya dua elemen (misalnya x = [x1, x2]), di mana x1 dan x2 adalah nilai-nilai yang diperoleh dari proses dekode kromosom atau input lain.
    • BilKecil: Parameter tambahan yang digunakan untuk menghindari nilai fitness menjadi terlalu kecil. Biasanya, BilKecil adalah nilai kecil positif yang ditambahkan untuk menghindari pembagi nol atau nilai fitness yang terlalu kecil.

  2. Fungsi Fitness:

    fitness = 1 / ((1000 * (x(1) - 2 * x(2))^2 + (1 - x(1))^2) + BilKecil);
    • Fungsi fitness dihitung dengan formula:

      fitness = 1 / (f(x) + BilKecil)
      Di mana f(x) adalah fungsi objektif yang dinyatakan dalam kurung:
      f(x) = 1000 * (x(1) - 2 * x(2))^2 + (1 - x(1))^2

Interpretasi Fungsi Fitness

  1. Fungsi Objektif f(x):

    • f(x) adalah fungsi kuadrat yang dihitung dari elemen-elemen vektor x:
      • 1000 * (x(1) - 2 * x(2))^2: Mengukur seberapa jauh kombinasi x(1) dan x(2) dari kondisi ideal x(1) = 2 * x(2).
      • (1 - x(1))^2: Mengukur seberapa jauh x(1) dari nilai ideal 1.
    • Fungsi ini biasanya digunakan dalam masalah optimasi di mana kita ingin meminimalkan nilai f(x).

  2. Penambahan BilKecil:

    • BilKecil ditambahkan pada penyebut untuk menghindari pembagi nol atau menghindari nilai fitness yang menjadi sangat besar jika f(x) mendekati nol.
    • Ini membantu memastikan bahwa fitness tetap dalam rentang yang dapat diterima dan stabil selama evaluasi.

  3. Fitness Function:

    • Fitness didefinisikan sebagai invers dari nilai f(x) + BilKecil:
      • Ketika f(x) rendah (mendekati nol), fitness akan tinggi, yang berarti individu tersebut dianggap baik.
      • Ketika f(x) tinggi, fitness akan rendah, yang menunjukkan individu tersebut kurang baik.

Contoh:

Misalkan x = [1.5, 0.5] dan BilKecil = 1e-6:

  1. Hitung f(x):

    f(x) = 1000 * (1.5 - 2 * 0.5)^2 + (1 - 1.5)^2
         = 1000 * (1.5 - 1)^2 + (-0.5)^2
         = 1000 * (0.5)^2 + 0.25
         = 1000 * 0.25 + 0.25
         = 250 + 0.25
         = 250.25

  2. Hitung fitness:

    fitness = 1 / (250.25 + 1e-6)
            ≈ 1 / 250.250001
            ≈ 0.00399

Ringkasan:

Fungsi EvaluasiIndividu mengevaluasi fitness individu berdasarkan fungsi objektif f(x) dan parameter tambahan BilKecil. Fitness diukur sebagai invers dari nilai fungsi objektif ditambah BilKecil. Ini membantu memastikan bahwa individu dengan nilai fungsi objektif yang lebih rendah memiliki fitness yang lebih tinggi, yang menunjukkan bahwa individu tersebut lebih baik dalam konteks masalah optimasi yang sedang dipecahkan.


            Untuk menjaga individu dengan nilai fitness terbaik, maka dilakukan elitisme,

BilKecil = 0.1;
% Menetapkan nilai kecil untuk menghindari pembagian dengan nol dalam fungsi fitness
fitness = EvaluasiIndividu(x, BilKecil);
% Menghitung fitness untuk variabel x dengan menggunakan fungsi EvaluasiIndividu
% BilKecil digunakan untuk menghindari pembagian dengan nol
x = DekodekanKromosom(Populasi(1,:), Nvar, Nbit, Ra, Rb);
% Mendekode kromosom pertama dari populasi untuk mendapatkan variabel x
Fitness(1) = EvaluasiIndividu(x, BilKecil);
% Menghitung fitness dari individu pertama dan menyimpannya dalam array Fitness
MaxF = Fitness(1);
% Menginisialisasi nilai maksimum fitness dengan fitness individu pertama
MinF = Fitness(1);
% Menginisialisasi nilai minimum fitness dengan fitness individu pertama
IndeksIndividuTerbaik = 1;
% Menginisialisasi indeks individu terbaik dengan 1 (individu pertama)
for ii = 2:UkPop
% Memulai loop dari individu kedua hingga UkPop (ukuran populasi)
Kromosom = Populasi(ii, :);
% Mengambil kromosom individu ke-ii dari populasi
x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb);
% Mendekode kromosom untuk mendapatkan variabel x
Fitness(ii) = EvaluasiIndividu(x, BilKecil);
% Menghitung fitness dari individu ke-ii dan menyimpannya dalam array Fitness
if (Fitness(ii) > MaxF)
% Jika fitness individu ke-ii lebih besar dari MaxF
MaxF = Fitness(ii);
% Memperbarui nilai MaxF dengan fitness individu ke-ii
IndeksIndividuTerbaik = ii;
% Memperbarui indeks individu terbaik dengan indeks ke-ii
BestX = x;
% Memperbarui variabel BestX dengan nilai x individu ke-ii
end
if (Fitness(ii) < MinF)
% Jika fitness individu ke-ii lebih kecil dari MinF
MinF = Fitness(ii);
% Memperbarui nilai MinF dengan fitness individu ke-ii
end
end
TemPopulasi = Populasi;
% Menyalin populasi saat ini ke variabel sementara TemPopulasi
if mod(UkPop, 2) == 0
% Jika ukuran populasi genap
IterasiMulai = 3;
% Mengatur IterasiMulai menjadi 3
TemPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
% Menyalin kromosom individu terbaik ke posisi pertama dalam TemPopulasi
TemPopulasi(2, :) = Populasi(IndeksIndividuTerbaik, :);
% Menyalin kromosom individu terbaik ke posisi kedua dalam TemPopulasi
else
% Jika ukuran populasi ganjil
IterasiMulai = 2;
% Mengatur IterasiMulai menjadi 2
TemPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
% Menyalin kromosom individu terbaik ke posisi pertama dalam TemPopulasi
end

Penjelasan Kode


BilKecil = 0.1;
fitness = EvaluasiIndividu(x, BilKecil);
  • BilKecil diatur sebagai 0.1, digunakan untuk stabilisasi dalam fungsi fitness EvaluasiIndividu.
  • fitness menghitung fitness individu x menggunakan parameter BilKecil.

x = DekodekanKromosom(Populasi(1,:), Nvar, Nbit, Ra, Rb);
Fitness(1) = EvaluasiIndividu(x, BilKecil);
MaxF = Fitness(1);
MinF = Fitness(1);
IndeksIndividuTerbaik = 1;
  • Mengambil kromosom pertama dari Populasi dan mendekodifikasinya ke nilai real x dengan DekodekanKromosom.
  • Menghitung fitness dari individu tersebut dan menyimpannya dalam Fitness(1).
  • MaxF dan MinF diinisialisasi dengan fitness individu pertama, sehingga saat ini MaxF dan MinF sama dengan fitness individu pertama.
  • IndeksIndividuTerbaik diatur ke 1, menandakan bahwa individu pertama adalah yang terbaik saat ini.

for ii = 2:UkPop
    Kromosom = Populasi(ii, :);
    x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb);
    Fitness(ii) = EvaluasiIndividu(x, BilKecil);
    if (Fitness(ii) > MaxF)
        MaxF = Fitness(ii);
        IndeksIndividuTerbaik = ii;
        BestX = x;
    end
    if (Fitness(ii) < MinF)
        MinF = Fitness(ii);
    end
end
  • Loop ini iterasi melalui setiap individu dalam populasi dari ii = 2 hingga UkPop.
  • Untuk setiap individu:
    • Ambil kromosom individu dan dekode menjadi nilai real x.
    • Hitung fitness individu tersebut dan simpan di Fitness(ii).
    • Jika fitness individu lebih tinggi dari MaxF, update MaxF dan IndeksIndividuTerbaik, serta simpan x sebagai BestX (individu terbaik).
    • Jika fitness individu lebih rendah dari MinF, update MinF.

TemPopulasi = Populasi;
if mod(UkPop, 2) == 0
    IterasiMulai = 3;
    TemPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
    TemPopulasi(2, :) = Populasi(IndeksIndividuTerbaik, :);
else
    IterasiMulai = 2;
    TemPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
end
  • TemPopulasi adalah salinan dari Populasi yang mungkin akan digunakan dalam iterasi berikutnya atau untuk tujuan lain dalam algoritma.
  • Cek apakah UkPop (ukuran populasi) adalah genap dengan mod(UkPop, 2) == 0:
    • Jika genap, set IterasiMulai ke 3. Salin individu terbaik ke baris pertama dan kedua dari TemPopulasi.
    • Jika tidak genap, set IterasiMulai ke 2. Salin individu terbaik ke baris pertama dari TemPopulasi.

Hasil


          Untuk menghindari kecenderungan konvergen pada optimum lokal, maka digunakaan penskalaan nilai fitness yang bertujuan untuk mendapatkan nilai fitness yang lebih baik, bervariansi tinggi.

Program:
%===============================================================================
% Men-skala-kan nilai fitness ke dalam ranking sehingga diperoleh
% nilai-nilai fitness baru yang berada dalam rentang [MaxF,MinF]
%
% Masukan
% UkPop : ukuran populasi atau jumlah kromosom dalam populasi
% Fitness: nilai fitness, matriks ukuran 1 x UkPop
% MaxF : nilai fitness maximum
% MinF : nilai fitness minimum
%
% Keluaran
% LFR : Linear Fitness Ranking
%===============================================================================
function LFR = LinearFitnessRanking(UkPop, Fitness, MaxF, MinF)
% Mendefinisikan fungsi bernama LinearFitnessRanking
% yang menerima empat argumen: UkPop (ukuran populasi), Fitness (vektor fitness), MaxF (nilai fitness maksimum), dan MinF (nilai fitness minimum)
% Output dari fungsi ini adalah vektor LFR yang berisi nilai fitness baru hasil pen-skala-an
% SF berisi nilai fitness yang terurut dari kecil ke besar (ascending)
% IndF berisi index dari nilai fitness yang menyatakan nomor urut kromosom
[SF, IndF] = sort(Fitness);
% Mengurutkan nilai fitness dari yang terkecil hingga yang terbesar
% SF adalah vektor nilai fitness yang terurut
% IndF adalah vektor indeks yang menunjukkan urutan asli dari nilai fitness
% LinearFitness = nilai fitness baru hasil pen-skala-an
for rr = 1:UkPop
% Memulai loop untuk setiap individu dalam populasi
LFR(IndF(UkPop - rr + 1)) = MaxF - (MaxF - MinF) * ((rr - 1) / (UkPop - 1));
% Menghitung nilai fitness baru berdasarkan urutan individu
% Nilai fitness baru dihitung dengan melakukan skala linear dari MaxF ke MinF
% Menggunakan urutan yang terbalik untuk memastikan individu dengan fitness lebih tinggi mendapatkan nilai fitness yang lebih tinggi
end

Fungsi LinearFitnessRanking ini digunakan dalam algoritma genetik untuk melakukan pemeringkatan individu berdasarkan nilai fitness mereka. Tujuan dari fungsi ini adalah untuk menyesuaikan fitness individu dengan skala linear sehingga individu dengan fitness lebih tinggi mendapatkan nilai fitness yang lebih tinggi dalam skala baru, sedangkan individu dengan fitness lebih rendah mendapatkan nilai fitness yang lebih rendah. Fungsi ini membantu dalam pemilihan individu untuk proses reproduksi.


function LFR = LinearFitnessRanking(UkPop, Fitness, MaxF, MinF)
  • UkPop: Jumlah individu dalam populasi.
  • Fitness: Vektor yang berisi nilai fitness asli dari setiap individu dalam populasi.
  • MaxF: Nilai fitness maksimum yang diinginkan dalam skala baru.
  • MinF: Nilai fitness minimum yang diinginkan dalam skala baru.

Proses dalam Fungsi

  1. Mengurutkan Fitness:


    [SF, IndF] = sort(Fitness);
    • SF adalah vektor nilai fitness yang telah diurutkan dari yang terkecil hingga terbesar.
    • IndF adalah indeks yang menunjukkan urutan dari nilai fitness dalam vektor asli.
    • IndF digunakan untuk mengetahui posisi individu dalam urutan fitness yang telah diurutkan.

  2. Penyesuaian Fitness Linear:


    for rr = 1:UkPop
      LFR(IndF(UkPop - rr + 1)) = MaxF - (MaxF - MinF) * ((rr - 1) / (UkPop - 1));
    end

    • LFR adalah vektor hasil yang berisi nilai fitness baru berdasarkan skala linear.

    • Loop for rr = 1:UkPop mengiterasi melalui setiap individu dalam populasi.

      • rr adalah iterasi saat ini, yang juga menunjukkan urutan individu dalam daftar SF (fitness terurut).
      • IndF(UkPop - rr + 1) mendapatkan indeks individu asli yang sesuai dengan urutan fitness rr.
      • LFR(IndF(UkPop - rr + 1)) mengatur fitness baru untuk individu tersebut.

    • Skala Linear:

      • Nilai fitness baru dihitung dengan rumus:

        LFR(IndF(UkPop - rr + 1)) = MaxF - (MaxF - MinF) * ((rr - 1) / (UkPop - 1))
      • Rumus ini mengubah fitness asli menjadi nilai baru yang terdistribusi secara linear antara MaxF (fitness maksimum) dan MinF (fitness minimum).
      • Individu dengan fitness terbaik mendapatkan nilai mendekati MaxF, sedangkan individu dengan fitness terburuk mendapatkan nilai mendekati MinF.

Contoh

Misalkan kita memiliki 5 individu dalam populasi dengan fitness yang diukur sebagai berikut:

  • Fitness: [10, 15, 20, 25, 30]
  • UkPop: 5
  • MaxF: 1.0
  • MinF: 0.0

Langkah-langkah dalam fungsi:

  1. Urutkan Fitness:

    • SF = [10, 15, 20, 25, 30]
    • IndF = [1, 2, 3, 4, 5] (indeks asli)

  2. Hitung Fitness Linear:

    • Untuk rr = 1: LFR(IndF(5 - 1 + 1)) = LFR(5) = MaxF - (MaxF - MinF) * ((1 - 1) / (4)) = 1.0

    • Untuk rr = 2: LFR(IndF(5 - 2 + 1)) = LFR(4) = MaxF - (MaxF - MinF) * ((2 - 1) / (4)) = 0.75

    • Untuk rr = 3: LFR(IndF(5 - 3 + 1)) = LFR(3) = MaxF - (MaxF - MinF) * ((3 - 1) / (4)) = 0.5

    • Untuk rr = 4: LFR(IndF(5 - 4 + 1)) = LFR(2) = MaxF - (MaxF - MinF) * ((4 - 1) / (4)) = 0.25

    • Untuk rr = 5: LFR(IndF(5 - 5 + 1)) = LFR(1) = MaxF - (MaxF - MinF) * ((5 - 1) / (4)) = 0.0

    • Hasil:

      • LFR = [0.0, 0.25, 0.5, 0.75, 1.0]

Program Coba

LFR = LinearFitnessRanking(UkPop, Fitness, MaxF, MinF);
% Memanggil fungsi LinearFitnessRanking dengan argumen UkPop (ukuran populasi),
% Fitness (vektor nilai fitness dari setiap individu), MaxF (nilai fitness maksimum),
% dan MinF (nilai fitness minimum).
% Output dari fungsi ini adalah vektor LFR yang berisi nilai fitness yang telah di-scaling
% secara linear berdasarkan urutan fitness dalam populasi.
Hasil


          
Prigram
%===============================================================================
% Memilih orang tua menggunakan LinearFitness, yaitu nilai fitness hasil
% pen-skala-an. Pemilihan dilakukan secara proporsional sesuai dengan
% nilai fitness-nya.
%
% Masukan
% UkPop : ukuran populasi atau jumlah kromosom dalam populasi
% LinearFitness : nilai fitness yang sudah di-skala-kan
%
% Keluaran
% Pindex : indeks dari kromosom yang terpilih (bernilai 1 sampai UkPop)
%===============================================================================
function Pindex = RouletteWheel(UkPop, LinearFitness)
% Mendefinisikan fungsi bernama RouletteWheel
% yang menerima dua argumen: UkPop (ukuran populasi) dan LinearFitness (vektor nilai fitness yang telah disesuaikan)
% Output dari fungsi ini adalah Pindex, indeks individu yang dipilih berdasarkan metode roda roulette
JumFitness = sum(LinearFitness);
% Menghitung jumlah total fitness dari seluruh populasi
KumulatifFitness = 0;
% Menginisialisasi variabel untuk menyimpan jumlah kumulatif fitness
RN = rand;
% Menghasilkan nilai acak antara 0 dan 1 (untuk digunakan dalam pemilihan individu)
ii = 1;
% Menginisialisasi variabel indeks untuk iterasi
while ii <= UkPop
% Memulai loop untuk setiap individu dalam populasi
KumulatifFitness = KumulatifFitness + LinearFitness(ii);
% Menambahkan fitness individu ke-ii ke total kumulatif fitness
if (KumulatifFitness / JumFitness) > RN
% Jika rasio kumulatif fitness terhadap total fitness lebih besar dari nilai acak
Pindex = ii;
% Menetapkan indeks individu ke-ii sebagai hasil pemilihan
break;
% Keluar dari loop karena individu telah dipilih
end
ii = ii + 1;
% Melanjutkan ke individu berikutnya
end

Fungsi RouletteWheel ini merupakan implementasi dari metode pemilihan berbasis roda roulette, yang digunakan dalam algoritma genetik untuk memilih individu dari populasi berdasarkan nilai fitness mereka. Metode ini memberikan probabilitas pemilihan yang lebih tinggi kepada individu dengan fitness yang lebih tinggi.

Mari kita bahas setiap bagian dari kode tersebut:

function Pindex = RouletteWheel(UkPop, LinearFitness)
  • UkPop: Jumlah individu dalam populasi.
  • LinearFitness: Vektor yang berisi nilai fitness baru dari setiap individu, hasil dari proses skala linear.

Proses dalam Fungsi

  1. Hitung Jumlah Fitness:


    JumFitness = sum(LinearFitness);
    • JumFitness adalah total dari semua nilai fitness dalam LinearFitness.
    • Ini digunakan untuk menghitung probabilitas kumulatif masing-masing individu.

  2. Inisialisasi Variabel:


    KumulatifFitness = 0;
    RN = rand;
    ii = 1;
    • KumulatifFitness menyimpan jumlah kumulatif fitness yang akan dibandingkan dengan angka acak.
    • RN adalah angka acak yang dihasilkan dari distribusi uniform [0,1], digunakan untuk menentukan individu yang terpilih.
    • ii adalah indeks yang digunakan untuk iterasi melalui populasi.

  3. Pemilihan Berdasarkan Roda Roulette:


    while ii <= UkPop
      KumulatifFitness = KumulatifFitness + LinearFitness(ii);
      if (KumulatifFitness / JumFitness) > RN
        Pindex = ii;
        break;
      end
      ii = ii + 1;
    end
    • Loop: Iterasi melalui setiap individu dalam populasi (ii dari 1 sampai UkPop).
      • Tambahkan nilai fitness individu saat ini (LinearFitness(ii)) ke KumulatifFitness.
      • Hitung proporsi kumulatif fitness terhadap total fitness (KumulatifFitness / JumFitness).
      • Jika proporsi kumulatif ini melebihi angka acak RN, individu saat ini (ii) dipilih dan loop dihentikan dengan break.
      • Jika tidak, lanjutkan ke individu berikutnya (ii = ii + 1).

Penjelasan Metode Roda Roulette

  • Roda Roulette: Metode ini bekerja seperti roda roulette dalam permainan kasino, di mana bagian dari roda sesuai dengan probabilitas proporsional individu dalam populasi.
  • Proporsi Kumulatif: KumulatifFitness / JumFitness adalah probabilitas kumulatif yang menggambarkan berapa bagian dari total fitness yang telah "dilewati" saat mengiterasi.
  • Pemilihan Individu: Angka acak RN membagi total fitness menjadi beberapa segmen. Jika proporsi kumulatif melebihi RN, individu yang terpilih adalah individu yang saat ini sedang diiterasi.

Contoh

Misalkan ada 4 individu dengan nilai fitness sebagai berikut:

  • LinearFitness: [10, 20, 30, 40]
  • UkPop: 4

  1. Hitung Total Fitness:


    JumFitness = sum([10, 20, 30, 40]) = 100;

  2. Generate Random Number:


    RN = rand; % Misalkan RN = 0.65

  3. Iterasi dan Kumulatif Fitness:

    • Individu 1:

      • KumulatifFitness = 10
      • KumulatifFitness / JumFitness = 10 / 100 = 0.10 (0.10 < 0.65)
      • Lanjutkan ke individu berikutnya.

    • Individu 2:

      • KumulatifFitness = 10 + 20 = 30
      • KumulatifFitness / JumFitness = 30 / 100 = 0.30 (0.30 < 0.65)
      • Lanjutkan ke individu berikutnya.

    • Individu 3:

      • KumulatifFitness = 30 + 30 = 60
      • KumulatifFitness / JumFitness = 60 / 100 = 0.60 (0.60 < 0.65)
      • Lanjutkan ke individu berikutnya.

    • Individu 4:

      • KumulatifFitness = 60 + 40 = 100
      • KumulatifFitness / JumFitness = 100 / 100 = 1.00 (1.00 > 0.65)
      • Individu 4 terpilih karena proporsi kumulatif melebihi RN.

Ringkasan

Fungsi RouletteWheel memilih individu dari populasi berdasarkan nilai fitness mereka menggunakan metode pemilihan berbasis roda roulette. Individu dengan fitness lebih tinggi memiliki probabilitas lebih besar untuk dipilih. Metode ini memungkinkan setiap individu dalam populasi memiliki kesempatan untuk dipilih sesuai dengan kontribusi fitness mereka.


          
Program
%===============================================================================
% Memindah-silangkan bagian kromosom Bapak dan Ibu yang dipotong
% secara random, sehingga dihasilkan dua buah kromosom Anak
%
% Masukan
% Bapak : kromosom, matriks berukuran 1 x JumGen
% Ibu : kromosom, matriks berukuran 1 x JumGen
% JumGen : jumlah gen
%
% Keluaran
% Anak : kromosom hasil pindah silang, matriks berukuran 1 x JumGen
%===============================================================================
function Anak = PindahSilang(Bapak,Ibu,JumGen);
% Membangkitkan satu titik potong (TP bernilai antara 1 sampai JumGen-1)
TP = 1 + fix(rand*(JumGen-1));
% Anak 1 berisi bagian depan Bapak dan bagian belakang Ibu
Anak(1,:) = [Bapak(1:TP) Ibu(TP+1:JumGen)];
Anak(2,:) = [Ibu(1:TP) Bapak(TP+1:JumGen)];

Fungsi PindahSilang ini merupakan implementasi dari operasi crossover (atau pemindahan silang) dalam algoritma genetik. Tujuannya adalah untuk menghasilkan individu baru (anak) dengan menggabungkan bagian-bagian dari dua individu orang tua (Bapak dan Ibu). Operasi ini merupakan langkah penting dalam algoritma genetik untuk menciptakan variasi genetik dan mengeksplorasi solusi baru.

Mari kita bahas kode fungsi PindahSilang secara rinci:

function Anak = PindahSilang(Bapak, Ibu, JumGen)
  • Bapak: Kromosom individu pertama (orang tua) yang akan digunakan dalam crossover.
  • Ibu: Kromosom individu kedua (orang tua) yang akan digunakan dalam crossover.
  • JumGen: Jumlah gen dalam setiap kromosom, yang merupakan panjang dari kromosom Bapak dan Ibu.

Proses dalam Fungsi

  1. Membangkitkan Titik Potong:


    TP = 1 + fix(rand * (JumGen - 1));
    • TP: Titik potong untuk crossover, yang ditentukan secara acak antara 1 dan JumGen-1. Titik ini adalah tempat di mana kromosom akan dipotong dan digabungkan.
    • rand menghasilkan angka acak antara 0 dan 1.
    • fix(rand * (JumGen - 1)) menghasilkan angka acak bulat antara 0 dan JumGen - 2.
    • Menambahkan 1 memastikan titik potong berada dalam rentang 1 hingga JumGen-1.

  2. Menghasilkan Anak dari Crossover:


    Anak(1, :) = [Bapak(1:TP) Ibu(TP+1:JumGen)];
    Anak(2, :) = [Ibu(1:TP) Bapak(TP+1:JumGen)];

    • Anak 1: Menggabungkan bagian depan dari Bapak hingga titik potong TP dengan bagian belakang dari Ibu setelah titik potong TP.

      • Bapak(1:TP) mengambil gen dari posisi 1 hingga TP dari kromosom Bapak.
      • Ibu(TP+1:JumGen) mengambil gen dari posisi TP+1 hingga akhir kromosom Ibu.
      • Anak(1, :) menyimpan hasil gabungan ini sebagai kromosom pertama dari anak.

    • Anak 2: Menggabungkan bagian depan dari Ibu hingga titik potong TP dengan bagian belakang dari Bapak setelah titik potong TP.

      • Ibu(1:TP) mengambil gen dari posisi 1 hingga TP dari kromosom Ibu.
      • Bapak(TP+1:JumGen) mengambil gen dari posisi TP+1 hingga akhir kromosom Bapak.
      • Anak(2, :) menyimpan hasil gabungan ini sebagai kromosom kedua dari anak.

Contoh

Misalkan kita memiliki dua kromosom orang tua berikut:

  • Bapak: [1, 2, 3, 4, 5, 6, 7, 8]
  • Ibu: [8, 7, 6, 5, 4, 3, 2, 1]
  • JumGen: 8

  1. Membuat Titik Potong:

    Misalkan TP = 4.

  2. Menghasilkan Anak:

    • Anak 1:

      • Bagian depan dari Bapak hingga TP: [1, 2, 3, 4]
      • Bagian belakang dari Ibu setelah TP: [5, 4, 3, 2, 1]
      • Gabungan: [1, 2, 3, 4, 5, 4, 3, 2]

    • Anak 2:

      • Bagian depan dari Ibu hingga TP: [8, 7, 6, 5]
      • Bagian belakang dari Bapak setelah TP: [6, 7, 8]
      • Gabungan: [8, 7, 6, 5, 6, 7, 8, 1]

Ringkasan

Fungsi PindahSilang menggunakan metode crossover satu titik untuk menggabungkan gen dari dua individu orang tua (Bapak dan Ibu) untuk menghasilkan dua individu anak. Titik potong dipilih secara acak, dan gen sebelum titik potong diambil dari satu orang tua, sedangkan gen setelah titik potong diambil dari orang tua lainnya. Ini memungkinkan eksplorasi solusi baru dalam ruang pencarian algoritma genetik dan memperkenalkan variasi dalam populasi.


         Program
%===============================================================================
% Mutasi gen dengan probabilitas sebesar Pmutasi
% Gen-gen yang terpilih diubah nilainya: 0 menjadi 1, dan 1 menjadi 0
%
% Masukan
% Kromosom : kromosom, matriks berukuran 1 x JumGen
% JumGen : jumlah gen
% Pmutasi : Probabilitas mutasi
%
% Keluaran
% MutKrom : kromosom hasil mutasi, matriks berukuran 1 x JumGen
%===============================================================================
function MutKrom = Mutasi(Kromosom, JumGen, Pmutasi)
% Mendefinisikan fungsi bernama Mutasi
% yang menerima tiga argumen: Kromosom (vektor kromosom), JumGen (jumlah gen), dan Pmutasi (probabilitas mutasi)
% Output dari fungsi ini adalah variabel MutKrom
MutKrom = Kromosom;
% Menginisialisasi MutKrom dengan salinan dari Kromosom
for ii = 1:JumGen
% Memulai loop dari 1 hingga JumGen (jumlah gen)
if (rand < Pmutasi)
% Jika nilai acak antara 0 dan 1 lebih kecil dari Pmutasi,
% lakukan mutasi pada gen tersebut
if Kromosom(ii) == 0
% Jika gen saat ini bernilai 0
MutKrom(ii) = 1;
% Set gen tersebut menjadi 1
else
% Jika gen saat ini bernilai 1
MutKrom(ii) = 0;
% Set gen tersebut menjadi 0
end
end
end
          Untuk menampilkan grafis 2D dari AG.
          Syntax-nya sebagai berikut :
%===============================================================================
% Algoritma Genetika Standar (dengan grafis 2D) terdiri dari:
%
% 1. Satu populasi dengan UkPop kromosom
% 2. Binary encoding
% 3. Linear fitness ranking
% 4. Roulette-wheel selection
% 5. Pindah silang satu titik potong
% 6. Probabilitas pindah silang dan probabilitas mutasi bernilai tetap
% 7. Elitisme, satu atau dua buah kopi dari individu bernilai fitness tertinggi
% 8. Generational replacement: mengganti semua individu dengan individu baru
%===============================================================================
clc % Me-refresh command window
clear % Menghapus semua semua variabel yang sedang aktif
Nvar = 2; % Jumlah variabel pada fungsi yang dioptimasi
Nbit = 10; % Jumlah bit yang mengkodekan satu variabel
JumGen = Nbit*Nvar; % Jumlah gen dalam kromosom
Rb = -5.12; % Batas bawah interval
Ra = 5.12; % Batas atas interval
UkPop = 200; % Jumlah kromosom dalam populasi
Psilang = 0.8; % Probabilitas pindah silang
Pmutasi = 0.05; % Probabilitas mutasi
MaxG = 100; % Jumlah generasi
BilKecil = 10^-1; % Digunakan untuk menghindari pembagian dengan 0
Fthreshold = 1/BilKecil; % Threshold untuk nilai Fitness
Bgraf = Fthreshold; % Untuk menangani tampilan grafis
% Inisialisasi grafis 2D
hfig = figure;
hold on
title('Optimasi fungsi menggunakan AG standar dengan grafis 2 dimensi')
set(hfig, 'position', [50,50,600,400]);
set(hfig, 'DoubleBuffer', 'on');
axis([1 MaxG 0 Bgraf]);
hbestplot = plot(1:MaxG,zeros(1,MaxG));
htext1 = text(0.6*MaxG,0.30*Bgraf,sprintf('Fitness terbaik: %7.4f', 0.0));
htext2 = text(0.6*MaxG,0.25*Bgraf,sprintf('Variabel X1: %5.4f', 0.0));
htext3 = text(0.6*MaxG,0.20*Bgraf,sprintf('Variabel X2: %5.4f', 0.0));
htext4 = text(0.6*MaxG,0.15*Bgraf,sprintf('Nilai minimum: %5.4f', 0.0));
htext5 = text(0.6*MaxG,0.10*Bgraf,sprintf('Ukuran populasi: %3.0f', 0.0));
htext6 = text(0.6*MaxG,0.05*Bgraf,sprintf('Probabilitas mutasi: %5.4f', 0.0));
xlabel('Generasi');
ylabel('Fitness terbaik');
hold off
drawnow;
% Inisialisasi populasi
Populasi = InisialisasiPopulasi(UkPop, JumGen);
% Menginisialisasi populasi dengan memanggil fungsi InisialisasiPopulasi
% yang menghasilkan matriks populasi dengan ukuran UkPop x JumGen
% Loop evolusi
for generasi = 1:MaxG
% Memulai loop untuk setiap generasi dari 1 hingga MaxG (jumlah generasi maksimum)
x = DekodekanKromosom(Populasi(1,:), Nvar, Nbit, Ra, Rb);
% Mendekode kromosom pertama dari populasi untuk mendapatkan variabel x
Fitness(1) = EvaluasiIndividu(x, BilKecil);
% Menghitung fitness dari individu pertama dan menyimpannya dalam array Fitness
MaxF = Fitness(1);
MinF = Fitness(1);
IndeksIndividuTerbaik = 1;
% Menginisialisasi nilai maksimum dan minimum fitness, serta indeks individu terbaik
for ii = 2:UkPop
% Memulai loop untuk setiap individu dalam populasi mulai dari individu kedua
Kromosom = Populasi(ii, :);
% Mengambil kromosom individu ke-ii dari populasi
x = DekodekanKromosom(Kromosom, Nvar, Nbit, Ra, Rb);
% Mendekode kromosom untuk mendapatkan variabel x
Fitness(ii) = EvaluasiIndividu(x, BilKecil);
% Menghitung fitness dari individu ke-ii dan menyimpannya dalam array Fitness
if (Fitness(ii) > MaxF)
% Jika fitness individu ke-ii lebih besar dari MaxF
MaxF = Fitness(ii);
IndeksIndividuTerbaik = ii;
BestX = x;
% Memperbarui nilai MaxF, indeks individu terbaik, dan variabel BestX
end
if (Fitness(ii) < MinF)
% Jika fitness individu ke-ii lebih kecil dari MinF
MinF = Fitness(ii);
% Memperbarui nilai MinF
end
end
% Penanganan grafis 2D
plotvector = get(hbestplot, 'YData');
% Mendapatkan data Y dari plot grafis hbestplot
plotvector(generasi) = MaxF;
% Memperbarui data Y untuk generasi ke-g
set(hbestplot, 'YData', plotvector);
% Mengatur data Y dari plot grafis hbestplot dengan data yang diperbarui
set(htext1, 'String', sprintf('Fitness terbaik: %7.4f', MaxF));
% Memperbarui teks pada htext1 untuk menampilkan fitness terbaik
set(htext2, 'String', sprintf('Variabel X1: %5.4f', BestX(1)));
% Memperbarui teks pada htext2 untuk menampilkan variabel X1
set(htext3, 'String', sprintf('Variabel X2: %5.4f', BestX(2)));
% Memperbarui teks pada htext3 untuk menampilkan variabel X2
set(htext4, 'String', sprintf('Nilai minimum: %5.4f', (1/MaxF) - BilKecil));
% Memperbarui teks pada htext4 untuk menampilkan nilai minimum
set(htext5, 'String', sprintf('Ukuran populasi: %3.0f', UkPop));
% Memperbarui teks pada htext5 untuk menampilkan ukuran populasi
set(htext6, 'String', sprintf('Probabilitas mutasi: %5.4f', Pmutasi));
% Memperbarui teks pada htext6 untuk menampilkan probabilitas mutasi
drawnow
% Memperbarui tampilan grafis agar perubahan segera terlihat
if MaxF >= Fthreshold
% Jika fitness maksimum lebih besar atau sama dengan ambang batas fitness
break;
% Keluar dari loop jika kondisi terpenuhi
end
TempPopulasi = Populasi;
% Menyalin populasi saat ini ke variabel sementara TempPopulasi
% Elitisme:
% - Buat satu kopi kromosom terbaik jika ukuran populasi ganjil
% - Buat dua kopi kromosom terbaik jika ukuran populasi genap
if mod(UkPop, 2) == 0
% Jika ukuran populasi genap
IterasiMulai = 3;
TempPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
TempPopulasi(2, :) = Populasi(IndeksIndividuTerbaik, :);
% Salin kromosom terbaik ke dua posisi pertama dalam populasi sementara
else
% Jika ukuran populasi ganjil
IterasiMulai = 2;
TempPopulasi(1, :) = Populasi(IndeksIndividuTerbaik, :);
% Salin kromosom terbaik ke posisi pertama dalam populasi sementara
end
LinearFitness = LinearFitnessRanking(UkPop, Fitness, MaxF, MinF);
% Menghitung ranking fitness linear dari populasi
% Roulette-wheel selection dan pindah silang
for jj = IterasiMulai:2:UkPop
% Memulai loop dari IterasiMulai hingga UkPop dengan langkah 2 (untuk pasangan kromosom)
IP1 = RouletteWheel(UkPop, LinearFitness);
% Memilih individu pertama untuk crossover menggunakan seleksi roda roulette
IP2 = RouletteWheel(UkPop, LinearFitness);
% Memilih individu kedua untuk crossover menggunakan seleksi roda roulette
if (rand < Psilang)
% Jika nilai acak kurang dari probabilitas crossover
Anak = PindahSilang(Populasi(IP1, :), Populasi(IP2, :), JumGen);
% Melakukan crossover untuk menghasilkan dua anak
TempPopulasi(jj, :) = Anak(1, :);
TempPopulasi(jj + 1, :) = Anak(2, :);
% Menyimpan anak-anak hasil crossover ke dalam populasi sementara
else
TempPopulasi(jj, :) = Populasi(IP1, :);
TempPopulasi(jj + 1, :) = Populasi(IP2, :);
% Menyalin individu tanpa crossover jika probabilitas crossover tidak terpenuhi
end
end
% Mutasi dilakukan pada semua kromosom
for kk = IterasiMulai:UkPop
% Memulai loop untuk semua individu dalam populasi mulai dari IterasiMulai
TempPopulasi(kk, :) = Mutasi(TempPopulasi(kk, :), JumGen, Pmutasi);
% Melakukan mutasi pada individu ke-kk dalam populasi sementara
end
% Generational Replacement: mengganti semua kromosom sekaligus
Populasi = TempPopulasi;
% Menggantikan populasi lama dengan populasi sementara yang telah dimutasi
end

           Program:
%===============================================================================
% Algoritma Genetika Standar (dengan grafis 3D) terdiri dari:
%
% 1. Satu populasi dengan UkPop kromosom
% 2. Binary encoding
% 3. Linear fitness ranking
% 4. Roulette-wheel selection
% 5. Pindah silang satu titik potong
% 6. Probabilitas pindah silang dan probabilitas mutasi bernilai tetap
% 7. Elitisme, satu atau dua buah kopi dari individu bernilai fitness tertinggi
% 8. Generational replacement: mengganti semua individu dengan individu baru
%===============================================================================
clc % Me-refresh command window
clear all % Menghapus semua semua variabel yang sedang aktif
Nvar = 2; % Jumlah variabel pada fungsi yang dioptimasi
Nbit = 10; % Jumlah bit yang mengkodekan satu variabel
JumGen = Nbit*Nvar; % Jumlah gen dalam kromosom
Rb = -5.12; % Batas bawah interval
Ra = 5.12; % Batas atas interval
UkPop = 200; % Jumlah kromosom dalam populasi
Psilang = 0.8; % Probabilitas pindah silang
Pmutasi = 0.05; % Probabilitas mutasi
MaxG = 100; % Jumlah generasi
BilKecil = 10^-1; % Digunakan untuk menghindari pembagian dengan 0
Fthreshold = 1/BilKecil; % Threshold untuk nilai Fitness
Bgraf = Fthreshold; % Untuk menangani tampilan grafis
% Inisialisasi grafis 3D
hfig = figure;
hold on;
title('Optimasi fungsi menggunakan AG standar dengan grafis 3 dimensi')
set(hfig, 'DoubleBuffer','on');
delta = 0.02;
limit = fix(2*Ra/delta) + 1;
[xg,yg] = meshgrid(Rb:delta:Ra,Rb:delta:Ra);
zg = zeros(limit,limit);
for j = 1:limit
for k = 1:limit
zg(j,k) = EvaluasiIndividu([xg(j,k) yg(j,k)], BilKecil);
end
end
surfl(xg,yg,zg)
colormap gray;
shading interp;
view([3 5 2]);
xind = zeros(UkPop,3);
h_indplot = plot3(xind(:,1),xind(:,2),xind(:,3),'k*');
hold off
drawnow
% Inisialisasi populasi
Populasi = InisialisasiPopulasi(UkPop,JumGen);
% Loop evolusi
for generasi=1:MaxG,
x = DekodekanKromosom(Populasi(1,:),Nvar,Nbit,Ra,Rb);
Fitness(1) = EvaluasiIndividu(x,BilKecil);
% xind digunakan untuk tampilan grafis
xind(1,1) = x(1);
xind(1,2) = x(2);
xind(1,3) = Fitness(1);
MaxF = Fitness(1);
MinF = Fitness(1);
IndeksIndividuTerbaik = 1;
for ii=2:UkPop,
Kromosom = Populasi(ii,:);
x = DekodekanKromosom(Kromosom,Nvar,Nbit,Ra,Rb);
Fitness(ii) = EvaluasiIndividu(x,BilKecil);
% xind digunakan untuk tampilan grafis
xind(ii,1) = x(1);
xind(ii,2) = x(2);
xind(ii,3) = Fitness(ii);
if (Fitness(ii) > MaxF),
MaxF = Fitness(ii);
IndeksIndividuTerbaik = ii;
BestX = x;
end
if (Fitness(ii) < MinF),
MinF = Fitness(ii);
end
end
% Penanganan grafis 3D
set(h_indplot,'XData',xind(:,1),'YData',xind(:,2),'ZData',xind(:,3));
drawnow;
if MaxF >= Fthreshold,
break;
end
TempPopulasi = Populasi;
% Elitisme:
% - Buat satu kopi kromosom terbaik jika ukuran populasi ganjil
% - Buat dua kopi kromosom terbaik jika ukuran populasi genap
if mod(UkPop,2)==0, % ukuran populasi genap
IterasiMulai = 3;
TempPopulasi(1,:) = Populasi(IndeksIndividuTerbaik,:);
TempPopulasi(2,:) = Populasi(IndeksIndividuTerbaik,:);
else % ukuran populasi ganjil
IterasiMulai = 2;
TempPopulasi(1,:) = Populasi(IndeksIndividuTerbaik,:);
end
LinearFitness = LinearFitnessRanking(UkPop,Fitness,MaxF,MinF);
% Roulette-wheel selection dan pindah silang
for jj=IterasiMulai:2:UkPop,
IP1 = RouletteWheel(UkPop,LinearFitness);
IP2 = RouletteWheel(UkPop,LinearFitness);
if (rand < Psilang),
Anak = PindahSilang(Populasi(IP1,:),Populasi(IP2,:),JumGen);
TempPopulasi(jj,:) = Anak(1,:);
TempPopulasi(jj+1,:) = Anak(2,:);
else
TempPopulasi(jj,:) = Populasi(IP1,:);
TempPopulasi(jj+1,:) = Populasi(IP2,:);
end
end
% Mutasi dilakukan pada semua kromosom
for kk=IterasiMulai:UkPop,
TempPopulasi(kk,:) = Mutasi(TempPopulasi(kk,:),JumGen,Pmutasi);
end
% Generational Replacement: mengganti semua kromosom sekaligus
Populasi = TempPopulasi;
end





     
    Terdapat tiga variabel utama yang harus ditentukan oleh user, yaitu: 
  1. UkPop (30-1000)
  2. Psilang (0,6-0,9)
  3. Pmutasi (1/jumlah gen)
Program
%===============================================================================
% Mencari parameter optimal: ukuran populasi dan probabilitas mutasi
%
% Pencarian parameter optimal dilakukan dengan mengkombinasikan kedua
% parameter tersebut. Dalam observasi ini, digunakan empat nilai untuk
% masing-masing parameter, sehingga diperoleh 16 kombinasi.
% Nilai untuk kedua parameter adalah sebagai berikut:
% - UkPop: 50, 100, 200, dan 400
% - Pmutasi: 0.01, 0.05, 0.1, dan 0.2
%===============================================================================
clc % Me-refresh command window
clear all % Menghapus semua semua variabel yang sedang aktif
Nvar = 2; % Jumlah variabel pada fungsi yang dioptimasi
Nbit = 10; % Jumlah bit yang mengkodekan satu variabel
JumGen = Nbit*Nvar; % Jumlah gen dalam kromosom
Rb = -5.12; % Batas bawah interval
Ra = 5.12; % Batas atas interval
Psilang = 0.8; % Probabilitas pindah silang
MaxJumInd = 60000; % Jumlah individu maksimum yang dievaluasi
BilKecil = 10^-1; % Digunakan untuk menghindari pembagian dengan 0
Fthreshold = 1/BilKecil; % Threshold untuk nilai Fitness
Bgraf = Fthreshold; % Untuk menangani tampilan grafis
ObUkPop = [50 100 200 400]; % Ukuran populasi yang diobservasi
ObPmutasi = [0.01 0.05 0.1 0.2]; % Probabilitas mutasi yang diobservasi
ObData = []; % Data hasil observasi
for ukp=1:length(ObUkPop),
UkPop = ObUkPop(ukp);
MaxG = fix(MaxJumInd/UkPop);
for pm=1:length(ObPmutasi),
Pmutasi = ObPmutasi(pm);
for observasi=1:10,
UkPop, Pmutasi, observasi
% Inisialisasi populasi
Populasi = InisialisasiPopulasi(UkPop,JumGen);
% Loop evolusi
for generasi=1:MaxG,
x = DekodekanKromosom(Populasi(1,:),Nvar,Nbit,Ra,Rb);
Fitness(1) = EvaluasiIndividu(x,BilKecil);
MaxF = Fitness(1);
MinF = Fitness(1);
IndeksIndividuTerbaik = 1;
for ii=2:UkPop,
Kromosom = Populasi(ii,:);
x = DekodekanKromosom(Kromosom,Nvar,Nbit,Ra,Rb);
Fitness(ii) = EvaluasiIndividu(x,BilKecil);
if (Fitness(ii) > MaxF),
MaxF = Fitness(ii);
IndeksIndividuTerbaik = ii;
BestX = x;
end
if (Fitness(ii) < MinF),
MinF = Fitness(ii);
end
end
TempPopulasi = Populasi;
% Elitisme:
% - Buat satu kopi kromosom terbaik jika ukuran populasi ganjil
% - Buat dua kopi kromosom terbaik jika ukuran populasi genap
if mod(UkPop,2)==0, % ukuran populasi genap
IterasiMulai = 3;
TempPopulasi(1,:) = Populasi(IndeksIndividuTerbaik,:);
TempPopulasi(2,:) = Populasi(IndeksIndividuTerbaik,:);
else % ukuran populasi ganjil
IterasiMulai = 2;
TempPopulasi(1,:) = Populasi(IndeksIndividuTerbaik,:);
end
LinearFitness = LinearFitnessRanking(UkPop,Fitness,MaxF,MinF);
% Roulette-wheel selection dan pindah silang
for jj=IterasiMulai:2:UkPop,
IP1 = RouletteWheel(UkPop,LinearFitness);
IP2 = RouletteWheel(UkPop,LinearFitness);
if (rand < Psilang),
Anak = PindahSilang(Populasi(IP1,:),Populasi(IP2,:),JumGen);
TempPopulasi(jj,:) = Anak(1,:);
TempPopulasi(jj+1,:) = Anak(2,:);
else
TempPopulasi(jj,:) = Populasi(IP1,:);
TempPopulasi(jj+1,:) = Populasi(IP2,:);
end
end
% Mutasi dilakukan pada semua kromosom
for kk=IterasiMulai:UkPop,
TempPopulasi(kk,:) = Mutasi(TempPopulasi(kk,:),JumGen,Pmutasi);
end
% Generational Replacement: mengganti semua kromosom sekaligus
Populasi = TempPopulasi;
if MaxF >= Fthreshold,
JumIndData(observasi) = generasi*UkPop;
MaxFData(observasi) = MaxF;
break;
else
if generasi == MaxG,
JumIndData(observasi) = MaxG*UkPop;
MaxFData(observasi) = MaxF;
end
end
end % loop evolusi
end % loop observasi
ObData = [ObData ; [UkPop Pmutasi mean(MaxFData) mean(JumIndData)]];
end
end
save ObData.mat ObData
clc % me-refresh layar
disp(['Mencari nilai optimal: Ukuran Populasi dan Prob. Mutasi ']);
disp(['Jumlah maksimum individu yang dievaluasi adalah ', num2str(MaxJumInd)]);
disp([' ']);
disp(['--------------------------------------------------------']);
disp(['Ukuran Probabilas Rata-rata Rata-rata ']);
disp(['Poulasi mutation Fitness Jumlah individu']);
disp(['--------------------------------------------------------']);
for ii=1:length(ObData(:,1)),
disp([' ', num2str(ObData(ii,1)),' ', num2str(ObData(ii,2)), ...
' ', num2str(ObData(ii,3)),' ', num2str(ObData(ii,4))]);
end
disp(['--------------------------------------------------------']);
    




VIDEO SIMULASI:
Bagian 1


Bagian 2


Bagian 3

Vidio Penjelasan mengenai AG



Tidak ada komentar:

Posting Komentar

Langganan: Postingan (Atom)

Bahan Presentasi Untuk Matakuliah Sistem Digital 2023 OLEH: Fadhila Amanda 2110952031 Dosen Pengampu: Dr. Darwison,MT Referensi: a. Anil K. ...

  • (tanpa judul)
      Bahan Presentasi Untuk Matakuliah Elektronika 2022 OLEH: Fadhila Amanda 2110952031 Elektronika C Dosen Pengampu: Darwison,MT Referensi: a....
  • (tanpa judul)
    Bahan Presentasi Untuk Matakuliah Sistem Digital 2023 OLEH: Fadhila Amanda 2110952031 Dosen Pengampu: Dr. Darwison,MT Referensi: a. Anil K. ...