Workshop Algoritma Genetika

Document Sample
Workshop Algoritma Genetika Powered By Docstoc
					Algoritma Genetika
Algoritma Genetika
               Representasi Kromosom


               Membangkitkan Populasi
                      Awal

                   Hitung Fitness


                       Seleksi


                 Perkawinan Silang


                       Mutasi


                    Individu Baru


       Tidak                            Ya
                      Optimal ?              Solusi Optimal
Aplikasi Algoritma Genetika

 • Aplikasi GA untuk mencari nilai maksimal dari
   suatu fungsi
 • Aplikasi GA untuk penyelesaian TSP
 • Aplikasi GA untuk optimasi Radio Base Station
 • Aplikasi GA pada peramalan Data Time Series
 • Aplikasi GA untuk mencari kata
Aplikasi Algoritma Genetika untuk Mencari Nilai
Maksimal dari Fungsi f(x)=1+e-xsin(4x)



•   Definisi Individu
•   Nilai Fitness
•   Seleksi roulette whell
•   Two point crossover
•   Mutasi gen
Definisi Individu
• Individu menyatakan solusi yaitu nilai x.
• Nilai x sebagai individu dinyatakan dalam nilai biner.
• Individu dinyatakan dalam 8 gen biner dengan batas 0
  sampai dengan 1 yang berarti sat bit setara dengan 2-8
• Sebagai contoh:
   10001001 = (128+8+1)/256 = 0.5352
   01010010 = (2+16+64)/256 = 0.3203


Fungsi Fitness
• Fungsi fitness dinyatakan sebagai fungsi f(x), karena
  yang dicari adalah nilai maksimum.
Membangkitkan Populasi Awal
Membangkitkan sejumlah individu,        For i = 1 To 8
misalkan satu populasi terdiri dari 8     For j = 1 To 8
individu, maka dibangkitkan 8                individu(i, j) = Int(2 * Rnd)
individu dengan 8 gen biner yang          Next j
dibangkitkan secara acak.               Next i


                                                           Hitung Fitness

                                        For i = 1 To 8
                                          d=0
                                          For j = 8 To 1 Step -1
                                             k=8-j
                                             d = d + individu(i, j) * 2 ^ k
                                          Next j
                                          X(i) = d / 255
                                          fitness(i) = 1 + Exp(-X(i)) * Sin(4 * X(i))
                                        Next i
Seleksi (1)                            Hitung Total Fitness

Seleksi roulette whell untuk memilih           Jfitness = 0
induk dilakukan dengan                         For i = 1 To 8
                                                 Jfitness = Jfitness + fitness(i)
menggunakan prosentasi fitness
                                               Next i
setiap individu, dimana setiap
individu mendapatkan luas bagian
sesuai dengan prosentase nilai       Menghitung prosentase
fitnessnya.                          fitness dan penentuan
                                     bidang

                                                    k=0
                                                    For i = 1 To 8
                                                      prosen = Int(100 * fitness(i) /
                                                    Jfitness)
                                                      Text3(i - 1) = prosen
                                                      For j = 1 To prosen
                                                         k=k+1
                                                         rolet(k) = i
                                                      Next j
                                                    Next i
Seleksi (2)            For i = 1 To 8
                         r = Int(k * Rnd) + 1
                         pilih = rolet(r)
                         Text4(i - 1) = pilih
                         For j = 1 To 8
  Pemutaran Roulette
                           induk(i, j) = individu(pilih, j)
                         Next j
                       Next i
Perkawinan Silang
Cross-Over (Perkawinan Silang) dilakukan dengan menentukan 2 posisi awal dan
akhir gen pada individu yang akan dikawinkan secara acak. Kemudian dilakukan
penukaran nilai gen induk 1 dan induk 2 dari posisi awal sampai dengan posisi
akhir untuk diperoleh anak 1 dan anak 2.

                                           For i = 1 To 4
                                             p = Rnd
                                             If p < probCO Then
                                                r1 = Int(8 * Rnd) + 1
                                                r2 = Int((8 - r1) * Rnd) + r1
                                                For j = r1 To r2
                                                  anak(2 * i - 1, j) = induk(2 * i, j)
                                                  anak(2 * i, j) = induk(2 * i - 1, j)
                                                Next j
                                             End If
                                           Next i
