›

Đồ án Tìm hiểu phương pháp nhận diện chữ viết tay sử dụng Kernel Discriminant Analysis - Phạm Đức Hải

pdf 50 trang huongle 2220
Download
Bạn đang xem 20 trang mẫu của tài liệu "Đồ án Tìm hiểu phương pháp nhận diện chữ viết tay sử dụng Kernel Discriminant Analysis - Phạm Đức Hải", để tải tài liệu gốc về máy bạn click vào nút DOWNLOAD ở trên

Tài liệu đính kèm:

  • pdfdo_an_tim_hieu_phuong_phap_nhan_dien_chu_viet_tay_su_dung_ke.pdf

Nội dung text: Đồ án Tìm hiểu phương pháp nhận diện chữ viết tay sử dụng Kernel Discriminant Analysis - Phạm Đức Hải

  1. MỤC LỤC LỜI CẢM ƠN 3 GIỚI THIỆU 4 CHƢƠNG I: KHÁI QUÁT VỀ NGÔN NGỮ C# 6 1.1 Khái niệm .NET 6 1.2 Hoạt động của .NET 6 1.2.1 Hỗ trợ hƣớng đối tƣợng và sử dụng giao diện. 7 1.2.3 Định kiểu mạnh. 8 1.2.4 Bắt lỗi xử dụng các ngoại lệ 9 1.2.5 Sử dụng các thuộc tính 9 1.2 Khái quát về C# 9 1.2.1 Đặc điểm ngôn ngữ 10 1.2.2 Các kiểu nguyên (primitive) 11 1.2.3 Khai báo (declarations) 11 1.2.4. Cấu trúc điều kiện (Conditionals structure) 12 1.2.5. Các vòng lặp (Loops) 12 1.2.6. Các phát biểu nhảy (Jumps) 12 1.2.7. Các phƣơng thức (methods) 13 1.2.8. Các thuộc tính (properties) 13 1.2.9. Từ chỉ định truy cập (Accessbility Modifiers) 14 1.2.10. Các đối tƣợng, các lớp và các cấu trúc 14 CHƢƠNG II NHẬN DẠNG CHỮ VIẾT TAY SỬ DỤNG HẠT NHÂN PHÂN TÍCH BIỆT THỨC 16 2.1. Phân tích biệt thức tuyến tính 16 2.2. Nhân Phân tích biệt thức 17 2.3. Chức năng nhân trick và nhân chuẩn. 17 2.4. Mô hình các lớp đƣợc sử dụng trong KDA 18 2.5. Nhận dạng chữ số 19 2.5.1. Dữ liệu số của UCI 19 Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 1
  2. 2.5.2 Phân lớp các chữ số số bằng KDA. 21 CHƢƠNG III CHƢƠNG TRÌNH THỬ NGHIỆM 23 3.1. Kiểm tra ứng dụng 23 3.1.1 Phân tích 23 3.1.2 Kết quả 25 3.2 Mã lệnh trong chƣơng trình viết cho một số các class 28 3.2.1 Class Linear Discrimnant Analysis 28 3.2.2 Kernel Discrimnant Analysis 43 KẾT LUẬN 49 TÀI LIỆU THAM KHẢO 50 Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 2
  3. LỜI CẢM ƠN Lời đầu tiên em xin đƣợc bày tỏ lòng biết ơn sâu sắc tới thầy giáo ThS. Đỗ Văn Chiểu, đã dành rất nhiều thời gian quý báu để tận tình giúp đỡ, chỉ bảo và hƣớng dẫn em hoàn thành tốt đồ án tốt nghiệp này. Em xin gửi lời cảm ơn đến ban giám hiệu nhà trƣờng và các thầy, cô giáo của trƣờng dân lập Hải Phòng đặc biệt là các thầy, cô khoa công nghệ thông tin đã giảng dạy chúng em trong suốt quãng thời gian qua, cung cấp cho chúng em những chuyên môn cần thiết và quý báu giúp chúng em hiểu rõ hơn các lĩnh vực đã nghiên cứu để hoàn thành đề tài đƣơc giao. Cuối cùng em xin cảm ơn sự quan tâm, chăm sóc của gia đình, sự động viên, giúp đỡ của bạn bè đã tạo điều kiện giúp đỡ em hoàn thành tốt quá trình nghiên cứu thực tập và thực hiện đề tài này. Hải Phòng, ngày 18 tháng 10 năm 2010 Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 3
  4. GIỚI THIỆU Trong thời đại ngày nay Cong nghệ thông tin hầu nhƣ đã thâm nhập vào toàn bộ các lĩnh vực đời sống xã hội. Xã hội càng phát triển thì nhu cầu về công nghệ thông tin ngày càng cao, do vậy dữ liệu số hầu nhƣ không còn xa lạ đối với mỗi ngƣời chúng ta. Trong mọi lĩnh vực các ứng dụng công nghệ thông tin đã trợ giúp con ngƣời rất nhiều. Công nghệ thông tin đƣợc ứng dụng một cách mạnh mẽ mọi nơi, mọi lúc. Ta dƣờng nhƣ có thể thấy máy tính xuất hiện ở mọi nơi trong các doanh nghiệp, cơ quan, trƣờng học Mọi công việc đều đòi hỏi liên quan tới Công nghệ thông tin nhƣ: quản lý học sinh, sinh viên, quản lý nhân sự và lƣơng, thiết kế cố vấn kiến trúc xây dựng cho đến các ngành nghề đòi hỏi chất lƣợng và chuyên môn sâu. Ngành nào nghề nào cũng có sự góp mặt của Công nghệ thông tin, từ giáo dục, y tế, giao thông, xây dựng, viễn thông . Trong ngành Công nghệ thông tin, thông tin hình ảnh đóng vai trò rất quan trọng trong trao đổi thông tin, bởi phần lớn các thông tin mà con ngƣời thu nhận đƣợc đều thông qua thị giác. Một loạt các bài toán đƣợc đặt ra và yêu cầu đƣợc giải quyết nhƣ: nhận dạng các tối tƣợng chuyển động, xử lý và chọn mẫu màu, nhận dạng chữ viết tay Bài toán nhận dạng tuy ra đời từ thập niên 60 của thế kỷ trƣớc nhƣng vẫn luôn nhận đƣợc sự quan tâm, nghiên cứu của nhiều nhà khoa học trên thế giới.Đặc biệt là trong những thập niên gần đây, cùng với quá trình đẩy mạnh tin học hóa trong mọi lĩnh vực đời sống xã hội, nhận dạng không chỉ còn là lĩnh vực nghiên cứu lý thuyết nữa mà đã đƣợc ứng dụng rộng rãi trong thực tế cuộc sống. Các bài toán nhận dạng đƣợc nghiên cứu nhiều nhất hiện nay bao gồm nhận dạng các mẫu hình học (vân tay, mặt ngƣời, hình khối, ), nhận dạng tiếng nói và nhận dạng chữ viết. Chúng đƣợc áp dụng vào nhiều lĩnh vực nhƣ y học, dự báo thời tiết, dự báo cháy rừng, điều khiển robot, Trong các bài toán nhận dạng này, nhận dạng chữ viết là bài toán đang đƣợc ứng dụng phổ biến nhất hiện nay. Nhận dạng chữ viết bao gồm hai kiểu chính là nhận dạng chữ in và nhận dạng chữ viết tay. Cho đến nay bài toán nhận dạng chữ in đã đƣợc giải quyết khá trọn vẹn với sự ra đời của nhiều hệ thống nhận dạng đạt tới độ chính xác gần nhƣ tuyệt đối. Tiêu biểu có hệ nhận dạng chữ in dựa trên mô hình mạng nơron bốn lớp của J. Wang và J.S.N. Jean đạt tới tỷ lệ chính xác 99.75%. Ở Việt Nam Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 4
  5. hiện đã có sản phẩm VNDOCR của Viện Công nghệ thông tin nhận dạng chữ in tiếng Việt với độ chính xác tới 99%. Trong nhận dạng chữ viết tay thì nhận dạng chữ viết tay đƣợc chia thành hai lớp bài toán lớn là nhận dạng chữ viết tay trực tuyến (online) và nhận dạng chữ viết tay ngoại tuyến (offline). Nhận dạng chữ viết tay trực tuyến là nhận dạng các chữ trên màn hình ngay khi nó đƣợc viết. Trong hệ nhận dạng này máy tính sẽ lƣu lại các thông tin về nét chữ nhƣ thứ tự nét viết, hƣớng và tốc độ của nét Ngƣợc lại, trong nhận dạng chữ viết tay ngoại tuyến, dữ liệu đầu vào đƣợc cho dƣới dạng các ảnh đƣợc quét từ các giấy tờ, văn bản. Vấn đề nhận dạng chữ viết tay đã đƣợc đề cập và nghiên cứu trong nƣớc từ khá lâu và đạt đƣợc kết quả với các phƣơng pháp nhƣ Support Vecto Machine (SVM). Tuy nhiên, việc ứng dụng các nhân (Kernel) vào việc nhận dạng chƣa đƣợc nghiên cứu nhiều. Chính vì thế mà em đã chọn đề tài: Tìm hiểu phương pháp nhận diện chữ viết tay sử dụng Kernel Discriminant Analysis. Nội dung chính của khóa luận bao gồm các phần sau: phần mở đầu, phần kết luận, ba chƣơng nội dung, cụ thể: Chương 1: C#. Chương 2: Giới thiệu về phƣơng pháp Kernel Discriminant Analysis. Chương 3: Chƣơng trình thử nghiệm. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 5
  6. CHƢƠNG I: KHÁI QUÁT VỀ NGÔN NGỮ C# C# là một ngôn ngữ lập trình hƣớng đối tƣợng mới. Cấu trúc và lập luận của C# có đầy đủ các đặc tính của một ngôn ngữ lập trình hƣớng đối tƣợng trƣớc đó ( C++, Java ). C# đƣợc thiết kế dùng cho nền .NET framework, một công nghệ mới và đầy triển vọng trong việc phát triển các ứng dụng hệ thống và mạng internet. một ngôn ngữ lập trình hoàn toàn độc lập, điều đó có nghĩa là mã của C# đƣợc chạy trên .NET nhƣng có những đặc tính của C# mà .NET không hỗ trợ ( quá tải toán tử ) hay là những đặc tính của .NET mà C# không hỗ trợ. 1.1 Khái niệm .NET .NET Framework là một thƣ viện class có thể đƣợc sử dụng với một ngôn ngữ .NET để thực thi các việc từ thao tác chuỗi cho đến phát sinh ra các trang web động (ASP.NET), phân tích XML và reflection. .NET Framework đƣợc tổ chức thành tập hợp các namespace, nhóm các class có cùng chức năng lại với nhau, thí dụ nhƣ System.Drawing cho đồ hoạ, System.Collections cho cấu trúc dữ liệu và System.Windows.Forms cho hệ thống Windows Forms. .NET là một môi trƣờng quản lý, phát triển và thực thi các mă ngôn ngữ biết .NET. .NET cung cấp các khả năng về cấp phát và thu hồi bộ nhớ, quản ly các nguồn tài nguyên. Trọng tâm của .NET bao gồm 2 thành phần là CLR ( the comon language runtime ) và .NET framework class libary – Các thƣ viện cơ sở. 1.2 Hoạt động của .NET chƣơng t nh sẽ đƣợc biên dịch thành MSIL (Microsoft Intermediate Language). Dịch IL( Intermediate Language ) thành nền cụ thể của .NET bằng CLR(Common Language Runtime). Có rất nhiều ngôn ngữ biết .NET, bao gồm C++, VB.NET, Managed C++, J+ and J#, Sc của chúng cũng sẽ đƣợc biên dịch thành IL. IL sẽ đảm bảo sự tƣơng thích giữa các ngôn ngữ khác nhau. 1 thành Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 6
  7. phần của ngôn ngữ này có thể sử dụng thành phần và thuộc tính của thành phần nằm trong ngôn ngữ khác. Đây có thể nói là một khả năng kì diệu của C#. Để đạt đƣợc những điều đó, IL bao hàm những thuộc tính sau: 1. Hỗ trợ hƣớng đối tƣợng và giao diện ( interface ). 2. Phân biệt giữa kiểu giá trị và kiểu tham chiếu. 3. Định kiểu mạnh. 4. Quản lỗi thông qua các ngoại lệ. 5. Sử dụng các thuộc tính. 1.2.1 Hỗ trợ hƣớng đối tƣợng và sử dụng giao diện. IL tạo nhiều thuận lợi với các ngôn ngữ lập trình hƣớng đối tƣợng, không phải vô tình mà các thƣ viện cơ sở của .NET đều đƣợc viế tƣởng về giao diệ COM là một nhị phân chuẩn cho phép các thành phần có thể tƣơng tác với nhau mà không cần quan tâm đến ngôn ngữ nào đă tạo lập ra c dịch ra đều thống nhất và tƣơng thích với COM. Tuy rằng COM không hỗ trợ tính thừa kế, chính thế COM đánh mất sự thuận lợi của lập t nh hƣớng đối tƣợng. Tương thích chéo Với khả năng hỗ trợ đồng thời nhiều loại ngôn ngữ, sau khi đƣợc biên dịch thành IL, m của các ngôn ngữ khác nhau có thể làm việc cùng với nhau. Cụ thể là một lớp đƣợc tạo ra trong một ngôn ngữ có thể thừa kế từ một lớp đƣợc viết trong một ngôn ngữ khác. Một lớp có thể chứa thể hiện của một lớp khác không quan tâm đến ngôn ngữ đă tạo ra hai lớp đó. Một đối tƣợng có thể gọi trực tiếp phƣơng thức của một đối tƣợng khác đƣợc viết bởi một ngôn ngữ khác. Các đối tƣợng (hoặc các tham chiếu đến các đối tƣợng) có thể đƣợc truyền qua lại giữa các hàm Bạn có khả năng bẫy lỗi từng bƣớc chƣơng t nh nguồn giữa các ngôn khác nhau Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 7
  8. 1.2.2 Phân biệt kiểu giá trị và kiểu tham chiếu. IL có sự phân biệt rõ ràng đối với kiểu giá trị và kiểu tham chiếu. Trên IL, các kiểu giá trị vẫn đƣợc lƣu trong vùng Stack, các kiểu tham chiếu vẫn đƣợc lƣu trong vùng Heap. 1.2.3 Định kiểu mạnh. ràng đối với từng kiểu dữ liệu trả về, các kiểu dữ liệu luôn đƣợc đánh dấu cụ thể. Điều này là hoàn toàn phù hợp với đặc tính hỗ trợ nền cho nhiều loại ngôn ngữ của .NET. Một vấn đề nảy sinh đó là có những kiểu đƣợc hỗ trợ trong ngôn ngữ này nhƣng lại không đƣợc hỗ trợ trong ngôn ngữ khác hoặc là nếu một lớp xuất nó cần phải biết tất cả các kiểu dùng trong các lớp đó. CTS: Để đáp ứng đƣợc tác vụ đó, IL sử dụng tiến trình CTS – Common Type System, đây vốn là một bộ con trong .NET, đảm bảo tất cả các kiểu dữ liệu khác nhau của các ngôn ngữ khác nhau đều đƣợc biên dịch thành một kiểu chung trên nền .NET CLS :CLS phối hợp với CTS để đảm bảo sự tƣơng thích giữa các ngôn ngữ. CLS là một chuẩn mà tất cả các ngôn ngữ biết .NET đều phải tuân theo. CLS hoạt động theo 2 nguyên tắc CLS không hoàn n bó buộc các ngôn ngữ lập trình, điều này khiến cho các ngôn ngữ hoàn toàn có thể phát triển theo các chiều hƣớng riêng. CLS gắn một chuẩn lên các ngôn ngữ lập t nh biết .NET, điều này đảm bảo m của các ngôn ngữ đó luôn đƣợc hỗ trợ khi biên dịch. Garbare Collection Garbage collector là một thành phần quản lí bộ nhớ của .NET. Tốc độ hoạt động của C# hoàn toàn phụ thuộc vào Garbare collection, GC là một ứng dụng có mục đích giải phóng bộ nhớ trên nền .NET. Nguyên tắc làm việc của GC nhƣ sau. Các m sau khi đƣợc biên dịch, kết quả sẽ đƣợc đƣa hoàn toàn vào Heap, khi Heap đầy, GC sẽ thực thi so sánh với các m đang thực hiên, nếu nhƣ các kết quả không dùng đến, GC sẽ thực hiện nhiệm vụ dọn dẹp và lấy lại bộ nhớ. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 8
  9. 1.2.4 Bắt lỗi xử dụng các ngoại lệ .NET đƣợc thiết kế để đơn giản hoá quá t nh bẫy lỗi thông qua các ngoại lệ, ƣ tƣởng ở đây là một vùng m đƣợc thiết kế nhƣ là các thủ tục quản ngoại lệ, mỗi đoạn m , hoặc không đƣợc phép thực thi một số lệnh). Những điều kiện này có thể đƣợc định nghĩa kĩ hoặc sơ qua tuỳ bạn. Cấu trúc ngoại lệ bảo đảm rằng khi một điều kiện sinh lỗi xảy ra, ngay lập tức luồn thi hành sẽ nhảy đến thủ tục quản ngoại lệ. 1.2.5 Sử dụng các thuộc tính Các thuộc tính trong IL cho phép ngƣời dùng có thể sử dụng dễ dàng hoặc có thể tự thiết lập các thuộc tính của riêng họ. Tiến trình biên dịch thành m .NET – Common language runtime CLR có nh IL thành m nh biên dịch kiểu just in time ( JIT ), khác với kiểu thông dịch trong Java. Thay vì phải d nh biên dịch JIT sẽ biên dịch từng phần m khi nó đƣợc gọi Khi m nguồn đƣợc biên dich, m kết quả của nó sẽ đƣợc lƣu lại trong bộ nhớ cho tới khi thoát khỏi ứng dụng, và trong các lần xử l tiếp theo, máy tính sẽ không phải biên dịch lại một lần nữa, đây là l .NET luôn chạy nhanh hơn trong những lần sau. Một đặc điểm nữa là .NET luôn hỗ trợ tối ƣu tuỳ vào loại vi xƣ l , đối với các tiến t mà đƣa ra cách thức phù hợp. 1.2 Khái quát về C# C# là một ngôn ngữ lập trình hƣớng đối tƣợng đƣợc phát triển bởi Microsoft, là phần khởi đầu cho kế hoạch .NET của họ. Tên của ngôn ngữ bao gồm ký tự thăng theo Microsoft nhƣng theo ECMA là C#, chỉ bao gồm dấu số thƣờng. Microsoft phát triển C# dựa trên C++ và Java. C# đƣợc miêu tả là ngôn ngữ có đƣợc sự cân bằng giữa C++, Visual Basic, Delphi và Java. C# đƣợc thiết kế chủ yếu bởi Anders Hejlsberg kiến trúc sƣ phần mềm nổi tiếng với các sản phẩm Turbo Pascal, Delphi, J++, WFC. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 9
  10. 1.2.1 Đặc điểm ngôn ngữ C#, theo một hƣớng nào đó, là ngôn ngữ lập trình phản ánh trực tiếp nhất đến .NET Framework mà tất cả các chƣơng trình .NET chạy, và nó phụ thuộc mạnh mẽ vào Framework này. Mọi dữ liệu cơ sở đều là đối tƣợng, đƣợc cấp phát và hủy bỏ bởi trình dọn rác Garbage-Collector (GC), và nhiều kiểu trừu tƣợng khác chẳng hạn nhƣ class, delegate, interface, exception, v.v, phản ánh rõ ràng những đặc trƣng của .NET runtime. So sánh với C và C++, ngôn ngữ C# bị giới hạn và đƣợc nâng cao ở một vài đặc điểm nào đó, nhƣng không bao gồm các giới hạn sau đây: Các con trỏ chỉ có thể đƣợc sử dụng trong chế độ không an toàn. Hầu hết các đối tƣợng đƣợc tham chiếu an toàn, và các phép tính đều đƣợc kiểm tra tràn bộ đệm. Các con trỏ chỉ đƣợc sử dụng để gọi các loại kiểu giá trị; còn những đối tƣợng thuộc bộ thu rác (garbage-collector) thì chỉ đƣợc gọi bằng cách tham chiếu. Các đối tƣợng không thể đƣợc giải phóng tƣờng minh. Chỉ có đơn kế thừa, nhƣng có thể cài đặt nhiều interface trừu tƣợng (abstract interfaces). Chức năng này làm đơn giản hóa sự thực thi của thời gian thực thi. C# thì an-toàn-kiểu (typesafe) hơn C++. Cú pháp khai báo mảng khác nhau("int[] a = new int[5]" thay vì "int a[5]"). Kiểu thứ tự đƣợc thay thế bằng tên miền không gian (namespace). C# không có tiêu bản. Có thêm Properties, các phƣơng pháp có thể gọi các Properties để truy cập dữ liệu. Có reflection. Trong C# 3.0, sẽ có vài bổ sung cơ bản sau: Các từ khóa "select, from, where" cho phép truy vấn từ một tập, từ SQL, v.v. (hay còn đƣợc gọi là LINQ - viết tắt của Language INtergrated Query) Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 10
  11. Khởi tạo đối tƣợng: Customer c = new Customer(); c.Name="James"; trở thành Customer c = new Customer { Name="James" }; Các biểu thức lambda: listOfFoo.Where(delegate(Foo x) { return x.size>10;}) trở thành listOfFoo.Where(x => x.size>10); var x = "hello"; có thể hoán đổi với string x = "hello"; Các phƣơng thức mở rộng 1.2.2 Các kiểu nguyên (primitive) C# sử dụng hệ thống kiểu/đối tƣợng trong .NET mà ở đó, các chƣơng trình C# có thể giao tiếp với nhiều ngôn ngữ khác trong .NET mà không gặp rắc rối nào về kiểu. Ví dụ, kiểu int là một bí danh của System.Int32 đƣợc kế thừa cuối cùng từ System.Object. Điều này có nghĩa là các kiểu primitive, hay kiểu simple trong hàm C# cũng giống nhƣ bất kỳ các đối tƣợng khác. Ví dụ, điều này là đúng khi gọi phƣơng thức toString hoặc GetType trong bất kỳ một kiểu primitive nào. Mặc dù các kiểu simple trong C# là những đối tƣợng, tuy nhiên chúng vẫn đƣợc truyền theo tham trị (pass-by-value) tƣơng tự nhƣ trong Java. Đây là trƣờng hợp khác, bởi vì ngoài việc là những đối tƣợng, tất cả các kiểu simple trong C# đều là các đối tƣợng – cấu trúc (struct) khi đƣợc truyền theo tham trị sẽ đƣợc truyền theo tham biến một lần nữa. 1.2.3 Khai báo (declarations) Trong C# có 2 cách để biết một biến hằng: Đánh dấu một biến bằng từ khóa const sẽ làm cho giá trị đƣợc chuyển đổi trƣớc khi biên dịch. Với định nghĩa sau: const int two = 2; phát biểu: 2 * two đƣợc chuyển thành 2 * 2 xử lý trƣớc khi biên dịch,điều này làm cho nó chạy nhanh hơn không phải tìm những giá trị hằng trong suốt quá trình chạy. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 11
  12. 1.2.4. Cấu trúc điều kiện (Conditionals structure) Trong C# cũng có các cấu trúc “if-then-else”, “switch” nhƣng trong switch không cho phép dòng điều khiển phải rơi vào chính xác trong các trƣờng hợp khác nhau của phát biểu switch 1.2.5. Các vòng lặp (Loops) Ngoài những dòng lặp: while, do-while, for. C# còn có foreach Ví dụ: foreach( int member in array ) Console.Writeln( member ); * Giao tiếp Ienumerable cung cấp khả năng nhận đƣợc một sự thay thế Ienumerator cho một đối tƣợng. Bất kỳ cái gì bổ sung các giao tiếp Ienumerable và Ienumerator đều có thể đƣợc tính toán trên vòng lặp foreach. 1.2.6. Các phát biểu nhảy (Jumps) Các phát biểu nhảy trong trong C#: continue, break, goto, return. Các phát biểu này đƣợc trình bày vắn tắt nhƣ sau: thoát khỏi các vòng lặp hoặc trả dòng điều khiển cho một khối lệnh khác. Trong C# đều là các ngoại lệ run-time, trình biên dịch sẽ không giúp đỡ các lập trình viên giữ lại trạng thái của các ngoại lệ. Có sẵn một cách đi tắt nếu đối tƣợng ngoại lệ không cần thiết bằng việc sử dụng framework dƣới đây Try { // những lệnh có thể gây ra ngoại lệ } catch { // xử lý những ngoại lệ mà không cần nhận một bộ xử lý cho đối tượng ngoại lệ } Nhƣng nếu bạn cần bắt một ngoại lệ cụ thể (trong khi không yêu cầu đối tƣợng ngoại lệ), có thể dùng tƣơng tự nhƣ sau: Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 12
  13. try { } catch (IOException) { } 1.2.7. Các phƣơng thức (methods) public void methodCaller ( params int[] a ); Và phƣơng thức có thể đƣợc gọi bất kỳ methodCaller ( 1 ); method Caller ( 1, 2, 3, 4 ); Bên trong phƣơng thức, các tham số có thể đƣợc truy cập thông qua dãy “a” đã đƣợc định nghĩa. Máy tính có thể hiểu, kết quả đƣợc tìm thấy 1.2.8. Các thuộc tính (properties) Các thuộc tính là các khởi dựng của C# thƣờng đƣợc dùng với mô hình (pattern) getter/setter trong nhiều lớp của Java. private int property; public int Property () { get { return this.property; } set { // value là một biến được tạo ra bởi trình biên dịch để thay thế các tham số this.property = value; } } Có thể dễ dàng sử dụng bên trong một chƣơng trình C# int currentValue = Property; Property = new Value; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 13
  14. 1.2.9. Từ chỉ định truy cập (Accessbility Modifiers) Access modifier bao gồm: Public, protected, internal, protected internal, private. Các modifier trên có thể đƣợc áp dụng cho cùng các cấu trúc mà Java cho phép bạn sử dụng chúng. Bạn có thể thay đổi khả năng truy cập đến các đối tƣợng, các phƣơng thức và các biến. Chúng ta sẽ nói về chúng ngay dƣới đây, và chúng ta có thể nói về các đối tƣợng và kế thừa ở phần tiếp theo. 1.2.10. Các đối tƣợng, các lớp và các cấu trúc Kế thừa các lớp ta dùng “:” Ví dụ: class B : A {} nghĩa là lớp B kế thừa từ lớp A _Struct đƣợc truyền theo tham trị thay vì theo tham biến _Struct không thể kế thừa, tuy nhiên chúng có thể bổ sung các giao tiếp _Struct không thể đƣợc định nghĩa một khởi dựng (contructor) mà không có tham số _Struct định nghĩa các contructor với các tham số phải định nghĩa chính xác tất cả các field bởi vì nó sẽ trả về điều khiển cho phƣơng thức nào gọi nó 1.2.11. Chuyển đổi kiểu C# cho phép khả năng định nghĩa chuyển đổi kiểu tự tạo cho hai đối tƣợng bất kỳ. Hai kiểu chuyển đổi là: chuyển đổi tƣơng đối và chuyển đổi tuyệt đối 1.2.12. Tải chồng toán tử (Operator overloading) Tải chồng toán tử trong C# rất đơn giản. Lớp FlooredDouble có thể đƣợc thừa kế để chứa một phƣơng thức static public static FloorDouble operator + ( FloorDouble fd1, FloorDouble fd2 ) { return new FloorDouble( fd1.Value + fd2.Value ); } Và các phát biểu sau là đúng Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 14
  15. FloorDouble fd1 = new FloorDouble( 3.5 ); FloorDouble fd2 = new FloorDouble( 4 ); FloorDouble sum = fd1 + fd2; 1.2.13. Tổ chức lại mã nguồn C# không đặt bất kỳ yêu cầu nào trong việc tổ chức file – một lập trình viên có thể sắp xếp toàn bộ chƣơng trình C# bên trong một file .cs 1.2.14.Giao diện *Giống nhƣ class chỉ gồm toàn các hàm trừu tƣợng *Khi một class thiết đặt(implement) một giao diện thì phải thi công tất cả các hàm giao diện này. +Thiết đặt một giao diện. +Truy xuất các hàm giao diện. +Override một thiết đặt giao diện. +Dùng giao diện nhƣ thông số. +Thiết đặt kế thừa giao diện. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 15
  16. CHƢƠNG II NHẬN DẠNG CHỮ VIẾT TAY SỬ DỤNG HẠT NHÂN PHÂN TÍCH BIỆT THỨC 2.1. Phân tích biệt thức tuyến tính Phân tích biệt thức tuyến tính (Linear Discriminant Analysis (LDA)) là một phƣơng pháp đƣợc sử dụng trong thống kê và máy học để tìm một sự kết hợp tuyến tính của các tính năng đặc trƣng nhất hoặc chia tách hai hay nhiều lớp của đối tƣợng, sự kiện. Kết quả của sự kết hợp có thể đƣợc sử dụng nhƣ một bộ phân loại tuyến tính (linear classifier), hoặc thông thƣờng hơn đối với giảm đa chiều (dimensionality reduction) trƣớc khi phân loại cuối. Phân tích biệt thức tuyến tính liên quan chặt chẽ tới phân tích thành phần chủ yếu (Principal Component Analysis (PCA) ) trong trƣờng hợp cả hai tìm kiếm sự kết hợp tuyến tính của các biến miêu tả dữ liệu một cách tốt nhất. LDA đã nỗ lực để xây dựng lên sự khác biệt giữa các lớp dữ liệu, tăng tối đa tính đúng đắn của công thức sau: Trong đó: Tƣơng ứng là các Ma trận tán xạ lớp giữa (Between-Class Scatter Matrix) và Ma trận phân tán lớp trong (Within-Class Scatter Matrix). Giải pháp tối ƣu có -1 thể đƣợc tìm ra đƣợc bởi máy tính là Giá trị riêng (Eigen values) của SB SW và lấy Véctơ riêng ứng với giá riêng lớn nhất để định ra cơ sở mới cho dữ liệu. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 16
  17. 2.2. Nhân Phân tích biệt thức KDA là một mở rộng của LDA để trở thành phi tuyến tính phân tán, cũng giống nhƣ KPCA là PCA. Mục tiêu của KDA cũng là tìm sự biến đổi phƣơng sai lớp giữa cực đại và phƣơng sai lớp trong cực tiểu. Điều đó cho thấy rằng, với nhân, công thức gốc cuối cùng đƣợc biểu diễn nhƣ sau: Trong đó: Với K c là ma trận nhân cho lớp c; u c là cột biểu diễn vecto K c, I là ma trận nhận dạng; l c là số mẫu trong lớp c ; 1 lc là ma trận (l c xl c) với tất cả phần tử 1 / l c (nghĩa là I - 1 / l c là trung ma trận của kích thƣớc Ic). 2.3. Chức năng nhân trick và nhân chuẩn. Nhâ ích và mạnh mẽ. Mạnh mẽ bởi vì nó cung cấp một cầu nối từ tuyến tính đến phi tuyến tính cho bất kỳ thuật toán mà chỉ phụ thuộc vào giao điểm (dot product ) giữa hai vectơ. Nó đến từ thực tế là, nếu đầu tiên chúng ta xây dựng bản đồ dữ liệu đầu vào vào một không gian chiều vô hạn, một thuật toán tuyến tính sẽ hoạt động trong không gian này sẽ xử lý phi tuyến tính trong không gian ban đầu. Bây giờ, các nhân trick thực sự hữu ích bởi vì nó lập bản đồ không bao giờ cần phải đƣợc tính toán. Nếu thuật toán của chúng ta chỉ có thể đƣợc thể hiện với điều kiện trong miền giữa hai vectơ thì tất cả điều chúng ta cần là thay thế tích trong này với tích trong khác từ một số không gian thích hợp khác. Đó là nơi chứa "trick": bất cứ nơi nào một giao điểm đƣợc sử dụng thì nó đƣợc thay thế bằng một hàm nhân. Hàm nhân biểu thị một tích trong vùng đặc trƣng và thƣờng đƣợc ký hiệu là: Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 17
  18. K(x,y) = K (x, y) = Sử dụng hàm nhân, thuật toán sau đó có thể đƣợc áp dụng vào một không gian nhiều chiều hơn kích thƣớc mà không lập bản đồ một cách rõ ràng các điểm đầu vào không gian này. Một số hàm nhân thông dụng bao gồm các nhân tuyến tính, nhân đa thức, nhân Gaussian. Dƣới đây là danh sách lƣợc các nhân với đặc điểm thú vị nhất. Nhân tuyến tính là hàm nhân đơn giản nhất. Nó đƣợc đƣa ra bởi các tích trong Nhân cộng với một hằng số c tùy chọn. tuyến Thuật toán nhân sử dụng một nhân tuyến tính tính thƣờng tƣơng đƣơng với các nhân phi tuyến, tức là KPCA với nhân tuyến tính tƣơng đƣơng chuẩn PCA. Nhân đa thức là một nhân không tĩnh. Nhân đa Nó rất thích hợp cho các vấn đề tất cả dữ thức liệu là bình thƣờng. Nhân Gaussian là một trong rất nhiều những nhân linh hoạt nhất. Đây là một Nhân hàm nhân cơ sở dạng tia và là nhân đƣợc Gaussian ƣa thích khi chúng ta không biết nhiều về cấu trúc của dữ liệu chúng ta đang cố gắng xây dựng mô hình. 2.4. Mô hình các lớp đƣợc sử dụng trong KDA Các mã nguồn có trong bài này chỉ chứa các tập con của mảng cần thiết cho KDA. Các lớp cũng đƣợc hiển thị trong hình dƣới đây. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 18
  19. Các lớp KDA kế thừa từ Phân tích biệt thức tuyến tính, mở rộng thuật toán cốt lõi của nó với nhân. Nguồn bao gồm hơn 20 nhân để lựa chọn, mặc dù nhân Gaussian sẽ là thích hợp nhất trong hầu hết các ứng dụng. 2.5. Nhận dạng chữ số 2.5.1. Dữ liệu số của UCI Các kho dữ liệu Máy Học UCI (UCI Machine Learning Repository) là tập hợp các cơ sở dữ liệu, lý thuyết miền, và máy xây dựng dữ liệu đƣợc sử dụng bởi các máy học tập cộng đồng cho việc phân tích thực nghiệm của các thuật toán học máy. Một trong những kho dữ liệu có sẵn là Nhận dạng chữ số viết tay. Trong dữ liệu chữ số, chữ số đƣợc biểu diễn là các ma trận 32x32. Chúng cũng có sẵn trong một hình thức tiền xử lý, trong đó chữ số đã đƣợc chia thành các khối không chồng khớp nhau 4x4 và số lƣợng các điểm ảnh trên đã đƣợc tính trong mỗi khối, tạo ra ma trận đầu vào 8x8 mà mỗi phần tử là một số nguyên trong khoảng 0 16. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 19
  20. Đa chiều giảm là một bƣớc rất cần thiết nếu chúng ta sẽ sử dụng phân lớp đƣợc tạo bởi Con trỏ của đa chiều (Curse of Dimensionality). Phƣơng pháp trong việc xử lý các vấn đề về đa chiều lớn bởi vì chúng không bị giới hạn. Mẫu chữ số được lấy ra từ kho số liệu chữ số thô. Phƣơng pháp nhân đƣợc sử dụng nhiều vì chúng có thể đƣợc áp dụng trực tiếp cho các vấn đề yêu cầu suy nghĩ kỹ càng dựa trên dữ liệu tiền xử lý và kiến thức rộng về cấu trúc của dữ liệu đang đƣợc mô hình hóa. Thậm chí nếu chúng ta biết rất ít về các dữ liệu, một ứng dụng của phƣơng pháp nhân mù thƣờng thấy kết quả khá đúng. Đạt đƣợc tối ƣu hóa bằng cách sử dụng các phƣơng pháp nhân có thể đƣơc, tuy nhiên, rất khó vì chúng ta có một sự lựa chọn vô hạn các hàm nhân và với mỗi hàm nhân có một không gian vô hạn để tinh chỉnh thông số. Các mã nguồn sau cho ta thấy một ví dụ cụ thể về KDA. Lƣu ý xử lý thế nào với đầu vào là các véc tơ đầy đủ cho 1024 vị trí. Điều này sẽ là không thực tế nếu chúng ta sẽ sử dụng Neural Networks, ví dụ: / / Giải nén đầu vào và đầu ra int samples = 500 ; double [,] input = new double [samples, 1024 ]; int [] output = new int [samples]; / / Tạo các lựa chọn nhân với các thông số đã cho Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 20
  21. IKernel kernel = new Gaussian(( double )numSigma.Value); / / Tạo các nhân phân tích biệt thức bằng cách sử dụng các nhân được lựa chọn kda = new KernelDiscriminantAnalysis(input, output, kernel); / / Thiết lập các ngưỡng tỷ lệ tối thiểu để giữ cho các thành phần trong phân tích kda.Threshold = ( double )numThreshold.Value; / / Thiết lập các qui chuẩn so sánh để tránh giải pháp đơn lẻ kda.Regularization = ( double )numRegularization.Value; / / Tính toán phân tích. kda.Compute(); / / Hiển thị thông tin về các dạng phân tích / / (Hầu hết các thuộc tính có thể đƣợc databound trực để điều khiển trực quan) dgvPrincipalComponents.DataSource = kda.Discriminants; dgvFeatureVectors.DataSource = new ArrayDataView(kda.DiscriminantMatrix); dgvClasses.DataSource = kda.Classes; 2.5.2 Phân lớp các chữ số số bằng KDA. Nhƣ đã đề cập trƣớc đó, Nhân Phân tích biệt thức không bị làm xấu đi sau khi áp dụng đa chiều. Điều này có nghĩa nó có thể đƣợc áp dụng cho các tập dữ liệu số nguyên 32x32 mà không cần bất kỳ loại tiền xử lý. Việc xử lý chỉ cần thiết sẽ là chuyển vị của ma trận 32x32 vào vector độ dài 1024. Tuy nhiên, KDA không phải là một phƣơng pháp rất hiệu quả, và nó cũng không phải là phƣơng pháp phù hợp đối với một tập dữ liệu lớn. Cho dù có sự gia tăng kích thƣớc song nó vẫn ít ảnh hƣởng (thậm chí là không ảnh hƣởng) tới thời gian phân tích, độ phức tạp KDA là O (n ³) với số lƣợng mẫu. Bên cạnh đó, các giải pháp của nó không ít ỏi nhƣ là trƣờng hợp với hỗ trợ Vector Machines (SVMs). Điều này có nghĩa một số lƣợng đáng kể không gian bộ nhớ sẽ đƣợc sử dụng để chứa các Ma trận nhân đầy đủ trong quá trình phân loại. Việc phân lớp sử dụng KDA thƣờng đƣợc thực hiện bằng cách xem xét khoảng cách tối thiểu giữa một dữ liệu điểm dự kiến tới không gian đặc trƣng và các lớp chỉ xét trong không gian đặc trƣng. Chúng ta có thể nhìn thấy mục tiêu đằng sau phƣơng pháp này trong ví dụ sau đây. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 21
  22. Ví dụ vấn đề phân lớp Yin Yang. Hình ảnh bên trái cho thấy hình ảnh ban đầu trong không gian đầu vào, hình ảnh bên trái cho thấy kết quả một nhân Phân tích biệt thức biểu diễn bởi một nhân Gaussian với sigma thiết lập nhƣ là 1,0. Các dấu chấm màu đỏ trong hình ảnh bên phải đánh dấu phép chiếu của dấu chấm màu đỏ của hình ảnh trái. Chú ý dấu chấm là gần với lớp màu xanh trong cả hai hình ảnh. Tuy nhiên trong phân tích không gian đặc trƣng, các lớp đã đƣợc trải ra thành nhiều tuyến tính. Trong t p này, khoảng cách Euclide (hoặc tƣơng đƣơng khoảng cách Malahanobis) đến lớp giá trị trung bình trong không gian đặc trƣng sẽ trở thành một các lớp gần. Các mã sau đây chứng minh việc phân lớp của các trƣờng hợp mới sử dụng một nhân đã đƣợc tính toán phân tích biệt thức. // Lấy các vector đầu vào double [] input = canvas.GetDigit(); // Phân loại các vector đầu vào int num = kda.Classify(input); // Thiết lập câu trả lời phân loại thực tế lbClassification.Text = num.ToString(); Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 22
  23. CHƢƠNG III CHƢƠNG TRÌNH THỬ NGHIỆM 3.1. Kiểm tra ứng dụng 3.1.1 Phân tích Việc thử nghiệm đi kèm với mã nguồn nhận dạng các chữ số viết tay bằng cách sử dụng KDA. Đầu tiên, chúng ta sẽ chạy ứng dụng, tốt nhất là chạy chƣơng trình không thông qua Visual Studio 2008. Nhắp chuột vào menu Tệp và chọn Mở. Thao tác sẽ tải một số mục từ kho dữ liệu chữ số vào ứng dụng. Dữ liệu chữ số đƣợc tải vào ứng dụng Bên phải: Chi tiết thông tin về các lớp riêng biệt của các chữ số viết tay. Để thực hiện việc phân tích, nhấp vào nút PHÂN TÍCH. Quá trình phân tích đƣợc thực hiện, sau khi phân tích xong, các tab khác trong việc ứng dụng mẫu sẽ đƣợc đƣa ra thông tin phân tích. Mức độ quan trọng của mỗi yếu tố đƣợc Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 23
  24. đƣa ra trong phân tích biệt thức đƣợc biểu diễn trong một đồ thị hình tròn để kiểm tra dễ dàng. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 24
  25. Các yếu tố đƣợc tìm thấy trong Phân tích biệt thức và mối liên quan tầm quan trọng của chúng. Từ không gian đầu vào kích thƣớc ban đầu kích thƣớc 1024, chỉ có 9 là quan trong để đƣợc chọn cho việc phân lớp. Sau khi phân tích xong, chúng ta có thể thử nghiệm khả năng phân lớp của nó trong việc kiểm tra kho dữ liệu. Các hàng cây xanh đã đƣợc xác định chính xác bởi khoảng cách biệt thức phân loại không gian Euclide. Chúng ta có thể nhìn thấy nó nhận dạng chính xác 92% các dữ liệu thử nghiệm. Các thử nghiệm dữ liệu đào tạo đƣợc phân chia và độc lập. Sử dụng các giá trị mặc định trong ứng dụng đạt đƣợc độ chính xác 92%. 3.1.2 Kết quả Sau khi phân tích đã đƣợc hoàn thành và xác nhận, chúng ta có thể sử dụng để trực tiếp trong ứng dụng. Các biểu đồ cột trên bên phải thể hiện kết quả tƣơng đối cho từng công Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 25
  26. thức biệt thức. Mỗi lớp có một công thức biệt thức rằng kết quả đầu ra một phƣơng pháp gần nhất cho mỗi điểm đầu vào. Việc phân loại này dựa trên công thức để đầu ra là tối đa. Nhận dạng số 1 Nhận dạng số 7 Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 26
  27. Nhận dạng số 8 Nhận dạng số 9 Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 27
  28. 3.2 Mã lệnh trong chƣơng trình viết cho một số các class 3.2.1 Class Linear Discrimnant Analysis using System; using System.Collections.ObjectModel; using System.Linq; using Accord.Math; using Accord.Math.Decompositions; namespace Accord.Statistics.Analysis { public class LinearDiscriminantAnalysis { private int dimension; private int samples; private int classes; private double[] totalMeans; private double[] totalStdDevs; private int[] classCount; private double[][] classMeans; private double[][] classStdDevs; private double[][,] classScatter; private double[][] classMeansTransformed; private double[,] eigenVectors; private double[] eigenValues; private double[] bias; private double[,] result; private double[,] source; private int[] outputs; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 28
  29. double[,] Sw, Sb, St; // Scatter matrices private double[] discriminantProportions; private double[] discriminantCumulative; DiscriminantCollection discriminantCollection; DiscriminantAnalysisClassCollection classCollection; // # Phần kiến tạo public LinearDiscriminantAnalysis(double[,] inputs, int[] output) { // Lấy số từ các class int startingClass = output.Min(); this.classes = output.Max() - startingClass + 1; // Lƣu trữ các dữ liệu gốc this.source = inputs; this.outputs = output; this.samples = inputs.GetLength(0); this.dimension = inputs.GetLength(1); // Tạo các cấu trúc đơn để lƣu thong tin về sau this.classCount = new int[classes]; this.classMeans = new double[classes][]; this.classStdDevs = new double[classes][]; this.classScatter = new double[classes][,]; // Tạo cấu trúc hƣớng đối tƣợng để giữ các thong tin về class DiscriminantAnalysisClass[] collection = new DiscriminantAnalysisClass[classes]; for (int i = 0; i < classes; i++) collection[i] = new DiscriminantAnalysisClass(this, i, startingClass + i); Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 29
  30. this.classCollection = new DiscriminantAnalysisClassCollection(collection); } # kết thúc phần // # Phần thuộc tính /// Quay lại nguồn dữ lieu cung cấp ban đầu để phân tích public double[,] Source { get { return this.source; } } public double[,] Result { get { return this.result; } } public int[] Classifications { get { return this.outputs; } } /// Lấy giá trị trung bình của dữ liệu nguồn để đƣa phƣớng án public double[] Means { get { return totalMeans; } protected set { totalMeans = value; } } /// Lấy trung bình tiêu chuẩn của các dữ liệu ban đầu cho phƣơng pháp public double[] StandardDeviations { get { return totalStdDevs; } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 30
  31. protected set { totalStdDevs = value; } } /// sử dụng ma trận lớp trong cho dữ liệu public double[,] ScatterWithinClass { get { return Sw; } protected set { Sw = value; } } /// sử dụng ma trận lớp giữa cho dữ liệu public double[,] ScatterBetweenClass { get { return Sb; } protected set { Sb = value; } } /// Lấy tổng ma trận lớp cho dữ liệu public double[,] ScatterMatrix { get { return St; } protected set { St = value; } } public double[,] DiscriminantMatrix { get { return eigenVectors; } protected set { eigenVectors = value; } } public double[] Eigenvalues { get { return eigenValues; } protected set { eigenValues = value; } } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 31
  32. /// Sử dụng các lớp trong mỗi biệt thức /// trong không gian biệt thức public double[] Proportions { get { return discriminantProportions; } } public double[] CumulativeProportions { get { return discriminantCumulative; } } public DiscriminantCollection Discriminants { get { return discriminantCollection; } } public DiscriminantAnalysisClassCollection Classes { get { return classCollection; } } public double[][,] ClassScatter { get { return classScatter; } } public double[][] ClassMeans { get { return classMeans; } } public double[][] ClassStandardDeviations Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 32
  33. { get { return classStdDevs; } } public int[] ClassCount { get { return classCount; } } # Kết thúc phần // # Phần khai báo phƣơng thức public virtual void Compute() { // Tính toán toàn bộ dữ liệu thiết lập các biện pháp Means = Tools.Mean(source); StandardDeviations = Tools.StandardDeviation(source, totalMeans); double total = dimension; // Khởi tạo các ma trận tán xạ this.Sw = new double[dimension, dimension]; this.Sb = new double[dimension, dimension]; // Cho mỗi lớp for (int c = 0; c < Classes.Count; c++) { // Lấy các lớp con double[,] subset = Classes[c].Subset; int count = subset.GetLength(0); // Lấy lớp trung bình double[] mean = Tools.Mean(subset); Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 33
  34. // Tiếp tục xây dựng Ma trận tán xạ lớp trong double[,] Swi = Tools.Scatter(subset, mean, (double)count); // Sw = Sw + Swi for (int i = 0; i < dimension; i++) for (int j = 0; j < dimension; j++) Sw[i, j] += Swi[i, j]; // Tiếp tục xây dựng Ma trận tán xạ lớp giữa double[] d = mean.Subtract(totalMeans); double[,] Sbi = d.Multiply(d.Transpose()).Multiply(total); // Sb = Sb + Sbi for (int i = 0; i < dimension; i++) for (int j = 0; j < dimension; j++) Sb[i, j] += Sbi[i, j]; // Lƣu các thông tin đƣợc thêm this.classScatter[c] = Swi; this.classCount[c] = count; this.classMeans[c] = mean; this.classStdDevs[c] = Tools.StandardDeviation(subset, mean); } // Tính tóan sự phân ly của giá trị riêng EigenvalueDecomposition evd = new EigenvalueDecomposition(Matrix.Inverse(Sw).Multiply(Sb)); // Lấy các giá trị riêng, tƣơng ứng với các vecto riêng double[] evals = evd.RealEigenvalues; double[,] eigs = evd.Eigenvectors; // Sắp xếp các giá treiSort eigen values and vectors in ascending order Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 34
  35. eigs = Matrix.Sort(evals, eigs, new GeneralComparer(ComparerDirection.Descending, true)); // Lƣu trữ thông tin this.Eigenvalues = evals; this.DiscriminantMatrix = eigs; // Tạo hàm biệt thức độ xiên bias = new double[classes]; for (int i = 0; i < classes; i++) { bias[i] = (-0.5).Multiply(classMeans[i]).Multiply( eigs.Multiply(classMeans[i])) + System.Math.Log(classCount[i] / total); } // Taọ các phép chiếu this.result = new double[dimension, dimension]; for (int i = 0; i < dimension; i++) for (int j = 0; j < dimension; j++) for (int k = 0; k < dimension; k++) result[i, j] += source[i, k] * eigenVectors[k, j]; createDiscriminants(); } public double[,] Transform(double[,] data) { return Transform(data, discriminantCollection.Count); } public virtual double[,] Transform(double[,] data, int discriminants) { int rows = data.GetLength(0); int cols = data.GetLength(1); double[,] r = new double[rows, discriminants]; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 35
  36. // Cộng dữ liệu ma trận bằng cách chọn các véctơ riêng for (int i = 0; i 1.0) throw new ArgumentException("Threshold should be a value between 0 and 1", "threshold"); for (int i = 0; i = threshold) return i + 1; } return discriminantCumulative.Length; } public int Classify(double[] input) { double[] projection = Transform(input); Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 36
  37. // Chọn lớp với hàm biệt thức cao hơn int imax = 0; double max = discriminantFunction(0, projection); for (int i = 1; i max) { max = fy; imax = i; } } return classCollection[imax].Number; } public int Classify(double[] input, out double[] responses) { double[] projection = Transform(input); responses = new double[classCollection.Count]; int imax = 0; double max = discriminantFunction(0, projection); responses[0] = max; for (int i = 1; i max) { max = fy; imax = i; } } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 37
  38. return classCollection[imax].Number; } public int[] Classify(double[][] inputs) { int[] output = new int[inputs.Length]; for (int i = 0; i < inputs.Length; i++) output[i] = Classify(inputs[i]); return output; } internal virtual double discriminantFunction(int c, double[] projection) { return classMeans[c].Multiply(projection) + bias[c]; } # Kết thúc phần // # Phần bảo vệ phƣơng thức protected void createDiscriminants() { int numDiscriminants = eigenValues.Length; discriminantProportions = new double[numDiscriminants]; discriminantCumulative = new double[numDiscriminants]; // Tính toán tổng ma trận phân tán int size = Sw.GetLength(0); St = new double[size, size]; for (int i = 0; i < size; i++) for (int j = 0; j < size; j++) St[i, j] = Sw[i, j] + Sb[i, j]; // Tính toán tỉ lệ double sum = 0.0; for (int i = 0; i < numDiscriminants; i++) Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 38
  39. sum += System.Math.Abs(eigenValues[i]); sum = (sum == 0) ? 0 : (1.0 / sum); for (int i = 0; i < numDiscriminants; i++) discriminantProportions[i] = System.Math.Abs(eigenValues[i]) * sum; // Tính toán tỉ lệ dồn lại this.discriminantCumulative[0] = this.discriminantProportions[0]; for (int i = 1; i < this.discriminantCumulative.Length; i++) this.discriminantCumulative[i] = this.discriminantCumulative[i - 1] + this.discriminantProportions[i]; // Taọ cấu trúc hƣớng đối tƣợng để giữ biệt thức tuyến tính Discriminant[] discriminants = new Discriminant[numDiscriminants]; for (int i = 0; i < numDiscriminants; i++) discriminants[i] = new Discriminant(this, i); this.discriminantCollection = new DiscriminantCollection(discriminants); } #Kết thúc phần } # Phần hỗ trợ các lớp public class DiscriminantAnalysisClass { private LinearDiscriminantAnalysis analysis; private int classNumber; private int index; internal DiscriminantAnalysisClass(LinearDiscriminantAnalysis analysis, int index, int classNumber) { this.analysis = analysis; this.index = index; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 39
  40. this.classNumber = classNumber; } public int Index { get { return index; } } public int Number { get { return classNumber; } } public double Prevalence { get { return (double)Count / analysis.Source.GetLength(0); } } /// Lấy lớp vecto trung bình public double[] Mean { get { return analysis.ClassMeans[index]; } } /// Lấy lớp vec tơ độ lệch quần phƣơng public double[] StandardDeviation { get { return analysis.ClassStandardDeviations[index]; } } /// Lấy ma trận phân tán cho lớp này public double[,] Scatter { get { return analysis.ClassScatter[index]; } } public int[] Indexes { Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 40
  41. get { return Matrix.Find(analysis.Classifications, y => y == classNumber); } } public double[,] Subset { get { return analysis.Source.Submatrix(Indexes); } } public int Count { get { return analysis.ClassCount[index]; } } /// Hàm biệt thức cho lớp public double DiscriminantFunction(double[] projection) { //return Mean.Multiply(projection) + Bias[index]; return analysis.discriminantFunction(index, projection); } } public class Discriminant { private LinearDiscriminantAnalysis analysis; private int index; internal Discriminant(LinearDiscriminantAnalysis analysis, int index) { this.analysis = analysis; this.index = index; } public int Index { get { return index; } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 41
  42. } public double[] Eigenvector { get { return analysis.DiscriminantMatrix.GetColumn(index); } } public double Eigenvalue { get { return analysis.Eigenvalues[index]; } } public double Proportion { get { return analysis.Proportions[index]; } } public double CumulativeProportion { get { return analysis.CumulativeProportions[index]; } } } public class DiscriminantCollection : ReadOnlyCollection { internal DiscriminantCollection(Discriminant[] components) : base(components) { } } public class DiscriminantAnalysisClassCollection : ReadOnlyCollection { internal DiscriminantAnalysisClassCollection(DiscriminantAnalysisClass[] components) : base(components) { } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 42
  43. } # Kết thúc phần } 3.2.2 Kernel Discrimnant Analysis using Accord.Math; using Accord.Math.Decompositions; using Accord.Statistics.Kernels; using System.Collections.Generic; namespace Accord.Statistics.Analysis { public class KernelDiscriminantAnalysis : LinearDiscriminantAnalysis { private IKernel kernel; private double regularization = 0.0001; private double threshold = 0.001; private double[][] kernelClassMeans; // # Phần kiến thiết tạo public KernelDiscriminantAnalysis(double[,] inputs, int[] output, IKernel kernel) : base(inputs, output) { this.kernel = kernel; this.kernelClassMeans = new double[Classes.Count][]; } # Kết thúc phần Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 43
  44. // # Phần khai báo thuộc tính public IKernel Kernel { get { return kernel; } } public double Regularization { get { return regularization; } set { regularization = value; } } public double Threshold { get { return threshold; } set { threshold = value; } } # Kết thúc phần // # Phần khai báo Phƣơng thức /// Tính toán thuật toán KDA nhiều lớp public override void Compute() { // Lấy mốt số thông tin ban đầu int dimension = Source.GetLength(0); double[,] source = Source; double total = dimension; // Tạo ma trận Gram (Kernel) double[,] K = new double[dimension, dimension]; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 44
  45. for (int i = 0; i < dimension; i++) { for (int j = i; j < dimension; j++) { double s = kernel.Function(source.GetRow(i), source.GetRow(j)); K[i, j] = s; K[j, i] = s; } } // Tính toán toàn bộ dữ liệu base.Means = Tools.Mean(K); base.StandardDeviations = Tools.StandardDeviation(K, Means); // Gán giá trị ban đầu cho ma trận phân tán tƣơng tự nhân double[,] Sb = new double[dimension, dimension]; double[,] Sw = new double[dimension, dimension]; // Cho mỗi lớp for (int c = 0; c < Classes.Count; c++) { // Lấy lớp con ma trận nhân double[,] Kc = K.Submatrix(Classes[c].Indexes); int count = Kc.GetLength(0); // Lấy trung bình lớp ma trận Nhân double[] mean = Tools.Mean(Kc); // Đặt ma trận tƣơng đƣơng của ma trận phân tán lớp trong double[,] Swi = Tools.Scatter(Kc, mean, (double)count); // Sw = Sw + Swi for (int i = 0; i < dimension; i++) for (int j = 0; j < dimension; j++) Sw[i, j] += Swi[i, j]; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 45
  46. // Đặt ma trận tƣơng đƣơng của ma trận phân tán lớp giữa double[] d = mean.Subtract(base.Means); double[,] Sbi = d.Multiply(d.Transpose()).Multiply(total); // Sb = Sb + Sbi for (int i = 0; i < dimension; i++) for (int j = 0; j < dimension; j++) Sb[i, j] += Sbi[i, j]; // Lƣu trữ dữ liệu thêm vào base.ClassScatter[c] = Swi; base.ClassCount[c] = count; base.ClassMeans[c] = mean; base.ClassStandardDeviations[c] = Tools.StandardDeviation(Kc, mean); } // Thêm quy tắc for (int i = 0; i < dimension; i++) Sw[i, i] += regularization; // Phân tích sự phân tán của giá trị riêng double[,] C = Matrix.Inverse(Sw).Multiply(Sb); EigenvalueDecomposition evd = new EigenvalueDecomposition(C); // Lấy giá trị riêng và tƣơng ứng với vecsto riêng double[] evals = evd.RealEigenvalues; double[,] eigs = evd.Eigenvectors; // Sắp xếp giá trị riêng và vecto riêng theo giá trị tăng dần eigs = Matrix.Sort(evals, eigs, new GeneralComparer(ComparerDirection.Descending, true)); Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 46
  47. if (threshold > 0) { // Calculate proportions earlier double sum = 0.0; for (int i = 0; i 0) { sum = 1.0 / sum; // Không lƣu những thông tin không quan trọng int keep = 0; while (keep threshold) keep++; eigs = eigs.Submatrix(0, dimension - 1, 0, keep - 1); evals = evals.Submatrix(0, keep - 1); } } // Lƣu trữ thông tin base.Eigenvalues = evals; base.DiscriminantMatrix = eigs; base.ScatterBetweenClass = Sb; base.ScatterWithinClass = Sw; // Tính toán khoảng trống cho việc phân lớp cuối cùng for (int c = 0; c < Classes.Count; c++) { double[] mean = new double[eigs.GetLength(1)]; for (int i = 0; i < eigs.GetLength(0); i++) for (int j = 0; j < eigs.GetLength(1); j++) mean[j] += ClassMeans[c][i] * eigs[i, j]; kernelClassMeans[c] = mean; Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 47
  48. } // Tính toán các thông tin đƣợc thêm về việc phân tích và tạo // cấu trúc hƣớng đối tƣợng để giữ các biệt thức tìm thấy createDiscriminants(); } public override double[,] Transform(double[,] data, int discriminants) { // Lấy một vài thông tin int rows = data.GetLength(0); int cols = data.GetLength(1); int N = Source.GetLength(0); // Tạo ma trận nhân double[,] K = new double[rows, N]; for (int i = 0; i < rows; i++) for (int j = 0; j < N; j++) K[i, j] = kernel.Function(Source.GetRow(j), data.GetRow(i)); // Xem xét khoảng trống biệt thức nhân double[,] result = new double[rows, discriminants]; for (int i = 0; i < rows; i++) for (int j = 0; j < discriminants; j++) for (int k = 0; k < N; k++) result[i, j] += K[i, k] * DiscriminantMatrix[k, j]; return result; } internal override double discriminantFunction(int i, double[] projection) { return -Distance.SquareEuclidean(projection, kernelClassMeans[i]); } # Kết thúc } } Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 48
  49. KẾT LUẬN tìm hiểu ng KDA . Tuy nhiên KDA gặp một số hạn chế: không hỗ trợ Vector Machines (SVMs), giải pháp của nó không trải đều. Quy mô không mở rộng với kích thƣớc mẫu đầu vào là O (n ³) mặc dù đã xử lý đƣợc vấn đề đƣa kích thƣớc lớn vào vecto. Dù vậy, KDA có một lợi thế, đó là tổng quát cho trƣờng hợp đa lớp. Sự lựa chọn phù hợp các chức năng nhân (và điều chỉnh các thông số của nó), chi phí hoạt động tốn kém, cả về năng lƣợng xử lý và dữ liệu đào tạo sẵn có. Hiệu quả bởi bất kỳ giải pháp nào tìm ra cũng sẽ là giải pháp tốt nhất có thể cho các giá trị tham số đƣợc học Neural Networks, trong đó ngƣời ta phải thử rất nhiều điểm đầu khác nhau và nhiều trƣờng hợp thử nghiệm để đảm bảo kết quả nhất quán) . Xây dựng bộ cài đặt và chƣơng trình riêng độc lập. : Sau khi đồ án đƣợc hoàn thành, chƣơng trình sẽ đƣợc bổ xung thêm các chức năng trong việc nhận dạng chữ cái latinh, chữ cái tiếng Việt, phù hợp hơn so với việc chỉ nhận dạng chữ số nhƣ trong phần nêu trên. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 49
  50. TÀI LIỆU THAM KHẢO Tài liệu tham khảo tiếng Việt [1.] PGS.TS , , , [2.] TS. Đỗ Năng Toàn, TS. Phạm Việt Bình, Giáo trình Xử lý ảnh [3.] Đinh Mạnh Tƣờng(2002), Trí tuệ nhân tạo, NXB Khoa học và Kỹ thuật [4.] Nguyễn Hữu Tình, Lê Tấn Hùng, Phạm Ngọc Yến, Nguyễn Lan Hƣơng(1999), Cơ sở và ứng dụng Matlab, NXB Khoa học và Kỹ thuật. [5.] Trịnh Thế Tiến. Nguyễn Minh, Các Cơ Sở Dữ Liệu Microsoft Visual C# 2008 - Lập Trình Căn Bản Và Nâng Cao, NXB Hồng Đức [6.] Lƣơng Mạnh Bá, Nguyễn Thanh Thủy, Nhập Môn Xử Lý Ảnh Số (Xuất Bản Lần Thứ 4 Có Chỉnh Lý Bổ Sung), NXB KHKT Tài liệu tham khảo tiếng Anh [7.] Oh S.H., Lee Yj(1995), A modified error function to improve the error Back-Propagation algorithm for Multi-layer perceptrons, ETRI Journal Vol 17, No 1. [8.] Ooyen A. V., Nienhuis B(1992), Improving the Convergence of the Back- Propagation algorithm, Neural networks, Vol. 5, pp.465-471. [9.] T. masters(1993), Practical neural network Recipes in C++, Academic Press, Inc. [10.] Tom M. Mitchell(1997), Machine learning, The McGraw-Hill Companies, Inc. Sinh viên Phạm Đức Hải – Lớp CTL201 – Trường ĐH DL Hải Phòng Trang 50