1 / 53

Kontrolowanie poszukiwania

Kontrolowanie poszukiwania. Controlling Search. Estimating Efficiency of a CLP Program Rule Ordering Literal Ordering Adding Redundant Constraints Minimization Identifying Deterministic Subgoals Example: Bridge Building. Szacowanie efektywności.

brie
Download Presentation

Kontrolowanie poszukiwania

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Kontrolowanie poszukiwania

  2. Controlling Search • Estimating Efficiency of a CLP Program • Rule Ordering • Literal Ordering • Adding Redundant Constraints • Minimization • Identifying Deterministic Subgoals • Example: Bridge Building

  3. Szacowanie efektywności • Obliczenia to przeszukiwanie w drzewie wyprowadzeń • Wielkość tego drzewa wpływa na koszt poszukiwań • gdy mniejsze to mniejszy • odpowiedź jest na lewo: mniej poszukiwania przed pierwszą odpowiedzią • Drzewo wyprowadzenia zależy od trybu użycia

  4. Tryb użycia • tryb użycia: definiuje warunki, które muszą spełniać argumenty, gdy predykat jest wywoływany • fixed: z magazynu więzów da sę wywnioskować pojedyńczą wartość dla parametru • free: dopuszczalne są wszystkie wartości • możliwe inne (np. ograniczone z góry, dołu)

  5. Przykład trybu użycia sumlist([], 0). sumlist([N|L], N+S) :- sumlist(L, S). • tryb użycia: 1 arg. fixed drugi free • sumlist([1],S). • L=[1,2],S > Z, sumlist(L,S). • Stany w drzewie wyprowadzenia w wywołaniem sumlist • < sumlist([1], S) | true > • < sumlist(L’,S’) | [1]=[N’|L’] /\ S = N’ + S’ >

  6. Przykład • Wyobraźmy sobie, że piszemy program obliczający • Myślimy w następujący sposób: • suma N liczb to suma N-1 iN • suma 0 liczb to 0 • Problem sum(1,S) nie daje odpowiedzi (S1) sum(N, S+N) :- sum(N-1, S). (S2) sum(0, 0).

  7. Przykład Uproszczone drzewo wyprowadzeń sum(1,S)

  8. Przykład • Nieskończone wyprowadzenie przed odpowiedzią • sum(1,S) da odpowiedź S=1, • a sum(1,0)? (S3) sum(0, 0). (S4) sum(N, S+N) :- sum(N-1, S).

  9. Przykład • Nie planowaliśmy, by program pracował z liczbami ujemnymi. Poprawmy go. (S5) sum(0, 0). (S6) sum(N, S+N) :- sum(N-1, S), N >= 1.

  10. Przykład • Przetwarzanie od lewa na prawo • sum(1,S) daje S = 1, sum(1,0) odpowiada no • metody: • zmiana porządku reguł • dodawanie więzów nadmiarowych • porządek literałów (S7) sum(0, 0). (S8) sum(N, S+N) :- N >= 1, sum(N-1, S).

  11. Porządek reguł • zasada ogólna • nierekurencyjne przed rekurencyjnymi • (pozwoli to czasem uniknąć nieskończonych wyprowadzeń) • zasada heurystyczna • najpierw reguły, które wydają się częściej prowadzić do odpowiedzi • (może przesuwać w lewo drzewa szczęśliwe węzły)

  12. Kolejność literałów • Więzy bazowe • więz w miejscu gdzie najwcześniej spowoduje porażkę (dla jakiegoś trybu użycia) • fac(N,F)zN ustaloną F wolną fac(N, F) :- N = 0,F = 1. fac(N, FF) :- N >= 1, FF = N * F, N1 = N - 1, fac(N1, F). fac(N, F) :- N = 0,F = 1. fac(N, FF) :- N >= 1, N1 = N - 1, fac(N1, F), FF = N * F.

  13. Kolejność literałów • Więzy użytkownika: • deterministyczne przed innymi • deterministyczny: p(s1,...,sn) jest deterministyczny, jeżeli w każdym punkcie wyboru w drzewie wyprowadzeń wszyskie gałęzie (prócz jednej) kończą się podczas analizy więzów bazowych (nie użytkownika) • predykat jest deterministyczny dla danego trybu użycia

  14. Predykaty deterministyczne • sumlist(L,S) jest deterministyczny, gdy L jest ustalone S wolne. Nie odwrotnie. • sum(N,S) podobnie • predykaty deterministyczne nie(?) wymagają poszukiwania do znalezienia odpowiedzi • Zmiana położenia predykatu w klauzuli może zmienić jego ,,deterministyczność’’

  15. Zmiana kolejności literałów father(jim,edward). father(jim,maggy). father(edward,peter). father(edward,helen). father(edward,kitty). father(bill,fi). mother(maggy,fi). mother(fi,lillian). father(F,C) jest deterministyczny dla C ustalonego i F wolnego, ale nie na odwrót. Podobnie mother(M,C) Każde dziecko ma jednego ojca Ojciec może mieć wiele dzieci

  16. Zmiana kolejności literałów grandf(GF,GC) :- father(GF,P),father(P,GC). grandf(GF,GC) :- father(GF,P),mother(P,GC). Dla trybu użycia GC ustalony GF wolny: • Jaki tryb użycia dla pierwszej wersji? • father(GF,P) oba wolne, father(P,GC) oba ustalone • Gdy zmienimy kolejność? • father(P,GC) wolne ustalone, father(GF,P) wolne, ustalone

  17. Zmiana kolejności literałów grandf(GF,GC) :- father(P,GC),father(GF,P). grandf(GF,GC) :- mother(P,GC),father(GF,P). Bardziej efektywny dla tryby wolny - ustalony grandf(X,peter) daje 63 stany w uproszczonym drzewie dla pierwszego programu a 23 dla drugiego.

  18. Dodawanie więzów nadmiarowych. • Nadmiarowym nazwiemy taki więz, który można usunąć z reguły nie zmieniając odpowiedzi • więz nadmiarowy: ten sam zbiór odpowiedzi • H :- L1, ..., Li, Li+1, ..., Ln • H :- L1, ..., Li, c, Li+1, ..., Ln • korzyści • <L1,...,Li,c|C> zawodzi, ale nie <L1,...,Li|C>

  19. Dodawanie więzów nadmiarowych. Więz N >= 1 dodany do programu na sumę był nadmiarowy (ze względu na odpowiedź) Inny przykład sum(N,7) (nowy tryb użycia)

  20. Dodawanie więzów nadmiarowych. Wiemy, że każda suma jest nieujemna (S9) sum(0, 0). (S10) sum(N, S+N) :- N >= 1, S >= 0, sum(N-1, S).

  21. Dodawanie więzów nadmiarowych • nadmiarowe dla solwera: więz bazowy jest nadmiarowy dla solwera jeżeli wynika z magazynu więzów • korzyści: gdy solwer jest częściowy może dać extra informacje (failure) • F >= 1, N >= 1, FF = N*F, FF >= 1

  22. Przykład (F1) fac(N, F) :- N = 0,F = 1. (F2) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, fac(N, F). fac(N,7) nie zatrzymuje się, jak sum(N,7). (F3) fac(N, F) :- N = 0,F = 1. (F4) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, F >= 1, fac(N, F). fac(N,7) podobnie

  23. Przykład Gdy F’’’’ >= 1 i N >= 4 to Musi być co najmniej 24. Solwer tego nie wykrywa!

  24. Przykład Rozwiązanie: dodaj nadmiarowy (dla solwera) więz N * F >= N (wynika z N >= 1, F >= 1 ) (F3) fac(N, F) :- N = 0,F = 1. (F4) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, FF >= N, F >= 1, fac(N, F). Teraz fac(N,7) zawodzi (skończenie)

  25. Minimalizacja • Literał minimalizacyjny powoduje przeszukiwanie innego drzewa wyprowadzeń • minimize(G,E) ma taki sam tryb użycia jak E < m, G • dla efektywnej minimalizacji, zapewnij, że G jest efektywne, gdy E jest ograniczone z góry

  26. Minimalizacja. Przykład Program znajdujący liście z głębokością leaf(node(null,X,null),X,0). leaf(node(L,_,_),X,D+1) :- leaf(L,X,D). leaf(node(_,_,R),X,D+1) :- leaf(R,X,D). Answers: X=h/\D=3 (h,3),(j,4),(k,4),(m,4),(o,5),(p,5),(f,2),(s,4), (t,4),(r,3)

  27. Minimalizacja. Przykład minimize(leaf(t(a),X,D), D): Po znalezieniu X = h /\ D = 3, działa jak D < 3 leaf(t(a),X,D), i nie powinien odwiedzać węzłów poniżej 3

  28. Minimalizacja. Przykład Poprawiamy leaf dla D ograniczonego z góry dodając więz nadmiarowy. leaf(node(null,X,null),X,0). leaf(node(L,_,_),X,D+1) :- D >= 0, leaf(L,X,D). leaf(node(_,_,R),X,D+1) :- D >= 0, leaf(R,X,D).

  29. Minimalizacja • Przeszukiwanie nie zawsze skorzysta z ograniczeń • n.p.. minimize(leaf(t(a),X,D), -D) • Po odwiedzeniu jednego liścią dalej musi odwiedzić wszystkie węzły • oryginalne sformułowanie jest lepsze, bo wymaga mniejszej ilości więzów • Pamiętajmy o trybie użycia E<m, G

  30. Wskazywanie determinizmu • Języki CLP zawierają konstrukcje, w których użytkownik wskazuje niedeterminizm i powoduje efektywniejsze wykonanie • if-then-else • once

  31. If-Then-Else • if-then-else l: (Gtest->Gthen;Gelse) • najpierw testuje Gtest, jeśli OK. to wykonuje Gthen w przeciwnym przypadku Gelse • if-then-else -- krok wyprowadzenia: G1 is L1, L2, ..., Lm, gdzie L1 to (Gt -> Gn ; Ge) • if <Gt | C1> daje szczęśliwe ,,najlewsze’’ wyprowadzenie <Gt | C1> => ... => < [] | C> • C2 to C, G2 to Gn, L2, ..., Lm • else C2 is C1, G2 is Ge, L2, ..., Lm

  32. Przykład • abs(X,Y) :- (X >= 0 -> Y = X ; Y = -X). • Jeśli X dodatnie to w.bezwgl. jest X, wpp -X

  33. Przykład: • zachowanie dla zapytań • abs(X,2), X < 0 and X < 0,abs(X,2) zawodzi ?! sukces X = -2 ? • NIEBEZPIECZEŃSTWO • odpowiedź silnie zależy od trybu użycia • używana jest jedynie pierwsza odpowiedź zaoytania Gt

  34. Przykłady far_eq(X,Y) :- (apart(X,Y,4)-> true ; X = Y). apart(X,Y,D) :- X >= Y + D. apart(X,Y,D) :- Y >= X + D. • X and Y are equal or at least 4 apart • far_eq(1,6) succeeds, far_eq(1,3) fails • far_eq(1,Y), Y = 6 fails • WHY? test goal commits to first answer X >= Y + 4

  35. If-Then-Else • bezpieczne użycie: wszystkie zmienne w Gtest ustalone • przykładowo: N i P0 ustalone cumul_pred([],_,P,P). cumul_pred([N|Ns],D,P0,P) :- (member(N,P0) -> P1 = P0 ; pred(N,D,[N|P0],P1) ), cumul_pred(Ns,D,P1,P).

  36. Once • once: once(G) • znajduje jedno rozwiązanie G • once derivation step: G1 is L1, L2, ..., Lm, where L1 is once(G) • if <G | C1> succeeds with leftmost successful derivation <G | C1> => ... => < [] | C> • C2 is C, G2 is L2, ..., Lm • else C2 is false, G2 is []

  37. Once Example • Sometimes all answers are equivalent • example: intersection • intersect([a,b,e,g,h],[b,e,f,g,i]) 72 states • 18 states intersect(L1,L2) :- member(X,L1), member(X,L2). intersect(L1,L2) :- once(member(X,L1), member(X,L2)).

  38. Bridge Building Example • AIM: build 2 dimensional spaghetti bridges • Approach: first build a program to analyze bridges, then use it to constrain designs

  39. Bridge Building Example • Constraints: • 20cm of struts, • strut of length L can sustain any stretch, only 0.5*(6-L)N compression, • floating joins can sustain any stretch, only 2N compression, sum of forces at a floating join is zero, one join in the center, at least 3 incident struts to a join, except center join only needs 2

  40. Representing Bridges • list of joins • cjoin(x,y,l) (xy coords, list of incident struts) • join(x,y,l) • list of struts: strut(n,x1,y1,x2,y2) name and coords of endpoints • analysis of the bridge will create an association list of stretching forces in each strut f(n,f)

  41. Representing Bridges js = [join(2,1,[a,c,d]), join(4,1,[d,e,g]), cjoin(3,-1,[b,c,e,f])] ss = [strut(a,0,0,2,1), strut(b,1,0,3,-1), strut(c,2,1,3,-1), strut(d,2,1,4,1), strut(e,3,-1,4,1), strut(g,4,1,6,0)]

  42. Strut Constraints strutc([],[],0). strutc([strut(N,X1,Y1,X2,Y2)|Ss], [f(N,F) |Fs], TL):- L = sqrt((X1-X2)*(X1-X2)+ (Y1-Y2)*(Y1-Y2)), F >= -0.5 * (6 - L), TL = L + RL, strutc(Ss, Fs, RL). Builds force association list, calculates total length, asserts max compression force

  43. Strut Constraints • Given a fixed list of struts works well • Like sum total length only causes failure at end • FIX add answer redundant constraint RL >= 0 • If the coords of the struts are not fixed length calculation is non-linear (incomplete) • (partial) FIX add solver redundant constraints (linear approximation)

  44. Summing Forces sumf([],_,_,_,0,0). sumf([N|Ns],X,Y,Ss,Fs,SFX,SFY) :- member(strut(N,X1,Y1,X2,Y2),Ss), end(X1,Y1,X2,Y2,X,Y,X0,Y0), member(f(N,F),Fs), F <= 2, L = sqrt((X1-X2)*(X1-X2)+ (Y1-Y2)*(Y1-Y2)), FX = F*(X-X0)/L, FY = F*(Y-Y0)/L, SFX = FX+RFX, SFY = FY+RFY, sumf(Ns,X,Y,Ss,Fs,RFX,RFY). end(X,Y,X0,Y0,X,Y,X0,Y0). end(X0,Y0,X,Y,X,Y,X0,Y0).

  45. Join Constraints joinc([],_,_,_). joinc([J|Js],Ss,Fs,W) :- onejoin(J,Ss,Fs,W). joinc(Js,Ss,Fs,W). onejoin(cjoin(X,Y,Ns),Ss,Fs,W) :- Ns = [_,_|_], sumf(Ns,X,Y,Ss,Fs,0,W). onejoin(join(X,Y,Ns),Ss,Fs,W) :- Ns = [_,_,_|_], sumf(Ns,X,Y,Ss,Fs,0,0). Apply minimum incident struts and sum forces cons.

  46. Join Constraints • Given a fixed list of struts for each join, works well • non-deterministic because of end although there is only one answer • hence use inside once

  47. Bridge Analysis • For the illustrated bridge TL <= 20, strutc(ss,Fs,TL), once(joinc(js,ss,Fs,W)). • Answer is W <= 2.63

  48. Bridge Design • strutc and joinc require the topology to be known to avoid infinite derivations • too many topologies to search all • one approach user defines topology tpl(Js,Ss,Vs) where Vs are the coordinate variables • system performs minimization search

  49. Bridge Design • Unfortunately constraints are nonlinear so minimization goal will not work • instead add explicit search to minimize on which fixes all coordinates tpl(Js,Ss,Vs), TL <= 20, strutc(Ss,Fs,TL), once(joinc(Js,Ss,Fs,W)), minimize(position(Vs), -W). • Answer W=6.15 /\ Vs=[2,2,5,1,3,3]

  50. Position Search position([]). position([V|Vs]) :- member(V,[6,5,4,3,2,1,0,-1,-2]), position(Vs). • Simply try each possible value in turn for each variable • More about this kind of search in the next chapter

More Related