Mutasi
Mutasi dilakukan dengan cara mengganti gen dengan nilai
inversinya, gen 0 menjadi 1 dan gen 1 menjadi 0 pada posisi gen
yang ditentukan secara acak.



                                    For i = 1 To 8
                                      p = Rnd
                                      If p < probMut Then
                                          r = Int(8 * Rnd) + 1
                                          anak(i, r) = 1 - anak(i, r)
                                    End If
                                    Next i
 Membentuk Individu Baru
                                         For i = 1 To 8
Anak hasil perkawinan silang dan
                                           For j = 1 To 8
mutasi menjadi generasi baru untuk            individu(i, j) = anak(i, j)
dilakukan proses regenerasi                Next j
                                         Next i
Pada generasi berikutnya, individu
terbaik (nilai fitness terbesar) dapat
dipertahankan dengan proses elitism
                                         kmin = 1
                                         fitnessmin = fitness(1)
                                         For i = 2 To 8
                                            If fitness(i) < fitnessmin Then
                                               kmin = i
                                               fitnessmin = fitness(i)
                                            End If
                                         Next i
                                         fitness(kmin) = fitnessmaks
                                         For i = 1 To 8
                                            individu(kmin, i) = individumaks(i)
                                         Next i
Contoh Hasil Algoritma Genetika


Generasi 1        Generasi 2
Contoh Hasil Algoritma Genetika


Generasi 3        Generasi 4
Aplikasi Algoritma Genetika untuk Penyelesaian
Permasalahan Traveling Salesman Problem
Permasalahan pada TSP adalah bagaimana seorang sales dapat
mengunjungi setiap kota dengan jarak yang paling pendek.
Pada contoh aplikasi GA untuk TSP, ditentukan 8 kota dengan
posisi koordinat (x, y).
Definisi Individu
• Individu menyatakan urutan kota yang dinyatakan dalam nilai
  integer 1 sampai dengan 8 sebanyak 9 gen (8 gen urutan kota
  dan 1 gen terakhir merupakan duplikat dari gen pertama)
• Sebagai contoh:
   718354627
   384265173




Fungsi Fitness
• Fungsi fitness dinyatakan sebagai kebalikan dari nilai kuadrat
  jarak dari urutan kota.
                              9
         Fitness  1000   ( xi  xi 1 ) 2  ( yi  yi 1 ) 2
                             i 2
    Membangkitkan Populasi Awal (1)
                                                                     For i = 1 To 8
                                                                       jumlah = 0
                                                                       For j = 1 To 7
  Membangkitkan sejumlah individu,                                         sw = 0
  misalkan satu populasi terdiri dari 8                                    While sw = 0
                                                                              r = Int(Rnd * 8) + 1
  individu, maka dibangkitkan 8                                               sw = 1
  individu dengan 9 gen integer yang                                          For k = 1 To j - 1
                                                                                 If r = individu(i, k) Then sw = 0
  dibangkitkan secara acak (nilai 1                                           Next k
  sampai dengan 8)                                                         Wend
                                                                           individu(i, j) = r
                                                                           jumlah = jumlah + r
                                                                       Next j
                                                                       individu(i, 8) = 36 - jumlah
                                                                       individu(i, 9) = individu(i, 1)
                                                                     Next i
For i = 1 To 8
  Z=0
  For j = 2 To 9
     r1 = individu(i, j)
     r2 = individu(i, j - 1)
     d = ((xkota(r1) - xkota(r2)) ^ 2 + (ykota(r1) - ykota(r2)) ^ 2) ^ 0.5
     Z=Z+d
                                                                                           Hitung Fitness
  Next j
  fitness(i) = 1000 - Int(Z)
