Tìm hiểu ứng dụng của ô tô mát nâng cao trong bài toán sánh mẫu
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.19 MB, 63 trang )
BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
--------------------------------------Nguyễn Thị Hà Thu
TÌM HIỂU ỨNG DỤNG CỦA ƠTƠMÁT NÂNG CAO
TRONG BÀI TỐN SÁNH MẪU
Chun ngành : Tốn - tin
LUẬN VĂN THẠC SĨ KỸ THUẬT
TOÁN – TIN ỨNG DỤNG
NGƯỜI HƯỚNG DẪN KHOA HỌC: PGS.TS PHAN TRUNG HUY
Hà Nội - 2012
MỤC LỤC
LỜI CAM ĐOAN ................................................................................................................. 3
DANH MỤC CÁC HÌNH VẼ ............................................................................................. 4
MỞ ĐẦU ............................................................................................................................... 5
1. Lý do chọn đề tài ........................................................................................................ 5
2. Mục đích nghiên cứu ................................................................................................. 6
3. Nội dung nghiên cứu .................................................................................................. 6
4. Các kết quả đã làm được ........................................................................................... 7
5. Bố cục luận văn .......................................................................................................... 7
CHƯƠNG 1. TỔNG QUAN .............................................................................................. 8
1.1. Khảo sát thực trạng tìm kiếm thơng tin hiện nay ............................................ 8
1.2. Giới thiệu bài toán sánh mẫu. .......................................................................... 11
CHƯƠNG 2. CÁC THUẬT TOÁN SÁNH MẪU.......................................................... 12
2.1. Thuật tốn cài đặt thơ Brute-Force ................................................................... 12
2.2. Thuật tốn áp dụng ơtơmát mờ. ......................................................................... 14
2.2.1. Phát biểu bài tốn.......................................................................................... 14
2.2.2. Mơ hình của ơtơmát mờ................................................................................ 14
2.2.3. Thuật tốn sánh mẫu theo tiếp cận ơtơmát mờ. ........................................ 15
2.3. Thuật tốn Aho-Corasick..................................................................................... 23
2.3.1. Phát biểu bài tốn.......................................................................................... 23
2.3.2. Mơ hình ơtơmát của thuật toán ................................................................... 23
2.3.3. Thuật toán sánh mẫu .................................................................................... 24
2.3.4. Ví dụ............................................................................................................... 27
2.3.5. Đánh giá về tốc độ tìm kiếm ........................................................................ 33
CHƯƠNG 3: TỔ CHỨC CẤU TRÚC DỮ LIỆU.......................................................... 34
3.1. Cây biểu thức logic. ............................................................................................ 34
3.2. Biểu thức logic dạng trung tố. ......................................................................... 35
3.3. Biểu thức logic dạng hậu tố. ............................................................................. 36
3.4. Chuyển đổi biểu thức logic dạng trung tố về dạng hậu tố. .............................. 37
3.5. Tính giá trị biểu thức logic dạng hậu tố. ........................................................... 40
CHƯƠNG 4. XÂY DỰNG PHƯƠNG THỨC TÌM KIẾM MỀM DẺO ...................... 43
4.1. Bài tốn tìm kiếm mềm dẻo theo biểu thức logic.............................................. 43
4.2. Xây dựng chương trình thử nghiệm tìm kiếm mềm dẻo theo biểu thức logic45
4.2.1. Giới thiệu môi trường, công cụ lập trình. .................................................. 45
4.2.2. Giới thiệu chương trình ............................................................................... 46
KẾT LUẬN......................................................................................................................... 62
TÀI LIỆU THAM KHẢO ................................................................................................. 63
2
LỜI CAM ĐOAN
Trước khi đi vào nội dung bản luận văn thạc sĩ của mình, em xin cam đoan
luận văn này do chính em viết, dựa trên những kiến thức, kinh nghiệm của bản thân,
sự hướng dẫn của thầy hướng dẫn, và những thơng tin mà em tìm hiểu, tham khảo
được qua các tài liệu liên quan.
Em xin gửi lời cảm ơn chân thành đến các thầy cơ Viện Tốn ứng dụng và
Tin học, trường Đại học Bách Khoa Hà Nội đã tạo điều kiện và truyền đạt cho em
những kiến thức vơ cùng hữu ích.
Đặc biệt, em xin bày tỏ lòng biết ơn sâu sắc đến PGS.TS Phan Trung Huy.
Ngoài việc truyền đạt cho em những kiến thức và giúp em tìm kiếm tài liệu tham
khảo, Thầy đã hướng dẫn em rất tận tình. Trong quá trình viết luận văn, khi em gặp
một số khó khăn, Thầy đã động viên, giúp đỡ em rất nhiều.
Do trình độ có hạn, luận văn của em có thể cịn nhiều nhược điểm và sơ suất,
kính mong được các thầy cơ góp ý. Em xin chân thành cảm ơn!
Hà Nội, ngày 15 tháng 09 năm 2012
Học viên
Nguyễn Thị Hà Thu
3
DANH MỤC CÁC HÌNH VẼ
Hình 1.1 Tìm kiếm thơng dụng theo các box cứng…………………………….………..8
Hình 1.2 Tìm kiếm nâng cao trong Yahoo!Việt Nam………………………….………..9
Hình 1.3 Tìm kiếm nâng cao trong Ask……………………………………...……………9
Hình 1.4 Tìm kiếm nâng cao trong Google……………………………………………..10
Hình 2.1 Sánh mẫu trong thuật tốn cài đặt thơ………………………………………12
Hình 2.2 Độ mờ trong thuật tốn sánh mẫu theo tiếp cận ơtơmát mờ………………15
Hình 2.3 Giá trị của next[i] trong thuật toán sánh mẫu theo tiếp cận ơtơmát mờ...17
Hình 2.4 Mơ hình cấu trúc cây của ơ tơ mát nâng cao trong thuật tốn
Aho-Corasick……………………………………………………………………..23
Hình 2.5 Trạng thái các hàm goto trong thuật tốn Aho-Corasick…………………28
Hình 2.6 Goto function trong thuật tốn sánh đa mẫu Aho-Corasick………………31
Hình 3.1 Cây biểu thức logic……………………………………………………………..34
Hình 4.1 Kết quả minh họa cho modun sánh mẫu theo thuật tốn cài đặt thơ…..47
Hình 4.2 Kết quả minh họa cho modun sánh mẫu theo tiếp cận ôtômát mờ……..50
Hình 4.3 Kết quả minh hoạ cho modun tìm kiếm đa mẫu theo thuật tốn
Aho-Corasick……………………………………………………………………52
Hình 4.4 Kết quả minh họa cho modun chuyển đổi biểu thức logic dạng
trung tố về dạng hậu tố…………………………………………………………54
Hình 4.5 Kết quả minh họa cho modun tính giá trị biểu thức logic dạng hậu tố…56
Hình 4.6 Kết quả minh họa cho modun tìm kiếm theo biểu thức logic áp dụng
thuật toán sánh mẫu cài đặt thơ……………………………………………...58
Hình 4.7 Kết quả minh họa cho mudun tìm kiếm theo biểu thức logic áp dụng
ơtơmát mờ………………………………………………………………………....59
Hình 4.8 Kết quả minh họa cho mudun tìm kiếm theo biểu thức logic áp dụng
thuật toán Aho-Corasick………………………………………………………61
4
MỞ ĐẦU
1. Lý do chọn đề tài
Trong xu thế phát triển của khoa học cơng nghệ, máy tính và Internet được
sử dụng trong hầu hết các lĩnh vực và góp phần vào việc thúc đẩy sự phát
triển nhiều lĩnh vực trong cuộc sống. Hiện nay, ngồi máy tính, cịn có rất
nhiều sản phẩm công nghệ khác như Ipad, Iphone, hay những chiếc điện thoại
cũng có thể thay thế cho một chiếc máy tính trong nhằm phục vụ cho những
mục đích nhất định của con người, như học tập, công việc, giải trí và tìm
kiếm thơng tin. Trong thời kì có sự phát triển của Internet rất mạnh mẽ ngày nay,
bài tốn tìm kiếm có vai trị rất quan trọng. Một vấn đề cốt lõi để hệ thống tìm
kiếm thơng tin hoạt động nhanh và chính xác đó là hệ thống phải được áp dụng
những thuật tốn hiệu quả để tìm kiếm dữ liệu. Dữ liệu trong máy tính được lưu trữ
dưới rất nhiều dạng khác nhau như hình ảnh, âm thanh,… nhưng phổ biến nhất vẫn
là lưu trữ sử dụng chuỗi. Ta có thể thấy các dạng khác nhau của chuỗi như ở các file
dữ liệu, trên biểu diễn của các gen, hay chính văn bản chúng ta đang đọc.
Ba vấn đề chính trong bài tốn tìm kiếm: một là tính hiệu quả về kết quả
tìm kiếm, hai là tốc độ tìm kiếm nhanh, và thứ ba là giao diện hướng người dùng.
Hiện nay, trên thị trường đang ứng dụng phổ biến nhất là các modun tìm kiếm
cứng nhắc. Ví dụ như các box tìm kiếm cứng trong các thư viện, các trang tìm kiếm
trên internet.. Người sử dụng phải nhập từng nội dung cần tìm kiếm vào các box
với số lượng hạn chế và nội dung phù hợp với tính năng của các box. Bởi với các
modun tìm kiếm cứng như vậy, việc tìm kiếm thơng tin theo nhiều yêu cầu khác
nhau với các liên kết logic cứng nhắc cần nhiều box. Điều này gây ra sự phức tạp
vì tính khơng mềm dẻo khi có các phát sinh số yêu cầu tìm kiếm và trong cách xây
dựng phát triển chương trình địi hỏi phải viết lại chương trình.
Vì vậy, cần phải xây dựng một phương thức tìm kiếm nâng cao, đáp ứng cả
ba vấn đề của bài tốn tìm kiếm. Một vấn đề cốt lõi để hệ thống tìm kiếm thơng tin
hoạt động nhanh và chính xác đó là hệ thống phải được áp dụng những thuật toán
hiệu quả để tìm kiếm dữ liệu, cụ thể là những thuật tốn sánh mẫu có tính mềm dẻo
5
để có thể kết hợp với tổ chức cấu trúc dữ liệu để xây dựng một phương thức tìm
kiếm mềm dẻo. Từ đó, cho phép người sử dụng chương trình có thể tìm kiếm thơng
tin theo một tổ hợp logic tùy ý của các xâu mẫu, nâng cao tính mềm dẻo của dạng
thức nhập dữ liệu đầu vào, không cứng nhắc như nhiều ứng dụng sẵn có trên thị
trường đang sử dụng. Phương pháp này khắc phục hai vấn đề: giao diện đã thân
thiện, mềm dẻo hơn với người sử dụng; và khơng phải xây dựng lại chương trình
khi có các yêu cầu mới phát sinh, tiết kiệm được chi phí khi xây dựng chương
trình.
Trên thế giới, cũng đã có những phần mềm tìm kiếm theo biểu thức logic,
tuy nhiên do tính bảo mật và những vẫn đề về bản quyền nên chúng ta khơng
biết được những phần mềm đó được xây dựng như thế nào. Nhu cầu tìm hiểu về
phương thức tìm kiếm này để chủ động nắm bắt được cơng nghệ, có thể phát
triển nâng cấp thuật tốn, sử dụng để tìm kiếm những vùng dữ liệu có tính chất
bảo mật và nhạy cảm, được nảy sinh một cách tự nhiên. Giải pháp cho vấn đề
này nhờ sử dụng phương pháp ơtơmát nâng cao là hợp lý.
Vì những lý do đó, đề tài được lựa chọn cho luận văn tốt nghiệp này là đi
vào tìm hiểu ứng dụng của ơtơmát nâng cao trong bài tốn sánh mẫu.
2. Mục đích nghiên cứu
Luận văn đi vào nghiên cứu các thuật tốn sánh mẫu ứng dụng ơtơmát nâng
cao, cách thức liên kết các thuật toán này với các biểu thức logic để giải quyết bài
tốn tìm kiếm trên cơ sở áp dụng kỹ thuật của ơtơmát nâng cao trong những tình
huống tìm kiếm chính xác đơn, đa mẫu và tìm kiếm mềm dẻo theo biểu thức logic.
3. Nội dung nghiên cứu
- Tìm hiểu về các thuật tốn sánh đơn mẫu và đa mẫu sử dụng ôtômát nâng cao,
so sánh các thuật tốn để thấy được sức mạnh của ơtơmát nâng cao trong bài tốn
sánh mẫu.
- Tìm hiểu cây biểu thức logic, cách tổ chức cấu trúc dữ liệu để tính “giá trị” một
câu lệnh tìm kiếm được biểu diễn dưới dạng một biểu thức logic.
- Tìm cách liên kết các thuật toán sánh mẫu và cây biểu thức logic để xây dựng
6
một phương thức tìm kiếm mềm dẻo.
4. Các kết quả đã làm được
- Trình bày các thuật tốn tìm kiếm đơn mẫu và đa mẫu, so sánh các thuật toán
để thấy được sức mạnh của ôtômát nâng cao trong bài tốn sánh mẫu.
- Trình bày về cách tổ chức cấu trúc dữ liệu, cây biểu thức logic, tính tốn giá trị
biểu thức logic.
- Đóng góp mới của tác giả: Xây dựng được phương thức tìm kiếm mềm dẻo
theo biểu thức logic dựa trên sự kết hợp giữa các thuật toán sánh mẫu ứng dụng
ôtômát nâng cao và cây biểu thức logic cho đơn mẫu và đa mẫu.
5. Bố cục luận văn
Luận văn bao gồm các chương sau :
• Chương 1: Tổng quan
Chương này giới thiệu bài tốn tìm kiếm mềm dẻo theo biểu thức logic, trọng
tâm là bài toán sánh mẫu có ứng dụng của ơtơmát nâng cao
• Chương 2: Các thuật tốn sánh mẫu
Chương này phân tích q trình tiền xử lý thơng tin đầu vào, trình bày các
thuật tốn tìm kiếm đơn mẫu theo phương thức cài đặt thơ, theo tiếp cận ơtơmát mờ,
tìm kiếm đa mẫu theo thuật tốn Aho-Corasick.
• Chương 3: Tổ chức cấu trúc dữ liệu
Chương này đưa ra cách xây dựng cây biểu thức logic, và trình bày cách thức
tính giá trị của một biểu thức logic theo phương pháp hậu tố.
• Chương 4: Xây dựng phương thức tìm kiếm mềm dẻo theo biểu thức logic
Nội dung chương 4 là kết hợp các thuật tốn sánh mẫu đã trình bày ở chương
2 và cây biểu thức logic ở chương 3 để xây dựng phương thức tìm kiếm mềm dẻo.
Chương này cũng giới thiệu cơng cụ và mơi trường lập trình để xây dựng chương
trình tìm kiếm mềm dẻo thử nghiệm dựa trên các modun cài đặt các thuật tốn sánh
mẫu.
• Kết luận
• Tài liệu tham khảo.
7
CHƯƠNG 1. TỔNG QUAN
1.1.
Khảo sát thực trạng tìm kiếm thơng tin hiện nay
Trong thời kì có sự phát triển của Internet rất mạnh mẽ ngày nay, bài tốn
tìm kiếm có vai trị rất quan trọng.
Dữ liệu trong máy tính được lưu trữ dưới rất nhiều dạng khác nhau như hình
ảnh, âm thanh,… nhưng phổ biến nhất vẫn là lưu trữ sử dụng chuỗi. Ta có thể thấy
các dạng khác nhau của chuỗi như ở các file dữ liệu, trên biểu diễn của các gen, hay
chính văn bản chúng ta đang đọc.
Ba vấn đề chính trong bài tốn tìm kiếm: một là tính hiệu quả về kết quả
tìm kiếm, hai là tốc độ tìm kiếm nhanh, và thứ ba là giao diện hướng người dùng.
Hiện nay, trên thị trường đang ứng dụng phổ biến nhất là các modun tìm kiếm
cứng nhắc dựa trên các box tìm kiếm. Người sử dụng phải nhập từng nội dung
cần tìm kiếm vào các box với số lượng hạn chế và nội dung phù hợp với tính năng
của các box. Bởi với các modun tìm kiếm cứng như vậy, việc tìm kiếm thơng tin
theo nhiều u cầu khác nhau với các liên kết logic cứng nhắc cần nhiều box.
Điều này gây ra sự phức tạp đối với người sử dụng và trong cách xây dựng phát
triển chương trình cũng như ảnh hưởng đến tốc độc tìm kiếm.
Hình 1.1 Tìm kiếm thơng dụng theo các box cứng
8
Hình 1.2 Tìm kiếm nâng cao trong Yahoo! Việt Nam
/>
Hình 1.3 Tìm kiếm nâng cao trong Ask
/>9
Hình 1.4 Tìm kiếm nâng cao trong Google
/>Trên thế giới, cũng đã có những chương trình tìm kiếm xây dựng dựa trên các
modun tìm kiếm mềm dẻo, ví dụ điển hình nhất là Tìm kiếm nâng cao trong
Google. Tuy nhiên, đó là phạm trù quốc tế, và do những vấn đề về cơng nghệ, sự
cạnh tranh, tính bảo mật nên chúng ta khơng biết những modun tìm kiếm mềm
dẻo ấy được xây dựng như thế nào.
Vì vậy, cần phải xây dựng một phương thức tìm kiếm nâng cao, đáp ứng cả
ba vấn đề của bài tốn tìm kiếm. Từ đó, cho phép người sử dụng chương trình có
thể tìm kiếm thông tin theo một tổ hợp logic tùy ý của các xâu mẫu, nâng cao tính
mềm dẻo của dạng thức nhập dữ liệu đầu vào, không cứng nhắc như nhiều ứng
dụng sẵn có trên thị trường đang sử dụng. Phương pháp này khắc phục hai vấn
đề: giao diện đã thân thiện, mềm dẻo hơn; và tốc độ tìm kiếm cũng sẽ được cải
thiện rất nhiều so với những modun tìm kiếm cứng nhắc, khơng phải xây dựng
lại chương trình khi có nhiều yêu cầu mới phát sinh.
Một vấn đề cốt lõi để hệ thống tìm kiếm thơng tin hoạt động nhanh và chính
xác đó là hệ thống phải được áp dụng những thuật tốn hiệu quả để tìm kiếm dữ
liệu, cụ thể là những thuật tốn sánh mẫu có tính mềm dẻo để có thể kết hợp với tổ
chức cấu trúc dữ liệu để xây dựng một phương thức tìm kiếm thơng minh. Các thuật
tốn sánh mẫu ứng dụng ơtơmát nâng cao là những thuật tốn đáp ứng được tính
chất mềm dẻo đó.
10
1.2.
Giới thiệu bài tốn sánh mẫu.
Sánh mẫu hay cịn gọi là so mẫu (pattern – matching), là một trong những bài
toán cơ bản và quan trọng trong các thuật toán xử lý về xâu ký tự hay xử lý văn bản
(text processing). Bài tốn đặt ra là tìm ra sự xuất hiện của một hoặc nhiều xâu mẫu
(pattern) trong chuỗi các ký tự cho trước được gọi là xâu đích. Đây là một bài toán
kinh điển và phổ biến trong khoa học kỹ thuật bởi hầu hết mọi ứng dụng tìm kiếm
đều có sự so khớp dữ liệu ở một dạng nào đó. Ứng dụng của sánh mẫu được áp dụng
phổ biến trong các trình soạn thảo văn bản hay các chương trình tìm kiếm văn bản
trên internet dựa vào các từ khóa, tất nhiên để thực thi các bài toán phức tạp này cần
rất nhiều kỹ thuật và cách xử lý khác đi kèm.
Ta đã có rất nhiều thuật tốn sánh mẫu, phương pháp tìm kiếm đơn mẫu cổ
điển và đơn giản nhất là thuật tốn Brute-Force cịn gọi là thuật toán duyệt lần lượt
hay thuật toán cài đặt thơ. Tiếp đến là các thuật tốn Karp-Rapin, Knuth-MorrisPratt (viết tắt là thuật toán KMP), Boyer-Moore…
Trong luận văn này, tác giả tập trung trình bày ứng dụng của ơtơmát nâng
cao trong hai thuật tốn sánh mẫu sau: thuật tốn tìm kiếm đơn mẫu theo tiếp cận
ơtơmát mờ và thuật tốn tìm kiếm đa mẫu Aho-Corasick. Sau đó là sự kết hợp của
hai thuật toán này với cây biểu thức logic để xây dựng phương thức tìm kiếm mềm
dẻo.
11
CHƯƠNG 2. CÁC THUẬT TỐN SÁNH MẪU
2.1.
Thuật tốn cài đặt thơ Brute-Force
Sánh mẫu (đơn mẫu) là bài tốn tìm sự xuất hiện
của một xâu mẫu w
trong một xâu đích S ( một dòng text hoặc một văn bản). Xâu mẫu và xâu đích là
tất cả những xâu gồm các kí tự trong bảng chữ cái.
Xâu mẫu w được kí hiệu là w = w[1 .. m] ; độ dài là m.
Xâu đích S được kí hiệu là s = s [1 .. n] ; độ dài là n .
• Thuật toán sánh mẫu được thực hiện như sau :
-
Đầu tiên chúng sắp thẳng hàng các vị trí biên trái của xâu mẫu và xâu đích, sau
đó so sánh các ký tự đã được sắp thẳng hàng của xâu mẫu và xâu đích – bước này
gọi là một phép thử hoặc một phép lấy mẫu.
- Sau khi so khớp được toàn bộ xâu mẫu hoặc sau một lần không khớp, chúng
dịch chuyển xâu mẫu về bên phải.
- Gán mỗi lần thử với vị trí thứ j trong xâu đích, khi xâu mẫu được sắp thẳng với
đoạn s[ j .. j+m-1].
- Các thủ tục duyệt được lặp đi lặp lại cho đến khi các vị trí biên phải của xâu
mẫu vượt quá vị trí biên phải của xâu đích. Đây gọi là phép duyệt và bước dịch
chuyển.
Hình 2.1 Sánh mẫu trong thuật tốn cài đặt thơ
Thuật tốn duyệt lần lượt bao gồm các bước duyệt, tại tất cả các vị trí từ 1
đến vị trí thứ n – m + 1 trong xâu đích, duyệt xem có một sự xuất hiện nào của xâu
mẫu hay khơng. Sau đó, qua mỗi lần thử, nó dịch xâu mẫu sang vị trí kế tiếp
bên tay phải. Độ phức tạp của thuật toán duyệt lần lượt này là O(mn) trong trường
hợp xấu nhất nhưng tiến trình của nó trong thực hành thường được thực hiện rất
12
nhanh trên kiểu dữ liệu đặc thù.
Đây là thuật toán đơn giản nhất, được mô tả như sau : BF( w, m, s, n )
1
Searching
2
for j = 1 to n – m + 1 do
3
i:= 1
4
while ( i < m + 1 and w[i] = s[i + j] )
5
i =i+1
6
if i > m
7
then OUTPUT ( j )
Đánh giá về tốc độ tìm kiếm.
Có thể thấy ngay rằng giải thuật này có cách thức khá đơn giản, dễ hiểu. Tuy
nhiên, việc so mẫu tại từng vị trí của xâu đích, sau khi so khớp được toàn bộ mẫu
hoặc sau 1 lần khơng khớp, mẫu lại được dịch chuyển về phía bên phải để đứng
sắp thẳng với vị trí tiếp theo trong xâu đích khiến thời gian xử lý của thuật tốn
khơng được nhanh, độ phức tạp cỡ O(mn).
Ở mục sau, chúng ta sẽ tìm hiểu một thuật tốn sánh mẫu (đơn mẫu) áp dụng
ôtômát mờ, khắc phục được nhược điểm về tốc độ của thuật toán duyệt lần lượt
này.
13
2.2. Thuật tốn áp dụng ơtơmát mờ.
Thuật tốn này cùng một mục đích với thuật tốn duyệt lần lượt ở mục trước
là giải quyết bài toán sánh mẫu (đơn mẫu)
2.2.1. Phát biểu bài tốn.
Có một dịng S gồm các kí tự trên bảng chữ cái mà ta cần phải tìm kiếm sự
xuất hiện của mẫu w với độ dài m. Bản chất của vấn đề tìm kiếm là duyệt từ trái
sang phải và xét từng kí tự xuất hiện trên S.
2.2.2. Mơ hình của ơtơmát mờ.
Giả sử : xâu mẫu w được kí hiệu là w = w[1 .. m] ; độ dài là m.
xâu đích S được kí hiệu là s = s [1 .. n] ; độ dài là n .
A là bảng chữ cái biểu diễn w và S
AW là tập các kí tự xuất hiện trong w
Các kí tự khơng xuất hiện trong w để đơn giản kí hiệu là #.
Ta xét ơtơmát mờ A = ( Q, A, δ , q0 , F ), trong đó:
- Q : tập hữu hạn các trạng thái mờ. Mỗi trạng thái mờ là một tập mờ với các giá trị
mờ nguyên thuộc đoạn [0,…, m], ta biểu diễn:
q = ( v1 , ..., v k ) .
Và q0 = ( 0, 0, …, 0 ).
- δ: hàm chuyển trạng thái được xác định thông qua hàm TFuzz được mô tả như
sau:
δ(q, a) = q ' = (v '1 ,..., v'k )
mà
v 'i = TFuzz(vi , a)
- F : tập hữu hạn các trạng thái mờ
q f = ( v1 , ..., v k )
Đối với tìm một mẫu thì k = 1
∃ i : vi = độ dài mẫu i
mà
q0 = 0 , q f = m, Q = {0,1,.., m}.
14
2.2.3. Thuật tốn sánh mẫu theo tiếp cận ơtơmát mờ.
Khi duyệt S từ trái sang phải, bắt đầu từ kí tự thứ t = 1,…, n ta sẽ kí hiệu là
s[1], s[2], .. , s[n]. Ta gọi fuz[t] là độ mờ xuất hiện của mẫu cho tới thời điểm
thứ t trên S tức là tại kí tự được đọc là s[t]. Ở đây, độ mờ được hiểu là độ
dài của khúc đầu ( prefix ) dài nhất trên w khớp với S sau khi đọc đến kí tự s[t].
Hình 2.2 Độ mờ trong thuật toán sánh mẫu theo tiếp cận ôtômát mờ
(Độ mờ là độ dài khúc đầu dài nhất trên w khớp với S tại thời điểm t)
Khi nhận được giá trị của độ mờ fuz[t] = m thì chứng tỏ có thêm một lần xuất hiện
mẫu tại vị trí t – m + 1 ứng với kí tự s[t – m+1].
Ban đầu, ôtômát ở trạng thái q0. Mỗi khi gặp được một kí tự s[t] và ơtơmát đang
ở trạng thái q thì ta nhận được trạng thái mới q’ = δ (q, s[t]).
Nếu q’ ∈ F
thì báo có một lần xuất hiện mẫu. Do đó, hàm TFuzz sẽ phải được
xây dựng một cách thích hợp để phản ánh được bản chất của thuật tốn trên.
Xét một ví dụ minh họa để dễ dàng hiểu được cách xây dựng bảng TFuzz:
ơtơmát đang ở trạng thái q thì ta nhận được trạng thái mới q’ = δ (q, s[t]).
Nếu q’ ∈ F
thì báo có một lần xuất hiện mẫu. Do đó, hàm TFuzz sẽ phải được
xây dựng một cách thích hợp để phản ánh được bản chất của thuật toán trên.
Xét một ví dụ minh họa để dễ dàng hiểu được cách xây dựng bảng TFuzz:
15
Ví dụ 1:
Xâu w = acaac
có độ dài m = 5.
Xâu S = abcdcdefaacaacgh
có độ dài n = 13
Bảng TFuzz:
i
#
a
c
0
0
1
0
1
0
1
2
2
0
3
0
3
0
4
2
4
0
1
5
5
0
3
0
Từ trạng thái 0, khi đọc được s[t] =a thì nhận được q’ = 1, có nghĩa là
fuz[t]=1,.. Chẳng hạn với q = 2, nếu đọc được s[t] =a thì q’ = 3, cịn nếu đọc được
s[t] = c thì q’ = 0. Như vậy, bản chất của q tại từng thời điểm là phản ánh độ mờ
của mẫu trên S tại thời điểm tương ứng.
Có thể thấy fuz[t] = δ ( fuz[t – 1], s[t] ).
Trường hợp k = 1 thì fuz[t] = TFuzz( fuz[t – 1], s[t] ).
Với ví dụ trên, từ bảng TFuzz, ta có cách tìm mẫu như sau :
S = a
b
a
c
b
a
a
c
a
a
c
g
h
t = 1
2
3
4
5
6
7
8
9
10
11
12
13
fuz[t]=0
0
1
2
0
1
1
2
3
4
5
0
0
Tại vị trí thứ 11 trên S, ứng với s[11] ta có độ mờ fuz[11] = 5, từ đó ghi
nhận mẫu xuất hiện ở vị trí thứ 11 – 5 + 1 = 7 ứng với kí tự s[7].
Tư tưởng của phương pháp là mảng hai chiều TFuzz (một chiều i = 0..m,
một chiều là chỉ số các ký tự trong AW ) sẽ được tính thơng qua một mảng 1
chiều ( i = 0..m) được đặt tên là next. Chúng ta sẽ tìm hiểu hàm next, TFuzz là gì?
Và chúng được tính như thế nào?
16
Khi đoạn đầu của mẫu w đã được khớp với một đoạn trên S, giả sử kí tự
cuối của đoạn khớp đó là w[i] cũng chính bằng s[t], khi đó ta có độ mờ là i .
Vậy thì sau khi đọc kí tự tiếp theo là s[t+1], độ mờ fuz[t+1] sẽ là bao nhiêu?
Nếu i là độ mờ trước khi đọc kí tự x thì TFuzz(i,x) chính là độ mờ sau khi đọc kí
tự x. Để tính được TFuzz(i,x), cần tính thơng qua mảng next[i] với i = 0 .. m. Ở
đây, next[i] chính là độ dài đoạn dài nhất của khúc đầu w khớp với khúc cuối của
đoạn w’ = w[1] .. w[i] ( đoạn chung này phải khác w’ tức là next[i] < i ).
Hình 2.3 Giá trị của next[i] trong thuật toán sánh mẫu theo tiếp cận ôtômát mờ
(Độ dài đoạn khớp nhau in đậm được gọi là next[i])
Như trên hình 2.3, đoạn w[i-h+1] .. w[i] khớp với đoạn w[1] .. w[h] thì
next[i] = h. Khi có được bảng next[i], ta sẽ tính được bảng TFuzz, và từ bảng
TFuzz, sẽ cho thấy độ mờ tại cái vị trí trên xâu S. Khi độ mờ bằng m thì ghi
nhận thêm một sự xuất hiện của w trên S.
Phương pháp sánh mẫu dựa trên mơ hình ơtơmát mờ được thực hiện thơng qua
3 bước sau đây :
• Bước 1: Xây dựng bảng next[i] với i = 0 .. m.
• Bước 2: Xây dựng bảng TFuzz(i, x) trong đó i = 0.. m và x là ký tự được
đọc.
• Bước 3: Duyệt từng kí tự trên S từ trái qua phải, tính độ mờ tại mỗi vị trí trên S.
Khi độ mờ bằng m thì ghi nhận một lần xuất hiện mẫu trên S.
Sau đây là giải thuật chi tiết các bước:
17
Bước 1: Xây dựng bảng next.
next[0] = -1; next[1] = 0;
for i = 2 to m do
{
j = next[i – 1];
while ( j >=0 and w[i] # w[ j+1 ])
{
j = next[ j ] ;
}
next[i] = j + 1;
}
Bước 2: Xây dựng bảng TFuzz.
for i=0 to m do
{
k:=i;
while ( k=m or (x # w[k+1] and k>=0) )
{
k := next[k];
}
TF(i, x) = k + 1;
}
Bước 3: Tính độ mờ fuz(t) tại các vị trí trên S và kết luận.
fuz[0] = 0;
while ( 0< t <= n
and fuz[t-1] < m)
{
fuz[t] = TF( fuz[t-1] , s[t] )
}
if fuz[t] = m then return 1 else return 0;
18
Trở lại với ví dụ 1:
w= a
c
a
w = w[1] w[2] w[3]
a
c
w[4]
w[5]
có độ dài m = 5
Và S = abacbaacaacgh. Có độ dài n = 13.
• Bước 1:
.
i= 0 : next[0] = -1 ;
i=1 : next[1] = 0 ;
i=2 :
j = next[1] = 0;
vì w[2] # w[1] nên
j = next[ j ] = next[0] = -1;
vì j = -1 < 0 nên dừng vòng while;
next[2] = j + 1 = -1 + 1 = 0;
i=3:
j = next[2] = 0;
vì w[3] = w[1] nên khơng thực hiện vịng while;
next[3] = j + 1= 0 + 1= 1
i=4:
j = next[3] = 1;
vì w[4] # w[2] nên
j = next[ j] = next[1] = 0;
vì w[4] = w[1] nên dừng vòng while;
next[4] = j + 1 = 0 + 1 = 1;
i=5:
j = next[4] = 1;
vì w[5] = w[2] nên khơng thực hiện vịng while;
next[5] = j + 1 = 1+ 1=2;
20
Kết thúc ta có bảng :
i
0
1
2
3
4
5
next[i]
-1
0
0
1
1
2
• Bước 2.
Tính TF( i, x).
Tính tốn theo thuật tốn, ta có bảng các giá trị TFuzz như sau :
Kí tự khác
a
c
i=0
0
1
0
i=1
0
1
2
i=2
0
3
0
i=3
0
4
2
i=4
0
1
5
i=5
0
3
0
• Bước 3: Tính độ mờ fuz trên xâu S.
fuz
S = a
b
a
c
b
a
a
c
a
a
c
0
0
1
2
0
1
1
2
3
4
5
1
g
h
Tại vị trí s[11] , ta có fuz[11] = 5 = m thì dừng lại, ra kết quả là w có xuất hiện
trong S.
Với bài tốn tìm nhiều sự xuất hiện của mẫu trên S thì ta tiếp tục duyệt
cho đến hết xâu S, mỗi lần tính được độ mờ tại vị trí thứ i bằng m thì ghi nhận thêm
một sự xuất hiện của mẫu tại vị trí t – m + 1.
21
Đánh giá về tốc độ tìm kiếm.
Các bước tính mảng next[i] và TFuzz(i,x) là các bước tiền xử lý, bản chất thuật
tốn này chỉ là duyệt lần lượt từng kí tự trên xâu đích S từ trái qua phải, tính tốn
độ mờ tại mỗi kí tự đọc được. Vì thế độ phức tạp của thuật toán này chỉ là O(n).
Như vậy, so với thời gian chạy của thuật toán cài đặt thơ là O(mn) thì
thuật tốn tìm kiếm xâu theo tiếp cận ôtômát mờ cải thiện về tốc độ hơn hẳn.
Tuy nhiên thuật tốn cải thiện về tốc độ thì kèm theo là sự chiếm dụng bộ
nhớ nhiều hơn do sử dụng mảng 2 chiều TFuzz.
22
2.3. Thuật tốn Aho-Corasick
Khơng như hai thuật tốn sánh đơn mẫu đã trình bày ở trên, Aho-Corasick là
thuật tốn sánh đa mẫu.
2.3.1. Phát biểu bài tốn.
Có một dịng S gồm các kí tự trên bảng chữ cái mà ta cần phải tìm kiếm sự
xuất hiện của n mẫu x1 , x2 , .., xn. Kết quả bài toán là đưa ra những xâu mẫu có
xuất hiện trong S.
2.3.2. Mơ hình ôtômát của thuật toán
Tập hợp các xâu mẫu x1 , x2 , .., xn sẽ được xây dựng thành cấu trúc cây.
Ví dụ hình dưới đây là cây được tạo cho tập hợp các xâu mẫu: {he, she, hers, his}
Hình 2.4 Cấu trúc cây của ôtômát nâng cao trong thuật toán Aho-Corasick
Cấu trúc cây như sau:
Mỗi nhánh đi sẽ tạo ra 1 xâu mẫu
Mỗi cạnh là 1 kí tự của xâu mẫu
Mỗi node được gọi là 1 trạng thái
Trong thuật toán này ta định nghĩa 3 hàm xử lý quan trọng
1. Hàm goto g(q, a): từ trạng thái q, nếu gặp kí tự a thì sẽ đi đến trạng thái nào.
Hàm này sẽ cho biết trạng thái đó.
23
2. Hàm failure link: hàm failure f() được định nghĩa như sau: giả sử node hiện tại là
q, f (q) = u trong đó u là hậu tố dài nhất của q mà u cũng là tiền tố của các xâu
mẫu xi trong cây T(X). Như vậy, failure link sẽ khơng được tìm thấy trong cây.
3. Output funtion: out(q) sẽ trả về tất cả các xâu được xác định với node q.
2.3.3. Thuật toán sánh mẫu
Thuật toán này gồm 2 phase:
Phase tiền xử lý (Preprocessing): xây dựng cây và xử lý dữ liệu
Phase tìm kiếm (Searching): tìm sự tồn tại các xâu mẫu x1 , x2 , .., xn trong
chuỗi text (xâu đích)
Phase tiền xử lý: Dùng để tạo cây với các thông tin sau
-
Xây dựng bộ dữ liệu goto function của các trạng thái trên cây
-
Xây dựng bộ dữ liệu ouput function của các trạng thái trên cây
-
Xây dựng bộ dữ liệu failure link của các trạng thái trên cây
Phase tiền xử lý sẽ gọi 2 function con là ENTER() và COMPLETE() để tạo 3 bộ dữ
liệu ở trên.
Phase tiền xử lý được định nghĩa như sau:
Tên hàm: PREAC
Input: X là tập hợp các xâu mẫu, k là số lượng xâu mẫu
Ký hiệu: X[i] = xi và x[j] là ký tự thứ j trong một xâu mẫu x
Ouput: cây tìm kiếm với các bộ dữ liệu cần thiết để tìm kiếm
Funtion PREAC(X, k)
Tạo node gốc
//Tạo vịng lặp, xây dựng hàm goto cho node gốc
For a ∈ ∑
Do g(root, a) = root
24
//Đưa các từ khóa vào cây
For i=0 to k-1
Do ENTER(X[i], root)
// Xây dựng hàm failure link để hoàn tất việc xây dựng cây
COMPLETE(root)
Return root
Trong đó, hàm ENTER được định nghĩa như sau:
Input: x là xâu mẫu, root là node gốc
Output: bộ dữ liệu goto function và 1 phần của bộ dữ liệu ouput function
ENTER(x, root)
Gán node r = root
i=0
//Duyệt theo các cạnh đã được xây dựng
While i < |x| and g(r, x[i]) ≠ FAIL and g(r, x[i]) ≠ root
Do r = g(r, x[i])
i=i+1
//Tạo cạnh mới
While i < |x|
Do : Tạo node mới s
g(r, x[i]) = s
r=s
i=i+1
out(r) = {x}
25
Hàm COMPLETE được định nghĩa như sau:
Input: root là node gốc
Ouput: xây dựng bộ dữ liệu failure link và phần còn lại của dữ liệu ouput function
COMPLETE(root)
Queue = empty
For: với mỗi kí tự a mà g(0, a) = s ≠ 0
Queue = Queue U {s}
F(s) = 0
While queue ≠ empty
Lấy node r ra từ queue
For: với mỗi kí tự a mà g(r, a) = s ≠ 0
Queue = Queue U {s}
State = f(r)
While g(state, a) = fail do state = f(state)
F(s) = g(state, a)
Output(s) = output(s) U output(f(s))
Phase tìm kiếm
Bắt đầu từ trạng thái state = 0
Duyệt các kí tự a của chuỗi text tìm kiếm
While g(state, ai) = fail do state = f(state)
State = g(state, ai)
Nếu output(state) != empty return True
Return False
26
