Yapay Sinir Ağları Nedir

Yapay Sinir Ağları Hakkında özet bilgiler

Fann Nedir

Fast Artifical Neural Networks Kütüphanesi hakkında

FannTool

Nedir Ne işe yarar Nasıl Kullanırız

What are Artificial Neural Networks ?

short info about Artificial Neural Networks

What is FANN ?

about Fast Artifical Neural Networks library

FannTool

What is and How to use

13 Kasım 2012 Salı

Yapay Sinir Ağları ile Koroner Arter Hastalığı Risk Hesaplama


Kırıkkale Üniversitesi - Bilgisayar Mühendisliği Bölümü
Yapay Sinir Ağları Final Projesi
Sinem Özder

Bu çalışmada amaç, bir hastadan alınan input seti ile hastada 10 yıl içinde Koroner Arter hastalığı görülme olasılığının tahmin edilmesidir

Proje için şekildeki gibi bir YSA dizayn edilmiştir.
Giriş değerleri ;
• Cinsiyet
• Yaş
• LDL Kolesterol
• HDL Kolesterol
• Diyastolik Kan Basıncı
• Sistolik Basıncı
• Diyabet
• Sigara
Çıkış değeri;
• KAH Riski
Yazıyı İndirmek için ;  KAH-Risk 

FANN Kütüphanesinin Kullanımı


FANN yani Fast Artificial Neural Network Library Bir Yapay Sinir Ağı (YSA) Kütüphanesi.
YSA nın ne olduğunu bildiğinizi varsayıp. Basitçe kullanımını anlatmak istiyorum.
1) YSA oluşturulur
2) YSA Eğitilir
3) YSA Çalıştırılır.
4) YSA yı Tekrar Kullanama

1) Öncelikle Bir YSA oluşturmamız lazım
Kullanabileceğimiz Fonksiyonlardan biri fann_create_standard

struct fann *FANN_API fann_create_standard( unsigned int num_layers, ... )

YSA nın kaç katmandan oluştuğunu yazıp - num_layers -
Sırayla Giriş, Gizli Katman - yada Katmanlar - Çıkış Katmanlarının kaç birimden oluştuğunu yazıyoruz

Mesela :

5 giriş 2 çıkışlı Tek ve 7 birimlik Gizli Katmanlı bir YSA oluşturmak için

struct fann *ann = fann_create_standard(3, 5, 7, 2);

5 giriş 2 çıkışlı , 7 ve 3 birimlik olmak üzere 2 Gizli Katmanlı bir YSA oluşturmak için

struct fann *ann = fann_create_standard(4, 5, 7,3, 2);

ann işaretçisi artık bizim oluşturduğumuz YSA yı gösteriyor


2) YSA Eğitimi için Kullanabileceğimiz Fonksiyonlardan biri fann_train_on_file

void FANN_API fann_train_on_file(
struct fann * ann, // fann_create_standard ile almıştıkconst char * filename, // Veri Dosyaunsigned int max_epochs,unsigned int epochs_between_reports,
float desired_error
)
ann : fann_create_standard ile aldığımız bizim YSA mızı gösteren işaretçi
filename : Eğitim için kullanacağımız Veri Dosyasının adı
max_epochs : Eğitimin çalışacağı maksimum adım Sayısı
epochs_between_reports : Kaç Adımda bir Rapor verilmesi isteniyor
desired_error : Eğitim sonunda arzulanan hata miktarı

Bu fonksiyonu çağrılınca İsmini belirttiğimiz Dosyadan veriler alınır ve Hata miktarı istenen değere yada maksimum adım sayısına ulaşana kadar YSA eğitime tabi tutulur. Arada belirttiğimiz adımda rapor verilir. Eğer istenen hata değerine ulaşılamazsa eğitim başarısız olmuş olur.