Next i
Membangkitkan Populasi Awal (2)
               Individu maksimum yang diperoleh
               mempunyai urutan 3 8 4 2 6 5 1 7
               dengan nilai fitness terbesar yaitu 648
Seleksi (1)                            Hitung Total Fitness

Seleksi roulette whell untuk memilih           Jfitness = 0
                                               For i = 1 To 8
induk dilakukan dengan
                                                  Jfitness = Jfitness + fitness(i)
menggunakan prosentasi fitness                 Next i
setiap individu, dimana setiap
individu mendapatkan luas bagian
                                     Menghitung prosentase
sesuai dengan prosentase nilai
                                     fitness dan penentuan
fitnessnya.
                                     bidang


                                                    k=0
                                                    For i = 1 To 8
                                                       prosen = Int(100 * fitness(i) /
                                                    Jfitness)
                                                       Text2(i - 1) = prosen
                                                       For j = 1 To prosen
                                                          k=k+1
                                                          rolet(k) = i
                                                       Next j
                                                    Next i
Seleksi (2)           For i = 1 To 8
                        r = Int(k * Rnd) + 1
                        pilih = rolet(r)
                        Text3(i - 1) = pilih
                        For j = 1 To 9
 Pemutaran Roulette         induk(i, j) = individu(pilih, j)
                            m = (i - 1) * 9 + j - 1
                            Text4(m) = induk(i, j)
                        Next j
                      Next i
Perkawinan Silang
Cross-Over (Perkawinan Silang) dilakukan dengan menentukan 2 posisi awal dan
akhir gen pada individu yang akan dikawinkan secara acak. Kemudian dilakukan
penukaran nilai gen induk 1 dan induk 2 dari posisi awal sampai dengan posisi
akhir untuk diperoleh anak 1 dan anak 2.

                                           For i = 1 To 8
                                             p = Rnd
                                             If p < probCO Then
                                                 r1 = Int(Rnd * 8) + 1
                                                 r2 = Int(Rnd * (8 - r1)) + r1
                                                 For r = r1 To r2
                                                    anak(i, r) = induk(i, r2 + r1 - r)
                                                 Next r
                                             End If
                                             anak(i, 9) = anak(i, 1)
                                             k = (i - 1) * 9 + 8
                                           Next i
         Mutasi dilakukan dengan cara menentukan
Mutasi   dua posisi gen secara acak (posisi 1 sampai
         dengan 8) dan melakukan pertukaran nilai
         gen pada kedua posisi tersebut, nilai gen ke
         1 diduplikasi ke nilai gen ke 9
         Contoh :
         Sebelum mutasi : 6 8 7 1 5 3 4 2 6
                  Posisi terpilih adalah 1 dan 8
         Sesudah mutasi : 2 8 7 1 5 3 4 6 2
                   For i = 1 To 8
                     p = Rnd
                     If p <= probMut Then
                        r1 = Int(8 * Rnd) + 1
                        r2 = Int(8 * Rnd) + 1
                        a = anak(i, r1)
                        anak(i, r1) = anak(i, r2)
                        anak(i, r2) = a
                     End If
                     anak(i, 9) = anak(i, 1)
                   Next i
Membentuk Individu Baru
Anak hasil perkawinan silang dan         For i = 1 To 8
                                           For j = 1 To 9
mutasi menjadi generasi baru untuk
                                               individu(i, j) = anak(i, j)
dilakukan proses regenerasi                Next j
                                         Next i
Pada generasi berikutnya, individu
terbaik (nilai fitness terbesar) dapat
dipertahankan dengan proses elitism
Contoh Hasil Algoritma Genetika
Generasi 1       Generasi 2
Contoh Hasil Algoritma Genetika
Generasi 3       Generasi 4
Aplikasi Algoritma Genetika untuk Optimasi
Penempatan Radio Based Station



