Embed Size (px)
Citation preview
BÁO CÁO MÔN TRÍ TUỆ NHÂN TẠO
I. Đề tài: Xây dựng chương trình giải quyết bài toán chiếc Balô 2 với thuật toán Gene,phương pháp chọn là Elitism.II.Mô tả bài toán:-Bài toán chiếc Balô 2 là 1 bài toán tối ưu hóa tổ hợp.Nội dung của bài toán là đặt những vật vào 1 chiếc balô sao cho giá trị của nó là lớn nhất mà khối lượng của vật trong được vượt quá khối lượng của túi.Bài toán chiếc Balô 2 dạng bài toán chiếc ba lô không giới hạn số lượng đồ vật cho vào ba lô.-Thuật toán được sử dụng nhằm giải quyết bài toán là thuật toán Gene.Nội dung của thuật toán bao gồm 7 bước như sau: +Mã hóa. +Khởi tạo quần thể. +Tạo hàm thích nghi. +Lựa chọn cho sự kết hợp lại. +Lai ghép(Crossover). +Đột biến(Mutation). +Kiểm tra tiêu chuẩn kết thúc. +End.III.Cách giải quyết bài toán thuật toán Gen1.Mã Hóa: Đối với bài toán Balô 2,do mỗi vật có thể được chọn lại nhiều lần nên ta sử dụng cách mã hóa giá trị cho các chromosome.Ở đó,số lần chọn 1 vật sẽ được gán bằng 1 số thực tương ứng.Ta có ví dụ sau:Ta có 1 Gen như sau: 02360010Với gen trên ta có thể hiểu là vật thứ 1 không được chọn lần nào (0).Vật thứ 2 được chọn 2 lần (2)……vật thứ 4 được chọn 6 lần (6).Và đây là cách mã hóa đối với bài toán chiếc ba lô 2 này.2.Khởi tạo quần thể:Sau khi mã hóa ta được các Gen ngẫu nhiên (random).Tuy nhiên trong số này có những Gen không thỏa mãn yêu cầu bài toán về khối lượng,Do đó ta sử dụng 1 hàm thích nghi để lọc bỏ những Gen không phù hợp với yêu cầu bài toán.Những Gen phú hợp còn lại cho ta 1 quần thể mới.Quần thể này sau ta sẽ dung để chọn lọc và lai ghép.3.Hàm thích nghi:Hàm thích nghi được xây dựng dựa trên tổng khối lượng của mỗi Gen.Mỗi Gen ở đây là 1 đáp án,sau khi ta có 1 gen,ta sẽ tính tổng khối lượng của đáp án đó thông qua số lần chọn vật và khối lượng của từng vật.Nếu tổng khối lượng vượt qua khối lượng của túi Gen đó sẽ bị loại,nếu tổng khối lượng nhỏ hơn hoặc bằng thì ta tiếp tục thuật toán.4.Lựa chọn cho sự kết hợp lại:Theo yêu cầu của bài toán ta sử dụng phương pháp chọn Elitism.Phương pháp Elitism cho phép copy những cá thể tốt sang quần thể mới.Thành phần còn lại được chọn từ phương pháp chọn khác.Để dánh giá Gen có tốt hay không ta cần tạo 1 hàm đánh giá,hàm đánh giá này trả về cho ta giá trị là tổng giá trị trong túi sau khi chọn vật.Ta xét với [i] thể tốt nếu chúng có tổng giá trị cao nhất.Những cá thể này sẽ được lưu lại,Sau khi chọn ta được 1 quần thể gồm n cá thể vừa được chọn ra từ Elitism và 1 phương pháp khác.[i] cá thể chọn từ Elítism sẽ được lưu để dung cho lần lai ghép sau.
5.Lai ghép: Là 1 phép toán cơ bản của thuật toán Gen.Có nhiều cách để lai ghép phụ thuộc vào cách mã hóa ở trên.Với bài toán này ta đã mã hóa giá trị nên ta sử dụng cách lai ghép cho mã hóa giá trị:-Ta cắt 1 phần gen của gen[a] ghép vào 1 phàn gen của gen[b],sau mỗi làn lai ghép ta phải kiểm tra qua hàm thích nghi,chỉ lấy những gen phù hợp khi thỏa mãn hàm thích nghi.6.Đột biến:Cũng như lai ghép,đây là 1 pháp toán cơ bản của thuật toán Gen.Đối với bài toán mã hóa theo giá trị ta cộng vào hoặc trừ đi 1 số nhỏ từ các giá trị đã được chọn.Đối với Lai ghép và đột biến ta cần chọn xác suất thực hiên(mức độ thường xuyên).Với Lai ghép: nếu xác suât là 100% thì tất cả các con đều được tao ra từ cha,nếu là 0% thì không có phần tử nào được tạo ra từ cha.Với đột biến: Nếu là 100% thì mọi nhiễm sắc thể sẽ thay đổi,còn nếu là 0% thì là copy hoàn toàn từ các nhiễm sắc thể cũ.7.Tiêu chuẩn kết thúc:Ta cho lặp lại công việc trên nhiều lần cho đến khi nào nhận thấy các cá thể không thay đổi theo thời gian.Hoặc khi các cá thể sinh ra là giống hệt nhau..Giao diện bài toán:
Ở đây ta có giao diện gồm 3 ô text box đê nhập dữ liêu vào lần lượt là: -Khối lượng của túi. -Số gen được chọn để lai ghép. -Số lượng vật do đầu bài đưa ra.Bên cạnh đó là 3 button là:-Nút Dữ liệu: Khi ấn vào đây chương trình sẽ random tạo ra các dữ liệu về vật như Giá trị và Khối lượng của vật 1 cách ngẫu nhiên.Các thông số sẽ được nằm trong 1 giới hạn do người viết quy định.-Nút Mã hóa: Sau k hi tạo dữ liệu ta sẽ mã hóa chúng sao cho chúng đạt yêu cầu về hàm thích nghi.-Tiến hóa:Đây là công việc chính trong thuật toán,mọi công việc chọn thế hệ cha,lai ghép và đột biên đều được thực hiên khi ấn nút Tiến hóa.Kết quả sẽ cho ra là khối lương của các vật được và giá trị tương ứng của nó.Do còn chưa nắm vững thuật toán và cách thể hiện qua code nên còn nhièu thiếu sót,mong thầy hướng dẫn thêm để em hoàn thiện chương trình.using System;using System.Collections.Generic;using System.Text;using System.Windows.Forms;using System.Collections;namespace Knapsack2_gene{ class Thuattoan
{ public int maxgiatri; public int soluongvat; public int solaighep; public int khoiluongtui; public int[] khoiluongvat; public int[] giatrivat; public Gene[] genes; Random rd; public Thuattoan(int soluong_vat, int khoiluong_tui, int[] khoiluong, int[] giatri, int sogenelaighep) { solaighep = sogenelaighep; soluongvat = soluong_vat; khoiluongtui = khoiluong_tui; khoiluongvat = khoiluong; giatrivat = giatri; } public Thuattoan(int soluong_vat, int khoiluong_tui, int sogenelaighep) { solaighep = sogenelaighep; soluongvat = soluong_vat; khoiluongtui = khoiluong_tui; rd = new Random(); khoiluongvat = new int[soluongvat]; giatrivat = new int[soluongvat]; random_vat(); genes = new Gene[30]; } public int danhgia(Gene gen) { int tonggiatri = 0; int maxgiatri = 0; int i; for (i = 0; i < soluongvat; i++) { tonggiatri += giatrivat[i] * gen.mang[i]; //maxgiatri = 10 * khoiluongtui / khoiluongvat[i]; }
return tonggiatri; } public bool thichnghi(Gene gen) { int tongkhoiluong = 0; int i; for (i = 0; i < soluongvat; i++) { tongkhoiluong += khoiluongvat[i] * gen.mang[i];
} if (tongkhoiluong <= khoiluongtui) { return true; } else { return false; } } public void random_vat() { for (int i = 0; i < soluongvat; i++) { khoiluongvat[i] = rd.Next(1, khoiluongtui/soluongvat); giatrivat[i] = rd.Next(1, 10); } } public String hienthigene() { string s = ""; int[] mang = new int[soluongvat]; for (int j = 0; j < 25; ) { genes[j] = new Gene(khoiluongtui, khoiluongvat, soluongvat); { for (int i = 0; i < soluongvat; i++) { genes[j].mang[i] = rd.Next(0, khoiluongtui/khoiluongvat[i]); } if (genes[j].ok()) { for (int i = 0; i < soluongvat; i++) { s += genes[j].mang[i].ToString()+"."; } s += "\r\n"; j++; } } } return s; } public ArrayList Elitism() { string s = ""; ArrayList arrMax = new ArrayList();
int[] mang = new int[soluongvat]; for (int j = 0; j < 25; j++) { genes[j].h = danhgia(genes[j]); } Gene temp; for (int j = 0; j < 25;j++ ) { for (int i = j; i < 25; i++) { if (genes[i].h < genes[j].h) { temp = genes[i]; genes[i] = genes[j]; genes[j] = temp; } } } for(int j=0; j<5; j++) { arrMax.Add(genes[j]); } return arrMax; } //public string laighep() //{ //} }}using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Text;using System.Windows.Forms;namespace Knapsack2_gene{ public partial class Form1 : Form { Thuattoan tt,tt1; Gene gn; public Form1() { InitializeComponent(); } private void button3_Click(object sender, EventArgs e) { int khoiluongtui;
int soluongvat; int sogenelaighep; try { khoiluongtui = int.Parse(textBox1.Text); sogenelaighep = int.Parse(textBox2.Text); soluongvat = int.Parse(textBox3.Text); tt = new Thuattoan(soluongvat, khoiluongtui, sogenelaighep); for (int i = 0; i < soluongvat; i++) { textBox4.Text += tt.khoiluongvat[i].ToString() + "\r\n"; textBox5.Text += tt.giatrivat[i].ToString() + "\r\n"; } } catch (Exception ex) { MessageBox.Show("chua nhap day du thong tin"); } } private void button2_Click(object sender, EventArgs e) { txtmahoa.Text = tt.hienthigene(); } private void button1_Click(object sender, EventArgs e) { } }}using System;using System.Collections.Generic;using System.Text;namespace Knapsack2_gene{ public class Gene { public int[] mang, khoiluongvat; int khoiluongtui; public int h; //Random rd = new Random(1); public Gene(int khoiluong_tui, int[] khoiluong_vat, int soluongvat) { khoiluongtui = khoiluong_tui; khoiluongvat = khoiluong_vat;
mang = new int[soluongvat]; } public bool ok()
{ int tongkhoiluong = 0; for (int i = 0; i < mang.Length; i++) { tongkhoiluong += mang[i] * khoiluongvat[i]; } if (tongkhoiluong > khoiluongtui) return false; else return true; } public Gene(int soluongvat) { mang = new int[soluongvat]; } }}
BÁO CÁO BÀI TẬP LỚNĐỀ TÀI: SỬ DỤNG GIẢI THUẬT GENE VỚI PHƯƠNG PHÁP CHỌN LÀ RANK ĐỂ XÂY DỰNG CHƯƠNG TRÌNH ĐỂ GIẢI QUYẾT BÀI TOÁN CHIẾC BALO LOẠI 1.
I. Phát biểu bài toán Cho một chiếc balo với khối lượng không đổi (cụ thể với bài tập lớn này có thể chứa tối đa là
50), cho tập các vật có giá trị và khối lượng tương ứng khác nhau (cụ thể là cho 10 vật có giá trị, khối lượng tương ứng).
Với mỗi đồ vật chỉ có thể lấy được một lần, bài toán đặt ra là phải lấy các đồ vật cho vào balo sao cho tổng khối lượng đưa vào balo không được vượt quá 50 và giá trị tương ứng phải là lớn nhất có thể.
Bài toán yêu cầu cần sử dụng thuật toán gene với cách chọn rank để giải quyết, vì vậy việc đầu tiên là phải mã hóa thành các gene tương ứng là chuỗi các số 0,1 ngẫu nhiên.
Sử dụng thuật toán gene với phương pháp chọn rank để chọn các cá thể vào quần thể rồi cho lai ghép, sau khi lai ghép sẽ sinh ra một tập hợp các quần thể mới gồm những cá thể ban đầu và những cá thể con được sinh ra. Tiếp tục sử dụng phương pháp chọn rank để loại đi những cá thể không cần thiết duy trì quần thể. Cứ tiếp tục như vậy cho đến khi có thể dừng lại và tìm ra cá thể có khả năng thích nghi, phù hợp với yêu cầu bài toán đặt ra.
Nhiệm vụ đặt ra trong bài toán này là phải tìm ra cách đưa được các đồ vật vào trong balo sao cho khối lượng không được vượt quá khả năng mang vác của balo nhưng tổng giá trị là lớn nhất có thể.
II. Phân tích nhiệm vụ bài toán Ban đầu phải mã hóa các cá thể của quần thể thành các gene tương ứng. Với mỗi gene sẽ là
một trường hợp chọn các vật cho vào balo. Khởi tạo ban đầu tập các cá thể với các gene đó cho vào quần thể ban đầu. Ta áp dụng thuật toán gene với phương pháp chọn rank để đưa các cá thể tốt và có khả năng
thích nghi cao đưa vào quần thể mới để lai ghép, đột biến.
Sau mỗi lần lai ghép và đột biến sẽ sinh ra một quần thể mới gồm những cá thể con được sinh ra và các cá thể cha ban đầu, lại phải sử dụng phương pháp chọn rank để chọn các cá thể đưa vào quần thể, tiếp tục lai hóa và đột biến.
Cứ thực hiện các bước như vậy cho đến khi sinh ra được cá thể được cho là phù hợp với bài toán thì dừng lại.
III. Thu thập và biểu diễn dữ liệu, tri thức cần thiết để giải quyết bài toán
a. Biểu diễn dữ liệu Dữ liệu đầu vào là khối lượng cả balo có thể mang được tối đa, được gán vào một biến. Sau đó là cần biểu diễn các vật có khối lượng và giá trị tương ứng bằng một mảng integer 2
chiều. Mã hóa các khả năng chọn vật bằng các chuỗi gene có giá trị 0,1. Với giá trị 1 là những vật
được chọn, giá trị 0 là những vật không được chọn. Thực hiện việc lai hóa, đột biến để sinh ra gene tốt nhất có thể phù hợp với bài toán.b. Hướng giải quyết bài toán Mã hóa các trường hợp chọn thành các gene, rồi viết hàm thích nghi (fitness) để đánh giá khả
năng phù hợp với yêu cầu đặt ra của các gene đó. Rồi từ hàm thích nghi đó, có thể phân loại và đánh giá xem cá thể nào có thể thích nghi tốt
hơn thì xếp cá thể đó lên trước. Viết hàm rank để sắp xếp và chọn ra các cá thể đáp ứng đưa vào quần thể cần lai ghép và đột biến.
Có nhiều phương pháp lai ghép khác nhau, như lai ghép tại một điểm, lai ghép tại hai điểm… cuối cùng sẽ sinh ra một quần thể mới với các cá thể cha và cá thể con được sinh ra.
Mặc dù vậy không phải tất cả các cá thể đều tốt và có thể sử dụng được, phải dùng hàm rank và hàm thích nghi để đánh giá và chọn ra cá thể mới đưa vào quần thể để tiếp tục lai hóa và đột biến, các cá thể còn lại sẽ bị loại bỏ.
IV. Thuật toán được lựa chọn để giải quyết bài toána. Áp dụng thuật toán gene vào bài toán Mã hóa các cá thể thành các chuỗi 0,1 khác nhau, với giá trị 1 là vật được chọn, 0 là vật
không được chọn. Sử dụng hàm thích nghi và hàm rank để chọn cá thể đưa vào quần thể, sử dụng các phép lai
ghép và đột biến để sinh ra quần thể mới. Lại tiếp tục áp dụng phương pháp chọn rank để chọn trong quần thể mới sinh ra đó, cá thể
nào tốt nhất thì giữ lại, và loại những cá thể xấu đi, còn số còn lại tiếp tục cho lai hóa và đột biến.
Tiếp tục làm như vậy cho đến khi có cá thể phù hợp với yêu cầu bài toán đặt ra.b. Hướng giải cụ thể Ngôn ngữ lập trình được sử dụng là C# Cấu trúc chương trình gồm 2 phần:
+ Tầng hiển thị: là phần có sự tương tác giữa người dùng và chương trình+ Tầng sử lý: làm các nhiệm vụ:
- Sinh ngẫu nhiên quần thể ban đầu- Chọn ra các cá thể để đưa vào quần thể lai hóa và đột biến- Đưa ra kết quả cuối cùng
Bố trí chương trình
Tên Kiểu dữ liệu Mô tảRandom_gene String Là hàm khởi tạo ngẫu nhiên kiểu gene cho một
cá thể gồm chuỗi 0 và 1Elitism String Chọn ra gene tốt nhất tại thời điểm đang xét để
lưu lại (khối lượng nhỏ nhất, giá trị lớn nhất)Ham_thich_nghi String Đánh giá khả năng phù hợp với yêu cầu bài toán
của một gene nào đóRank Integer Chọn ra gene có khả năng thích nghi đưa vào
quần thể mới để lai hóa và đột biếnSingle_point_crossover String Phương pháp lai hóa tại một điểm.Two_point_crossover String Phương pháp lai hóa tại hai điểm
Mutation String Hàm đột biến với sác xuật đột biến là 0,06%
Một số giải thuật sử dụng trong bài toán- Sinh ngẫu nhiên cá thể trong quần thể ban đầu:
+ Ngẫu nhiên sinh ra các chuỗi 0,1.+ Kiểm tra tổng khối lượng các vật được chọn không được vượt quá 50
- Hàm elitism+ Chọn trong các cá thể của quần thể đang xét có cá thể nào có tổng giá trị là lớn nhất và khối lượng là nhỏ nhất thì lưu lại và đưa vào quần thể sau
- Xây dựng hàm thích nghi+ Chọn cá thể có khối lượng không vượt quá 50 nhưng phải lớn hơn 40 và giá trị không được thấp hơn 30 để đưa vào quần thể lai hóa.
- Hàm lai hóa+ Xác định kiểu lai hóa+ Với mỗi kiểu lai hóa đều sinh ra quần thể mới có các cá thể con và cá thể bố mẹ.
- Hàm đột biến+ Đột biến trên 1 gene nào đó, với giá trị 0 sẽ chuyển thành 1, và ngược lại.
Giao diện chương trình
Lời nói đầu...............................................................................................................................1
I. Khái quát.................................................................................................................................3
1. Giới thiệu Genetic Algorithms (GAs)...............................................................................3
2. Baì toán 0/1 knapsack :.......................................................................................................4
II. Algorithms...........................................................................................................................4
1. Mã hóa (encoding ) :.......................................................................................................4
2. Khởi tạo quần thể ( initial population generation ) :...................................................5
3. Hàm thích nghi (fitness function ) :...............................................................................5
4. Sự lựa chọn cho sự kết hợp lại (selection for recombination).....................................5
5. Lai ghép ( crossover )......................................................................................................6
6. Đột biến ( Mutation).......................................................................................................8
7. Tiêu chuẩn kết thúc.........................................................................................................8
III. Nhận xét...........................................................................................................................9
IV. Flowchart chương trình chính………………………………………………………………..10
Tài liệu tham khảo :................................................................................................................11
Khái quát
Chúng ta giả sử gene bước đầu tiếp cận cho giải thuật gene. Nó mạnh hơn nếu được so sánh với cách tiếp cận truyền thống trong giải thuật gene. Sự tiếp cận được ứng dụng cho bài toán 0/1 kapsack .Giải thuật này tìm ra được kết quả cận tối ưu trong tất cả kết quả đặc biệt được biểu diễn trong tài liệu này, trong khi các cách tiếp cận truyền thống thất bại phần lớn các ví dụ bởi những đặc điểm lợi thế riêng biệt của các cá thể trong quần thể. Trong sự kết hợp giữa toán tử tìm kiếm đột biến , phương pháp này cung cấp một kết quả tốt hơn cho tất cả các vấn đề của các thực thể đã được nghiên cứu.
1. Giới thiệu Genetic Algorithms (GAs)Giải thuật Gene (GAs) cơ bản dựa trên thuyết chọn lọc tự nhiên của Darwin. Bắt đầu sinh ngẫu nhiên một quần thể từ các cá thể, cho thấy một giải pháp tiềm năng cho vấn đề sau nghie cứu. Những cá thể này được lựa chọn theo các giá trị phù hợp nhất thể tạo ra một thế hệ kế tiếp. Toán tử gene, chủ yếu là lai ghép và đột biến, biến đổi các cá thể và làm chúng trở thành một phần của quần thể của thế hệ sau. Các cá thể trong thế hệ có bình quân thích nghi cao hơn so với thế hệ trước. Hai hai thành phần gene, lai ghép và đột biến, là nền tảng cho giải thuật gene. Đột biến thay thế một hoặc nhiều các gene ở mỗi cá thể. Nó giữ vai trò duy trì sự đa dạng quần thể. Về lý thuyết, giải thuật gene được tin để xử lý những mẫu động dạng được gọi là các lược đồ. Mỗi lược đồ định lý [3], còn được gọi là đinh lý cơ sở của giả thuật gene ,’ lược đồ ngắn, lược đồ yêu cầu thấp,lược đồ trên mức trung bình nhận những giá trị thử tăng theo hàm mũ trong những quần thể sau đó. Như một lược đồ triển vọng được đặt tên là khối xây dựng . Giải thuật gene xử lý một số lượng lớn các lược đồ cùng lúc, cuối cùng hội tụ về giải pháp tốt nhất cho vấn đề. Trên thực tế, lược đồ và khối xây dựng này là một liên kết của gene.Giả thiết một cách tiếp cận gene đệ quy là giới thiệu từng gene một tới quần thể. Các gene này liên kết thông qua hoạt động của thực thể gene để cấu thành các cá thể. Quá trình này tương tự như những hiện tượng tự nhiên của sự tiến hóa từ những cá thể đơn bào tới dạng sống phức tạp hiện nay.
2. Baì toán 0/1 knapsack : Một người ăn xin, gặp may được cho một số lượng lớn đồ vật với giá trị và khối lượng khác nhau. Người ăn xin này chỉ có một cái ba lô ( knapsack) mang được một khối lượng giới hạn, và anh ta muốn sao cho lấy được đầy ba lô với giá trị lớn nhất có thể. Xong mỗi đồ vật chỉ được lấy một lần. Bài tập này sẽ xây dựng giải thuật sao cho anh ta có sự lựa chọn tối ưu nhất.
Áp dụng GAs đệ quy để tiếp cận với cách giải quyết 0/1 knapsack Vấn đề bài toán 0/1 knapsack được xác định như sau
Đưa ra vector giá trị : Pi
Vector khối nượng : wi
Giá trị cực đại : ∑ni=1 pixi
Số vật thể phải thỏa mãn điều kiện : ∑ni=1 wixi ≤ C
xi nhận giá trị 0 hoặc 1 ,( i= 1,…..,n) n là số các phần tử 0 : đồ vật ( nhiễm sắc thể ) không được chọn .1 : đồ vật ( nhiễm sắc thể ) được chọn .Số thứ tự đồ vật được tính từ trái sang phải .
Mã hóa gene cho bài toan 0/1 knapsack có thể làm trực tiếp từ các bit để kết luận biến quyết định (gene quyết định) có thể là một giải pháp cho vấn đề hay không.
I. Algorithms 1. Mã hóa (encoding ) :
xi nhận giá trị 0 hoặc 1 ,( i= 1,…..,n) n là số các phần tử 0 : đồ vật ( nhiễm sắc thể ) không được chọn . 1 : đồ vật ( nhiễm sắc thể ) được chọn .
Số thứ tự đồ vật được tính từ trái sang phải .Dùng biến là một mảng 2 chiều : knapsack [i,j] , để biểu diễn quần thể trong chiếc ba lô.
Trong đó : + i : biểu diễn cho yếu tố giá trị. + j : biểu diễn cho yếu tố khối lượng.
2. Khởi tạo quần thể ( initial population generation ) :
Thuật toán bắt đầu bằng cách từ những nhiễm sắc thể, hình thành một số lượng lớn các cá thể .sinh một quần thể ngẫu nhiên từ những cá thể trên.Trong thử nghiệm này ta truyền vào 7 nhiễm sắc thể là mảng 2 chiều :
public int[,] knapsack = new int[9, 2] { { 5, 7 }, { 8, 8 }, { 3, 4 }, { 2, 10 }, { 7, 4 }, { 9, 6 }, { 4,4},{10,7},{6,3} };
Quần thể ban đầu được khởi tạo gồm 50 cá thể, bằng cách khai báo phần tử mảng là 50 3. Hàm thích nghi (fitness function ) :
*Hàm thích nghi xây dựng dựa trên phép toán tính tổng giá trị và khối lượng để xác đình cá thể tốt.*Ngưỡng để so sánh thử nghiệm là :
- Giá trị của cá thể : ∑ni=1 pixi ≥ 22
-Khối lượng cá thể : ∑ni=1 wixi ≤ 20
4. Sự lựa chọn cho sự kết hợp lại (selection for recombination)
Có rất nhiều thuật toán để lựa chọn cá thể để tham gia vào quá trình lai ghép ( crossover ) và đột biến (mutation). Ví dụ như :Roulette wheel selection, rank selection , Elitism, Steady-state, v.v.v.Bài tập này đi sâu vào thuật toán lựa chọn : Steady-state. Thuật toán được mô tả như sau
Steady-state selection Với giải thuật gene steady-state,mỗi lần một thành viên của quần thể bị thay đổi. Lựa chọn một cá thể của quần thể phải dựa trên hàm thích nghi ( fitness).Nó được sao chép và những bản sao biến thể. Thành viên thứ hai của quần thể được lựa chọn là cá thể bị thay thế bởi chuỗi đột biến. Trong quá trình lai ghép hai cá thể với nhau một cá thể thể con được sinh ra và nó thay thể một phần tử của quần thể. Bất chứ phương pháp lựa chọn nào cũng có thể được dùng để lựa chọn cá thể cho sự đột biến hoặc làm phần tử cha-mẹ( parents) . Có nhiều chiến thuật thay thế khác nhau như :
Thay thế cá thể tồi nhất . cách này thường đưa đến sự hội tụ quá nhanh.
Thay thế một cách chọn ngẫu nhiên thành viên. Lựa chọn điểm thay thế dùng hàm thích nghi âm tính. (negative
fitness) .
Quá trình lựa chọn được thực hiện dựa trên hàm thích nghi (fitness). Cá thể nào được đánh giá là có độ thích nghi cao thì sẽ được lựa chọn tham gia vào quá trình lai ghép đột biến để tạo ra quần thể mới. Trong khi đó, những cá thể có độ thích nghi thấp sẽ bị bỏ qua. Cả thể có độ thích nghị cao nhất có thể được lựa chọn nhiều lần Tuy nhiên số lượng cá thể được lựa chọn để thực thi phải tương ứng với độ lớn của quần thể ban đầu , vì thế phải đảm bảo được số lượng cá thể ở mỗi thế hệ. Giai đoạn sự tham gia của sự lựa chọn ngẫu nhiên tương tự như quá trình chọn lọc tự nhiên.
5. Lai ghép ( crossover ) Lai ghép là quá trình kết hợp các bit của cá thể này với các bit của cá thể khác . Đây là tiến trình tạo cá thể mới cho thế kế cận, cá thể này kế thừa những đặc tính của các cá thể bố mẹ.Tiến trình lai ghép lựa chọn ngẫu nhiên định vị và sự thay đổi chuỗi con trước và sau nó. Từ điểm lai ghép này tạo ra 2 cá thể mới. Lai ghép có thể có rất nhiều cách. Cụ thể trong có 3 cách được áp dụng để giải quyết bài toán :
i. Lai ghép một điểmXem xét ví dụ sau
parent 1 1 0 0 | 0 1 1 1Parent 2 1 1 1 1| 0 0 0Offspring1 1 0 0 1 0 0 0 Offspring2 11 1 1 1 1 1
Trong ví trên điểm lai ghép là ở vị trí thứ 3 ( tính từ trái sang ) của 2 cá thể cha mẹ. Cá thể con thứ kế thừa nhiễm sắc thể ở vị trí 1 ,2 và 3 từ cá thể parent1 , và các nhiễm sắc thể ở vì trí 4, 5, 6 và 7 của cá thể parent2. Đối với cá thể con thứ 2 nhận các nhiễm sắc thể 1, 2, 3 từ cá thể parent2 còn các nhiễm sắc thể 4, 5, 6, và 7 thì kế thừa ở cả thể parent1.
ii. Lai ghép 2 điểm
parent 1 1 0 0 | 0 1 | 1 1Parent 2 1 1 1 | 1 0 | 0 0Offspring1 1 0 0 1 0 0 0 Offspring2 111 0 1 1 1
Trong ví trên điểm lai ghép là ở vị trí thứ 3 và thứ 5 ( tính từ trái sang ) của 2 cá thể cha mẹ.+ Cá thể con thứ kế thừa nhiễm sắc thể ở vị trí 1 ,2, 3 và 6,7 từ cá thể parent1 , còn các nhiễm sắc thể ở vị trí 4, 5 của cá thể parent2. +Đối với cá thể con thứ 2 nhận các nhiễm sắc thể 1, 2, 3 và 6,7 từ cá thể parent2 còn các nhiễm sắc thể 4, 5, thì kế thừa ở cả thể parent1.
iii. Tính toán ngẫu nhiên điểm lai ghép
+ Trong tài liệu này dùng thuật toán random để chọn ra 1 điểm lai ghép giữa hai cá thể cha mẹ sinh ra cá thể con.
6. Đột biến ( Mutation)
Đột biến được thực thi sau tiến trình lai ghép ( crossover) để đảm bảo không bị dừng lại ở giá trị cực trị địa phương ( a local optimum) trong quá trình giải quết bài toán.Tiến trình đột biến diễn ra nhằm thay đổi cá thể con mới bằng cách đổi các bít 0 và 1 với hoặc ngược lại. Đột biến có thể diễn ra với từng bit trong chuỗi với một vài khả năng, thường là rất nhỏ ( ví dụ : 0.001 ) . Để làm rõ vấn đề, chúng ta xét ví dụ sau
Cá thể chưa bị đột biến : 1 0 0 0 1 1 1Cá thể sau đột biến : 1 1 0 0 1 1 1 Nhiễm sắc thể 0 ở vị trí thứ 2 bị thay thế bởi nhiễm sắc 1 .
7. Tiêu chuẩn kết thúc.Thuật toán Gene sẽ dừng lại khi thỏa mãn một trong các yếu tố sau:-Quần thể hội tụ, hay nói cách khác là khi tìm ra được cá thể tốt nhất trong quần thể giống với kết quả mong muôn.-Kết thúc khi số thế hệ sinh ra đạt đến số sinh ra trước.-Kết thúc khi cá thể tốt nhất trong quần thể không thay đổi theo thời gian.-Kết thúc khi các cá thể trở nên giống nhau.II. Nhận xét
a) Thuật toán GAs Thuật toán Gene là thuật toán không thể khái quát, mà phải áp dụng cho từng bài
toán cụ thể, vì không có lý thuyết chung có thể hợp các tham số của thuật toán gene với bất cứ bài toán nào.
Sự giới thiệu thường là kết quả việc học kinh nghiệm của thuật toán gen, cái thường thực hiện chỉ trên mã hóa nhị phân.
Ưu điểm Chính là khả năng song song của thuật toán .
GAs duyệt qua không gian tìm kiếm sử dụng nhiều cá thể (and with genotype rather than phenotype) và ít mắc phải cực trị địa phương như các thuật toán khác
Dễ thể hiện . Khi đã có thuật toán gen cơ bản, chỉ cần viết một NST mới (just one object) để
xử lý bài toán khác. Với cùng cách mã hóa bạn có thể thay đổi hàm thích nghi . Mặc dù vậy, trong một số trường hợp chọn và thể hiện mã hóa sẽ gặp khó
khăn. Nhược điểm
Nhược điểm chính của Gas là thới gian tính toán GAs có thể chậm hơn các thuật toán khác Có thể kết thúc tính toán bất cứ lúc nào
b) Nhận xét về hàm lựa chọn steady-state :Trong quá trình lựa chọn, thuật toán chỉ lựa chọn những cá thể có độ thích nghi cao để tạo ra quần thể mới. Xong trên thực tế đây không phải là sự lựa chọn đúng đắn, bởi trong nhiều trường hợp sự lai ghép 1 cá thể tồi với 1 cá thể có đặc tính gene cao lại tạo nên một cá thể con có độ thích nghi cao hơn cả .Và cũng không loại trừ trương hợp : sự kết hợp của 2 gene tốt là cho ra một cá thể chứa toàn bộ nhiễm sắc thể lặn và hình thành nên cá thể có độ thích nghi thấp.
III. Flowchart của chương trình chính :
using System;using System.Collections.Generic;using System.Text;using System.Windows.Forms;using System.Collections;
namespace Knapsack2_gene{ class Thuattoan { public int maxgiatri; public int soluongvat; public int solaighep; public int khoiluongtui; public int[] khoiluongvat; public int[] giatrivat; public Gene[] genes; Random rd; public Thuattoan(int soluong_vat, int khoiluong_tui, int[] khoiluong, int[] giatri, int sogenelaighep) { solaighep = sogenelaighep; soluongvat = soluong_vat; khoiluongtui = khoiluong_tui;
khoiluongvat = khoiluong; giatrivat = giatri; } public Thuattoan(int soluong_vat, int khoiluong_tui, int sogenelaighep) {
solaighep = sogenelaighep; soluongvat = soluong_vat; khoiluongtui = khoiluong_tui;
rd = new Random(); khoiluongvat = new int[soluongvat]; giatrivat = new int[soluongvat]; random_vat(); genes = new Gene[30]; } public int danhgia(Gene gen) { int tonggiatri = 0; int maxgiatri = 0; int i; for (i = 0; i < soluongvat; i++) { tonggiatri += giatrivat[i] * gen.mang[i]; //maxgiatri = 10 * khoiluongtui / khoiluongvat[i]; }
return tonggiatri; } public bool thichnghi(Gene gen) { int tongkhoiluong = 0; int i; for (i = 0; i < soluongvat; i++) { tongkhoiluong += khoiluongvat[i] * gen.mang[i]; } if (tongkhoiluong <= khoiluongtui) { return true; } else { return false; }
}
public void random_vat() { for (int i = 0; i < soluongvat; i++) { khoiluongvat[i] = rd.Next(1, khoiluongtui/soluongvat); giatrivat[i] = rd.Next(1, 10); } }
public String hienthigene() { string s = ""; int[] mang = new int[soluongvat]; for (int j = 0; j < 25; ) { genes[j] = new Gene(khoiluongtui, khoiluongvat, soluongvat); { for (int i = 0; i < soluongvat; i++) { genes[j].mang[i] = rd.Next(0, khoiluongtui/khoiluongvat[i]);
} if (genes[j].ok()) { for (int i = 0; i < soluongvat; i++) { s += genes[j].mang[i].ToString()+"."; } s += "\r\n"; j++; } } } return s; } public ArrayList Elitism() { string s = ""; ArrayList arrMax = new ArrayList(); int[] mang = new int[soluongvat]; for (int j = 0; j < 25; j++) { genes[j].h = danhgia(genes[j]); } Gene temp; for (int j = 0; j < 25;j++ ) {
for (int i = j; i < 25; i++) { if (genes[i].h < genes[j].h) { temp = genes[i]; genes[i] = genes[j]; genes[j] = temp; } } } for(int j=0; j<5; j++) { arrMax.Add(genes[j]); } return arrMax; } //public string laighep() //{ //} }
}using System;using System.Collections.Generic;using System.Text;
namespace Knapsack2_gene{ public class Gene { public int[] mang, khoiluongvat; int khoiluongtui; public int h; //Random rd = new Random(1);
public Gene(int khoiluong_tui, int[] khoiluong_vat, int soluongvat) {
khoiluongtui = khoiluong_tui; khoiluongvat = khoiluong_vat;
mang = new int[soluongvat]; } public bool ok() { int tongkhoiluong = 0; for (int i = 0; i < mang.Length; i++) { tongkhoiluong += mang[i] * khoiluongvat[i]; } if (tongkhoiluong > khoiluongtui) return false; else return true; } public Gene(int soluongvat) { mang = new int[soluongvat]; } }}using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Text;using System.Windows.Forms;
namespace Knapsack2_gene{ public partial class Form1 : Form { Thuattoan tt,tt1; Gene gn;
public Form1() { InitializeComponent(); }
private void button3_Click(object sender, EventArgs e) { int khoiluongtui; int soluongvat; int sogenelaighep;
try { khoiluongtui = int.Parse(textBox1.Text); sogenelaighep = int.Parse(textBox2.Text); soluongvat = int.Parse(textBox3.Text);
tt = new Thuattoan(soluongvat, khoiluongtui, sogenelaighep); for (int i = 0; i < soluongvat; i++) { textBox4.Text += tt.khoiluongvat[i].ToString() + "\r\n"; textBox5.Text += tt.giatrivat[i].ToString() + "\r\n"; } } catch (Exception ex) { MessageBox.Show("chua nhap day du thong tin"); } }
private void button2_Click(object sender, EventArgs e) { txtmahoa.Text = tt.hienthigene(); }
private void button1_Click(object sender, EventArgs e) { }
}}
I. Giới thiệuTrong ngành khoa học máy tính, tìm kiếm lời giải tối ưu cho các bài toán là vấn đề được các nhà khoa học máy tính đặc biệt rất quan tâm. Mục đích chính của các thuật toán tìm kiếm lời giải là tìm ra lời giải tối ưu nhất cho bài toán trong thời gian nhỏ nhất. Các thuật toán như tìm kiếm không có thông tin / vét cạn (tìm kiếm trên danh sách, trên cây hoặc đồ thị) sử dụng phương pháp đơn giản nhất và trực quan nhất hoặc các thuật toán tìm kiếm có thông tin sử dụng heurictics để áp dụng các tri thức về cấu trúc của không gian tìm kiếm nhằm giảm thời gian cần thiết cho việc tìm kiếm được sử dụng nhiều nhưng chỉ với không gian tìm kiếm nhỏ và không hiệu quả khi tìm kiếm trong không gian tìm kiếm lớn. Tuy nhiên, trong thực tiễn có rất nhiều bài toán tối ưu với không gian tìm kiếm rất lớn cần phải giải quyết. Vì vậy, việc đòi hỏi thuật giải chất lượng cao và sử dụng kỹ thuật trí tuệ nhân tạo đặc biệt rất cần thiết khi giải quyết các bài toán có không gian tìm kiếm lớn. Thuật giải di truyền (genetic algorithm) là một trong những kỹ thuật tìm kiếm lời giải tối ưu đã đáp ứng được yêu cầu của nhiều bài toán và ứng dụng. Hiện nay, thuật toán di truyền cùng với logic mờ được ứng dụng rất rộng rãi trong các lĩnh vực phức tạp. Thuật toán di truyền kết hợp với logic mờ chứng tỏ được hiệu quả của nó trong các vấn đề khó có thể giải quyết bằng các phương pháp thông thường hay các phương pháp cổ điển, nhất là trong các bài toán cần có sự lượng giá, đánh giá sự tối ưu của kết quả thu được. Chính vì vậy, thuật giải di truyền đã trở thành đề tài nghiên cứu thú vị và đem đến nhiều ứng dụng trong thực tiễn.Tuy giải thuật Gene (GA) có thể chậm hơn một số thuật toán khác song GA lại có một vài ưu điểm nổi trội như: dễ thể hiện, không bị rơi vào trạng thái cực trị địa phương, dễ thay đổi hàm thích nghi, … Vì vậy, thuật toán Gene là một lựa chọn thích hợp cho dạng bài toán quyết định. Ví dụ như bài toán tìm đường, bài toán balô, …Trong khuôn khổ của đề tài này, em xin trình bày nội dung của giải thuật Gene và ứng dụng của nó trong việc giải quyết bài toán Chiếc ba lô loại 2 (Knapsack 2) với phương pháp lựa chọn Rank Selection.Giải thuật di truyền (Genertic Algorithm - GAs)
1. Giới thiệu: GAs (John Holland, 1975) mô phỏng tiến hóa tự nhiên (Darwinian Evolution) ở mức gen sử dụng tư tưởng của survival of the fittest (chọn lọc tự nhiên). Một cá thế (chromosome) mô tả một lời giải ứng viên của bài toán. Một tập các cá thể “alive”, gọi là quần thể (population) được tiến hóa từ thế hệ này tới thế hệ khác phụ thuộc vào sự thích nghi của các cá thể. Thế hệ sinh ra sẽ chứa lời giải của bài toán.
Giải thuật: - Khởi tạo quần thể P(0)- chỉ số i chỉ thế hệ thứ i
- Lặp đến khi quần thể hội tụ hoặc đạt đến tiêu chuẩn kết thúc+ Đánh giá độ thích nghi của mỗi cá thể trong P(i)
+ Lựa chọn các cha từ P(i) dựa trên độ thích nghi của chúng trong P(i).+ Áp dụng các toán tử Gen (crossover, mutation) từ các cha đã chọn để sinh ra các con + Đạt được thế hệ tiếp theo P(i + 1) gồm các cá thể con và cha P(i)
2. Các thành phần cơ bản của Gas a. Khởi tạo (Initializetion)Tạo ngẫu nhiên một số cá thể chấp nhận được để được một quần thể phù hợp với kích thước quần thể được quy định sẵnb. Hàm thích nghi (Fitness Function)Gán giá trị thích nghi cho mỗi cá thể. Giá trị thích nghi càng sát với thực tế thì độ chính xác càng cao.c. Lựa chọn để kết hợp lại (Selection For Recombine)Có nhiều kiểu lựa chọn
+ roulette wheel selection+ Boltzman selection+ Tournament selection+ rank selection+ steady state selection+ Elitism
d. Mã hóaMã hóa chuỗi gene của mỗi cá thể thành dạng thích hợp (nhị phân, mã hóa giá trị, mã hóa hoán vị)
e. Lai ghépSau khi chọn được các cặp NST dùng để lai, ta tiến hành cắt ghép để tạo được các NST mới (con mới). Có nhiều hình thức lai ghép: lai 1 điểm, lai nhiều điểm, lai bằng các phép toán nhị phân, …
f. Đột biếnSau khi lai ghép, để tạo sự đa dạng quần thể, ta làm phép đột biến đối với một vài cá thể. Trên chuỗi gene, tại 1 vài vị trí, làm thay đổi giá trị của 1 đoạn gene nào đó.
g. Đánh giáKhi đã có quần thể mới, ta tiến hành kiểm tra đánh giá xem cá thể nào tốt nhất, cá thể nào tồi. Loại bỏ bớt những cá thể tồi để lặp lại các bước trên đó
h. Tiêu chuẩn kết thúcKhông có quá trình nào là không thể kết thúc. Quá trình tiến hóa có thể dừng lại sau một khoảng tgian được quy định(một số thế hệ) hoặc sau khi đã hội tụ (không thể tìm thêm được cá thể tốt hơn)
II. Bài toán Ba lô 21. Phát biểu bài toán:
Bạn chuẩn bị đi du lịch và bạn cần chuẩn bị một số thứ. Tuy nhiên, bạn không thể đem tất cả đi được vì sức người có hạn. Bạn phải đem theo đồ gì, số lượng mỗi loại là bao nhiêu để đạt được tổng giá trị là lớn nhất nhưng vẫn trong khả năng có thể đem theo được.
2. Ứng dụng Gas để giải quyết bài toán: a. Các bước thực hiện:* Khởi tạo đồ vật và trọng lượng tối đa ba lô:- Tạo ra x đồ vật với khối lượng và giá trị khác nhau (ngẫu nhiên)- Ấn định khối lượng tối đa của túi* Khởi tạo quần thể:
Tạo ra n chiếc ba lô, mỗi ba lô chứa số lượng các vật là khác nhau, không ba lô nào bị quá tải. Số lượng mỗi vật trong balô là một số ngẫu nhiên trong khoảng từ 0 → KL balô/KL vậtTìm balô tốt nhất
* Lựa chọn:Xếp các balô từ thế hệ trước theo thứ tự và được xếp rank
Thứ tự Quá tải Không quá tảiGiá trị tăng dần Giá trị tăng dần
Rank 1 2 … maxRankTính tổng các rankXác định số cá thể con định tạo ra
Lặp đến khi đủ số cá thể conLấy ngẫu nhiên 1 số thuộc khoảng (1; tổng Rank)Cộng các Rank đến khi đc giá trị > giá trị ngẫu nhiênXác định Gene được chọn và đưa vào mảng để lai
* Mã hóa:Với các Gene được chọn để đem lai, mã hóa chúng thành dạng chuỗi bằng phương pháp mã hóa giá trị
* Lai:Phương pháp lai được chọn là lai 2 điểm.
Chuỗi gen được chia thành 3 phần, phần 1 có độ dài = ¼ chuỗi gene, phần 2 có độ dài = ½ chuỗi gene, phần 3 là phần còn lạiCách lai:
Bố a b c Con1 a b’ c
Mẹ a’ b’ c’ Con2 a’ b c’
* Đột biếnDựa vào tỉ lệ đột biến → số lần đột biến → số cá thể đột biếnChọn 3 vị trí để đột biến. Giá trị đột biến = vị trí
* Đánh giáGiải mã gene: Từ chuỗi mã hóa đưa về dạng knapsack→ Sau quá trình lai ghép, quần thể gồm cả các cá thể cha và con.
Vì quần thể có kích thước cố định nên phải đánh giá để chọn ra n cá thể tốt cho thế hệ kế tiếp* Lặp lại các bước trên đến khi quần thể hội tụ hoặc sau k thế hệ
Ứng dụng mô phỏng bài toán:1. Môi trường xây dựng ứng dụng: - Framework:.Net 3.5- IDE: Microsoft Visual Studio 20082. Cấu trúc ứng dụng: Ứng dụng được chia thành 2 phần:- Core: Chứa các file class mô tả thuật toán- Presentation: Chứa các file mô tả giao diện3. Một số thành phần của chương trình:
Class
Item mô tả vật chứa trong túi
Knapsack mô tả chiếc balô (cá thể)
GAs thuật toán Gas
Properties và Methods in class
ItemItemWeight Khối lượng vật
ItemValue Giá trị vật
Knapsack
knapsackMaxWeight KL tối đa của túi
KnapsackCurrentWeight KL hiện tại của túi
KnapsackValue Giá trị hiện tại
Rank Rank trong quần thể
ListItemAmount Mảng chứa sl mỗi vật
overload() Kiểm tra túi quá tải
showItem() Hiển thị sl các vật dạng string
GAsKnapsackWeight KL tối đa của túi
knapsackAmount SL túi trong 1 thế hệ
mutationProp tỉ lệ đột biến
listItem dsách các đồ vật
listKnapsack dsách các cá thể trong 1 thế hệ
newListKnapsack danh sách cá thể cũ và mới
ksBestCurrent chiếc túi tốt nhất
maxValue giá trị của túi tốt nhất
goodGeneration thế hệ có túi tốt nhất
encodedListKnapsack mảng các gene đc mã hóa
initialize() khởi tạo quần thể
selectionFor NewGeneration()
chọn từ quần thể sau khi sinh ra các cá thể tốt
selectionFor Recombination()
các cặp được đem lai
encoding() mã hóa các cặp sẽ lai với nhau
crossover() lai ghép
mutation() đột biến
evaluation() giải mã và tổng hợp cá thể
gene() tổng hợp các bước
4. Giao diệnKết quả hiển thị là quần thể sau khi tiến hóa (con mới sinh và cha)
using System;using System.Collections.Generic;using System.Collections;using System.Text;
public class Knapsack{ //properties public int knapsackMaxWeight, KnapsackCurrentWeight, KnapsackValue, Rank; public int[] ListItemAmount;
//constructor public Knapsack(int knapsackMaxWeight, int itemAmount) { this.knapsackMaxWeight = knapsackMaxWeight; KnapsackCurrentWeight = 0; KnapsackValue = 0; ListItemAmount = new int[itemAmount]; }
//methods public Boolean overload() { if (KnapsackCurrentWeight > knapsackMaxWeight) return true; else return false; }
public string showItem() { string s = ""; int i; for (i = 0; i < ListItemAmount.Length - 1; i++) s += ListItemAmount[i] + ", "; s += ListItemAmount[i].ToString();
return s; }}using System;using System.Collections.Generic;using System.Collections;using System.Text;
public class GAs{ //properties public int knapsackWeight, knapsackAmount, maxValue = 0, mutationProp, goodGeneration; public Knapsack[] listKnapsack, newListKnapsack; public Knapsack ksBestCurrent;
private Random rand; private int generation = 0; private int[,] encodedListKnapsack; private Item[] listItem;
//constructor and methods public GAs(int knapsackWeight, int knapsackAmount, Item[] listItem, int mutationProp) { this.knapsackWeight = knapsackWeight; this.knapsackAmount = knapsackAmount; this.mutationProp = mutationProp; this.listItem = listItem; rand = new Random(); initialize(); newListKnapsack = listKnapsack; generation += 1; gene(); }
private void initialize() { int i = 0, j = 0, k = 0; Knapsack knapsack; bool exist; listKnapsack = new Knapsack[knapsackAmount]; while (i < knapsackAmount) { j = 0; exist = false; int ItemAmount; knapsack = new Knapsack(knapsackWeight, listItem.Length); foreach (Item item in listItem) { ItemAmount = rand.Next(0,Convert.ToInt32(knapsackWeight / (item.ItemWeight))); knapsack.ListItemAmount[j++] = ItemAmount; knapsack.KnapsackCurrentWeight += ItemAmount * item.ItemWeight; knapsack.KnapsackValue += ItemAmount * item.ItemValue; } if ((!knapsack.overload()) && (knapsack.KnapsackValue > 0)) { for (k = 0; k < i; k++) { if (knapsack.KnapsackCurrentWeight == listKnapsack[k].KnapsackCurrentWeight && knapsack.KnapsackValue == listKnapsack[k].KnapsackCurrentWeight) { exist = true; break; } } if (!exist) { listKnapsack[i] = knapsack; if (knapsack.KnapsackValue > maxValue)
{ maxValue = knapsack.KnapsackValue; ksBestCurrent = knapsack; goodGeneration = 0; } i++; } } } }
private void selectionForNewGeneration() { Knapsack[] temp = new Knapsack[newListKnapsack.Length]; int i, j, k, n, m, length = newListKnapsack.Length;
for (i = 0, j = 0, k = newListKnapsack.Length - 1; i < length; i++) { if (newListKnapsack[i].overload()) { temp[j++] = newListKnapsack[i]; } else { temp[k--] = newListKnapsack[i]; } }
Knapsack ksTemp; for (m = 0; m < j; m++) { for (n = m; n < j; n++) { if (temp[m].KnapsackValue > temp[n].KnapsackValue) { ksTemp = temp[m]; temp[m] = temp[n]; temp[n] = ksTemp; } } }
for (m = j; m < length; m++) { for (n = m; n < temp.Length; n++) { if (temp[m].KnapsackValue > temp[n].KnapsackValue) { ksTemp = temp[m]; temp[m] = temp[n]; temp[n] = ksTemp; } } }
int count = knapsackAmount - 1; i = 1; while (count > -1) { if (count == knapsackAmount - 1) { listKnapsack[count] = temp[length - i]; listKnapsack[count].Rank = count + 1; count--; } else { if (listKnapsack[count + 1].KnapsackValue != temp[length - i].KnapsackValue) { listKnapsack[count] = temp[length - i];
listKnapsack[count].Rank = count + 1; count--; } } i++; } }
private void selectionForRecombination() { int rankTotal = knapsackAmount * (1 + knapsackAmount) / 2, i = 0, times; times = rand.Next(knapsackAmount, knapsackAmount + 10); if (times < 0) times = knapsackAmount; if (times % 2 != 0) times += 1;
Knapsack[] selectedListKnapsack = new Knapsack[times]; while (i < times) { int randNumber = rand.Next(1, rankTotal); int currentTotal = 0, pos = 0; while (currentTotal <= randNumber) { currentTotal += listKnapsack[pos++].Rank; } if (i == 0) { selectedListKnapsack[i++] = listKnapsack[pos - 1]; } else { if (selectedListKnapsack[i - 1].Rank != listKnapsack[pos - 1].Rank) { selectedListKnapsack[i] = listKnapsack[pos - 1]; i++; } } } encoding(selectedListKnapsack); }
private void encoding(Knapsack[] selectedListKnapsack) { int i, j, length1 = selectedListKnapsack.Length, length2 = listItem.Length; encodedListKnapsack = new int[length1, length2]; for (i = 0; i < length1; i++) { for (j = 0; j < length2; j++) { encodedListKnapsack[i, j] = selectedListKnapsack[i].ListItemAmount[j]; } } }
private void crossover() { int[,] encodedNewGeneration = new int[encodedListKnapsack.GetLength(0), encodedListKnapsack.GetLength(1)]; int i, j, length1 = encodedListKnapsack.GetLength(0), length2 = encodedListKnapsack.GetLength(1), startPart2 = encodedListKnapsack.GetLength(1) / 4, startPart3 = startPart2 * 3;
for (i = 0; i < length1 - 1; i += 2) { for (j = 0; j < length2; j++) { if (j < startPart2) {
encodedNewGeneration[i, j] = encodedListKnapsack[i, j]; encodedNewGeneration[i + 1, j] = encodedListKnapsack[i + 1, j]; } else if (j < startPart3) { encodedNewGeneration[i, j] = encodedListKnapsack[i + 1, j]; encodedNewGeneration[i + 1, j] = encodedListKnapsack[i, j]; } else { encodedNewGeneration[i, j] = encodedListKnapsack[i, j]; encodedNewGeneration[i + 1, j] = encodedListKnapsack[i + 1, j]; } }
} encodedListKnapsack = encodedNewGeneration; }
private void mutation() { //Random rand = new Random(); int times = mutationProp * encodedListKnapsack.GetLength(0) / 100; for (int i = 0; i < times; i++) { int chooseInvidiual = rand.Next(0, encodedListKnapsack.GetLength(0) - 1); for (int j = 0; j < 3; j++) { int choosePosition = rand.Next(0, encodedListKnapsack.GetLength(1) - 1); encodedListKnapsack[chooseInvidiual, choosePosition] = choosePosition; } } }
private void evaluation() // decoding { newListKnapsack = new Knapsack[knapsackAmount + encodedListKnapsack.GetLength(0)]; int i, j, length1 = encodedListKnapsack.GetLength(0), length2 = encodedListKnapsack.GetLength(1); Knapsack knapsack; for (i = 0; i < length1; i++) { knapsack = new Knapsack(knapsackWeight, listItem.Length); for (j = 0; j < length2; j++) { knapsack.ListItemAmount[j] = encodedListKnapsack[i, j]; knapsack.KnapsackCurrentWeight += listItem[j].ItemWeight * encodedListKnapsack[i, j]; knapsack.KnapsackValue += listItem[j].ItemValue * encodedListKnapsack[i, j]; } //knapsack.fitness = knapsack.KnapsackValue; newListKnapsack[i] = knapsack; if (!knapsack.overload()) { if (knapsack.KnapsackValue > maxValue) { maxValue = knapsack.KnapsackValue; ksBestCurrent = knapsack; goodGeneration = generation; } } } j = 0; while (i < length1 + knapsackAmount) {
newListKnapsack[i++] = listKnapsack[j++]; } }
public void gene() { selectionForNewGeneration(); selectionForRecombination(); crossover(); mutation(); evaluation(); generation++; }}
Lời nói đầu...............................................................................................................................1
I. Khái quát.................................................................................................................................3
1. Giới thiệu Genetic Algorithms (GAs)...............................................................................3
2. Baì toán 0/1 knapsack :.......................................................................................................4
II. Algorithms...........................................................................................................................4
1. Mã hóa (encoding ) :.......................................................................................................4
2. Khởi tạo quần thể ( initial population generation ) :...................................................5
3. Hàm thích nghi (fitness function ) :...............................................................................5
4. Sự lựa chọn cho sự kết hợp lại (selection for recombination).....................................5
5. Lai ghép ( crossover )......................................................................................................6
6. Đột biến ( Mutation).......................................................................................................8
7. Tiêu chuẩn kết thúc.........................................................................................................8
III. Nhận xét...........................................................................................................................9
IV. Flowchart chương trình chính………………………………………………………………..10
Tài liệu tham khảo :................................................................................................................11
Khái quát
Chúng ta giả sử gene bước đầu tiếp cận cho giải thuật gene. Nó mạnh hơn nếu được so sánh với cách tiếp cận truyền thống trong giải thuật gene. Sự tiếp cận được ứng dụng cho bài toán 0/1 kapsack .Giải thuật này tìm ra được kết quả cận tối ưu trong tất cả kết quả đặc biệt được biểu diễn trong tài liệu này, trong khi các cách tiếp cận truyền thống thất bại phần lớn các ví dụ bởi những đặc điểm lợi thế riêng biệt của các cá thể trong quần thể. Trong sự kết hợp giữa toán tử tìm kiếm đột biến , phương pháp này cung cấp một kết quả tốt hơn cho tất cả các vấn đề của các thực thể đã được nghiên cứu.
3. Giới thiệu Genetic Algorithms (GAs) Giải thuật Gene (GAs) cơ bản dựa trên thuyết chọn lọc tự nhiên của Darwin. Bắt đầu sinh ngẫu nhiên một quần thể từ các cá thể, cho thấy một giải pháp tiềm năng cho vấn đề sau nghie cứu. Những cá thể này được lựa chọn theo các giá trị phù hợp nhất thể tạo ra một thế hệ kế tiếp. Toán tử gene, chủ yếu là lai ghép và đột biến, biến đổi các cá thể và làm chúng trở thành một phần của quần thể của thế hệ sau. Các cá thể trong thế hệ có bình quân thích nghi cao hơn so với thế hệ trước. Hai hai thành phần gene, lai ghép và đột biến, là nền tảng cho giải thuật gene. Đột biến thay thế một hoặc nhiều các gene ở mỗi cá thể. Nó giữ vai trò duy trì sự đa dạng quần thể.Về lý thuyết, giải thuật gene được tin để xử lý những mẫu động dạng được gọi là các lược đồ. Mỗi lược đồ định lý [3], còn được gọi là đinh lý cơ sở của giả thuật gene ,’ lược đồ ngắn, lược đồ yêu cầu thấp,lược đồ trên mức trung bình nhận những giá trị thử tăng theo hàm mũ trong những quần thể sau đó. Như một lược đồ triển vọng được đặt tên là khối xây dựng . Giải thuật gene xử lý một số lượng
lớn các lược đồ cùng lúc, cuối cùng hội tụ về giải pháp tốt nhất cho vấn đề. Trên thực tế, lược đồ và khối xây dựng này là một liên kết của gene.Giả thiết một cách tiếp cận gene đệ quy là giới thiệu từng gene một tới quần thể. Các gene này liên kết thông qua hoạt động của thực thể gene để cấu thành các cá thể. Quá trình này tương tự như những hiện tượng tự nhiên của sự tiến hóa từ những cá thể đơn bào tới dạng sống phức tạp hiện nay.
4. Baì toán 0/1 knapsack : Một người ăn xin, gặp may được cho một số lượng lớn đồ vật với giá trị và khối lượng khác nhau. Người ăn xin này chỉ có một cái ba lô ( knapsack) mang được một khối lượng giới hạn, và anh ta muốn sao cho lấy được đầy ba lô với giá trị lớn nhất có thể. Xong mỗi đồ vật chỉ được lấy một lần. Bài tập này sẽ xây dựng giải thuật sao cho anh ta có sự lựa chọn tối ưu nhất.
Áp dụng GAs đệ quy để tiếp cận với cách giải quyết 0/1 knapsack
Vấn đề bài toán 0/1 knapsack được xác định như sau Đưa ra vector giá trị : Pi
Vector khối nượng : wi
Giá trị cực đại : ∑ni=1 pixi
Số vật thể phải thỏa mãn điều kiện : ∑ni=1 wixi ≤ C
xi nhận giá trị 0 hoặc 1 ,( i= 1,…..,n) n là số các phần tử 0 : đồ vật ( nhiễm sắc thể ) không được chọn .1 : đồ vật ( nhiễm sắc thể ) được chọn .Số thứ tự đồ vật được tính từ trái sang phải .
Mã hóa gene cho bài toan 0/1 knapsack có thể làm trực tiếp từ các bit để kết luận biến quyết định (gene quyết định) có thể là một giải pháp cho vấn đề hay không. IV. Algorithms
8. Mã hóa (encoding ) :
xi nhận giá trị 0 hoặc 1 ,( i= 1,…..,n) n là số các phần tử 0 : đồ vật ( nhiễm sắc thể ) không được chọn . 1 : đồ vật ( nhiễm sắc thể ) được chọn . Số thứ tự đồ vật được tính từ trái sang phải .
Dùng biến là một mảng 2 chiều : knapsack [i,j] , để biểu diễn quần thể trong chiếc ba lô.Trong đó : + i : biểu diễn cho yếu tố giá trị. + j : biểu diễn cho yếu tố khối lượng.
9. Khởi tạo quần thể ( initial population generation ) :
Thuật toán bắt đầu bằng cách từ những nhiễm sắc thể, hình thành một số lượng lớn các cá thể .sinh một quần thể ngẫu nhiên từ những cá thể trên.Trong thử nghiệm này ta truyền vào 7 nhiễm sắc thể là mảng 2 chiều :
public int[,] knapsack = new int[9, 2] { { 5, 7 }, { 8, 8 }, { 3, 4 }, { 2, 10 }, { 7, 4 }, { 9, 6 }, { 4,4},{10,7},{6,3} };
Quần thể ban đầu được khởi tạo gồm 50 cá thể, bằng cách khai báo phần tử mảng là 50 10. Hàm thích nghi (fitness function ) :
*Hàm thích nghi xây dựng dựa trên phép toán tính tổng giá trị và khối lượng để xác đình cá thể tốt.*Ngưỡng để so sánh thử nghiệm là : - Giá trị của cá thể : ∑n
i=1 pixi ≥ 22 -Khối lượng cá thể : ∑n
i=1 wixi ≤ 20
11. Sự lựa chọn cho sự kết hợp lại (selection for recombination)
Có rất nhiều thuật toán để lựa chọn cá thể để tham gia vào quá trình lai ghép ( crossover ) và đột biến (mutation). Ví dụ như :Roulette wheel selection, rank selection , Elitism, Steady-state, v.v.v.Bài tập này đi sâu vào thuật toán lựa chọn : Steady-state. Thuật toán được mô tả như sau Steady-state selection Với giải thuật gene steady-state,mỗi lần một thành viên của quần thể bị thay đổi. Lựa chọn một cá thể của quần thể phải dựa trên hàm thích nghi ( fitness).Nó được sao chép và những bản sao biến thể. Thành viên thứ hai của quần thể được lựa chọn là cá thể bị thay thế bởi chuỗi đột biến. Trong quá trình lai ghép hai cá thể với nhau một cá thể thể con được sinh ra và nó thay thể một phần tử của quần thể. Bất chứ phương pháp lựa chọn nào cũng có thể được dùng để lựa chọn cá thể cho sự đột biến hoặc làm phần tử cha-mẹ( parents) . Có nhiều chiến thuật thay thế khác nhau như :
Thay thế cá thể tồi nhất . cách này thường đưa đến sự hội tụ quá nhanh.
Thay thế một cách chọn ngẫu nhiên thành viên. Lựa chọn điểm thay thế dùng hàm thích nghi âm tính. ( negative
fitness ) .
Quá trình lựa chọn được thực hiện dựa trên hàm thích nghi (fitness). Cá thể nào được đánh giá là có độ thích nghi cao thì sẽ được lựa chọn tham gia vào quá trình lai ghép đột biến để tạo ra quần thể mới. Trong khi đó, những cá thể có độ thích nghi thấp sẽ bị bỏ qua. Cả thể có độ thích nghị cao nhất có thể được lựa chọn nhiều lần Tuy nhiên số lượng cá thể được lựa chọn để thực thi phải tương ứng với độ lớn của quần thể ban đầu , vì thế phải đảm bảo được số lượng cá thể ở mỗi thế hệ. Giai đoạn sự tham gia của sự lựa chọn ngẫu nhiên tương tự như quá trình chọn lọc tự nhiên.
12. Lai ghép ( crossover ) Lai ghép là quá trình kết hợp các bit của cá thể này với các bit của cá thể khác . Đây là tiến trình tạo cá thể mới cho thế kế cận, cá thể này kế thừa những đặc tính của các cá thể bố mẹ.Tiến trình lai ghép lựa chọn ngẫu nhiên định vị và sự thay đổi chuỗi con trước và sau nó. Từ điểm lai ghép này tạo ra 2 cá thể mới. Lai ghép có thể có rất nhiều cách. Cụ thể trong có 3 cách được áp dụng để giải quyết bài toán :
Lai ghép một điểmXem xét ví dụ sau
parent 1 1 0 0 | 0 1 1 1Parent 2 1 1 1 1| 0 0 0Offspring1 1 0 0 1 0 0 0 Offspring2 11 1 1 1 1 1
Trong ví trên điểm lai ghép là ở vị trí thứ 3 ( tính từ trái sang ) của 2 cá thể cha mẹ. Cá thể con thứ kế thừa nhiễm sắc thể ở vị trí 1 ,2 và 3 từ cá thể parent1 , và các nhiễm sắc thể ở vì trí 4, 5, 6 và 7 của cá thể parent2. Đối với cá thể con thứ 2 nhận các nhiễm sắc thể 1, 2, 3 từ cá thể parent2 còn các nhiễm sắc thể 4, 5, 6, và 7 thì kế thừa ở cả thể parent1.
Lai ghép 2 điểm
parent 1 1 0 0 | 0 1 | 1 1Parent 2 1 1 1 | 1 0 | 0 0Offspring1 1 0 0 1 0 0 0 Offspring2 111 0 1 1 1
Trong ví trên điểm lai ghép là ở vị trí thứ 3 và thứ 5 ( tính từ trái sang ) của 2 cá thể cha mẹ.+ Cá thể con thứ kế thừa nhiễm sắc thể ở vị trí 1 ,2, 3 và 6,7 từ cá thể parent1 , còn các nhiễm sắc thể ở vị trí 4, 5 của cá thể parent2. +Đối với cá thể con thứ 2 nhận các nhiễm sắc thể 1, 2, 3 và 6,7 từ cá thể parent2 còn các nhiễm sắc thể 4, 5, thì kế thừa ở cả thể parent1. Tính toán ngẫu nhiên điểm lai ghép
+ Trong tài liệu này dùng thuật toán random để chọn ra 1 điểm lai ghép giữa hai cá thể cha mẹ sinh ra cá thể con.
13. Đột biến ( Mutation)
Đột biến được thực thi sau tiến trình lai ghép ( crossover) để đảm bảo không bị dừng lại ở giá trị cực trị địa phương ( a local optimum) trong quá trình giải quết bài toán.Tiến trình đột biến diễn ra nhằm thay đổi cá thể con mới bằng cách đổi các bít 0 và 1 với hoặc ngược lại. Đột biến có thể diễn ra với từng bit trong chuỗi với một vài khả năng, thường là rất nhỏ ( ví dụ : 0.001 ) . Để làm rõ vấn đề, chúng ta xét ví dụ sau
Cá thể chưa bị đột biến : 1 0 0 0 1 1 1Cá thể sau đột biến : 1 1 0 0 1 1 1 Nhiễm sắc thể 0 ở vị trí thứ 2 bị thay thế bởi nhiễm sắc 1 .
14. Tiêu chuẩn kết thúc.Thuật toán Gene sẽ dừng lại khi thỏa mãn một trong các yếu tố sau:
- Quần thể hội tụ, hay nói cách khác là khi tìm ra được cá thể tốt nhất trong quần thể giống với kết quả mong muôn.
- Kết thúc khi số thế hệ sinh ra đạt đến số sinh ra trước.- Kết thúc khi cá thể tốt nhất trong quần thể không thay đổi theo thời gian.- Kết thúc khi các cá thể trở nên giống nhau.
V. Nhận xét c) Thuật toán GAs
Thuật toán Gene là thuật toán không thể khái quát, mà phải áp dụng cho từng bài toán cụ thể, vì không có lý thuyết chung có thể hợp các tham số của thuật toán gene với bất cứ bài toán nào.
Sự giới thiệu thường là kết quả việc học kinh nghiệm của thuật toán gen, cái thường thực hiện chỉ trên mã hóa nhị phân.
Ưu điểm Chính là khả năng song song của thuật toán . GAs duyệt qua không gian tìm kiếm sử dụng nhiều cá thể (and with genotype
rather than phenotype) và ít mắc phải cực trị địa phương như các thuật toán khác
Dễ thể hiện . Khi đã có thuật toán gen cơ bản, chỉ cần viết một NST mới (just one object) để
xử lý bài toán khác. Với cùng cách mã hóa bạn có thể thay đổi hàm thích nghi . Mặc dù vậy, trong một số trường hợp chọn và thể hiện mã hóa sẽ gặp khó
khăn. Nhược điểm
Nhược điểm chính của Gas là thới gian tính toán GAs có thể chậm hơn các thuật toán khác Có thể kết thúc tính toán bất cứ lúc nào
d) Nhận xét về hàm lựa chọn steady-state :Trong quá trình lựa chọn, thuật toán chỉ lựa chọn những cá thể có độ thích nghi cao để tạo ra quần thể mới. Xong trên thực tế đây không phải là sự lựa chọn đúng đắn, bởi trong nhiều trường hợp sự lai ghép 1 cá thể tồi với 1 cá thể có đặc tính gene cao lại tạo nên một cá thể con có độ thích nghi cao hơn cả .Và cũng không loại trừ trương hợp : sự kết hợp của 2 gene tốt là cho ra một cá thể chứa toàn bộ nhiễm sắc thể lặn và hình thành nên cá thể có độ thích nghi thấp. VI. Flowchart của chương trình chính :
using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;
using System.Text;using System.Windows.Forms;
namespace Gene{ public partial class Form1 : Form { public Form1() { InitializeComponent(); }public int[,] knapsack = new int[7, 2] { { 5, 7 }, { 8, 8 }, { 1, 4 }, { 10, 2 }, { 7, 4 }, { 9, 6 }, { 4,4} }; private string[] str_dt = new string[50]; private string[] str_p = new string[50]; private string[] str_f = new string[50]; public int count; public string Random_ks() { string str = ""; count = 0; Random rd = new Random();loop: for (int i = 0; i < 7; i++) { int tmp = 0; tmp = rd.Next(0, 2); if (tmp == 1) { count++; } if (count > 4) { tmp = 0; str += tmp.ToString(); } else str += tmp.ToString();
} if (count < 3 ) { str = ""; count = 0; goto loop;
} return str; }
private void button1_Click(object sender, EventArgs e) { lb.Items.Clear(); for (int i = 0; i < 50; i++) { gen_str: string str_ = Random_ks(); if (i==0) str_dt[i] = str_; else for (int j = 0; j < i; j++) { if (str_dt[j] == str_) goto gen_str; else str_dt[i] = str_; } }
for (int i = 0; i < 50; i++) { lb.Items.Add(str_dt[i]);
} }
//=================================================================================================================================================
private void function_fitness(string[] str_p_) { int sum1 = 0; int sum2 = 0; lb_Steady.Items.Clear(); string tmp = ""; count = 0; for (int i = 0; i < 50; i++) { tmp = str_p_[i]; for (int j = 0; j < 7; j++) { if (Convert.ToInt16(tmp[j]) == 49) { sum1 += knapsack[j, 0]; sum2 += knapsack[j, 1]; } } if (sum2 <= 20 && sum1 >= 22) { lb_Steady.Items.Add(tmp); str_f[count] = tmp; count++; } sum2 = 0; sum1 = 0; } } //=================================================================================================================================================
private void btn_fitness_Click(object sender, EventArgs e) { lb_gt.Items.Clear(); lb_kl.Items.Clear(); int sum1 = 0; int sum2 = 0; lb_Steady.Items.Clear(); string tmp = ""; function_fitness(str_dt); for (int i = 0; i < 50; i++) { str_p[i] = str_dt[i]; tmp = str_dt[i]; for (int j = 0; j < 7; j++) { if (Convert.ToInt16(tmp[j]) == 49) { sum1 += knapsack[j, 0]; sum2 += knapsack[j, 1]; } } lb_gt.Items.Add(sum1); lb_kl.Items.Add(sum2); sum1 = 0;
sum2 = 0;
} btn_alter.Enabled = true; }//=================================================================================================================================================//Hàm lai ghép private string Single_point_crossover(string str1, string str2) { string str_temp = str1.Substring(0, 4) + str2.Substring(4, 3); return str_temp; }
private string Two_point_crossover(string str1, string str2) { string str_temp = str1.Substring(0, 2) + str2.Substring(2, 3) + str1.Substring(5,2); return str_temp; }
private string Arithmetic_crossover(string str1, string str2) { string temp=""; for (int i = 0; i < str1.Length; i++) { temp += Convert.ToString(Convert.ToByte(str1[i]) ^ Convert.ToByte(str2[i])); } return temp; }//=============================================================================================================================================== private void Mutation(string[] str) { Random rnd = new Random(); int index_str = rnd.Next(0,50); string tmp = str[index_str]; int num = rnd.Next(1, 3); for (int i = 0; i < num; i++) { int index = rnd.Next(0,6); if (tmp[index].Equals("0")) { tmp.Remove(index, 1); tmp.Insert(index, "1"); } else { tmp.Remove(index, 1); tmp.Insert(index, "0"); } } str_p[index_str] = tmp; }//================================================================================================================================================= private bool termination_check(string[] str_c) { int dem=0; for (int i = 0; i < str_c.Length; i++) { if (str_c[i] != null) dem++; } for (int i = 0; i < dem - 1; i++) {
for (int j = i; j < dem; j++) { if (!str_c[i].Equals(str_c[j])) return false; } } return true; }
private void button1_Click_1(object sender, EventArgs e) { string[] str_p_ = new string[50]; Boolean flag1, flag2, flag3, flag_termination1, flag_termination2 = false ; flag1 = flag2 = flag3 = true; flag_termination1 = false; String tmp = ""; Random rnd = new Random(); int ran1 = 0,dem=0; int ran2 = 0; int sum1 = 0; int sum2 = 0; while (!flag_termination2) { lb_gtp.Items.Clear(); lb_klp.Items.Clear(); lb_p1.Items.Clear(); if (str_p[0] != null) { function_fitness(str_p); } dem++; for (int i = 0; i < 50; i+=1) { ran1 = rnd.Next(1, count); ran2 = rnd.Next(1, count); if (flag1) { tmp = Single_point_crossover(str_f[ran1], str_f[ran2]); lb_p1.Items.Add(tmp); str_p[i] = tmp; flag1 = false; flag2 = true; for (int j = 0; j < 7; j++) { if (Convert.ToInt16(tmp[j]) == 49) { sum1 += knapsack[j, 0]; sum2 += knapsack[j, 1]; } } lb_gtp.Items.Add(sum1); lb_klp.Items.Add(sum2); } else if (flag2) { tmp = Two_point_crossover(str_f[ran1], str_f[ran2]); lb_p1.Items.Add(tmp); str_p[i] = tmp; if (flag_termination1) { flag1 = true; flag2 = false; } else
{ flag2 = false; flag3 = true; } for (int j = 0; j < 7; j++) { if (Convert.ToInt16(tmp[j]) == 49) { sum1 += knapsack[j, 0]; sum2 += knapsack[j, 1]; } } lb_gtp.Items.Add(sum1); lb_klp.Items.Add(sum2); } else if (flag3 && !flag_termination1) { tmp = Arithmetic_crossover(str_f[ran1], str_f[ran2]); lb_p1.Items.Add(tmp); str_p[i] = tmp; flag3 = false; flag1 = true; for (int j = 0; j < 7; j++) { if (Convert.ToInt16(tmp[j]) == 49) { sum1 += knapsack[j, 0]; sum2 += knapsack[j, 1]; } } lb_gtp.Items.Add(sum1); lb_klp.Items.Add(sum2); } sum1 = 0; sum2 = 0; }
if (termination_check(str_f)) { flag1 = true; flag_termination1 = true; }
if (termination_check(str_p)) flag_termination2 = true; else { } if (dem == 1000) break; } for (int i = 0; i < 50; i++) { lb_p1.Items.Add(str_p[i]); str_f[i] = null; } str_p[0] = null; btn_alter.Enabled = false; }
private void Form1_Load(object sender, EventArgs e) { btn_alter.Enabled = false;
}
private void label5_Click(object sender, EventArgs e) {
} }}
Đề tài: Không gian trạng thái là bài toán chiếc ba lô loại 2.
Hãy xây dựng chương trình giải quyết bài toán theo giải thuật
gene với phương pháp chọn là steady state.
Thuật giải di truyền (Genetic Algorithm_GA) là kỹ thuật chung giyp giải quyết vấn đề-bài toỏn bằng cỏch mụ phỏng sự tiến húa của con người hay của sinh vật núi chung (dựa trờn thuyết tiến húa muụn loài của Darwin) trong điều kiện qui định sẵn của mụi trường. GA là một thuật giải và mục tiờu của GA khụng nhằm đưa ra lời giải chớnh xỏc tối ưu mà là đưa ra lời giải tương đối tối ưu.
Thuật toỏn di truyền gồm cú bốn quy luật cơ bản là lai ghộp, đột biến, sinh sản và chọn lọc tự nhiờn như sau:
Quo trơnh lai ghôp (phôp lai) Quỏ trỡnh này diễn ra bằng cỏch ghộp một hay nhiều đoạn gen từ hai nhiễm sắc thể cha-mẹ để hỡnh thành nhiễm sắc thể mới mang đặc tớnh của cả cha lẫn mẹ. Phộp lai này cú thể mụ tả như sau: Chọn ngẫu nhiờn hai hay nhiều cỏ thể trong quần thể. Giả sử chuỗi nhiễm sắc thể của cha và mẹ đều cú chiều dài là m. Tỡm điểm lai bằng cỏch tạo ngẫu nhiờn một con số từ 1 đến m-1. Như vậy, điểm lai này sẽ chia hai chuỗi nhiễm sắc thể cha-mẹ thành hai nhúm nhiễm sắc thể con là m1 và m2. Hai chuỗi nhiễm sắc thể con lyc này sẽ là m11+m22 và m21+m12. éưa hai chuỗi nhiễm sắc thể con vào quần thể để tiếp tục tham gia quỏ trỡnh tiến húa
Quo trơnh đôt biến (phôp đôt biến) Quỏ trỡnh tiến húa được gọi là quỏ trỡnh đột biến khi một hoặc một số tớnh trạng của con khụng được thừa hưởng từ hai chuỗi nhiễm sắc thể cha-mẹ. Phộp đột biến xảy ra với xỏc suất thấp hơn rất nhiều lần so với xỏc suất xảy ra phộp lai. Phộp đột biến cú thể mụ tả như sau: Chọn ngẫu nhiờn một số k từ khoảng 1 ≥ k ≥ m Thay đổi giỏ trị của gen thứ k éưa nhiễm sắc thể con vào quần thể để tham gia quỏ trỡnh tiến húa tiếp theo
Quo trơnh sinh sản và chọn lọc (phôp toi sinh và phôp chọn) Phôp toi sinh: là quỏ trỡnh cỏc cỏ thể được sao chộp dựa trờn độ thớch nghi của nú. éộ thớch nghi là một hàm được gỏn cỏc giỏ trị thực cho cỏc cỏ thể trong quần thể của nú. Phộp tỏi sinh cú thể mụ phỏng như sau: Tớnh độ thớch nghi của từng cỏ thể trong quần thể, lập bảng cộng dồn cỏc giỏ trị thớch nghi đú (theo thứ tự gỏn cho từng cỏ thể) ta được tổng độ thớch nghi. Giả sử quần thể cú n cỏ thể. Gọi độ thớch nghi của cỏ thể thứ i là Fi, tổng dồn thứ i là Ft.Tổng độ thớch nghi là Fm Tạo số ngẫu nhiờn F cú giỏ trị trong đoạn từ 0 đến Fm Chọn cỏ thể k đầu tiờn thỏa món F ≥ Ft đưa vào quần thể của thế hệ mới.
Phôp chọnSteady state: là quỏ trỡnh loại bỏ cỏc cỏ thể xấu và để lại những cỏ thể tốt.
Phộp chọn Steady state được mụ tả như sau:
Sắp xếp quần thể theo thứ tự độ thớch nghi giảm dần
Loại bỏ cỏc cỏ thể cuối dóy, chỉ để lại n cỏ thể tốt nhất.
Cấu tryc thuật giải di truyền tổng quỏt:
Bắt đầu
t =0;
Khởi tạo P(t)
Tớnh độ thớch nghi cho cỏc cỏ thể thuộc P(t);
Khi (điều kiện dừng chưa thỏa) lặp
t = t + 1;
Chọn lọc P(t)
Lai P(t)
éột biến P(t)
Hết lặp
Kết thyc
Ta đi vào từng bước cụ thể như sau:
1.Khởi tạo quần thể: class Gene { public int[] gen, khoiluongvat; int khoiluongtui; public Gene(int khoiluong_tui, int[] khoiluong_vat, int soluongvat) { khoiluongtui = khoiluong_tui;
khoiluongvat = khoiluong_vat; gen = new int[soluongvat]; }
}
Ta tạo ra một lớp mới cú tờn là Gene mang cỏc thuộc tớnh như sau:
Khoiluongtui: là trọng lượng lớn nhất cú thể mang được của balo
Khoiluongvat[]: là một mảng để lưu giỏ trị khối lượng của vật theo thứ tự
Soluongvat: là số lượng vật được xem xột trong bài toỏn, giỏ trị này sau này sẽ là độ dài của gen[] ta cần mó húa.
Gen[]: là chuỗi cỏc số lần chọn tương ứng của cỏc vật được cho vào balo
2. Tớnh độ thớch nghi cho cỏc cỏ thể thuộc P(t)public int danhgia(Gene g) {
int tonggiatri = 0; int i; for (i = 0; i < soluongvat; i++) { tonggiatri += giatrivat[i] * g.gen[i]; }
return tonggiatri; }
public bool hamthichnghi(Gene g) { int thichnghi = 0;
for (int i = 0; i < soluongvat; i++) { thichnghi += khoiluongvat[i] * g.gen[i]; } if (thichnghi <= khoiluongtui) { return true; } else { return false; }
Gene g thỏa món là một cỏ thể trong quần thể khụng gian bải toỏn cần xột khi mà chyng cú tổng khối lượng cỏc vật được chọn nhỏ hơn hoặc bằng khối lượng của tyi. Tổng khối lượng của cỏc vật đó chọn được tớnh theo cụng thức: thichnghi += khoiluongvat[i] * g.gen[i];
éỏnh giỏ cỏ thể là tớnh tổng giỏ trị của cỏc vật đó được chọn, tổng giỏ trị càng cao thỡ dóy gen được đỏnh giỏ là càng tốt và ngược lại. Tổng giỏ trị được tớnh bằng cụng thức: tonggiatri += giatrivat[i] * g.gen[i]
using System;using System.Collections.Generic;using System.Text;namespace KnapSack2_NguyenDInhHung{ class Gene { public int[] gen, khoiluongvat; int khoiluongtui;
public Gene(int khoiluong_tui, int[] khoiluong_vat, int soluongvat) { khoiluongtui = khoiluong_tui; khoiluongvat = khoiluong_vat; gen = new int[soluongvat]; } public bool ok() { int tongkhoiluong = 0; for (int i = 0; i < gen.Length; i++) { tongkhoiluong += gen[i] * khoiluongvat[i]; } if (tongkhoiluong > khoiluongtui) return false; else return true; } public Gene(int soluongvat) { gen = new int[soluongvat]; } }}using System;using System.Collections.Generic;using System.Text;namespace KnapSack2_NguyenDInhHung{ class Ham { public int soluongvat; public int khoiluongtui; public int[] khoiluongvat; public int[] giatrivat; public Gene[] genes; Random rand; public Ham(int soluong_vat, int khoiluong_tui, int[] khoiluong, int[] giatri) { soluongvat = soluong_vat; khoiluongtui = khoiluong_tui; khoiluongvat = khoiluong; giatrivat = giatri; } public Ham(int soluong_vat, int khoiluong_tui) { soluongvat = soluong_vat; khoiluongtui = khoiluong_tui;
rand = new Random(); khoiluongvat = new int[soluongvat]; giatrivat = new int[soluongvat]; khoitao(); genes = new Gene[50]; } public void khoitao() { for (int i = 0; i < soluongvat; i++) { khoiluongvat[i] = rand.Next(1,khoiluongtui/soluongvat); giatrivat[i] = rand.Next(1, 20); }
} public bool hamthichnghi(Gene g) { int thichnghi = 0;
for (int i = 0; i < soluongvat; i++)
{ thichnghi += khoiluongvat[i] * g.gen[i]; } if (thichnghi <= khoiluongtui) { return true; } else { return false; } } public String hienthigene() { string s = ""; int[] mang = new int[soluongvat]; for (int j = 0; j < 50; ) { genes[j] = new Gene(khoiluongtui, khoiluongvat, soluongvat); { for (int i = 0; i < soluongvat; i++) { genes[j].gen[i] = rand.Next(1,khoiluongtui / khoiluongvat[i] ); } if (genes[j].ok()) { for (int i = 0; i < soluongvat; i++) { s += genes[j].gen[i].ToString(); } s += "\r\n"; j++; } } } return s; } }}using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Text;using System.Windows.Forms;
namespace KnapSack2_NguyenDInhHung{ public partial class Form1 : Form { public Form1() { InitializeComponent(); }
Ham h; private void btnMAHOA_Click(object sender, EventArgs e) { textMahoa.Text = h.hienthigene(); //do //{ // string gen = Mahoa(); // listMahoa.Items.Add(gen.ToString()); // if (thichnghi < 10) // { // listSteady.Items.Add(gen.ToString());i++; // } // //else
// //{ // // listHienthi2.Items.Add(gen.ToString()); // // //} //while (i < 5); //for (i = 0; i < maxchon[0]; i++) //{ // thichnghi += khoiluong[0] * i; // str += i.ToString(); // if (thichnghi < 100) // { // for (a = 0; a < maxchon[1];i++ ) // { // thichnghi += khoiluong[1] * a; // str += a.ToString(); // if (thichnghi < 100) // { // for (s = 0; s < maxchon[2]; s++) // { // str += s.ToString(); // if (thichnghi < 100) // { // thichnghi += khoiluong[s] * s; // } // } // } // } // } //} //listHienthi1.Items.Add(str.ToString()); }
private void Form1_Load(object sender, EventArgs e) { int khoiluongtui; int soluongvat; textMahoa.Clear(); soluongvat = int.Parse(textBox1.Text); khoiluongtui = int.Parse(textBox2.Text); h = new Ham(soluongvat, khoiluongtui); for (int i = 0; i < soluongvat; i++) { listKhoitao.Items.Add((i+1).ToString() + " ( " + h.khoiluongvat[i].ToString() + " ; " + h.giatrivat[i].ToString() + " )");}}}}
