Mạng thần kinh nhân tạo cho phân lớp màu sắc part 3 doc

277
return;
}
else if(dx==0)
{
if(y1>y2)
{
y_end=y1;
y=y2;
}
else
y_end=y2 ;
y=y1;
}
while(y<=y_end)
{
set_pixel(x1,y,color);
y++;
}
return;
}
else
{
if(dy<=dx)
{
if(x1>x2)
{
x_end=x1;
y_end=y1;
x=x2; y=y2;
}

else
{
x=x1; y=y1;
x_end=x2;
y_end=y2;
}
if(y_end>y) ind=1;
else ind=0;
p=2*dy-dx;
const1=2*dy;
278
const2=2*(dy-dx);
set_pixel(x,y,color);
while((x < x_end))
{
x++;
if(p<0) p+=const1;
else
{
if(ind) y++;
else y ;
p+=const2;
}
set_pixel(x,y,color);
}
set_pixel(x,y,color);
}
else
{
if(y1>y2)

{
x_end=x1;
y_end=y1;
x=x2; y=y2;
}
else
{
x_end=x2;
y_end=y2;
x=x1; y=y1;
}

if(x_end>x) ind=1;
else ind=0;
p=2*dx-dy ;
const1=2*dx;
const2=2*(dx-dy);
set_pixel(x,y,color);
while((y < y_end))
{
y++;
279
if(p<0) p+=const1;
else
{
if(ind) x++:
else x ;
p+=const2;
}
set_pixel(x,y,color);

}
set_pixel(x,y,color);
}
}
}
/* Routine to draw a circle of any color given the
radius,
land cent re. It uses Bresenham's algorithm for
circle drawing . */

void draw_circle(int x_centre, int y_centre,
int radius,int color)
{
int p,x,y;
x=0;
y=radius;
p=3-2*radius;
while(x<y)
{
set_pixel(x_centre+x,y_centre+y,color);
set_pixel(x_centre-x,y_centre+y,color);
set_pixel(x_centre+x,y_centre-y,color);
set_pixel(x_centre-x,y_centre-y,color);
set_pixel(x_centre+y,y_centre+x,color);
set_pixel(x_centre-y,y_centre+x,color);
set_pixel(x_centre+y,y_centre-x,color);
set_pixel(x_centre-y,y_centre-x,color);

if(p<0)
p+=4*x+6;

else
{
280
p+=4*(x-y)+10;
y ;
}
x++;
}
if (x==y)
{
set_pixel(x_centre+x,y_centre+y,color);
set_pixel(x_centre-x,y_centre+y,color);
set_pixel(x_centre+x,y_centre-y,color);
set_pixel(x_centre-x,y_centre-y,color);
set_pixel(x_centre+y,y_centre+x,color);
set_pixel(x_centre-y,y_centre+x,color);
set_pixel(x_centre+y,y_centre-x,color);
set_pixel(x_centre-y,y_centre-x,color);
}
}
/* Routine to set a pixel on the VGA screen
to any of the standard colors.*/
void set_pixel(int x,int y, int color)
{
union REGS reg;

reg.h.ah=0x0c;
reg.h.al=color;
reg.h.bh=0;
reg.x.cx=x;

reg.x.dx=y:
int86(0x10,&reg,&reg);
}

/* Routine to turn on cursor mouse on the VGA
screen. */

void mouse_cursor_on(void)
{
union REGS reg;
reg.x.ax=0x01;
int86(0x33,&reg,&reg);
}
281

/* Routine to turn off cursor mouse on the VGA
screen.*/

void mouse_cursor_off(void)
{
union REGS reg;

reg.x.ax=0x02;
int86(0x33,&reg,&reg);
}

/* Routine to read mouse row and column location.
It also provides mouse button status.*/

void read_mouse( int *row, int *col, int *button )

{
union REGS reg:

reg.x.ax=0x03;
int86(0x33,&reg,&reg);
*button=reg.x.bx;
*col=reg.x.cx;
*row=reg.x.dx;
}

/* Routine to set vertical range for mouse. */

void mouse_vrange(int min, int max)
{
union REGS reg;
reg.x.ax=0x08;
reg.x.cx=min;
reg.x.dx=max;
int86(0x33,&reg,&reg);
}

/* Routine to set horizontal range for mouse. */

void mouse_hrange(int min, int max)
282
{
union REGS reg;

reg.x.ax=0x07;
reg.x.cx=min;

reg.x.dx=max;
int86(0x33,&reg,&reg);
}

/* Routine to move mouse cursor to a specified
location. */

void set_mouse(int row, int col)
{
union REGS reg;

reg.x.ax=0x04;
reg.x.cx=col;
reg.x.dx=row;
int86(0x33,&reg,&reg);
}