•   Definisi Individu
•   Nilai Fitness
•   Seleksi roulette wheel
•   Crossover aritmatik
•   Mutasi gen
Definisi Individu
• RBS dibatasi sebanyak 5.
• Setiap individu menyatakan lokasi dari kelima RBS.
• Setiap individu terdiri dari 10 gen yang menyatakan posisi x
  dan y dari tiap RBS.
• Nilai dari gen dinyatakan dengan bilangan integer yang
  dibatasi sesuai dengan ukuran wilayah yang disediakan.
• Ukuran wilayah yang disediakan adalah 60 untuk posisi x &
  40 untuk posisi y.


Fungsi Fitness
• Fungsi fitness dinyatakan sebagai invers dari fungsi
  yang menghitung jumlah blank area paling sedikit.
 Membangkitkan Populasi Awal


Membangkitkan sejumlah individu,        For i = 1 To 8
misalkan satu populasi terdiri dari 8     For k = 1 To 5
                                             xr = Int(59 * Rnd) + 2
individu, maka dibangkitkan 8                yr = Int(39 * Rnd) + 2
individu dengan 10 gen (maks. 60             individu(i, k * 2 - 1) = xr
                                             individu(i, k * 2) = yr
untuk x dan 40 untuk y) yang              Next k
dibangkitkan secara acak.               Next i


                                                            Hitung Fitness
Membangkitkan Populasi Awal
                                                Hitung Fitness

                  For i = 1 To 8
                    For xp = 1 To 60
                        For yp = 1 To 40
                           s(xp, yp) = 0
                           For j = 1 To 5
                              xr = individu(i, j * 2 - 1)
                              yr = individu(i, j * 2)
                              d = ((xp - xr) ^ 2 + (yp - yr) ^ 2) ^ 0.5
                              If d < radius + 1 Then s(xp, yp) = 1
                           Next j
                        Next yp
                    Next xp
                    Jcover = 0
                    For xp = 1 To 60
                        For yp = 1 To 40
                           Jcover = Jcover + s(xp, yp)
                        Next yp
                    Next xp
                    fitness(i) = Jcover
                  Next i
Seleksi (1)                        Hitung Total Fitness

Seleksi roulette wheel untuk                 Jfitness = 0
memilih induk dilakukan dengan               For i = 1 To 8
                                               Jfitness = Jfitness + fitness(i)
menggunakan prosentasi fitness
                                             Next i
setiap individu, dimana setiap
individu mendapatkan luas bagian
sesuai dengan prosentase nilai     Menghitung prosentase
fitnessnya.                        fitness dan penentuan
                                   bidang

                                              k=0
                                              For i = 1 To 8
                                                prosen = Int(100 * fitness(i) /
                                              Jfitness)
                                                Text2(i - 1) = prosen
                                                For j = 1 To prosen
                                                   k=k+1
                                                   rolet(k) = i
                                                Next j
                                              Next i
Seleksi (2)            For i = 1 To 8
                         r = Int(k * Rnd) + 1
                         pilih = rolet(r)
                         Text4(i - 1) = pilih
                         For j = 1 To 10
  Pemutaran Roulette
                           induk(i, j) = individu(pilih, j)
                         Next j
                       Next i
Perkawinan Silang
Cross-Over (Perkawinan Silang) dilakukan dengan menentukan 2 posisi awal dan
akhir gen pada individu yang akan dikawinkan secara acak. Kemudian pada posisi
tersebut dilakukan cross-over aritmetik.


                                           For i = 1 To 4
                                             p = Rnd
                                             If p < probCO Then
                                                 r1 = Int(10 * Rnd) + 1
                                                 r2 = Int((10 - r1) * Rnd) + r1
                                                 For r = r1 To r2
                                                    a = 0.5 + 0.5 * Rnd
                                                    anak(2 * i - 1, r) = Int(a * induk(2 * i - 1,
                                                        r) + (1 - a) * induk(2 * i, r))
                                                    anak(2 * i, r) = Int(a * induk(2 * i, r) + (1
                                                        - a) * induk(2 * i - 1, r))
                                                    k = (2 * i - 2) * 10 + r - 1
                                                 Next r
                                           Next i
