Báo cáo tiểu luận môn học trí tuệ nhân tạo điều khiển cánh tay ROBOT gắp vật

BÁO CÁO TIỂU LUẬN MÔN HỌC TRÍ TUỆ NHÂN TẠO ĐỀ TÀI ĐIỀU KHIỂN CÁNH TAY ROBOT GẮP VẬT Ngày nay trong lĩnh vực công nghiệp, tự động hóa quá trình công nghệ đã trở thành một yếu tố quan trọng quyết định sự thành công của một doanh nghiệp. Và quá trình tự động hóa không thể không kể đến những cánh tay robot, vốn được sử dụng rất phổ biến trong những ngành công nghiệp quan trọng như hàn, mạ, vi điện tử, cơ khí chính xác … Việc điều khiển sao cho những cánh tay robot có thể thực thi với năng lượng ít nhất và thời gian nhanh nhất một cách tối ưu, chính xác là nhân tố quan trọng quyết định giá thành sản phẩm. Điều này hoàn toàn có thể được giải quyết được nhờ ứng dụng những tri thức đạt được trong lĩnh vực trí tuệ nhân tạo.

BÁO CÁO TIỂU LUẬN MÔN HỌC

TRÍ TUỆ NHÂN TẠO

ĐỀ TÀI

ĐIỀU KHIỂN CÁNH TAY

ROBOT GẮP VẬT

5 - 2007

A – VẤN ĐỀ

Ngày nay trong lĩnh vực công nghiệp, tự động hóa quá trình công nghệ

đã trở thành một yếu tố quan trọng quyết định sự thành công của một doanh nghiệp Và quá trình tự động hóa không thể không kể đến những cánh tay robot, vốn được sử dụng rất phổ biến trong những ngành công nghiệp quan trọng như hàn, mạ, vi điện tử, cơ khí chính xác … Việc điều khiển sao cho những cánh tay robot có thể thực thi với năng lượng ít nhất và thời gian nhanh nhất một cách tối ưu, chính xác là nhân tố quan trọng quyết định giá thành sản phẩm Điều này hoàn toàn có thể được giải quyết được nhờ ứng dụng những tri thức đạt được trong lĩnh vực trí tuệ nhân tạo

Mục đích của tiểu luận là viết một chương trình đơn giản dựa trên ngôn ngữ lập trình Prolog để điều khiển cánh tay gắp khối chuyển từ trạng thái đầu bất kỳ sang một trạng thái đích nhất định, ứng dụng từ những giải thuật tìm kiếm như: tìm theo chiều rộng, theo chiều sâu và heuristic

B – PHƯƠNG PHÁP LUẬN GIẢI QUYẾT VẤN ĐỀ

Cho mô hình một cánh tay robot, trạng thái đầu và đích của những sản phẩm như hình vẽ

Mục đích của bài toán là điều khiển cánh tay robot di chuyển những khối từ trạng thái đầu sang trạng thái đích Các bước thực hiện:

1 Mô tả trạng thái của bài toán bằng các vị từ tổng quát:

a location(W, X, Y, Z) : mô tả vị trí của khối W tại tọa độ X, Y, Z

b on(X, Y) : mô tả khối X nằm trên khối Y

c clear(X) : mô tả làm sạch X ( không có khối nào nằm trên khối X)

d holding(X) : mô tả cánh tay robot đang giữ khối X

f ontable(X): mô tả khối X nằm trên mặt bàn

2 Mô tả các thao tác của cánh tay robot bằng vị từ:

a goto(X, Y, Z) : di chuyển cánh tay robot đến vị trí X, Y, Z

b pickup(X) : thực hiện lệnh nhất X lên khỏi mặt bàn

c putdown(X) : thực hiện lện đặt X xuống mặt bàn

d takeoff(X, Y) : thực hiện lệnh lấy khối X từ đỉnh khối Y

e stack(X, Y) : thực hiện lệnh đặt khối X lên trên khối Y

3 Mô tả các luật suy diễn

a Luật xác định làm sạch khối : khi không có khối Y nào nằm trên X, X sạch

∀X(clear(X) ←← ¬¬¬∃∃Y(on(Y, X)))

b Luật xác định khối nằm trên mặt bàn: Y nằm trên bàn khi và chỉ khi