/* Routine to draw the chromaticity diagram on the
VGA screen. */

#define xxp(x) (int)((x)*400.0+200.0)
#define yyp(y) (int)(400.0-(y)*250.0)

float xx[]={ 0.7347, 0.2757, 0.1661 };
float yy[]={ 0.2653, 0.7147, 0.0094 };


struct coord
{
float xc;

float yc;
};

struct coord p[7]={ { 0.408, 0.585 }, {0.479,
0.517}, {0.532,
283
0.465},{ 0.501, 0.160 }, {0.337, 0.086},
{0.208, 0.285}, {0.229, 0.424 }};
struct coord w={0.333, 0.333};

void CIE(void)
{
float x1,Y1,x2,y2;
int i,radius;
x1=xxp(xx[0]); y1=yyp(yy[0]);
x2=xxp(xx[1]); y2=yyp(yy[1]);
draw_line(x1,y1,x2,y2,LIGHTGRAY);
x1=x2; y1=y2;
x2=xxp(xx[2]); y2=yyp(yy[2]);
draw_line(x1,y1,x2,y2,LIGHTGRAY);
x1=x2; y1=y2;
x2=xxp(xx[0]); y2=yyp(yy[0]);
draw_line(x1,y1.x2,y2,LIGHTGRAY);
x1=xxp(w.xc); y1=yyp(w.xc);
for(i=0;i<7;i++)
{
x2=xxp(p[i].xc); y2=yyp(p[i].yc);
draw_line(x1,y1,x2,y2,LIGHTGRAY);
}
radius=(int)((xxp(((float)(w.xc)+0.01))-x1)+0.5);

draw_circle(x1,y1,radius,LIGHTGRAY);
}

/* Routine to draw a cross on the VGA screen. */

void draw_cross( float x. float y, int color)
{
int xx,yy;
xx=xxp(x); yy=yyp(y);
draw_line(xx-2,yy-2,xx+2,yy+2,color);
draw_line(xx-2,yy+2,xx+2,yy-2,color);
}
284
12.5 Dạy nhận biết bằng phơng pháp tối thiểu hoá hàm sai lệch tổng
Quy tắc delta nh chúng ta đã chứng kiến, là sơ đồ lặp hội tụ rất chậm. Sự
lựa chọn giá trị của và quyết định tốc tốc độ hội tụ. Phép hội tụ này
chậm, đòi hỏi hàng trăm phép lặp, và để giải quyết hết các vấn đề thì số
phép lặp lên đến hàng nghìn. Một perceptron có hai đầu vào và vì vậy có hai
trọng số có thể thay đổi đợc, phần tử mà tự nó có thể chia đợc hai lớp màu
riêng biệt nhau, đòi hỏi một số lợng phép tính nh trong trờng hợp phân
chia lớp màu trong file "TINT.DAT". Nếu tất cả các phép tính này cần thoả
mãn cho một bài toán đơn giản nh vậy, thì bạn tởng tợng điều gì sẽ xảy
ra nếu chúng ta dùng phơng pháp này để dạy cho một cấu trúc thần kinh đa
chức năng. Vấn đề cấp thiết đặt ra là phải tìm cách để đảm bảo sự hội tụ xảy
ra với tốc độ nhanh hơn.
Yêu cầu thực tế bây giờ là phải tối thiểu hoá, và đòi hỏi cho sự tối thiểu
hoá này là hàm sai lệch tổng:
E d y
i i
i

M




1
2
2
0
1
( ) (12.5)
ở đây d
i
là đáp ứng ra mong muốn cho các mẫu X
i
= [ x
0
, x
1
, , x
N-1
], và y
i
là
đáp ứng ra thực sự cho cùng các mẫu đầu vào này. Nếu y
i
là một hàm phi
tuyến của trọng số có thể thay đổi đợc : W = [ w
0
, w

1
, , w
N
], vấn đề trở
thành bài toán tối thiểu hoá một hàm phi tuyến. Vì vậy, chúng ta sẽ tìm
kiếm các phơng pháp từ phạm vi phi tuyến đã đợc chứng minh để có kết
quả trong việc giải quyết các vấn dề tơng tự.
12.5.1 Phơng pháp tìm kiếm bất biến
Một phơng pháp hay dùng nhất để rút ra giá trị nhỏ nhất của một hàm
đơn biến là phơng pháp tỷ lệ vàng (Golden Section). Phơng pháp này dựa
trên một giản đồ loại trừ miền, và giả thiết rằng hàm chỉ có một giá trị nhỏ
285
nhất trong một miền xác định trớc. Hàm nh thế gọi là hàm đơn điệu. Giản
đồ loại trừ miền trong trờng hợp tổng quát có thể giải thích bằng biểu đồ
nh trong hình 12.7.

