Bu yazının amacı, bilgisayar bilimlerinde, özellikle de mantıksal sistemlerin ispatında kullanılan ileri zincirleme ve geri zincirleme yöntemlerini açıklamaktır.

Yöntemin çalışması oldukça basittir. Öncelikle problem, mantık düzleminde modellenir. Buradaki mantık sistemi sonlu ispatı olan herhangi bir system olabilir. Örneğin birinci dereceden mantık (first order logic) veya daha özel olarak boole cebiri kullanılabilir.

Modelleme aşamasının ardından problemin çözümüne geçilir. İşte tam bu noktada ileri zincirleme (forward chaining) veya geri zincirleme (backward chaining) yöntemlerinden birisi seçilebilir.

Örneğin aşağıdaki mantıksal sistemi ve şekli ele alalım:

Sistemde görüldüğü üzere bazı mantıksal dizilimler verilmiş ve son iki satırda A ve B önermelerinin (kaziye) doğru olduğu belirtilmiştir.

Buna göre sağdaki çizim, hangi durumlarda, hangi diğer durumların doğru olacağını bu mantıksal sistemden çıkarır. Örneğin p=> q ifadesi, çizimin en tepesinde gösterilmiş ve p önermesinin (predicate, kaziyesinin) doğruluğu halinde q önermesinin de (kaziyesinin de) doğru olacağını ifade etmektedir.

Benzer şekilde, L önermesinin (kaziyesinin) doğruluğu A ve B önermelerine bağlı olduğu gibi, A ve P önermelerinin doğruluğuna da bağlanmıştır. Bu iki sistemden birisinin doğru olması sonucun doğruluğunu sağlar.

Şimdi şekilde gösterilen sistemi ileri zincirleme (forward chaining) yöntemi ile çözelim. Öncelikle sistemdeki bütün doğruluk şartlarını sayısal olarak ifade ediyoruz:

Şekilde görüldüğü üzere bütün doğruluk şartları birer sayı ile ifade edilmiştir. Söz gelimi, M önermesinin doğruluğu L ve B önermesi gibi 2 önermenin doğruluğunu gerektirir. Bu yüzden M birleşiminde 2 sayısı bulunur. Benzer şekilde Q önermesinde bulunan 1 sayısı, sadece P önermesinin doğruluğunun yeterli olduğunu ifade etmektedir.

Şimdi ileri zincirleme yöntemini kullanarak sistemin doğru olduğu verilen A ve B önermelerinden itibaren çözümünü izleyelim.

Öncelikle A ve B’ye komşu olan düğümlerdeki değerleri 1′er azaltıyoruz:

Yukarıdaki şekilde ileri zincirleme işlemi (forward chaingin) A önermesi için çalıştırılmış olup A’nın komşularını 1 azaltmıştır. Sırada B önermesi var ve onu da çalıştıralım:

Görüldüğü üzere B’nin komşuları da 1 azaldığında 0 değerine sahip bir düğüm elde ettik. Bu durumda L’nin doğru olduğunu söyleyebiliriz çünkü L’nin doğru olması için gereken 2 değer de sağlandı. Yani mantıksal sistemimizde bulunan

A Ù B Þ L

Satırını sağlamış olduk. Buradan doğruluğunu bulduğumuz L önermesinin komşularını 1 azaltıyoruz:

L’nin komşularının 1 azalması sonucunda M’nin değeri 0′a inmişi oluyor ve artık M için de doğru diyebiliyoruz. Şimdi M’nin komşularını 1 azaltalım:

Artık P için doğru sonucuna ulaştık ve P’nin iki komşusununda değerini 1 azaltarak sonucu buluyoruz:

Görüldüğü üzere zaten doğru olduğunu bildiğimiz L için tekrar doğru sonucunu bulduk ve ilave olarak Q için de doğru sonucunu bulduk.

Demek ki ilk sistem bize verildiğinde, Q’nun değeri sorulsaydı, doğru olduğunu söyleyebilirdik, ancak bunu bilgisayarın bulması için yukarıda adım adım anlatılan aşamaların tamamlanması gerekmektedir.

Geri Zincirleme (Backward Chaining)

Gelelim aynı amaç için kullanılan, yani bir mantıksal sistemi çözmek için kullanılan geri zincirleme yöntemine. İleri zincirleme yöntemine çok benzer olarak yine bir mantıksal sistem, bir şekil üzerinde gösterilebilr:

Sistemde diyelim ki Q’nun değerini merak ediyor olalım. Bilgisayar algoritması, bu defa Q’nun değerinin doğruluğunun P’nin değerinin doğruluğuna bağlı olduğunu çözerek işe başlayacaktır. Aslında geri zincirlemede kullanılan yaklaşım, tam olarak ileri zincirlemenin tersidir. İleri zincirlemede, doğruluğunu bildiğimiz önermelerden başlanırken, geri zincirlemede, doğruluğunu aradığımız önermelerden başlıyoruz. Burada doğruluğunu aradığımız önerme Q olduğuna göre, Q’dan başlayarak sistemi dolaşacağız. İlk adımda Q’nun doğruluğu, P’nin doğruluğuna bağlıdır, o halde Q yerine P doğru mudur diye sistemi çözmeye çalışırız:

P’nin doğruluğu, şekilde de görüldüğü üzere, L ve M’ye bağlıdır ve artık L ve M doğru mudur diye sorarız. Bunlardan birisinin yanlış olması halinde sonuç yanlış veya ikisinin de doğru olması halinde sonuç doğru olacaktır. Burada sonuç ile kastedilen P ve dolayısıyla Q’dur. Dikkat edilirse artık L ve M’ye bakarak Q’nun değerini tahmin edebiliyoruz. Devam edelim:

L’nin doğruluğuna bakıldığında P ve A bulunmakta, aslında bu sorunun cevabını P’nin değerini bilmediğimiz için veremeyiz. Ancak burada bir tehlike bizi bekliyor, şayet doğruluğunu araştırmak için DFS (depth first search, derin öncelikli arama) benzeri bir algoritma ile ağacı (veya şekli (graph) ) dolaşıyorsak, bu durumda bir sonsuz döngüye (fasit daire) girme ihtimalimiz bulunuyor. Bunu engellemek için diyelim ki derinliği sabitledik ve L’nin doğruluğu için A ve B ikilisine bakmaya karar verdik:

Sonuçta A ve B doğru ise L doğru demektir. O halde L doğru mu sorusunu sormayı bırakıyor ve M doğrumu A ve B doğru mu sorularını arayarak sistemi çözmeye devam ediyoruz. M’nin doğruluğu ise L ve B’ye dayanmakta, o halde bir kere daha L’nin doğruluğunu sorguluyor ve yukarıda anlatıldığı üzere bir kere daha A ve B’nin doğruluğunu sorguluyoruz. Neticede sorumuz basitçe A ve B doğru mudur şeklinde oluyor.

Verilen mantıksal sistemden de bildiğimiz üzere A ve B doğrudur, o halde Q da doğrudur diyebiliriz, çünkü sistemi buraya kadar adım adım çözdük ve neticede Q’nun doğruluğunu sorgulamanın A ve B’nin doğruluğunu sorgulamak olduğunu gördük.

Geri zincirleme (backward chaining) yaklaşımında istenirse buradan geriye dönülerek bütün sistemdeki önermelerin durumları doğru veya yanlış olarak işaretlenebilir. Ancak geri zincirleme algoritması, bu aşamada aranan Q önermesinin sonucunu bularak durabilir de. Bu iki yaklaşım arasındaki fark aslında CPS (call by passing style) ile birikimsel tarz (accumulation style) arasındaki fark gibidir.

İki yöntemde de sonuç doğru bir şekilde bulunur. Belki ufak bir fark olarak dikkat edilmesi gereken, geri zincirlemede, özel olarak aranan bir önermenin sonucuna konsantre olmamız, buna bağlı olarak da bazı büyük sistemlerde, sistemin sadece belirli bir kısmını çözüyor olmamız görülebilir. Buna mukabil, ileri zincirleme yaklaşımında, sistemin tamamı çözülmektedir.

40 views

Bu yazının amacı, PROLOG diline giriş yapmak ve basit bazı yapay zeka problemlerinin PROLOG dilinde nasıl kodlanarak çözüldüğünü göstermektir.

Kurulum ve çalıştırma:

Bu yazı kapsamında SWI-PROLOG programı kullanılacaktır. Programı, www.swi-prolog.com adresinden temin etmek mümkündür.

Yazı kapsamında MAC OSX üzerinde örnekler çalıştırılarak gösterilecektir ancak kurulum ve sonrasında başarılı bir çalıştırma yapılabiliyorsa hangi işletim sisteminde olduğunuzun bir önemi yoktur, bütün sistemlerde aynı PROLOG komutları çalışır.

Siteden indirilip kurulum yapıldıktan sonra,

$ /opt/local/bin/swipl 

Dizini altında bulunan swipl komutu çalıştırılarak, PROLOG komut satırı açılabilir.

Program çalıştırıldığında, aşağıdakine benzer bir komut satırı ile komut girilmesini bekleyecektir:

?- _

Yardım

İlk ve en önemli komutumuz olan yardım komutu ile başlayabiliriz.

?- help(help).

Bu komut, X11 ekranında, yardım dokümanını görüntüleyecektir. Basitçe herhangi bir komut hakkında bilgi alınmak istendiğinde bu komutu help fonksiyonuna parametre olarak vermek yeterlidir. Yukarıdaki kullanımda help komutunun kendisi için yardım alınmıştır.

Çıkış

Prolog komut satırından çıkmak için

?- halt.

Yazılması yeterlidir. Bu komut programı sonlandıracaktır.

Basit Kaziyeler

Aşağıdaki komutları PROLOG üzerinde çalıştıralım ve ardından burada yapılan işlemleri yorumlayalım.