nó không nằm trên khối nào khác

∀X ∀∀Y (¬¬on(Y, X) ↔↔ ontable(Y))

c Luật xác định cánh tay robot rỗng: cánh tay rỗng khi nó không giữ khối nào

∀Y (handemty() ↔↔ ¬¬holding(Y))

d Thay đổi trạng thái khi thực hiện lện pickup

_ Trạng thái hiện tại: cánh tay rỗng, X ontables, X sạch

_ Trạng thái sau pickup: cánh tay giữ X

∀X(pickup(X)→→(holding(X)←← (handemty()∧∧ontable(X)∧∧clear(X))))

e Thay đổi trạng thái khi thực hiện lệnh putdown:

_ Trạng thái hiện tại: cánh tay giữ X

_ Trạng thái sau putdown: cánh tay rỗng, X ontable, X sạch

∀X(putdown(X)→→(handemty()∧∧ontable(X)∧∧clear(X)) ←← holding(X)))

f Thay đổi trạng thái khi thực hiện lệnh puton:

_ Trạng thái hiện tại: Cánh tay giữ X, Y rỗng

_ Trạng thái sau puton: cánh tay rỗng, X trên Y, X sạch

∀X∀∀Y(stack(X,Y)→→((handemty()∧∧on(X,Y)∧∧clear(X))←←(holdin g(X)∧∧clear(Y))))

g Thay đổi trạng thái khi thực hiện lệnh takeoff

_ Trạng thái hiện tại: cánh tay rỗng, X trên Y, X sạch

_ Trạng thái sau takeoff: Giữ X, Y sạch

∀X∀∀Y(takeoff(X,Y)→→ ((holding(X)∧∧clear(Y))←←

(handemty()∧∧on(X,Y)∧∧clear(X))))

h Xử lý ràng buộc khi thực hiện lệnh takeoff : Nếu X nằm trên bàn thì

nó không bị ảnh hưởng bởi lệnh takeoff(Y,Z)

∀X∀∀Y∀∀Z(takeoff(Y,Z)→→ (ontable(X)←←ontable(X)))

i Xử ly ràng buộc khi thực hiện lệnh puton: Nếu X nằm trên bàn thì nó không bị ảnh hưởng bởi lệnh puton(Y,Z)

∀X∀∀Y∀∀Z(stack(Y,Z)→→ (ontable(X)←←ontable(X)))

Do các luật trên có thể dẫn đến một không gian trạng thái rất rộng và phức tạp ( do sự lặp lại trạng thái của bài toán) Để xứ lý ta lập bộ ba danh sách P, A, D

mô tả các sự kiện và điều kiện ràng buộc cho chúng

P – danh sách các tiền điều kiện

A – danh sách bổ sung các sự kiện

D – danh sách hủy bỏ các sự kiện

Từ danh sách trên ta có thể xây dựng lại toán tử vị từ để loại bỏ bớt các luật khung của bài toán, gồm 4 toán tử vận hành chính sau:

Giới thiệu các trạng thái của vật

holding(X): trạng thái cánh tay robot đang gắp vật X

on(Y,X) : trạng thái vật Y nằm trên vật X

ontable(X) : trạng thái vật X đang nằm trên bàn

Giới thiệu các thao tác của cánh tay robot

Ký hiệu : P – là danh sách các tiền đề điều kiện

A – là danh sách bổ sung các sự kiện

D – là danh sách hủy bỏ các sự kiện

a) pickup(X) : cánh tay robot gắp vật X từ trên bàn

P : handempty( ), clear(X), ontable(X)

A : holding(X)

D : handempty( ), clear(X), ontable(X)

b) putdown(X) : cánh tay robot để vật X lên bàn

P : holding(X)

A : ontable(X), clear(X), handempty( )

D : holding(X)

c) takeoff(Y,X) : cánh tay robot gắp vật Y ra khỏi vật X

P : clear(Y), on(Y,X), handempty( )

A : holding(Y), clear(X)

D : clear(Y), on(Y,X), handempty( )

d) stack(Y,X) : cánh tay robot chồng vật Y lên vật X

pickup(X)

putdown(X)

takeoff(Y,X)

P : holding(Y), clear(X)

A : clear(Y), on(Y,X), handempty( )