Veri Dosyasının yapısı : Veri Dosyası dediğimiz şey Giriş ve çıkış değerlerinin bulunduğu basit bir text dosyasıdır.
Örnek Sayısı(N) Giriş(K) Çıkış (J)
G11 G12 G13 ...G1K
Ç11 Ç12 Ç13...Ç1J
G21 G22 G23 ...G2K
Ç21 Ç22 Ç23...Ç2J
....
GN1 GN2 GN3 ...GNK
ÇN1 ÇN2 ÇN3...ÇNJ

Mesela 3 Giriş 1 Çıkışlık 2 Örnekli bir veri dosyası

2 3 1
1 1 1
0
1 0 1
1

Eğitim öncesi Aktivasyon Fonksiyonlarını Ayarlamak istiyorsanız

fann_set_activation_function_hidden(
struct fann * ann,
enum fann_activationfunc_enum activation_function
)

fann_set_activation_function_output(
struct fann * ann,
enum fann_activationfunc_enum activation_function
)

Mesela
fann_set_activation_function_hidden(ann, FANN_SIGMOID);
fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC);
gibi

Kendi rapor Fonksiyonumuzuda tanımlayabiliriz
void fann_set_callback( struct fann * ann, fann_callback_type callback )
Mesela 

int FANN_API my_report(struct fann *ann, struct fann_train_data *train,
unsigned int max_epochs, unsigned int epochs_between_reports,
float desired_error, unsigned int epochs)
{ 
printf("Adım %8d. MSE: %.5f. Desired-MSE: %.5f\n", epochs, fann_get_MSE(ann),desired_error);return 0;
 }

fann_set_callback( ann, my_report );




Eğer Dinamik bir eğitme süreci gerekmiyorsa, Eğitim ve Parametre ayarlarını kolayca FannTool ile yapabilirsiz

3) Artık Eğitimini tamamladığımız YSA yı çalıştırabiliriz. YSA'nın çalışması demek Giriş değerleri verilerek sonuçta elde edilen çıkış değerlerini almak demektir
Bu iş için kullanacağımız fonksiyon fann_run

fann_type * FANN_API fann_run( struct fann * ann, fann_type * input )

Yani YSA'yı giriş değerlerini içeren bir dizinin adresini gönderiyoruz.

Mesela 3 giriş 2 çıkışlı bir YSA için

fann_type *sonuc;
fann_type input[3]={1,1,0}; // giriş değerleri
sonuc = fann_run(ann, input);
printf("Çıkış Değerelri %f %f \n", sonuc[0], sonuc[1] );

4) YSA yı her kullandığımızda yukardekileri tekrar tekrar yapmamıza gerek yok. YSA eğitildikten sonra Kaydedip. Kullanacağımız zaman bu kayıttan yeniden YSA yı oluşturabiliriz.
Kaydetmek için fann_save Kullanımı çok basit

int fann_save( struct fann * ann, const char *FileName )

FileName kısmına bir Dosya ismi girip kaydediyoruz. Kayıt Geri dönüş değerine göre 0 ise başarılı -1 ise başarısız.

Kaydettiğimiz YSA yı tekrar yüklemek için fann_create_from_file fonksiyonu kullanılır.

struct fann * fann_create_from_file(const char *FileName)

Fonksiyon Kaydedilmiş Dosya ismiyle çağrılır.

Eğer YSA ile işimiz bittiyse fann_destroy kullanılarak hafızada YSA için kullandığımız alanlar boşaltılır.

void fann_destroy( struct fann * ann )

Mesela : YSA için İlk üç adımı yaptık kaydediyoruz

fann_save(ann, "YSA.net");
fann_destroy(ann);

Tekrar çağırıyoruz