Sistemimizde kayıtlı olan bir dosyayı program tarafından açıp çalıştırılır bir şekilde yüklemek için dosya ismi köşeli parantezler içerisinde verilmelidir:

?- [‘ilkdosya.pl'].

Yukarıda, bilgisayarımızda bulunan “ilkdosya.pl” isimli dosyayı sisteme tanıtarak yükledik. Bu dosyada bulunan tanımlar da otomatik olarak yüklenmiş ve sorgulanmaya / çalışmaya hazır hale getirilmiş olacaktır. Ayrıca bu dosyada bulunan genel hatalar, yükleme sırasında ekrana basılır.

PROLOG ile Faktöriyel Kodu

PROLOG dili, yapısal olarak özyineli (recursive) bir yapıdadır ve döngülerin yerine özyineli fonksiyon (recursive function) kullanılması gerekir. Bu kullanımı göreceğimiz en basit uygulamalardan birisi olan faktöriyel kodunu yazıp kodlamaya çalışalım.

Herhangi bir editör açılarak (ben tercihen vi kullanıyorum, siz de istediğiniz bir editör ile dosyayı açıp içeriğini ) aşağıdaki şekilde yazabilirsiniz:

factorial(0,1).      

factorial(A,B) :- 

             A > 0,

             C is A-1,

            factorial(C,D),

            B is A*D. 

Ardından aşağıdaki şekilde dosyamızı sisteme yükleyelim:

?- ['ilkdosya.pl'].

% ilkdosya.pl compiled 0.00 sec, 732 bytes

true.

Komut satırında dosyamızın yüklendiği ve yükleme süresi ve dosya boyutu gösterilmektedir. Son satırda yer alan true bilgisine kadar bir hata bulunmamış olması, dosyamızda bir hata olmadığını gösterir. Şimdi artık ilk fonksiyonumuzu kullanmaya başlayabiliriz.

?- factorial(5,X).

X = 120 ;

false.

Komut satırında, factorial(5,X) komutu verilerek, 5! Değerinin X değişkenine döndürülmesi istenmiştir. Burada öğrenilen birkaç önemli noktayı belirtelim. Birincisi X ile gösterilen değer bir değişkendir ve PROLOG dünyasında buna unbounded variable (bağlanmamış değişken) ismi verilir. Basitçe Prolog kodlarındaki bütün büyük harf ile başlayan ifadeler birer değişkendir ve ayrıca bir değişken tanımı yapılmaz. İkinci bir nokta, Prolog dilinde kod yazılırken girilen her satır bir emirdir ( declaration) ve yapısal olarak Prolog dili, haber mantığını (predicate calculus) barındırır. Buna göre yüklü olan dosyada bulunan komutlar yukarıdan aşağıya doğru çalıştırılırken üstte bulunan satır, alttakine gore öncelikli olur ve aynı zamanda birden fazla satırda emirin tanımlanması durumunda, sırasıyla bu emirler işlenir.

Örneğin yukarıdaki kodda, ilk satırda bulunan factorial (0,1). İfadesi, 0! = 1 anlamındadır ve bir şekilde birisi bize sıfır faktöriyeli sorarsa, ikinci değer olarak 1 sonucunu döndürmeyi gerektirir.

İkinci satırdan sonra başlayan tanımda ise, sırasıyla A>0 kontrolü yapılmış, ardından C değişkenine değer olarak A-1 değeri konmuş ve yeni bulunan C değerinin faktöriyeli hesaplanarak, B sonucuna hesaplanan bu C faktöriyel değeri ile A’nın çarpımı eklenmiştir.

Yukarıdaki şekilde kodumuzu ilkdosya.pl  dosyasına yazıp kaydettikten sonra prolog komut satırında dosyamızı yükleyip çalıştırabiliriz:

Yukarıda görüldüğü üzere faktöriyel kodumuz çalışmış ve sonucu doğru şekilde bulmuştur.

Kodun çalışmasını takip etmek için trace komutu kullanılabilir. Basitçe komut satırında:

trace.

Yazıldıktan sonra çalışmaya başlar ve bu çalışmadan sonra çağrılan fonksiyonların detayları ekrana basılır:

Görüldüğü üzere factorial fonksiyonumuzun her adımı ekrana basılmıştır.

Hanoi Kuleleri (Towers of Hanoi)

İkinci bir uygulama olarak çok klasik bilgisayar bilimleri problemlerinden olan Hanoi Kulelerini ( tower of hanoi ) kodlamaya çalışalım.

Oyunun kuralı gayet basit. Başlangıçta bir çubukta dizili olan bütün diskler her adımda tek bir disk hareket ettirerek diğer iki çubuktan birisine taşınacaktır. Bu taşıma işlemleri sırasında büyük bir disk, küçük olan bir diskin üzerine gelmeyecektir.

Ayrıca oyunun internetten oynan bir denemesi için daha önce hazırladığım aşağıdaki ödev sayfasına bakabilirsiniz:

http://www.sadievrenseker.com/c/odev5.html

Problemin çözümünde kullanacağımız kod aşağıdaki şekildedir:

SADIs-MacBook-Air:prolog sadievrenseker$ vi hanoi.pl

oyna(1,X,Y,_) :-

    write(X),

    write(‘ en üstteki diskini ‘),

    write(Y),

    write(‘ oynat ‘),

    nl.

oyna(N,X,Y,Z) :-

    N>1,

    M is N-1,

    oyna(M,X,Z,Y),

    oyna(1,X,Y,_),

    oyna(M,Z,Y,X).

Kod örneği yukarıda verilmiştir. Kodumuzun çalışmasını görüp ardından nasıl çalıştığını açıklamaya geçebiliriz.

?- oyna(4,a,b,c).

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

a en üstteki diskini c oynat

b en üstteki diskini a oynat

b en üstteki diskini c oynat

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

c en üstteki diskini a oynat

b en üstteki diskini a oynat

c en üstteki diskini b oynat

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

true .

?-

Yukarıdaki çalışmadan da görüldüğü üzere ilk baştaki 4 diskin dizili olduğu a çubuğundan bütün diskler sırasıyla b çubuğuna taşınmıştır.

Kodumuz, doğru sıra ile oynama yaklaşımı ile kodlanmıştır. Hanoi kulelerinin farklı çözümleri bulunur. Örneğin geri izleme algoritması (backtracking) kullanarak kaba kuvvetle (brute force) bütün ihtimallerin denendiği ve başarısızlık olması halinde en son iyi duruma geri dönen yaklaşımları kodlamak da mümkündür.

Bizim kodlamamızda ise her seferinde doğru çubuktan doğru diskin oynatılması esası kullanılmıştı. Bu yüzden hiç geri oynama veya yapılan hamleden vaz geçme olmamıştır.

Bu oynama esasını daha iyi anlatabilmek için daha ufak bir örnek üzerinden çalışmayı gösterelim :

?- oyna(2,a,b,c).

a en üstteki diskini c oynat

a en üstteki diskini b oynat

c en üstteki diskini b oynat

true

Görüldüğü üzere iki disklik bir dizilimde, c çubuğu geçici olarak kullanılmakta, esas büyük diskin b çubuğuna oynanması sırasında, küçük diskleri depolamak için kullanılmaktadır.

Bu durum disk sayısı artsa da değişmez. En büyük diskin a çubuğundan b çubuğuna oynanması sırasında,  diğer bütün küçük diskleri depolamak için c çubuğunu kullanırız. Buradan anlaşılacağı üzere ikinci büyük diskin c çubuğuna oynaması gerekir. Bunun için de b çubuğunu geçici depolama için kullanırız. Bu yaklaşım en büyük diskten en küçüğüne kadar aynı mantıkla işleyerek devam eder.

8 Vezir Problemi (8 Queens Problem)

Yeni bir problem olarak klasik sorulardan birisi olan 8 vezir problemini ( eight queens problem) ele alalım. Problem basitçe bir satranç tahtasına 8 veziri, birbirini yemeden nasıl yerleştireceğimizdir.

Problemin çözümü olan PROLOG kodu aşağıda verilmiştir.

perm([X|Y],Z) :- perm(Y,W), birinial(X,Z,W).

perm([],[]).

birinial(X,[X|R],R).

birinial(X,[F|R],[F|S]) :- birinial(X,R,S).

cozum(P) :-

     perm([1,2,3,4,5,6,7,8],P),

     birlestir([1,2,3,4,5,6,7,8],P,S,D),

     hepsifarkli(S),

     hepsifarkli(D).

birlestir([X1|X],[Y1|Y],[S1|S],[D1|D]) :-

     S1 is X1 +Y1,

     D1 is X1 – Y1,

     birlestir(X,Y,S,D).

birlestir([],[],[],[]).

hepsifarkli([X|Y]) :-  \+member(X,Y), hepsifarkli(Y).

hepsifarkli([X]).

Kodun çalışan örneği aşağıdaki şekildedir:

?- cozum(P).

P = [5, 2, 6, 1, 7, 4, 8, 3] ;

P = [6, 3, 5, 7, 1, 4, 2, 8] ;

P = [6, 4, 7, 1, 3, 5, 2, 8] ;

P = [3, 6, 2, 7, 5, 1, 8, 4] ;

P = [6, 3, 1, 7, 5, 8, 2, 4] ;

P = [6, 2, 7, 1, 3, 5, 8, 4] ;

P = [6, 4, 7, 1, 8, 2, 5, 3] ;

P = [3, 6, 2, 7, 1, 4, 8, 5] ;

P = [6, 3, 7, 2, 4, 8, 1, 5] ;

…

Yukarıdaki örneklerde görüldüğü üzere her kolon için, o kolondaki kaçıncı satıra vezir yerleştirilebileceği ve bu yerleştirme işlemine göre bütün kuralları sağlayan bir dizilimin nasıl elde edileceği listelenmiştir. Problemin birden fazla çözümü olduğu için her satır, çözümlerden birisini göstermektedir. Örneğin ilk çözüm satırını ele alırsak, aşağıdaki gibi bir satranç tahtası elde ederiz.

P = [5, 2, 6, 1, 7, 4, 8, 3] ;

Kodda, kabaca bütün ihtimalleri deneyen bir permütasyon algoritması geliştirilmiştir. Ardından koşulların sağlanıp sağlanmadığı kontrol edilmiş ve buna göre koşulları sağlayan ihtimaller sonuç olarak döndürülmüştür.

Algoritma, bir arama algoritması (search algorithm) şeklinde probleme yaklaştığı için, problemin çözümü sırasındaki bütün ihtimaller sadece bir kere denenecek ve denenen bir ihtimal tekrar etmeyecektir. Bu deneme sırası, permütasyon fonksiyonu ile sağlanır.

113 views

Bilgisayar bilimlerinde, özellikle metin işlemenin yoğun olduğu, arama motoru gibi uygulamalarda dosyaların veya web sitelerinin birbirine olan benzerliğini bulmak için kullanılan bir algoritmadır.

Algoritmaya alternatif olarak klasik hash fonksiyonları kullanılabilir. Yani, örneğin iki sayfasnın ayrı ayrı hash değerleri alınıp bu değerleri karşılaştırmak mümkündür. Ancak simhash algoritması, bu yönteme göre daha fazla hız ve performans sunar.

Sim hash algoritması, iki dosyayı birer vektör olarak görür ve bu vektorler (yöney, vector) arasındaki cosinüs (cosine) bağlantısını bulmaya çalışır.

Yukarıdaki şekilde temsil edildiği üzere iki dokümanın ayrı ayrı birere vektör olması durumunda, aralarında cos (x) olarak gösterilen bir açı ile bağlantı bulunması mümkündür.

Algoritma, öncelikle işlediği metindeki kelimelerin ağırlıklarını (weight) çıkarmakta ve buna göre kelimeleri sıralamaktadır.

Sıralanan her kelimeye, b uzunluğunda, yegane (unique) değer döndüren bir fonksiyon kullanılır. Örneğin her kelime için farklı bir hash sonucu döndüren fonksiyon kullanılır.

b boyutundaki bir vektörün ağırlık değeri hesaplanırken, her kelimedeki 1 değeri için +1 ve 0 değeri için -1 değeri ağırlığa eklenir.

Son olarak üretilen ağırlık vektöründeki + değerler 1, 0 ve – değerler ise 0 olarak çevirilir.

Örnek

Yukarıdaki algoritmanın çalışmasını bir örnek üzerinden anlatalım. Algoritmanın üzerinde çalışacağı metin aşağıdaki şekilde verilmiş olsun:

www bilgisayar kavramları com bilgisayar kavramlarının anlatıldığı bir bilgisayar sitesidir ve com uzantılıdır

Yukarıdaki bu metni, algoritmanın anlatılan adımlarına göre işleyelim:

İlk adımımız, algoritmadaki kelimelerini ağırlıklarının çıkarılmasıdır. Bu adımı çeşitli şekillerde yapmak mümkündür ancak biz örneğimizde kolay olması açısından kelime frekanslarını (tekrar sayısı, frequency) kullanacağız. Buna göre metindeki kelimelerin tekrar sayılarına göre sıralanmış hali aşağıda verilmiştir:

bilgisayar 3 com 2 kavramları 1 kavramlarının 1 anlatıldığı 1 bir 1 www 1 sitesidir 1 ve 1 uzantılıdır 1

Yukarıda geçen her kelime için bir parmak izi (fingerprint) değeri üretiyoruz. Bu değerin özelliği, kelimeler arasında yegane (unique) bir değer bulmaktır. Bu değer, herhangi bir hash fonksiyonu üzerinden de üretilebilir. Biz örneğimizde kolalık olması açısından her kelime için rast gele bir değer kendimiz atayacağız. Ancak gerçek bir uygulamada rast gele değerlerin kullanılması mümkün değildir. Bunun sebebi, aynı kelimenin tekrar gelmesi halinde yine aynı değerin üretilmesi zorunluluğudur. Bu yazıdaki amaç algoritmayı anlatmak olduğu için birer hash sonucu olarak rast gele değerler kullanılacaktır.

bilgisayar 10101010 com 11000000 kavramları 01010101 kavramlarının 10100101 anlatıldığı 11101110 bir 01011111 www 11110001 sitesidir 10101110 ve 00001111 uzantılıdır 00100010

3. adımda, yukarıdaki değerleri topluyoruz. Toplama işlemi sırasında 1 değerleri için +1 ve 0 değerleri için -1 alıyoruz.

10101010
11000000
01010101
10100101
11101110
01011111
11110001
10101110
00001111
00100010
——–
2 0 2 -4 0 2 2 0

Son olarak, yukarıdaki değerleri ikilik tabana çeviriyoruz: 10100110 bu değer bizi simhash sonucumuz olarak bulunuyor.

Örneğin yeni bir dosyayı daha işlemek istediğimizde, bu dosyadaki kelime yoğunluğuna göre yukarıda bulduğumuz simhash değerine yakın bir değer çıkmasını bekleriz.

Diyelim ki yeni bir dosyada da sadece “bilgisayar kavramları com” yazıyor olsun. Bu yazının sim hash değerini bularak karşılaştırmaya çalışalım:

bilgisayar 10101010 com 11000000 kavramları 01010101

10101010
11000000
01010101
———
1 1 -1 -1 -1 1 1 1

Değerin ikilik tabana çevrilmiş hali : 11000111

Orjinal dokümandan çıkardığımız simhash değeri ile farklı olan bit sayısı 3′tür. Bunun anlamı yukarıdaki bilgisayar kavramları com yazısının orjinal yazıya 3 mesafesinde yakın olduğudur.

136 views

Bu yazının amacı, sezgisel algoritmalar (heuristic algorithms) tarafından kullanılan sezgisel fonksiyon (heuristic function) kavramını açıklamak ve bazı zaviyelerden tasnif etmektir.

1. Baskınlık Özelliği (Dominance)
2. Tutarlılık Özelliği (Consistent, Monotone)

3. Makbul Özelliği (Admissible)

Sezgisel algoritma, en basit anlamda, bir sezgisel algoritmanın, problem bağımlı olarak bazı tahminlerde bulunmasıdır. Örneğin daha önce yazdığım A* (A yıldız, A Star) algoritmasında, bir yol bulma örneği vermiştim. Bu algoritmadaki amaç, hedef düğüme (node) en kısa ulaşan yolu bulmaktı. Yollar karışık olmasına karşılık, hedefe giden kuş uçuşu mesafeyi sezgisel bir fonksiyon olarak kabul etmiştik:

Yukarıdaki şekilde, siyah renkle yazılı olan sayılar, düğümler arası mesafeyi gösterirken, düğümlerin üzerinde kırmızı renkle yazılan sayılar, o düğümün, hedefe olan kuş uçuşu mesafesini vermektedir. Bu durumda en kısa yolu bulmayı hedeflediğimiz bu problemde, sezgisel olarak bir fonksiyon tanımlamış oluyoruz ve problem hakkında bir bilgiyi, problemin çözümünde avantaj sağlaması için kullanıyoruz.

Farklı bir problem ve farklı bir fonksiyon tanımı yaparak konuyu daha iyi izah etmeye çalışalım. Örneğin 8 bulmacası (8 puzzle) olarak bilinen, aşağıdaki klasik oyunu ele alalım.

Yukarıdaki temsili resimde görüldüğü üzere, 8 bulmacasının bir başlangıç durumundan bir hedef durumuna kadar her adımda bir kutuyu boş olan hücreye kaydırmak suretiyle oynanması amaçlanmaktadır. Amacımıza yönelik olarak bir bilgisayar programı geliştirmek için sezgisel algoritmalardan (heuristic algorithms) faydalanmak istiyoruz. Bu durumda kullanabileceğimiz sezgisel algoritmalarda en önemli etkenlerden birisi de sezgisel fonksiyonumuz olacaktır. Yani probleme has bir fonksiyon geliştireceğiz ve bu fonksiyonla her adımda karar vermeye çalışacağız.

Bu aşamada iki fonksiyondan birisi önerilebilir:

• Taşların kaç tanesinin yerinde olmadığı
• Taşların bitiş durumunda olması gereken yere olan uzaklığı (kare mesafesi, manhattan distance)

Yukarıdaki iki farklı fonksiyon için de, yine yukarıda verilen şekildeki mesafeleri hesaplayalım.

ilk fonksiyonumuz olan, yanlış yerdeki taş sayısını hesaplamak için, yerinde olmayan taşları listeleyelim: 1,2,3,4,5,6,7,8 taşlarının tamamı hedef durumda olması gereken yerde değil. Burada boşluk hücresinin konumunu da sayarsak fonksiyon değeri olarak 9 buluruz.

İkinci fonksiyonumuza göre taşların, hedef konumuna olan mesafelerini sırasıyla listeleyelim:

1. 3
2. 1
3. 2
4. 2
5. 2
6. 3
7. 3
8. 2

Yukarıda, her taşın hedef konumuna olan mesafesi verilmiştir. Daha iyi anlaşılması açısından, örneğin 1 numaralı taş başlangıç durumunda sağ alt köşedeyken, bitiş durumunda üst ortaya gelmesi isteniyor. Bu taşın, tahtada hiç başka taş olmasaydı, başlangıç durumundan hedef durumuna gelebilmesi için yapılan hamle sayısı 3′tür. Yukarıdaki listede de her taş için bu değer sırasıyla yazılmıştır.

Fonksiyonumuzun toplam değeri : 3+1+2+2+2+3+3+2 = 18 olarak bulunur

Yukarıda, aynı problem için iki farklı sezgisel fonksiyon örneği verdik. Şimdi bu iki fonksiyonu karşılaştırarak özelliklerini açıklamaya çalışalım

1. Baskınlık ( Dominance ) Özelliği

Bu özellik, aynı problemin, aynı algoritma ile sezgisel olarak çözümü sırasında birden fazla fonksiyon bulunuyorsa, bu fonksiyonlar arasında seçim yapma kriterini belirler. Buna göre bir fonksiyonun alabileceği değer kumesi (fonksiyonun menzil uzayı (range) ) ne kadar geniş ise o kadar baskın fonksiyondur ve o derecede tercih edilmelidir.

Örneğin yukarıda, 8 bulmacası için iki farklı fonksiyon tanımı yaptık. Bu fonksiyonlardan ilki olan, yanlış yerdeki taş sayısı, en fazla 9 değeri alabilir. Şayet taşlardan bir tanesi doğru yerdeyse, fonksiyon değeri düşerek 8 değerine sahip olacaktr. Dolayısıyla fonksiyonun tanımlı olduğu, ve sonuç olarak döndürebileceği değerler 0 ile 9 arasındadır.

İkinci fonksiyonumuz olan manhattan mesafesi ise, taşların azami mesafede olması durumunda her taş için ayrı ayrı olarka 4 değerine sahip olabilir. (hedef durumunun (goal state) saat yönünde 4 kere çevrildiğini düşünün) ve 8 taşımız olduğu için 4 x 8 = 32 değeri, fonksiyonun döndürebileceği azami değerdir. Dolayısıyla fonksiyon 0 ile 32 arasındaki herhangi bir değeri döndürebilir.

İki fonksiyon kıyaslandığında, ilk fonksiyonun 9 ihtimalden birisini döndürebildiği, ikinci fonksiyonun ise 32 ihtimalden birini döndürebildiği görülmektedir. Bu durumda, ikinci fonksiyon, ilkine nazaran baskın fonksiyon olmakta ve ikisinden birisinin tercih edilmesi gerektiğinde, ikincisinin tercih edilmesi daha doğru olmaktadır.

Yukarıdaki baskınlık durumunun daha iyi anlaşılması için iki fonksiyon arasındaki farkı anlatmaya çalışalım. Çok kaba anlamda, ikinci fonksiyon 32 farklı değer döndürürken, ilk fonksiyon 9 farklı değer döndürebilmektedir. Bunun anlamı, ikinci fonksiyonun ayırt ettiği bazı durumları, ilk fonksiyonun ayıramamasıdır. Örneğin ilk fonksiyondaki her değer için ikinci fonksiyonda 3-4 farklı değer bulunabilmektedir. Diğer bir deyişle, 9 ihtimalden bir tanesi, 32 ihtimalden bir kaç tanesine karşılık gelmekte, bu bir kaç farklı durum da fonksiyonun sonuca ne kadar yaklaşıldığını ölçmede ayırım oluşturmasını sağlamaktadır.

Daha net bir şekilde farkını anlatacak olursak, bulmacanın verildiği şekildeki, 8 ve 5 numaralı karolar, başlangıç durumunda yer değiştirmiş olsaydı, ilk fonksiyonumuza göre, yerinde olmayan taş sayısı yine 9 olarak bulunacaktı. Ancak ikinci fonksiyonumuzda 18 yerine 20 değeri bulunmuş olunacaktı. Bu değişim, ilk fonksiyona göre karar vermemize imkan tanımazken, ikinci fonksiyon, aralarında seçim yapma imkanı sunacaktı.

2. Tutarlılık (Consistent, Monotone)

Tutarlılık kavramını anlamak için üçgen eşitsizliği halini anlamamız gerekir. Çok basit anlamda, bir üçgenin üç kenarı a b ve c olmak üzere, herhangi iki kenarının toplamı, üçüncü kenardan büyük olmalıdır. Bu hale üçgen eşitsizliği hali denir ve tersten okunursa, herhangi bir kenarın, diğer iki kenarın toplamından küçük olması olarak yorumlanabilir.

Şimdi bu çok basit kavram olan üçgen eşitsizliğinin sezgisel fonksiyonla nasıl bir ilişkisi var diye sorabilirsiniz. Tutarlılık durumu, gayet basittir aslında, basitçe bir arama şeklinde (graph) herhangi bir düğümün aldığı sezgisel fonksiyon değeri, çocuğunun aldığı sezgisel foknsiyon değeri ile toplandığında çıkan sonuç çocuğunun çocğuna doğrudan giden değerden daha büyük olmalıdır. Durumu aşağıdaki şekilde görsel olarak ifade edelim:

Yukarıdaki şekilde görüldüğü üzere en sağdaki düğüme giden ve n_i düğümünden başlayan iki yol bulunmaktadır. Bu yollardan birisi doğrudan gitmekte olup, ağırlık değeri (weight) h(n_{i) olarak ifade edilmiştir. İkinci yol ise nj üzerinden geçen yol olup, önce c(ni, nj) (ni ile nj arasındaki gerçek mesafe (sezgisel değil) ) mesafesi gidilmekte ardından nj için sezgisel bir değer bulunmaktadır. İşte üçgen eşitsizliği, bu iki değer arasında, ikincisinin daha büyük olmasını gerektirir. Ki bu durum, yukarıdaki şekilde de aşağıdaki şekilde ifade edilmiştir:}

h(n_i) <e; c(n_i, n_j) + h(n_j)

Şayet bir sezgisel fonksiyon yukarıdaki bu şartı her durum için sağlıyorsa tutarlı (consistent) sağlamıyorsa tutarsız (inconsistent) olarak tasnif edilebilir.

Fonksiyonların, tutarlı olması tercih edilir bir durumdur, bunun sebebi bir düğümden diğerine gidildiğinde ödenen maliyetin sezgisel fonksiyona yansımasının, sonucu bulmada etkisi olmasıdır. Şayet bir fonksiyon tutarsız ise, mesafe giderken harcanan maliyetin, sezgisel fonksiyona yansımadığı, en az bir durum var demektir ki bu da problemin çözümünde sorunlarla karşılaşılmasını (en azından tutarlı bir fonksiyona göre daha geç sonucun bulunmasını) beraberinde getirir.

Tutarlı bir fonksiyonun, aynı zamanda tektonlu (monotone) olarak isimlendirilmesinin sebebi ise, yukarıda izah edildiği üzere bir fonksiyonun tutarlı olması halinde, her düğümün tek bir kere ziyaret edilmesidir. Şayet bir fonksiyon tutarsız ise (inconsistent) bu durumda, aynı düğüm, arama işlemi sırasında, birden fazla kere ziyaret edilebilir. İşte bu anlamda tutarlı fonksiyonlar aynı zamanda tektonlu (monotone) olarak isimlendirilir.

3. Makbul (Macaiz, Kabul Edilebilir, Admissable)

Literatürde admissable olarak geçen durumdur. Bir sezgisel algoritmanın kabul edilebilir olup olmadığını (makbul) belirler. Makbul, hali, kısaca bir sezgisel fonksiyonun, herhangi bir mesafe için, gerçek mesafeden her zaman daha küçük değer vermesidir. Örneğin herhangi bir düğüm n için gerçek mesafe f(n) iken sezgisel fonksiyon olan h(n) değeri, her zaman için h(n) <e; f(n) şartını sağlamalıdır

Şayet bütün düğümler, yukarıdaki bu h(n) <e; f(n) şartını sağlıyorsa, bu sezgisel fonksiyona makbul (admissible) ismi verilebilir. Şayet sağlamayan tek bir durum varsa, bu sezgisel fonksiyonun makbul olmadığını (gayri makbul, non-admissible) söyleyebiliriz.

Yukarıdaki bu yaklaşımın sebebi, gerçek değerden daha yüksek bir sezgisel değer elde edildiği anda, bu sezgisel değerin, en iyi çözüm olan gerçek değeri perdelemesidir. Yani bir sezgisel algoritmada, makbul olmayan bir sezgisel fonksiyon kullanılırsa, bu fonksiyon için, sezgisel algoritmamız en iyi çözümü bulamayabilir.

335 views

Bilgisayar bilimlerinin çeşitli alanlarında (örneğin yapay zeka, veri yapıları veya şekil kuramı (graph theory) gibi) kullanılan arama algoritmalarından birsidir.

Algoritma, derin öncelikli drama (depth first search) üzerine kurulu olduğu için, literatürde “iterative deepening depth first search (yinelemeli derinleşen, derin öncelikli arama)” olarak da geçmektedir.

Algoritma basitçe derinlik değerini bir değişkende tutmakta ve bu değeri her adımda arttırmaktadır.
Yineleme yapısı (iteration) basit bir döngü (loop) olarak düşünülebilir ve her adımda derinliğin, bir döngü değişkeni (loop variable) gibi düşünülerek derinleştiği kabul edilebilir.

Örneğin aşağıdaki şekli (graph) ele alalım:

Ağaçta görüldüğü üzere iki adet döngü (cycle) bulunmaktadır. Iterative Deepening search algoritmasını bu ağaç üzerinde çalıştıracak olursak, algoritma öncelikle derinlik değerini (bundan sonra d değişkeni (variable) ile ifade edilecektir) 0′dan başlatarak her adımda bir ilerletecektir.

d=0 için arama:
A
d=1 için arama:
A (tekrar A değerine bakar) B C (sanki ağacın en üstteki üç düğümü, şekilde gösterildiği gibi bağlanmış kabul edilebilir, daha alttaki derinliklerde bulunan DEFG düğümlerine hiç bakamaz)
d=2 için arama:
A B D E C F G (Bu aramada sanki sondaki daireler (cycle) bulunmuyormuş gibi kabul edilebilir, çünkü belirtilen derinlik bu dairelere kadar inemez)
d=3 için arama:
A B D B E C F G A
d=4 için arama:
A B D B D E B C F G A B C

Yukarıdaki arma işlemi, derinlik arttıkça devam etmektedir.

Arama algoritmalarının değerlendirildiği bazı kriterler bulunmaktadır. Buna göre IDDFS (iterative deepening depth first search) algoriması “tam” algoritma olarak kabul edilebilir.
Tamlık teriminin (completeness) anlamı aşağıdaki şekilde tanımlanabilir:

Bir arama algoritması, bütün düğümleri dolaşarak aranan düğümü bulmayı garanti ediyorsa bu algoritmaya tam arama algoritması ismi verilir.

Örneğin yine yukarıdaki şekil için klasik derin öncelikli arama (depth first search) algoritmasını ele alsaydık, bu algoritmanın tam olmadığını söyleyebilirdik. Bunun sebebi DFS algoritmasının dolaşması sırasında, aşağıdaki döngüye girmesidir:

A B D B D B D ( B D ikilisi sosuza kadar tekrar eder)

Kısacası A B D düğümleri dışındaki düğümlere asla bakmaz. Bu anlamda tam olmadığını söyleyebiliriz.

BFS (breadth first search , yayılma öncelikli veya sığ öncelikli arama) algoritması ise her zaman için tam kabul edilebilir, sebebi bir sonraki derinlik seviyesine inmeden önce, bulunduğu seviyedeki düğümleri bitirmesi ve bu sayede bütün ağaca bakmayı garanti etmesidir.

Algoritmanın karmaşıklığına değinecek olursak. Aşağıdaki şekilde bir formül ile karşılaşırız.

Bu formülde görülen terimler şekil kuramında (graph theory) sıkça kullanılan bazı değerlere atıfta bulunur.
d değerinin derinlik olduğunu daha önce belirtmiştik. b ile gösterilen değer ise dallanma katasyısıdır (branching factor).

Kısaca her düğümün kaç çocuğu olduğu (out order, kaç düğüme gidilebildiği) olarak tutulur. Örneğin tam dolu ikili arama ağacının (binary search tree) b değeri 2′dir. Genelde en kötü durum analizinde bütün çocukların dolu olması ihtimali üzerinde durulur. Ayrıca istatistiksel olarak ortalamam çocuk sayısının da alındığı olur. Örneğin şehirlerin tutulduğu bir şekilde, her şehirden gidilebilecek şehir sayısı değişmektedir. Bu durumda b değeri ortalama değer olarak hesaplanabilir.

Bu açıklama ardından yukarıdaki denkleme tekrar bakarak anlamaya çalışalım.

IDDFS algoritmasında, en altta bulunan düğümlerin 1 kere (d sabitlendiğinde en altta kalan düğümler hangileri ise) dolaşıldığını, d-1 derinliğindeki düğümlerin ise 2 kere dolaşıldığını ve böylece kök düğüme (root) kadar her düğümün, bulunduğu seviyeye göre kaç kere dolaşıldığını hesaplayabileceğimize göre yukarıdaki denklem çıkarılabilir.

Diğer bir deyişle d=0 için kök 1 kere dolaşılırken d=1 olduğunda kök 2 ve kökün çocukları 1 kere dolaşılmış olur. d=3 olduğunda kök 3 kere ve çocukları 2 ve en alttaki çocuklar ise 1 kere dolaşılmış olur. Görüldüğü üzere derinliğin her artışında kök derinlik kadar altındaki her düğüm ise birer azalarak en nihayetinde yapraklar (leaf) tek bir kere dolaşılmış olmaktadır.

Sonuç olarak Yukarıdaki formülün ilk terimi kök (d+1)1 (tek düğüm d+1 kere dolaşılmıştır) , ikinci terimi kökün çocukları (db (kökün çocukları (ki sayısı b’dir) derinlik kadar (ki d ile gösterilir) dolaşılmıştır).

Yukarıdaki bu formülü daha toplu şekilde aşağıda gösterildiği gibi yazabiliriz:

Algoritmanın dolaşma (arama) zamanı karmaşıklığı yukarıda gösterildiği gibidir. Terimler birleştirildiğinde en kötü durum analizi (worst case analysis) için O(b^d) gösterimi kullanılabilir.

Hafıza karmaşıklığı ise O(bd) olarak ifade edilebilir. Bunun sebebi d derinliğindeki bir ağacın her seviyesinde b adet çocuğu bulunması durumunda bd kadar düğüm olacağıdır. Algoritma, çalışması sırasında ilave düğümlere ihtiyaç duymaz ve şeklin kendisi üzerinde dolaşarak sonuca ulaşır.

387 views

Bu yazının amacı, geri izleme algoritmasının (backtracking algorithm) bir uygulaması olarak, basit bir labirentte yol bulma kodunu JAVA dilinde kodlamaktır. Bu uygulamada herhangi bir yapay zeka yönetmi uygulanmayacaktır. Basitçe kör arama (blind search) yapan ve ihtimalleri sırayla deneyen bir robot uygulaması geliştirilecektir.

Örneğin labirent bilgisinin bir dosyada bulunduğunu ve bizim amacımızın bu dosyayı okuyarak labirentin başlangıcından çıkışına kadar olan yolu bulmak olduğunu düşünelim. Labirent tasarımımızda duvarları 1 ve yolları 0 ile gösterelim. Örneğin aşağıda bir labirent verilmiştir:

1111111
0010011
1000011
1101111
1100000
1111111

Yukarıdaki bu labirentte, sol üst köşeyi başlangıç konumu ve sağ alt köşeyi de bitiş konumu olarak kabul edeceğiz. Buna göre labirentin her zaman için ikinci satırının ilk kolonunda başlıyoruz ve labirentin boyutuna göre son satırın bir üstünde en sağ kolonda bitiriyoruz. Amacımız bu iki nokta arasındaki yollardan bir tanesini çözüm olarak bulmak. Ayrıca dosyadan labirent okuyacağımız için, veri yapısı kullanımını kolaylaştırmak amacıyla, labirentin boyutlarını da dosyanın ilk satırında tutalım. Buna göre bir labirent dosyasının içeriği aşağıdaki şekilde olacaktır:

6 7
1111111
0010011
1000011
1101111
1100000
1111111

Dosyanın ilk satırında, labirentin satır ve sütun boyutları verilmiştir.

Algoritmamız, basitçe labirentin başlangıç konumundan yola çıkacak ve yol alternatiflerini değerlendirecektir. Şayet yol tek yönlü ise hareket etmeye devam edecek ancak bir yol ayrımına geldiğinde bu noktayı bir yığında (stack) tutarak çıkmaz bir yola girdiğinde en son aklında tuttuğu bu yola geri dönecek ve farklı bir karar verecektir.

Örneğin yukarıdkai problem için çözümü elle yaparak tasarımımıza başlayalım. Başlangıç durumumuz (1,0) olacak (dizide satır sayısının 0′dan başladığını düşünürsek, ikinci satırın ilk sütunu (1,0) olarak gösterilecektir.

Bitiş durumumuz ise (4,6) olarak belirlenecektir (dizi boyutumuzda azami satır ve sütun değerleri 5,6 olacaktır (boyuttan bir eksik) ve en altın bir üstü satır 4 ve son sütun 6 olacaktır. Dolayısıyla bitiş durumu olarak (4,6) tanımlıyoruz.

(1,0) konumundan, (4,6) konumuna kadar olan çözüm yolunu bulmak için adım adım algoritma tasarımımızı inceleylim.

Algoritmamız kör arama (blind search) olduğu için, çözüme giden en mantıklı yolu bulmak yerine bütün ihtimalleri deniyeceğiz. Bu ihtimalleri belirli bir sıra ile aramamız gerekiyor. Bu srıalama için algoritmamızı aşağıdaki şekilde tasarlayalım:

Geldiğim yeri işaretle

if(sola gidilmemişse)

sola git;

else if(sağa gidilmemişse

sağa git;

else if(yukarı gidilmemişse)

yukarı git;

else if (aşağı gidilmemişse)

aşağı git;

Yukarıdaki bu tasarımda sol -> sağ -> yukarı -> aşağı sırası tamamen rast gele olarak üretilmiştir ve daha farklı sırada da olabilirdi.

(1,0) konumundan başlayarak yukarıdaki algoritmayı icra ettirelim. İşaretleme için 2 değerini kullanacağız. Öncelikle yığın (stack) değeri boş olarak başlıyoruz (bundan sonra S olarak gösterilecek ve sağdan eklenerek sağdan çıkarma yapılacaktır):

1111111
0010011
1000011
1101111
1100000
1111111

S -> boş

İlk değeri işaretliyoruz:

1111111
2010011
1000011
1101111
1100000
1111111

(1,0) konumunda tek gidilebilecek komşu, (1,1) konumudur (1,0) konumunun komşuları 0,0 2,0 ve 1,1 olduğuan göre bu değerlere bakıyoruz ve bunlardan 0 olan tek değere gidiyoruz:

1111111
2210011
1000011
1101111
1100000
1111111

Benzer şekilde (1,1) konumunun tek 0 olan komşusu (2,1) olan konuma gidiliyor. Benzer şekilde (2,1) konumunun tek komşusu olan (2,2) konumuna gidilerek aşağıdaki durum elde ediliyor:

1111111
2210011
1220011
1101111
1100000
1111111

Yukarıdaki son durumda geldiğimiz konum (2,2) ve birden fazla komşumuzda 0 değer var. Yani (2,2) konumunun komşuları olan (2,3) ve (3,2) değerleri 0 olduğu için bu alternatiflerden birisini takip edeceğiz. İşte bu yol ayrımında yığın (stack) kullanmanın sırası geliyor. Bunun sebebi şu anda vereceğimiz kararın doğru olup olmadığını bilmediğimiz ve basitçe hata yapıyorsak buraya geri dönmek istememiz.

S -> (2,2)

Yukarıdaki şekilde karar noktamızı yığına yerleştirdikten (push) sonra algoritmamızdaki öncelikli yol olan sol tarafı deniyoruz. Sol tarafımızda ((2,2)’nin solunda (2,1) vardır) 0 olmadığı için gidemiyoruz. Algoritmamızdaki ikinci ihtimal olan sağ tarafa bakıyoruz (sağın koordinatı (2,3)) ve bu değer 0 olduğu için bu yönde gidiyoruz.

1111111
2210011
1222011
1101111
1100000
1111111

Sağa gitme işlemine devam ediyoruz (aşağıya gidemediğimiz için) ayrıca burada bir yol ayrımı bulunduğu için (sağa veya yukarıya gidebiliriz) yığının (stack) içerisine yerleştiriyoruz:

S -> (2,2) , (2,3)

1111111
2210011
1222211
1101111
1100000
1111111

Tek alternatif olan yukarıya devam ediyoruz:

1111111
2210211
1222211
1101111
1100000
1111111

Tek alternatif olan sola devam ediyoruz:

1111111
2212211
1222211
1101111
1100000
1111111

Netice itibariyle alternatifi kalmayan (hiçbir yönde 0 olmayan) bir duvar ile karşılaştık ve bu noktadan sonra çıkma ihtimalimiz kalmadığı için yığındaki en üstte bulunan ve en son karar verdiğimiz noktaya dönüyoruz.

Bu nokta (2,3) koordinatlarındadır ve pop edildikten sonra stack aşağıdaki şekildedir:

S – > (2,2)

Pop ettiğimiz (2,3) noktasında da gidilecek hiçbir alternatif bulunmuyor. Mecburen yığındaki (stack) bir sonraki noktaya dönüyoruz:

S -> Boş

Döndüğümüz koordinat (2,3) noktası ve buradaki tek alternatif aşağı yönde bulunan 0 değeri:

1111111
2212211
1222211
1121111
1100000
1111111

Bu aşamadan sonra, hiçbir alternatif kalmadan 0 olan yollar izlenerek sonuca ulaşan yol bulunmuş oluyor.

Kodlama

Yukarıdaki yaklaşımın JAVA dilinde kodlanmış hali yazının sonunda verilmiştir. Bu kodun kısaca açıklamasını bu bölümde anlatacağım. Kodumuzda temel olarak iki sınıf bulunuyor:

• currentInfo
• Maze

currentInfo sınıfı, anlık olarak matrisin hangi konumunda bulunduğumuzu tutmaya yarıyor. Çok basit şekilde satır ve sütün koordinatlarımızı barındırıyor. Ayrıca bu değerlere erişmeyi sağlayan inşa sınıfları (constructors) ve kapsülleme fonksiyonları (encapsulation) bulunuyor.

Maze sınıfı ise geri kalan herşeyi yapan ana sınıfımız. Bu sınıfta getMaze() isimli fonksiyon, dosyadan labirent bilgilerini okumak için kullanılıyor. solveMaze fonksiyonu da labirentteki sonucu bulmaya yarayan yukarıdaki işlemleri çalıştırıyor.

Yukarıdaki anlatımda geçen ve S harfi ile ifade ettiğimiz yığın (stack) ise kodumuzda path ismi ile tanımlanmış java.util.Stack sınıfından tanımlanmış bir yığın. Buradaki yığın, karar verirken atılan her adımı tutmakta. Yani yukarıdaki labirent çözümünde geçen ve 2 olarak işaretlerken, birden fazla 0 ihtimali bulunan dönüm noktalarını tutuyor.

Yığının en temel 3 fonksiyonu ise aşağıdaki şekildedir:

• Pop() yığında bulunan en üstteki değeri alarak bir değişkene döndürür.
• Push() yığının en üstüne, parametre olarak aldığı veriyi yerleştirir.
• Peek() yığının en üstündeki veriyi alır ancak pop fonksiyonunun aksine bu veriyi silmez. Bu fonksiyon bazı kaynaklarda Top() olarak da geçmektedir ancak java.util.Stack sınıfında peek ismi ile tanımlanmıştır.

Kodumuzda kullandığımız iki temel dizi ise aşağıda verilmiştir:

• mazeData[][] iki boyutlu bu dizi, dosyadan okunan ve hafızada labirent bilgisini tutan dizidir.
• Mark[][] diğer iki boyutlu dizimiz ise sonuca giden yolu tutar.

İkinci diziye neden ihtiyaç duyduğumuz sorusunu şu şekilde cevaplayalım. Dizimizi dolaşırken, yanlış yollara sapabiliyoruz, geçtiğimiz her yeri basarsak bu sonuçta görmek istediğimiz çözüm yolu olmayacaktır. Ayrıca labirentte dolaşırken, çözüme giden yolu 2 ile işaretliyoruz ama hatalı yolları da 2 ile işaretliyoruz. Dolayısıyla labirenti dolaştıktan sonra 2 ile işaretli yolları basarsak bu yollarda da sonuca gitmeyen değerlerin basılması söz konusu. Çözüm olarak ayrı bir dizide, sonuca giden yoldaki koordinatları ayrıca tutuyoruz.

Koddaki bazı satırları anlatmamız gerekirse:

Yukarıdaki kod parçasında, bulunduğumuz konumdan (current) sonraki gidebileceğimiz yönleri sırasıyla deniyoruz. İlk if koşulunda mazeData isimli dizide (yani labirentin verilerinin tutulduğu dizi) bulunan ve mevcut konumun bir sağında yer alan (col + 1 işleminin anlamı bir sonraki kolon demektir) değere gidilmesi ve bu değerin daha önce mark dizisinde işaretlenmemiş olması (gidilmemiş olması ) durumu kontrol edilmektedir. Ardından sırasıyla, sol, aşağı ve yukarı yönler için aynı kontroller yapılmaktadır. Yazıda anlatılan sıradan bu anlamda farklıdır.

Yukarıdaki kod parçasında ise, bir önceki kod parçasının devamı niteliğinde, şayet 4 yöndede hareket edilemiyorsa, çıkmaz bir yola girilmiş neticesine varılabilir. Bu durumda mevcut durum dolaşıldı anlamında, 2 ile işaretlendikten sonra, yığından (stack) pop fonksiyonu ile dönülecek en son karar anına bakılıyor.

Şayet yığın bir şekilde boş olursa (ki bu durum try/catch blokları arasında istisna kabz edilerek (exception handling) çözülmüştür) bu durumda labirentin bir çözümü olmadığını söyleyebiliriz çünkü hem bir çıkmaz yol bulduk hem de geriye döneceğimiz hiçbir yol ayrımı bulunmuyor demektir.

Netice itibariyle, 61. Satıra kadar ulaştıysak, bu satırda flag değişkeni true değerinde olup, yukarıdaki 4 iften birisine girerek bir yöne hareket etmiş olabilir. Bu durumda gidilen bu yok, mark dizisinde işaretlerenerek yığına yerleştiriliyor. Ayrıca flag değişkenin false olduğu tek ihtimal olan çıkmaz yol durumunda da if bloğu çalışmıyor.

Yukarıda alıntılıanan kod parçası ise bütün işlemler bitip, labirent bir sonuca ulaşacak şekilde dolaşıldıktan sonra, mark dizisi üzerinden dolaşılan yolu ekrana basmaktadır. Döngü, labirent boyutları olan dim1 ve dim2 sınırlarında dönmekte, her adımdaki konum 71. Satırda ekrana basılmakta ve sonraki konum da 4 farklı koşul konrolü ile işaretlenmiş olan yöne doğru değiştirilmektedir.

Kodun çalışması sonucunda, örnek ekran çıktısı aşağıda verilmiştir:

Görüldüğü üzere labirentteki bütün yolları dolaşarak, sonuca ulaşan yolları ekrana basmıştır(lütfen basma işlemi sırasında, 71. Satırda olduğu üzere önce satır sonra sütun koordinatının basıldığına dikkat ediniz). Bu örnek çalışma, aşağıdaki labirent içindir:

Ayrıca farklı bir dosya içeriği, projenin bulunduğu dizindeki maze.dat dosyasının içerisine yerleştirilerek çalıştırılabilir.

Kodun tamamını netbeans projesi olarak indirmek için tıklayınız.

934 views

158 views

Bu yazının amacı, site üzerinde gelen bir soru üzerine, WEKA programı üzerinde, destekçi vektör makinesinin (SVM) gerçekleştirilmesi ile ilgili bir uygulama anlatmaktır.

WEKA üzerinde genel olarka bir işlem yapmak için aşağıdaki adımlar izlenebilir:

Yukarıdaki adımlara göre, öncelikle, işlenmek için hazır bir veri kümemiz bulunması gerekiyor.

Yazımızdaki amacımız, konuyu öğrenmek olduğu için, WEKA kurulumu ile gelen örnek veri kümelerinden birsini, bu yazı kapsamında kullanacağız.

1. Adım: WEKA’yı açıyoruz:

2. Adım: Önce veri kümemize bir göz atalım. WEKA’nın kurulumu ile birlikte gelen data dizini altındaki, labor.arff dosyasını görmek için, açılan ilk weka ekranında (yukarıdaki resimde temsil edilen), “Experimenter” düğmesine basıyoruz. Açılan ekranda, File / Open seçeneklerini menülerden seçtikten sonra, dosya seçicisinden “labor.arff” dosyasını işaretleyip açıyoruz:

Kullanacağımız örnek veri kümesi yukarıdaki şekildedir. Hızlı bir bakışla, verilerin, çalışan verileri olduğunu ve her çalışanın maaş, çalışma süreleri, sosyal güvenliğine ait bilgilerin yer aldığı bir veri kümesi olduğunu söyleyebiliriz. Şimdiki adımımız bu veri kümesi üzerinden SVM algoritmasını çalıştırmak olacak.

3. Adımda WEKA’nın ilk açılan ana ekranına dönerek, bu sefer “Explorer” düğmesine basıyoruz ve WEKA içerisinde yer alan fonksiyonları kullanacağımız ekran açılıyor.

Yukarıdaki açılan Weka Explorer ekranında bulunan ilk sekme olan Preprocess sekmesinde (ki ilk açıldığında bu sekme açık gelir), bulunan “Open File” düğmesine tıklayarak dosya seçicimizi açıyoruz ve yine Weka’nın kurulumuyla gelen data dizini altında bulunan “labor.arff” dosyasını seçerek açıyoruz.

Ekranda, seçilen bu dosyanın ön işleme sonuçları görülüyor. Buna göre sol taraftaki listede, ilk başta görüntülediğimiz arff dosyasının her bir kolonu yer almakta olup, her kolona tıklandığında, bu kolon ile ilgili veri detayları sağ tarafta çubuk grafik olarak görülmektedir.

4. Adımda WEKA’nın sınıflandırma işlemi için ilgili modülün yüklenmesine geçecegiz. Bu işlem için, ekranın üzerinde bulunan “Classify” sekmesine geçiyoruz.

Sekmeye geçtikten sonra “Choose” düğmesine tıklayarak kullanacağımız modülü seçeceğiz. Burada WEKA içerisinde yüklü olan ve konu ile ilgisi olan 3 ayrı modülden bahsetmekte yarar vardır:

Listede görülen classifiers klasörü altındaki functions elemanlarıdır. Bunların tamamı, sınıflandırma için kullanılan fonksiyonlardır. Tam bu noktada 3 ayrı alternatiften bahsedelim:

SMO

Yani birden fazla kümeye, veriyi bölmeye yarar. Listede bulunan SMO, SVM benzeri bir yapıdadır.

Sequential Minimal Optimisation kelimelerinin baş harflerinden oluşan SMO, esas itibariyle Suppor Vector kullanan bir algoritmadır. Algoritmanın detayı için WEKA dokümantasyonunda da yer alan aşağıdaki makalelere bakılabilir:

• J. Platt: Fast Training of Support Vector Machines using Sequential Minimal Optimization. In B. Schoelkopf and C. Burges and A. Smola, editors, Advances in Kernel Methods – Support Vector Learning, 1998.
• S.S. Keerthi, S.K. Shevade, C. Bhattacharyya, K.R.K. Murthy (2001). Improvements to Platt’s SMO Algorithm for SVM Classifier Design. Neural Computation. 13(3):637-649.
• Trevor Hastie, Robert Tibshirani: Classification by Pairwise Coupling. In: Advances in Neural Information Processing Systems, 1998.

LibSVM

SVM sınıflandırıcısının en önemli kütüphanesi, bir doktora tezi sırasında ortaya çıkmış olan ve libSVM olarak bilinen açık kaynak kodlu kütüphanedir. Bu kütüphane, ne yazık ki WEKA kurulumu ile gelememektedir. Ancak bu kütüphaneyi WEKA altında kullanmanın iki yolu bulunur. İlki, kütüphaneyi WEKA’ya tanıtmaktır. Bunun için, yukarıdaki temsili resmi verilen listede bulunan libSVM kullanılabilir. Öncelikle kütüphane, aşağıdaki adresten indirlmelidir:

http://www.csie.ntu.edu.tw/~cjlin/libsvm/

Ardından weka’nın paket yöneticisi tarafından kurulmalıdır. Wekanın paket yöneticisi ise WEKA’nın classpath tanımının yapıldığı bir konsolda aşağıdaki komutu vererek çalıştırılabilir:

java weka.core.WekaPackageManager

Diğer bir yöntem ise, indirilen libsvm kütüphanesinin WEKA classpath’ine eklenmesidir. İlgili ayarlar yapıldıktan sonra 4. adımda bahsettiğimiz sınıflandırmalardan birisi olarak libSVM kullanılabilir.

LibSVM kullanımı için ikinci bir yöntem ise, LibSVM ve WEKA programlarını, aynı anda içeren wlsvm kütüphanesini kullanmaktır. Bu kütüphaneye de aşağıdaki adresten erişilebilir:

http://www.cs.iastate.edu/~yasser/wlsvm/

SMOreg

SVM ile ilgili, weka içerisinde bulunan 3. bir seçenek de SMOreg seçeneğidir. Bu seçenek, SVM üzerinde Regression (ilkelleme, regrezizasyon) uygulamaya yarayan kütüphanedir. Bu kütüphane için de detaylı bilgi, aşağıdaki kaynaklardan edinilebilir:

• Alex J. Smola, Bernhard Scholkopf (1998). A Tutorial on Support Vector Regression. NeuroCOLT2 Technical Report Series – NC2-TR-1998-030.
  
• S.K. Shevade, S.S. Keerthi, C. Bhattacharyya, K.R.K. Murthy, Improvements to SMO Algorithm for SVM Regression. Technical Report CD-99-16, Control Division Dept of Mechanical and Production Engineering, National University of Singapore.
  

5. Adımda, Yukarıdaki seçeneklerden birisi seçildikten sonra, seçilen modüle göre ayarlama yapılması gerekemektedir. Örneğin SMO kütüphanesi üzerinden ilerleyecek olalalım. Bu modülün parametre ayarlarını, Object Editor ile yapabiliriz. ObjectEditor’ü açmak için ekranda bulunan ve fonksiyonun parametrelerini içeren metin kutusuna tıklamak yeterlidir:

Açılan bu ekranda, ilgili parametre ayarları yapıldıktan sonra, sınıflandırma fonksiyonunun çalışması için, WEKA Explorer ekranında bulunan “Start” düğmesine basmak yeterli olacaktır. Sonuçlar ve sonuçların değerlendirmeleri (hata miktarları gibi), sonuç ekranında görülecektir. Buradaki sonucu etkileyen diğer bir ayar da, kullanım sırasında eğitim ve test için izlenecek stratejidir.

WEKA doğrudan, 4 farklı özellik desteklemektedir. Bunlar sırasıyla aşağıda anlatılmıştır:

Trainin set seçeneği, seçilen verinin sadece eğitim amaçlı kullanılmasını sağlar. Bu seçenekte önce eğitim yapılıp ardından ikinci bir küme, test amaçlı kullanılabilir. Bu seçenek de yine yukarıdaki ekranda bulunan “Supplied test set” seçeneği ile gösterilen küme üzerinde çalışır.

“Cross-validation” seçeneği, veri kümesine belirtilen (folds sayısı olarak belirtilen) sayıda kümeye böler. Alt kümelerden birisini eğitim kümesi olarak kabul ederek sistemi eğitir. Ardından bu eğitim sonucunu diğer bir alt küme üzerinde sınar (ki bu kümeye sınama kümesi (validating set) veya test kümesi (test set) ismi verilir). Bu işlemi belirtilen küme sayısı kadar tekrarlayarak sisemi iyileştirmeye çalışır.

Son seçenek olan “percentage split” ise, verilen oranda kümeyi ikiye böler ve ilk kümeyi eğitim ikinci kümeyi ise test amaçlı kullanır. Örneğin %66 bölümün anlamı, kümenin ilk %66 kısmının eğitim sonraki %34 kısmının ise test amaçlı kullanılacağıdır.

605 views

Veri madenciliğinde kullanılan ve veri kümeleri veya veriler arasındaki ilişkiyi çıkarmak için geliştirilmiş algoritmanın ismidir. Ayrıca pek çok akademik konuda geçen ve temelini felsefeden (ve daha özel olarak mantıktan) alan a priori konusu için bu bağlantıyı tıklayabilirsiniz.

Apriori algoritması, özellikle çok büyük ölçekli veri tabanları (VLDB, very large databases) üzerindeki veri madenciliği (datamining) çalışmalarında geliştirilmiştir. Genel anlamda münasebet kuralı (association rule, birliktelik kuralı) çıkarımında kullanılan bir algoritmadır. Algoritmanın amacı, veri tabanında bulunan satırlar arasındaki bağlantıyı ortaya çıkarmaktır.

Algoritmanın ismi, kendinden önceki çıkarımlara bağlı olduğu için, latince, önce anlamına gelen “prior” kelimesinden gelmektedir.

Algoritma yapı olarak, aşağıdan yukarıya (bottom-up) yaklaşımı kullanmakta olup, her seferinde tek bir elemanı incelemekte ve bu elemanla diğer adaylarla münasebetini ortaya çıkarmaya çalışmaktadır.

Ayrıca algoritmanın her eleman için çalışmasını, bir arama algoritmasına benzetmek mümkündür. Algoritma, bu anlamda sığ öncelikli arama (breadth first search) yapısında olup, sanki adayları birer ağaç (tree) gibi düşünerek bu ağaç üzerinde arıyor kabul edilebilir.

Ağaç yapısında, k elemanlı bir aday listesinden k-1 elemana baktıktan sonra, alt frekans örüntüsü yetersiz olan elemanları budamakta ve kalan elemanların üzerinden arama yapmaya devam etmektedir.

Örnek

Algoritmayı daha iyi anlamak için bir örnek üzeridnen inceleyelim.

Bir firmanın ürünlerink SKU numaraları ile (Stock Keeping Unit, depo numarası), veritabanında tuttuğunu düşünelim. Bu durumda firmanın satılan ürünlerden hangilerinin beraber alındığını bulma şansı olabilir. Örneğin kasada işlem yapıldığında aynı fatura içerisinde yer alan SKU’ların beraber satıldığını kabul edelim.

Örneğin faturaların tutulduğu veri tabanı tablosundaki kayıtlar aşağıdaki şekilde olabilir:

{1,2,3,4},

{1,2},

{2,3,4},

{2,3},

{1,2,4},

{3,4},

{2,4}

Yukarıdaki her faturada, hangi ürünün diğer hangi ürünlerle birlikte satıldığı görülmektedir. Buna göre, örneğin yukarıdaki listedeki ikinci satır, firmanın sattığı ürünlerden 1 ve 2 SKU numarasına sahip ürünleri temsil etmektedir (diyelim ki 1 numaralı ürün kravat ve 2 numaralı ürün gömlek olsun, bu durumda ikinci satır, {1,2} kayıdı ile bize gömlek ve kravatın beraber satıldığını anlatmaktadır)

Apriori algoritmamızın ilk adımı, her ürünün frekansını, yani kaç kere listede geçtiğini saymak olacaktır.

Yukarıdaki tabloda, her ürünün toplam satış sayısı bulunmaktadır. Bu değere frekans veya destek (support) ismi verilmektedir.

Algoritmanın ikinci adımında, asgari destek değerini belirliyoruz. Bu belirleme işlemi, üretilen tabloya göre değişebilmektedir. Yukarıdaki örnek için asgari desteğimiz 3 olsun.

Algoritmanın sıradaki adımı, ürünleri 2′li gruplara ayırmak olacak. Buradaki amaç her elemanın diğer elemanlarla olan münasebetini bulmak. Yukarıdaki tabloda, frekansı düşük olan (daha seyrek olan, sık geçmeyen) elemanları eliyoruz. Bunların sonuç listesinde de yer almayacağını kabul ediyoruz.

Bu defa tablomuzda sadece 2 elamanlı listeleri bulunduruyoruz:

Yukarıdaki tabloda bulunan değerleri listelerdeki çiftlerden çıkmıştır. Örneğin {1,2} değeri, 3 yerde geçmektedir ve bunlar:

{1,2,3,4},

{1,2},

{1,2,4},

Listeleridir ( veya senaryomuz gereği faturalar olarak düşünülebilir). Dolayısıyla {1,2} ikilisi için 3 frekansı hesaplanmış olur.

Yukarıdaki listenin devamında 3 elemanlı listelerin tablosu da çıkarılabilir ancak ne yazık ki 3 veya 4 elamanlı liste örneğimizde çıkarılamamaktadır. Bunun sebebi asgari destek değerimizi 3 kabul etmiş olmamızdır. Örneğin {1,2,4} şeklindeki faturayı ele alalım. Bu değer sadece 2 yerde geçmektedir:

{1,2,3,4},

{1,2,4},

Ve dolayısıyla frekans değeri (destek değeri) 2 olmaktadır. Bu destek değeri, asgari destekten küçük olduğu için kabul edilmemektedir.

Algoritma

Konu üzerindeki ilk yayını yapan Agrawal ve Srikat, tarafınan algoritmanın müsvette kodu (pseudo code) aşağıdaki şekilde verilmiştir.

L₁ = {sık tekrarlanan öğeleri içeren küme}

for(k=2; L _k-1 != 0 ; k++){

C_k = apriori-üret (L _k-1);

forall (işlemler t ÎD){

C_t  ⊂ (C_k,t);

forall adaylar c ∈ C_t{

c.sayaç++;

}

}

L_k={ c ∈C_k | c.sayaç = enküçük }

}

Sonuç = U_k L_k;

Algoritmayı açıklayacak olursak, algoritmadaki L, veri tabanı veya veri kümemizde bulunan öğeleri temsil etmektedir. Apriori üret fonksiyonundan üretilen her bir C_k kümesi için, t bir işlem (transaction) olmak üzere, üretilen bu Ck kümesinin t işlemini tutan sayacı, her münasebette bir arttırıyoruz. Ardından sıradaki L değerini alarak algoritmamız çalışmaya devam ediyor. Sonuç olarak da üretilen bu L değerlerinin birleşim kümesini döndürüyoruz.

Yukarıdaki algoritmada belirsiz olan apriori-üret fonksiyonunu ise aşağıdaki şekilde verebiliriz:

C_k‘ya ekle

select p.eleman₁, p.eleman₂, … p.eleman _k-1, q.eleman _k-1

for(L _k-1 p’den L _k-1 q’ya kadar)

where p.eleman₁, p.eleman₂, … p.eleman _k-2 = q.eleman _{k-2 ,} p.eleman _k-1 < q.eleman _k-1

forall elemanlar c ∈C_k {

forall c’nin (k-1)-alt kümesi s için{

if( s ∉L _k-1 ){

c’yi C_k ‘dan sil

}

}

}

Yukarıdaki algoritma, basitçe bütün adayların üretilerek elemanların aday kümelerine konulmasını hedeflemektedir.

302 views

Yazan : Şadi Evren ŞEKER

Bu yazının amacı, hırsız oyunu (game of nim) isimli oyun üzerinden asgari-azami ağaçları (minimax trees) açıklamaktır. Öncelikle oyunu kısaca anlatalım.

Oyun iki kişi tarafından karşılıklı olarak sırayla oynanmaktadır. Oyun sayılabilir varlıklar üzerinden oynanır. Örneğin boncuk, çubuk, kalem gibi sayılabilir varlıklar oyun için kullanışlıdır. Bu yazı boyunca çubuk kullanıldığını düşünerek konuyu izah edelim.

Başlangıçta n miktarda çubuk ile oyuna başlanır. Bu n sayısı imkanlar dahilinde değişmekle birlikte mümkünse asal sayı almak daha iyidir ki taraflardan birisi hızlı bir hesaplama ile hile yapamasın

Bu örnekte 7 olarak kabul edelim.

Oyuna 7 adet çubuk ile başlıyoruz. Sıra kendisinde olan taraf çubukları iki gruba ayırıyor. Grupların büyüklüğüne kendisi karar veriyor. Örneğin 7 çubuğu, 1+6, 2+5, 3+4 şeklinde gruplara ayırabilir.

Ardından sıra diğer oyuncuya geçiyor ve bu oyuncu da gruplardan istediğini iki gruba bölüyor ve oyun böylelikle sürüp gidiyor. En sonunda taraflardan birisi artık iki gruba ayıramayacak hale gelince oyunu diğer taraf kazanmış oluyor. Oyunda gruplara ayırma sırasında bir de istisna bulunuyor. Buna göre eşit sayıda iki gruba bölemiyoruz. Örneğin 6 çubuk olması halinde 3+3 şeklinde iki gruba bölmek yasak. Dolayısıyla 2 çubuk kalması halinde oyun bitiyor çünkü oyuncu 1+1 şeklinde bölemez.

Oyunun örnek hamle ağacını aşağıdaki şekilde çizebiliriz:

Yukarıdaki ağaçta görüldüğü üzere, oyun 7 adet çubuk ile başlamış ve bütün ihtimaller ağaçta gösterilmiştir. Ağaçta görüldüğü üzere oyunun 3 farklı bitiş koşulu bulunmaktadır. Bu bitişler aşağıdaki şekilde işaretlenmiştir:

Bitişler, aynı zamanda kazananı da belirlemektedir. Yukarıdaki bu ağaç üzerinde asgari-azami ağacı işaretleyecek olursak, aşağıdaki şekli elde ederiz:

Yukarıdaki şekilde, ağaçta gösterilen değerler, hamlelere karar verme sırasında kullanılmaktadır. Örneğin yukarıdaki şekle bakıldığında her durumda 1 sonucuna ulaşılabilecek hamleler yapılacağı görülmektedir. Diğer bir deyişle 1 sonucu, bizim kazanma durumumuzu göstermekte ve %100 ihtimal ile oyunu kazanmaktayız.

İlk hamleyi Rakip oyuncu yapıyor ve ilk hamlede bütün ihtimaller üzerinde 1 değeri olduğu için ne oynadığının hiç önemi yok. Diyelim ki 5+2 ihtimalini oynadı. Bu durumda mecburen 5 grubunu böleceğiz (2 grubunu bölemez çünkü bölmesi halinde iki eşit grup oluşacaktır). 5 grubunu ise iki farklı şekilde bölünebilir: 4+1 veya 3+2.

Bu hamlelerden bizim için karlı olanı, 4+2 şeklinde bölmek çünkü bu hamle bize oyunu kazandıracak (3+2+2 kolunda 0 değeri olduğuna dikkat ediniz)

Sıra tekrar rakibe geçince yapabileceği tek hamle 4+2+2 grubundaki 4 değerini 3+1 şeklinde bölmek olacaktır.

Biz ise son hamleyi yapıp 3 grubunu 2+1 olarak bölüyor ve oyunu kazanıyoruz.

Yukarıda görüldüğü üzere oyunun bütün hamlelerini minimax ağacı üzerinde hesaplayarak bir sonuca eriştik ve oyunu kesin olarak kazanacağımızı biliyoruz. Ayrıca yukarıdaki ağaçta dinamik programlama (dynamic programming) kullanılmıştır. Yani, örneğin 4+2+1 sonucuna iki farklı yerden ulaşılabilmektedir. (6+1 veya 5+2′den) Ağaçta bu değerler ayrı ayrı gösterilmek yerine tek bir düğümde gösterilmiştir. Bu sayede ağacın karmaşıklığı indirgenmiştir.

Yukarıdaki oyunun minimax ağacını daha da verimli hale getirebiliriz. Bunun için alfa beta budaması (alfa beta prunning) kullanmayı deneyelim. Konu hakkında bilgisi olmayanlar ilgili yazıyı, linke tıklayarak okuyabilirler.

Yukarıdaki ağaçta, iki dal budanmıştır. Bunun sebebi, ağacın dolaşılması sırasında, azami değerin alınacağı seviyede 1 değerine ulaşılmış olması ve sonrasında gelen değerlerin bir önemi olmamasıdır. Örneğin 5+2 düğümüne, 1 değeri 4+2+1 düğümünden taşındıktan sonra diğer koldan ne geldiğinin artık bir önemi yoktur çünkü azami değere ulaşılmıştır. Bu sayede bazı kolların altındaki değerlerin hesaplanmasına gerek kalmadan sonuca daha hızlı bir şekilde ulaşılmış olunur.

615 views