D : holding(Y), clear(X)

Trong cách biểu diễn này, danh sách bổ sung A và danh sách hủy bỏ

D xác định các yếu tố cần thiết để thỏa mãn luật khung Các thành phần mô tả khác không đề cập đến trong hai danh sách trên được xem như không thay đổi trạng thái trong danh sách mới khi thực hiện các toán tử trên

Từ các danh sách trên ta có thể xây dựng được các giải thuật tìm kiếm theo chiều rộng và chiều sâu để đạt đến trạng thái đích của bài toán

_ Trạng thái đầu và đích của bài toán được mô tả thông qua vị từ như sau:

• Ontable(D)

4 Phương pháp tìm kiếm theo chiều rộng

stack(Y,X)

B A

B A

B A

B A

B A

B A

B A

B A

B A

B A

B A

Takeoff(B,A)

stack(B,A)

stack(B,C)

Pickup A Takeoff(B,C)

stack(A,B) Putdown(A)

5 Phương pháp tìm kiếm theo chiều sâu

6 Phương pháp tìm kiếm theo heuristic

B

A C D

E

B

A C D

E

B

A C D

E

B

A C D

E

B

A

C D

E

B

A C D

E B

A

C D

E

B

A C D

E

_ Định nghĩa: Heuristic của bài toán được định nghĩa là số vị từ khác nhau mô tả trạng thái hiện tại và trạng thái đích Trạng thái nào có số vị từ mô tả khác nhau là ít nhất thì

đó là trạng thái tốt nhất

C – GIẢI THUẬT

I Giải thuật tìm kiếm theo chiều rộng :

begin

open := [Start]

closed := []

while open ≠ []

begin

Hủy bỏ đỉnh đầu tiên từ danh sách Open, gọi nó là X;

if X là đích then return(success) và gọi hàm in kết quả các thao tác;

else begin

phát sinh các con của X;

đặt X vào đầu danh sách closed;

loại bỏ các con của X đã có mặt trên open hoặc closed;

đặt các con còn lại của nó vào cuối danh sách open thêm tập trạng thái [con,cha] vào danh sách closed end

end;

return(failure) end

Do giải thuật chiều rộng sẽ tìm kiếm tất cả các trường hợp có thể có ở tại một cấp, vì vậy mà khi tìm tới trạng thái đích thì tập các trạng thái trong tập closed

sẽ bao gồm tất cả các trạng thái đã duyệt qua Do đó để tìm ra được đường đi từ trạng thái đầu đến trạng thái cuối thì tại mỗi bước sau khi xác định được trạng thái con thì khi thêm vào danh sách closed ta thêm dưới dạng [trạng thái con, trạng thái cha] để cho dễ dàng suy đường đi từ trạng thái đầu đến trạng thái đích của bài toán Sau đó dùng hàm tìm các thao tác đối với đường dẫn trạng thái vừa tìm được

để tìm ra danh sách các thao tác tương ứng cho yêu cầu bài toán

Chương trình giải quyết bài toán cánh tay Robot gắp vật theo giải thuật tìm kiếm theo chiều rộng:

domains

action = takeoff(Symbol,Symbol); pickup(Symbol); putdown(Symbol);

stack(Symbol,Symbol)

laction = action*

process = del(state); add(state)

lprocess = process*

state =

handempty();clear(Symbol);on(Symbol,Symbol);ontable(Symbol);holding(Symbol)

lstate = state*

list_lstate = lstate*

list_list_lstate = list_lstate*

predicates

nondeterm del_queue(List_lstate,List_list_lstate,List_list_lstate)

nondeterm dequeue(List_lstate,List_list_lstate,List_list_lstate)

nondeterm empty_queue(List_list_lstate)

nondeterm subset(lstate,lstate)

nondeterm member(state,lstate)

nondeterm member_set(state,lstate)

nondeterm member_queue(List_lstate,List_list_lstate)

nondeterm member_queue1(List_lstate,List_list_lstate)

nondeterm member_queue2(List_lstate,List_list_lstate)

nondeterm equal_set(lstate,lstate)

nondeterm moves(Lstate,List_list_lstate,List_list_lstate,List_lstate)

nondeterm get_children(Lstate,List_list_lstate,List_list_lstate,List_list_lstate)