Hình 12.7 Sơ đồ loại trừ miền.
Trong hình 12.7, nếu hai điểm đợc chọn trong miền giữa w
0
và w
1
, và
nếu y
2
> y
1
thì rõ ràng giá trị cực tiểu nằm giữa w
1
và a
2

. Vì vậy, miền [a
2
,
w
2
] có thể loại trừ khỏi vùng tìm kiếm. Nếu hai điểm khác đợc lựa chọn
trong miền nhỏ hơn và phép xử lý đợc lặp lại, miền tìm kiếm sẽ bị co hẹp
lại. Cuối cùng, giá trị nhỏ nhất đợc thu hẹp nằm trong một vùng rất nhỏ.
Một câu hỏi đặt ra: Bằng cách nào chúng ta chọn đợc các điểm nằm bên
trong này? Một câu hỏi khó hơn nữa sẽ là: Có điều kiện gì cho việc tìm
kiếm một dãy các điểm này để giá trị nhỏ nhất thu hẹp trong một vùng có độ
rộng 2

sau một số xác định các bớc? Câu trả lời cho vấn đề này đã đợc
Kiefer tìm ra vào năm 1953. Cách tìm kiếm lần lợt đợc biết dới tên tìm
kiếm Fibonacci. Phép tìm kiếm này dựa trên dãy số nguyên do Fibonacci
đa ra vào thế kỉ 13. Một phơng pháp tìm kiếm không đòi hỏi toàn bộ dãy
số nguyên Fibonacci đợc đa ra dới tên là tìm kiếm tỷ lệ vàng (Golden
Section). Chứng minh của phơng pháp này vẫn cha đợc trình bày trong
cuốn sách này; nhng bởi vì nó đơn giản và tôi đoán chắc là bạn muốn tìm
hiểu, nên tôi sẽ trình bày với bạn phần chứng minh:
Chúng ta sẽ giả sử rằng việc tìm kiếm cho tìm kiếm Fibonacci sẽ tiến
hành trên miền chuẩn hoá [0, 1]. Dãy số nguyên Fibonacci đợc định nghĩa
bằng các biểu thức:
F
0
= F
1

= 1

(12.6)
F
n
= F
n-1
+ F
n-2
n = 2,3,
286
Nếu N các giá trị hàm đợc dùng để tính

, nếu chúng ta đã bắt đầu lùi từ
phía sau kết quả và chuyển dịch về phía trớc tới đầu miền trong khi mở
rộng miền trong tất cả các bớc giới thiệu dới đây
Hình 12.8 Tìm kiếm Fibonacci.
L
N
= 2 = F
2

L
N-1
= 3 = F
3
(12.7)
L
N-2
= 5 = F
4

.
.
.
L
2
= F
N

L
1
= F
N+1

ở đây L
i
là khoảng cách trong lần lặp thứ i, và F
k
, k = 2, 3, , N+1 là các số
Fibonacci.
Nếu khoảng cách đầu tiên là [0,1] thì biểu thức cuối cùng của (12.7) có
thể viết thành
287




1
1
F
N

hoặc
F
N

1
1


và vì thế, nếu đợc cho, thì N có thể xác định từ
F
N


1
1


tơng tự, nếu N đã đợc cho, thì một kết quả lớn hơn




1
1
F
N

không đợc mong đợi.
Các bớc thực hiện của tìm kiếm Fibonacci rất đơn giản. Hai giá trị hàm

ban đầu đợc xác định tại a
2
= L
2
= F
N

và a
1
= 1 - L
2
= 1 - F
N

. Dựa trên
kết quả, khoảng cách giữa [0,a
1
] hoặc [a
2
,1] đợc loại trừ và một điểm mới
đợc lấy ra trong phần đối xứng khoảng cách còn lại với sự lu tâm đến
điểm bên trong. Bớc xử lý này đợc lặp lại cho đến khi tất cả N giá trị hàm
đã đợc xác định.
Tìm kiếm tỷ lệ vàng đợc tính từ tìm kiếm Fibonacci. Nếu


L
F
N2

và



1
1
F
N
thì L
F
F
N
N
2
1



Giả sử L
2
đợc chọn từ giả thuyết rằng một số lớn các giá trị hàm sẽ đợc
tạo ra (thậm chí ngay cả khi chúng ta không có ý định tạo ra chúng). Hãy
xấp xỉ L
2
bằng L
2
. Vì thế

L

F
F
N
N
N
2
1



lim

Cho N lớn