fann_create_from_file("YSA.net");

 5) Test Etmek : Eğittiğimiz YSA yı test etmek gerekmektedir Eğitim için kullandığımız verinin % 10 - 30 arasındaki bir miktarda veriyle YSA test edilir ve Hata faktörüne bakılır. Öncelikle aynı Eğitim verisi için kullandığımız dosya yapısında bir dosya hazırlanır ve fann_read_train_from_file fonksiyonuyla yüklenir. Bundan sonra tek yapacağınız fann_test_data fonksiyonunu çağırmak. işi bitincede fann_destroy_train ile hafızdaki yerleri boşaltmak

Mesela :
struct fann_train_data *dt;
dt=fann_read_train_from_file("test.dat");
ann=fann_create_from_file("aproje.net");
fann_reset_MSE(ann);
fann_test_data(ann,dt);
printf("\n Test Sonucu MSE : %f \n\n", fann_get_MSE(ann) );
fann_destroy_train(dt);

MSE (Mean Square Error) dediğimiz şey ortalama karesel hata yani bizim YSA mız yaptığı - Eğitim yada Test - işte istenenle hesaplanan değerler arasındaki - Hata - farklarının karelerinin ortalaması gibi birşey

void fann_reset_MSE(struct fann *ann)
MSE değerini sıfırlar

float FANN_API fann_get_MSE(struct fann *ann)
MSE değerini okur


6) Diğer Faydalı Fonksiyonlar

Eğitim Algoritmalarını ayarlayanlar

enum fann_train_enum fann_get_training_algorithm(struct fann *ann)
Kullanılan Eğitim metodunu okur

void fann_set_training_algorithm(struct fann *ann,enum fann_train_enum training_algorithm)
* Eğitim metadunu değiştirir.

Eğitim metodları ise  
FANN_TRAIN_INCREMENTAL, 
FANN_TRAIN_BATCH, 
FANN_TRAIN_RPROP, 
FANN_TRAIN_QUICKPROP 
olarak 4 çeşittir. Metodların detayı için kitaplara yada google müracaat edilsin

* Öğrenme hızını ayarlayanlar


float fann_get_learning_rate(struct fann *ann)
kullanılan öğrenme hızını döndürür.

void fann_set_learning_rate(struct fann *ann, float learning_rate)
Öğrenme hızını ayarlar. Öğrenme hızı için geçerli Normal Değer 0.7
Bu fonkisyonları FANN_TRAIN_RPROP metodu için kullanamıyoruz

* Aktivasyon Fonksiyonlarını Ayarlayanlar
Daha önce geçmişti
Gizli katman için
fann_set_activation_function_hidden(
struct fann * ann,
enum fann_activationfunc_enum activation_function
)
Çıkış katamanı için
fann_set_activation_function_output(
struct fann * ann,
enum fann_activationfunc_enum activation_function
)

kullanılır
Aktivasyon fonksiyonlarıda ;  
FANN_LINEAR,
FANN_THRESHOLD,
FANN_THRESHOLD_SYMMETRIC,
FANN_SIGMOID, 
FANN_SIGMOID_STEPWISE, 
FANN_SIGMOID_SYMMETRIC, 
FANN_GAUSSIAN, 
 FANN_GAUSSIAN_SYMMETRIC, 
FANN_ELLIOT, 
FANN_ELLIOT_SYMMETRIC, 
FANN_LINEAR_PIECE, 
FANN_LINEAR_PIECE_SYMMETRIC 

gibi pek çok çeşit var detayı için bakınız


Uygulama 

 Güneş lekeleri

Güneş lekeleri , Güneş'in yüzeyinde (ışık yuvarda), çevresine oranla daha düşük sıcaklığa sahip olan, ve mıknatıssal etkinliğin gözlemlendiği bölgelerdir. Her ne kadar 4000-4500 K sıcaklık ile son derece parlak olsalar da, çevrelerinin 5778 K'de olması, karanlık bölgeler olarak görüldüklerinden bu ismi alırlar.
Neyse işte insanların işi gücü yok bu lekeleri sayıp kaydını tutmuşlar.Biz de bu verileri kullanacağız.