Mutasi
Mutasi dilakukan dengan cara menggeser posisi gen yang
dimutasi. Penggeseran ini dilakukan dengan melakukan
penambahan atau pengurangan pada posisi tersebut.
                                 For i = 1 To 8
                                   p = Rnd
                                   If p < probMut Then
                                       r1 = Int(10 * Rnd) + 1
                                       r2 = Int((10 - r1) * Rnd) + 1
                                       For r = 1 To r2
                                          If r Mod 2 = 0 Then bt = 40 Else bt = 60
                                          a = Int(10 * Rnd) - 4
                                          If a < 1 Then a = a - 1
                                          anak(i, r) = anak(i, r) + a
                                          If anak(i, r) < 1 Or anak(i, r) > bt Then
                                               anak(i, r) = anak(i, r) - 2 * a
                                          k = (i - 1) * 10 + r - 1
                                          Next r
                                          End If
                                 Next i
Membentuk Individu Baru
                                         For i = 1 To 8
Anak hasil perkawinan silang dan
                                           For j = 1 To 8
mutasi menjadi generasi baru untuk            individu(i, j) = anak(i, j)
dilakukan proses regenerasi                Next j
                                         Next i
Pada generasi berikutnya, individu
terbaik (nilai fitness terbesar) dapat
dipertahankan dengan proses elitism
                                         kmin = 1
                                         fitnessmin = fitness(1)
                                         For i = 2 To 8
                                            If fitness(i) < fitnessmin Then
                                               kmin = i
                                               fitnessmin = fitness(i)
                                            End If
                                         Next i
                                         fitness(kmin) = fitnessmaks
                                         For i = 1 To 8
                                            individu(kmin, i) = individumaks(i)
                                         Next i
Contoh Hasil Algoritma Genetika


 Generasi 1
Contoh Hasil Algoritma Genetika

 Generasi 2
Contoh Hasil Algoritma Genetika


 Generasi 3
Contoh Hasil Algoritma Genetika


 Generasi 4
 Aplikasi Algoritma Genetika untuk Peramalan
 Time Series
                            Model Sistem

                                               Training dengan
                                             algoritma genetika
Permasalahan pada                           untuk mendapatkan
                              Data Input
peramalan time series                       nilai koefisien model
                                                     linier
adalah bagaimana
mempelajari perilaku data
time series yang                                         
                              Data Test
direpresentasikan pada        (Forecast)
model linier untuk
menghasilkan nilai             Hasil
                            Peramalan
peramalan

                                           Koefisien model linier
Data Model
                      Data untuk learning/training              Data prediksi

      Data input (time lag)                       Data test

                                                                                x(k)



           Input(1)              Target(1)
              Input(2)                Target(2)
                 Input(3)                Target(3)


                                             Input(k)         Target(k)




Model peramalan algoritma genetika menggunakan model matematika
untuk merepresentasikan pola data time series sebagai berikut :

 y (k  1)  a0  a1 x1 (k )  a 2 x2 (k )  ...  a n x n (k )  e(k )
x1(k)  xn(k) : data input prediksi pada step ke k
y(k+1)        : nilai prediksi pada step ke k+1
e(k)          : error pada step ke k
Data Time Series
Data time series sunspot dengan jumlah data 30 yang dibagi
dalam periode input (time lag) 14 dan periode training
algoritma genetika 5




        Periode Input
                    Periode Training   Periode Peramalan
Membangkitkan Populasi Awal
Membangkitkan sejumlah individu,             ncrom = m - pga + 1
                                             For i = 1 To 8