nondeterm move(Action,Lstate,Lprocess)

nondeterm add_list_to_queue(List_list_lstate,List_list_lstate,List_list_lstate)

nondeterm add_list(List_lstate,List_list_lstate,List_list_lstate)

nondeterm add_if_not_in_set(state,lstate,lstate)

nondeterm delete_if_in_set(state,lstate,lstate)

nondeterm change_state(lstate,lprocess,lstate)

nondeterm path(List_list_lstate,List_list_lstate,Lstate)

nondeterm go(Lstate,Lstate)

nondeterm printsolution(List_lstate,List_list_lstate,List_list_lstate)

nondeterm find_action(List_list_lstate)

clauses

% Cac thao tac cua canh tay robot

move(takeoff(X,Y),[handempty(),clear(X),on(X,Y)],[del(handempty()),del(clear(X)),

del(on(X,Y)),add(clear(Y)),add(holding(X))])

move(putdown(X),[holding(X)],[del(holding(X)),add(ontable(X)),add(clear(X)),

add(handempty())])

move(pickup(X),[handempty(),clear(X),ontable(X)],[del(handempty()),del(clear(X)),

del(ontable(X)),add(holding(X))])

move(stack(X,Y),[holding(X),clear(Y)],[del(holding(X)),del(clear(Y)),add(handempty()),

add(on(X,Y)),add(clear(X))])

% Tim kiem cac trang thai con tu trang thai hien tai

get_children(State,Rest_open_queue,Closed_set,Children):-

findall(Child,moves(State,Rest_open_queue,Closed_set,Child),Children)

moves(State,Res_open_queue,Closed_set,[Child_state,State]):-

move(_,Preconditions,Actions), subset(Preconditions,State), change_state(State,Actions,Child_state), not(member_queue2([Child_state,_],Res_open_queue)), not(member_queue([Child_state,State],Res_open_queue)), not(member_queue([Child_state,State],Closed_set))

% Tim kiem duong di tu trang thai dau toi trang thai dich tu tap cac trang thai trung gian

printsolution([_,[]],_,A):-nl,nl,find_action(A),nl,nl

printsolution([State,Parent],Closed_set,Been_queue):-

member_queue1([Parent,Grandparent],Closed_set), add_list([Parent,State],Been_queue,New_been_queue), del_queue([Parent,Grandparent],Closed_set,New_closed_set), printsolution([Parent,Grandparent],New_closed_set,New_been_queue)

% Tim kiem cac trang thai trung gian cua cac khoi vat de thoa yeu cau bai toan

path(Open_queue,_,_):-

empty_queue(Open_queue),!, write("Graph searched, no solution found")

path(Open_queue,Closed_set,Goal_state):-

dequeue([State,Parent],Open_queue,_), equal_set(State,Goal_state),write("Solution path is : "), empty_queue(Been_queue),

printsolution([State,Parent],Closed_set,Been_queue),!

path(Open_queue,Closed_set,Goal_state):-

dequeue([State,Parent],Open_queue,Rest_open_queue), get_children(State,Rest_open_queue,Closed_set,Children), add_list_to_queue(Children,Rest_open_queue,New_open_queue), add_list([State,Parent],Closed_set,New_closed_set),

path(New_open_queue,New_closed_set,Goal_state)

go(Start_state,Goal_state):-

empty_queue(Empty_open_queue), add_list([Start_state,[]],Empty_open_queue,Open_queue), empty_queue(Closed_set),

path(Open_queue,Closed_set,Goal_state)

% Tim kiem thao tac phu hop tuong ung voi tap cac trang thai trung gian

find_action([])

find_action([[A,B]|Tail]):-

move(Name,Preconditions,Actions), subset(Preconditions,A),

change_state(A,Actions,C), equal_set(B,C),write(" ",Name),nl, find_action(Tail)

%Cac ham xu ly danh sach

empty_queue([])

subset([],_)

subset([H|T],S):- member_set(H,S),subset(T,S)

member_set(H,S):-member(H,S)

member(X,[X|_])

member(X,[_|T]):-member(X,T)

equal_set(S1,S2):- subset(S1,S2),subset(S2,S1)

member_queue2([A1,_],[[B1,_]|_]):-equal_set(A1,B1)