Öncelikle Neural networks for financial time series prediction isimli dosyaya bir göz atın. O yazıda detaylarıyla anlatıldığı gibi Verileri aldığımız haliyle kullanmayız, ön işlemeden geçirmeliyiz. ( 3.4 Design of ANNs in finance kısmı )

Güneş lekelerinin (2006 - 1980) aralığında aylık ortamalarını raw.dat isimli dosyaya her satır 1 değer olarak kaydedildi. Öncelikle verileri YSA da kullanabilmek için - Kullandığınız aktivasyon fonksiyonuna göre - (0 , 1) yada ( -1 , 1 ) değerleri arasına çekiyoruz Normalizasyon. Bir ay sonraki ortalama güneş lekesi sayısını bulmak için önceki 24 ayın değerleri kullanılıyor. 2 adet gizli katman kullanılıyor yani YSA mızın yapısı girişten çıkışa doğru
24 -> 16 -> 7 -> 1

şeklinde oluyor. Peki Bu değerleri Nasıl belirliyoruz ? derseniz Net bir cevabı yok.* Genellikle Giriş ve çıkış düğüm sayısı bellidir. Saklı katman yada katmanlardaki düğüm sayıları YSA nın eğitim performansına göre seçilir.

Programımız
LoadRawData("raw.dat");
Normalize();
WriteTrainData(24,1,"sunspot.dat");
Train();
Test();
Run();

dan ibaret
Açıklamalarına gelince
  • LoadRawData : Ham verileri ismi verilen - Veri dosyasında Her satır 1 veri içeriyor- text dosyasından okuyup data dizisine aktarıyor
  • Normalize : Diziye atılmış verileri -0.8 ile 0.8 arsına çekerek Normalize ediyor
  • WriteTrainData : Normalize edilmiş verileri alıp FANN kütüphanesinin kullanabileceği veri dosyası olarak kaydediyor
  • Train : YSA yı Eğitiyor.
  • Test : test.dat dosyasındaki verileri kullanarak Eğitilmiş YSA'yı test edip sonuçta ulaşılan Hatadeğerini bildiriyor
  • Run : Verilerimizden Rasgele 10 adedini kullanarak YSA çalıştırılıyor ve YSA nın hesapladığı ve gerçek değeri birlikte gösteriyor
Şimdi gelelim benim yapmadığım fakat aslında yapılması gereken şeylerden bazılarına

1) Veri sayısı yeterince büyük olması lazım
2) Bu veriler Eğitim, Test ve Kontrol için 3 parçaya ayrılıp her işlem için kendine ayrılan veri kulanılması lazım.


Sonuçta yazılan projeyi indirmek için : SunSpot

* bakınız NN_FAQ Bu YSA için yazılmış Sıkça Sorulan Soruları İndirmenizi ve incelemenizde tavsiye ediyorum FAQ.

10 Kasım 2012 Cumartesi

Diagnosis of Coronary Artery Disease Using ANN / YSA ile Koroner Arter Hastalığı Tanısı

Veri Setini University California Irvine nin ilgili sayfasından
http://archive.ics.uci.edu/ml/datasets/Heart+Disease
indirdik. Bu sayfadaki verilerden biz "Cleveland Clinic Foundation" tarafından oluşturulanları kullandık.
Bu syafada görebileceğiniz gibi bu verilerle pek çok çalışma yapılmıştır

Bizde YSA ile bir çalışma yapalım istedik.
YSA ya bir şeyler öğretebilmek için eğitim gerekli, Eğitim içinse veri.

Sınıflandırma yapmamız için etkili olan faktörler tespit edilir - Giriş değişkenleri -
Sonuçta bu faktörlere göre bir sınıflara ulaşırız -Çıkış değerleri - 
İşte Bu giriş ve çıkış değerleri YSA nın giriş ve çıkış değerleri oluyor.