misalkan satu populasi terdiri dari 8          For k = 1 To 10
individu, maka dibangkitkan 8 individu             a(i, k) = Rnd / ncrom
dengan 10 gen float yang dibangkitkan          Next k
secara acak (nilai antara 0-1) sebagai       Next i
representasi koefisien model linier
                                         Hitung Fitness
                                                 pGA1 = m - pga
                                                 pGA2 = pGA1 + pga

                                                 For i = 1 To 8
                                                   e=0
                                                   ndata = 0
                                                   For k = pGA1 + 1 To pGA2
                                                      zp = a(i, 1)
                                                      For j = 2 To ncrom
                                                        zp = zp + a(i, j) * aktual(k + 1 - j)
                                                      Next j
                                                      e = e + (aktual(k) - zp) ^ 2
                                                      ndata = ndata + 1
                                                   Next k
                                                   er = e / ndata
                                                   fitness(i) = ncrom / (er + 0.01)
                                                 Next i
Seleksi
Seleksi roulette whell untuk memilih induk dilakukan dengan
menggunakan prosentasi fitness setiap individu, dimana setiap
individu mendapatkan luas bagian sesuai dengan prosentase
nilai fitnessnya.
Perkawinan Silang
Cross-Over (Perkawinan Silang) dilakukan dengan menentukan 2 posisi
awal dan akhir gen pada individu yang akan dikawinkan secara acak.
Digunakan arithmetic crossover untuk perkawinan silang

                           c1(k) = r.p1(k) + (1-r).p2(k)
                           c2(k) = (1-r).p1(k) + r.p2(k)
Mutasi
Mutasi untuk algoritma genetika dilakukan dengan metode
shift yaitu menentukan satu posisi gen pada kromosom
secara random. Kemudian nilai gen tersebut ditambahkan
dengan bilangan kecil antara -0.1 sampai dengan 0.1
sebagai nilai gen yang baru tetapi tetap pada jangkauan nilai
gen awal.
Membentuk Individu Baru
Anak hasil perkawinan silang dan mutasi menjadi generasi baru
untuk dilakukan proses regenerasi.
Pada generasi berikutnya, individu terbaik (nilai fitness terbesar)
dapat dipertahankan dengan proses elitism
Contoh Hasil Algoritma Genetika
Generasi 1
Contoh Hasil Algoritma Genetika
Generasi 2
Contoh Hasil Algoritma Genetika
Generasi 3
Contoh Hasil Algoritma Genetika
Generasi 4
Aplikasi Algoritma Genetika untuk Pencarian
Kata secara Acak



•   Definisi Individu
•   Nilai Fitness
•   Seleksi roulette wheel
•   Two point crossover
•   Mutasi gen
Definisi Individu
• Kata yang menjadi acuan adalah “GENETIKA”.
• Setiap individu menyatakan kata dugaan terhadap kata acuan.
• Setiap individu terdiri dari 8 gen.
• Nilai dari gen dinyatakan dengan bilangan integer antara 1 s/d
  26 yang jika dikonversikan akan didapatkan karakternya.
• 1 dikonversikan ke huruf ‘A’, dst sampai 26 dikonversikan ke
  huruf ‘Z’.


Fungsi Fitness
• Fungsi fitness dinyatakan sebagai 8 * 26 - (ac[i] –
  gen[i])
 Membangkitkan Populasi Awal


Membangkitkan sejumlah individu,      For i = 1 To 16
misalkan satu populasi terdiri dari     For j = 1 To 8
                                           individu(i, j) = Int(26 * Rnd + 1)
16 individu, maka dibangkitkan 8           k = (i - 1) * 8 + j - 1
individu dengan 8 gen integer (1         Text1(k) = Chr(individu(i, j) + 64)
                                         Next j
gen26) yang dibangkitkan secara     Next i
acak.

                                                         Hitung Fitness
Membangkitkan Populasi Awal


                                             Hitung Fitness


                  For i = 1 To 16
                    er = 0
                    er1 = 0
                    For j = 1 To 8
                        er = er + ad(j) * (ac(j) - individu(i, j)) ^ 2
                        If ac(j) <> individu(i, j) Then er1 = er1 + 1
                    Next j
                    fitness(i) = 8 * 26 - Int(er ^ 0.5) - 8 * er1
                    If fitness(i) < 0 Then fitness(i) = 0
                  Next i