member_queue2([A1,B1],[[_,_]|Tail]):-member_queue2([A1,B1],Tail)

member_queue1([A1,A2],[[A1,A2]|_])

member_queue1([A1,A2],[[_,_]|Tail]):-member_queue1([A1,A2],Tail)

member_queue([A1,A2],[[B1,B2]|_]):-equal_set(A1,A2),equal_set(B1,B2)

member_queue([A1,A2],[[_,_]|Tail]):-member_queue([A1,A2],Tail)

dequeue([A1,A2],[[A1,A2]|Tail],Tail)

del_queue([A1,A2],[[A1,A2]|Tail],Tail)

del_queue([A1,A2],[[_,_]|Tail],New_tail):-del_queue([A1,A2],Tail,New_tail)

change_state(S,[],S)

change_state(S,[add(P)|T],S_new):- change_state(S,T,S2),add_if_not_in_set(P,S2,S_new),! change_state(S,[del(P)|T],S_new):- change_state(S,T,S2), delete_if_in_set(P,S2,S_new),! delete_if_in_set(_,[],[])

delete_if_in_set(E,[E|T],T):-!

delete_if_in_set(E,[H|T],[H|T_new]):-delete_if_in_set(E,T,T_new),!

add_if_not_in_set(X,S,S):- member(X,S),!

add_if_not_in_set(X,S,[X|S])

add_list_to_queue(E,[],E)

add_list_to_queue(E,[H|T],[H|Tnew]):-add_list_to_queue(E,T,Tnew)

add_list(E,T,[E|T])

Goal

go([handempty(),ontable(b),on(a,b),clear(a),ontable(c),on(d,c),clear(d)],

[handempty(),ontable(a),on(b,a),on(d,b),on(c,d),clear(c)])

Kết quả chạy thử nghiệm :

a Trạng thái đầu : handempty( ), ontable(b),on(a,b), clear(a), ontable(c), on(d,c), clear(d)

Trạng thái đích: handempty( ), ontable(a), on(b,a), on(d,b), on(c,d), clear(c)

Kết quả thu được từ chương trình :

takeoff("a","b") putdown("a")

pickup("b")

stack("b","a")

takeoff("d","c")

stack("d","b")

pickup("c")

stack("c","d")

b Trạng thái đầu : handempty(), ontable(a), on(b,a), clear(e), on(e,b), ontable(c), on(d,c), clear(d)

Trạng thái đích: handempty(), ontable(d), on(c,d), on(b,c), on(a,b), clear(a), ontable(e), clear(e)

Kết quả thu được từ chương trình :

takeoff("e","b") putdown("e")

takeoff("d","c")

putdown("d")

pickup("c")

stack("c","d")

takeoff("b","a")

stack("b","c")

pickup("a")

stack("a","b")

II Giải thuật tìm kiếm theo chiều sâu

Giải thuật tìm kiếm theo chiều sâu :

begin

open:=[Start]; closed := [];

while open ≠ [];

begin

Loại bỏ đỉnh đầu tiên của danh sách open, gọi nó là X;

If X là đích then return(success) và in ra danh sách thao tác else begin

Từ trạng thái X tìm kiếm các trạng thái con từ các thao tác Đưa X vào closed;

Loại bỏ các con của X đã có mặt trên open hoặc closed;

Đặt các con còn lại ở đầu danh sách open Thêm thao tác vừa sử dụng vào danh sách thao tác end

end;

return(failure) end

Chương trình giải quyết bài toán cánh tay Robot gắp vật theo giải thuật tìm kiếm theo chiều sâu:

domains

action =

takeoff(Symbol,Symbol);pickup(Symbol);putdown(Symbol);stack(Symbol,Symbol)

laction = action*

process = del(state); add(state)

lprocess = process*

state =

handempty();clear(Symbol);on(Symbol,Symbol);ontable(Symbol);holding(Symbol)

lstate = state*

list_lstate = lstate* %sua

predicates

nondeterm move(action,lstate,lprocess)

nondeterm plan(lstate,lstate,list_lstate,laction)

nondeterm subset(lstate,lstate)

nondeterm subset_stack(lstate,list_lstate) %sua

nondeterm equal_set(lstate,lstate)