Peki YSA verileri doğrudan verebilirmiyiz ?
Malesef veremeyiz.
YSA da katmanlar arasında veri iletişimi bir çeşit aktivasyon fonksiyonundan geçerek sağlanır. Bu fonksiyonlarda tipine göre (0 , - 1 ) yada (-1 , 1) aralığında sonuçlar verir. Bu durumda bizim verilerinizi bu aralıklara çekmemiz lazım.

Peki Bu normalizasyon işlemini nasıl yapacağız.
Değişkenin en küçük (min) ve en büyük (max) değerleri tespit edilir ve bir aralık hesaplanır
range = max-min
Biz bu uygulamamızda ( 0 - 1) aralığını kullandığımızdan normalizasyon formülümüz şöyle oluyor.
Norm(x)= (x-min)/range
ufak bir tavsiyede bulanayım değişkenin veri kümesinden tespit ettiğimiz min max değerlerini aralığı hafifçe açacak şekilde genişletirseniz daha iyi olur.

Giriş değişkeni eğer mantıksal bir değişkense, (doğru-yanlış) gibi sadece iki değeri içeriyorsa normalizasyonu gayet kolay değerin biri 0 diğeri 1 olarak seçilir.

Peki değişken eğer sayısal değilse ne yapacağız mesela bizim örneğimizde "chest pain type"
göğüs ağrısı tipi diye bir değişken var ve bu değişken {angina, abnang, notang, asympt} gibi 4
değişik kategoriden oluşuyor. Bu durumda yapacağımız şey bu tip değişkenleri mantıksal değişkenlere bölmek
yani chest pain type değişkenini 4 adet mantıksal alana yayıyoruz
eğer ağrı tipi
angina ise 1 0 0 0 
yok 
notang ise 0 0 1 0 gibi.
Şimdi gelelim verilerimize verilerin aslı aşağıdaki gibi bir matriste tutuluyor

60, male, asympt, 140, 293, fal, hyp, 170, fal, 1.2, flat, 2, rev, sick.
37, male, notang, 130, 250, fal, norm, 187, fal, 3.5, down, 0, norm, buff.
64, male, angina, 110, 211, fal, hyp, 144, true, 1.8, flat, 0, norm, buff.

bu matriste 14 sütün var ilk 13 ü giriş değişkenleri son sütün çıkış değişkeni. fakat biz bu
değişkenleri YSA ya aktarabilmek için normalize ederken sütün sayımız 25 e çıkıyor nasıl mı oluyor bakınız


ANN Dizaynı

| Inputs
| ------------------------
| -- 1. age : 1 sütun
| -- 2. sex : 1 sütun
| -- 3. chest pain type (4 values) : 4 sütun
| -- 4. resting blood pressure : 1 sütun
| -- 5. serum cholestoral in mg/dl : 1 sütun
| -- 6. fasting blood sugar > 120 mg/dl : 1 sütun
| -- 7. resting electrocardiographic results (values 0,1,2) : 3 sütun
| -- 8. maximum heart rate achieved : 1 sütun
| -- 9. exercise induced angina : 1 sütun
| -- 10. oldpeak = ST depression induced by exercise relative to rest : 1 sütun
| -- 11. the slope of the peak exercise ST segment : 3 sütun
| -- 12. number of major vessels (0-3) colored by flourosopy : 4 sütun
| -- 13. thal: ( normal, fixed defect,reversable defect) : 3 sütun
25 giriş

| Outputs
| ------------------------
| Absence (1) or presence (2) of heart disease 1 sütun

1 Çıkış

evet Elimizdeki 180 adet veriyi  normalize ettiktten sonra ikiye ayırıyoruz.
155 adedi eğitim için 25 adedi test için. ve verileri FANN kütüphanesinin standartına uygun olarak kaydediyoruz.

Bundan sonrasını FannTool'u kullanarak yapacağız. FannTool'u çalıştırın ve Eğitim için Training
Data File olaraka "heart_train_data.dat" yükleyin, Test içinde  "heart_test_data.dat" 'ı yükleyin.