Seleksi (1)                        Hitung Total Fitness

Seleksi roulette wheel untuk                 Jfitness = 0
memilih induk dilakukan dengan               For i = 1 To 8
                                               Jfitness = Jfitness + fitness(i)
menggunakan prosentasi fitness
                                             Next i
setiap individu, dimana setiap
individu mendapatkan luas bagian
sesuai dengan prosentase nilai     Menghitung prosentase
fitnessnya.                        fitness dan penentuan
                                   bidang

                                              k=0
                                              For i = 1 To 8
                                                prosen = Int(100 * fitness(i) /
                                              Jfitness)
                                                Text2(i - 1) = prosen
                                                For j = 1 To prosen
                                                   k=k+1
                                                   rolet(k) = i
                                                Next j
                                              Next i
Seleksi (2)            For i = 1 To 8
                         r = Int(k * Rnd) + 1
                         pilih = rolet(r)
                         Text4(i - 1) = pilih
                         For j = 1 To 10
  Pemutaran Roulette
                           induk(i, j) = individu(pilih, j)
                         Next j
                       Next i
Perkawinan Silang
Cross-Over (Perkawinan Silang) dilakukan dengan menentukan 2 posisi awal dan
akhir gen pada individu yang akan dikawinkan secara acak. Kemudian dilakukan
penukaran nilai gen induk 1 dan induk 2 dari posisi awal sampai dengan posisi
akhir untuk diperoleh anak 1 dan anak 2.


                                         For i = 1 To 8
                                           p = Rnd
                                           If p < probCO Then
                                              r1 = Int(8 * Rnd) + 1
                                              r2 = Int((8 - r1) * Rnd) + r1
                                              For j = r1 To r2
                                                jn = r2 - (j - r1)
                                                anak(2 * i - 1, j) = induk(2 * i, j)
                                                anak(2 * i, j) = induk(2 * i - 1, j)
                                                k = ((2 * i - 1) - 1) * 8 + j - 1
                                                k = (2 * i - 1) * 8 + j - 1
                                             Next j
                                           End If
                                         Next i
Mutasi
Mutasi dilakukan dengan cara menggeser posisi gen yang
dimutasi. Penggeseran ini dilakukan dengan melakukan
penambahan atau pengurangan pada posisi tersebut.


                                For i = 1 To 16
                                  p = Rnd
                                  If p < probMut Then
                                      r1 = Int(8 * Rnd) + 1
                                      r2 = Int((8 - r1) * Rnd) + r1
                                      For r = r1 To r2
                                         anak(i, r) = Int(Rnd * 26) + 1
                                         k = (i - 1) * 8 + r - 1
                                      Next r
                                  End If
                                Next i
 Membentuk Individu Baru
                                         For i = 1 To 8
Anak hasil perkawinan silang dan
                                           For j = 1 To 8
mutasi menjadi generasi baru untuk            individu(i, j) = anak(i, j)
dilakukan proses regenerasi                Next j
                                         Next i
Pada generasi berikutnya, individu
terbaik (nilai fitness terbesar) dapat
dipertahankan dengan proses elitism
                                         kmin = 1
                                         fitnessmin = fitness(1)
                                         For i = 2 To 8
                                            If fitness(i) < fitnessmin Then
                                               kmin = i
                                               fitnessmin = fitness(i)
                                            End If
                                         Next i
                                         fitness(kmin) = fitnessmaks
                                         For i = 1 To 8
                                            individu(kmin, i) = individumaks(i)
                                         Next i
Contoh Hasil Algoritma Genetika
 Generasi 1
Contoh Hasil Algoritma Genetika
 Generasi 2
Contoh Hasil Algoritma Genetika
Generasi 3
Contoh Hasil Algoritma Genetika
Generasi 4
Contoh Hasil Algoritma Genetika
Generasi 5

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:70
posted:10/2/2012
language:Unknown
pages:63