Artık Keyfinize ve tecrübelerinize göre eğitim denemelerinini yapabilrsiniz.

ilk etapta saklı katman sayısı (# of Layer)
ve bu katmanlardaki hücre sayılarını (Hid Layer 1 ...) ayarlaya bilirsiniz.
İsterseniz Eğitim metodunu (Detect Optimum Training Algorithm)
ve Aktivasyon foksiyonlarını (Detect Optimum Activation Functions )
sizin için seçmesini istiyebilirsiniz.
Ezberci bir eğitime düşmemek için   ( Overtraining Caution System ) seçeneğini açıp eğitim esnasında test verilerinin hata durumlarını takip edebilirsiniz.
Artık Train -> Normal diyerek YSA eğitimini başlata bilirsiniz. Eğer Belirlediğiniz hata değerine yada altına ulaşıldığında Eğitilmiş YSA yı kaydetmek için sizden bir dosya ismi istenir. Bir isim verip kaydedin .net uzantılı olarak kaydetmeniniz iyi olur.

Eğitimin bir diğer metoduda Train->Cascade dir bu metodda YSA nın Saklı katmanlarını kendisi dinamik olarak belirler. Siz sadece kullanabileceği maksimum hücre sayısını belirtebilirsiniz. Bu değeri de FannTool Saklı katmanlardaki hücre sayılarını giriş ve çıkış hücre sayılarına ekleyerek hesaplar.
Ulaştığımız sonuçlar şöyle

Eğitim verileri İçin % 91.61  ( 142 Doğru 13 Yanlış )
Test Verileri İçin % 92 ( 23 Doğru 2 Yanlış )

 Eğitimizi tamamlayıp testimizi yaptık ve sonucunda tatminkar hata değerine ulaştık. Bütün bunlardan sonrayapılacak şey  bir arabirim yazmaktır. 
Onuda yazdık, İndirmek ( Download ) için : Hearth
Program Tanı için gereken verileri alıp Eğitilmiş YSA ya verileri verip sonucu ondan istiyor ve size gösteriyor. yani kısaca  Koroner Arter Hastalığı Tanısı işlemini gerçekleştiriyor.

6 Kasım 2012 Salı

FANN – neural networks made easy

Author : Swizec
Source : FANN – neural networks made easy

Over the weekend I was struck with the realization that I don’t know how to use neural networks in practice, damn it. Even though a few months ago I realized what neural networks are, even though I’ve tried implementing them, even though I’ve used them in a class setting …
How the hell do you use these things in real life!?
Implement from scratch? … no that can’t be it.
Find a library, write some code, run some tests, fiddle with features, run a test, fiddle with features, realize everything is slow, decide to use more layers, fiddle with features, play around with activation functions, run a test, fiddle with features, rewrite the code because it’s a mess, fiddle with features, run a test, run the network, run more tests and so on and on ad nauseum.
That can’t be it either …

FANN

Looking far and wide for a good library to use I stumbled upon FANN – Fast Artificial Neural Networks.
Fast Artificial Neural Network Library is a free open source neural network library, which implements multilayer artificial neural networks in C with support for both fully connected and sparsely connected networks. Cross-platform execution in both fixed and floating point are supported. It includes a framework for easy handling of training data sets. It is easy to use, versatile, well documented, and fast. Bindings to more than 15 programming languages are available. An easy to read introduction article and a reference manual accompanies the library with examples and recommendations on how to use the library. Several graphical user interfaces are also available for the library.
Perfect!
Not only has someone gone to the trouble of implementing everything and making sure it works – nothing sucks more than figuring out whether you’re using your learning software wrong or it’s just buggy – they even gave it all the fiddly features I need!
It gets better! There’s a slew of graphical interfaces -> You get to play with the fiddly bits without even knowing what you’re doing! Yes!
Put the data in the fann format, load it up, and away you go. Playing around until you figure out what you’re looking for, then you can just implement the same thing with the FANN binding of your choice.












It can suggest a good training algo














You get to set up the neural network











Fiddly bits!



Watch it converge in real time

Done in a few hours

FANN really saved my skin last night. At least the GUI did. I still haven’t solved my problem – trying to predict how many people will read a whole post – but it took me literally a couple of minutes to realize that the same network can’t be used to predict two outputs since it won’t even converge.
That’s something very specific to the problem.
I also realized the networks were overfitting my data, then performing poorly on the test.
Another specific thing.
It is because of this incredibly problem-specific nature of most work involving neural networks that having tools like these is really important. Who wants to fiddle around with implementing all this stuff by hand for several hours before even running the first tests?
I probably ran twenty or thirty different configurations in the space of three hours last night. Could I have done that without a simple tool? Probably not – wouldn’t even have the first configuration implemented by now.
Now if only the GUI tool calculated precision and recall instead of mean standard error …

5 Kasım 2012 Pazartesi

Rapport de Projet VidéoBuzz

 Rapport de Projet Master -Université d'Avignon

Description

Les sites d'hébergement de vidéos déposées par les utilisateurs ont connu un très fort développement ces dernières années. Certaines de ces vidéos ont été consulté par des milliers d'internautes, d'autres restent archivées sans qu'elles soient significativement visionnées. Ce projet consiste à développer un système de prédiction de la fréquentation à court terme d'une vidéo. Cette prédiction pourra utiliser 2 indices complémentaires :
- à partir d'un historique de la fréquentation d'une sur une période donnée (par exemple de 2 jours), on pourra utiliser un système prédictif (par exemple un réseau de neurones) pour faire une estimation de la fréquentation future,
- les utilisateurs ajoutent souvent des méta-données (des tags) aux vidéos déposées. Ces informations et le titre de la vidéo peuvent donner une indication sur le buzz potentiellement généré par une vidéo.

Outre les propositions de méthodes et leur évaluation objectives, le projet consiste à développer une application Web permettant de visualiser les prédictions réalisées.

Fanntool ; 

 

FannTool est un logiciel multi-plateforme développé en C qui fournit un ensemble d’outils permettant l’utilisation de la librairie FANN. FANN ( pour Fast Artificial Neural Network ) est une librairie open-source de réseaux de neurones qui permet à la fois l'entraînement du réseau neuronal et ensuite l’utilisation de celui-ci.
Il faut lui fournir en entrer un fichier respectant ce format:

3 Kasım 2012 Cumartesi

Handwritten Digit Recognition

Handwritten digits recognition is a classic problem of machine learning. The objective is to recognize images of single handwritten digits(0- 9). in This example We will apply FANN and FANNTool on this problem. Semeion Handwritten Digit Data Set is used for training and testing.

1593 handwritten digits from around 80 persons were scanned, stretched in a rectangular box 16x16 in a gray scale of 256 values.Then each pixel of each image was scaled into a boolean (1/0) value using a fixed threshold. This data set contains no missing values. Each person wrote on a paper all the
digits from 0 to 9, twice. The commitment was to write the digit the first time in the normal way


and the second time in a fast way



This data set consists of 1593 records (rows) and 256 attributes (columns). Each record represents a handwritten digit, originally scanned with a resolution of 256 grays scale. Each pixel of the each original scanned image was first stretched, and after scaled between 0 and 1 (setting to 0 every pixel
whose value was under the value 127 of the grey scale (127 included) and setting to 1 each pixel whose original value in the grey scale was over 127). Finally, each binary image was scaled again into a 16x16 square box (the final 256 binary attributes).

 Firstly We train a ANN for this Data set by using FannTool. After that we write a demonstration program to show a results.

Reached ANN prediction Succes ;
For Training Data : %100 Succes
For Testing Data   :  % 90.1 Succes