2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Yapay Zeka, Makine öğrenmesi ve Veri Bilimi
Kursu
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Sı ı ı
2024-04-02 13:01:04 +03:00
Eğitmen: Kaan ASLAN
Bu notlar Kaan ASLAN tarafı ı ı ı
(Notları
2024-10-03 14:16:20 +03:00
Son Güncelleme: 03/10/2024 - Perşembe
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
1. Ders - 23/12/2024 - Pazar
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
Katı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2. Ders - 24/12/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Python Programlama Dilinin gözden geçirilmesine başlandı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
3. Ders - 06/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Python Programlama Dilinin gözden geçirilmesine devam edildi.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
4. Ders - 07/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Python Programlama Dilinin gözden geçirilmesine devam edildi.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
5. Ders - 13/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Python Programlama Dilinin gözden geçirilmesine devam edildi.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
6. Ders - 14/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Python Programlama Dilinin gözden geçirilmesine devam edildi.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
7. Ders - 20/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
NumPy kütüphanesinin gözden geçirilmesine başlandı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
8. Ders - 21/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
NumPy kütüphanesinin gözden geçirilmesine devam edildi ve Pandas kütüphanesinin gözden geçirilmesine başlandı
kütüphanesi gözden geçirildi.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
9. Ders - 27/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Kursumuzun ilk bölümünde zeka, yapay zeka, öğrenme, makine öğrenmesi ve veri bilimi kavramları ı
2024-04-02 13:01:04 +03:00
açı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Zeka kapsamı ı ı ı ı ı ı ı
ve nörobilimciler arası ı ı ı ı ı ı
çeşitli tanı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
çeşitli araçlar da geliştirmeye çalı ı ı
Charles Spearman zekayı ı ı ı ı
yürütme ve problem çözmeyle ilgili olan "genel zekayı ı
yönelik "spesifik zekayı ı
Howard Gardner tarafı ı
"sözel/dilbilimsel (verbal/linguistic), müzikal (musical), mantı
(visual/spatial), kinestetik (kinesthetic), kişilerarası ı
türe ayı ı ı
dokuza çı ı ı
Robert Sternberg'e göre ise "analitik (analytical), pratik (practical) ve yaratı ı ı
Analitik zeka problemi parçalara ayı ı
ölçmeye çalı ı ı ı ı ı
yeni yöntemler bulmak, problemleri farklı
Catell-Horn-Carroll (CHC) Teorisi diye isimlendirilen çok katmanlı
2024-05-20 13:45:43 +03:00
(Raymond Catell aslı ı ı
intelligence)" ve "akı ı ı ı ı
ve becerilerle ilgili iken akı ı
Catell'in bu iki tür zekası ı ı
ilişkin yetileri, niceliksel işlemlere yönelik yetileri ve okuma yazma becerilerini de eklemiştir. Nihayet John Carroll zeka
ile ilgili 460 yeteneği faktör analizine sokarak üç katmanlı
Wechsler zeka testlerinin ileri sürümlerinin benimsediği zeka anlayı ı ı
2024-04-02 13:01:04 +03:00
Bu bilgilerin eşliğinde kuramsal farklı ı ı ı ı ı
yeni durumlara uyum sağlamak ve problem çözmek için deneyimlerden öğrenme, bilgi edinme ve kaynakları
becerisidir.
Yapay zeka ise -ismi üzerinde- insan zekası ı ı
2024-05-20 13:45:43 +03:00
belirtmektedir. Yapay zeka terimi ilk kez 1955 yı ı ı ı ı ı
zekanı ı ı ı ı ı ı
olduğu varsayı ı ı
makineler tarafı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
- Yapay zeka insan zekası ı ı
edilmesidir.
- Yapay zeka zeki makineler yaratma amacı ı ı
- Bilgisayarları ı ı ı ı ı
Yapay zekanı ı ı ı ı ı ı
- Bir şeyin nası ı ı ı
- Akı
- Problem çözme (problem solving)
- Algı
- Öğrenme (learning)
- Planlama (planning)
- Doğal dili anlama ve konuşma
- Uzmanlı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Yapay zeka ile ilgili düşünceler ve görüşler çok eskiye kadar götürülebilir. Ancak modern yapay zeka çalı ı ı ’
yı ı ı ı ı
Örneğin bugün kullandı ı ı ı ı
çok bilimsel ve teknolojik gelişmeler belli bir noktaya gelmiş ve yapay zeka dediğimiz bu alan 1950’ ı
başlamı ı
2024-04-02 13:01:04 +03:00
Yapay zeka çalı ı ı ı ı
- Mantı ı ı ı ı ı
adlı ı ı ı
- Matematikteki Gelişmeler: 1930’
fonksiyonel notasyonla hesaplanabilirliği araştı ı ı ı ’
systems)" üzerindeki çalı ı ı ı
2024-05-20 13:45:43 +03:00
- Turing Makineleri: Alan Turing’ ’ ı ı ı
1936) tasarladı ı ı ı ı ı
çı ı ı ı
algoritma analizinde ve algoritmik karmaşı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
- Elektronik Bilgisayarları ı ı ’ ı ı ı ı
Bilgisayarlar yapay zeka çalı ı ı ı
Yapay Zeka (Artificial Intelligence) terimi ilk kez John McCarthy tarafı ı ı
Marvin Minsky, Nathan Rocheste ve Claude Shannon tarafı ı ı ’
Bu konferans yapay zeka kavramı ı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
edilmektedir. Yapay zeka terimi de bu konferansta katı ı ı ı ı
dünyanı ’ ı ı ı ı ı ı
kullanı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
10. Ders - 28/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka çalı ı ı ı ı ı
finansman sı ı ı ı ı ı ı ı ı ı ı ı ı
"Kı ı ı ı ı ı ı ı ı ı ı
çalı ı ı ı
2024-05-20 13:45:43 +03:00
1956-1974 yapay zekanı ı ı ı ı ı
uygulama üzerinde çalı ı ı ı ı ı
(heuristic) yöntemlerle daraltı ı ı ı ı ı ı
Bu ilk çalı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
- 1958 yı ı ı ı ı
(Halbuki bu durum 90'lı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
- 1970 yı ı ı ı ı
1974-1980 yı ı ı ı ı ı
görülmüş bu da biraz hayal kı ı ı ı ı ı ı ı ı ı
Yeni projeler için finans elde edilmesi zorlaşmı ı
1980'li yı ı ı ı ı ı
alanı ı ı ı ı ı
çalı ı ı
2024-05-20 13:45:43 +03:00
1987-1993 yı ı ı ı ı ı ı
finans kaynakları
2024-04-02 13:01:04 +03:00
1993 yı ı ı ı ı ı
mobil aygı ı ı ı ı ı ı
getirmiştir. 1990'lı ı ı ı ı ı
kendini kabul ettirmiştir. Özellikle 2011 yı ı ı ı
ağları ı ı ı ı ı ı ı
artı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka aslı ı ı ı ı ı
- Makine Öğrenmesi
- Yapay Sinir Ağları
- Robotik Sistemlerin Tasarı ı
- Bulanı
- Evrimsel Yöntemler (Genetic Algoritmalar, Differential Evoluation, Neuroevolution vs. )
- Üst Sezgisel (Meta Heuristic) Yöntemler (Karı
- Olası ı
- Uzman Sistemler (Expert Systems)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zekanı ı ı ı ı ı ı ı ı
konusu olarak görülmemeye başlanmı ı ı
görülürdü. Ancak zamanla OCR işlemleri o kadar bilindik ve rutin bir hale geldi ki artı ı
2024-08-22 19:31:50 +03:00
bir yapay zeka faaliyeti olarak ele alı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
bir yapay zeka faaliyeti olarak görülüyorken artı ı ı
2024-08-22 19:31:50 +03:00
ele alı ı ı
yapay zeka alanı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
faaliyetlerin yapay zeka kapsamı ı ı ı
faaliyeti olarak ele aldı ı ı ı ı
istiyoruz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de makine öğrenmesinin ne anlama geldiği üzerinde duracağı
ne olduğunu ele almak gerekir. Psikolojide öğrenme "davranı ı ı
biçiminde tanı ı ı ı ı ı
kapsamaktadı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
genişletmiştir.
2024-04-02 13:01:04 +03:00
Psikolojide öğrenme kabaca dört bölümde ele alı ı
1) Klasik Koşullanma (Classical Conditioning)
2) Edimsel Koşullanma (Operant Conditioning)
3) Sosyal Bilişsel Öğrenme (Social Cognitive Learning)
2024-05-20 13:45:43 +03:00
4) Bilişsel Öğrenme (Cognitive Learning)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
11. Ders - 03/02/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Organizmada doğal bir tepki oluşturan uyaranlara "koşulsuz uyaranlar (unconditioned stimuli)", koşulsuz uyaranlara karşı
organizmanı
koşulsuz uyarana, gök gürültüsüne karşı
başlangı
stimulus) zamansal bakı ı ı
benzer bir tepki oluşturmaya başlamaktadı ı ı
artı ı
tepki (conditioned response)" denilmektedir. Bu süreci şekilsel olarak aşağı
Koşulsuz Uyaran ---> Koşulsuz Tepki (Doğal Durum)
Nötr Uyaran ---> Koşulsuz Uyaran (Klasik Koşullanma Süreci)
Nötr Uyaran ---> Koşulsuz Uyaran (Klasik Koşullanma Süreci)
... ---> ... (Klasik Koşullanma Süreci)
2024-05-20 13:45:43 +03:00
Nötr uyaran artı
2024-04-02 13:01:04 +03:00
Koşullu Uyaran ---> Koşullu Tepki (Öğrenilmiş Yeni Durum)
Klasik koşullanma sürecinin gerçekleşmesi için önce nötr uyaranı ı ı ı
gerekmektedir. Burada iki uyaran arası ı ı
güçleşmektedir. Pek çok çalı ı ı ı ı ı ı
olduğunu göstermektedir.
Klasik koşullanma ilk kez Ivan Pavlov tarafı ı ı ı
2024-05-20 13:45:43 +03:00
tipik bir örnektir. Bu deneyde Pavlov köpeğe yemek gösterdiğinde (koşulsuz uyaran) köpek salya salgı ı
2024-10-08 00:12:04 +03:00
görünce köpeğin salya salgı ı
uyaran) sonra yemeği göstermiş ve bu işlemi bir süre tekrarlamı ı ı ı
duyduğunda (artı ı
salgı ı ı ı ı
2024-04-02 13:01:04 +03:00
Klasik koşullanma süreci pek çok hayvan üzerinde denenmiştir. Hayvanları
öğrenebilmektedir. Birinci kuşak davranı ı ı ı ı ı ı
de fobilerin çoğunda klasik koşullanmanı ı
2024-05-20 13:45:43 +03:00
çok kı ı ı ı
yeniden karanlı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Edimsel koşullanma en önemli öğrenme yolları
koşullanmada önce uyaran sonra tepki gelmektedir. Halbuki edimsel koşullanmada önce tepki sonra uyaran gelir. Organizma bir
faaliyette bulunur. Bunun sonucunda hoşa giden bir durum (buna ödül de denilmektedir) oluşursa bu davranı ı
böylece öğrenme gerçekleşir. Yani özetle organizmada hoşa giden sonuçlar doğuran davranı
Edimsel koşullanma bir süreç olarak ilk kez Edward Thorndike tarafı
verdiği bir kafes düzeneği ile yaptı ı
2024-10-08 00:12:04 +03:00
olduğu" sonucunu çı ı ı ı
koşullanmayı
ası ı ı
2024-04-02 13:01:04 +03:00
Edimsel koşullanmada ödül oluşturan uyaranlara "pekiştireç (reinforcer)" denilmektedir. Davranı
o kadar iyi öğrenilmektedir. Pekiştireçler "pozitif" ve "negatif" olmak üzere ikiye ayrı ı
doğrudan organizmanı ı ı
2024-10-08 00:12:04 +03:00
durumu ortadan kaldı ı ı ı
2024-04-02 13:01:04 +03:00
- Ödevini yapan öğrenciye öğretmenin ödül vermesi ödev yapma davranı ı ı ı ı
- Maddenin bunaltı ı ı ı ı ı
- Arabada emniyet kemeri bağlı ı ı ı ı
emniyet kemerini bağlarlar (negatif pekiştireç).
- Ağlayan çocuğun isteklerini ebeveynin karşı ı ı ı ı ı ı
(pozitif pekiştireç).
Bugün psikolojide edimsel koşullanma davranı ı
edilmektedir.
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Sosyal bilişsel öğrenmeye taklit yoluyla öğrenme" ya da "model alarak öğrenme" de denilmektedir. Biz başkaları ı
ederek de davranı ı ı ı ı
hale getirilmiştir. Aslı ı
doğrudan değil dolaylı ı ı
girdiğine dikkat ediniz. Çünkü bu süreçte kişinin başkaları ı ı ı ı ı
ve onlardan sonuçlar çı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Biliş (cognition) organizmanı
2024-04-02 13:01:04 +03:00
bilinç, akı ı ı ı ı ı
hayvanlarda mümkün olduğunu göstermişlerdir. Yani biz klasik koşullanma, edimsel koşullanma ve sosyal öğrenme süreçleri
olmadan yalnı
Halk arası ı ı ı ı
değerlendirilmektedir. Halbuki her türlü öğrenmede açı ı ı ı ı ı ı
beklenir. Ancak "davranı ı ı ı ı
gibi ilk davranı ı ı ı ı ı ı
de davranı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
O halde makine öğrenmesi (machine learning) nedir? Aslı ı
Biz makinenin (makine demekle donanı ı ı ı ı ı ı ı
isteriz. Yani makinenin davranı ı ı
İşte makine öğrenmesi kabaca geçmiş bilgilerden ve deneyimlerden faydalı ı ı ı
algoritmalar ve yöntemler topluluğudur. Makine öğrenmesinde üç bileşen vardı
canlı ı
edilmesini ve onlardan bir kestirim ya da faydalı ı ı ı ı ı
şeydir. Görevler düşük bir deneyimle düşük bir performansla gerçekleştirilebilirler. Deneyim arttı
performansı
incelenir, analiz edilir, bundan sonuçlar çı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
yerine getirilmesi de gitgide iyileştirilir. Bu süreç çeşitli algoritmalarla ve yöntemlerle değişik biçimlerde ve yaklaşı
yürütülmektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesi genel olarak üç bölümde ele alı
1) Denetimli Öğrenme (Supervised Learning)
2) Denetimsiz Öğrenme (Unsupervised Learning)
3) Pekiştirmeli Öğrenme (Reinforcement Learning)
Denetimli (supervised) öğrenmede makineye (yani algoritmaya) biz daha önce gerçekleşmiş olan olayları ı
olarak veririz. Makine bu olaylarla sonuçlar arası ı ı
onun sonucunu makineden kestirmesini isteriz. Denetimsiz öğrenmede biz makineye yalnı ı ı
arası ı ı ı ı ı ı
resimler verip bunları ı ı
verdiğimizde o daha önceki deneyimlerden hareketle bunun elma olduğu sonucunu çı
bir örnektir. Şimdi biz makineye elma ve armut resimlerini verelim ama bunları
resimleri ortak özelliklerine göre iki gruba ayı ı ı
ise tı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Yapay zeka, makine öğrenmesi ve veri bilimi alanları ı ı ı ı
istiyoruz.
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
Bilgisayar Bilimleri (Computer Science): bilgi işlem ve programlama etkinlikleriyle ilgili geniş kapsamlı ı ı
Bilgisayar bilimlerindeki teknikler ve yöntemler kullanı ı
2024-04-02 13:01:04 +03:00
İstatistik: İstatistik temelde iki bölüme ayrı ı
- Betimsel istatistik (descriptive statistics)
2024-06-17 00:07:33 +03:00
- Çı ı
2024-04-02 13:01:04 +03:00
Betimsel istatistik verilerin gruplanması
2024-06-17 00:07:33 +03:00
betimleyici istatistik "zaten var olan durumu" betimlemektedir. Çı ı
2024-05-20 13:45:43 +03:00
Makine öğrenmesi ve veri bilimi istatistiğin kestirimsel yöntemlerini açı ı
analizi, karar ağaçları ı
ortaya çı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Matematik: Makine öğrenmesi ve veri bilimi uygulamaları ı ı
makine öğrenmesinde matematiğin çok değişkenli fonksiyonlar, limit, türev gibi konuları ı
kullanı ı
2024-04-02 13:01:04 +03:00
Veri Madenciliği (Data Mining): Veri madenciliği verilerin içerisinden çeşitli faydalı ı ı
elde edilmesi ve bunlarla ilişkin süreçlerle ilgilenmektedir. Şüphesiz bu süreçler istatistiksel birtakı ı ı
yazı ı ı ı ı ı ı
ilgili olduğuna dikkat ediniz. Veri madenciliği de "verinin içinde zaten var olan değerli unsurları ı ı ı ı
ilgilidir. Bu nedenle veri madenciliğindeki "madencilik" teriminin süreci anlatmak için uygun bir sözcük olduğu söylenebilir.)
2024-06-17 00:07:33 +03:00
İlgili Konudaki Özel Bilgiler (Domain Specific Knowledge): Şüphesiz her türlü algoritmik yöntem için bir biçimde hedeflenen
2024-05-20 13:45:43 +03:00
konuda belli bir bilgi birikiminin var olması
görüntüsel verilerle çalı ı
örneğin hiç muhasebe bilmeyen iyi bir programcı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Veri bilimi (data science) ve makine öğrenmesi uygulamaları ı
gelen dil şüphesiz Python'dur. Ancak C++, Java, C# gibi popüler programlama dilleri de bu amaçla gittikçe daha fazla kullanı ı
hale gelmektedir. Python programlama dili son on yı ı ı ı
Python dilinin özellikle veri bilimi ve makine öğrenmesi konusunda popülaritesinin neden bu kadar arttı ı
şöyledir:
2024-10-03 14:16:20 +03:00
- Son yı ı ı
2024-04-02 13:01:04 +03:00
iyi bir araç olarak düşünülmektedir.
- Veri bilimi ve makine öğrenmesi için Python dilinden kullanı ı
diğer dillerden -şimdilik- daha fazladı
- Python nispeten basit bir dildir. Bu basitlik ana hatları ı ı ı
2024-05-20 13:45:43 +03:00
Bu nedenle Python diğer disiplinlerden gelip de veri bilimi ve makine öğrenmesi uygulaması
2024-04-02 13:01:04 +03:00
kolay bir araç durumundadı
- Python genel amaçlı ı ı ı ı ı ı
Yani Python'un matematiksel alana yönelik ifade gücü (expressivity) popüler diğer programlama dillerinden daha yüksektir.
- Python dilinin çeşitli prestijli üniversitelerde "programlamaya giriş (introduction to programming)" gibi derslerde kullanı
başlanmı ı ı ı ı ı
iyileştirilmiştir.
2024-05-20 13:45:43 +03:00
- Python dilinin veri bilimi için diğer dillere göre daha erken yola çı ı ı
araştı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Pekiyi Python dilinin veri bilimi ve makine öğrenmesi konusunda hangi dezavantajları ı ı
2024-04-02 13:01:04 +03:00
sı
- Python nispeten yavaş bir dildir. Bu yavaşlı ı
programları ı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
veri analizi ve makine öğrenmesinde kullanı
ası ı ı ı ı ı
işlemler yavaşlı ı
2024-04-02 13:01:04 +03:00
- Python yüksek seviyeli bir dil olduğu için dilin olanakları ı ı ı
2024-05-20 13:45:43 +03:00
Pekiyi Python genel olarak yavaş bir dilse bu durum veri bilimi ve makine öğrenmesi uygulamaları ı
İşte Python'un yavaşlı ı ı ı ı ı ı ı ı
olmaktan çı ı ı ı
2024-04-02 13:01:04 +03:00
ana dil olarak kullanı ı ı
2024-06-30 23:07:28 +03:00
demekle projeyi Python'da hı ı ı
dillerle kodlamayı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bilgisayar teknolojisinin gelişmesine paralel olarak veri toplama ve depolama olanakları ı ı
analizinde yeni bir dönemin başladı ı ı ı
2024-10-08 00:12:04 +03:00
daha fazla miktarda veriyle karşı ı ı ı ı ı ı ı ı ı ı ı
İşte "veri bilimi (data science)" 2000'li yı ı ı ı ı
biliminin tanı ı ı ı ı
ve içgörülerin (insights) elde edilmesine yönelik çalı ı ı ı ı ı
uğraşan uygulamacı ı
ele alı ı ı ı
Aslı ı ı ı ı
göre "veri bilimi" terimi gereksiz biçimde uydurulmuş bir terimdir ve aslı ı
şey değildir. Ancak ne olursa olsun son 30 senedir verilerin işlenmesi ve bunlardan faydalı ı ı ı ı ı
için yapı ı ı ı ı ı
eleştiriliyor olsa da- kendini kabul ettirmiş ve yaygı ı ı
2024-04-02 13:01:04 +03:00
İstatistik ile veri bilimi arası ı ı ı
farklı ı ı ı ı ı
örneklemlerden ziyade çok daha büyük verilerle uğraşma eğilimindedir. İstatistiksel çalı
odaklanı ı ı ı
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
12. Ders - 04/02/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka ve özellikle de makine öğrenmesi ile ilgili çalı
sahip olması ı ı ı
konulara ilişkin pek çok ayrı ı ı ı ı
konuları ı ı ı ı ı ı
çok uzun süredir incelenen bir konudur. Ancak son yı ı ı
ve bu bağlamda pek çok algoritmik yöntem geliştirilmiştir. Dolaysı
bir konusu olduğu halde biz bu tekniğin ayrı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İstatistikte ölçülen ya da ölçülmüş olan değerlerin sı ı ı
ölçeklerin yalnı ı ı ı ı ı
ölçekler tipik olarak dört sı ı ı ı
Kategorik (Nominal) Ölçekler: Bu ölçeklerde söz konusu kümenin elemanları ı
coğrafi bölge gibi. Bu ölçekteki ölçülen ya da ifade edilen değerlerin sayı ı ı ı ı
erkekler arası ı ı ı ı ı ı ı
ölçülmesi istenen değişkenlerden "cinsiyet" kategorik (nominal) bir ölçeğe ilişkindir. Benzer biçimde kişilerin renk tercihleriyle
ilgili bir araştı ı ı ı
Sı ı
küçüklük ilişkisi söz konusudur. Örneğin eğitim durumu için kategorik değerler "ilköğretim", "lise", "üniversite" olabilir
ve bunlar arası ı ı ı ı
Aralı ı ı ı ı ı ı
miktar uzaklı ı ı ı ı
puan alan da 20 puan alandan aynı ı ı ı
bu tür ölçeklerde sı ı ı ı
göre anlamlı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı
"derece (celcius)" bir aralı ı ı ı ı ı
arası ı ı ı ı ı ı ı ı ı ı ı ı
olmayabilmektedir. Örneğin 20 derecelik ı ı ı ı ı ı
dereceden iki kat daha sı ı
Oransal (Ratio) Ölçekler: Bu ölçekler de sayı ı
sahiptirler. Ancak ek olarak oransal ölçeklerde mutlak bir sı ı ı ı ı ı ı
mutlak olarak anlamlı ı
uzunluğunun sı ı ı ı ı ı ı ı ı ı ı
Örneğin kişinin yaşı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
İstatistikte verilerin merkezine ilişkin bilgi veren ölçülere "merkezi eğilim ölçüleri (measures of central tendency)"
denilmektedir. Merkezi eğilim ölçülerinin en yaygı ı ı ı
toplanarak değer sayı ı
2024-05-20 13:45:43 +03:00
Aritmetik ortalama hesaplamak için çeşitli kütüphanelerde çeşitli fonksiyonlar hazı ı
2024-04-02 13:01:04 +03:00
standart kütüphanesindeki statistics modülünde bulunan mean fonksiyonu aritmetik ortalama hesaplamaktadı
>>> import statistics
>>> a = [1, 2, 7, 8, 1, 5]
>>> statistics.mean(a)
4
mean fonksiyonu herhangi bir dolaşı
2024-05-20 13:45:43 +03:00
NumPy kütüphanesindeki mean fonksiyonu eksen (axis) temelinde (yani satı
Örneğin:
2024-04-02 13:01:04 +03:00
>>> import numpy as np
>>> a = np.array([[1, 2, 3], [5, 6, 7], [8, 9, 10]])
>>> np.mean(a, axis=0)
array([4.66666667, 5.66666667, 6.66666667])
NumPy'da mean fonksiyonu aynı ı ı ı ı ı
>>> import numpy as np
>>> a = np.array([[1, 2, 3], [5, 6, 7], [8, 9, 10]])
>>> a.mean(axis=0)
array([4.66666667, 5.66666667, 6.66666667])
2024-10-08 00:12:04 +03:00
Pandas kütüphanesinde Series ve DataFrame sı ı ı ı ı ı ı
sı ı ı ı
2024-04-02 13:01:04 +03:00
>>> import pandas as pd
>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> df
0 1 2
0 1 2 3
1 4 5 6
2 7 8 9
>>> df.mean()
0 4.0
1 5.0
2 6.0
dtype: float64
Aritmetik ortalama aralı ı ı ı
2024-05-20 13:45:43 +03:00
hesaplanabilmektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-17 00:07:33 +03:00
Diğer bir merkezi eğilim ölçüsü de "medyan (median)" denilen ölçüdür. Medyan küçükten büyüğe sı ı ı
ortası ı ı ı ı ı ı ı
aritmetik ortalaması ı ı
aritmetik ortalamadan daha fazla zaman alan bir işlemdir. Çünkü medyan için önce değerlerini sı
Dolayı ı ı ı
modülü içerisindeki median isimli fonksiyonla yapı
2024-04-02 13:01:04 +03:00
>>> import statistics
>>> a = [1, 23, 56, 12, 45, 21]
>>> statistics.median(a)
22.0
NumPy kütüphanesinde medyan işlemi eksensel biçimde median fonksiyonuyla yapı
>>> import numpy as np
>>> a = np.random.randint(1, 100, (10, 10))
>>> a
array([[ 8, 26, 42, 26, 10, 66, 94, 91, 3, 97],
[31, 62, 82, 86, 45, 73, 38, 29, 43, 62],
[78, 49, 22, 32, 74, 15, 54, 59, 37, 87],
[ 5, 75, 34, 82, 58, 63, 84, 40, 92, 20],
[57, 21, 2, 65, 69, 37, 78, 9, 57, 9],
[57, 6, 72, 17, 39, 13, 25, 49, 85, 46],
[57, 47, 57, 47, 25, 40, 20, 72, 10, 16],
[12, 83, 35, 89, 86, 84, 66, 54, 50, 38],
[90, 88, 65, 82, 29, 18, 86, 37, 60, 70],
[38, 17, 40, 81, 18, 89, 4, 22, 59, 65]])
>>> np.median(a, axis=0)
array([47.5, 48. , 41. , 73. , 42. , 51.5, 60. , 44.5, 53.5, 54. ])
ndarray sı ı ı ı
Benzer biçimde Pandas kütüphanesinde de Series ve DataFrame sı ı ı ı ı
yapabilmektedir. Tabii DataFrame sı ı ı ı ı ı ı
Örneğin:
>>> a = np.random.randint(1, 100, (10, 10))
>>> a
array([[39, 73, 50, 26, 3, 87, 78, 49, 87, 39],
[91, 39, 6, 99, 85, 1, 50, 59, 20, 19],
[83, 91, 94, 54, 28, 84, 25, 41, 19, 83],
[38, 46, 78, 56, 53, 3, 2, 8, 27, 42],
[33, 32, 36, 61, 7, 6, 88, 72, 71, 88],
[32, 71, 68, 46, 64, 70, 45, 92, 8, 64],
[71, 42, 36, 82, 45, 17, 13, 63, 8, 60],
[70, 56, 76, 59, 64, 28, 81, 62, 60, 72],
[82, 66, 93, 44, 67, 53, 97, 92, 89, 44],
[34, 2, 3, 75, 19, 17, 34, 89, 98, 14]])
>>> df = pd.DataFrame(a)
>>> df
0 1 2 3 4 5 6 7 8 9
0 39 73 50 26 3 87 78 49 87 39
1 91 39 6 99 85 1 50 59 20 19
2 83 91 94 54 28 84 25 41 19 83
3 38 46 78 56 53 3 2 8 27 42
4 33 32 36 61 7 6 88 72 71 88
5 32 71 68 46 64 70 45 92 8 64
6 71 42 36 82 45 17 13 63 8 60
7 70 56 76 59 64 28 81 62 60 72
8 82 66 93 44 67 53 97 92 89 44
9 34 2 3 75 19 17 34 89 98 14
>>> df.median()
0 54.5
1 51.0
2 59.0
3 57.5
4 49.0
5 22.5
6 47.5
7 62.5
8 43.5
9 52.0
dtype: float64
Tabii median işlemi de ancak sayı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Merkezi eğilim ölçülerinin bir diğeri de "mod" denilen ölçüdür. Bir grup verideki en çok yinelenen değere "mod (mode)"
denilmektedir. Mod özellikle kategorik ve sı ı ı ı ı
2024-09-25 13:52:00 +03:00
Mod işlemi genel olarak O(N log N) karmaşı ı ı ı ı
2024-05-20 13:45:43 +03:00
sonra yan yana aynı
2024-04-02 13:01:04 +03:00
modülünde bulunan mode fonksiyonuyla yapı
>>> a = [1, 3, 3, 4, 2, 2, 5, 2, 7, 9, 5, 3, 5, 7, 5]
>>> statistics.mode(a)
5
Eğer en çok yinelenen değer birden fazla ise mode fonksiyonu dizilimde ilk karşı ı
dönmektedir.
NumPy kütüphanesinde mod işlemini yapan bir fonksiyon bulunmamaktadı
2024-05-20 13:45:43 +03:00
modülü içerisindeki mode fonksiyonu kullanı
tuple sı ı ı ı ı ı ı ı
en çok yinelenen değerleri ve onları ı ı ı ı ı ı
demet gibi de kullanı
2024-04-02 13:01:04 +03:00
>>> import scipy.stats
>>> import numpy as np
>>> a = np.random.randint(1, 10, (20, 10))
>>> a
array([[2, 5, 1, 9, 9, 9, 1, 5, 1, 8],
[3, 1, 1, 8, 2, 5, 3, 2, 5, 4],
[7, 3, 7, 6, 1, 2, 4, 5, 3, 7],
[8, 3, 9, 4, 9, 9, 4, 5, 1, 8],
[6, 1, 6, 6, 3, 2, 2, 4, 3, 9],
[1, 4, 5, 6, 4, 4, 6, 2, 7, 3],
[6, 5, 7, 4, 5, 8, 5, 4, 4, 9],
[5, 1, 4, 8, 8, 9, 6, 1, 8, 6],
[8, 8, 5, 4, 2, 8, 6, 1, 1, 5],
[3, 8, 4, 9, 7, 6, 6, 9, 6, 4],
[5, 8, 1, 6, 7, 8, 7, 7, 6, 4],
[7, 7, 1, 8, 8, 3, 1, 8, 3, 1],
[5, 5, 5, 4, 9, 3, 8, 7, 9, 8],
[8, 9, 9, 2, 7, 3, 3, 6, 2, 6],
[1, 6, 6, 8, 4, 4, 3, 2, 2, 4],
[1, 2, 4, 5, 8, 3, 1, 5, 1, 3],
[5, 9, 3, 1, 1, 6, 9, 5, 4, 1],
[3, 1, 4, 9, 1, 2, 5, 1, 3, 7],
[8, 7, 3, 3, 7, 4, 1, 7, 6, 9],
[9, 2, 1, 6, 5, 3, 7, 9, 5, 7]])
>>> mr = scipy.stats.mode(a, axis=0)
>>> mr.mode
array([[5, 1, 1, 6, 7, 3, 1, 5, 1, 4]])
>>> mr.count
array([[4, 4, 5, 5, 4, 5, 4, 5, 4, 4]])
2024-05-20 13:45:43 +03:00
Pandas kütüphanesinde Series ve DataFrame sı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
>>> a = np.random.randint(1, 10, (20, 10))
>>> df = pd.DataFrame(a)
>>> df
0 1 2 3 4 5 6 7 8 9
0 5 5 9 1 4 7 4 3 9 6
1 1 3 2 1 6 8 4 4 3 3
2 8 7 9 5 8 1 5 3 8 1
3 8 7 1 7 1 7 5 8 7 6
4 1 9 9 5 4 7 5 6 9 9
5 7 9 1 7 9 6 5 4 7 8
6 3 2 6 5 4 8 6 5 5 9
7 4 9 6 9 5 4 9 4 4 7
8 2 3 3 8 4 8 2 1 4 1
9 7 6 6 1 7 3 5 1 6 9
10 3 3 1 5 9 6 1 3 1 4
11 4 6 2 1 1 1 6 3 2 1
12 9 1 1 6 3 7 1 1 7 8
13 8 3 3 5 9 1 1 8 2 4
14 8 7 7 1 6 5 8 6 4 8
15 4 8 4 9 2 6 7 9 2 1
16 6 3 2 6 1 2 5 3 9 2
17 3 9 3 6 9 1 9 7 9 4
18 6 2 9 1 4 2 4 8 6 2
19 3 2 7 2 5 9 1 7 9 2
>>> df.mode()
0 1 2 3 4 5 6 7 8 9
0 3 3.0 1 1.0 4.0 1 5.0 3.0 9.0 1.0
1 8 NaN 9 NaN NaN 7 NaN NaN NaN NaN
DataFrame sı ı ı ı ı ı ı
Diğer satı ı ı
sayı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Değerlerin merkezine ilişkin bilgiler dağı ı ı ı
ortalama yı ı ı ı ı ı ı
farklı ı ı ı ı ı ı ı ı ı ı
önemlidir. İstatistikte değerlerin ortalamaya göre yayı ı ı ı ı
2024-05-20 13:45:43 +03:00
bazı ı ı ı ı ı ı ı ı
hedeflemektedir.
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Eğer biz değerleri ortalamadan çı ı ı ı ı ı ı
uzaklı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
değerler elde edilebilir.)
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8])
mean = np.mean(a)
print(mean)
result = np.mean(a - mean)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Merkezi yayı ı ı ı
2024-04-08 14:07:40 +03:00
alı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
çok iyi bir yöntem değildir. Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8])
mean = np.mean(a)
print(mean)
result = np.mean(np.abs(a - mean))
print(result) # 2.5
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı
sapmada ortalamadan uzaklı ı ı ı
değerleri daha fazla farklı ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
Aynı ı ı
2024-06-17 00:07:33 +03:00
problemleri için daha uygun bir işlem olduğunu göreceğiz.)
2024-04-02 13:01:04 +03:00
Standart sapma, değerlerin ortalamadan farkları ı ı ı ı ı
2024-06-20 23:19:45 +03:00
ortalama bulunurken değer sayı ı ı
n'e bölme yapı ı ı ı ı ı
(n - 1)'e bölme işlemine "Bessel düzeltmesi (Bessel's correction)" denilmektedir. Genellikle standart sapma hesaplayan
fonksiyonlar kaça bölüneceğini "ddof (delta degrees of freedom)" parametresiyle programcı
"n eksi kaça bölüneceğini" belirtir. Örneğin ddof=0 ise n'e bölme ddof=1 ise (n - 1)'e bölme uygulanı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def sd(a, ddof = 0):
return np.sqrt(np.sum((a - np.mean(a)) ** 2) / (len(a) - ddof))
a = [1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8]
result = sd(a)
print(result) # 2.7688746209726918
#----------------------------------------------------------------------------------------------------------------------------
2024-06-17 00:07:33 +03:00
Python Standart Kütüphanesinde statistics modülü içerisinde standart sapma hesabı ı
2024-06-09 22:37:05 +03:00
bulunmaktadı
2024-04-02 13:01:04 +03:00
fonksiyonu n'e bölme yapmaktadı
#----------------------------------------------------------------------------------------------------------------------------
import statistics
a = [1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8]
std = statistics.stdev(a)
print(std) # 2.891995221924885
std = statistics.pstdev(a)
print(std) # 2.7688746209726918
#----------------------------------------------------------------------------------------------------------------------------
NumPy kütüphanesinde std isimli fonksiyon eksensel standart sapma hesaplayabilmektedir. Fonksiyonun ddof parametresi
default durumda 0'dı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8])
result = np.std(a)
print(result) # 2.7688746209726918
#----------------------------------------------------------------------------------------------------------------------------
Pandas kütüphanesinde de Series ve DataFrame sı ı ı ı ı ı
Ancak bu metotlarda ddof parametresi default 1 durumundadı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
s = pd.Series([1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8])
result = s.std()
print(result) # 2.891995221924885
s = pd.Series([1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8])
result = s.std(ddof=0)
print(result) # 2.7688746209726918
#----------------------------------------------------------------------------------------------------------------------------
Standart sapmanı
bulunan variance ve pvariance fonksiyonları ı ı
ndarray sı ı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
Yine NumPy'ı ı
parametresinin default değeri 1’
2024-04-02 13:01:04 +03:00
Pekiyi neden standart sapma varken ayrı
aslı ı ı ı ı ı
2024-06-17 00:07:33 +03:00
bu hesaba ayrı ı ı ı ı ı ı ı ı
yönelik bir örnek verilmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import statistics
import numpy as np
import pandas as pd
data = [1, 4, 6, 8, 4, 2, 1, 8, 9, 3, 6, 8]
result = statistics.pvariance(data)
print(result) # 7.666666666666667
result = np.var(data)
print(result) # 7.666666666666667
s = pd.Series(data)
result = s.var(ddof=0)
print(result) # 7.666666666666667
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
13. Ders - 10/02/2024 - Cumartesi
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir deney sonucunda oluşacak durum baştan tam olarak belirlenemiyorsa böyle deneylere "rassal deney (random experiment)"
denilmektedir. Örneğin bir paranı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
rassal bir deneydir. Benzer biçimde bir zarı ı ı ı
deneyin sonucu önceden bilinebiliyorsa bu tür deneylere "deterministik deneyler" de denilmektedir. Bazı
süreçler deterministiktir. Ancak bazı
Önceden sonucu tam olarak kestirilemeyen süreçlere "olası ı
denilmektedir.
2024-04-02 13:01:04 +03:00
Deterministik süreçlerle olası ı ı ı ı ı
süreç diye bir şey yoktur. Her şey deterministiktir. Bir sürecin olası ı ı
belirleyemememizden" kaynaklanmaktı ı ı ı ı ı ı
olası ı
2024-09-25 13:52:00 +03:00
olayı ı
2024-04-02 13:01:04 +03:00
da "kelebek etkisi" denilmektedir. Eğer evrende mutlak bir determinizm varsa evren reset konumuna alı ı ı
yine bugüne aynı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir rassal deney sonucunda oluşabilecek tüm olası ı ı
2024-06-20 23:19:45 +03:00
bir paranı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
S = {1, 2, 3, 4, 5, 6} biçimindedir. İki zarı ı ı ı
Örnek uzayı ı ı ı ı
E1 = {1, 3}
E2 = {3, 4, 5}
E3 = {6}
Bir kümenin bütün alt kümelerine o kümenin "kuvvet kümesi (power set)" denilmektedir. Bir rassal deneydeki bütün olaylar
2024-06-20 23:19:45 +03:00
kuvvet kümesi içerisindeki olaylardı ı ı ı
2024-04-02 13:01:04 +03:00
Örnek uzayı ı ı ı
atı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Olası ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
(relative frequency)" tanı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
bir değere yakı ı ı ı ı
sayı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Buna istatistike "büyük sayı ı
Aşağı ı ı ı ı ı ı
Programı ı ı ı ı
head = 0.4, tail = 0.6
head = 0.5, tail = 0.5
head = 0.479, tail = 0.521
head = 0.4977, tail = 0.5023
head = 0.50005, tail = 0.49995
head = 0.500075, tail = 0.499925
head = 0.5002417, tail = 0.4997583
head = 0.49997078, tail = 0.50002922
#----------------------------------------------------------------------------------------------------------------------------
import random
HEAD = 1
def head_tail(n):
head = tail = 0
for _ in range(n):
val = random.randint(0, 1)
if val == HEAD:
head += 1
else:
tail += 1
return head / n, tail / n
2024-04-19 00:21:20 +03:00
2024-04-02 13:01:04 +03:00
head, tail = head_tail(10)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(100)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(1000)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(10_000)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(100_000)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(1_000_000)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(10_000_000)
print(f'head = {head}, tail = {tail}')
head, tail = head_tail(100_000_000)
print(f'head = {head}, tail = {tail}')
#----------------------------------------------------------------------------------------------------------------------------
Olası ı ı ı
2024-06-17 00:07:33 +03:00
olası ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
1) Örnek uzayı ı ı ı ı ı ı ı ı ı
uzayı ı ı ı ı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
P({1, 2, 3, 4, 5, 6}) = 1'dir. Buradaki P({1, 2, 3, 4, 5, 6}) bir zarı
olası ı ı ı ı
2024-04-02 13:01:04 +03:00
2) Herhangi bir olayı ı ı ı ı ı ı ı
2024-06-17 00:07:33 +03:00
belirtilmektedir. O halde olası ı ı ı
2024-04-02 13:01:04 +03:00
3) Bir kümenin olası ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
zarı ı ı ı ı ı ı ı ı ı ı ı
2024-06-17 00:07:33 +03:00
elemanları ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
olay olmak üzere eğer bu iki olay ayrı ∪
2024-04-02 13:01:04 +03:00
2024-06-20 23:19:45 +03:00
Bu üç kural kabul edildiğinde kümeler teorisi, permütasyon, kombinasyon gibi işlemlerle tüm olası ı
2024-04-08 14:07:40 +03:00
edilebilmektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Olası ı ı ı
Her ne kadar "rassal değişken" teriminde bir "değişken" sözcüğü geçiyorsa da aslı
2024-06-09 22:37:05 +03:00
Rassal değişken bir rassal deney ile ilgilidir. Bir rassal değişken örnek uzayı ı ı ı ı
2024-06-17 00:07:33 +03:00
gerçek (reel) bir değere eşleyen bir fonksiyon belirtmektedir. Rassal değişkenler genellikle "sözel biçimde" ifade edilirler.
2024-04-02 13:01:04 +03:00
Ancak bir fonksiyon belirtirler. Rassal değişkenler matematiksel gösterimlerde genellikle büyük harflerle belirtilmektedir.
Örneğin:
2024-06-17 00:07:33 +03:00
- Z rassal değişkeni "iki zar atı ı ı ı ı ı ı ı ı
bir fonksiyondur. Örnek uzayı ı ı
2024-04-02 13:01:04 +03:00
şöyle belirtilebilir:
2024-06-17 00:07:33 +03:00
Z: S -> R
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Burada Z fonksiyonunun S örnek uzayı ı ı ı ı
eşleme yapmaktadı
2024-04-02 13:01:04 +03:00
(1, 1) -> 2
(1, 2) -> 3
(1, 3) -> 4
...
(6, 5) -> 11
(6, 6) -> 12
K rassal değişkeni "rastgele seçilen bir kişinin kilosunu belirtiyor" olsun. Bu durumda örnek uzayı ı
tüm insanlardı ı
C rassal değişkeni "rastgele seçilen bir rengin RGB değerlerinin ortalaması ı
bir RGB ortalaması ı ı ı ı ı
Rassal değişkenler kümeler üzerinde işlemler yapmak yerine gerçek sayı ı ı ı
ve gösterimlerde kolaylı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-20 23:19:45 +03:00
Her rassal değişkenin belli değerler alması ı ı ı ı ı ı ı ı ı
2024-09-25 13:52:00 +03:00
toplamı ı ı ı ı
demektir. Yani P(R = 5) ile aslı ı ı
(3, 2)}) olası ı ı ı ı ı ı ı ı ı ı ı
değeri 1/9'dur.
2024-04-02 13:01:04 +03:00
2024-06-17 00:07:33 +03:00
Bir rassal değişkenin olası ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
parantezleri bazı ı
derken bazı ı
belirttiğini ve bu kümenin olası ı ı ı ı ı
K rassal değişkeni rastgele seçilen bir insanı ı ı
onları ı ı ı ı ı
2024-06-17 00:07:33 +03:00
60'tan küçük olma olası ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Rassal değişkenler tı ı
olabilmektedir. Eğer bir rassal değişken (yani fonksiyon) teorik olarak belli bir aralı ı
2024-10-08 00:12:04 +03:00
alabiliyorsa böyle rassal değişkenlere "sürekli (continuous)", yalnı ı
2024-06-20 23:19:45 +03:00
rassal değişkenlere ise "kesikli (discrete)" rassal değişkenler denilmektedir. Örneğin "iki zarı ı ı
sayı ı ı ı
seçilen bir kişinin kilosunu belirten" K rassal değişkeni süreklidir. Çünkü teorik olarak belli bir aralı
değerleri alabilir. (Biz kişilerin kiloları ı ı ı ı ı
tüm gerçek değerlerden biri olabilir.)
2024-04-02 13:01:04 +03:00
Sürekli rassal değişkenlerin noktasal olası ı ı ı
değişkeni söz konusu olsun. P{K = 67} gibi bir olası ı ı ı ı ı
67 yalnı ı ı ı
olası ı ı ı ı ı
elemanları ı ı ı ı
ilişkili hale gelmektedir. Sürekli rassal değişkenlerin aralı ı ı ı ı ı
bir anlamı ı ı ı ı
Bu konuda da kişiler farklı ı
koymamaktadı
2024-06-20 23:19:45 +03:00
(Sonsuz büyüklükte bir kümeye bir eleman daha eklesek bunun bir etkisi olabilir mi?)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka ve makine öğrenmesinde sürekli rassal değişkenler daha fazla karşı ı ı ı
2024-06-20 23:19:45 +03:00
değişkenler üzerinde biraz daha duracağı
2024-04-02 13:01:04 +03:00
2024-06-20 23:19:45 +03:00
Sürekli bir rassal değişkenin aralı ı ı ı ı
fonksiyona gereksinim vardı ı ı ı ı ı ı ı
fonksiyonlara "olası ı ı
belli bir aralı ı ı ı ı ı ı
olması ı ı ı ı
2024-04-02 13:01:04 +03:00
Bir fonksiyonun olası ı ı ı
kalan alanı ı ı ı ı ı ı
denilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-20 23:19:45 +03:00
Pekiyi mademki bizim bir rassal değişkenin aralı ı ı ı ı ı ı ı ı
var o halde bu fonksiyonu nası ı ı ı ı
uyduğu görülmektedir. Örneğin doğadaki pek çok olgunun (boy gibi, kilo gibi, zeka gibi) olası ı
dağı ı ı ı ı ı ı ı ı
fonksiyonları ı ı ı ı
belirten "ortalama" ve zayı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-20 23:19:45 +03:00
Bu durumda örneğin sürekli rassal değişkenlerle ilgili bir olası ı ı ı
standart sapması ı ı ı ı ı ı ı ı
nedir?" Burada bize rassal değişkenin olası ı ı ı ı
için tek yapacağı ı ı
2024-04-02 13:01:04 +03:00
Pekiyi rassal değişkenimiz başkaları ı ı
2024-06-20 23:19:45 +03:00
değişkenin olası ı ı ı ı ı ı ı ı
olası ı ı ı
2024-04-02 13:01:04 +03:00
aslı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
14. Ders - 11/02/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğada en fazla karşı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
yoğunluk fonksiyonu çan eğrisine benzemektedir. Yukarı ı ı ı ı
"Ortalama" ve "standart sapma". Ortalama çan eğrisinin orta noktası ı ı
olması ı ı
da "Gauss fonksiyonu" denilmektedir.
2024-04-02 13:01:04 +03:00
Gauss fonksiyonu simetrik bir fonksiyondur. Bu fonksiyon ortalama etrafı
hı ı ı
sı ı ı ı ı
2024-06-17 00:07:33 +03:00
Gauss fonksiyonu bir olası ı ı ı
2024-06-20 23:19:45 +03:00
Fonksiyon simetrik olduğuna göre ortalamanı ı ı
2024-04-02 13:01:04 +03:00
2024-06-20 23:19:45 +03:00
Yukarı ı
Ortalaması ı ı ı ı ı ı ı
de Z değerleri" denilmektedir.
2024-04-02 13:01:04 +03:00
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
def gauss(x, mu = 0, std = 1):
return 1 / (std * np.sqrt(2 * np.pi)) * np.e ** (-0.5 * ((x - mu) / std) ** 2)
x = np.linspace(-5, 5, 1000)
y = gauss(x)
plt.title('Gauss Function')
plt.plot(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Yukarı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
def gauss(x, mu = 0, std = 1):
return 1 / (std * np.sqrt(2 * np.pi)) * np.e ** (-0.5 * ((x - mu) / std) ** 2)
def draw_gauss(mu = 0, std = 1):
x = np.linspace(-5 * std + mu, 5 * std + mu, 1000)
y = gauss(x, mu, std)
mu_y = gauss(mu, mu, std)
plt.figure(figsize=(10, 4))
plt.title('Gauss Function', pad=10, fontweight='bold')
axis = plt.gca()
axis.set_ylim([-mu_y * 1.1, mu_y * 1.1])
axis.set_xlim([-5 * std + mu, 5 * std + mu])
axis.set_xticks(np.arange(-4 * std + mu, 5 * std + mu, std))
# axis.set_yticks(np.round(np.arange(-mu_y, mu_y, mu_y / 10), 2))
axis.spines['left'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['bottom'].set_position('center')
axis.spines['right'].set_color(None)
axis.plot(x, y)
plt.show()
draw_gauss(100, 15)
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
olduğu eğirinin şeklinden anlaşı ı ı ı
kaplanan alan yani P{mu - std < X < mu + std} olası ı ı
alan yani P{mu - std * 2 < X < mu + std * 2} olası ı ı
yani P{mu - std * 3 < X < mu + std * 3} olası ı ı
2024-04-02 13:01:04 +03:00
Matplotlib'te bir eğrinin altı ı ı ı
sı ı ı ı ı ı
ile boyanmı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
def gauss(x, mu = 0, std = 1):
return 1 / (std * np.sqrt(2 * np.pi)) * np.e ** (-0.5 * ((x - mu) / std) ** 2)
2024-06-20 23:19:45 +03:00
def fill_gauss(mu = 0, std = 1, fstart= 0, fstop = 0):
2024-04-02 13:01:04 +03:00
x = np.linspace(-5 * std + mu, 5 * std + mu, 1000)
y = gauss(x, mu, std)
mu_y = gauss(mu, mu, std)
plt.figure(figsize=(10, 4))
plt.title('Gauss Function', pad=10, fontweight='bold')
axis = plt.gca()
axis.set_ylim([-mu_y * 1.1, mu_y * 1.1])
axis.set_xlim([-5 * std + mu, 5 * std + mu])
axis.set_xticks(np.arange(-4 * std + mu, 5 * std + mu, std))
# axis.set_yticks(np.round(np.arange(-mu_y, mu_y, mu_y / 10), 2))
axis.spines['left'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['bottom'].set_position('center')
axis.spines['right'].set_color(None)
axis.plot(x, y)
x = np.linspace(fstart, fstop, 1000)
y = gauss(x, mu, std)
axis.fill_between(x, y)
plt.show()
2024-06-20 23:19:45 +03:00
fill_gauss(100, 15, 85, 115)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-20 23:19:45 +03:00
Yukarı ı ı
tüm birikimli olası ı ı ı ı
gelmektedir. Normal dağı ı ı ı ı ı
belirtmektedir. (Başka bir deyişle sürekli dağı ı ı ı
integraline eşittir.)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
"merkezi limit teoremi (central limit theorem)" ile daha iyi anlaşı ı ı ı ı
limit teoremi olduğu için normal dağı ı ı
ele alacağı
2024-04-02 13:01:04 +03:00
Bizim de Python programcı ı ı ı ı ı
1) Belli bir x değeri için eksi sonsuzdan o x değerine kadar eğri altı ı ı
2024-06-20 23:19:45 +03:00
aslı ı ı ı
2024-04-02 13:01:04 +03:00
O halde aslı ı ı ı ı ı
2) Yukarı ı ı
buna ilişkin x değeri istenebilir.
3) Belli bir x değeri için Gauss fonksiyon değerinin elde edilmesi. (Yani belli bir x değeri için olası ı
2024-06-17 00:07:33 +03:00
değerinin elde edilmesi.)
2024-04-02 13:01:04 +03:00
4) Normal dağı ı ı ı ı ı ı
maddede belirtelen işleme sokarsak normal dağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı
isimli bir sı ı ı ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
NormalDist nesnesi yaratı ı
standart sapma için 1 default değerleri kullanı ı
2024-04-02 13:01:04 +03:00
import statistics
nd = statistics.NormalDist(100, 15)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
NormalDist sı ı ı ı
2024-06-30 23:07:28 +03:00
toplam alanı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.cdf(0)
print(result) # 0.5
#----------------------------------------------------------------------------------------------------------------------------
Örneğin biz ortalaması ı ı ı ı ı ı ı ı
elde edebiliriz:
nd = statistics.NormalDist(100, 15)
result = nd.cdf(140) - nd.cdf(130)
2024-06-20 23:19:45 +03:00
Şöyle bir soru sorulduğunu düşünelim: "İnsanları ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Bu durumda zeka puanı ı ı ı ı ı ı ı
P{X > 140} olası ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
olmadı ı ı
2024-04-02 13:01:04 +03:00
nd = statistics.NormalDist(100, 15)
result = 1 - nd.cdf(140)
2024-06-20 23:19:45 +03:00
print(result) # 0.003830380567589775
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist(100, 15)
result = nd.cdf(140) - nd.cdf(130)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı
fonksiyonuyla F(x2) - F(x1) işlemi ile elde edebiliriz. Örneğin ortalaması ı ı ı
120 ile 130 arası ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import statistics
import numpy as np
nd = statistics.NormalDist(100, 15)
result = nd.cdf(130) - nd.cdf(120)
print(result)
import matplotlib.pyplot as plt
plt.title('P{120 < x <= 130} Olası ı ı
x = np.linspace(40, 160, 1000)
y = [nd.pdf(val) for val in x]
axis = plt.gca()
axis.set_ylim(-0.030, 0.030)
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_xticks(range(40, 170, 10))
plt.plot(x, y)
x = np.linspace(120, 130, 100)
y = [nd.pdf(val) for val in x]
axis.fill_between(x, y)
plt.text(120, -0.01, f'P{{120 < x <= 130}} = {result:.3f}', color='blue', fontsize=14)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Eskiden bilgisayarları ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
Bu tablolar belli bir Z değeri için (standart normal dağı ı ı ı ı
dağı ı ı
2024-04-02 13:01:04 +03:00
0.00 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09
0.0 0.5000 0.5040 0.5080 0.5120 0.5160 0.5199 0.5239 0.5279 0.5319 0.5359
0.1 0.5398 0.5438 0.5478 0.5517 0.5557 0.5596 0.5636 0.5675 0.5714 0.5753
0.2 0.5793 0.5832 0.5871 0.5910 0.5948 0.5987 0.6026 0.6064 0.6103 0.6141
0.3 0.6179 0.6217 0.6255 0.6293 0.6331 0.6368 0.6406 0.6443 0.6480 0.6517
0.4 0.6554 0.6591 0.6628 0.6664 0.6700 0.6736 0.6772 0.6808 0.6844 0.6879
0.5 0.6915 0.6950 0.6985 0.7019 0.7054 0.7088 0.7123 0.7157 0.7190 0.7224
0.6 0.7257 0.7291 0.7324 0.7357 0.7389 0.7422 0.7454 0.7486 0.7517 0.7549
0.7 0.7580 0.7611 0.7642 0.7673 0.7704 0.7734 0.7764 0.7794 0.7823 0.7852
0.8 0.7881 0.7910 0.7939 0.7967 0.7995 0.8023 0.8051 0.8078 0.8106 0.8133
0.9 0.8159 0.8186 0.8212 0.8238 0.8264 0.8289 0.8315 0.8340 0.8365 0.8389
1.0 0.8413 0.8438 0.8461 0.8485 0.8508 0.8531 0.8554 0.8577 0.8599 0.8621
1.1 0.8643 0.8665 0.8686 0.8708 0.8729 0.8749 0.8770 0.8790 0.8810 0.8830
1.2 0.8849 0.8869 0.8888 0.8907 0.8925 0.8944 0.8962 0.8980 0.8997 0.9015
......................................................................................
Bu tabloda ilgili hücredeki değer o Z değerinin kümülatif olası ı ı ı ı ı ı ı
2024-06-20 23:19:45 +03:00
böyle bir tablo kullanması ı ı
2024-04-02 13:01:04 +03:00
Pekiyi bu Z tabloları ı ı ı ı ı
2024-06-20 23:19:45 +03:00
kümülatif olası ı ı ı ı ı ı
dağı ı ı ı ı ı
dağı ı ı
2024-04-02 13:01:04 +03:00
Z = (x - mu) / std
2024-06-30 23:07:28 +03:00
Örneğin ortalaması ı ı ı ı ı
2.40'tür.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Belli bir kümülatif olası ı ı ı ı ı ı ı ı
Örneğin standart normal dağı ı ı ı ı ı
2024-06-30 23:07:28 +03:00
n = statistics.NormalDist()
2024-04-02 13:01:04 +03:00
result = nd.inv_cdf(0.99)
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.inv_cdf(0.99)
print(result) # 2.32
#----------------------------------------------------------------------------------------------------------------------------
2024-06-30 23:07:28 +03:00
Belli bir x değeri için Gauss fonksiyonunda ona karşı ı ı ı
için standart normal dağı ı ı
2024-04-02 13:01:04 +03:00
nd = statistics.NormalDist()
result = nd.pdf(0)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.pdf(0)
print(result) # 0.3989422804014327
#----------------------------------------------------------------------------------------------------------------------------
2024-06-30 23:07:28 +03:00
Normal dağı ı ı ı ı ı ı ı ı
sayı ı ı ı ı
Örneğin:
2024-04-02 13:01:04 +03:00
nd = statistics.NormalDist()
result = nd.samples(10)
Bu işlemden biz normal dağı ı
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.samples(10)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Biz normal dağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.samples(10000)
import matplotlib.pyplot as plt
plt.hist(result, bins=20)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi normal dağı ı ı ı ı ı
aralı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import random
import statistics
nd = statistics.NormalDist(100, 15)
result = [nd.inv_cdf(random.random()) for _ in range(10000)]
import matplotlib.pyplot as plt
2024-06-30 23:07:28 +03:00
plt.hist(result, bins=20)
2024-04-02 13:01:04 +03:00
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-06-30 23:07:28 +03:00
Aslı ı ı ı
bulundurulmuştur. gauss fonksiyonunun parametrik yapı ı
gauss(mu=0.0, sigma=1.0)
Python 3.11’ ı ı ı ı ı
gauss fonksiyonu kullanı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import random
2024-06-30 23:07:28 +03:00
result = [random.gauss(0, 1) for _ in range(10000)]
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-06-30 23:07:28 +03:00
plt.hist(result, bins=20)
2024-04-02 13:01:04 +03:00
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Python'ı ı ı ı ı
normal dağı ı ı ı
vektörel işlemler yapan sı ı ı
kütüphanesi tercih edilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
scipy.stats modülü içerisindeki "norm" isimli singleton nesne normal dağı ı
norm bir sı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
sı ı ı ı ı ı ı
ederler:
2024-04-02 13:01:04 +03:00
from scipy.stats import norm
norm nesnesine ilişkin sı ı ı ı
cdf(x, loc=0, scale=1)
Buradaki x bir NumPy dizisi ya da Python dolaşı ı ı ı
hesaplanı ı ı
result = norm.cdf([100, 130, 140], 100, 15)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm
result = norm.cdf([100, 130, 140], 100, 15)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
norm nesnesinin ilişkin olduğu sı ı ı ı
Yani kümülatif olası ı ı ı ı ı
sı ı ı ı ı
ppf(q, loc=0, scale=1)
ppf (percentage point function) ismi size biraz tuhaf gelebilir. Bu isim birikimli dağı ı
2024-04-19 00:21:20 +03:00
için kullanı ı ı ı ı ı ı
bölen noktayı ı ı ı
ortadan bölen değil de diğer noktalardan bölen değerler için "percentage point" de denilmektedir. Örneğin normal dağı ı
1/4 noktası ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm
result = norm.ppf([0.50, 0.68, 0.95], 100, 15)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
norm nesnesinin ilişkin olduğu sı ı ı
2024-04-02 13:01:04 +03:00
y değerlerini vermektedir. Metodun parametrik yapı ı
pdf(x, loc=0, scale=1)
2024-07-15 13:23:34 +03:00
Burada yine x hesaplanacak değeri, loc ortalamayı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
x = np.linspace(40, 160, 1000)
y = norm.pdf(x, 100, 15)
plt.plot(x, y)
x = np.full(200, 100) # 200 tane 100'lerden oluşan dizi
yend = norm.pdf(100, 100, 15)
y = np.linspace(0, yend, 200)
plt.plot(x, y, linestyle='--')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
norm nesnesinin ilişkin olduğu sı ı ı ı ı ı ı ı
Metodun parametrik yapı ı
rvs(loc=0, scale=1, size=1)
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm
import matplotlib.pyplot as plt
x = norm.rvs(100, 15, 10000)
plt.hist(x, bins=20)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı ı ı ı ı ı ı ı
0.68 civarı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
result = norm.cdf(1) - norm.cdf(-1)
print(result)
x = np.linspace(-5, 5, 1000)
y = norm.pdf(x)
plt.title('Ortalamadan 1 Standart Sapma Arası
axis = plt.gca()
axis.set_ylim(-0.5, 0.5)
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_xticks(range(-4, 5))
axis.text(2, 0.3, f'{result:.3f}', fontsize=14, fontweight='bold')
plt.plot(x, y)
x = np.linspace(-1, 1, 1000)
y = norm.pdf(x)
plt.fill_between(x, y)
axis.arrow(2.5, 0.25, -2, -0.1, width=0.0255)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı ı ı ı ı
olası ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
result = norm.cdf(2) - norm.cdf(-2)
print(result)
x = np.linspace(-5, 5, 1000)
y = norm.pdf(x)
plt.title('Ortalamadan 2 Standart Sapma Arası
axis = plt.gca()
axis = plt.gca()
axis.set_ylim(-0.5, 0.5)
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_xticks(range(-4, 5))
axis.text(2, 0.3, f'{result:.3f}', fontsize=14, fontweight='bold')
plt.plot(x, y)
x = np.linspace(-2, 2, 1000)
y = norm.pdf(x)
plt.fill_between(x, y)
axis.arrow(2.5, 0.25, -2, -0.1, width=0.0255)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Normal dağı ı ı ı ı ı
olası ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
result = norm.cdf(3) - norm.cdf(-3)
print(result)
x = np.linspace(-5, 5, 1000)
y = norm.pdf(x)
axis = plt.gca()
axis.set_ylim(-0.5, 0.5)
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_xticks(range(-4, 5))
axis.text(2, 0.3, f'{result:.3f}', fontsize=14, fontweight='bold')
plt.plot(x, y)
x = np.linspace(-3, 3, 1000)
y = norm.pdf(x)
plt.fill_between(x, y)
axis.arrow(2.5, 0.25, -2, -0.1, width=0.0255)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
Diğer çok karşı ı ı ı ı ı ı ı ı
dağı ı ı ı ı ı ı ı ı
dikdörtgensel bir alandı ı ı ı ı ı ı
dağı ı ı ı ı
2024-04-02 13:01:04 +03:00
f(x) = {
1 / (b - a) a < x < b
0 diğer durumlarda
}
2024-07-15 13:23:34 +03:00
Sürekli düzgün dağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Ancak SciPy içerisinde stats modülünde uniform isimli bir singleton nesne bulunmaktadı ı ı ı
2024-07-15 13:23:34 +03:00
cdf, ppf, pdf ve rvs metotları ı ı ı ı
2024-04-02 13:01:04 +03:00
Örneğin:
result = uniform.pdf(15, 10, 10)
Burada aslı ı ı ı ı
Tabii aslı ı ı ı ı
result = uniform.cdf(15, 10, 10)
2024-07-22 23:31:13 +03:00
Burada a = 10, b = 20 olan bir sürekli düzgün dağı ı
2024-04-19 00:21:20 +03:00
göre elde edilecek bu değer 0.5'tir. uniform nesnesinin metotları
2024-07-22 23:31:13 +03:00
üçüncü parametrenin a'dan uzaklı ı ı ı
stats modülünde tüm dağı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import uniform
import matplotlib.pyplot as plt
A = 10
B = 20
x = np.linspace(A - 5, B + 5, 1000)
y = uniform.pdf(x, A, B - A)
2024-07-15 13:23:34 +03:00
plt.title('Continuous Uniform Distribution', fontweight='bold')
2024-04-02 13:01:04 +03:00
plt.plot(x, y)
x = np.linspace(10, 12.5, 1000)
y = uniform.pdf(x, A, B - A)
plt.fill_between(x, y)
plt.show()
result = uniform.cdf(12.5, A, B - A)
print(result) # 0.25
result = uniform.ppf(0.5, A, B - A)
print(result) # 15
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Düzgün dağı ı ı ı ı
2024-04-19 00:21:20 +03:00
kütüphanesindeki random modülünde bulnan random fonksiyonu 0 ile 1 arası ı ı
2024-07-22 23:31:13 +03:00
a = 0, b = 1 olan düzgün dağı ı ı ı ı
2024-04-19 00:21:20 +03:00
modülündeki random fonksiyonu 0 ile 1 arası ı ı ı
2024-04-02 13:01:04 +03:00
result = uniform.rvs(10, 10, 10)
Burada a = 10, b = 20 olan sürekli düzgün dağı ı ı ı
Örneğin 100 ile 200 arası ı ı ı
uniform.rvs(100, 100, 10)
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import uniform
import numpy as np
x = np.random.random(10)
print(x)
x = uniform.rvs(0, 1, 10) # yukarı ı ı
print(x)
#----------------------------------------------------------------------------------------------------------------------------
Özellikle güven aralı ı ı
2024-08-22 19:31:50 +03:00
bir sürekli dağı ı ı ı ı ı ı ı ı ı ı ı
makalesini "Student" takma adı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
t dağı ı ı ı ı ı ı ı ı ı ı
derecesi (degrees of freedom)" denilen bir değere göre değişir. t dağı ı ı ı ı
2024-06-17 00:07:33 +03:00
biçimindedir. t dağı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
dağı ı ı ı ı ı ı ı ı ı
dağı ı ı ı ı ı
örtüşmektedir. Yani serbestlik derecesi >= 30 durumunda artı ı ı ı ı ı
arası ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
t dağı ı ı ı ı ı ı ı ı
Tabii t dağı ı ı ı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı ı ı
standart normal dağı ı
2024-04-02 13:01:04 +03:00
t dağı ı ı ı ı ı ı ı ı ı ı
testlerinde" kullanı ı ı ı ı
anakütle standart sapması ı ı ı ı ı ı ı ı ı
standart sapması ı ı ı
büyüklüğü >= 30 olduğu durumda zaten t dağı ı ı ı ı ı ı ı
yoğun kullanı ı ı ı ı ı ı ı ı
2024-06-17 00:07:33 +03:00
oluştursa da tercih edilebilmektedir.
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
t dağı ı ı ı ı
büyüklüğünden bir eksik olan" değerdir. Örneğin örneklem büyüklüğü 10 ise serbestlik derecesi 9'dur. Serbestlik derecesi
(dolayı ı ı ı ı ı ı ı ı ı ı
n >= 30 durumunda artı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
t dağı ı ı ı ı ı ı ı
bulunmamaktadı ı ı ı
kullanı ı ı ı ı ı
2024-08-22 19:31:50 +03:00
önce x değerini sonra serbestlik derecesini, sonra da ortalama değeri ve standart sapma değerlerini parametre olarak almaktadı
Ortalama ve standart sapma değerleri kullanı ı ı ı ı
dağı ı ı ı ı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı ı ı ı
olası ı ı ı ı ı ı
standart normal dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
import numpy as np
from scipy.stats import norm, t
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 10))
x = np.linspace(-5, 5, 1000)
y = norm.pdf(x)
axis = plt.gca()
axis.set_ylim(-0.5, 0.5)
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_xticks(range(-4, 5))
plt.plot(x, y)
y = t.pdf(x, 5)
plt.plot(x, y)
y = t.pdf(x, 30)
plt.plot(x, y, color='red')
2024-08-22 19:31:50 +03:00
plt.legend(['Standart Normal Dağı ı ı ı ı
't dağı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.show()
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Tabii standart normal dağı ı ı ı ı ı ı ı ı ı ı
kümülatif olası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, t
2024-09-16 10:49:44 +03:00
x = [-0.5, 0, 1, 1.25]s
2024-04-02 13:01:04 +03:00
result = norm.cdf(x)
print(result) # [0.30853754 0.5 0.84134475 0.89435023]
x = [-0.5, 0, 1, 1.25]
result = t.cdf(x, 5)
print(result) # [0.31914944 0.5 0.81839127 0.86669189]
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Biz bu konuda sürekli dağı ı ı ı ı ı ı ı ı ı ı ı ı
Aslı ı ı ı ı ı ı ı ı
içerisinde ele alacağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı ı ı ı
kesikli (discrete) dağı ı ı
Kesikli dağı ı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
fonksiyonlar elde edilemeyecek kesikli noktalar elde edilecektir. Kesikli dağı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
eşleyen fonksiyonlara "olası ı
olası ı ı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
doğrudan rassal değişkeninin ilgili noktadaki olası ı ı ı ı ı ı ı
genellikle büyük P ya da küçük p harfi ile gösterilmektedir:
px(x) = P{X = x}
Bu ifade X'in x değerine eşit olma olsı ı ı ı ı
bazı ı ı
toplamı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-17 00:07:33 +03:00
Tı ı ı ı ı ı ı ı ı ı ı
vardı ı ı ı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
kesikli dağı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-26 14:00:39 +03:00
P(X = x) = (e^-lamda * lamda^x) / x!
2024-04-02 13:01:04 +03:00
Dağı ı ı ı ı ı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
değeri belirtmektedir. Lamda ise ortalama olay sayı ı ı
2024-04-02 13:01:04 +03:00
bir değer olabilir. Ancak x değerleri 0, 1, 2, ... n biçiminde 0 ve pozitif tamsayı ı
Yukarı ı ı ı ı ı ı ı ı
karşı ı ı ı ı ı ı ı
2024-06-17 00:07:33 +03:00
"bir futbol maçı ı ı ı ı ı ı ı
belirtiyor olabilir. Bir olgunun poisson dağı ı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
ortalamadan iki yandan uzaklaştı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Poisson dağı ı ı ı ı
2024-06-17 00:07:33 +03:00
bulunmamaktadı ı ı
2024-04-02 13:01:04 +03:00
işlemler kolaylı ı
2024-06-17 00:07:33 +03:00
SciPy'da kesikli dağı ı ı ı
kullanı ı ı ı ı
2024-09-16 10:49:44 +03:00
Buradaki "pmf" ismi "probability mass function" sözcüklerinden kı ı ı ı
2024-04-02 13:01:04 +03:00
SciPy'daki poisson nesnesinin fonksiyonları
2024-06-17 00:07:33 +03:00
Örneğin futbol maçları ı ı ı ı ı ı ı ı ı ı
kabul edelim. Bu durumda bir maçta 5 gol olma olası ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-26 14:00:39 +03:00
from scipy.stats import poisson
2024-04-02 13:01:04 +03:00
result = poisson.pmf(5, 2)
print(result) # 0.03608940886309672
Yukarı ı ı ı ı ı ı ı ı
2024-09-16 10:49:44 +03:00
Sonra kişiden bazı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
soruyu nası ı ı ı ı
2024-06-17 00:07:33 +03:00
(x değeri de dahil olmak üzere) kümülatif olası ı ı ı ı ı ı ı
edebiliriz:
2024-04-02 13:01:04 +03:00
result = 1 - poisson.cdf(2, 2)
print(result) # 0.3233235838169366
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-26 14:00:39 +03:00
Aşağı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
grafiğini andı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import poisson
import matplotlib.pyplot as plt
2024-08-26 14:00:39 +03:00
plt.title('Lamda = 10 İçin Poisson Dağı ı ı
2024-04-02 13:01:04 +03:00
x = range(0, 40)
2024-08-26 14:00:39 +03:00
y = poisson.pmf(x, 10)
2024-04-02 13:01:04 +03:00
plt.scatter(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-06-17 00:07:33 +03:00
Poisson dağı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import poisson
import matplotlib.pyplot as plt
2024-08-26 14:00:39 +03:00
plt.title('Lamda = 100 İçin Poisson Dağı ı ı
2024-04-02 13:01:04 +03:00
x = range(0, 200)
y = poisson.pmf(x, 100)
plt.scatter(x, y)
plt.show()
result = poisson.pmf(3, 4)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Bernoulli dağı ı ı ı ı ı ı ı
X = 1 durumu ise bir olayı ı ı ı ı ı
değer aldı ı
bir paranı ı ı ı ı ı
Bernouli deneylerinde genellikle X = 1 durumundaki olası ı ı ı ı ı
olası ı ı ı ı ı ı ı ı
P{X = x} = {
p X = 1 ise
1 - p X = 0 ise
}
Ya da bu olası ı ı
P{X = x} = p^x * (1 - p)^(1 - x)
Burada X = 0 için 1 - p değerinin X = 1 için p değerinin elde edildiğine dikkat ediniz.
Bernoulli dağı ı ı
Tabii bu dağı ı ı ı ı
2024-06-17 00:07:33 +03:00
ilişkin olduğu sı ı ı ı ı
2024-04-02 13:01:04 +03:00
bernoulli.pmf(0, 0.7)
buradan 0.3 değeri elde edilecektir.
----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-26 14:00:39 +03:00
Diğer çok karşı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
(yani iki sonucu olan bir deney) toplam n defa yinelenmektedir. Bu n defa yinelenmede olayı
sonuçlanacağı ı ı ı ı ı ı ı ı ı ı ı ı
0, 1, 2, ... gibi tamsayı ı ı ı ı ı
3 kez Tura gelme olası ı ı ı ı ı ı
olumlu kabul ettiğimiz Tura gelme durumunun toplamda 3 kez olması ı ı ı ı
2024-08-26 14:00:39 +03:00
Binom dağı ı ı ı ı ı ı ı
paranı ı ı ı
2024-04-02 13:01:04 +03:00
T Y T Y T
T T T Y Y
Y T T Y T
...
Burada toplamda 3 kez Tura gelme durumu aslı ı
p^3 değerini çarpmamı ı ı ı ı ı
(1 - p)^2 ile çarpı ı ı ı ı ı ı ı
P{X = x} = C(n, x)p^x * (1 - p)^(n - x)
Binom dağı ı ı ı
2024-08-26 14:00:39 +03:00
kullanı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
belirtmektedir. Bu fonksiyonlarda birinci parametre "olumlu gerçekleşme sayı ı ı ı ı ı
2024-08-26 14:00:39 +03:00
ve üçüncü parametre de "olumlu gerçekleşme olası ı ı ı ı ı
2024-04-02 13:01:04 +03:00
atı ı ı ı ı
binom.pmf(3, 5, 0.5)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şüphesiz "sonuç çı ı ı
theorem)" denilen teoremdir. Bu teorem George Pólya tarafı ı ı
2024-08-26 14:00:39 +03:00
Merkezi limit teoreminin biçimsel ifadesi biraz karmaşı ı ı
Bu teoreme göre bir anakütleden elde edilen örnek ortalamaları ı ı ı
küçük örneklerin ortalamaları ı ı ı ı ı ı ı ı
için örneklerin belli bir büyüklükte (tipik olarak >= 30) olması ı ı ı
da sağdan çarpı ı
kümeleri yani örnekleri elde edip bunları ı ı ı ı ı ı
anakütleden alı
2024-04-02 13:01:04 +03:00
2024-08-26 14:00:39 +03:00
Aşağı ı ı ı ı ı
100,000 tane 50'lik rastgele örnekler elde edilmiştir. Sonra da elde edilen bu örneklerin ortalamaları ı
ortalamaları ı ı ı ı ı ı ı ı ı
dikkat ediniz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-08-26 14:00:39 +03:00
POPULATION_RANGE = 1_000_000
NSAMPLES = 100_000
2024-04-02 13:01:04 +03:00
SAMPLE_SIZE = 50
2024-08-27 01:07:02 +03:00
samples = np.random.randint(0, POPULATION_RANGE + 1, (NSAMPLES, SAMPLE_SIZE))
2024-04-02 13:01:04 +03:00
samples_means = np.mean(samples, axis=1)
2024-08-26 14:00:39 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 8))
plt.title('Merkezi Limit Teoremi', fontweight='bold', pad=10)
2024-04-02 13:01:04 +03:00
plt.hist(samples_means, bins=50)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Tabii yukarı
#----------------------------------------------------------------------------------------------------------------------------
import random
import statistics
2024-08-26 14:00:39 +03:00
POPULATION_RANGE = 1_000_000
NSAMPLES = 100_000
2024-04-02 13:01:04 +03:00
SAMPLE_SIZE = 50
2024-08-27 01:07:02 +03:00
samples_means = [statistics.mean(random.sample(range(POPULATION_RANGE + 1), SAMPLE_SIZE)) for _ in range(NSAMPLES)]
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-08-26 14:00:39 +03:00
plt.figure(figsize=(12, 8))
plt.title('Merkezi Limit Teoremi', fontweight='bold', pad=10)
2024-04-02 13:01:04 +03:00
plt.hist(samples_means, bins=50)
2024-08-26 14:00:39 +03:00
2024-04-02 13:01:04 +03:00
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-08-26 14:00:39 +03:00
Merkezi limit teoremine göre örnek ortalamaları ı ı ı ı ı
2024-04-02 13:01:04 +03:00
(Yani bir anakütleden çekilen örnek ortalamaları ı ı ı ı ı
2024-08-26 14:00:39 +03:00
bu durum aşağı
2024-04-02 13:01:04 +03:00
2024-08-26 14:00:39 +03:00
Muxbar = Mu (Mu yerine mu sembolü xbar yer yerine de x üstü çizgi olduğunu varsayı ı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı ı
ortalaması ı ı
2024-09-16 10:49:44 +03:00
örneği almamı ı ı ı ı
2024-04-02 13:01:04 +03:00
elde edilebilir. Bu aşağı
328392407820232468120659145980537063071733850478231049855714233423603813357488386226050559849769116542462344220085901
45569291064005813572729171162888456999821437660641232861427083961136203001102459836375149013720622748800690778924980000
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-08-27 01:07:02 +03:00
POPULATION_RANGE = 1_000_000
NSAMPLES = 100_000
2024-04-02 13:01:04 +03:00
SAMPLE_SIZE = 50
2024-08-27 01:07:02 +03:00
population_mean = np.mean(range(POPULATION_RANGE + 1))
samples = np.random.randint(1, POPULATION_RANGE + 1, (NSAMPLES, SAMPLE_SIZE))
2024-04-02 13:01:04 +03:00
samples_means = np.mean(samples, axis=1)
samples_means_mean = np.mean(samples_means)
print(f'Anakütle ortalaması
print(f'Örnek ortalamaları ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Yukarı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
ortalaması ı ı ı ı ı ı ı
merkezi limit teoremine göre örnek ortalamaları ı ı ı
2024-08-27 01:07:02 +03:00
Yani örnek ortalamaları ı ı ı ı ı
ortalamaları ı ı ı
ilişkin normal dağı ı ı ı ı
örnek büyüklüğü artı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-27 01:07:02 +03:00
Aşağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
uygunluğu gösterilmektedir. Bu bu örnekte de aslı ı ı ı ı ı
değerlerden bir sapma söz konusu olacaktı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-08-27 01:07:02 +03:00
POPULATION_RANGE = 1_000_000
NSAMPLES = 100_000
2024-04-02 13:01:04 +03:00
SAMPLE_SIZE = 50
2024-08-27 01:07:02 +03:00
population_mean = np.mean(range(POPULATION_RANGE + 1))
population_std = np.std(range(POPULATION_RANGE + 1))
2024-04-02 13:01:04 +03:00
2024-08-27 01:07:02 +03:00
samples = np.random.randint(1, POPULATION_RANGE + 1, (NSAMPLES, SAMPLE_SIZE))
2024-04-02 13:01:04 +03:00
samples_means = np.mean(samples, axis=1)
samples_means_mean = np.mean(samples_means)
sample_means_std = np.std(samples_means)
print(f'Anakütle ortalaması
print(f'Örnek ortalamaları ı ı
print(f'Fark: {np.abs(population_mean - samples_means_mean)}')
print(f'Merkezi limit teroreminden elde edilen örnek ortalamaları ı ı
print(f'Örnek ortalamaları ı ı
#----------------------------------------------------------------------------------------------------------------------------
Merkezi limit teoremine göre eğer anakütleden çekilen örnekler büyükse yani tipik olarak n örnek büyüklüğü, N ise anakütle
büyüklüğü olmak üzere n / N >= 0.05 ise bu durumda örneklem dağı ı ı ı ı
değeri "düzeltme faktörü (correction factor)" denilen bir çarpanla çarpı ı ı
biçimindedir. Bu konunun ayrı ı ı
Biz 30 elemanlı ı ı
oldukça küçük olma eğilmindedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-27 01:07:02 +03:00
Yukarı ı ı ı ı ı ı
0'dan 1,000,000'a kadar sayı ı ı
2024-04-02 13:01:04 +03:00
aşağı
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
2024-08-27 01:07:02 +03:00
POPULATION_RANGE = 1_000_000
population = range(0, POPULATION_RANGE + 1)
2024-04-02 13:01:04 +03:00
2024-08-27 01:07:02 +03:00
plt.figure(figsize=(12, 8))
plt.title('Merkezi Limit Teoremi', fontweight='bold', pad=10)
2024-04-02 13:01:04 +03:00
plt.hist(population, bins=50)
#----------------------------------------------------------------------------------------------------------------------------
Merkezi limit teoreminde anakütlenin normal dağı ı ı ı
"düzgün dağı ı ı ı
örneklem ortalamaları ı ı ı ı ı ı ı
Bu değer tipik olarak >= 30 biçimindedir. Tabii örnek büyüklüğü 30'dan küçükse de dağı ı ı ı
Ancak anakütlenin normal dağı ı ı ı ı ı ı
alı ı ı ı ı
limit teoreminden faydalanı ı
(non-paranmetric) yöntemler" denilen yöntemler tercih edilmelidir.
Buradan çı
- Eğer anakütle normal dağı ı ı ı ı ı ı
- Eğer anakütle normal dağı ı ı ı ı ı ı ı ı
olması ı ı ı ı
Özetle anakütle normal dağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Parametrik istatistiksel yöntemler genel olarak anakütle ve/veya örneklem dağı ı ı ı ı ı
Bu nedenle bazen anakütlenin normal dağı ı ı ı ı ı ı
anakütleden bir örnek alı ı ı ı ı ı ı ı
(confidence level)" belirlenir. Buna "normallik testleri" denilmektedir. Aslı
yapı ı ı
biz anakütlenin de normal dağı ı ı ı ı ı ı ı
için bazı ı ı ı ı
vardı ı ı ı ı ı ı
içermektedir. Biz bu bölümde bu konuda ayrı ı ı ı ı
içerisinde ayrı ı ı ı
Hipotez testlerinde bir hipotez öne sürülür ve bu hipotezin belirli güven düzeyi içerisinde doğrulanı ı ı ı ı
Genel olarak bizim doğrulanması ı
yani arzu edilmeyen durumu belirten hipoteze de H1 hipotezi denilmektedir. Örneğin normallik testindeki H0 ve H1 hipotezleri
şöyle oluşturulabilir:
2024-04-02 13:01:04 +03:00
H0: Seçilen örnek normal bir anakütleden gelmektedir.
H1: Seçilen örnek normal dağı ı
2024-09-16 10:49:44 +03:00
Normallik testlerinden birisi Kolmogorov-Smirnov testidir (test ünlü Sovyet matematikçisi ve istatistikçisi Andrey Kolmogorov
ve Nikolai Smirnov tarafı ı ı
bulunan kstest fonksiyonuyla uygulanabilmektedir. Fonksiyonun parametrik yapı ı
kstest(rvs, cdf, args=(), N=20, alternative='two-sided', method='auto', *, axis=0, nan_policy='propagate', keepdims=False)
Fonksiyonunun ilk iki parametresi zorunlu parametrelerdir. Birinci parametre anakütleden rastgele seçilen örneği, ikinci
parametre testi yapı ı ı ı ı ı ı ı
yazı ı ı ı ı ı
kullanı
parametrelerini SciPy dokümanları ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
kstest fonksiyonu çağrı ı
isimli ilk elemanı ı ı
p değerinin kendi seçtiğimiz belli bir kritik değerden büyük olup olmadı ı ı
olarak alı ı ı ı ı
gibi bu testte iki hipotez vardı
2024-04-02 13:01:04 +03:00
H0: Seçilen örnek normal dağı ı
H1: Seçilen örnek normal dağı ı
2024-09-16 10:49:44 +03:00
Eğer test sonucunda elde ettiğimiz "p değeri belirlediğimiz kritik değereden (0.05) büyükse H0 hipotezi kabul edilir,
H1 hipotezi reddedilir. Eğer bu p değeri bu kritik değerden küçükse H0 hipotezi reddedilip, H1 hipotezi kabul edilmektedir.
Yani özetle bu p değeri 0.05 gibi bir kritik değerden büyükse örnek normal dağı ı
bir kritik değereden küçükse örnek normal dağı ı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı ı
2024-09-16 10:49:44 +03:00
fonksiyonuna sokulmuştur. Burada birinci örnek için p değeri 1’ ı ’ ı ı ı ı
Böylece birinci örneğin alı ı ı ı ı ı ı ı
dağı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, uniform, kstest
sample_norm = norm.rvs(size=1000)
result = kstest(sample_norm, 'norm')
print(result.pvalue) # 1'e yakı
sample_uniform = uniform.rvs(size=1000)
result = kstest(sample_uniform, norm.cdf)
print(result.pvalue) # 0'a çok yakı
#----------------------------------------------------------------------------------------------------------------------------
17. Ders - 24/02/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
kstest fonksiyonunda ikinci parametreye 'norm' girildiğinde birinci parametredeki değerler ortalaması ı
1 olan standart normal dağı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
test yapı ı ı ı ı ı
sapması ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, uniform, kstest
sample_norm = norm.rvs(100, 15, size=1000)
2024-09-16 10:49:44 +03:00
result_norm = kstest(sample_norm, 'norm', args=(100, 15))
2024-04-02 13:01:04 +03:00
sample_uniform = uniform.rvs(100, 100, size=1000)
2024-09-16 10:49:44 +03:00
result_uniform = kstest(sample_uniform, 'norm', args=(100, 15))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(20, 8))
ax1 = plt.subplot(1, 2, 1)
ax1.set_title(f'p değeri: {result_norm.pvalue}', pad=15, fontweight='bold')
ax2 = plt.subplot(1, 2, 2)
ax2.set_title(f'p değeri: {result_uniform.pvalue}', pad=15, fontweight='bold')
ax1.hist(sample_norm, bins=20)
ax2.hist(sample_uniform, bins=20)
plt.show()
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Shapiro-Wilk testi scipy.stats modülündeki shapiro fonksiyonuyla yapı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
shapiro(x, *, axis=None, nan_policy='propagate', keepdims=False)
Bu fonksiyonun kullanı ı ı ı
çekilen örneği belirtir. Buradaki normal dağı ı
dağı ı ı ı
Aşağı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
örnek seçilip Shapiro-Wilk testine sokulmuştur. Buradan elde edine pvalue değerlerine dikkat ediniz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, uniform, shapiro
sample_norm = norm.rvs(100, 15, size=1000)
2024-09-16 10:49:44 +03:00
result_norm = shapiro(sample_norm)
2024-04-02 13:01:04 +03:00
sample_uniform = uniform.rvs(100, 100, size=1000)
2024-09-16 10:49:44 +03:00
result_uniform = shapiro(sample_uniform)
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(20, 8))
ax1 = plt.subplot(1, 2, 1)
ax1.set_title(f'p değeri: {result_norm.pvalue}', pad=15, fontweight='bold')
ax2 = plt.subplot(1, 2, 2)
ax2.set_title(f'p değeri: {result_uniform.pvalue}', pad=15, fontweight='bold')
ax1.hist(sample_norm, bins=20)
ax2.hist(sample_uniform, bins=20)
plt.show()
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi Kolmogorov-Simirnov testi ile Shapiro-Wilk testi arası ı ı ı ı ı ı
spesifik farklı ı ı ı ı
Shapiro-Wilk testinin kullanı ı ı ı
2024-09-16 10:49:44 +03:00
testi Kolmogorov-Simirnov testine göre daha iyi bir sonucun elde edilmesine yol açmaktadı
2024-04-02 13:01:04 +03:00
testini tercih edebilirsiniz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-03 14:16:20 +03:00
İstatistikte örneğe dayalı ı ı ı ı
tahmini (parameter estimation)" denilmektedir. Parametre tahmini "noktasal olarak (point estimate)" ya da "aralı
olarak (interval estimate)" yapı ı ı ı
güven düzeyinde tahmin edilmesi önemli bir konudur. Böylece biz anakütlenin tamamı ı ı ı ı
bir örneğe bakarak anakütle ortalaması ı ı
2024-09-25 13:52:00 +03:00
Anakütle parametrelerinin aralı ı ı ı ı
tamamen merkezi limit teroremi kullanı ı ı ı ı
uygulamaları
2024-09-16 10:49:44 +03:00
Güven aralı ı ı
level) içerisinde aralı
örneklemlerin ortalamaları ı ı ı ı ı
ortalaması ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
Bizim anakütle ortalaması ı ı ı ı ı
anakütle standart sapması ı ı
2024-09-25 13:52:00 +03:00
o örneğin ortalaması ı ı ı
ki: Örneğin seçtiğimiz güven düzeyi %95 olsun. Bu durumda bizim örneğimiz örnek ortalamaları ı ı ı ı ı ı
2024-09-16 10:49:44 +03:00
soldan 0.025 ve sağdan 0.975 kümülatif olası ı ı ı ı
ortalaması ı ı ı ı ı ı ı
edilmesidir. Bu durumda anakütle ortalaması ı ı ı
basit olarak "rastgele elde ettiğimiz örneğin ortalaması ı ı ı ı
kümülatif olası ı ı ı
2024-04-02 13:01:04 +03:00
Örneğin standart sapması ı ı ı ı
109 olduğunu varsayalı ı ı ı ı
elde edilebilir:
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.025, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.975, sample_mean, sampling_mean_std)
2024-09-25 13:52:00 +03:00
print(f'[{lower_bound}, {upper_bound}]') # [105.20454606435501, 112.79545393564499]
2024-04-02 13:01:04 +03:00
Burada biz anakütlenin standart sapması ı ı ı ı ı ı ı
hesaplayabildik. Buradan elde ettiğimiz güven aralı ı ı
2024-09-25 13:52:00 +03:00
[105.20454606435501, 112.79545393564499]
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
Güven düzeyini yükseltirsek güven aralı ı ı ı ı
belirlemiş olalı
2024-04-02 13:01:04 +03:00
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.005, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.995, sample_mean, sampling_mean_std)
2024-09-25 13:52:00 +03:00
print(f'[{lower_bound}, {upper_bound}]') [104.01192800234102, 113.98807199765896]
2024-04-02 13:01:04 +03:00
Burada güven aralı ı ı ı
2024-09-25 13:52:00 +03:00
[104.01192800234102, 113.98807199765896]
2024-04-02 13:01:04 +03:00
Gördüğünüz gibi aralı
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.025, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.975, sample_mean, sampling_mean_std)
2024-09-25 13:52:00 +03:00
print(f'[{lower_bound}, {upper_bound}]') # [105.20454606435501, 112.79545393564499]
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.005, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.995, sample_mean, sampling_mean_std)
print(f'{lower_bound}, {upper_bound}') # 104.01192800234102, 113.98807199765896
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı
Örnek ortalamaları ı ı ı ı ı ı
yaklaşacağı ı ı ı ı ı
güven aralı ı ı ı ı ı ı ı
büyüklükleri için %99 güven düzeyinde güven aralı ı ı
sample size: 30: [103.63241756884852, 114.36758243115148]
sample size: 35: [104.03058429805395, 113.96941570194605]
sample size: 40: [104.35153725771579, 113.64846274228421]
sample size: 45: [104.61738729711709, 113.38261270288291]
sample size: 50: [104.84228852695097, 113.15771147304903]
sample size: 55: [105.03577765357056, 112.96422234642944]
sample size: 60: [105.20454606435501, 112.79545393564499]
sample size: 65: [105.3534458105975, 112.6465541894025]
sample size: 70: [105.48609245861904, 112.51390754138096]
sample size: 75: [105.60524279777148, 112.39475720222852]
sample size: 80: [105.71304047283782, 112.28695952716218]
sample size: 85: [105.81118086644236, 112.18881913355763]
sample size: 90: [105.9010248384772, 112.0989751615228]
sample size: 95: [105.98367907149301, 112.01632092850699]
sample size: 100: [106.06005402318992, 111.93994597681008]
Buradan da gördüğünüz gibi örneği büyüttüğümüzde güven aralı ı ı
edilmektedir. Örnek büyüklüğünün artı ı ı ı ı ı
2024-09-25 13:52:00 +03:00
noktadan sonra bu daralma azalmaya başlamaktadı
2024-04-02 13:01:04 +03:00
büyüklüğünün makul seçilmesi önemli olmaktadı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
population_std = 15
sample_mean = 109
for sample_size in range(30, 105, 5):
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.025, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.975, sample_mean, sampling_mean_std)
print(f'sample size: {sample_size}: [{lower_bound}, {upper_bound}]')
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı
büyük olması ı ı ı ı ı
2024-09-25 13:52:00 +03:00
bizim örnekleri >= 30 olacak biçimde seçmemiz uygun olur.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi eskiden bilgisayarları ı ı ı ı
hale getirmek için ortalaması ı ı ı ı ı ı
tablosu dendiğini anı ı ı ı ı ı
değerleri dendiğini anı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı ı ı ı
2024-09-25 13:52:00 +03:00
güven aralı ı ı ı
2024-04-02 13:01:04 +03:00
Z değerine aşağı ı ı ı
2024-09-25 13:52:00 +03:00
Z = (x - mu) / sigma
2024-04-02 13:01:04 +03:00
O halde buaradki X örneğin ortalaması ı ı ı ı ı ı
üzere Z tablosuna dayalı ı ı ı
xbar ⩲ Z * sigma_xbar
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
upper_bound = sample_mean + norm.ppf(0.975) * sampling_mean_std
lower_bound = sample_mean - norm.ppf(0.975) * sampling_mean_std
2024-09-25 13:52:00 +03:00
print(f'[{lower_bound}, {upper_bound}]') # [105.20454606435501, 112.79545393564499]
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Örnekten hareketle anakütle ortalamaları ı ı ı ı
elde edilebilmektedir. interval metodunun parametrik yapı ı
interval(confidence, loc=0, scale=1)
Metodun birinci parametresi olan confidence güven düzeyini belirtmektedir. Örneğin %95 güven düzeyi için bu parametre 0.95
2024-09-25 13:52:00 +03:00
girilmelidir. Metodun ikinci ve üçüncü parametreleri (loc ve scale parametreleri) örneğin ortalaması ı ı ı ı ı
standart sapması ı ı ı
sapması ı ı ı ı ı
bir demetle geri döner. Demetin ilk elemanı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Bu durumda yukarı ı
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
2024-09-25 13:52:00 +03:00
2024-04-02 13:01:04 +03:00
lower_bound, upper_bound = norm.interval(0.95, sample_mean, sampling_mean_std)
print(f'{lower_bound}, {upper_bound}')
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
sample_size = 60
population_std = 15
sample_mean = 109
sampling_mean_std = population_std / np.sqrt(sample_size)
lower_bound = norm.ppf(0.025, sample_mean, sampling_mean_std)
upper_bound = norm.ppf(0.975, sample_mean, sampling_mean_std)
print(f'{lower_bound}, {upper_bound}')
lower_bound, upper_bound = norm.interval(0.95, sample_mean, sampling_mean_std)
print(f'{lower_bound}, {upper_bound}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
Bu değerlerin anakütleyi oluşturduğu varsayı ı ı ı
2024-09-25 13:52:00 +03:00
edilmştir. Bu örneğe dayanı ı
2024-04-02 13:01:04 +03:00
ekrana yazdı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import norm
POPULATION_SIZE = 1_000_000
SAMPLE_SIZE = 60
population = norm.rvs(100, 15, POPULATION_SIZE)
population_mean = np.mean(population)
population_std = np.std(population)
print(f'population mean: {population_mean}')
print(f'population std: {population_std}')
sample = np.random.choice(population, SAMPLE_SIZE)
sample_mean = np.mean(sample)
sampling_mean_std = population_std / np.sqrt(SAMPLE_SIZE)
print(f'sample mean: {sample_mean}')
lower_bound, upper_bound = norm.interval(0.95, sample_mean, sampling_mean_std)
print(f'[{lower_bound}, {upper_bound}]')
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı ı
anakütle ortalaması ı ı
2024-09-25 13:52:00 +03:00
anakütle ortalaması ı ı ı ı ı ı
standart sapmasymı ı ı ı ı ı ı ı ı ı ı
William Gosset t dağı ı ı ı ı ı ı ı ı
standart sapması ı ı ı ı ı ı
bir dağı ı ı
2024-04-19 00:21:20 +03:00
t dağı ı ı ı ı ı ı
eksik değeridir. Ayrı ı ı ı ı ı ı
2024-09-25 13:52:00 +03:00
Çektiğimiz örneğin standart sapması ı ı ı ı
bölünerek hesaplanmalı ı ı ı ı ı ı ı ı ı
üzerinde durmayacağı ı ı
standart sapmaları
Anı ı ı ı ı
of freedom)" deniyordu. Standart sapma ya da varyans hesabı ı ı
ddof parametreleri default 0 iken Pandas'da 1'dir.) Yani bu ddof parametresi (N - değer)'deki değeri belirtmektedir. Örneğin
ddof = 0 ise bölme N'e ddof = 1 ise bölme (N - 1)'e yapı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Örneğin anakütleden aşağı ı
2024-04-02 13:01:04 +03:00
sample = np.array([101.93386212, 106.66664836, 127.72179427, 67.18904948, 87.1273706 , 76.37932669, 87.99167058, 95.16206704,
101.78211828, 80.71674993, 126.3793041 , 105.07860807, 98.4475209 , 124.47749601, 82.79645255, 82.65166373, 92.17531189,
117.31491413, 105.75232982, 94.46720598, 100.3795159 , 94.34234528, 86.78805744, 97.79039692, 81.77519378, 117.61282039,
109.08162784, 119.30896688, 98.3008706 , 96.21075454, 100.52072909, 127.48794967, 100.96706301, 104.24326515, 101.49111644])
Anakütlenin standart sapması ı ı ı ı ı
şöyle oluşturabiliriz:
import numpy as np
from scipy.stats import t
sample = np.array([101.93386212, 106.66664836, 127.72179427, 67.18904948, 87.1273706 , 76.37932669,
87.99167058, 95.16206704, 101.78211828, 80.71674993, 126.3793041 , 105.07860807,
98.4475209 , 124.47749601, 82.79645255, 82.65166373, 92.17531189, 117.31491413,
105.75232982, 94.46720598, 100.3795159 , 94.34234528, 86.78805744, 97.79039692,
81.77519378, 117.61282039, 109.08162784, 119.30896688, 98.3008706 , 96.21075454,
100.52072909, 127.48794967, 100.96706301, 104.24326515, 101.49111644])
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
sampling_mean_std = sample_std / np.sqrt(len(sample))
lower_bound = t.ppf(0.025, len(sample) - 1, sample_mean, sampling_mean_std)
upper_bound = t.ppf(0.975, len(sample) - 1, sample_mean, sampling_mean_std)
2024-09-25 13:52:00 +03:00
print(f'[{lower_bound}, {upper_bound}]') # [94.81902512213665, 105.0959541612919]
2024-04-02 13:01:04 +03:00
Burada örneğin standart sapması ı ı ı ı ı ı ı ı ı
değil t dağı ı ı ı ı ı ı
2024-09-25 13:52:00 +03:00
örnek büyüklüğünün bir eksik değeri olarak alı ı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Örneklem dağı ı ı ı ı ı ı ı ı
sem isimli bir fonksiyon da bulunmaktadı ı ı
2024-04-02 13:01:04 +03:00
sample_std = np.std(sample, ddof=1)
sampling_mean_std = sample_std / np.sqrt(len(sample))
Bu işlem tek hamlede sem fonksiyonuyla da yapı
sampling_mean_std = sem(sample)
2024-09-25 13:52:00 +03:00
30 serbestlik derecesinden sonra artı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
örnek büyüklüğü 35'tir. Örnek büyüklüğü >= 30 durumunda t dağı ı ı ı ı
2024-09-25 13:52:00 +03:00
bu örnekte t dağı ı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı
ayrı ı ı
Dolayı ı ı ı ı ı ı ı
işlemleri bilgisayarlarla yaptı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import t
sample = np.array([101.93386212, 106.66664836, 127.72179427, 67.18904948, 87.1273706 , 76.37932669,
87.99167058, 95.16206704, 101.78211828, 80.71674993, 126.3793041 , 105.07860807,
98.4475209 , 124.47749601, 82.79645255, 82.65166373, 92.17531189, 117.31491413,
105.75232982, 94.46720598, 100.3795159 , 94.34234528, 86.78805744, 97.79039692,
81.77519378, 117.61282039, 109.08162784, 119.30896688, 98.3008706 , 96.21075454,
100.52072909, 127.48794967, 100.96706301, 104.24326515, 101.49111644])
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
sampling_mean_std = sample_std / np.sqrt(len(sample))
lower_bound = t.ppf(0.025, len(sample) - 1, sample_mean, sampling_mean_std)
upper_bound = t.ppf(0.975, len(sample) - 1, sample_mean, sampling_mean_std)
print(f'[{lower_bound}, {upper_bound}]')
#----------------------------------------------------------------------------------------------------------------------------
18. Ders - 25/02/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Tı ı ı ı
2024-04-19 00:21:20 +03:00
bulunmaktadı ı ı ı ı ı ı ı ı
parametrik yapı ı
2024-04-02 13:01:04 +03:00
interval(confidence, df, loc=0, scale=1)
Buradaki confidence parametresi yine "güven düzeyini (confidence level)" belirtmektedir. df parametresi serbestlik derecesini
2024-09-25 13:52:00 +03:00
belirtir. loc ve scale parametreleri de sı ı
biz örneğimizin ortalaması ı ı ı ı ı ı ı ı ı ı ı
standart sapması ı ı ı ı ı
geri döndürmektedir. Örneğin:
2024-04-02 13:01:04 +03:00
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
sampling_mean_std = sample_std / np.sqrt(len(sample))
lower_bound, upper_bound = t.interval(0.95, len(sample) - 1, sample_mean, sampling_mean_std)
print(f'[{lower_bound}, {upper_bound}]')
Burada sample örneğine dayanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.stats import t
sample = np.array([101.93386212, 106.66664836, 127.72179427, 67.18904948, 87.1273706 , 76.37932669,
87.99167058, 95.16206704, 101.78211828, 80.71674993, 126.3793041 , 105.07860807,
98.4475209 , 124.47749601, 82.79645255, 82.65166373, 92.17531189, 117.31491413,
105.75232982, 94.46720598, 100.3795159 , 94.34234528, 86.78805744, 97.79039692,
81.77519378, 117.61282039, 109.08162784, 119.30896688, 98.3008706 , 96.21075454,
100.52072909, 127.48794967, 100.96706301, 104.24326515, 101.49111644])
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
sampling_mean_std = sample_std / np.sqrt(len(sample))
lower_bound = t.ppf(0.025, len(sample) - 1, sample_mean, sampling_mean_std)
upper_bound = t.ppf(0.975, len(sample) - 1, sample_mean, sampling_mean_std)
print(f'[{lower_bound}, {upper_bound}]')
lower_bound, upper_bound = t.interval(0.95, len(sample) - 1, sample_mean, sampling_mean_std)
print(f'[{lower_bound}, {upper_bound}]')
2024-10-03 14:16:20 +03:00
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Ana kütlenin standart sapması ı
2024-04-09 13:15:47 +03:00
ana kütlenin normal dağı ı ı ı ı
2024-04-02 13:01:04 +03:00
örnek yeteri kadar büyükse (tipik olarak >= 30) ana kütlenin hesaplamalarda normal dağı ı ı
t dağı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
>= 30) t dağı ı ı ı
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
Pekiyi örneğimiz küçükse (tipik olarak < 30) ve ana kütle normal dağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
bu tür durumlarda güven aralı ı ı ı ı
yöntemler kullanı ı
sonuçlar vermektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesi ve veri bilimi uygulamaları ı ı
gerekmektedir. Kursumuzun bu bölümünde biz "verilerin kullanı ı
duracağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Her türlü veri analizi, veri bilimi ve makine öğrenmesi uygulaması ı ı
2024-10-03 14:16:20 +03:00
verilerin elde edilmesi elde edilmesi" aşaması ı ı ı
"anket (survey)" yoluyla veriler toplanabilir. Günümüzde sensör teknolojilerinin de gelişmesiyle verilerin otomatik olarak
toplanması ı ı ı ı ı
medyadaki yazı ı ı ı
ya da topluluklar tarafı ı ı ı
başka kurumlar ve topluluklar tarafı ı ı
web sitelerine üye olmanı ı ı
ederiz. Kaggle 2010 yı ı ı ı ı ı ı ı ı
2024-10-11 00:32:36 +03:00
Veriler toplandı ı ı ı ı
Verilerin dosyalarda saklanmsı ı
2024-10-08 00:12:04 +03:00
öğrenmesi ve veri bilimi uygulamaları ı ı ı
2024-10-11 00:32:36 +03:00
Eğer veriler veritabanları ı ı ı ı ı
2024-10-03 14:16:20 +03:00
çekmesi gerekebilir. Bazı
2024-10-08 00:12:04 +03:00
genellikle "CSV" ve "HDF (Hierarchical Data Format)" formatları ı ı ı ı
verileri veritabanları
2024-04-02 13:01:04 +03:00
2024-10-11 00:32:36 +03:00
İstatistik ve veri biliminde organize edilmiş veri toplulukları
tipik olarak bir tablo gibi sütunlardan ve satı
(feature)", satı ı ı ı
veritabanları
#----------------------------------------------------------------------------------------------------------------------------
<BURADA KALDIK>
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-10-03 14:16:20 +03:00
Veriler toplandı
gerekebilmektedir. Bu ön işlemlere "verilerin kullanı ı
bölümde verilerin hazı ı ı ı
işlem etkinliklerini gerçekleştirebilmek için başka konuları ı
özel ön işlemler ilgili konuları ı ı ı ı ı
Verilerin kullanı ı ı
2024-04-02 13:01:04 +03:00
1) Verilerin Temizlenmesi (Data Cleaning): Veriler eksiklikler içerebilir ya da geçersiz değerler içerebilir. Bazen de aşı ı
değerlerden (outliers) kurtulmak gerekebilir. Bu faaliyetlere verilerin temizlenmesi denilmektedir. Kusurlu veriler yapı
analizleri olumsuz yönde etkilemektedir.
2) Özellik seçimi (Feature Selection): Veri kümelerindeki tüm sütunlar bizim için anlamlı
sütunları ı ı ı ı
"Adı ı ı ı ı ı
atı ı ı ı
sahip sütunda yanlı ı
3) Verilerin Dönüştürülmesi (Data Transformation): Kategorik veriler, tarih ve zaman verileri gibi veriler, resimler gibi
veriler doğrudan işleme sokulamazlar. Bunları ı
skala farklı ı ı ı ı ı ı ı ı ı
birbirine benzer hale getirme sürecine "özellik ölçeklemesi (feature scaling)" denilmektedir.
4) Özellik Mühendisliği (Feature Engineering): Özellik mühendisliği veri tablosundaki sütunlardan olmayan başka sütunları
oluşturulması
edilmesidir. Örneğinin kişinin boy ve kilosu biliniyorsa biz vücut kitle endeksini tabloya ekleyebiliriz.
5) Boyutsal Özellik İndirgemesi (Dimentionality Feature Reduction): Veri kümesinde çok fazla sütun olması ı
dezavantajı
biçimde etkileyebilir. Fazla sayı ı ı ı ı ı
yanlı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
k tane sütun haline getirilmesi sürecine boyutsal özellik indirgemesi denilmektedir. Bu konu kursumuzda ileride ayrı
bölümde ele alı ı
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
6) Verilerin Çoğaltı ı ı
yöntemini uygulayabilmek için sayı ı ı ı ı ı ı
kastediyoruz) yeni verilerin oluşturulması ı ı ı ı ı
denilmektedir. Örneğin bir resimden döndürülerek pek çok resim elde edilebilir. Benzer biçimde örneğin bir resmin çeşitli
kı ı ı ı ı ı
ise "satı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Eksik verilerin ortaya çı
eksik verilerin bir kalı ı
grupta ele almaktadı
1) Tamamen Rastgele Oluşan Eksik Veriler (Missing Completely At Random - MCAR): Burada eksik veriler rastgele satı ı
rastgele sütunları ı ı ı ı ı ı
hale getirmez.
2024-04-19 00:21:20 +03:00
2) Rastgele Oluşan Ekisik Veriler (Missing At Random - (MAR): Burada eksik veriler bir kalı ı ı
tablonun başka sütunları
Kadı ı ı ı
atı ı ı
2024-04-02 13:01:04 +03:00
3) Rastgele Oluşmayan Eksik Veriler (Missing Not At Random - MNAR): Burada eksik verilerde bir kalı ı ı
tabloda sütunlarla açı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
CSV dosyaları ı ı ı ı
Pandas'ı
"person.csv" isimli dosya şu içeriği sahip olsun:
Adı ı
Sacit Bulut,78,172,34,Erkek
Ayşe Er,67,168,45,Kadı
Ahmet San,,182,32,Erkek
Macit Şen,98,156,65,Erkek
Talat Demir,85,,49,Erkek
Bu dosyayı ı
import pandas as pd
df = pd.read_csv('person.csv')
Şöyle bir çı ı
Adı ı
0 Sacit Bulut 78.0 172.0 34 Erkek
1 Ayşe Er 67.0 168.0 45 Kadı
2 Ahmet San NaN 182.0 32 Erkek
3 Macit Şen 98.0 156.0 65 Erkek
4 Talat Demir 85.0 NaN 49 Erkek
Bir CSV dosyası ı ı
anlamı ı ı ı ı ı
özel sözcükleri "eksik veri" gibi ele almaktadı
'-nan', '1.#IND', '1.#QNAN', '<NA>', 'N/A', 'NA', 'NULL', 'NaN', 'None', 'n/a', 'nan', ‘ ’ ı
karşı ı ı ı ı
parametresi yoluyla programcı ı ı ı
oluşan dolaşı
df = pd.read_csv('person.csv', na_values=['NE'])
Burada read_csv yukarı ı ı ı ı
parametresi False olarak girilirse (bu parametrenin default değeri True biçimdedir) bu durumda yukarı
veri kabul edilen yazı ı ı ı ı
2024-04-19 00:21:20 +03:00
fonksiyonu bir süredir yazı ı ı ı
elemanı ı
yine onu np.float64 NaN değeri olarak ele almaktadı
2024-04-02 13:01:04 +03:00
Eksik veri işlemleri NumPy kütüphanesi ile loadtxt fonksiyonu kullanı ı
eksik verileri ele almak için kullanı ı ı ı
Pandas'ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Eksik verilerle çalı ı ı ı ı
satı ı ı ı ı
sorulara yanı ı ı
Eksik verilerin ele alı ı ı
1) Eksik verilerin bulunduğu satı ı
2) Eksik verilerin yerine başka değerler yerleştirmek (imputation).
Eksik verilerin bulunduğu satı ı ı ı
a) Eksik verili satı ı ı ı
b) Eksik verili satı ı ı ı ı
Eğer bu soruları ı ı ı ı ı
Eksik veriler yerine bir verinin doldurulması
satı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
DataFrame nesnesi df olmak üzere, eksik veri analizinde şu kalı ı
1) Sütunlardaki eksik verilerin miktarları
df.isna().sum() ya da pd.isna(df).sum()
Pandas'taki isna fonksiyonu aynı ı ı ı ı
2024-04-19 00:21:20 +03:00
bool türden bir DataFrame ya da Series nesnesi vermektedir. bool üzerinde sum işlemi yapı ı ı
True değerler 1 olarak işleme girer. Dolayı ı ı ı ı ı
oluruz. isna fonksiyonunun diğer bir ismi isnull biçimindedir.
2024-04-02 13:01:04 +03:00
2) Eksik verilerin toplam sayı ı
df.isna().sum().sum() ya da pd.isna(df).sum().sum()
2024-04-19 00:21:20 +03:00
isna fonksiyonu (ya da metodu) sütunsan temelde eksik verilerin sayı ı ı ı ı
verileri verecektir.
2024-04-02 13:01:04 +03:00
3) Eksik verilerin bulunduğu satı ı ı
pd.isna(df).any(axis=1).sum() ya da df.any().any(axis=1).sum()
any fonksiyonu ya da metodu bir eksen parametresi alarak satı
True değer varsa True değerini veren hiç True değer yoksa False değerini veren" bir fonksiyondur. Yukarı
biz önce isna fonksiyonu ile eksik verileri matrisel bir biçimde DataFrame olarak elds ettik. Sonra da onun satı ı
any işlemi uyguladı ı ı ı ı ı ı ı
4) Eksik verilerin bulunduğu satı
df.index[pd.isna(df).any(axis=1)] ya da df.loc[df.isna().any(axis=1)].index
5) Eksik verilerin bulunduğu sütun isimleri şöyle elde edilebilir:
missing_columns = [name for name in df.columns if df[name].isna().any()]
Burada liste içlemi kullandı
o sütunda en az bir eksik veri varsa o sütunun ismini listeye ekledik.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
19. Ders - 02/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
"Melbourne Housing Snapshot (MHS)" veri kümesinin eksik veri bakı ı
aşağı ı ı
2024-04-02 13:01:04 +03:00
https://www.kaggle.com/datasets/dansbecker/melbourne-housing-snapshot?resource=download
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('melb_data.csv')
missing_columns = [colname for colname in df.columns if df[colname].isna().any()]
print(f'Eksik verilen bulunduğu sütunlar: {missing_columns}', end='\n\n')
missing_column_dist = df.isna().sum()
print('Eksik verilerin sütunlara göre dağı ı ı
print(missing_column_dist, end='\n\n')
missing_total = df.isna().sum().sum()
print(f'Eksik verilen toplam sayı ı
missing_ratio = missing_total / df.size
print(f'Eksik verilen oranı
missing_rows = df.isna().any(axis=1).sum()
print(f'Eksik veri bulunan satı ı ı ı
missing_rows_ratio = missing_rows / len(df)
print(f'Eksik veri bulunan satı ı ı
"""
Elde Edilen Çı ı
Eksik verilen bulunduğu sütunlar: ['Car', 'BuildingArea', 'YearBuilt', 'CouncilArea']
Eksik verilerin sütunlara göre dağı ı ı
Suburb 0
Address 0
Rooms 0
Type 0
Price 0
Method 0
SellerG 0
Date 0
Distance 0
Postcode 0
Bedroom2 0
Bathroom 0
Car 62
Landsize 0
BuildingArea 6450
YearBuilt 5375
CouncilArea 1369
Lattitude 0
Longtitude 0
Regionname 0
Propertycount 0
dtype: int64
Eksik verilen toplam sayı ı
Eksik verilen oranı
Eksik veri bulunan satı ı ı ı
Eksik veri bulunan satı ı ı
"""
#----------------------------------------------------------------------------------------------------------------------------
Eksik verileri DataFrame nesnesinden silmek için DataFrame sı ı ı ı ı
axis = 0'dı ı ı ı ı
durumda bize eksik verilerin atı ı ı ı ı
nesne üzerinde atı ı ı
Aşağı ı ı ı ı
https://www.kaggle.com/datasets/dansbecker/melbourne-housing-snapshot?resource=download
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('melb_data.csv')
print(f'VEri kümesinin boyutu: {df.shape}')
df_deleted_rows = df.dropna(axis=0)
print(f'Satı
df_deleted_cols = df.dropna(axis=1)
print(f'Sütun atma sonucundaki yeni boyut: {df_deleted_cols.shape}')
#----------------------------------------------------------------------------------------------------------------------------
Eksik verilerin yerine başka değerlerin yerleştirilmesi işlemine "imputation" denilmektedir. Kullanı
stratejiler şunlardı
- Sütun sayı ı
- Sütun kaegorik ya da sı
- Eksik verilerin sütunlarda uç değeler varsa medyan değeri ile doldurulması
- Eksik verilerin yerine belli aralı ı ı
- Eksik verilerin zaman serileri tarzı ı
- Eksik değerlerin regresyonla tahmin edilmesi yoluyla doldurulması
- Eksik değerlerin KNN (K-Nearest Neighbours) Yöntemi ile doldurulması
En çok uygulanan yöntem basitliği nedeniyle sütun ortalaması ı
Yukarı ı ı ı ı
2024-04-19 00:21:20 +03:00
kümesi ile ne yapmak istediğimize bağlı ı ı
veri içeren sütunlar atı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
veri kümesi yanlı ı ı ı
"Melbourne Housing Snapshot" veri kümesimde satı ı ı ı ı ı
burada "imputation" düşünülebilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi imputation işlemine MHS veri kümesi üzerinde örnek verelim. Bu veri kümesinde eksik veriler şu sütunlarda bulunmaktaydı
"Car", "BuildingArea", "YearBuilt", "CouncilArea". Inputation işlemi için bu vsütunları
için ayrı ı ı ı ı ı ı
imputation için sütun oralaması ı ı ı ı
impute_val = df['Car'].mean().round()
df['Car'] = df['Car'].fillna(impute_val) # eşdeğeri df['Car'].fillna(impute_val, inplace=True)
DataFrame ve Series sı ı ı ı ı ı ı
Bu metotta inplace parametresi True yapı ı
yapı ı
Eksik veri içeren diğer bir sütun da "BuildingArea" sütunudur. Bu sütun evin metrekare cinsindende büyüklüğünü belirtmektedir.
2024-04-19 00:21:20 +03:00
Her ne kadar bu sütun tamsayı
Tabii yine yuvarlama da uygulayabiliriz. Örneğin:
2024-04-02 13:01:04 +03:00
impute_val = df['BuildingArea'].mean().round()
df['BuildingArea'] = df['BuildingArea'].fillna(impute_val) # eşdeğeri df['Car'].fillna(impute_val, inplace=True)
2024-04-19 00:21:20 +03:00
Veri kümesinin YearBuilt sütunu binanı ı ı ı ı ı
ölçeğe sahiptir? Aslı ı ı ı ı ı
ya da aralı ı ı ı ı
daha uygun olabilmektedir. O halde biz bu sütunun ortalama değeri olarak medyan işlemi uygulayabiliriz:
2024-04-02 13:01:04 +03:00
impute_val = df['YearBuilt'].median()
df['YearBuilt'] = df['YearBuilt'].fillna(impute_val) # eşdeğeri df['YearBuilt'].fillna(impute_val, inplace=True)
Eksik veri içeren diğer bir sütun da "CouncilArea" sütunudur. Bu sütun binanı
Dolayı ı
impute_val = df['CouncilArea'].mode()
df['CouncilArea'] = df['CouncilArea'].fillna(impute_val[0]) # eşdeğeri df['CouncilArea'].fillna(impute_val, inplace=True)
2024-04-19 00:21:20 +03:00
Pandas'taki DataFrame ve Series sı ı ı ı ı ı
yinelenen birden fazla değer olabilecğei için bu değerlerin hepsinin verilmesi tercih edilmiştir.) Dolayı ı
Series ensnesinin ilk elemanı ı
2024-04-02 13:01:04 +03:00
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('melb_data.csv')
impute_val = df['Car'].mean().round()
df['Car'] = df['Car'].fillna(impute_val) # eşdeğeri df['Car'].fillna(impute_val, inplace=True)
impute_val = df['BuildingArea'].mean().round()
df['BuildingArea'] = df['BuildingArea'].fillna(impute_val) # eşdeğeri df['Car'].fillna(impute_val, inplace=True)
impute_val = df['YearBuilt'].median()
df['YearBuilt'] = df['YearBuilt'].fillna(impute_val) # eşdeğeri df['YearBuilt'].fillna(impute_val, inplace=True)
impute_val = df['CouncilArea'].mode()
df['CouncilArea'] = df['CouncilArea'].fillna(impute_val[0]) # eşdeğeri df['CouncilArea'].fillna(impute_val, inplace=True)
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı
bunlardı ı ı
Örneğin MHS veri kümesinde eksik veri olan evin metrekaresini ortalama yoluyla doldurmak uygun olmayabilir. Çünkü bazı
pahalı ı ı ı
evin metrekaresi başka özelliklere göre (sütun bilgilerine göre) değişebilmektedir. Pekiyi bu tür durumlarda ne yapmak gerekir?
İşte sütun değerleri satı
genellikle bu tür durumlar göz ardı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesi ve veri bilimi için NumPy, Pandas ve SciPy dı ı ı
denilen ve "sklearn" ya da "scikit-learn" isimli pakette bulunan kütüphanedir. Biz bu kütüphaneye bazen scikit-learn bazen de
sklearn diyeceğiz.
NumPy ve Pandas genel amaçlı ı ı
Oysa scikit-learn makine öğrenmesi amacı ı ı
şöyle yapı
pip install scikit-learn
Ancak scikit-learn kütüphanesi yapay sinir ağları ı ı ı
verilerin kullanı ı ı ı
ve istatistiksel ağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn kütüphanesi genel olarak "nesne yönelimli" biçimde oluşturulmuştur. Yani kütüphane daha çok fonksiyonlar yoluyla
değil sı ı ı ı ı ı
değişik sı ı ı ı ı
1) Önce ilgili sı ı ı ı ı ı ı ı
from sklearn.impute import SimpleImputer
si = SimpleImputer(...)
2) Nesne yaratı ı ı ı ı
Bu işlem sı ı ı ı ı ı ı ı
içerisinde saklar. Yani fit metotları ı
Örneğin:
si.fit(dataset)
fit işlemi genel olarak transform için kullanı ı ı ı
sonra artı
3) fit işleminden sonra fit işlemiyle elde edilen bilgilerin bir veri kümesine uygulanması
metotları ı ı ı
result1 = si.transform(data1)
result2 = si.transform(data2)
...
fit ve transform metotları
listesi olarak alabilmektedir. fit metotları ı
NumPy dizilerine geri dönmektedir.
4) Bazen fit edilecek veri kümesi ile transform edilecek veri kümesi aynı ı ı
çağı ı ı ı ı ı
result = si.fit_transform(dataset)
5) Ayrı ı ı ı ı ı ı
olabilmektedir.
6) Sı ı ı ı ı ı
yapmaktadı ı ı
Genel olarak scikit-learn kütüphanesi hem NumPy hem de Pandas nesnelerini desteklemektedir. fit, transform ve fit_transform
metotları ı ı
örneğin biz bu metotlara Pandas'ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
20. Ders - 03/03/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi eksik verilerin doldurulması ı ı ı ı ı
Sı ı ı ı ı ı ı ı ı ı ı ı ı
işlemini transform yapmaktadı ı ı ı ı ı ı
belirtilebilmektedir. Bunları ı ı
durumdadı ı ı ı ı ı ı
'median'
'most_frequent'
'constant'
'constant' stratejisi belli bir değerle doldurma işlemini yapar. Eğer bu strateji seçilirse doldurulacak değerin fill_value
parametresiyle belirtilmesi gerekir. Diğer parametreler için sı ı ı
Aşağı ı ı ı ı
işlemi uygulanmı ı
2024-04-19 00:21:20 +03:00
SimpleImputer sı ı ı ı ı ı
NumPy dizisi geçirecekseniz onun iki boyutlu olması ı
2024-04-02 13:01:04 +03:00
anı ı ı
için DataFrame nesnelerini geçebiliriz. Eğer elimizde tek boyutlu bir dizi varsa onu bir sütundan n satı
boyutlu bir diziye dönüştürmeliyiz. Bunun için NumPy ndarray sı ı ı ı
SimpleImputer nesnesi yaratı ı ı ı ı ı
stratejiyi uygulamaktadı ı
birden fazla SimpleImputer nesnesi yaratı
si1 = SimpleImputer(strategy='mean')
si2 = SimpleImputer(strategy='median')
...
Ancak bunun yerine SİmpleImputer sı ı ı ı ı
değiştirmekte kullanı ı
si = SimpleImputer(strategy='mean')
...
si.set_params(strategy='median')
...
2024-04-19 00:21:20 +03:00
SimpleImputer sı ı ı ı
sağlamak için kullanı
bunu bu parametreyle belirtmemiz gerekir. Örneğin:
2024-04-02 13:01:04 +03:00
si = SimpleImputer(strategy='mean')
SimpleImputer sı ı ı ı ı
bilgileri elde eder. Yani örneğin:
a = np.array([1, 1, None, 4, None]).reshape(-1, 1)
si = SimpleImputer(strategy='mean')
si.fit(a)
Burada fit metodu aslı ı ı ı ı
var). Biz fit yaptı ı ı
b = np.array([1, 1, None, 4, None]).reshape(-1, 1)
result = si.transform(b)
Biz şimdi burada a'dan elde ettiğimiz ortalama 3 değeri ile bu b dizisini doldurmuş oluruz. Tabii genellikle bu tür durumlarda
fit yapı ı ı
a = np.array([1, 1, None, 4, None]).reshape(-1, 1)
si = SimpleImputer(strategy='mean')
si.fit(a)
result = si.transform(a)
İşte bu tür durumlarda fit ve transform bir arada fit_transform metoduyla yapı
a = np.array([1, 1, None, 4, None]).reshape(-1, 1)
si = SimpleImputer(strategy='mean')
result = si.fit_transform(a)
scikit-learn kütüphanesindeki pek çok sı ı ı
sı ı ı ı ı
dizi geri döndürmektedir. Örneğin SimpleImputer sı ı ı ı
fit metodu her sütunu diğerinden ayrı ı
metoduna aşağı ı
1 4
None 7
5 None
3 8
9 2
Stratejinin "mean" olduğunu varsayalı ı ı ı
saklayacaktı ı
bizim verdiğimiz dizinin ilk sütunununu fit ettiğimiz dizinin ilk sütunundan elde ettiği bilgiyle, ikinci sütununu fit
ettiğimiz dizinin ikinci sütunundan elde ettiği bilgiyle dolduracakı ı ı ı ı
metotları
bir dizi varsa biz onu reshape metoduyla iki boyutlu hale getirerek fit ve transform metotları
>>> a = np.array([1, 2, 3, None, 5])
>>> si.fit_transform(a.reshape(-1, 1))
array([[1. ],
[2. ],
[3. ],
[2.75],
[5. ]])
Aşağı ı ı ı ı
doldurulmuştur.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
df = pd.read_csv('melb_data.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean')
df[['Car', 'BuildingArea']] = np.round(si.fit_transform(df[['Car', 'BuildingArea']]))
si.set_params(strategy='median')
df[['YearBuilt']] = np.round(si.fit_transform(df[['YearBuilt']]))
si.set_params(strategy='most_frequent')
df[['CouncilArea']] = si.fit_transform(df[['CouncilArea']])
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn kütüphanesinde sklearn.impute modülünde aşağı ı ı ı ı
SimpleImputer
IterativeImputer
MissingIndicator
KNNImputer
Buradaki KNNImputer sı ı ı ı ı ı ı
sı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
dizi vermiş olalı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
doğrusal bir model oluşturmaktadı ı ı ı ı ı ı
alı ı
bu eksik veriyi ortalama metrakareyle doldurmak yerine "bölgeyi", "binanı ı ı
Ancak yukarı ı ı ı
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('melb_data.csv')
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
si = IterativeImputer()
df[['Car', 'BuildingArea', 'YearBuilt']] = si.fit_transform(df[['Car', 'BuildingArea', 'YearBuilt']])
#----------------------------------------------------------------------------------------------------------------------------
Verilerin kullanı ı ı ı
sütunları ı ı
işlemler yaparlar. Dolayı ı ı ı
dönüştürülmeleri gerekir. Genellikle bu dönüştürme "eksik verilerin ele alı ı ı ı
bazen önce kategorik dönüştürmeyi yapı ı
Kategorik verilerin sayı ı ı ı
kerşı ı ı ı
Kı ı ı
Mavi
Kı ı ı
Yeşil
Mavi
Yeşil
...
Biz şimdi burada bu kategorik alanı ı ı ı ı
sütun şu hale gelecektir:
0
1
0
2
1
2
....
Örneğin biz bu işlemi yapan bir fonksiyon yazabiliriz. Fonksiyonun birinci parametresi bir DataFrame olabilir. İkinci
2024-09-25 13:52:00 +03:00
parametresi ise hangi sütunun sayı ı ı ı ı
2024-04-02 13:01:04 +03:00
Fonksiyonu şöyle yazabiliriz:
def category_encoder(df, colnames):
2024-09-16 10:49:44 +03:00
for colname in colnames:
labels = df[colname].unique()
for index, label in enumerate(labels):
df.loc[df[colname] == label, colname] = index
2024-04-02 13:01:04 +03:00
Burada biz önce sütun isimlerini tek tek elde etmek için dı ı
etiketleri (labels) elde ettik. SOnra bu etiketleri iç bir döngüde dolaşarak sütunda ilgili etiketin bulunduğu satı
onları ı ı ı ı ı
Adı ı
Sacit Bulut,78,172,34,Erkek,Kı ı ı
Ayşe Er,67,168,45,Kadı
Ahmet San,85,182,32,Erkek,Kı ı ı
Macit Şen,98,192,65,Erkek,Mavi
Talat Demir,85,181,49,Erkek,Yeşil
Sibel Ünlü,72,172,34,Kadı
Ali Serçe,75,165,21,Erkek,Yeşil
Test kodu da şöyle olabilir:
import pandas as pd
def label_encode(df, colnames):
for colname in colnames:
labels = df[colname].unique()
for index, label in enumerate(labels):
df.loc[df[colname] == label, colname] = index
label_encode(df, ['RenkTercihi', 'Cinsiyet'])
print(df)
Şöyle bir çı ı
Adı ı
0 Sacit Bulut 78 172 34 0 0
1 Ayşe Er 67 168 45 1 1
2 Ahmet San 85 182 32 0 0
3 Macit Şen 98 192 65 0 2
4 Talat Demir 85 181 49 0 1
5 Sibel Ünlü 72 172 34 1 2
6 Ali Serçe 75 165 21 0 1
Aşağı ı ı ı ı
#---------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
df = pd.read_csv('melb_data.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean')
df[['Car', 'BuildingArea']] = np.round(si.fit_transform(df[['Car', 'BuildingArea']]))
si.set_params(strategy='median')
df[['YearBuilt']] = np.round(si.fit_transform(df[['YearBuilt']]))
si.set_params(strategy='most_frequent')
df[['CouncilArea']] = si.fit_transform(df[['CouncilArea']])
def category_encoder(df, colnames):
for colname in colnames:
labels = df[colname].unique()
for index, label in enumerate(labels):
df.loc[df[colname] == label, colname] = index
category_encoder(df, ['Suburb', 'SellerG', 'Method', 'CouncilArea', 'Regionname'])
print(df)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı
LabelEncoder sı ı ı ı ı ı ı ı ı ı ı
ve transform metotları ı ı
genel olarak fit ve transform metotları ı
yukarı ı ı ı ı ı ı
transform metoduyla yapı ı ı ı ı
fit_transform metoduyla da yapı ı ı ı
kategorik olmaktan çı ı ı
import pandas as pd
from sklearn.preprocessing import LabelEncoder
df = pd.read_csv('test.csv')
le = LabelEncoder()
transformed_data = le.fit_transform(df['RenkTercihi'])
df['RenkTercihi'] = transformed_data
transformed_data = le.fit_transform(df['Cinsiyet'])
df['Cinsiyet'] = transformed_data
print(df)
LabelEncoder sı ı ı ı ı ı
(unique)" etiketleri bize NumPy dizisi olarak vermektedir.
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
df = pd.read_csv('melb_data.csv')
print(df, end='\n\n')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean')
df[['Car', 'BuildingArea']] = np.round(si.fit_transform(df[['Car', 'BuildingArea']]))
si.set_params(strategy='median')
df[['YearBuilt']] = np.round(si.fit_transform(df[['YearBuilt']]))
si.set_params(strategy='most_frequent')
df[['CouncilArea']] = si.fit_transform(df[['CouncilArea']])
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
for colname in ['Suburb', 'SellerG', 'Method', 'CouncilArea', 'Regionname']:
df[colname] = le.fit_transform(df[colname])
print(df)
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
LabelEncoder sı ı ı ı ı ı ı
zaten hangi etiketlerin hangi sayı ı ı ı
verdiğimizde onun yazı ı ı ı ı
2024-04-02 13:01:04 +03:00
some_label_numbers = [0, 1, 1, 2, 2, 1]
label_names = le.inverse_transform(some_label_numbers)
Aşağı ı ı ı
örneği verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import LabelEncoder
df = pd.read_csv('test.csv')
print(df, end='\n\n')
le = LabelEncoder()
transformed_data = le.fit_transform(df['RenkTercihi'])
df['RenkTercihi'] = transformed_data
some_label_numbers = [0, 1, 1, 2, 2, 1]
label_names = le.inverse_transform(some_label_numbers)
print(label_names, end='\n\n')
transformed_data = le.fit_transform(df['Cinsiyet'])
df['Cinsiyet'] = transformed_data
print(df)
some_label_numbers = [0, 1, 1, 1, 0, 1]
label_names = le.inverse_transform(some_label_numbers)
print(label_names)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
2024-05-20 13:45:43 +03:00
"one-hot encoding" denilen biçimde sayı ı ı ı
2024-04-02 13:01:04 +03:00
paragraflarda ele alacağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Sı ı ı ı ı
olabilir. Örneğin "EğitimDurumu", "ilkokul", "ortaokul", "lise", "üniversite" biçiminde dört kategoride sı ı
olabilir. Biz de bu bilgilere sı ı
İlkokul --> 0
Ortaokul --> 1
Lise --> 2
Üniversite --> 3
scikit-learn içerisindeki LabelEncoder sı ı ı ı ı
gibi numara vermemektedir. scikit-learn içerisinde bu işlemi pratik bir biçimde yapan hazı ı ı ı
scikit-learn içerisinde OrdinalEncoder isimli bir sı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
21. Ders - 09/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
OrdinalEncoder sı ı ı ı ı ı ı ı ı
kümesi kullanı ı ı ı ı ı
örnek özniteliği oluşturulan kategorileri NumPy dizisi olarak vermektedir. Sı ı ı
fit işlemine sokulan sütunları ı ı ı
OrdinalEncoder sı ı ı ı ı ı ı ı
(Yani sözlükte ilk gördüğü kategoriye düşük numara vermektedir. Tabii bu işlem UNICODE tabloya göre yapı ı
bizim istediğimiz numaraları ı ı ı ı ı
Bu bağlamda OrdinalEncoder sı ı ı ı ı ı ı ı ı ı ı ı ı ı
(özelliği) kabul etmesidir. Halbuki LabelEncoder sı ı ı
kümemiz şöyle olsun:
Adı ı
Sacit Bulut,78,172,34,Erkek,Kı ı ı
Ayşe Er,67,168,45,Kadı
Ahmet San,85,182,32,Erkek,Kı ı ı
Macit Şen,98,192,65,Erkek,Mavi,Lise
Talat Demir,85,181,49,Erkek,Yeşil,Üniversite
Sibel Ünlü,72,172,34,Kadı
Ali Serçe,75,165,21,Erkek,Yeşil,İlkokul
Burada "Cinsiyet" ve "RenkTercihi" kategorik (nominal) ölçekte sütunlardı ı ı
olarak ele alı ı ı
kodlama yapmak istersek bunu LabelEncoder ya da OrdinalEncoder ile sağlayamayı
df = pd.read_csv('test.csv')
print(df, end='\n\n')
oe = OrdinalEncoder()
transformed_data = oe.fit_transform(df[['Cinsiyet', 'RenkTercihi', 'EğitimDurumu']])
df[['Cinsiyet', 'RenkTercihi', 'EğitimDurumu']] = transformed_data
Buradan şöyle bir DataFrame elde edilecektir:
Adı ı
0 Sacit Bulut 78 172 34 0.0 0.0 3.0
1 Ayşe Er 67 168 45 1.0 2.0 1.0
2 Ahmet San 85 182 32 0.0 0.0 3.0
3 Macit Şen 98 192 65 0.0 1.0 0.0
4 Talat Demir 85 181 49 0.0 2.0 2.0
5 Sibel Ünlü 72 172 34 1.0 1.0 1.0
6 Ali Serçe 75 165 21 0.0 2.0 3.0
Bunu OridinalEncoder sı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import OrdinalEncoder
df = pd.read_csv('test.csv')
print(df, end='\n\n')
oe = OrdinalEncoder()
transformed_data = oe.fit_transform(df[['Cinsiyet', 'RenkTercihi', 'EğitimDurumu']])
df[['Cinsiyet', 'RenkTercihi', 'EğitimDurumu']] = transformed_data
print(df)
#----------------------------------------------------------------------------------------------------------------------------
Bu durumda eğer kategorilere istediğiniz gibi değer vermek istiyorsanı
veri kümesi read_csv fonksiyonuyla okunurken converters parametresi yoluyla hemen dönüştürme yapı
load_txt fonksiyonları ı
okunurken hangi dönüştürmenin yapı ı ı ı ı ı
ya da sütun indeksinden değeri ise o sütunun dönüştürülmesinde kullanı ı
lambda ifadesi olarak da girilebilir. Örneğin:
df = pd.read_csv('test.csv', converters={'EğitimDurumu': lambda s: {'İlkokul': 0, 'Ortaokul': 1, 'Lise': 2, 'Üniversite': 3}[s]})
Elde edilecek DataFrame nesnesi şöyle olacaktı
Adı ı
0 Sacit Bulut 78 172 34 Erkek Kı ı ı
1 Ayşe Er 67 168 45 Kadı
2 Ahmet San 85 182 32 Erkek Kı ı ı
3 Macit Şen 98 192 65 Erkek Mavi 2
4 Talat Demir 85 181 49 Erkek Yeşil 3
5 Sibel Ünlü 72 172 34 Kadı
6 Ali Serçe 75 165 21 Erkek Yeşil 0
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv', converters={'EğitimDurumu': lambda s: {'İlkokul': 0, 'Ortaokul': 1, 'Lise': 2, 'Üniversite': 3}[s]})
print(df, end='\n\n')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-11 00:32:36 +03:00
Kategorik verilerin 0'dan itibaren LabelEncoder ya da OrdinalEncoder sı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Çünkü bu durumda sanki veri "sı ı
etkilenmektedir. Örneğin veri kümesinin bir sütununda "RenkTercihi" olsun. Bu RenkTercihi de "Kı ı ı
renklerindne oluşuyor olsun. Biz bu sütunu LabelEncoder ile sayı ı ı ı
Yeşil = 2 biçiminde renklere numara verilecektir. İşte burada makine öğrenmesi algoritmaları ı ı ı
"Yeşil > "Mavi" gibi bir durum varmı ı ı ı
gibi gerçekte var olmayan özellikler de ortaya çı ı ı
edilmesi yoluna gidilmektedir. Kategorik verilerin birden fazla sütunla ifade edilmesinde en yaygı ı
hot encoding" denilen yöntemdir. Bu yöntemde sütundaki kategorilerin sayı ı ı ı
"One hot" terimi "bir grup bitten hepsinin sı ı ı ı
tane kategori n tane sütunla ifade edilir. Her kategori yalnı ı
Örneğin:
RenkTercihi
-----------
Kı ı ı
Kı ı ı
Mavi
Kı ı ı
Yeşil
Mavi
Yeşil
...
2024-05-20 13:45:43 +03:00
Burada 3 renk olduğunu düşünelim. Bunun "one-hot encoding" dönüştürmesi şöyle olacaktı
2024-04-02 13:01:04 +03:00
Kı ı ı
1 0 0
1 0 0
0 1 0
1 0 0
0 0 1
0 1 0
0 0 1
...
2024-05-20 13:45:43 +03:00
Eğer sütundaki kategori sayı ı ı ı
2024-04-02 13:01:04 +03:00
ikili sütunlar 0 ve 1 biçiminde kodlanabilir. (Yani bu işlem LabelEncoder sı ı ı ı
2024-05-20 13:45:43 +03:00
iki kategori içeren sütunları ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
"one-hot encoding" yapmanı ı
2024-04-02 13:01:04 +03:00
OneHotEncoder sı ı ı ı ı ı ı ı ı ı ı ı
Yani önce fit işllemi sonra transform işlemi yapı ı ı ı ı
categories_ örnek özniteliğine NumPy dizilerinden oluşan bir liste biçiminde kaydedilmektedir. Örneğimizde kullanacağı ı
test.csv" dosyası
Adı ı
Sacit Bulut,78,172,34,Kı ı ı
Ayşe Er,67,168,45,Yeşil
Ahmet San,85,182,32,Kı ı ı
Macit Şen,98,192,65,Mavi
Talat Demir,85,181,49,Yeşil
Sibel Ünlü,72,172,34,Mavi
Ali Serçe,75,165,21,Yeşil
2024-05-20 13:45:43 +03:00
"one-hot encoding" yapı ı
vererek atama yapı ı ı
2024-04-02 13:01:04 +03:00
önemli değildir. Ancak OneHotEncoder nesnesi önce sütunu np.unique fonksiyonuna sokmakta ondan sonra o sı
yapmaktadı ı ı ı ı ı ı
aslı ı ı
nesnesi fit işlemi yapı ı ı
bize vermektedir. Biz DataFrame eklemesi yaparken doğrudan bu isimleri kullanabiliriz. categories_ örnek özniteliğinin bir liste
2024-05-20 13:45:43 +03:00
olduğuna dikkat ediniz. Çünkü birden fazla sütun tek hamlede "one-hot encoding" yapı ı ı ı
2024-04-02 13:01:04 +03:00
listenin ilgili elemanı
Yukarı ı ı ı ı ı
Bu durumda biz bu metotlara Pandas'ı
OneHotEncoder nesnesini yaratı ı ı
ismi yalnı ı ı
olarak vermektedir. Elemanları ı
matrisler "fazla yer kaplaması ı ı ı ı ı
kursumuzun sonraki bölümlerinde ele alı ı
Yine OneHotEncoder nesnesi yaratı ı ı ı
Matris seyrek formda elde edilmeyecekse bu dtype türünü "uint8" gibi en küçük türde tutabilirsiniz. max_categories parametresi
kategori sayı ı ı ı ı ı
Örneğin:
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi']])
df.drop(['RenkTercihi'], axis=1, inplace=True)
df[ohe.categories_[0]] = transformed_data
Burada önce veri kümesi okunmuş sonra OneHotEncoder sı ı ı ı ı ı
içerisindeki "RenkTercihi" sütunu silinip onun yerine categories_ örnek özniteliğindeki kategori isimleri nesneye eklenmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi']])
df.drop(['RenkTercihi'], axis=1, inplace=True)
df[ohe.categories_[0]] = transformed_data
print(df)
#----------------------------------------------------------------------------------------------------------------------------
DataFrame nesnesine yukarı
ilişkin sütunlardan biri zaten varsa o sütun yok edilip yerine bu kategori sütunu oluşturulacaktı
oluşturacağı ı ı ı ı ı
bu durumda çakı ı ı ı ı
yerine "RenkTercihi_Kı ı ı
etmek "liste içlemiyle" oldukça kolaydı
category_names = ['RenkTercihi_' + category for category in ohe.categories_[0]]
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi']])
df.drop(['RenkTercihi'], axis=1, inplace=True)
category_names = ['RenkTercihi_' + category for category in ohe.categories_[0]]
df[category_names] = transformed_data
print(df)
#----------------------------------------------------------------------------------------------------------------------------
Veri kümesinde birden fazla sütunda kategorik bilgiler olabilir. Bunlar OneHotEncoder sı ı ı
Ancak aslı ı ı ı ı
Örneğin "test.csv" veri kümemiz şöyle olsun:
Adı ı
Sacit Bulut,78,172,34,Kı ı ı
Ayşe Er,67,168,45,Yeşil,Mühendis
Ahmet San,85,182,32,Kı ı ı
Macit Şen,98,192,65,Mavi,Doktor
Talat Demir,85,181,49,Yeşil,Avukat
Sibel Ünlü,72,172,34,Mavi,Doktor
Ali Serçe,75,165,21,Yeşil,Mühendis
2024-05-20 13:45:43 +03:00
Burada "RenkTercihi"nin yanı ı
2024-04-02 13:01:04 +03:00
işlemine sokabiliriz:
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi', 'Meslek']])
df.drop(['RenkTercihi', 'Meslek'], axis=1, inplace=True)
categories1 = ['RenkTercihi_' + category for category in ohe.categories_[0]]
categories2 = ['Meslek_' + category for category in ohe.categories_[1]]
df[categories1 + categories2] = transformed_data
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi', 'Meslek']])
df.drop(['RenkTercihi', 'Meslek'], axis=1, inplace=True)
categories1 = ['RenkTercihi_' + category for category in ohe.categories_[0]]
categories2 = ['Meslek_' + category for category in ohe.categories_[1]]
df[categories1 + categories2] = transformed_data
print(df)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
2024-05-20 13:45:43 +03:00
"one-hot encoding" işleminden önce NumPy dizisine geçip hiç isimlerini oluşturmadan geri kalan kı ı
2024-04-02 13:01:04 +03:00
yapabiliriz. Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
transformed_data = ohe.fit_transform(df[['RenkTercihi', 'Meslek']])
df.drop(['Adı ı
dataset = df.to_numpy()
dataset = np.concatenate((dataset, transformed_data), axis=1)
print(dataset)
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
One-hot encoding uygulamanı ı
2024-04-09 13:15:47 +03:00
fonksiyonu bizden bir DataFrame, Series ya da dolaşı ı
bütün bir DataFrame geçirirsek fonksiyon oldukça akı ı ı
2024-05-20 13:45:43 +03:00
yazı ı ı ı ı ı ı
2024-04-09 13:15:47 +03:00
dönüştürülmüş yeni bir DataFrame nesnesi verir. Pandas ile çalı ı ı ı
veri kümemiz şöyle olsun:
2024-04-02 13:01:04 +03:00
Adı ı
Sacit Bulut,78,172,34,Kı ı ı
Ayşe Er,67,168,45,Yeşil,Mühendis
Ahmet San,85,182,32,Kı ı ı
Macit Şen,98,192,65,Mavi,Doktor
Talat Demir,85,181,49,Yeşil,Avukat
Sibel Ünlü,72,172,34,Mavi,Doktor
Ali Serçe,75,165,21,Yeşil,Mühendis
Biz aslı ı
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, dtype='uint8')
Burada biz tek hamlede istediğimiz dönüştürmeyi yapabildik. Bu dönüştürmede yine sütun isimleri orijinal sütun isimleri
ve kategori simleriyle öneklendirilmiştir. Eğer isterse programcı
parametresiyle de '_' karakteri yerine başka birleştirme karakterlerini kullanabilir. get_dummies fonksiyonu default durumda
sparse olmayan bool türden bir DataFrame nesnesi vermektedir. Ancak get_dummies fonksiyonunda "dtype" parametresi belirtilerek
"uint8" gibi bir türden çı ı ı
2024-05-20 13:45:43 +03:00
Biz bir DataFrame nesnesinin tüm yazı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
isteyebiliriz. Bu durumda fonksiyon DataFrame nesnesinin diğer sütunları ı
transformed_df = pd.get_dummies(df, columns=['Meslek'], dtype='uint8')
2024-05-20 13:45:43 +03:00
Biz burada yalnı ı
"one-hot encoding" yapı ı
"test.csv" dosyası ı ı ı ı ı
2024-04-02 13:01:04 +03:00
işlmeine sokulacaktı
Örneğin:
transformed_df = pd.get_dummies(df.iloc[:, 1:], dtype='uint8')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
22. Ders - 10/03/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
print(df, end='\n\n')
ohe_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'])
print(ohe_df)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı
kategoroileri '_' ile birleştirerek vermektedir. Ancak bir istersek prefix parametresi ile bu önekleri değiştirebiliriz.
Örneğin:
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', prefix=['R', 'M'])
Burada oluşturulacak sütunlar için önekler sı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', prefix=['R', 'M'])
print(transformed_df)
#----------------------------------------------------------------------------------------------------------------------------
Yine yukarı ı
değiştirilebilmektedir. Örneğin:
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', prefix=['R', 'M'], prefix_sep='-')
Burada artı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', prefix=['R', 'M'], prefix_sep='-')
print(transformed_df)
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Diğer bir "one-hot encoding" uygulama yöntemi de "tensorflow.keras" kütüphanesindeki "to_categorical" fonksiyonudur. Bazen
2024-04-09 13:15:47 +03:00
zaten Keras ile çalı ı
sütunun sayı ı ı
2024-05-20 13:45:43 +03:00
işlemini uygulamalı ı ı ı
2024-04-09 13:15:47 +03:00
diğer seçeneklere göre kullanı ı
modülde bulunnaktadı ı
2024-04-02 13:01:04 +03:00
from tensorflow.keras.utils import to_categorical
Tabii bu fonksiyonu kullanabilmeniz için tensorflow kütüphanesinin de yüklü olması
bu kütüphaneyi kullanacağı
pip install tensorflow
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
transformed_color = le.fit_transform(df['RenkTercihi'])
transformed_occupation = le.fit_transform(df['Meslek'])
ohe_color = to_categorical(transformed_color)
ohe_occupation = to_categorical(transformed_occupation)
color_categories = ['RenkTercihi_' + color for color in df['RenkTercihi'].unique()]
occupation_categories = ['Meslek_' + occupation for occupation in df['Meslek'].unique()]
df.drop(['RenkTercihi', 'Meslek'], axis=1, inplace=True)
df[color_categories] = ohe_color
df[occupation_categories] = ohe_occupation
print(df)
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
"one-hot encoding" yapmanı ı ı
2024-04-02 13:01:04 +03:00
en basit yöntemlerdne biri NumPy'ı ı
dizisi bir listeyle indekslenebildiğine göre bu birim matris LabelEncoder ile sayı
indekslenirse istenilen dönüştürme yapı ı
RenkTercihi
-----------
Kı ı ı
Mavi
Yeşil
Yeşil
Mavi
Kı ı ı
Mavi
2024-04-19 00:21:20 +03:00
Burada sütunda üç farklı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
RenkTercihi
-----------
0
1
2
2
1
0
1
3 farklı ı
1 0 0
0 1 0
0 0 1
2024-05-20 13:45:43 +03:00
Sonrada bu birim matris bir dizi ile indekslenirse "one-hot encoding" işlemi gerçekleştirilir.
2024-04-02 13:01:04 +03:00
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
print(df, end='\n\n')
import numpy as np
color_cats = np.unique(df['RenkTercihi'].to_numpy())
occupation_cats = np.unique(df['Meslek'].to_numpy())
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df['RenkTercihi'] = le.fit_transform(df['RenkTercihi'])
df['Meslek'] = le.fit_transform(df['Meslek'])
print(df, end='\n\n')
color_um = np.eye(len(color_cats))
occupation_um = np.eye(len(occupation_cats))
ohe_color = color_um[df['RenkTercihi'].to_numpy()]
ohe_occupation = occupation_um[df['Meslek'].to_numpy()]
df.drop(['RenkTercihi', 'Meslek'], axis=1, inplace=True)
df[color_cats] = ohe_color
df[occupation_cats] = ohe_occupation
print(df, end='\n\n')
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
"one-hot encoding" işleminin bir versiyonuna da "dummy variable encoding" denilmektedir. Şöyle ki: "one-hot encoding" işleminde
2024-04-02 13:01:04 +03:00
n tane kategori için n tane sütun oluşturuluyordu. Halbuki "dummy variable encoding" işleminde n tane kategori için n - 1
2024-05-20 13:45:43 +03:00
tane sütun oluşturulmaktadı ı ı ı
Örneğin Kı ı ı
2024-04-02 13:01:04 +03:00
Mavi Yeşil
0 0 (Kı ı ı
1 0 (Mavi)
0 1 (Yeşil)
2024-04-19 00:21:20 +03:00
Görüldüğü gibi kategorilerden biri (burada "Kı ı ı ı ı ı ı
bir eksiltilmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
"Dummy variable encoding" işlemi için farklı ı ı ı ı
2024-04-02 13:01:04 +03:00
yapan sı ı
OneHotEncoder sı ı ı ı
biçiminde yapı ı ı ı
Adı ı
Sacit Bulut,78,172,34,Kı ı ı
Ayşe Er,67,168,45,Yeşil,Mühendis
Ahmet San,85,182,32,Kı ı ı
Macit Şen,98,192,65,Mavi,Doktor
Talat Demir,85,181,49,Yeşil,Avukat
Sibel Ünlü,72,172,34,Mavi,Doktor
Ali Serçe,75,165,21,Yeşil,Mühendis
Biz de "RenkTercihi" sütununu "dummy variable encoding" ile dönüştürmek isteyelim. Bu işlemi şöyle yapabiliriz:
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, drop='first')
transformed_data = ohe.fit_transform(df[['RenkTercihi']])
print(df['RenkTercihi'])
print(ohe.categories_)
print(transformed_data)
Buradan şu çı ı
0 Kı ı ı
1 Yeşil
2 Kı ı ı
3 Mavi
4 Yeşil
5 Mavi
6 Yeşil
Name: RenkTercihi, dtype: object
[array(['Kı ı ı
[[0. 0.]
[0. 1.]
[0. 0.]
[1. 0.]
[0. 1.]
[1. 0.]
[0. 1.]]
Görüldüğü gibi burada "Kı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
from sklearn.preprocessing import OneHotEncoder
df = pd.read_csv('test.csv')
ohe = OneHotEncoder(sparse_output=False, drop='first')
transformed_data = ohe.fit_transform(df[['RenkTercihi']])
print(df['RenkTercihi'])
print(ohe.categories_)
print(transformed_data)
#----------------------------------------------------------------------------------------------------------------------------
Pandas'ı ı
Örneğin:
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', drop_first=True)
Burada veri kümesinin "RenkTercihi" ve "Meslek" sütunları ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
transformed_df = pd.get_dummies(df, columns=['RenkTercihi', 'Meslek'], dtype='uint8', drop_first=True)
print(transformed_df)
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Sütundaki kategori sayı ı
2024-04-02 13:01:04 +03:00
açmaktadı ı ı ı ı ı ı ı
bellekte çok yer kaplaması ı ı
Pekiyi kategori çok fazla ise ve biz çok fazla sütunun veri kümesine eklenmesini istemiyorsak bu durumda ne yapabiliriz?
Yöntemlerden biri çeşitli kategorileri başka üst kategoriler içerisinde toplamak olabilir. Böylece aslı
2024-05-20 13:45:43 +03:00
sı ı ı ı
2024-04-19 00:21:20 +03:00
başka kodlamaları ı ı ı
2024-05-20 13:45:43 +03:00
iyi yöntem aslı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-11 00:32:36 +03:00
Binary encoding yönteminde her kategori "ikilik sistemde bir sayı ı
2024-04-19 00:21:20 +03:00
kategori olsun. Bu kategoriler 0'dan 255'e kadar numaralandı ı ı ı
ile ifade edilebilir. Örneğin bir kategorinin sayı ı ı ı ı
2024-04-02 13:01:04 +03:00
aşağı ı
0 0 0 0 1 1 1 0
Tabii kategori sayı ı ı ı
bit sayı ı ı ı ı
Binary encoding işlemi manuel bir biçimde yapı ı ı
scikit-learn kütüphanesinin ana modülleri içerisinde de böyle bir sı ı
girişimlerinden birinde bu işlemi yapan bir BinaryEncoder isminde bir sı ı ı ı ı
bir paket içerisindedir ve bu paket ayrı ı
pip install category_encoders
BinaryEncoder sı ı ı ı ı ı ı ı ı
"test.csv" dosyası ı ı
Adı ı
Sacit Bulut,78,172,34,Kı ı ı
Ayşe Er,67,168,45,Yeşil,Mühendis
Ahmet San,85,182,32,Kı ı ı
Macit Şen,98,192,65,Mavi,Doktor
Talat Demir,85,181,49,Yeşil,Avukat
Sibel Ünlü,72,172,34,Mavi,Doktor
Ali Serçe,75,165,21,Yeşil,Mühendis
BinaryEncoder sı ı ı ı ı ı ı ı ı
için aşağı
from category_encoders.binary import BinaryEncoder
BinaryEncoder sı ı ı ı ı ı
return_df parametresi False geçilirse bu durumda transform fonksiyonları
df = pd.read_csv('test.csv')
be = BinaryEncoder()
transformed_data = be.fit_transform(df['Meslek'])
print(transformed_data)
Burada "Meslek" sütunu "binary encoding" biçiminde kodlanmı ı ı ı
Yukarı ı ı ı
Meslek_0 Meslek_1
0 0 1
1 0 1
2 1 0
3 1 1
4 1 0
5 1 1
6 0 1
2024-04-19 00:21:20 +03:00
BinaryEncoder sı ı ı
Örneğin:
2024-04-02 13:01:04 +03:00
be = BinaryEncoder()
transformed_data = be.fit_transform(df[['RenkTercihi', 'Meslek']])
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('test.csv')
from category_encoders.binary import BinaryEncoder
be = BinaryEncoder()
transformed_data = be.fit_transform(df[['RenkTercihi', 'Meslek']])
print(transformed_data)
df.drop(['RenkTercihi', 'Meslek'], axis=1, inplace=True)
df[transformed_data.columns] = transformed_data # pd.concat((df, transformed_data), axis=1)
print(df)
#----------------------------------------------------------------------------------------------------------------------------
Tı ı ı
tüm yazı ı ı ı ı ı
cols parametresi ile hangi sütunları
df = pd.read_csv('test.csv')
from category_encoders.binary import BinaryEncoder
be = BinaryEncoder(cols=['RenkTercihi', 'Meslek'])
transformed_df = be.fit_transform(df)
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('test.csv')
from category_encoders.binary import BinaryEncoder
be = BinaryEncoder(cols=['RenkTercihi', 'Meslek'])
transformed_df = be.fit_transform(df)
print(transformed_df)
#----------------------------------------------------------------------------------------------------------------------------
23. Ders - 16/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
Yapay zeka ve makine öğrenmesi alanı ı ı ı
ve "derin öğrenme (deep learning)" denilen yöntemler gelmektedir. Biz de bu bölümde belli bir derinlikte bu konuları
alacağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay Sinir ağları ı ı
2024-04-19 00:21:20 +03:00
tarafı ı ı
yı ı ı ı ı ı ı ı ı ı
1950'li yı ı ı ı ı
Bu yı ı ı ı ı
için önemli bir CPU gücü gerekmekteydi. Bu nedenle özellikle 1960 yı
Yapay sinir ağları ı ı
popülaritesi hepten artmı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay Sinir ağları ı ı ı ı
- Metinlerin sı ı ı ı ı
- Ses tanı
- Karakter tanı
- İsimlendirilmiş Varlı ı ı ı
- Sözcük grupları ı ı
- Metin üretimi (text generation)
- Makine çevirisi (machine translation)
- Örüntü tanı
- Yüz tanı
2024-04-19 00:21:20 +03:00
- Finansal uygulamalar (portföy yönetimi, kredi değerlendirmesi, sahtecilik, gayrimenkul değerlemesi, döviz fiyatları ı
tahmini vs.)
2024-04-02 13:01:04 +03:00
- Endüstriyel problemlerin çözümü
- Biyomedikal mühendisliğindeki bazı ı ı ı
- Optimizasyon problemlerinin çözümü
- Pazarlama süreçlerinde karşı ı
- Ulaştı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay Sinir Ağları ı
sisteminin temel yapı ı
gelen iletileri alan "dendrid" denilen bir bölümü vardı
Aksonları ı ı
(neurotransmitter)" denilen kimyasallar zerk edilir. Bunlar diğer nöronun reseptörleri tarafı ı ı
potansiyeli (action potantial)" kritik bir düzeye geldiğinde ateşleme yapı ı ı
olabilmektedir. Bir nöronun akson ucu ile diğer nönronun dendrid reseptörleri arası
nörotransmiterler vardı ı ı ı ı ı ı
nörotransmiteri sinaplarda artı
biçimlerde sağlanabilmektedir. Örneğin presinaptik nöronda (nörotransmiterleri zert eden nöron) nörotransmiter miktarı ı ı
Post sinaptik nörondaki (nörotransmiterleri alan nöron) reseptör duyarlı ı ı ı ı
sonra akson uçları ı ı ı ı ı ı
edilmesiyle de sinapstaki nörotransmiter etkinliği artı ı
denilen antideprasan ilaçlar bu mekanizmayla sinapslardaki serotonin miktarı ı ı ı ı
Nöronları ı ı ı ı ı
işleyen bölümüne iletmekte işlev görürler. İletiler nihai olarak beyindeki bazı
arka kı ı ı ı ı
"motor nöronlar (motor neurons)" denilmektedir. Motor nöronlar kaslara bağlı ı ı ı ı ı
el hareketi beynin emir vermesiyle nöral iletinin ele ulaşı ı ı ı ı
bu nöral ileti bozulursa felç durumu ortaya çı ı ı ı ı ı ı
2024-10-11 00:32:36 +03:00
bulunabilmektedir. Bu kı ı ı ı ı ı ı ı
bu bölgelere "beyaz madde (white matter)", miyelinsiz nöronlar da gri bir biçimde gözüktüğü için bu nöronları
bölgelere de "gri madde (gray matter)" denilmektedir.
2024-04-02 13:01:04 +03:00
2024-10-11 00:32:36 +03:00
Makine öğrenmesindeki yapay sinir ağları ı ı ı ı ı
Ancak artı ı ı ı
yerine yalnı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay sinir ağları ı ı ı ı ı
bir tane de çı ı ı ı ı ı ı
girdileri olarak kullanı ı ı ı
değerler çarpı ı ı ı ı ı ı
wi'ler karşı ı ı ı ı ı ı ı ı
çarpı ı ı
total = x1w1 + x2w2 + x3w3 + x4w4 + x5w5
İki vektörün karşı ı ı ı ı ı ı ı ı
fonksiyonuyla yapı ı
edeceğiz. Örneğin:
total = x1w1 + x2w2 + x3w3 + x4w4 + x5w5 + b
Bu toplam da "aktivasyon fonsiyonu (activation function)" ya da "transfer fonksiyonu (transfer function)" denilen bir fonksiyona
sokulmaktadı ı ı ı
out = activation(x1w1 + x2w2 + x3w3 + x4w4 + x5w5 + b)
Biz bu işlemi vektörel olarak şöyle de gösterebiliriz:
out = activation(XW + b)
Bir nöronun çı ı ı ı ı ı ı ı ı ı ı ı
k tane nöron olsun. Tüm girdilerin (yani Xi'lerin) bu nöronları ı ı ı ı ı ı
ve bias değeri diğerlerinden farklı ı ı ı ı ı ı ı
outs = activation(XW + b)
2024-04-19 00:21:20 +03:00
Artı ı ı ı
değeri elde edilecektir. Buradaki XW işleminin artı ı ı
Gösterimimizdeki X matrisi bir satı ı
2024-04-02 13:01:04 +03:00
X = [x1, x2, x3, ..., xn]
W matrisi aşağı
w11 w21 w31 ... wk1
w12 w22 w31 ... wk2
w13 w23 w33 ... wk3
... ... ... ... ...
w1n w2n w3n ... wkn
Buradaki X matrisi ile W matrisi matrisi matris çarpı ı
b matrisi şöyle temsil edilebilir:
b = [b1, b2, b2, ...., bk]
Böylece XW + b işleminden 1XK boyutunda bir matris elde edilecektir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Bir sinir ağı ı ı ı
2024-04-02 13:01:04 +03:00
çı ı ı ı ı ı ı
gerekir. Sinir ağları ı
öğrenmede önce ağı ı ı ı
değerlerinin ve b değerlerinin uygun biçimde belirlenmesi anlamı ı ı ı
verilerle eğitip bu w ve b değerlerinin uygun biçimde oluşturulması ı ı ı
kadar iyi eğitilirse ağı ı ı
2024-04-19 00:21:20 +03:00
Örneğin biz bir dairenin fiyatı ı ı ı ı
için şu verilerin toplandı ı ı ı
2024-04-02 13:01:04 +03:00
- Dairenin büyüklüğü
- Dairenin kaçı ı
- Dairenin içinde bulunduğu binanı ı
- Dairenin yaşam alanı ı ı
- Dairenin ne kadar yakı ı
- Dairenin içinde bulunduğu binanı ı
- Apartman aidatı
İşte elimizde veri kümesinin sütunları ı ı
elde etmiş olmamı ı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
ağı ı ı ı ı
kümesini kullanı ı ı ı ı ı ı ı ı
Artı ı ı ı
Ağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı ı ı ı ı ı
bileşenleri hakkı ı ı ı ı ı
olnmaktadı
- Ağı ı ı ı ı ı
- Ağdaki nöronları ı ı ı ı ı
- Nöronlarda kullanı ı ı ı ı
- Ağdaki w ve b değerlerini oluşturmak için kullanı ı ı ı ı
Biz de bir süreç içerisinde bu sorulara yanı ı
önemli bir işlem yükü vardı ı ı ı
yapı ı ı
Bugün artı ı ı
yapmaktadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İstatistikte girdi değerlerinden hareketle çı ı
(regression)" denilmektedir. Regresyon işlemleri çok çeşitli biçimlerde sı ı ı ı ı ı
işlemleri istatistikte tipik olarak iki grupla sı ı ı ı ı
1) (Lojistik Olmayan) Regresyon İşlemleri
2) Lojistik Regresyon İşlemleri
Aslı ı ı
Bu tür regresyonlarda girdilerden hareketle kategorik değil sayı ı ı
yukarı ı ı ı ı ı ı
değerdir. Lojistik regresyon çı ı ı
bir resmin pixel'leri olabilir. Çı ı ı ı ı ı
Bu tür regresyonlara istatistikte "lojistik regresyonlar" ya da "logit regresyonları
2024-05-20 13:45:43 +03:00
lojistik regresyon terimi yerine genellikle "sı ı ı ı ı
de kullanacağı ı ı ı
amacı ı
karşı ı ı ı
kı ı
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
Lojistik olsun ya da olması ı ı ı
edilmesi sürecidir. Örneğin:
2024-04-02 13:01:04 +03:00
y = f(x1, x2, ..., xn)
İşte makine öğrenmesinde bu f fonksiyonunun elde edilmesinin çeşitli yöntemleri vardı ı ı
bu biçimde bir f fonksiyonu bulunmaya çalı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Sı ı ı ı ı ı ı ı ı ı
çı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
biçiminde iki değerden oluştuğunu düşünelim. Bu sı ı ı ı ı ı ı
görüntüdeki kitlenin "iyi huylu (benign)" mu "kötü huylu (malign)" mu olduğuna yönelik sı ı ı ı ı ı
örnektir. Eğer sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
(multiclass)" sı ı ı
için kullanı ı ı ı ı ı ı
İstatistikte "lojistik regresyon" denildiğinde aslı ı ı ı ı ı
Çok sı ı ı
logistic regression" denilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
24. Ders - 17/03/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
En basit yapay sinir ağı
2024-05-20 13:45:43 +03:00
"doğrusal olarak ayrı ı ı ı ı ı ı
çözülebilmektedir. Her ne kadar tek bir nöron bile bazı ı ı
nöron sayı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
class Neuron:
def __init__(self, w, b):
self.w= w
self.b = b
def output(self, x, activation):
return activation(np.dot(x, self.w) + self.b)
def sigmoid(x):
return np.e ** x / (1 + np.e ** x)
w = np.array([1, 2, 3])
b = 1.2
n = Neuron(w, b)
x = np.array([1, 3, 4])
result = n.output(x, sigmoid)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Bir yapay sinir ağı ı ı
ağı ı ı ı
1) Girdi Katmanı
2) Saklı
3) Çı ı ı
Girdi katmanı ı ı ı ı ı
gerçek anlamda nöronlardan oluşmaz. Ancak anlatı ı ı ı ı ı
Başka bir deyişle girdi katmanı ı ı ı ı ı ı
fonksiyonları ı ı ı ı
2024-04-19 00:21:20 +03:00
nöron sayı ı ı ı ı ı ı
olan bir sinir ağı ı ı
2024-04-02 13:01:04 +03:00
x1 ---> O --->
x2 ---> O --->
x3 ---> O --->
x4 ---> O --->
x5 ---> O --->
Buradaki O sembolleri girdi katmanı ı ı ı
çı ı ı ı
fonksiyonu da f(x) = x biçiminde olmalı ı
Girdiler saklı ı ı ı ı
bulunabilir. Saklı ı ı ı ı ı ı ı ı
değişebilmektedir. Yani saklı ı ı ı ı ı ı
nöron sayı ı ı
Çı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Örneğin biz bir evin fiyatı ı ı ı ı ı ı ı ı ı
problemi üzerinde çalı ı ı ı ı ı ı ı ı ı ı ı
da kestirmek istiyorsak bu durumda çı ı ı ı ı ı ı ı ı ı
çı ı ı ı ı ı ı
Bir yapay sinir ağı ı ı ı ı ı ı ı ı ı ı
Bu nedenle katman sayı ı ı ı ı ı ı ı ı ı
Örneğin biz "modelimizde 5 katman var" dediğimizde birisi bu 5 katmanı ı
kalabilir. O halde iki anlamlı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir yapay sinir ağı ı ı ı ı ı ı ı
biçimde katmanlardaki nöron sayı ı ı ı ı ı ı ı
sayı ı ı ı ı ı
tam ters bir biçimde ağı ı ı ı ı
2024-04-19 00:21:20 +03:00
katmanlardaki nöron sayı ı ı ı ı ı ı
tanı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Pekiyi bir sinir ağı ı ı ı ı
- Sı ı ı
"doğrusal olarak ayrı ı ı ı ı ı ı
çözebilmektedir.
- Tek saklı ı ı ı ı ı
yeterlilikte çözebilmektedir. Ancak tek saklı ı
- İki saklı ı ı ı ı
karmaşı ı ı
- İkiden fazla saklı ı ı ı ı
katmandan fazla katmana sahip olan modellere genel olarak "derin öğrenme ağları
Yukarı ı
karmaşı ı ı ı
terimdir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay sinir ağları ı ı
Aşağı ı
tercih edilmektedir. Keras eskiden bağı ı
PlaidML gibi kütüphaneleri "backend" olarak kullanbiliyordu. Ancak daha sonraları ı ı ı
Dolayı ı ı ı
üzerinde ilerleyeceğiz. Ancak sonra diğer aşağı ı
TensorFlow kütüphanesinin kurulması ı
pip install tensorflow
TensorFlow çok thread'li ve paralel işlem yapan bir kütüphanedir. Paralel işlemler sı ı ı ı ı ı ı
da kullanmaktadı ı ı ı ı ı ı
artı ı ı ı ı
https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir veri kümesini CSV dosyası ı ı ı ı ı ı ı
Yapı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı
belirtmektedir.
Eğitim bittikten sonra genellikle ağı ı ı
Ağı ı ı ı ı ı
bir veri kümesi biçiminde olması ı ı ı ı ı ı
düşebilecektir.) O halde bizim ana veri kümesini "eğitim veri kümesi" ve "test veri kümesi" biçiminde iki kı ı ı
Oranlar çeşitli koşullara göre değişebilirse de tipik olarak %80'lik verinin eğitim için %20'lik verinin test için kullanı ı
tercih edilmektedir.
Eğitim ve test veri kümesini manuel olarak ayı ı ı ı ı ı
uygun olur. Çünkü bazı ı ı ı ı ı
bazı ı ı ı ı ı
belli kı ı ı ı ı
Biz programları ı ı ı ı
çı ı ı ı ı ı ı ı ı
vereceğiz: "training_dataset_x", "training_dataset_y", "test_dataset_x", "test_dataset_y".
Aşağı ı ı ı ı
veri kümesinin manuel ayrı ı ı ı ı ı
https://www.kaggle.com/datasets/uciml/pima-indians-diabetes-database
Bu kümesinde bazı ı ı
eksik verileri ortaalama değerle doldurabiliriz. Eksik veri içeren sütunlar şunlardı
Glucose
BloodPressure
SkinThickness
Insulin
BMI
#----------------------------------------------------------------------------------------------------------------------------
TRAINING_RATIO = 0.80
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-02 13:01:04 +03:00
dataset = df.to_numpy()
import numpy as np
np.random.shuffle(dataset)
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
training_len = int(np.round(len(dataset_x) * TRAINING_RATIO))
training_dataset_x = dataset_x[:training_len]
test_dataset_x = dataset_x[training_len:]
training_dataset_y = dataset_y[:training_len]
test_dataset_y = dataset_y[training_len:]
#----------------------------------------------------------------------------------------------------------------------------
25. Ders - 23/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Veri kümesini eğitim ve test olarak ayı
sı ı ı ı ı ı
DataFrame ve Series nesnelerini ayı ı ı
ya da train_size parametreleri 0 ile 1 arası ı ı ı ı
train_test_split fonksiyonu bize 4'lü bir liste vermektedir. Listenin elemanları ı ı ı
test_dataset_x, training_dataset_y, test_dataset_y. Örneğin:
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
Aslı
türden değer verilirse bu int değer eğitim ve test veri kümesinin sayı ı ı ı
bu parametreler için oransal değerler vermeyi tercih etmektedir.
train_test_split fonksiyonu veri kümesini bölmeden önce karı ı ı
False yapı ı ı ı
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
Burada fonksiyona dataset_x ve dataset_y girdi olarak verilmiştir. Fonksiyon bunları
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-02 13:01:04 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
#----------------------------------------------------------------------------------------------------------------------------
train_test_split fonksiyonu ile biz doğrudan Pandas DataFrame ve Series nesneleri üzerinde de bölme işlemini yapabiliriz.
Bu durumda fonksiyon bize dörtlü listeyi DataFrame ve Series nesneleri biçiminde verecektir. Aşağı
bir örnek verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
dataset_x = df.iloc[:, :-1]
dataset_y = df.iloc[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Keras'ta bir sinir ağı ı ı ı ı ı ı ı ı ı
bahsedeceğiz.
1) Öncelikle bir model nesnesi oluşturulmalı ı ı ı ı ı
En çok kullanı ı ı ı ı ı ı ı ı ı ı ı
modelde ağa her eklenen katman sona eklenir. Böylece ağ katmanları ı ı
yaratı ı
from tensorflow.keras import Sequential
model = Sequential(name='Sample')
Aslı ı ı
sı ı ı ı ı ı ı ı ı
2) Model nesnesinin yaratı ı ı
gereksinimler için farklı ı ı ı ı ı ı ı
Dense sı ı ı ı ı ı ı ı ı
hepsine girdi yapı ı
katman ekliyorsak bu durumda modele k * n + n tane yeni parametre (yani tahmin edilmesi gereken parametre) eklemiş oluruz. Burada
k * n tane ayarlanması ı ı ı
w (ağı ı ı ı
ediniz.
Dense sı ı ı ı ı ı ı
parametresi o katmandaki tüm nöronları ı ı ı ı
fonksiyonları ı
olarak girilebilir. Örneğin:
from tensorflow.keras.layers import Dense
layer = Dense(100, activation='relu')
ya da örneğin:
from tensorflow.keras.activations import relu
layer = Dense(100, activation=relu)
Dense fonksiyonun use_bias parametresi default durumda True biçimdedir. Bu parametre katmandaki nöronlarda "bias" değerinin
kullanı ı ı ı ı ı
parametrelerinin ilkdeğerlerinin rastgele biçimde hangi algoritmayla oluşturulacağı ı
değeri "glorot_unfiorm" biçimindedir. Metodun bias_initializer parametresi ise katmandaki nöronları ı
nası ı ı ı ı
durumundadı ı ı ı ı ı
Keras'ta Sequential modelde girdi katmanı ı ı ı ı ı ı ı
nöron sayı ı
input_shape ise çok boyutlu girdiler için kullanı ı
layer = Dense(100, activation='relu', input_dim=8)
Tabii input_dim ya da input_shape parametrelerini yalnı ı ı ı
dataset_x'tekü sütun sayı ı ı ı
layer = Dense(100, activation='relu', input_dim=training_dataset_x.shape[1])
Aslı ı ı ı
yeni versiyonları ı ı ı ı ı
vermektedir. Girdi katmanı ı ı ı ı ı ı ı ı
bir demet biçiminde (yani sahpe olarak) girilmelidir. Örneğin:
input = Input((8, ))
Burada 8 nöronşuk bir girdi katmanı ı ı ı
belirtiliyordu. Ancak Tensorflow kütüphanesinin yeni verisyonları ı ı ı ı
uyarı ı ı ı ı ı
girdi katmanı ı ı ı
Her katmana istersek name parametresi ile bir isim de verebiliriz. Bu isimler model özeti alı ı
kullanı
layer = Dense(100, activation='relu', name='Hidden-1')
Oluşturulan katman nesnesinin model nesnesine eklenmesi için Sequential sı ı ı ı ı ı
input = Input((8, ))
model.add(input)
layer = Dense(100, activation='relu', name='Hidden-1')
model.add(layer)
Programcı ı ı ı ı
model.add(Dense(100, activation='relu', input_dim=9, name='Hidden-1'))
3) Modele katmanlar eklendikten sonra bir özet bilgi yazdı ı ı ı ı ı
yapı ı
Yukarı ı ı ı
katmanı ı ı ı ı ı ı ı ı ı
bu katmandaki nöron sayı ı ı ı
değeri olduğuna göre bu değerler de bu sayı ı ı ı ı
sayı ı ı ı ı
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
B modelde bir girdi katmanı ı ı ı ı ı
summary metodundan elde edilen çı ı
Model: "Diabetes"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 16) │ 144 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 16) │ 272 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 1) │ 17 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 433 (1.69 KB)
Trainable params: 433 (1.69 KB)
Non-trainable params: 0 (0.00 B)
Trainable params: 433 (1.69 KB)
Non-trainable params: 0 (0.00 B)
Burada ağı ı ı ı ı
8 * 16 nöron girmektedir. Öte yandan her nöronun bir tane bias değeri de olduğuna göre ilk katmandaki tahmin ayarlanması
gereken parametrelerin (trainable parameters) sayı ı ı
bağlanmı ı ı ı
çı ı ı ı ı ı ı ı ı ı ı ı
gereken parametre vardı
Ağı ı ı ı ı ı ı
çı ı ı
1 arası ı ı ı
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-02 13:01:04 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
#----------------------------------------------------------------------------------------------------------------------------
26. Ders - 24/03/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
4) Model oluşturulduktan sonra modelin derlenmesi (compile edilmesi) gerekir. Buradaki "derleme" makine diline dönüştürme
anlamı ı ı ı ı ı ı ı ı
compile isimli metoduyla yapı ı ı ı
ve "optimizasyon algoritması ı ı ı ı ı ı ı
değerlerinin nası ı
işlemlerinde belli bir fonksiyonun minimize edilmesi istenir. İşte minimize edilecek bu fonksiyona da "loss fonksiyonu"
denilmektedir. Başka bir deyişle optimizasyon algoritması
algoritmadı ı ı
Loss fonksiyonları ı ı ı ı ı ı ı
genel olarak iki girdi alı ı ı ı
Çı ı ı ı ı ı
Tabii loss değerinin düşmesi aslı ı ı ı ı
2024-04-08 14:07:40 +03:00
çı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
cross-entropy", çoklu sı ı ı
isimli loss fonksiyonları
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Optimizasyon algoritmaları ı ı ı
benzer performans göstermektedir. En çok kullanı ı ı ı
Bu algoritmalar "gradient descent" denilen genel optimizasyon yöntemini farklı ı
algoritmaları ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
compile metodunda optimizasyon algoritması ı ı ı
bir sı ı
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', ...)
Örneğin:
from tensorflow.keras.optimizers import RMSprop
rmsprop = RMSprop()
model.compile(optimizer=rmsprop, ...)
Tabii optimizer parametresinin bir sı ı ı ı ı ı
Optimizasyon işlemlerinde bazı ı
denilmektedir. İşte optimizasyon algoritması ı ı ı ı ı
düzey parametreleri istediğimiz gibi belirleyebiliriz. Eğer optimizasyon algoritması ı
parametreler default değerlerle kullanı ı
parametre için değer girmezsek default optimazyon algoritması ı ı
loss fonksiyonu compile metoduna yine isimsel olarak ya da tensorflow.keras.losses modülündeki sı ı ı ı
biçiminde ya da doğrudan fonksiyon olarak girilebilmektedir. loss fonksiyonları ı ı
kullanı ı
'mean_squared_error' ya da 'mse'
'mean_absolute_error' ya da 'mae'
'mean_absolute_percentage_error' ya da 'mape'
'mean_squared_logarithmic_error' ya da 'msle'
'categorical_crossentropy'
'binary_crossentropy'
tensorflow.keras.losses modülündeki fonksiyonlar da kı
tensorflow.keras.losses.mean_squared_error ya da tensorflow.keras.losses.mse
tensorflow.keras.losses.mean_absolute_error ya da tensorflow.keras.losses.mae
tensorflow.keras.losses.mean_absolute_percentage_error ya da tensorflow.keras.losses.mape
tensorflow.keras.losses.mean_squared_logarithmic_error ya da tensorflow.keras.losses.msle
tensorflow.keras.losses.categorical_crossentropy
tensorflow.keras.losses.binary_crossentropy
Bu durumda compile metodu örnek bir biçimde şöyle çağrı
model.compile(optimizer='rmsprop', loss='binary_crossentropy')
compile metodunun üçüncü önemli parametresi "metrics" isimli parametredir. metrics parametresi bir liste ya da demet olarak
girilir. metrics parametresi daha sonra açı ı ı ı
belirtmektedir. Sı ı ı
parametresinde ilave fonksiyonlar da girilebilmektedir. Örneğin ikili sı ı ı
2024-05-20 13:45:43 +03:00
denilen metrik fonksiyon, çoklu sı ı ı
için de "mean_absolute_error" isimli metrik fonksiyon sı ı ı ı ı ı ı
biz eğitim sı ı ı ı
şöyle çağı ı ı
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
5) Model derlenip çeşitli belirlemeler yapı ı ı ı
sı ı ı ı ı ı
Biz burada training_dataset_x ve training_dataset_y verilerini fit metodunun ilk iki paramtresine geçirmeliyiz.
fit metodunun önemli bir parametresi batch_size isimli parametredir. Eğitim işlemi aslı ı ı
yapı ı ı ı ı ı
edilir. Bu bir grup çı ı ı ı ı ı ı ı ı
w ve bias değerleri güncellenir. Yani optimizasyon algoritması ı
2024-04-08 14:07:40 +03:00
fit metodunda batch_size parametresiyle belirtilmektedir. Bu değer girilmezse batch_size 32 olarak alı ı
pek çok uygulama için uygun bir değerdir. Optimizasyon işleminin satı ı ı ı ı ı ı
önemli nedeni vardı ı ı ı ı ı ı ı ı ı ı
"overfitting" denilen olumsuz durum için bir önlem oluşturması ı ı ı ı ı
2024-04-02 13:01:04 +03:00
fit metodunun diğer önemli parametresi de "epochs" isimli parametredir. eğitim veri kümesinin eğitim sı ı
eğitimde kullanı ı ı ı
parametresinin de 20 olduğunu varsayalı
model parametreleri 50 kere ayarlanacaktı ı
iyi bir biçimde konumlandı ı ı ı
2024-04-08 14:07:40 +03:00
epochs sayı ı ı ı ı ı ı
uygulamacı ı ı ı
"overfitting" denilen olumsuz duruma zemin hazı ı ı ı ı ı
epoch'lar sı ı ı ı ı ı ı ı
belirlediğimiz fonksiyonları ı ı ı ı
belli bir duruma geldiğinde eğitim işlemini kesebilir. Ya da uygulamacı
eğitimini yapabilir. İşlemler bitince epoch'lardaki performansa bakabilir. Olması
modeli yeniden bu sayı
karı ı ı ı ı ı ı ı ı ı ı
epoch'ta eğitim veri kümesi karı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
27. Ders - 30/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Modelin fit metodu ile eğitilmesi sı ı ı ı
işlemi test işlemine benzemektedir. Ancak test işlemi tüm model eğitildikten sonra yapı ı ı
sonra modelin eğitim sürecinde yapı ı ı ı
Epoch'lar sı ı ı ı ı ı ı ı ı ı ı
için fit metodunun validation_split parametresinin 0 ile 1 arası
değer eğitim veri kümesinin yüzde kaçı ı ı ı ı ı
veri kümesinin %20'sinin sı ı ı ı ı
2024-04-08 14:07:40 +03:00
kullanı ı ı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı ı ı
metodunda ayrı ı ı ı ı
Bazen programcı ı ı ı ı ı
Tabii validation_data parametresi girildiyse artı ı
artı ı ı
2024-04-02 13:01:04 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-04-08 14:07:40 +03:00
validation_split parametresinin default değerinin 0 olduğuna dikkat ediniz. validation_split değerinin 0 olması
sonrası ı ı ı ı
2024-04-02 13:01:04 +03:00
Pekiyi modelin fit metodunda her epoch'tan sonra sı ı ı ı
belirtilen ve ismine metrik fonksiyonlar denilen fonksiyonlar her epoch işlemi sonucunda ekrana yazdı ı ı
sonucunda fit metodu şu değerleri yazdı ı
- Epoch sonrası ı
- Epoch sonrası ı
- Epoch sonrası ı ı ı ı
- Epoch sonrası ı ı ı ı
Bir epoch işleminin batch batch yapı ı ı ı ı ı ı ı ı ı ı
bu batch işlemlerden elde edilen ortalama değerlerdir. Yani çrneğin her batch işleminden bir loss değeri elde edilir. Sonra
bu loss değerlerinin ortalaması ı ı ı ı
edilen değerler birbirine karı ı ı ı
Örneğin biz ikili sı ı ı ı ı ı ı ı
fit metodu her epoch sonrası ı ı
loss (eğitim veri kümesinden elde edilen ortalama loss değeri)
binary_accuracy (eğitim veri kümesinden elde edilen ortalama metrik değer)
val_loss (sı
val_binary_accuracy (sı
Tabii compile metodunda birden fazla metirk değer de belirtilmiş olabilir. Bu durumda fit tüm bu metrik değerlerin ortalaması ı
ekrana yazdı ı ı ı ı ı ı
....
Epoch 91/100
16/16 [==============================] - 0s 3ms/step - loss: 0.5536 - binary_accuracy: 0.7230 - val_loss: 0.5520 -
val_binary_accuracy: 0.7480
Epoch 92/100
16/16 [==============================] - 0s 3ms/step - loss: 0.5392 - binary_accuracy: 0.7251 - val_loss: 0.5588 -
val_binary_accuracy: 0.7805
Epoch 93/100
16/16 [==============================] - 0s 3ms/step - loss: 0.5539 - binary_accuracy: 0.7088 - val_loss: 0.5666 -
val_binary_accuracy: 0.8049
...
Burada loss değeri epoch sonrası ı
sı ı
ortalama isabet yüzdesini ve val_binary_accuracy ise epoch sonrası ı
yüzdesini belirtmektedir.
Eğitim sı ı ı ı ı
2024-04-08 14:07:40 +03:00
etmektedir. Örneğin ikili sı ı ı
olduğunu ancak val_binary_accuracy değerinin %65 olduğunu düşünelim. Bunun anlamı ı
sı ı ı
kümesini epoch'larla sürekli bir biçimde gözden geçiren model artı ı ı ı ı
bir veri kümesinde gösterememektedir. İşte bu olguya "overfitting" denilmektedir. Yanlı
öğrenilememesi kadar kötü bir durumdur. Overfitting oluşumunun çeşitli nedenleri vardı
dolayı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
6) fit işleminden sonra artı ı ı ı ı
evaluate isimli metodu ile yapı ı
almaktadı ı ı
2024-04-08 14:07:40 +03:00
kullanı ı ı ı
batch batch yapı ı ı ı ı ı
sonrası ı ı ı ı ı ı ı ı ı ı
batch değeri yalnı ı ı ı ı ı
32 alı ı ı
fonksiyonunun değeridir. Diğer elemanları ı ı ı
2024-04-02 13:01:04 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
Aslı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
metrics_names isimli bir örnek özniteliği (instance attribute) bulundurulmuştur. Bu metrics_names listesindeki isimler bire
bir evalute metodunun geri döndürdüğü liste elemanları
2024-04-02 13:01:04 +03:00
aşağı ı
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
Aynı
for name, value in zip(model.metrics_names, eval_result):
print(f'{name}: {value}')
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
28. Ders - 06/04/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
7) Artı ı
2024-04-08 14:07:40 +03:00
sı ı ı ı ı ı ı ı ı
veriririz. predict metodu da bize çı ı ı ı
bir NumPy dizisi vermeliyiz. Çünkü predict metodu tek hamlede birden çok satı
metoduna bir satı
2024-04-02 13:01:04 +03:00
import numpy as np
2024-04-08 14:07:40 +03:00
ı
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
predict_result = model.predict(predict_data)
print(predict_result)
2024-04-08 14:07:40 +03:00
predict metodu bize tahmin edilen değerleri iki boyutlu bir NumPy dizisi biçiminde vermektedir. Bunun nedeni aslı ı
birden fazla çı ı ı ı ı ı ı ı ı
sütundan" oluşan bir matris, ağı ı ı ı ı
örneğin çı ı ı
2024-04-02 13:01:04 +03:00
for i in range(len(predict_result)):
print(predict_result[i, 0])
2024-04-08 14:07:40 +03:00
Ya da şöyle yazdı
for result in predict_result[:, 0]:
print(result)
2024-04-02 13:01:04 +03:00
Tabii iki boyutlu diziyi Numpy'ı ı
yapabilirdik:
for val in predict_result.flatten():
print(val)
2024-04-08 14:07:40 +03:00
predict metodu bize ağı ı ı ı ı ı ı ı
fonksiyonunun "sigmoid" olduğunu anı ı ı ı ı
çı ı ı ı ı ı
şeker hastası ı ı ı ı ı ı
hastası ı ı ı ı ı ı ı ı ı
sigmoid fonksiyonun çı ı ı ı ı ı ı ı ı ı
çı ı ı
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-04-08 14:07:40 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-08 14:07:40 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-04-08 14:07:40 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-04-08 14:07:40 +03:00
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='Diabetes')
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-08 14:07:40 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import numpy as np
2024-04-08 14:07:40 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
predict_result = model.predict(predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Şimdi yukarı ı ı ı ı ı ı
katmanla ve Dense bir bağlantı ı ı ı ı ı
katmanlı ı ı ı ı ı ı
iki saklı ı ı ı
öğrenme (deep learning)" modelleri de denilmektedir.
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Girdi katmanı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
"one-hot encoding" işlemine sokulmalı ı ı ı ı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
(binary classification) problemlerinde çı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
çı ı ı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
sayı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Saklı ı ı ı ı ı ı
faktörlere de bağlı ı ı ı ı ı
parametrelerin durumları ı ı ı ı ı ı
için şunlar söylenebilir:
2024-04-02 13:01:04 +03:00
- Problem karmaşı ı ı ı ı ı ı
- Saklı
2024-04-08 14:07:40 +03:00
- Saklı ı
da yol açabilir. Aynı ı ı ı ı
- Eğitim veri kümesi azsa saklı ı ı
- Pek çok problemde saklı ı ı ı
2024-04-02 13:01:04 +03:00
- Saklı ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
Çeşitli kaynaklar saklı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
- Saklı ı ı ı ı ı ı ı ı ı ı ı ı
sayı ı ı ı ı ı ı ı ı ı ı
katmandaki nöron sayı ı
2024-04-02 13:01:04 +03:00
- Saklı ı ı ı ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
Biz genellikle genel problemlerde iki saklı ı ı
2024-04-02 13:01:04 +03:00
Ancak ileride özel mimarilerde bu durumu farklı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Yapay sinir ağı ı ı ı
eğitimden eğitime değişebilir. Her eğitimde ağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
1) train_test_split fonksiyonu her çalı ı ı ı ı ı
karı ı
2024-04-08 14:07:40 +03:00
2) Katmanlardaki "w" değerleri (ve istersek "bias" değerleri) programı ı ı ı ı ı
set edilmektedir.
2024-04-02 13:01:04 +03:00
3) fit işleminde her epoch sonrası ı ı ı ı
2024-04-08 14:07:40 +03:00
Bir rastgele sayı ı ı ı ı
sayı ı
tohum değeri programı ı ı ı ı ı ı
O halde eğitimden hep aynı ı ı
dikkate alı ı ı ı
1) scikit-learn ve diğer bazı ı ı ı ı ı
rassal sayı
import numpy as np
np.random.seed(12345)
2) Tensorflow kütüphanesi bazı ı ı
set edilebilir. Örneğin:
from tensorflow.keras.utils import set_random_seed
set_random_seed(78901)
Tabii yukarı ı ı
rassal sayı ı ı ı ı ı ı ı ı
ifade etmekltedir.
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Pekiyi neden ağı ı ı ı
İşte bazen modellerimizde ve algoritmaları ı ı ı ı ı
kı ı ı ı ı ı ı ı ı ı
değerler olması ı ı ı ı ı ı ı
üretimi yapmak yerine algoritmaları ı ı ı ı
karşı ı ı ı
O halde biz yukarı ı ı ı ı
test işleminde aynı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-04-08 14:07:40 +03:00
import numpy as np
from tensorflow.keras.utils import set_random_seed
np.random.seed(1234567)
set_random_seed(678901)
2024-04-02 13:01:04 +03:00
df = pd.read_csv('diabetes.csv')
2024-04-08 14:07:40 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-08 14:07:40 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-04-08 14:07:40 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-04-08 14:07:40 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
model = Sequential(name='Diabetes')
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-08 14:07:40 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-08 14:07:40 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
predict_result = model.predict(predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de dikkatimizi katmanlardaki aktivasyon fonksiyonları ı ı ı
Girdi katmanı ı ı ı
fonksiyonları ı ı ı ı ı ı ı
olarak ele alacağı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Özellikle son yı ı
aktivasyon fonksiyonudur. Bu fonksiyona İngilizce "rectifier" da denilmektedir. Relu fonksiyonu şöyledir:
2024-04-02 13:01:04 +03:00
x >= 0 ise y = x
2024-04-08 14:07:40 +03:00
x < 0 ise y = 0
Yani relu fonksiyonu x değeri 0'dan büyük ise (ya da eşit ise) aynı
fonksiyondur. relu fonksiyonunu basit bir biçimde aşağı
def relu(x):
return np.maximum(x, 0)
NumPy kütüphanesinin maximum fonksiyonunun birinci parametresi bir NumPy dizisi ya da Python listesi biçiminde girilirse
fonksiyon bu dizinin ya da listenin her elemanı ı
>>> import numpy as np
>>> x = [10, -4, 5, 8, -2]
>>> y = np.maximum(x, 3)
>>> y
array([10, 3, 5, 8, 3])
2024-04-02 13:01:04 +03:00
Relu fonksiyonun grafiği aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
2024-04-08 14:07:40 +03:00
def relu(x):
return np.maximum(x, 0)
2024-04-02 13:01:04 +03:00
x = np.linspace(-10, 10, 1000)
2024-04-08 14:07:40 +03:00
y = relu(x)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
plt.title('Relu Function', fontsize=14, fontweight='bold', pad=20)
2024-04-02 13:01:04 +03:00
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-10, 10)
2024-04-08 14:07:40 +03:00
plt.plot(x, y, color='red')
2024-04-02 13:01:04 +03:00
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Aktivasyon fonksiyonları
fonksiyonlar biçiminde de girilebilmektedir. Örneğin:
2024-04-02 13:01:04 +03:00
from tensorflow.keras.activations import relu
...
model.add(Dense(16, activation=relu, name='Hidden'))
2024-04-08 14:07:40 +03:00
Bu modüldeki fonksiyonlar keras Tensorflow kullanı ı ı ı ı ı
grafik çizdirirken fonksiyonunu kendimiz yazmak yerine tensorflow içerisindeki fonksiyonu doğrudan da kullanabiliriz. Tensor
nesnelerinin NumPy dizilerine dönüştürülmesi için Tensor sı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
from tensorflow.keras.activations import relu
x = np.linspace(-10, 10, 1000)
y = relu(x).numpy()
Aşağı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
import numpy as np
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
def relu(x):
return np.maximum(x, 0)
x = np.linspace(-10, 10, 1000)
# y = relu(x)
from tensorflow.keras.activations import relu
y = relu(x).numpy()
plt.title('Relu Function', fontsize=14, fontweight='bold', pad=20)
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-10, 10)
plt.plot(x, y, color='red')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
İkili sı ı ı ı ı ı ı
Yukarı ı ı ı ı ı ı ı ı
problemlerinde ağı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Pekiyi sigmoid nası
ifadesi şöyledir:
2024-04-02 13:01:04 +03:00
y = 1 / (1 + e ** -x)
2024-04-08 14:07:40 +03:00
Burada e değeri 2.71828... biçiminde irrasyonel bir değerdir. Yukarı ı ı ı
aşağı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
y = e ** x / (1 + e ** x)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Fonksiyona "sigmoid" isminin verilmesinin nedeni S şekline benzemesinden dolayı ı
veren x pozitif yönde arttı ı ı ı
eğridir. Sigmoid fonksiyonunun (0, 1) arası ı ı
hiçbir zaman 1 olmaz. Benzer biçimde x değeri azaldı ı
Sigmoid fonksiyonu makine öğrenmesinde ve istatistikte belli bir gerçek değeri 0 ile 1 arası ı
kullanı ı ı ı ı ı ı ı ı ı ı
bulunurken kesin bir yargı ı ı ı ı
0.5'ten büyükse bunu 1 gibi, 0.5'ten küçükse 0 gibi değerlendiririz.
2024-04-02 13:01:04 +03:00
Sigmoid eğrisi aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 1000)
y = np.e ** x / (1 + np.e ** x)
plt.title('Sigmoid (Logistic) Function', fontsize=14, pad=20, fontweight='bold')
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-1, 1)
plt.plot(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Yine benzer biçimde tensorflow.keras.activations modülü içerisinde sigmoid fonksiyonu zaten hazı ı
Tabii bu fonksiyon da bize Tensorflow'daki bir Tensor nesnesini vermektedir. Aşağı ı
kullanarak çizdiriyoruz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
import numpy as np
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
from tensorflow.keras.activations import sigmoid
x = np.linspace(-10, 10, 1000)
y = sigmoid(x).numpy()
plt.title('Sigmoid (Logistic) Function', fontsize=14, fontweight='bold', pad=20)
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-1, 1)
plt.plot(x, y, color='red')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Sigmoid fonksiyonu nası ı ı ı ı
Sigmoid fonksiyonunun birinci türevi Gauss eğrisine benzemektedir. Aşağı
alı ı ı
türevi şöyledir:
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
sigmoid'(x) = exp(x)/(exp(x) + 1) - exp(2 * x)/(exp(x) + 1) ** 2
#----------------------------------------------------------------------------------------------------------------------------
import sympy
2024-04-02 13:01:04 +03:00
from sympy import init_printing
init_printing()
2024-04-08 14:07:40 +03:00
x = sympy.Symbol('x')
fx = sympy.E ** x / (1 + sympy.E ** x)
dx = sympy.diff(fx, x)
2024-04-02 13:01:04 +03:00
print(dx)
import numpy as np
np.linspace(-10, 10, 1000)
pdx = sympy.lambdify(x, dx)
x = np.linspace(-10, 10, 1000)
y = pdx(x)
import matplotlib.pyplot as plt
plt.title('First Derivative of Sigmoid Function', fontsize=14, pad=20, fontweight='bold')
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-0.4, 0.4)
plt.plot(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Diğer çok kullanı ı
da denilmektedir. Fonksiyonun matematiksel ifadesi şöyledir:
2024-04-02 13:01:04 +03:00
f(x) = (e ** (2 * x) - 1) / (e ** (2 * x) + 1)
2024-04-08 14:07:40 +03:00
Fonksiyonun sigmoid fonksiyonuna benzediğine ancak üstel ifadenin x yerine 2 * x olduğuna dikkat ediniz. Tanh fonksiyonu adeta
sigmoid fonksiyonunun (-1, +1) arası ı ı
Tanh fonksiyonu saklı ı ı ı ı ı
çok yoğun kullanı ı ı ı
daha iyi sonuç verdiği modeller de söz konusu olmaktadı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
tanh fonksiyonu Keras'ta tensorflow.keras.activations modülünde tanh ismiyle de bulunmaktadı
2024-04-02 13:01:04 +03:00
Fonksiyonun grafiğini aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 1000)
y = (np.e ** (2 * x) - 1) / (np.e ** (2 * x) + 1)
plt.title('Hiperbolik Tanjant (tanh) Fonksiyonunun Grafiği', fontsize=14, pad=20, fontweight='bold')
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-1, 1)
plt.plot(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok karşı ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
problemlerinde çı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Örneğin bir resmin "elma", "armut", "kayı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
logistic regression)" da denilmektedir. Bu tür problemlerde sinir ağı ı ı ı ı
yukarı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Ağı ı ı ı ı ı ı ı ı ı ı ı ı ı
değerlerinin toplamı ı ı ı ı ı ı ı ı ı ı ı ı ı
hale gelir. Biz de toplamı ı ı ı ı ı ı ı ı ı ı ı
Örneğin yukarı ı ı ı ı ı ı ı ı ı ı
çı ı ı
2024-04-02 13:01:04 +03:00
Elma Nöronunun Çı ı ı
Armut Nöronunun Çı ı ı
Kayı ı ı ı ı
Şeftali Nöronunun Çı ı ı
2024-04-08 14:07:40 +03:00
karpuz Nöronunun Çı ı ı
Burada en büyük çı ı ı ı ı ı
Softmax fonksiyonu bir grup değer için o grup değerlere bağlı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
softmax(x) = np.e ** x / np.sum(np.e ** x)
Burada gruptaki değerler x vektörüyle temsil edilmektedir. Fonksiyonda değerlerinin e tabanı
e tabanı ı ı ı
Tabii bu değerlerin toplamı ı ı
x = np.array([3, 6, 4, 1, 7])
Şimdi bu x değerlerinin softmax değerlerini elde edelim:
2024-04-02 13:01:04 +03:00
>>> import numpy as np
>>> x = np.array([3, 6, 4, 1, 7])
>>> x
array([3, 6, 4, 1, 7])
>> sm = np.e ** x / np.sum(np.e ** x)
>>> sm
array([0.0127328 , 0.25574518, 0.03461135, 0.0017232 , 0.69518747])
>>> np.sum(sm)
1.0
2024-04-08 14:07:40 +03:00
softmax fonksiyonu Keras'ta tensorflow.keras.activations modülünde softmax ismiyle de bulunmaktadı
kullanı ı
Tensorflow kütüphanesindeki aktivasyon fonksiyonları ı ı ı ı ı ı
Bu nedenle softmax gibi bazı ı ı
birden fazla değer üzerinde de bir Tensor olarak işlem yapabilmektedir. (softmax fonksiyonunda aslı
değerden oluştuğu için girdi olarak da bizden iki boyutlu bir Tensor istenmektedir.) Örneğin:
>>> import numpy as np
>>> import tensorflow as tf
>>> from tensorflow.keras.activations import softmax
>>> x = np.array([[1, 2, 3, 4, 5]], dtype=np.float64)
>>> t = tf.convert_to_tensor(x)
>>> result = softmax(t)
>>> result
<tf.Tensor: shape=(1, 5), dtype=float64, numpy=array([[0.01165623, 0.03168492, 0.08612854, 0.23412166, 0.63640865]])>
2024-04-02 13:01:04 +03:00
Keras aslı ı ı ı ı ı
ağı ı ı ı ı
uygular. Başka bir deyişle çı ı ı
değerlendirilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Diğer çok kullanı ı ı
ya da f(x) = x fonksiyonudur. Yani "linear" fonksiyonu girdi ile aynı
bir fonksiyondur. Pekiyi böyle bir aktivasyon fonksiyonunun ne anlamı
2024-05-20 13:45:43 +03:00
(lojistik olmayan regresyon problemlerinde)" çı ı ı ı ı ı ı ı ı
bilgisi değil gerçek bir değer bulmaya çalı ı ı
başı ı ı ı ı ı ı
biz kursumuzda bir sayı ı ı
modelleri)" de diyoruz. Aslı
2024-04-08 14:07:40 +03:00
anlaşı ı
linear aktivasyon fonksiyonu Keras'ta "linear" ismiyle kullanı ı ı
2024-04-19 00:21:20 +03:00
fonksiyonu aynı ı
Örneğin:
2024-04-08 14:07:40 +03:00
>>> from tensorflow.keras.activations import linear
>>> x = [1, 2, 3, 4, 5]
>>> x = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> result = linear(x)
>>> result
array([1., 2., 3., 4., 5.])
linear fonksiyonunun grafiğini -bariz olması ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
import numpy as np
import matplotlib.pyplot as plt
def linear(x):
return x
x = np.linspace(-10, 10, 1000)
y = linear(x)
"""
from tensorflow.keras.activations import linear
y = linear(x).numpy()
"""
plt.title('Linear Function', fontsize=14, fontweight='bold', pad=20)
axis = plt.gca()
axis.spines['left'].set_position('center')
axis.spines['bottom'].set_position('center')
axis.spines['top'].set_color(None)
axis.spines['right'].set_color(None)
axis.set_ylim(-10, 10)
plt.plot(x, y, color='red')
plt.show()
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Biz yukarı ı ı ı ı ı ı ı ı ı ı
aktivasyon fonksiyonu vardı ı ı ı ı ı ı
üzerinde duracağı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
loss fonksiyonları ı ı ı ı ı ı ı
ifade eden fonksiyonlardı ı ı ı ı ı
değerlerle ağı ı ı ı ı ı
anlamı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-08 14:07:40 +03:00
Anı ı ı
Yukarı ı ı ı ı
Başka bir deyişle "loss" fonksiyonu aslı
görmektedir. Değişik problemler için değişik loss fonksiyonları ı ı ı ı ı ı
loss parametresiyle loss fonksiyonu isimsel biçimde girebilir. Ya da isterse tensorflow.keras.losses modülündeki sı ı
ve fonksiyonlar yoluyla girebilir. (Loss fonksiyonları ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Eğitim batch batch yapı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
Yani bir batch işleminin gerçek sonucu ile ağdan o batch için elde edilecek kestirim sonuçları ı
hesaplanmaktadı ı ı ı ı
eder. Bu 32 çı ı
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemleri için en yaygı ı
Türkçe "Ortalama Karesel Hata" diyebiliriz. MSE fonksiyonu çı ı ı ı
karelerinin ortalaması ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
mse = np.mean((y - y_hat) ** 2)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Burada y gerçek değerleri, y_hat ise kestirilen değerleri belirtmektedir. Örneğin:
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
>>> y = np.array([1, 2, 3, 4, 5])
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> np.mean((y - y_hat) ** 2)
0.020080000000000032
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Aynı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
>>> from tensorflow.keras.losses import mse
>>> mse(y, y_hat)
<tf.Tensor: shape=(), dtype=float64, numpy=0.020080000000000032>
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemleri için kullanı
Bu fonksiyona da Türkçe "Ortalama Mutlak Hata" diyebiliriz. Ortalama mutlak hata gerçek değerlerden kestirilen değerlerin
farkları ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
mae = np.mean(np.abs(y - y_hat))
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada y gerçek değerleri y_hat ise ağı
olarak çoğu kez MSE tercih edilmektedir. Çünkü kare alma işlemi algoritmalar için daha uygun bir işlemdir. Aynı
eğerleri daha fazla farklı ı ı ı ı
2024-04-08 14:07:40 +03:00
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> mae = np.mean(np.abs(y - y_hat))
>>> mae
0.12400000000000003
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Ortalama karesel hata bir metrik değer olarak bizim için iyi bir çağrı ı ı
bizim için anlamlı ı ı ı ı ı ı ı ı ı ı
değerden 0.124 solda ya da sağda olabilir. Yine ortalama mutlak hata tensorflow.keras.losses modülü içerisindeki "mae" ya da
"mean_absolute_error" isimli fonksiyonla da hesaplanabilmektedir. Örneğin:
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
>>> from tensorflow.keras.losses import mae
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> result = mae(y, y_hat)
>>> result
<tf.Tensor: shape=(), dtype=float64, numpy=0.12400000000000003>
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemleri için diğer bir loss fonksiyonu da "Mean Absolute Percentage Error (MAPE)" isimli fonksiyondur. Fonkisyonun
sembolik ifadesi şöyledir:
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
mape = 100 * np.mean(np.abs(y - y_hat) / y)
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
Burada y gerçek değerleri y_hat ise ağı
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> mape = 100 * np.mean(np.abs(y - y_hat) / y)
>>> mape
5.413333333333335
Tabii aynı
>>> from tensorflow.keras.losses import mape
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> result = mape(y, y_hat)
>>> result
<tf.Tensor: shape=(), dtype=float64, numpy=5.413333333333335>
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemleri için diğer bir loss fonksiyonu da "Mean Squared Logarithmic Error (MSLE)" isimli fonksiyondur. Bu
fonksiyon gerçek değerlerle kestirilen değerlerin logaritmaları ı ı ı ı ı
Sembolik ifadesi şöyledir:
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
msle = np.mean((np.log(y) - np.log(y_hat)) ** 2)
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
Bazen bu fonksiyon gerçek ve kestirilen değerlere 1 toplanarak da oluşturulabilmektedir (Tensorflow "msle" fonksiyonunu
bu biçimde kullanmaktadı
2024-04-02 13:01:04 +03:00
2024-04-08 14:07:40 +03:00
msle = np.mean((np.log(y + 1) - np.log(y_hat + 1)) ** 2)
2024-04-02 13:01:04 +03:00
Örneğin:
2024-04-08 14:07:40 +03:00
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> msle = np.mean((np.log(y + 1) - np.log(y_hat + 1)) ** 2)
>>> msle
0.0015175569737783628
Aynı
>>> from tensorflow.keras.losses import msle
>>> y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
>>> y_hat = np.array([1.1, 1.9, 3.2, 3.8, 5.02])
>>> result = msle(y, y_hat)
>>> result
<tf.Tensor: shape=(), dtype=float64, numpy=0.0015175569737783555>
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İkili sı ı ı ı ı
Bu fonksiyonun sembolik gösterimi şöyledir:
bce = -np.mean(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))
Burada bir toplam teriminin olduğunu görüyorsunuz. Gerçek değerler 0 ya da 1 olduğuna göre bu toplam teriminin ya sol tarafı
ya da sağ tarafı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Örneğin gerçek y değeri 0 olsun ve ağ da sigmoid çı ı ı ı
sağ tarafı ı ı ı ı ı
düşününelim. Bu kez toplamı ı ı ı ı ı ı ı
logaritmaları ı ı ı
>>> y = np.array([1, 0, 1, 1, 0])
>>> y_hat = np.array([0.9, 0.05, 0.095, 0.89, 0.111])
>>> -np.mean(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))
0.5489448114302314
Aynı
>>> y_hat = np.array([0.9, 0.05, 0.095, 0.89, 0.111])
>>> result = binary_crossentropy(y, y_hat)
>>> result
<tf.Tensor: shape=(), dtype=float64, numpy=0.5489445126600796>
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Cok sı ı ı ı ı ı ı ı
fonksiyondur. CCE fonksiyonu aslı ı
sayı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-04-21 09:50:22 +03:00
nöronları ı ı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
değerlerin one-hot encoding biçiminde kodlanmı ı ı ı ı ı ı ı
problemi için biz ağa çı ı ı ı ı
satı ı ı ı ı
2024-04-21 09:50:22 +03:00
değeri söz konusu olmalı ı
2024-04-08 14:07:40 +03:00
cce = -np.sum(yk * log(yk_hat))
2024-05-20 13:45:43 +03:00
Burada yk one-hot encoding yapı ı ı ı ı ı
2024-04-21 09:50:22 +03:00
değerleri temsil etmektedir.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
#----------------------------------------------------------------------------------------------------------------------------
30. Ders - 20/04/2024 - Cumartesi
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı
2024-04-21 09:50:22 +03:00
almak için kullanı ı
bulunmaktadı ı
bir liste biçiminde girilmektedir. Metrik fonksiyonlar yazı
fonksiyonlar ve sı ı
Metrik fonksiyonlar da tı ı ı ı ı ı ı ı
olarak almaktadı ı ı ı ı
algoritmaları ı ı ı ı
için bizim tarafı ı ı ı
Aslı ı ı ı ı
değerlerini her epoch'ta eğitim ve sı ı ı ı ı ı
eğer biz loss fonksiyonu olarak "binary_crossentropy" girmişsek ayrı ı
Özetle er loss fonksiyonu bir metrik fonksiyon gibi de kullanı
kullanı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
"binary_accuracy" isimli metrik fonksiyon ikili sı ı ı ı ı
Bu fonksiyon kabaca kaç gözlemin değerinin kestirilen değerle aynı
veri kümesinde "binary_accuracy" değerinin 0.70 olması
"binary_accuracy" metrik değeri Keras'ta isimsel olarak girilebileceği gibi tensorflow.keras.metrics modülündeki fonksiyon
ismi olarak da girilebilir.
Aslı ı ı ı ı ı
yeterli dokümantasyona sahip değildir. Tensorflow kütüphanesinin çeşitli versiyonları ı ı
Bu nedenle bu fonksiyonları ı ı ı ı
Örneğin biz tensorflow.keras.metrics modülündeki binary_accuracy fonksiyonunu aşağı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.metrics import binary_accuracy
import numpy as np
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
y = np.array([1, 0, 1, 1, 0])
y_hat = np.array([0.90, 0.7, 0.6, 0.9, 0.6])
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
result = binary_accuracy(y, y_hat)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Çok sı ı ı ı ı ı ı
2024-04-08 14:07:40 +03:00
Bu fonksiyon da yine gözlemlerin yüzde kaçı ı ı ı ı
2024-04-21 09:50:22 +03:00
0.50 değeri iyi bir değer değildir. Çünkü zaten rastgele seçim yapı ı
100 sı ı ı ı ı
isimsel biçimde ya da tensorflow.keras.metrics modülündeki fonksiyon ismiyle kullanabiliriz.
tensorflow.keras.metrics modülündeki categorical_accuracy fonksiyonu aslı
vermektedir, ortalama vermemektedir. Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.metrics import categorical_accuracy
import numpy as np
# elma, armut, kayı ı
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
y = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
y_hat = np.array([[0.2, 0.7, 0.1], [0.2, 0.1, 0.7], [0.8, 0.1, 0.1], [0.7, 0.2, 0.1], [0.6, 0.2, 0.2]])
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
result = categorical_accuracy(y, y_hat)
result_ratio = np.sum(result) / len(result)
print(result_ratio)
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemleri için pek çok loss fonksiyonu aslı ı
problemde loss fonksiyonu olarak "mean_squared_error" seçmişsek metrik fonksiyon olarak "mean_absolute_error" seçebiliriz.
mean_absolute_error fonksiyonu loss fonksiyonu olarak o kadar iyi olmasa da metrik anlamda kişilerin kolay anlayabileceği
bir fonksiyondur. Benzer biçimde regresyon problemlerinde "mean_asbolute_percentage_error", "mean_squared_logarithmic_error"
fonksiyonları ı
2024-04-21 09:50:22 +03:00
Loss fonksiyonları ı ı
loss fonksiyonu ile mean_absolute_error metrik fonksiyonu aynı ı
tensorflow.keras.losses ve tensorflow.keras.metrics modüllerinde ayrı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
Metrik fonksiyonlar yazı ı ı
2024-04-21 09:50:22 +03:00
'binary_accuracy' (kı
'categorical_accuracy' (kı
'mean_absolute_error' (kı
'mean_absolute_percentage_error' (kı
'mean_squared_error' kı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir sinir ağı ı ı ı ı ı
2024-04-21 09:50:22 +03:00
ağı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
verilerle eğitim yapı ı
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
Keras'ta yapı ı
2024-04-19 00:21:20 +03:00
kastedilmektedir. Ayrı ı ı
gerek kalmaz. Tüm model katmanları ı
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
Sinir ağı ı ı ı
dosya formatları ı
2024-04-19 00:21:20 +03:00
akla gelen format "HDF (Hieararchical Data Format)" denilen formattı ı ı
olarak bilinmektedir.
2024-04-02 13:01:04 +03:00
Modeli bir bütün olarak saklamak için Sequential sı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
dosyanı ı ı ı ı
dosya TensorFlow kütüphanesinin kullandı ı ı ı ı
girmeliyiz. Örneğin:
2024-04-02 13:01:04 +03:00
model.save('diabetes.h5', save_format='h5')
2024-04-21 09:50:22 +03:00
Aşağı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-04-21 09:50:22 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-21 09:50:22 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-04-21 09:50:22 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-04-21 09:50:22 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-04-21 09:50:22 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-21 09:50:22 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
model.save('diabetes.h5', save_format='h5')
#----------------------------------------------------------------------------------------------------------------------------
2024-04-21 09:50:22 +03:00
HDF5 formatı ı ı ı
yüklenebilir. load_model fonksiyonu bizden yüklenecek dosyanı ı
nesnesini mektedir. Örneğin:
2024-04-02 13:01:04 +03:00
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
2024-04-21 09:50:22 +03:00
Artı ı ı
Aşağı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.models import load_model
import numpy as np
2024-04-21 09:50:22 +03:00
model = load_model('diabetes.h5')
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
predict_result = model.predict(predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-21 09:50:22 +03:00
Aslı ı ı ı ı ı ı ı
save_weights metodu kullanı ı
2024-04-02 13:01:04 +03:00
model.save_weights('diabetes-weights', save_format='h5')
2024-04-21 09:50:22 +03:00
Aşağı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-04-21 09:50:22 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-21 09:50:22 +03:00
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-04-21 09:50:22 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-04-21 09:50:22 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-04-21 09:50:22 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-21 09:50:22 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
model.save_weights('diabetes-weights.h5', save_format='h5')
#----------------------------------------------------------------------------------------------------------------------------
2024-04-21 09:50:22 +03:00
save_weights metodu yalnı
aynı ı ı
sı ı ı ı ı ı
model.load_weights('diabetes-weights.h5')
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
Aşağı ı ı
gibi save_weights model bilgilerini saklamadı ı ı ı
"w" ve "bias" değerlerini load_weights metodu ile geri yüklerken veri kümesini oluşturmamı
metodu model yalnı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras import Sequential
2024-04-21 09:50:22 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-04-21 09:50:22 +03:00
model.add(Input((8,)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-21 09:50:22 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-02 13:01:04 +03:00
model.load_weights('diabetes-weights.h5')
2024-04-21 09:50:22 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
predict_result = model.predict(predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Biz katman nesnelerini (Dense nesnelerini) model sı ı ı ı ı ı ı ı ı
Bu katman nesnelerini ileride kullanmak istediğimizd enası
yaratı ı
model = Sequential(name='Diabetes')
model.add(Input((8,)))
layer1 = Dense(16, activation='relu', name='Hidden-1')
model.add(layer1)
layer2 = Dense(16, activation='relu', name='Hidden-2')
model.add(layer2)
layer3 = Dense(1, activation='sigmoid', name='Output')
model.add(layer3)
model.summary()
Aslı ı ı ı ı
indeks eşliğinde bizim eklediğimiz katman nesnelerini bize vermektedir. layers örnek özniteliği bir Python listesidir.
Örneğin:
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
layer2 = model.layers[2]
2024-04-02 13:01:04 +03:00
2024-04-21 09:50:22 +03:00
Tabii layers özniteliği bize Input katmanı ı ı ı ı ı
katmanı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
31. Ders - 21/04/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-04-21 09:50:22 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı
2024-05-20 13:45:43 +03:00
ağı ı ı ı ı ı ı ı ı ı ı
set_weights isimli metotları ı ı
2024-04-21 09:50:22 +03:00
NumPy dizisi olarak elde edip geri yükleyebiliriz.
2024-04-02 13:01:04 +03:00
Dense sı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
Listenin ilk elemanı ı ı ı ı ı
belirtmektedir. Katmandaki nöronları ı ı
katmanı ı ı ı ı ı ı ı ı
i'inci satı ı ı ı ı ı ı
Bu durumda örneğin [i, k] indeksindeki eleman önceki katmanı ı ı ı ı ı
ağı ı ı
get_weights metodunun verdiği listenin ikinci elemanı ı ı
Bias değerlerinin ilgili katmandaki nöron sayı ı ı
değeri vardı
Örneğin yukarı ı ı ı ı
layer = model.layers[0]
weights, bias = layer.get_weights()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada weights dizisinin shape'i yazdı ı ı ı ı ı ı ı
görülecektir.
Aşağı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-05-20 13:45:43 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
hidden1 = model.layers[0]
2024-05-20 13:45:43 +03:00
weights, bias = hidden1.get_weights()
print('Weights')
print(weights)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
print('Bias')
print(bias)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
print("5'inci girdi nöronunun ilk katmanı ı ı
w = weights[5, 9]
print(w)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Bir katmandaki "w" ve "bias" değerlerini Dense sı ı ı ı
hidden1 = model.layers[0]
weights, bias = hidden1.get_weights()
weights = weights + 0.1
hidden1.set_weights([weights, bias])
Burada birinci saklı ı ı ı ı
metodunun iki elemanı ı ı ı
veriyorsa set_weights metodu da hem "w" hem de "bias" değerlerini istemektedir.
Aşağı ı
anlam aramayı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-05-20 13:45:43 +03:00
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
hidden1 = model.layers[0]
2024-05-20 13:45:43 +03:00
weights, bias = hidden1.get_weights()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
weights = weights + 0.1
hidden1.set_weights([weights, bias])
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Yapay sinir ağları ı ı
2024-04-02 13:01:04 +03:00
1) Hedefin Belirlenmesi: Öncelikle uygulamacı ı ı ı
2024-05-20 13:45:43 +03:00
istediği problem nedir? Bir sı ı ı ı
dili anlama problemi midir? gibi...
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
2) Kestirimle İlgili Olacak Özellerin (Sütunları
gereksinim duyulmaktadı
isteyelim. Burada ilk gelecek özellikler şunlar olabilir:
2024-04-02 13:01:04 +03:00
- Eczanenin konumu
- Ecnanenin önünden geçen günlük insan sayı ı
2024-05-20 13:45:43 +03:00
- Eczanenin destek ürünleri satı ı ı
2024-04-02 13:01:04 +03:00
- Eczanenin kozmetik ürünler satı ı ı
- Eczanenin anlaşmalı
2024-05-20 13:45:43 +03:00
- Eczanenin büyüklüğü
2024-04-02 13:01:04 +03:00
- Eczanenin yakı ı ı ı ı ı ı
- Eczacı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
3) Eğitim İçin Verilerin Toplanması ı
yöntemler söz konusu olabilir:
2024-04-02 13:01:04 +03:00
- Anketler (Surveys)
- Daha önce elde edilmiş veriler
2024-05-20 13:45:43 +03:00
- Çeşitli kurumlar tarafı
2024-04-02 13:01:04 +03:00
- Sensörler yoluyla elde edilen veriler
2024-05-20 13:45:43 +03:00
- Sosyal ağlardan elde edilen veriler
2024-04-02 13:01:04 +03:00
- Birtakı ı
2024-05-20 13:45:43 +03:00
4) Verilerin Kullanı ı ı ı ı ı ı
gerekmektedir. Örneğin gereksiz sütunlar atı ı ı ı ı ı
veriler sayı ı ı ı ı ı ı
(feature scaling)" ve "özellik mühendisliği (feature engineering)" işlemleri yapı ı ı
2024-04-02 13:01:04 +03:00
5) Yapay Sinir Ağı ı ı ı ı
6) Modelin Eğitilmesi ve Test Edilmesi: Oluşturulan model eldeki veri kümesiyle eğitilmeli ve test edilmelidir.
7) Kestirim İşleminin Yapı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Callback sözcüğü programlamada belli bir olay devam ederken programcı ı
bir nesnenin) çağrı ı ı ı ı ı ı ı
Bu sayede biz çeşitli olaylar devam ederken bu olayları ı ı ı ı
sağlayabiliriz. Böylece birtakı
gerekli işlemleri yapabiliriz.
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Sequential sı ı ı ı ı ı
callback fonksiyonları ı ı ı ı ı ı
bu callable nesneleri çağı ı
2024-04-02 13:01:04 +03:00
2024-04-19 00:21:20 +03:00
Aslı ı ı ı ı ı ı ı ı ı ı ı ı
yazabilirse de aslı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
gereksinimi karşı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
En sı ı ı ı ı ı ı ı ı ı ı ı ı ı
kullanmaz. Sequential sı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
hist = model.fit(....)
2024-05-20 13:45:43 +03:00
History callback sı ı ı ı ı ı ı ı
değerlerin kaydedilmesi için kullanı ı ı
fit işlemi sı ı ı ı
eğitim sı ı ı ı ı ı ı
zaten eğitim sı ı ı ı
nesnesi aslı ı ı ı ı ı
numaraları ı ı
bir sözlük türündendir. Sözlüğün anahtarları ı ı ı ı ı
2024-04-19 00:21:20 +03:00
değerler ise her epoch'taki ilgili değerleri belirten list türünden nesnelerdir. History nesnesinin history sözlüğü her zaman
"loss" ve "val_loss" anahtarları ı ı ı ı ı ı ı ı ı
da barı ı ı ı
"val_binary_accuracy" isimli iki anahtara da sahip olacaktı ı
2024-05-20 13:45:43 +03:00
verisinden elde edilen değerleri "val" ile başlamayan anahtarlar ise eğitim veri kümesinden elde edilen değerleri belirtir.
2024-04-19 00:21:20 +03:00
"loss" değeri ve diğer metrik değerler epoch'un tamamı ı ı ı
2024-05-20 13:45:43 +03:00
(Yani bu değerler kümülatif bir ortalama değil, her epoch'taki ortalamalara ilişkindir.)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Epoch'lar sonrası ı ı
hakkı ı ı ı ı ı ı ı
Hatta tam tersine belli bir epoch'tan sonra "overfitting" denilen olgu kendini gösterebilmekte model gitgide yanlı
öğrenir duruma gelebilmektedir. İşte uygulamacı
grafikleri epoch sayı ı ı ı
birbirbirlerinden kopması ı ı
gereken epoch sayı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
Aşağı ı
çizdirilmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-05-20 13:45:43 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300, validation_split=0.2)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Aslı
from tensorflow.keras.callbacks import History
hist = History()
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300, validation_split=0.2, callbacks=[hist])
Tabii buna hiç gerek yoktur. Zaten bu History callback nesnesi fit metodu tarafı
dönüş değeri yoluyla bize verilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
CSVLogger isimli callback sı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
CSVLogger nesnesi yaratı ı ı ı ı
2024-04-02 13:01:04 +03:00
doldurulmuş olacaktı
from tensorflow.keras.callbacks import CSVLogger
2024-04-19 00:21:20 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2,
callbacks=[CSVLogger('diabtes-epoch.csv')])
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
iimport pandas as pd
2024-04-02 13:01:04 +03:00
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import CSVLogger
2024-05-20 13:45:43 +03:00
csv_logger = CSVLogger('diabetes-epoch-logs.csv')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300, validation_split=0.2, callbacks=[csv_logger])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
32. Ders - 27/04/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Daha önce de belirttiğimiz gibi tüm callback sı ı ı ı ı
türetilmiştir. Biz de bu sı ı ı ı ı ı ı ı
callbacks parametresine girilen callback nesnelerinin çeşitli metotları ı ı ı ı ı ı
da kendi callback sı ı ı ı ı ı ı ı ı
bittiğinde Callback sı ı ı ı ı ı ı ı ı ı
biz türemiş sı ı ı
girecektir. on_epoch_end metodunun parametrik yapı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_epoch_end(epoch, logs):
pass
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Buradaki birinci parametre epoch numarası ı ı ı ı
ve sı ı
değerleri belirten yazı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Örneğin her epoch sonrası ı ı ı
"val_loss" değerini ekrana yazdı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
class MyCallback(Callback):
def on_epoch_end(self, epoch, logs):
loss = logs['loss']
val_loss = logs['val_loss']
print(f'epoch: {epoch}, loss: {loss}, val_loss: {val_loss}')
mycallback = MyCallback()
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300,
validation_split=0.2, callbacks=[mycallback], verbose=0)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada fit metodunun verbose parametresine 0 değerini geçtik. fit metodu (evaluate ve predict metotları ı
durum söz konusu) çalı ı ı ı
artı ı ı ı ı ı ı ı ı
ekranda görünecektir.
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
fit, evaluate ve predict tarafı ı ı ı ı ı ı ı ı ı
on_epoch_begin
on_epoch_end
on_batch_begin
on_batch_end
on_train_begin
on_train_end
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Tabii bir sı ı ı ı ı
aşağı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Metot Parametreler
on_epoch_begin self, epoch ve logs
on_epoch_end self, epoch ve logs
on_batch_begin self, batch ve logs
on_batch_end self, batch ve logs
on_train_begin self, logs
on_train_end self, logs
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı ı ı ı ı ı ı ı
edilmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras.callbacks import Callback
class MyCallback(Callback):
def on_epoch_end(self, epoch, logs):
loss = logs['loss']
val_loss = logs['val_loss']
print(f'epoch: {epoch}, loss: {loss}, val_loss: {val_loss}')
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-05-20 13:45:43 +03:00
mycallback = MyCallback()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300, validation_split=0.2, callbacks=[mycallback], verbose=0)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
LambdaCallback isimli callback sı ı ı ı ı
noktalarda çağı ı ı ı
anlamları
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
on_train_begin: Eğitim başladı ı ı
on_train_end: Eğitim bittiğinde çağrı
on_epoch_begin: Her epoch başladı ı ı
on_epoch_end: Her epoch bittiğinde çağrı
on_batch_begin: Her batch işleminin başı ı
on_batch_end: Her batch işlemi bittiğinde çağrı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Bu fonksiyonları ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Fonksiyon Parametreler
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
on_epoch_begin epoch ve logs
on_epoch_end epoch ve logs
on_batch_begin batch ve logs
on_batch_end batch ve logs
on_train_begin logs
on_train_end logs
Burada epoch parametresi epoch numarası ı ı ı
belirtmektedir. Bu sözlüğün içerisinde loss değeri gibi metrik değerler gibi önemli bilgiler vardı
parametresi History nesnesindeki anahtarları
içermeyecektir. Örneğin biz her epoch bittiğinde, her batch başladı ı ı ı ı
isteyelim. Bunu şöyle gerçekleştirebiliriz:
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_epoch_end_proc(epoch, logs):
pass
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_batch_begin_proc(batch, logs):
pass
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_batch_end_proc(batch, logs):
2024-04-02 13:01:04 +03:00
pass
2024-05-20 13:45:43 +03:00
from tensorflow.keras.callbacks import LambdaCallback
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
lambda_callback = LambdaCallback(on_epoch_end=on_epoch_end_proc, on_batch_begin=on_batch_begin_proc, on_batch_end=on_batch_end_proc)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=300,
validation_split=0.2, callbacks=[lambda_callback], verbose=0)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı ı ı ı ı ı ı
epoch içerisindeki batch işlemlerinin sonucunda elde edilen "loss" değerleri de ekrana yazdı ı ı ı ı
örnekte batch'lerdeki loss değerleri bir listede saklanmı ı ı ı ı ı
fit metodu tarafı ı
Ancak HistoryCallback (ve fir metodunun ekrana yazdı ı ı
ortalama "loss" değeridir. Maalesef Keras'taki bu değerlerin nası ı ı ı ı ı ı
Dokümanlarda açı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
df = pd.read_csv('diabetes.csv')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
si = SimpleImputer(strategy='mean', missing_values=0)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
dataset = df.to_numpy()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
batch_losses= []
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_epoch_begin_proc(epoch, logs):
global batch_losses
batch_losses = []
print(f'eopch: {epoch}')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_epoch_end_proc(epoch, logs):
loss = logs['loss']
val_loss = logs['val_loss']
print(f'\nepoch: {epoch}, loss: {loss}, val_loss: {val_loss}')
print(f'batch mean: {np.mean(batch_losses)}')
print('-' * 30)
def on_batch_end_proc(batch, logs):
global total
loss = logs['loss']
batch_losses.append(loss)
print(f'\t\tbatch: {batch}, loss: {loss}')
from tensorflow.keras.callbacks import LambdaCallback
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
lambda_callback = LambdaCallback(on_epoch_begin=on_epoch_begin_proc, on_epoch_end=on_epoch_end_proc, on_batch_end=on_batch_end_proc)
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100,
validation_split=0.2, callbacks=[lambda_callback], verbose='auto')
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
LambdaCallback sı ı ı ı ı ı ı ı ı ı
bize verilen fonksiyonları ı ı ı ı
LambdaCallback sı ı ı ı ı ı ı ı ı ı ı
LambdaCallback sı ı ı ı ı ı ı ı ı ı ı ı ı ı
çalı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import Callback
class MyLambdaCallback(Callback):
2024-05-20 13:45:43 +03:00
def __init__(self, on_epoch_begin=None, on_epoch_end=None, on_batch_begin=None, on_batch_end=None):
2024-04-02 13:01:04 +03:00
self._on_epoch_begin = on_epoch_begin
self._on_epoch_end = on_epoch_end
self._on_batch_begin = on_batch_begin
self._on_batch_end = on_batch_end
2024-05-20 13:45:43 +03:00
2024-04-02 13:01:04 +03:00
def on_epoch_begin(self, epoch, logs):
if self._on_epoch_begin:
self._on_epoch_begin(epoch, logs)
2024-05-20 13:45:43 +03:00
2024-04-02 13:01:04 +03:00
def on_epoch_end(self, epoch, logs):
if self._on_epoch_end:
self._on_epoch_end(epoch, logs)
2024-05-20 13:45:43 +03:00
2024-04-02 13:01:04 +03:00
def on_batch_begin(self, batch, logs):
if self._on_batch_begin:
self._on_batch_begin(batch, logs)
2024-05-20 13:45:43 +03:00
2024-04-02 13:01:04 +03:00
def on_batch_end(self, batch, logs):
if self._on_batch_end:
2024-05-20 13:45:43 +03:00
self._on_batch_end(batch, logs)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
batch_losses= []
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def on_epoch_begin_proc(epoch, logs):
global batch_losses
batch_losses = []
print(f'eopch: {epoch}')
def on_epoch_end_proc(epoch, logs):
loss = logs['loss']
val_loss = logs['val_loss']
print(f'\nepoch: {epoch}, loss: {loss}, val_loss: {val_loss}')
print(f'batch mean: {np.mean(batch_losses)}')
print('-' * 30)
def on_batch_end_proc(batch, logs):
global total
loss = logs['loss']
batch_losses.append(loss)
print(f'\t\tbatch: {batch}, loss: {loss}')
mylambda_callback = MyLambdaCallback(on_epoch_begin=on_epoch_begin_proc, on_epoch_end=on_epoch_end_proc, on_batch_end=on_batch_end_proc)
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[mylambda_callback], verbose=0)
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Bir nörona giren değerlerin "w" değerleriyle çarpı ı ı ı ı
2024-04-19 00:21:20 +03:00
fonksiyonuna sokulduğunu biliyoruz. Örneğin modelde girdi katmanı
2024-05-20 13:45:43 +03:00
olsun. Bu girdiler ilk saklı
toplam da aktivasyon fonksiyonuna sokulacaktı ı ı
çok farklı ı
olarak değerlendirilmesine yol açacaktı ı ı ı ı ı
İşte bu nedenden dolayı ı ı ı ı ı
Bu işlemlere "özellik ölçeklemesi (feature scaling)" denilmektedir. Yapay sinir ağları ı ı ı ı
varsa mutlaka özellik ölçeklemesi yapı ı ı
Özellik ölçeklemesi makine öğrenmesinde başka konularda da gerekebilmektedir. Ancak bazı
kursumuzda her konuda özellik ölçeklemesinin gerekli olup olmadı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Çeşitli özellik ölçeklemesi yöntemleri vardı ı ı ı ı
ölçeklendirmeleri diğerlerine göre avantaj sağlayabilmektedir. En çok kullanı
" standart ölçekleme (standard scaling)" ve "minmax ölçeklemesi (minmax scaling)" dir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Özellik ölçeklemesi konusunda aşağı ı ı
2024-04-02 13:01:04 +03:00
Soru: Yapay sinir ağları
2024-05-20 13:45:43 +03:00
Cavap: Eğer sütunlar metrebe olarak birbirlerine zaten yakı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Soru: Gerektiği halde özellik ölçeklemesini yapmazsak ne olur?
2024-04-02 13:01:04 +03:00
Cevap: Modelin kestirim gücü azalı
Soru: Özellik ölçeklemesi gerekmediği halde özellik ölçeklemesi yaparsak bunun bir zararı ı
Cevap: Hayı
2024-05-20 13:45:43 +03:00
Soru: Kategorik sütunlara (0 ve 1'lerden oluşan ya da one-hot encoding yapı ı
2024-04-02 13:01:04 +03:00
Cevap: Bu sütunlara özellik ölçeklemesi uygulanmayabilir. Ancak uygulamanı ı ı
2024-05-20 13:45:43 +03:00
tüm sütunlara özellik ölçeklemesi uyguladı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Özellik ölçeklemesi yalnı ı ı ı ı
ve anlamı ı ı ı ı ı ı ı ı
eğitmeden önce özellik ölçeklemesi yapmı
verilerini de aynı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
33. Ders - 28/04/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
En çok kullanı
sütunlar diğerlerden bağı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
result = (x - mean(x)) / std(x)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Tabii burada biz formülü temsili kod (pseudo code) olarak verdik. Burdaki "mean" sütunun ortalaması ı
sapması ı ı ı ı
ölçeklemenin değerleri standart normal dağı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Standart ölçeklemeye "standardizasyon (standardization)" da denilmektedir. Standart ölçekleme aşı ı
olumsuz bir biçimde etkilenme eğilimindedir. Veri bilimcileri genellikle standart ölçeklemeyi default ölçekleme olarak
kullanmaktadı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Standart ölçekleme yapan bir fonksiyonu aşağı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
def standard_scaler(dataset):
scaled_dataset = np.zeros(dataset.shape)
for col in range(dataset.shape[1]):
scaled_dataset[:, col] = (dataset[:, col] - np.mean(dataset[:, col])) / np.std(dataset[:, col])
return scaled_dataset
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Tabii aslı ı ı ı ı
da yapabiliriz:
def standard_scaler(dataset):
return (dataset - np.mean(dataset, axis=0)) / np.std(dataset, axis=0)
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
import numpy as np
2024-05-20 13:45:43 +03:00
data= np.array([4, 7, 1, 90, 45, 70, 23, 12, 6, 9, 45, 82, 65])
mean = np.mean(data)
std = np.std(data)
print(f'Mean: {mean}, Standard Deviation: {std}')
result = (data - mean) / std
print(f'Data: {data}')
print(f'Scaled Data: {result}')
print('--------------------------------')
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
2024-04-02 13:01:04 +03:00
def standard_scaler(dataset):
2024-05-20 13:45:43 +03:00
scaled_dataset = np.zeros(dataset.shape)
2024-04-02 13:01:04 +03:00
for col in range(dataset.shape[1]):
2024-05-20 13:45:43 +03:00
scaled_dataset[:, col] = (dataset[:, col] - np.mean(dataset[:, col])) / np.std(dataset[:, col])
return scaled_dataset
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
result = standard_scaler(dataset)
print(dataset)
2024-04-02 13:01:04 +03:00
print(result)
2024-05-20 13:45:43 +03:00
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Ası
isimli bir sı ı ı ı ı ı ı ı ı ı ı ı ı
türünden bir nesne yaratı ı ı ı ı ı
aynı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import StandardScaler
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ss = StandardScaler()
ss.fit(dataset)
scaled_dataset = ss.tranform(dataset)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
fit işlemi sütunları ı ı ı ı ı
kullanı ı
fit işleminden sonra sı ı ı ı
sapmaları ı ı
Aşağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
print(dataset)
2024-04-02 13:01:04 +03:00
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
2024-05-20 13:45:43 +03:00
ss.fit(dataset)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
print(f'{ss.mean_}, {ss.scale_}')
scaled_dataset = ss.transform(dataset)
print(scaled_dataset)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Sinir ağları ı ı
gerçekleştirilir. Sonra eğitim veri kümesindeki sütunlardaki bilgiler kullanı
ölçeklendirilir. (Yani test veri kümesi ve kestirim veri kümesi kendi arası
alı ı ı ı ı
ifade edebiliriz:
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
scaled_predict_dataset_x = ss.transform(predict_dataset_x)
Örneğin "diabetes.csv" veri kümesi üzerinde standart ölçekleme yapmak isteyelim. Bunun için önce veri kümesini dataset_x
ve dataset_y biçiminde sonra da "eğitim" ve "test" olmak üzere ikiye ayı ı ı
özellik ölçeklemesi yapı ı ı
bilgisinin test işlemi işlemi öncesinde test veri kümesine de, kestirim işlemi öncesinde kestirim veri kümesine de
uygulanması
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
2024-05-20 13:45:43 +03:00
ss.fit(training_dataset_x)
2024-04-02 13:01:04 +03:00
scaled_training_dataset_x = ss.transform(training_dataset_x)
2024-05-20 13:45:43 +03:00
scaled_test_dataset_x = ss.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-02 13:01:04 +03:00
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
2024-04-02 13:01:04 +03:00
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
scaled_predict_dataset = ss.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Diğer çok kullanı
değerleri [0, 1] arası ı ı ı ı ı
2024-04-02 13:01:04 +03:00
(a - min(a)) / (max(a) - min(a))
2024-05-20 13:45:43 +03:00
Örneğin sütun değerleri aşağı
2
5
9
4
12
Burada min-max ölçeklemesi şöyle yapı ı
2 => (2 - 2) / 10
5 => (5 - 2) / 10
9 => (9 - 2) / 10
4 => (4 - 2) / 10
12 => (12 - 2) / 10
Min-max ölçeklemesinde en küçük değerin ölçeklenmiş değerinin 0 olduğuna, en büyük değerin ölçeklenmiş değerinin 1 olduğuna,
diğer değerlerin ise 0 ile 1 arası
Min-max ölçeklemesi yapan bir fonksiyon şöyle yazı
import numpy as np
def minmax_scaler(dataset):
scaled_dataset = np.zeros(dataset.shape)
for col in range(dataset.shape[1]):
min_val, max_val = np.min(dataset[:, col]), np.max(dataset[:, col])
scaled_dataset[:, col] = 0 if max_val - min_val == 0 else (dataset[:, col] - min_val) / (max_val - min_val)
return scaled_dataset
Bir sütundaki tüm değerlerin aynı ı ı ı
mi? Tabii ki olmaz. Min-max ölçeklemesi yaparken sütundaki tüm değerler aynı ı ı
Yukarı ı ı ı ı ı
atı ı ı ı ı
def minmax_scaler(dataset):
return (dataset - np.min(dataset, axis=0)) / (np.max(dataset, axis=0) - np.min(dataset, axis=0))
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def minmax_scaler(dataset):
2024-05-20 13:45:43 +03:00
scaled_dataset = np.zeros(dataset.shape)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for col in range(dataset.shape[1]):
min_val, max_val = np.min(dataset[:, col]), np.max(dataset[:, col])
scaled_dataset[:, col] = 0 if max_val - min_val == 0 else (dataset[:, col] - min_val) / (max_val - min_val)
return scaled_dataset
"""
def minmax_scaler(dataset):
return (dataset - np.min(dataset, axis=0)) / (np.max(dataset, axis=0) - np.min(dataset, axis=0))
"""
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
result = minmax_scaler(dataset)
print(dataset)
print(result)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
sckit-learn kütüphanesinde sklearn.preprocessing modülünde min-max ölçeklemesi yapan MinMaxScaler isimli bir sı ı
bulunmaktadı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(dataset)
scaled_dataset = mms.transform(dataset)
Yine sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
2024-04-02 13:01:04 +03:00
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
2024-05-20 13:45:43 +03:00
mms.fit(dataset)
scaled_dataset = mms.transform(dataset)
print(dataset)
print(scaled_dataset)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Şimdi de "dibates" örneğini min-max ölçeklemesi ile yeniden gerçekleştirelim. Aşağı ı ı ı ı ı ı
ölçeklemesinin standart ölçeklemeden bu veri kümesi için daha iyi sonuçlar verdiğini görmekteyiz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
2024-05-20 13:45:43 +03:00
mms.fit(training_dataset_x)
2024-04-02 13:01:04 +03:00
scaled_training_dataset_x = mms.transform(training_dataset_x)
2024-05-20 13:45:43 +03:00
scaled_test_dataset_x = mms.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
2024-04-02 13:01:04 +03:00
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
scaled_predict_dataset = mms.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
print(predict_result)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for result in predict_result[:, 0]:
print('Şeker hastası ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
34. Ders - 04/05/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Diğer bir özellik ölçeklemesi de "maxabs" ölçeklemesi denilen ölçeklemedir. Maxabs ölçeklemesinde sütundaki değerler sütundaki
değerlerin mutlak değerlerinin en büyüğüne bölünmektedir. Böylece sütun değerleri [-1, 1] arası
ölçeklemesi şöyle yapı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
x / max(abs(x))
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada sütundaki tüm değerler en büyük mutlak değere bölündüğüne göre ölçeklenmiş değerler -1 ile +1 arası ı
scikit-learn kütüphanesinde "maxabs" ölçeklemesi MaxAbsScaler isimli sı ı ı ı
sı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
import numpy as np
2024-05-20 13:45:43 +03:00
def maxabs_scaler(dataset):
scaled_dataset = np.zeros(dataset.shape)
for col in range(dataset.shape[1]):
maxabs_val = np.max(np.abs(dataset[:, col]))
scaled_dataset[:, col] = 0 if maxabs_val == 0 else dataset[:, col] / maxabs_val
return scaled_dataset
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
"""
def maxabs_scaler(dataset):
return dataset / np.max(np.abs(dataset), axis=0)
"""
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
result = maxabs_scaler(dataset)
print(dataset)
2024-04-02 13:01:04 +03:00
print(result)
2024-05-20 13:45:43 +03:00
print('------------------------------------------------')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
dataset = np.array([[1, 2, 3], [2, 1, 4], [7, 3, 8], [8, 9, 2], [20, 12, 3]])
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import MaxAbsScaler
mas = MaxAbsScaler()
mas.fit(dataset)
scaled_dataset = mas.transform(dataset)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
print(dataset)
print(scaled_dataset))
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
maxabs ölçeklemesi diğerlerine göre uygun bir ölçekleme değildir. Ancak biz burada ölçeklemenin kullanı ı
örnek vermek istiyoruz.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('diabetes.csv')
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import MaxAbsScaler
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
mas = MaxAbsScaler()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
mas.fit(training_dataset_x)
scaled_training_dataset_x = mas.transform(training_dataset_x)
scaled_test_dataset_x = mas.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Diabetes')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-05-20 13:45:43 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
scaled_predict_dataset = mas.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
print(predict_result)
for result in predict_result[:, 0]:
print('Şeker hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı
Aslı ı ı ı ı
Pekiyi elimizdeki veri kümesi için hangi ölçeklemenin daha iyi olduğuna nası ı ı
çok prtaik yolları ı ı ı
türünü seçerken aşağı
- Sütunlarda aşı ı
uzaklaşması ı
- Sütunlardaki değerler normal dağı ı ı
diğerlerine göre daha iyi performans gösterebilmektedir.
- Sütunlardaki değerler düzgün dağı ı ı ı
Ancak yine uygulamacı ı ı
istemiyorlarsa standart ölçeklemeyi default ölçekleme olarak tercih etmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi özellik ölçeklemesi yaptı ı ı ı ı ı
ölçeklemesini scikit-learn kullanarak yaptı ı ı ı ı
bir parçası ı ı ı ı ı
Keras'ta özellik ölçeklendirmeleri bir katman nesnesi olarak da bulundurulmuştur. Eğer özellik ölçeklemeleri bir katman ile
yapı ı ı
bilgisinin nası ı ı
Programalamada bir sı ı ı ı
getirilmesi (object serialization)" denilmektedir. scikit-learn içerisinde "object serialiazation" işlemine yönelik özel
sı ı ı
Örneğin scikit-learn ile standard ölçekleme yapmı ı
bir dosyada saklamak isteyelim. Bu işlemi şöyle yapabiliriz:
import pickle
with open('diabetes-scaling.dat', 'wb') as f:
pickle.dump(ss, f)
Nesneyi dosyadan geri yükleme işlemi de şöyle yapı ı
with open('diabetes-scaling.dat', 'rb') as f:
ss = pickle.load(f)
Aşağı ı ı
saklanmı ı
#----------------------------------------------------------------------------------------------------------------------------
# diabetes-scaling-save.py
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
model.save('diabetes.h5')
import pickle
with open('diabetes-scaling.dat', 'wb') as f:
pickle.dump(ss, f)
# diabetes-scaling-load.py
import numpy as np
from tensorflow.keras.models import load_model
import pickle
model = load_model('diabetes.h5')
with open('diabetes-scaling.dat', 'rb') as f:
ss = pickle.load(f)
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
scaled_predict_dataset = ss.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
print(predict_result)
for result in predict_result[:, 0]:
print('Şeker hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
sakladı ı ı ı ı ı
bulunmuyordu. Ancak daha sonraları ı ı ı
bu biçimdeki hazı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Keras'a sonradan eklenen Normalization isimli katman özellik ölçeklemesi yapabilmektedir. Normalization katmanı
olarak "standart ölçekleme" için düşünülmüştür. Ancak "minmax ölçeklemesi" için de kullanı ı
için önce Normalization türünden bir nesnenin yaratı ı ı ı ı ı
yapı ı
tf.keras.layers.Normalization(axis=-1, mean=None, variance=None, invert=False, **kwargs)
Burada mean sütunları ı ı ı ı
bu değerleri girmesine gerek yoktur. Normalization sı ı ı ı ı
o kümeden elde edebilmektedir. Bu durumda standart ölçekleme için Normalization katmanı ı
from tensorflow.keras.layers import Normalization
norm_layer = Normalization()
norm_layer.adapt(traininf_dataset_x)
Tabii nu katmanı ı
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(norm_layer)
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Örneğin:
import numpy as np
dataset = np.array([[1, 2, 3], [4, 5, 6], [3, 2, 7], [5, 9, 5]])
print(dataset)
from tensorflow.keras.layers import Normalization
norm_layer = Normalization()
norm_layer.adapt(dataset)
print(norm_layer.mean)
print(norm_layer.variance)
Tabii biz ölçeklemeyi bir katman biçiminde modele eklediğimizde artı ı
yapmamı ı ı ı
Yukarı ı ı ı ı ı ı ı
saklanması ı ı ı ı ı
Aşağı ı ı ı ı
konunun anlaşı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Normalization, Dense
norm_layer = Normalization()
norm_layer.adapt(training_dataset_x)
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(norm_layer)
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import numpy as np
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
model.save('diabetes.h5')
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
predict_result = model.predict(predict_dataset)
print(predict_result)
for result in predict_result[:, 0]:
print('Şeker hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Keras'ta minmax ölçeklemesi için hazı ı ı ı
oluşturulabilir. Aşağı
https://fdnieuwveldt.medium.com/implementing-sklearn-like-transformers-in-keras-a-custom-preprocessing-layer-example-60688ba821e0
Tabii biz henüz Tensorflow kütüphanesini incelemediğimiz için şu anda böyle bir örnek vermeyeceğiz.
Aslı ı ı ı ı ı ı
yapı ı ı ı ı ı ı
(X - mu) / sigma
Burada mu ve sigma ilgili sütunun ortalaması ı ı ı ı ı ı ı
anı ı ı
(X - min ) / (max - min)
O halde biz aslı
sigma değerinin ise max - min olması
mins = np.min(training_dataset_x, axis=0)
maxmin_diffs = np.max(training_dataset_x, axis=0) - np.min(training_dataset_x, axis=0)
norm_layer = Normalization(mean=mins, variance=maxmin_diffs ** 2)
Aşağı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
impute_features = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
df[impute_features] = si.fit_transform(df[impute_features])
dataset = df.to_numpy()
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Normalization, Dense
import numpy as np
mins = np.min(training_dataset_x, axis=0)
maxmin_diffs = np.max(training_dataset_x, axis=0) - np.min(training_dataset_x, axis=0)
norm_layer = Normalization(mean=mins, variance=maxmin_diffs ** 2)
model = Sequential(name='Diabetes')
model.add(Input((training_dataset_x.shape[1],)))
model.add(norm_layer)
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
import numpy as np
predict_dataset = np.array([[2 ,90, 68, 12, 120, 38.2, 0.503, 28],
[4, 111, 79, 47, 207, 37.1, 1.39, 56],
[3, 190, 65, 25, 130, 34, 0.271, 26],
[8, 176, 90, 34, 300, 50.7, 0.467, 58],
[7, 106, 92, 18, 200, 35, 0.300, 48]])
model.save('diabetes.h5')
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
predict_result = model.predict(predict_dataset)
print(predict_result)
for result in predict_result[:, 0]:
print('Şeker hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Biz şimdiye kadar Keras ve sinir ağı ı ı ı
Şimdi başka veri kümelerini kullanarak başka örnekler üzerinde çalı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı ı ı
için "lojistik olmayan regresyon modelleri" terminini de kullanı ı ı
çı ı ı ı ı
Başka bir deyişle f(x) değerinin x ile aynı ı ı ı
parametresi girilmezse default durumda aktivasyon fonksiyonu "linear" alı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
35. Ders - 05/05/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Auto-MPG otomobillerin bir galon benzinle kaç mil gidebildiklerininin (başka bri deyişle yakı
amacı ı ı
yı ı ı ı ı ı ı ı ı
https://archive.ics.uci.edu/dataset/9/auto+mpg
Veri kümesi bir zip dosyası ı ı ı
"auto-mpg.names" dosyası ı ı ı ı ı
Veri kümsindeki sütunlar SPACE karakterleriyle ve son sütun da TAB karakteriyle biribirlerinden ayrı ı ı ı
anlamları
1. mpg: continuous
2. cylinders: multi-valued discrete
3. displacement: continuous
4. horsepower: continuous
5. weight: continuous
6. acceleration: continuous
7. model year: multi-valued discrete
8. origin: multi-valued discrete
9. car name: string (unique for each instance)
Burada orijin kategorik bir sütundur. Buradaki değer 1 ise araba Amerika orijinli, 2 ise Avrupa orijinli ve 3 ise Japon
orijinlidir.
Veri kümesinin text dosyadaki görünümü aşağı
18.0 8 307.0 130.0 3504. 12.0 70 1 "chevrolet chevelle malibu"
15.0 8 350.0 165.0 3693. 11.5 70 1 "buick skylark 320"
18.0 8 318.0 150.0 3436. 11.0 70 1 "plymouth satellite"
16.0 8 304.0 150.0 3433. 12.0 70 1 "amc rebel sst"
17.0 8 302.0 140.0 3449. 10.5 70 1 "ford torino"
25.0 4 98.00 ? 2046. 19.0 71 1 "ford pinto"
19.0 6 232.0 100.0 2634. 13.0 71 1 "amc gremlin"
16.0 6 225.0 105.0 3439. 15.5 71 1 "plymouth satellite custom"
17.0 6 250.0 100.0 3329. 15.5 71 1 "chevrolet chevelle malib
....
Veri kümesi incelendiğinde dördüncü sütunda (horsepower) '?' karakteri ile belirtilen eksik verilerin bulunduğu görülmektedir.
Veri kümesindeki veriler az olmadı ı ı ı
de yaptı ı ı ı ı ı ı ı
olsa da arabaları ı ı ı
Bu sütun da veri kümesinden atı
Veri kümesinin bir başlı ı ı ı ı ı ı
olmadı ı ı ı ı ı ı ı
sağlam bir yöntem değildir. Bu nedenle bu veri kümesi okunurken read_csv fonksiyonunda header parametresi None geçilmelidir.
read_csv default olarak sütunlardaki ayı ı ı
ayı ı ı ı
delimeter parametresine r'\s+' biçiminde "düzenli ifade (regular expression)" kalı ı
Uygulamaları ı ı ı ı ı
biçiminde nümerik almaktadı
Bu durumda yukarı ı ı
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
Şimdi bizim araba markaları ı ı
df = df.iloc[:, :-1]
Tabii bu işlemi DataFrame sı ı ı ı
df.drop(8, axis=1, inplace=True)
Aslı ı ı ı ı ı
Şimdi de 3'üncü indeksli sütundaki eksik verileri temsil eden '?' bulunan satı ı ı ı
belirttiğimiz gibi bu sütundaki eksik verilerin sayı ı ı
şöyle yapı
df = df[df.iloc[:, 3] != '?']
Ancak biz geçmiş konuları ı ı ı
Burada dikkat edilmesi gereken nokta DataFrame nesnesinin 3'üncü indeksli sütununun türünün nümerik olmaması ı
öncelikle bu sütunun türünü nümerik hale getirmek gerekir. Tabii sütunda '?' karakterleri olduğuna göre önce bu karakterler
yerine 0 gibi nümerik değerleri yerleştirmeliyiz:
df.iloc[df.loc[:, 3] == '?', 3] = 0
Tabii eğer ilgili sütunda zaten 0 değerleri varsa bu durumda 0 ile doldurmak yerine np.nan değeri ile dolduma yolunu tercih
edebilirsiniz. Örneğin:
df.iloc[df.loc[:, 3] == '?', 3] = np.nan
Artı
df[3] = df[3].astype('float64')
Aslı ı ı ı ı ı
fonksiyonun np.nan değerlerini yerleştirmesini de sağlayabiliriz.
Burada doğrudan indekslemede sütun isimlerinin kullanı ı ı ı ı ı
sayı ı
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=0)
df[3] = si.fit_transform(df[[3]])
Henüz NumPy'a dönmeden önce 7'inci sütundaki kategorik verileri Pandas'ı
biçimine dönüştürebiliriz:
df = pd.get_dummies(df, columns=[7], dtype='uint8')
Artı
dataset = df.to_numpy()
Şimdi de veri kümesini x ve y olarak ayrı ı ı
ediniz:
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
Bundan sonra veri kümesi eğitim ve test aması ı ı
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
Artı ı
Normailzation isimli Keras katmanı ı ı ı ı ı ı
minmax ölçeklemesinin daha iyi performans verebileceği izlenimi edinilmektedir. Ancak bu konuda deneme yanı
uygulamak gerekir. Biz default standart ölçekleme uygulayalı
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
Artı ı ı ı ı ı
yine "relu" olarak alacağı ı ı ı ı ı ı ı
model = Sequential(name='Auto-MPG')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(32, activation='relu', name='Hidden-1'))
model.add(Dense(32, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
Şimdi de modelimizi compile edip fit işlemi uygulayalı ı
Regresyon problemleri için loss fonksiyonunun genellikle "mean_squared_error" biçiminde alı
regresyon problemleri için "mean_absolute_error" metrik değeri kullanı
odel.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
Modelimizi test veri kümesiyle test edebiliriz:
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
Şimdi kestirim yapmaya çalı ı
yapı ı ı ı ı ı ı
8,307.0,130.0,3504,12.0,70,1
4,350.0,165.0,3693,11.5,77,2
8,318.0,150.0,3436,11.0,74,3
Bu dosyayı ı ı ı
gerekir:
predict_df = pd.read_csv('predict.csv', header=None)
predict_df = pd.get_dummies(predict_df, columns=[6])
predict_dataset_x = predict_df.to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x)
predict_result = model.predict(scaled_predict_dataset_x)
for val in predict_result[:, 0]:
print(val)
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
df.iloc[df.loc[:, 3] == '?', 3] = np.nan
df[3] = df[3].astype('float64')
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=np.nan)
df[3] = si.fit_transform(df[[3]])
df = pd.get_dummies(df, columns=[7], dtype='uint8')
dataset = df.to_numpy()
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='Auto-MPG')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(32, activation='relu', name='Hidden-1'))
model.add(Dense(32, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Mean Absolute Error', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Measn Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_df = pd.read_csv('predict.csv', header=None)
predict_df = pd.get_dummies(predict_df, columns=[6])
predict_dataset_x = predict_df.to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_result = model.predict(scaled_predict_dataset_x)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for val in predict_result[:, 0]:
print(val)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
36. Ders - 11/05/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
one-hot encoding işleminde Pandas'ı ı
yapı ı
değerlerden hareketle kategorileri belirler.) Eğer predict yapacağı ı ı ı
bu durum bir sorun yaratı ı ı ı
bizlere yardı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
OneHotEncoder sı ı ı
Biz "one-hot encoding" yapı
parametresi iki boyutlu bir liste olarak girilmelidir. Çünkü birden fazla sütun "one-hot encoding" işlemine sokulabilmektedir.
Bu durumda bu iki boyutlu listenin her elemanı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ohe = OneHotEncoder(sparse=False, categories=[[0, 1, 2], ['elma', 'armut', 'kayı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada biz iki sütunlu bir veri kümesinin iki sütununu da one-hot encoding yapmak istemekteyiz. Bu veri tablosunun ilk
sütunundaki kategoriler 0, 1, 2 biçiminde, ikinci sütunundaki kategoriler 'elma', 'armut', 'kayı ı
bu sütunlarda daha az kategori varsa burada belirtilen sayı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Tabii OneHotEncoder sı ı ı ı ı ı ı ı ı
gibi OneHotEncoder sı ı ı ı
eğer saklanmı ı ı
saklanmamı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict işlemi yapı ı ı ı
uyuşması ı
unique elemanları ı ı ı ı ı
fonksiyonu ve scikit-learn'deki OneHotEncoder sı ı ı ı
işlemlerini farklı ı ı ı ı ı ı ı
one-hot encoding sütunları ı ı ı
sı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Burada NumPy ve Pandas ile ilgili bir ayrı ı
elemanları ı ı ı ı
işlemini ayrca yapmamaktadı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Aşağı ı ı ı ı ı ı
OneHotEncoder nesnesi oluşturulmamı ı ı ı ı ı ı
kullanı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-05-20 13:45:43 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
2024-05-20 13:45:43 +03:00
df.iloc[df.loc[:, 3] == '?', 3] = np.nan
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
df[3] = df[3].astype('float64')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='mean', missing_values=np.nan)
df[3] = si.fit_transform(df[[3]])
df_1 = df.iloc[:, :7]
df_2 = df.iloc[:, [7]]
dataset_1 = df_1.to_numpy()
dataset_2 = df_2.to_numpy()
import numpy as np
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False)
dataset_2 = ohe.fit_transform(dataset_2)
dataset = np.concatenate([dataset_1, dataset_2], axis=1)
2024-04-02 13:01:04 +03:00
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import StandardScaler
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-05-20 13:45:43 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Auto-MPG')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(32, activation='relu', name='Hidden-1'))
model.add(Dense(32, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
2024-05-20 13:45:43 +03:00
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Mean Absolute Error', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
2024-05-20 13:45:43 +03:00
plt.legend(['Measn Absolute Error', 'Validation Mean Absolute Error'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-05-20 13:45:43 +03:00
model.save('auto-mpg.h5')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
import pickle
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
with open('auto-mpg.pickle', 'wb') as f:
pickle.dump((ohe, ss), f)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_df = pd.read_csv('predict.csv', header=None)
predict_df_1 = predict_df.iloc[:, :6]
predict_df_2 = predict_df.iloc[:, [6]]
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset_1 = predict_df_1.to_numpy()
predict_dataset_2 = predict_df_2.to_numpy()
predict_dataset_2 = ohe.transform(predict_dataset_2)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset = np.concatenate([predict_dataset_1, predict_dataset_2], axis=1)
scaled_predict_dataset = ss.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
for val in predict_result[:, 0]:
print(val)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Aşağı ı ı
yüklenerek kullanı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
import pickle
import numpy as np
import pandas as pd
2024-04-02 13:01:04 +03:00
from tensorflow.keras.models import load_model
2024-05-20 13:45:43 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
model = load_model('auto-mpg.h5')
2024-04-02 13:01:04 +03:00
with open('auto-mpg.pickle', 'rb') as f:
2024-05-20 13:45:43 +03:00
ohe, ss = pickle.load(f)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_df = pd.read_csv('predict.csv', header=None)
predict_df_1 = predict_df.iloc[:, :6]
predict_df_2 = predict_df.iloc[:, [6]]
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset_1 = predict_df_1.to_numpy()
predict_dataset_2 = predict_df_2.to_numpy()
predict_dataset_2 = ohe.transform(predict_dataset_2)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
predict_dataset = np.concatenate([predict_dataset_1, predict_dataset_2], axis=1)
scaled_predict_dataset = ss.transform(predict_dataset)
predict_result = model.predict(scaled_predict_dataset)
2024-04-02 13:01:04 +03:00
for val in predict_result[:, 0]:
print(val)
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Bir veri kümesinde "one-hot encoding" yapı ı
önce "one-hot encoding" yapı ı ı ı ı ı ı ı
birden fazla sütun için uygulayabilirsiniz. Anı ı ı ı ı
hamlede birden fazla sütunu "one-hot encoding" yapabiliyordu. İzleyen paragraflarda bu tür örnekler üzerinde duracağı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi "one-hot encoding" işlemi Keras'taki bir katmana yaptı ı ı
yaptı ı ı ı
programcı ı ı ı ı ı
gerekir. Keras içerisinde CategoryEncoding isimli bir katman bulunuyor olsa da bu katman tüm girdideki sütunları
encoding" yapmaktadı ı ı ı ı ı
ileride "Keras Modelinin Fonksiyonel Biçimde Oluşturulması ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Regresyon problemlerinde çok kullanı
Bu veri kümesi daha önce görümüş olduğumuz "Melbourne Housing Snapshot (MHS)" veri kümesine benzemektedir. Bu veri kümesinde
evlerin çeşitli bilgileri sütunlar halinde kodlanmı ı ı ı ı ı
toplanmı ı ı
ülkelerinde hiç enflasyon olmadı ı ı ı ı ı ı ı
atı ı ı ı ı
değer hale gelmektedir.) BHP veri kümesi aşağı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
https://www.kaggle.com/datasets/vikrishnan/boston-house-prices
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Buradan veri kümesini bir zip dosyası ı ı ı ı
edilmektedir. Veri kümesi aşağı
0.00632 18.00 2.310 0 0.5380 6.5750 65.20 4.0900 1 296.0 15.30 396.90 4.98 24.00
0.02731 0.00 7.070 0 0.4690 6.4210 78.90 4.9671 2 242.0 17.80 396.90 9.14 21.60
0.02729 0.00 7.070 0 0.4690 7.1850 61.10 4.9671 2 242.0 17.80 392.83 4.03 34.70
0.03237 0.00 2.180 0 0.4580 6.9980 45.80 6.0622 3 222.0 18.70 394.63 2.94 33.40
0.06905 0.00 2.180 0 0.4580 7.1470 54.20 6.0622 3 222.0 18.70 396.90 5.33 36.20
0.02985 0.00 2.180 0 0.4580 6.4300 58.70 6.0622 3 222.0 18.70 394.12 5.21 28.70
0.08829 12.50 7.870 0 0.5240 6.0120 66.60 5.5605 5 311.0 15.20 395.60 12.43 22.90
0.14455 12.50 7.870 0 0.5240 6.1720 96.10 5.9505 5 311.0 15.20 396.90 19.15 27.10
............
Burada da görüldüğü gibi her ne kadar dosyası ı ı ı ı
ayrı ı ı ı ı ı ı ı
fonksiyonuyla okunabilir. Örneğin:
dataset = np.loadtxt('housing.csv')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Ancak biz kursumuzda ilk aşamaları ı ı ı ı ı ı
fonksiyonuyla yapacağı ı
expression)" biçiminde olmalı ı ı ı ı ı ı ı ı
şöyle yapabiliriz:
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
df = pd.read_csv('housing.csv', header=None, delimiter=r'\s+')
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Veri kümesindeki sütunlar için İngilizce olarak aşağı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
1. CRIM: per capita crime rate by town
2. ZN: proportion of residential land zoned for lots over 25,000 sq.ft.
3. INDUS: proportion of non-retail business acres per town
4. CHAS: Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
5. NOX: nitric oxides concentration (parts per 10 million)
6. RM: average number of rooms per dwelling
7. AGE: proportion of owner-occupied units built prior to 1940
8. DIS: weighted distances to five Boston employment centers
9. RAD: index of accessibility to radial highways
10. TAX: full-value property-tax rate per $10,000
11. PTRATIO: pupil-teacher ratio by town
12. B: 1000(Bk−
13. LSTAT: % lower status of the population
14. MEDV: Median value of owner-occupied homes in $1000s
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Buradaki son sütun evin fiyatı ı
4'üncü sütununda kategorik bir bilgi bulunmaktadı ı ı
sütunlar için "one-hot encoding" işlemine gerek olmadı ı ı ı ı ı ı ı
kategorik bir bilgi bulunmaktadı ı ı ı ı
arası ı ı ı ı ı
gerekmektedir. Veri kümesinin sütunları ı ı ı
ölçekleme ya da min-max ölçeklemesi kullanı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
37. Ders - 12/05/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
BHP veri kümesi için oluşturulmuş olan CSV dosyası ı ı ı ı ı ı
ile CSV dosyası ı ı ı ı ı
vermektedir.
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
8'inci sütun kategorik olduğu için o sütunu "one-hot encoding" işlemine sokalı
highway_class = df.iloc[:, 8].to_numpy()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ohe = OneHotEncoder(sparse_output=False)
ohe_highway = ohe.fit_transform(highway_class.reshape(-1, 1))
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Şimdi "one-hot encoding" işleminden elde ettiğimiz matrisi DataFrame nesnesinin sonuna yerleştirebiliriz. Tabii bundan
önce bu sütunu silip "y" verilerini de ayı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
dataset_y = df.iloc[:, -1].to_numpy()
df.drop([8, 13], axis=1, inplace=True)
dataset_x = pd.concat([df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Şimdi elimizde NumPy dizisine dönüştürülmüş olan dataset_x ve dataset_y verileri var. Artı
olmak üzere ikiye ayı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Bu işlemden sonra diğer adı ı
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_dataset_x = ss.transform(training_dataset_x)
Burada standart ölçekleme uyguladı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
Veri kümesi için iki saklı ı
model = Sequential(name='Boston-Housing-Prices')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
Modelin çı ı ı
değerin de "mean_absolute_error" olarak dikkat ediniz.
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
2024-05-20 13:45:43 +03:00
highway_class = df.iloc[:, 8].to_numpy()
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False)
ohe_highway = ohe.fit_transform(highway_class.reshape(-1, 1))
dataset_y = df.iloc[:, -1].to_numpy()
df.drop([8, 13], axis=1, inplace=True)
dataset_x = pd.concat([df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from sklearn.preprocessing import StandardScaler
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
2024-06-09 22:37:05 +03:00
scaled_test_dataset_x = ss.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
model = Sequential(name='Boston-Housing-Prices')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
2024-05-20 13:45:43 +03:00
model.compile('rmsprop', loss='mse', metrics=['mae'])
2024-04-02 13:01:04 +03:00
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
2024-05-20 13:45:43 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-05-20 13:45:43 +03:00
"""
import pickle
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
model.save('boston-housing-prices.h5')
with open('boston-housing-prices.pickle', 'wb') as f:
pickle.dump([ohe, ss], f)
"""
predict_df = pd.read_csv('predict-boston-housing-prices.csv', delimiter=r'\s+', header=None)
highway_class = predict_df.iloc[:, 8].to_numpy()
ohe_highway = ohe.transform(highway_class.reshape(-1, 1))
predict_df.drop(8, axis=1, inplace=True)
predict_dataset_x = pd.concat([predict_df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x )
predict_result = model.predict(scaled_predict_dataset_x)
2024-04-02 13:01:04 +03:00
for val in predict_result[:, 0]:
print(val)
2024-06-09 22:37:05 +03:00
# predict-boston-hosing-prices.csv
0.13554 12.50 6.070 0 0.4090 5.5940 36.80 6.4980 4 345.0 18.90 396.90 13.09
0.12816 12.50 6.070 0 0.4090 5.8850 33.00 6.4980 4 345.0 18.90 396.90 8.79
0.08826 0.00 10.810 0 0.4130 6.4170 6.60 5.2873 4 305.0 19.20 383.73 6.72
0.15876 0.00 10.810 0 0.4130 5.9610 17.50 5.2873 4 305.0 19.20 376.94 9.88
0.09164 0.00 10.810 0 0.4130 6.0650 7.80 5.2873 4 305.0 19.20 390.91 5.52
0.19539 0.00 10.810 0 0.4130 6.2450 6.20 5.2873 4 305.0 19.20 377.17 7.54
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
38. Ders 18/05/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesi ve veri bilimine ilişkin pek çok kğtğphane ve framework'te hazı ı
Örneğin Keras içerisinde tensorflow.keras.datasets modülünde aşağı ı ı
boston_housing
california_housing
cifar10
cifar100
fashion_mnist
imdb
mnist
reuters
Keras dokümanları ı
kullanı ı ı ı ı
Bu fonksiyonlar ikişer elemandan oluşan ikili bir demet vermektedir. Dolayı ı ı
açı
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = boston_housing.load_data()
Görüldüğü gibi load_data fonksiyonu zaten eğitim ve test veri kğmelerini ayrı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi Keras içerisindeki hazı ı ı
edilebilir:
from tensorflow.keras.datasets import boston_housing
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = boston_housing.load_data()
8'inci sütunu OneHotEncoding yapabiliriz:
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe_result_training = ohe.fit_transform(training_dataset_x[:, 8].reshape(-1, 1))
ohe_result_test = ohe.transform(test_dataset_x[:, 8].reshape(-1, 1))
Artı ı
one-hot encoding yapı ı ı ı
Ancak burada bir değişiklik olsun diye one-hot encoding yapı
edelim:
training_dataset_x = np.delete(training_dataset_x, 8, axis=1)
test_dataset_x = np.delete(test_dataset_x, 8, axis=1)
training_dataset_x = np.insert(training_dataset_x, [8], ohe_result_training, axis=1)
test_dataset_x = np.insert(test_dataset_x, [8], ohe_result_test, axis=1)
Yukarı ı ı
Geri kalan işlemler önceki örnekte olduğu gibi yürütülebilir. Aşağı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import boston_housing
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = boston_housing.load_data()
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe_result_training = ohe.fit_transform(training_dataset_x[:, 8].reshape(-1, 1))
ohe_result_test = ohe.transform(test_dataset_x[:, 8].reshape(-1, 1))
import numpy as np
training_dataset_x = np.delete(training_dataset_x, 8, axis=1)
test_dataset_x = np.delete(test_dataset_x, 8, axis=1)
training_dataset_x = np.insert(training_dataset_x, [8], ohe_result_training, axis=1)
test_dataset_x = np.insert(test_dataset_x, [8], ohe_result_test, axis=1)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
model = Sequential(name='Boston-Housing-Prices')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
"""
import pickle
model.save('boston-housing-prices.h5')
with open('boston-housing-prices.pickle', 'wb') as f:
pickle.dump([ohe, ss], f)
"""
import pandas as pd
predict_df = pd.read_csv('predict-boston-housing-prices.csv', delimiter=r'\s+', header=None)
predict_dataset_x = predict_df.to_numpy()
ohe_result_predict = ohe.transform(predict_dataset_x [:, 8].reshape(-1, 1))
predict_dataset_x = np.delete(predict_dataset_x, 8, axis=1)
predict_dataset_x = np.insert(predict_dataset_x, [8], ohe_result_predict, axis=1)
scaled_predict_dataset_x = ss.transform(predict_dataset_x )
predict_result = model.predict(scaled_predict_dataset_x)
for val in predict_result[:, 0]:
print(val)
# predict-boston-housing-pripces.csv
0.13554 12.50 6.070 0 0.4090 5.5940 36.80 6.4980 4 345.0 18.90 396.90 13.09
0.12816 12.50 6.070 0 0.4090 5.8850 33.00 6.4980 4 345.0 18.90 396.90 8.79
0.08826 0.00 10.810 0 0.4130 6.4170 6.60 5.2873 4 305.0 19.20 383.73 6.72
0.15876 0.00 10.810 0 0.4130 5.9610 17.50 5.2873 4 305.0 19.20 376.94 9.88
0.09164 0.00 10.810 0 0.4130 6.0650 7.80 5.2873 4 305.0 19.20 390.91 5.52
0.19539 0.00 10.810 0 0.4130 6.2450 6.20 5.2873 4 305.0 19.20 377.17 7.54
2024-05-20 13:45:43 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Biz regresyon terimini daha çok "çı ı ı ı ı ı ı
daha genel bir terim olarak kullanacağı
Aslı ı ı
Regresyon en genel anlamda girdi ile çı ı ı
y = f(x) biçiminde bir f fonksiyonunun elde edilme süreci olarak da tanı
x değerlerini fonksiyonda yerine koyarak y değerini elde edebiliriz. Tabi y = f(x) fonksiyonunda x değişkeni aslı
(x0, x1, x2, ..., xn) biçiminde birden fazla değişkeni de temsil ediyor olabilir. Bu durumda f fonksiyonu f((x0, x1, x2, ..., xn))
biçiminde çok değişkenli bir fonksiyon olacaktı
veriyor olabilir. Yani buradaki y değeri (y0, y1, y2, ..., ym) biçiminde de olabilir.
2024-04-02 13:01:04 +03:00
İstatistikte regresyon işlemleri tipik olarak aşağı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
- Eğer bağı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
- Eğer bağı ı
denilmektedir.
- Eğer girdiyle çı ı ı
elde edilmek isteniyorsa) bu tür regresyonlara "doğrusal regresyon (linear regression)" denilmektedir. Doğrusal regresyon
da bağı ı ı ı
ise "çoklu doğrusal regresyon (multiple linear regression)" biçiminde ikiye ayrı
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
- Bağı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
bir polinom elde edilmeye çalı ı
ya da çoklu olabilir. Aslı ı
2024-04-02 13:01:04 +03:00
dönüştürülebilmektedir. Dolayı ı ı ı ı ı
fark yoktur.
2024-05-20 13:45:43 +03:00
- Girdiyle çı ı ı
istenebilir). Bu tür regresyonlara "doğrusal olmayan regresyon (nonlinear regressions)" denilmektedir. Yukarı
gibi her ne kadar polinomlar doğrusal fonksiyonlar olmasa da bunlar transformasyonla doğrusal hale getirilebildikleri için doğrusal
olmayan regresyon denildiğinde genel olarak polinomsal regresyonlar kastedilmemektedir. Örneğin logatirmik, üstel regresyonlar
doğrusal olmayan regresyonlara örnektir.
2024-04-02 13:01:04 +03:00
- Bir regresyonda çı ı
regresyonlar denilmektedir. Örneğin:
2024-05-20 13:45:43 +03:00
(y1, y2) = f((x1, x2, x3, x4, x5))
Regresyon terminolojisinde "çok değişkenli" sözcüğü bağı ı ı ı
bağı ı ı ı
biçiminde ifade edilmektedir.
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
- Eğer regresyonun çı ı ı
(logictic regression)" ya da "logit regresyonu" denilmektedir. Lojistk regresyonda çı ı ı ı ı ı
gibi, olumlu-olumsuz gibi, doğru-yanlı ı ı ı
regression)" denilmektedir. Eğer çı ı ı ı ı ı ı
regresyon (multi-class/multinomial logistic regression)" denilmektedir. Tabii aslı ı
"lojistik regresyon" terimi yerine "sı ı ı
zaman değil) kategorik kestirim modellerine "lojistik regresyon modelleri" yerine "sı ı ı
anı ı ı
2024-04-02 13:01:04 +03:00
2024-05-20 13:45:43 +03:00
- Sı ı ı ı ı ı ı ı ı ı
değişkenli (multivariate) sı ı ı ı ı ı
her çı ı ı ı
olmadı ı ı ı ı ı ı ı ı ı ı
bir etiketteki kategorileri belirtmek için kullanı ı ı ı ı
(yani "multivariate lojistik regresyon" modelleri) genellikle aşağı ı ı ı ı ı
- Tek Etiketli İki Sı ı ı ı ı ı ı ı
bir tanedir. Etiket de iki sı ı ı ı
model tek etiketli iki sı ı ı
- Tek Etiketli Çok Sı ı ı ı ı ı ı ı ı ı ı
ikiden fazla sı ı ı ı ı ı ı ı ı ı ı
problemi tek etiketli çok sı ı ı
- Çok Etiketli İki Sı ı ı ı ı ı
zaten default olarak iki sı ı ı ı ı ı ı ı ı
tag'lamak istediğimizde her tag ayrı ı ı ı ı ı ı ı ı
- Çok Etiketli Çok Sı ı ı ı ı ı
modellere genellikle "çok boyutlu (multidimentional)" modeller denilmektedir. Yani çı ı ı ı ı
ikiden fazla sı ı ı ı ı
düşünebilirsiniz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Şimdi de tek etiketli çok sı ı ı ı ı ı
kümesini kullanacağı ı ı ı
şağı ı
2024-04-02 13:01:04 +03:00
https://www.kaggle.com/datasets/uciml/iris?resource=download
2024-05-20 13:45:43 +03:00
Yukarı ı ı ı ı ı ı
dosyası
Veri kümesi aşağı
Id,SepalLengthCm,SepalWidthCm,PetalLengthCm,PetalWidthCm,Species
1,5.1,3.5,1.4,0.2,Iris-setosa
2,4.9,3.0,1.4,0.2,Iris-setosa
3,4.7,3.2,1.3,0.2,Iris-setosa
4,4.6,3.1,1.5,0.2,Iris-setosa
5,5.0,3.6,1.4,0.2,Iris-setosa
6,5.4,3.9,1.7,0.4,Iris-setosa
7,4.6,3.4,1.4,0.3,Iris-setosa
8,5.0,3.4,1.5,0.2,Iris-setosa
9,4.4,2.9,1.4,0.2,Iris-setosa
......
Veri kümesinde üç grup zambak vardı
yaprakları ı ı
"Id" isimli ilk sütun sı ı ı ı ı
Çok sı ı ı ı ı ı ı ı ı
işlemine sokulması ı ı ı ı ı ı ı ı ı ı ı
biliyor olması ı ı ı ı
sort ettikten sonra "one-hot encoding" işlemi yapmaktadı ı ı ı ı
küçükten büyüğe sı ı ı ı ı
özniteliği le bu sütunları ı ı ı ı
uygulamaktadı ı ı ı ı ı ı ı ı ı ı
özniteliğindeki kategoriler de leksikografik olarak sı
Veri kümesini aşağı
df = pd.read_csv('Iris.csv')
x verilerini aşağı ı ı
dataset_x = df.iloc[:, 1:-1].to_numpy(dtype='float32')
y verilerini aşağı ı ı
ohe = OneHotEncoder(sparse= False)
dataset_y = ohe.fit_transform(df.iloc[:, -1].to_numpy().reshape(-1, 1))
Anı ı ı ı ı ı ı ı ı ı ı
aktivasyon fonksiyonu "softmax" olmalı ı ı ı ı
(Keras metrik değer olarak "accuracy" girildiğinde zaten problemin türüne göre onu "binary_accuracy" ya da "categorical_accuracy"
biçiminde ele alabilmektedir.) Veri kümesi yine özellik ölçeklemesine sokulmalı ı ı
Sinir ağı
model = Sequential(name='Iris')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(dataset_y.shape[1], activation='softmax', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
Çok sı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
fonksiyonu olarak softmax alı ı ı ı ı ı ı
çı ı ı ı ı ı ı
ziyade onun çı ı ı ı
argmax fonksiyonu ile yapı ı ı
Bu 2 numaralı ı ı ı ı ı
encoding sonucundaki 2 numaralı
sütunun hangi sı ı ı ı ı ı ı ı
özniteliğinde sakladı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-05-20 13:45:43 +03:00
df = pd.read_csv('Iris.csv')
2024-04-02 13:01:04 +03:00
dataset_x = df.iloc[:, 1:-1].to_numpy(dtype='float32')
from sklearn.preprocessing import OneHotEncoder
2024-05-20 13:45:43 +03:00
ohe = OneHotEncoder(sparse= False)
2024-04-02 13:01:04 +03:00
dataset_y = ohe.fit_transform(df.iloc[:, -1].to_numpy().reshape(-1, 1))
from sklearn.model_selection import train_test_split
2024-05-20 13:45:43 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
2024-05-20 13:45:43 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
2024-04-02 13:01:04 +03:00
model = Sequential(name='Iris')
2024-05-20 13:45:43 +03:00
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(64, activation='relu', name='Hidden-2'))
2024-05-20 13:45:43 +03:00
model.add(Dense(dataset_y.shape[1], activation='softmax', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
2024-05-20 13:45:43 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-05-20 13:45:43 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-05-20 13:45:43 +03:00
scaled_test_dataset_x = ss.transform(test_dataset_x)
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-05-20 13:45:43 +03:00
predict_dataset_x = pd.read_csv('predict-iris.csv').to_numpy(dtype='float32')
scaled_predict_dataset_x = ss.transform(predict_dataset_x)
2024-04-02 13:01:04 +03:00
import numpy as np
2024-05-20 13:45:43 +03:00
predict_result = model.predict(scaled_predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
for pi in predict_indexes:
print(ohe.categories_[0][pi])
"""
predict_categories = ohe.categories_[0][predict_indexes]
print(predict_categories)
"""
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
#predict-iris.csv
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
4.8,3.4,1.6,0.2
4.8,3.0,1.4,0.1
4.3,3.0,1.1,0.1
6.6,3.0,4.4,1.4
6.8,2.8,4.8,1.4
6.7,3.0,5.0,1.7
6.0,2.9,4.5,1.5
5.7,2.6,3.5,1.0
6.3,2.5,5.0,1.9
6.5,3.0,5.2,2.0
6.2,3.4,5.4,2.3
5.9,3.0,5.1,1.8
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
39. Ders 25/05/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Yapay zeka ve makine öğrenmesinin en önemli uygulama alanları
alanı ı
Bugün doğal dil işlemede artı ı ı ı ı ı
translation) süreci aslı ı ı
makine öğrenmesi teknikleriyle yapı ı ı
(text mining)" denilen alandı ı ı ı ı ı
ile ilgili süreçleri belirtmektedir. Bugün metin madenciliğinde de yine veri bilimi ve makine öğrenmesi teknikleri yoğun
olarak kullanı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Metinler üzerinde makine öğrenmesi teknikleri uygulanı ı
gerekir. Çünkü makine öğrenmesi tekniklerinde yazı ı ı ı
makine öğrenmesinde yazı ı ı ı
alanları ı ı ı ı
bir yazı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
"Filmi pek beğenmedim. Oyuncular iyi oynayamamı ı ı ı
kötü mü olduğu konusunda kafam karı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Bu yazı ı ı ı ı ı ı
şunlardı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
- Yazı ı ı
- Sözükleri küçük harfe ya da büyük harfe dönüştürmek (transformation)
- Kendi başı ı ı ı
denilmektedir.
- Sözcüklerin köklerini elde ve köklerini kullanmak (stemming)
- Bağlam içerisinde farklı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Yukarı ı ı
NLTK isimli kütüphanedir.
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Sözcükleri birbirinden bağı ı ı ı
Ancak son 20 yı ı ı ı
Bunun ağlarda sözcüklerin sı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Sı ı ı ı ı ı
Biz buna Türkçe "duygu analizi" diyeceğiz. Duygu analizi problemlerinde kişiler bir olgu hakkı ı ı ı ı
yazarlar. Bu yazı ı ı ı ı ı ı
etiketlendirmeler de söz konusu olabilmektedir. Böylece eğitim sonrası ı ı
kestirimler yapı
Duygu analizi için oluşturulmuş çeşitli örnek veri kümeleri vardı ı ı
Movie Database)" isimli veri kümesidir. Bu veri kümesinde kişiler filmler hakkı ı ı ı ı
yazı ı ı ı ı
yazı ı ı
IMDB veri kümesindeki girdiler (yani dataset_x) yazı ı ı ı
biçiminde ikili bir çı ı ı ı ı
https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews
Buradan veri kümesi zip dosyası ı ı ı ı
Bu CSV dosaysı ı ı ı ı ı
"sentiment" sütunu ise "positive" ya da "negative" biçiminde kanı ı ı ı
problemi olduğuna dikkat ediniz.
Duygu analizi problemlerinde girdiler birer yazı ı
sayı ı ı ı ı ı
1) Vektörizasyon (vectorization) yöntemi
2) Sözcük Gömme (Word Embedding) yöntemi
Her iki yöntemde de önce yazı ı ı ı
bir sözcük grubu haline getirilir. Biz burada en basit yöntem olan "vektörizasyon" yöntemi üzerinde duracağı
Sözcük gömme yöntemini sonraki paragraflarda ele alacağı
Vektörizasyon işlemi şöyle uygulanmaktadı
1) Tüm yorumlardaki tüm sözcüklerin kümesine "kelime haznesi (vocabulary)" denilmektedir. Örneğin IMDB veri kümesinde tek
olan (unique) tüm sözcüklerin sayı ı ı
2) Veri kümesindeki x verileri yorum sayı ı ı ı ı
bir matris biçiminde oluşturulur. Örneğin sözcük haznesindeki sözcük sayı ı
varsa x veri kümesi 10000x50000 büyüklüğünde bir matris biçimindedir. Bir yorum bu matriste bir satı
Yoruma ilişkin satı ı ı ı ı
yapı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
40. Ders - 26/05/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Örneğin elimizdeki yorum yazı ı
"Film güzeldi. Ancak uzundu."
"Film güzel değildi."
"Film kötüydü. Tavsiye etmem."
"Film iyiydi. Tavsiye ederim."
"Film kötü değildi."
Yukarı ı ı ı ı ı
olmaktadı ı ı
haznesi şöyle olacaktı
film
güzeldi
ancak
güzel
uzundu
değildi
kötüydü
tavsiye
etmem
iyiydi
ederim
kötü
Burada tüm bu sözcükleri bir sözlükte toplayarak bunlara birer numara verelim:
film 0
güzeldi 1
ancak 2
uzundu 3
güzel 4
değildi 5
kötüydü 6
tavsiye 7
etmem 8
iyiydi 9
ederim 10
kötü 11
Burada toplam 5 tane yorum vardı
haline getirilir:
0 1 2 3 4 5 6 7 8 9 0 1
----------------------------
1 1 1 1 0 0 0 0 0 0 0 0
Diğer yorumlar da şöyle kodlanacaktı
0 1 2 3 4 5 6 7 8 9 0 1
----------------------------
1 1 1 1 0 0 0 0 0 0 0 0 (1. Yorum: "Film güzeldi. Ancak uzundu.")
1 0 0 0 1 1 0 0 0 0 0 0 (2. Yorum: "Film güzel değildi.")
1 0 0 0 0 0 1 1 1 0 0 0 (3. Yorum: "Film kötüydü. Tavsiye etmem.")
1 0 0 0 0 0 0 1 0 1 1 0 (4. Yorum: "Film iyiydi. Tavsiye ederim.")
1 0 0 0 0 1 0 0 0 0 0 1 (5. Yorum: "Film kötü değildi.")
Yorum yazı ı ı ı ı
0, 1, 2, 3 (1. Yorum: "Film güzeldi. Ancak uzundu.")
0, 4, 5 (2. Yorum: "Film güzel değildi.")
0, 6, 7, 8 (3. Yorum: "Film kötüydü. Tavsiye etmem.")
0, 7, 9, 10 (4. Yorum: "Film iyiydi. Tavsiye ederim.")
0, 11, 5 (5. Yorum: "Film kötü değildi.")
Bu vektörizasyon yöntemi fazlaca bellek kullanma eğilimindedir. Veri yapı ı ı ı ı ı ı
farklı
dikkat ediniz. Eğer sözcük haznesi çok büyükse gerçekten de tüm girdilerin yukarı
toplanması ı
bütün olarak istemektedir. Bu durumda değişik teknikler kullanı
duracağı
Yukarı ı ı ı ı ı ı
Bu biçimde uygulanan vektörüzasyon sözcükleri bağlamı ı ı ı
vektörizasyon ikili (binary) biçimdedir. Yani yazı ı ı ı
ilişkin sütun elemanı ı ı ı ı ı ı ı
Örneğin "film" sözcüğü yazı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de IMDB örneğinde yukarı ı ı ı ı ı
okuyalı
df = pd.read_csv('IMDB Dataset.csv')
Şimdi tüm yorumlardaki farklı ı
import re
vocab = set()
for text in df['review']:
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
Burada Python'daki "düzenli ifade (regular expression)" kütüphanesinden faydalanı ı ı
ile yazı
arama yapı ı ı ı ı
vocab_dict = {word: index for index, word in enumerate(vocab)}
Aslı ı ı ı ı
vocab_dict = {}
for index, word in enumerate(vocab):
vocab_dict[word] = index
Şimdi artı ı ı ı ı ı ı ı
len(df) kadar (yani yorum sayı ı ı ı ı ı
dataset_x = np.zeros((len(df), len(vocab)), dtype='uint8')
Şimdi yeniden tüm yorumları ı ı ı ı ı ı ı ı ı
sütunları ı ı
for row, text in enumerate(df['review']):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
dataset_x[row, word_numbers] = 1
y değerlerini de "positive" için 1, "negatif" için 0 biçiminde oluşturabiliriz:
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Veri kümsini eğitim ve test biçiminde ikiye ayı
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
Artı ı ı ı ı ı ı ı ı ı
ağı ı ı ı ı ı
yükseltebiliriz.
model = Sequential(name='IMDB')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=5, validation_split=0.2)
Bu veri kümesinden bu haliyle %88 civarı ı
biçimde yapı ı ı
review
The movie was very bad. The players showed a poor performance. The script is not interesting.
I liked the movie very much. The players also played well. The ending of the movie was very surprising.
The movie is a work of medium quality. I think it's neither good nor bad.
Great movies should always leave you with a feeling during or after seeing them.
The worst movie I've ever seen in my life
I can't say that I am very happy that I went to this movie.
Bu CSV dosyası ı ı ı ı ı ı
predict_df = pd.read_csv('predict-imdb.csv')
predict_dataset_x = np.zeros((len(predict_df), len(vocab)))
for row, text in enumerate(predict_df['review']):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
predict_dataset_x[row, word_numbers] = 1
Kestirim işlemini de şöyle yapabiliriz:
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
Pekiyi biz binary vektör haline geitirilmiş yazı ı ı
getiremeyiz. Çünkü biz burada binary vektör oluşturduğumuz için sözük sı ı ı ı ı ı ı ı
anlamsı ı ı
rev_vocab_dict = {index: word for word, index in vocab_dict.items()}
word_indices = np.argwhere(dataset_x[0] == 1).flatten()
words = [rev_vocab_dict[index] for index in word_indices]
text = ' '.join(words)
print(text)
NumPy'ı ı ı
argwhere fonksiyonu bize iki boyutlu bir dizi vermektedir. Biz de onu flatten (ya da reshape) fonkisyonu ile tek boyutlu
dizi haline getirdik, sonra da liste içlemiyle bu indekslere karşı
de bunları ı ı
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
2024-06-09 22:37:05 +03:00
vocab = set()
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
import re
2024-04-02 13:01:04 +03:00
for text in df['review']:
2024-06-09 22:37:05 +03:00
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
vocab_dict = {word: index for index, word in enumerate(vocab)}
2024-04-02 13:01:04 +03:00
"""
2024-06-09 22:37:05 +03:00
vocab_dict = {}
for index, word in enumerate(vocab):
vocab_dict[word] = index
"""
2024-04-02 13:01:04 +03:00
import numpy as np
2024-06-09 22:37:05 +03:00
dataset_x = np.zeros((len(df), len(vocab)), dtype='uint8')
2024-04-02 13:01:04 +03:00
for row, text in enumerate(df['review']):
2024-06-09 22:37:05 +03:00
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
dataset_x[row, word_numbers] = 1
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-06-09 22:37:05 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-06-09 22:37:05 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='IMDB')
2024-06-09 22:37:05 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=5, validation_split=0.2)
import matplotlib.pyplot as plt
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-06-09 22:37:05 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-06-09 22:37:05 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-06-09 22:37:05 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_dataset_x = np.zeros((len(predict_df), len(vocab)))
for row, text in enumerate(predict_df['review']):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
predict_dataset_x[row, word_numbers] = 1
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
2024-04-02 13:01:04 +03:00
print('Positive')
else:
print('Negative')
2024-06-09 22:37:05 +03:00
# dataset_x'teki birinci yorumun yazı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
rev_vocab_dict = {index: word for word, index in vocab_dict.items()}
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
word_indices = np.argwhere(dataset_x[0] == 1).flatten()
words = [rev_vocab_dict[index] for index in word_indices]
text = ' '.join(words)
print(text)
#----------------------------------------------------------------------------------------------------------------------------
41. Ders - 01/06/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Yazı ı ı ı ı ı ı
dezavantajları ı
2024-04-02 13:01:04 +03:00
- Aynı ı ı ı ı ı
yazı ı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
Yani yukarı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
- Vektörizasyon işlemi bir bağlam oluşturamamaktadı ı ı
"kötüyü" nitelemektedir. Ancak bunu bizim ağı ı ı ı ı
2024-04-02 13:01:04 +03:00
ettiğimiz vektör değişmeyecektir.
2024-06-09 22:37:05 +03:00
- Vektörizasyon işlemi çok yer kaplama potansiyelinde olan bir işlemdir. Bu durumda ağı ı
kalabiliriz. Parçalı
verilir. Keras'ta parçalı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
- Biz yukarı ı ı ı ı ı
performansı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Aslı
bulunan CountVectorizer sı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
1) Önce CountVectorizer sı ı ı ı ı ı ı ı ı ı ı
belirlemeler yapı ı ı
parametreyi elde edilecek matrisin kaplayacğı
Default durumda bu dtype parametresi 'float64' biçimindedir. Sı ı
Ancak metodun lowercase parametresi False geçilirse bu dönüştürme yapı ı ı
Örneğin metodun stop_words parametresi "stop word" denilen anlamsı ı
stop words'lerden oluşan bir liste ya da NumPy dizisi girilirse bu sözcükler sözcük haznesinden atı ı
deyişle yokmuş gibi ele alı ı ı
içerisinde aynı ı ı ı
edilmektedir. Biz eğer yukarı
yapabiliriz. Metodun diğer parametreleri için scikit-learn dokümanları
Örneğin:
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(dtype='uint8', stop_words=['de', 'bir', 've', 'mu'], binary=True)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
2) Bundan sonra scikit-learn kütüphanesinin diğer sı ı ı ı ı
2024-04-02 13:01:04 +03:00
fit metoduna yazı ı ı
2024-06-09 22:37:05 +03:00
oluşturur. Biz de bu sözlük haznesini bir sözlük nesnesi biçiminde nesnenin vocabulary_ özniteliğinden elde edebiliriz. Bu
vocabulary_ tı ı ı ı ı ı ı
sözlğk biçimindedir. Örneğin:
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
texts = ["film güzeldi ve senaryo iyidi", "film berbattı ı ı
"oyuncular güzel oynamı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(dtype='uint8', stop_words=['de', 'bir', 've', 'mu'], binary=True)
2024-04-02 13:01:04 +03:00
cv.fit(texts)
2024-06-09 22:37:05 +03:00
fit işlemi sonrası
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
{'film': 4, 'güzeldi': 9, 'senaryo': 14, 'iyidi': 10, 'berbattı ı
'oyuncular': 13, 'güzel': 8, 'oynamı
fit medodunun yalnı ı ı
bize vektörel hale getirilmiş olan yazı ı ı ı
2024-06-30 23:07:28 +03:00
vermektedir. Bu sı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
dataset_x = cv.transform(dataset).todense()
2024-04-02 13:01:04 +03:00
2024-06-30 23:07:28 +03:00
Aslı ı ı ı ı
bulunuyorsa biz doğrudan dosye nesnesini bu fit metoduna verebiliriz. Bu durumda tüm yazı ı ı
Örneğin:
from sklearn.feature_extraction.text import CountVectorizer
f = open('text.csv')
cv = CountVectorizer()
cv.fit(f)
2024-06-09 22:37:05 +03:00
Artı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
from sklearn.feature_extraction.text import CountVectorizer
2024-06-09 22:37:05 +03:00
texts = ["film güzeldi ve senaryo iyidi", "film berbattı ı ı ı
"senaryo berbattı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(dtype='uint8', stop_words=['de', 'bir', 've', 'mu'])
2024-04-02 13:01:04 +03:00
cv.fit(texts)
print(cv.vocabulary_)
2024-06-09 22:37:05 +03:00
dataset_x = cv.transform(texts).todense()
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
print(dataset_x)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Yukarı ı ı ı ı ı
Bu parametrenin False olması ı ı ı
anlamı ı ı
yaparken "binary" mi yoksa frekanslı ı ı ı ı ı
Ancak binary bilgilerin tutulma biçiminden özel olarak bir kazanç sağlanmaya çalı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Aşağı ı ı ı ı ı ı ı
yapı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
df = pd.read_csv('IMDB Dataset.csv')
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
from sklearn.feature_extraction.text import CountVectorizer
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(dtype='uint8', binary=True)
cv.fit(df['review'])
dataset_x = cv.transform(df['review']).todense()
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
from sklearn.model_selection import train_test_split
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='IMDB')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=5, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# prediction
predict_df = pd.read_csv('predict-imdb.csv')
predict_dataset_x = cv.transform(predict_df['review']).todense()
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
# dataset_x'teki birinci yorumun yazı
import numpy as np
rev_vocab_dict = {index: word for word, index in cv.vocabulary_.items()}
word_indices = np.argwhere(dataset_x[0] == 1)[:, 1]
words = [rev_vocab_dict[index] for index in word_indices]
text = ' '.join(words)
print(text)
#----------------------------------------------------------------------------------------------------------------------------
Keras içerisinde tensorflow.keras.datasets modülünde IMDB veri kümesi de hazı ı ı
kümelerinde olduğu gibi bu IMDB veri kğmesi de modüldeki load_data fonksiyonu ile yüklenmektedir. Örneğin:
2024-04-02 13:01:04 +03:00
from tensorflow.keras.datasets import imdb
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data()
2024-06-09 22:37:05 +03:00
Burada load_data fonksiyonunun num_words isimli parametresine eğer bir değer girilirse bu değer toplam sözcük haznesinin
2024-04-19 00:21:20 +03:00
sayı ı ı
2024-04-02 13:01:04 +03:00
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data(num_words=1000)
2024-06-09 22:37:05 +03:00
Burada artı ı ı ı ı
vektörlerin sütun uzunlukları ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Bize load_data fonksiyonu x verileri olarak vektörizasyon sonucundaki vektörleri vermemektedir. Sözcüklerin indekslerine ilişkin
vektörleri bir liste olarak vermektedir. (Bunun nedeni uygulamacı ı
sağlamaktı ı ı ı
sözcük indekslerini üç fazla vermektedir. Bu sözcük indekslerindeki 0, 1 ve 2 indeksleri özel anlam ifade etmektedir.
Dolayı ı ı ı ı ı ı
gerekmektedir.
imdb modülündeki get_word_index fonksiyonu bize sözcük haznesini bir sözlük olarak vermektedir. num_words ne olursa olsun bu
sözlük her zaman tüm kelime haznesini içermektedir. Başka bir deyişle buradaki get_word_index fonksiyonu bizim kodları ı
vocab_dict sözlüğünü vermektedir. Örneğin:
2024-04-02 13:01:04 +03:00
vocab_dict = imdb.get_word_index()
2024-06-09 22:37:05 +03:00
Bu durumda biz training_dataset_x ve test_dataset_x listelerini aşağı
yazabiliriz:
def vectorize(sequence, colsize):
dataset_x = np.zeros((len(sequence), colsize), dtype='uint8')
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
Burada vectorize fonksiyonu indekslerin bulunduğu liste listesini ve oluşturulacak matrisin sütun uzunluğunu parametre
olarak almı ı ı
colsize parametresine get_word_index ile verilen sözlüğün eleman sayı ı
bu indeks listelerinde 0, 1 ve 2 değerleri özel bazı ı ı ı ı ı
3 fazladı ı ı ı ı
indeks değerleriden 3 çı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
training_dataset_x = vectorize(training_dataset_x, len(vocab_dict) + 3)
test_dataset_x = vectorize(test_dataset_x, len(vocab_dict) + 3)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Artı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Kestirim işleminde de aynı
yaptı ı ı ı ı ı
sokup onun numarası ı ı ı ı
yazmı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
predict_list = []
for text in predict_df['review']:
index_list = []
words = re.findall('[A-Za-z0-9]+', text.lower())
for word in words:
index_list.append(vocab_dict[word] + 3)
predict_list.append(index_list)
predict_dataset_x = vectorize(predict_list, len(vocab_dict) + 3)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_result = model.predict(predict_dataset_x)
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import imdb
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data()
vocab_dict = imdb.get_word_index()
import numpy as np
def vectorize(sequence, colsize):
dataset_x = np.zeros((len(sequence), colsize), dtype='uint8')
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
training_dataset_x = vectorize(training_dataset_x, len(vocab_dict) + 3)
test_dataset_x = vectorize(test_dataset_x, len(vocab_dict) + 3)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='IMDB')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=5, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import pandas as pd
import re
predict_df = pd.read_csv('predict-imdb.csv')
predict_list = []
for text in predict_df['review']:
index_list = []
words = re.findall('[A-Za-z0-9]+', text.lower())
for word in words:
index_list.append(vocab_dict[word] + 3)
predict_list.append(index_list)
predict_dataset_x = vectorize(predict_list, len(vocab_dict) + 3)
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
# dataset_x'teki birinci yorumun yazı
rev_vocab_dict = {index: word for word, index in vocab_dict.items()}
word_indices = np.argwhere(training_dataset_x[0] == 1).flatten()
words = [rev_vocab_dict[index - 3] for index in word_indices if index > 2]
text = ' '.join(words)
print(text)
#----------------------------------------------------------------------------------------------------------------------------
42. Ders - 02/06/2024 - Pazar
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yazı ı ı ı ı ı ı ı
80'lerin başları ı ı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
Dolayı ı ı ı ı ı ı ı ı ı ı
46 farklı ı
yazı ı ı
ilk etiketini alacağı ı ı ı ı ı
biçimde kullanacağı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Reuters veri kümesinin orijinali ".SGM" uzantı ı ı ı ı ı ı
hazı ı ı ı
kaydedilmiş biçimde sunulmaktadı
2024-04-02 13:01:04 +03:00
https://www.kaggle.com/datasets/nltkdata/reuters
Buradaki dosya indirilip açı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
training <DIR>
test <DIR>
2024-04-02 13:01:04 +03:00
cats.txt
2024-06-09 22:37:05 +03:00
stopwords
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Ancak veri kümesini açtı ı ı ı ı ı
diğerlerini atabilirsiniz.
Buradaki "cats.txt" dosyası ı ı ı
her bir yazı ı
kullanmalı ı ı ı ı ı ı ı
dizin yapı ı
ReutersData
training <DIR>
test <DIR>
cats.txt
stopwords
Burada veri kümesi "eğitim" ve "test" biçiminde zaten ikiye ayrı ı ı ı ı ı
ve "test" biçiminde ayı ı ı ı ı
test/14826 trade
test/14828 grain
test/14829 nat-gas crude
test/14832 rubber tin sugar corn rice grain trade
test/14833 palm-oil veg-oil
test/14839 ship
test/14840 rubber coffee lumber palm-oil veg-oil
...
raining/5793 nat-gas
training/5796 crude
training/5797 money-supply
training/5798 money-supply
training/5800 grain
training/5803 gnp
training/5804 gnp
training/5805 gnp
training/5807 gnp
training/5808 acq
training/5810 trade
training/5811 money-fx
training/5812 carcass livestock
...
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Reuters veri kümesinde ayrı
sözcük haznesinden çı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Biz burada vektörizasyon işlemini önce manuel bir biçimde yapı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-19 00:21:20 +03:00
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Önce "cats.txt" dosyası ı ı ı
sözlük nesnelerinin anahtarları ı ı ı ı ı ı
training_dict = {}
test_dict = {}
cats = set()
with open('ReutersData/cats.txt') as f:
for line in f:
toklist = line.split()
ttype, fname = toklist[0].split('/')
if ttype == 'training':
training_dict[fname] = toklist[1]
else:
if ttype == 'test':
test_dict[fname] = toklist[1]
cats.add(toklist[1])
vocab = set()
training_texts = []
training_y = []
for fname in os.listdir('ReutersData/training'):
with open('ReutersData/training/' + fname, encoding='latin-1') as f:
text = f.read()
training_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
training_y.append(training_dict[fname])
test_texts = []
test_y = []
for fname in os.listdir('ReutersData/test'):
with open('ReutersData/test/' + fname, encoding='latin-1') as f:
text = f.read()
test_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
test_y.append(test_dict[fname])
Burada tüm sözcük haznesinin vocab isimli bir kümede tüm kategorilerin de cats isimli bir kümede toplandı ı
Hazı ı ı ı ı ı ı
her yazı ı ı ı ı ı
verebiliriz:
vocab_dict = {word: index for index, word in enumerate(vocab)}
Şimdi manuel olarak binary vektörizasyon uygulayalı
training_dataset_x = np.zeros((len(training_texts), len(vocab)), dtype='uint8')
test_dataset_x = np.zeros((len(test_texts), len(vocab)), dtype='uint8')
for row, text in enumerate(training_texts):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
training_dataset_x[row, word_numbers] = 1
for row, text in enumerate(test_texts):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
test_dataset_x[row, word_numbers] = 1
Problem çok sı ı ı ı ı ı
uygulayabiliriz:
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe.fit(np.array(list(cats)).reshape(-1, 1))
training_dataset_y = ohe.transform(np.array(training_y).reshape(-1, 1))
test_dataset_y = ohe.transform(np.array(test_y).reshape(-1, 1))
Artı
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(len(cats), activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=10, validation_split=0.2)
Kestirim işlemi için eğitimdeki veri kğmesine benzer bir veri kümesi oluşturulabilir. Biz örneğimizde kestirim için
"PredictData" isimli bir dizin oluşturup o dizine yazı ı ı
tiketlerini dosya ismine ek yaptı
14829-nat-gas
14841-wheat
14849-interest
14854-ipi
14860-earn
14862-bop
14876-earn
21394-acq
Kestirim kodu şöyle oluşturulabilir:
word_numbers_list = []
fnames = []
for fname in os.listdir('PredictData'):
with open('PredictData/' + fname, encoding='latin-1') as f:
text = f.read()
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
word_numbers_list.append(word_numbers)
fnames.append(fname)
predict_dataset_x = np.zeros((len(word_numbers_list), len(vocab)), dtype='uint8')
for row, word_numbers in enumerate(word_numbers_list):
predict_dataset_x[row, word_numbers] = 1
predict_result = model.predict(predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
for index, pi in enumerate(predict_indexes):
print(f'{fnames[index]} => {ohe.categories_[0][pi]}')
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import os
2024-06-09 22:37:05 +03:00
import re
training_dict = {}
test_dict = {}
cats = set()
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
with open('ReutersData/cats.txt') as f:
2024-04-02 13:01:04 +03:00
for line in f:
2024-06-09 22:37:05 +03:00
toklist = line.split()
ttype, fname = toklist[0].split('/')
if ttype == 'training':
training_dict[fname] = toklist[1]
else:
if ttype == 'test':
test_dict[fname] = toklist[1]
cats.add(toklist[1])
vocab = set()
training_texts = []
training_y = []
for fname in os.listdir('ReutersData/training'):
with open('ReutersData/training/' + fname, encoding='latin-1') as f:
text = f.read()
training_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
training_y.append(training_dict[fname])
test_texts = []
test_y = []
for fname in os.listdir('ReutersData/test'):
with open('ReutersData/test/' + fname, encoding='latin-1') as f:
text = f.read()
test_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
test_y.append(test_dict[fname])
vocab_dict = {word: index for index, word in enumerate(vocab)}
import numpy as np
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
training_dataset_x = np.zeros((len(training_texts), len(vocab)), dtype='uint8')
test_dataset_x = np.zeros((len(test_texts), len(vocab)), dtype='uint8')
for row, text in enumerate(training_texts):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
training_dataset_x[row, word_numbers] = 1
for row, text in enumerate(test_texts):
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
test_dataset_x[row, word_numbers] = 1
import numpy as np
from sklearn.preprocessing import OneHotEncoder
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe.fit(np.array(list(cats)).reshape(-1, 1))
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
training_dataset_y = ohe.transform(np.array(training_y).reshape(-1, 1))
test_dataset_y = ohe.transform(np.array(test_y).reshape(-1, 1))
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='Reuters')
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(len(cats), activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=10, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x , test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# prediction
word_numbers_list = []
fnames = []
for fname in os.listdir('PredictData'):
with open('PredictData/' + fname, encoding='latin-1') as f:
text = f.read()
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] for word in words]
word_numbers_list.append(word_numbers)
fnames.append(fname)
predict_dataset_x = np.zeros((len(word_numbers_list), len(vocab)), dtype='uint8')
for row, word_numbers in enumerate(word_numbers_list):
predict_dataset_x[row, word_numbers] = 1
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_result = model.predict(predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
for index, pi in enumerate(predict_indexes):
print(f'{fnames[index]} => {ohe.categories_[0][pi]}')
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
43. Ders - 08/06/2024 - Cumartesi
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de Reuters örneğini CountVectorizer sı ı ı ı ı ı ı ı ı ı
zaten vektörizasyon işlemini kendisi yapmaktaydı ı ı ı ı
sı ı ı ı ı
2024-07-22 23:31:13 +03:00
satı ı ı ı ı ı ı ı
belirtebiliyorduk.) Reuters veri kümesinde verilen stop word'leri bir Python listesi biçiminde şöyle elde edebiliriz:
2024-06-09 22:37:05 +03:00
import pandas as pd
df_sw = pd.read_csv('ReutersData/stopwords', header=None)
sw = df_sw.iloc[:, 0].to_list()
CountVectorizer sı ı ı ı ı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
ayı ı ı ı ı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
tı ı ı ı ı ı ı
bir uyumsuzluk durumu ortaya çı ı ı ı ı ı ı ı ı
sözcükler içerisinde bulunmayacaktı ı ı ı ı ı ı
biçiminde bunu aşağı
"C:\Users\aslan\anaconda3\lib\site-packages\sklearn\feature_extraction\text.py:409: UserWarning: Your stop_words may be
inconsistent with your preprocessing. Tokenizing the stop words generated tokens ['ain', 'aren', 'couldn', 'didn', 'doesn',
'don', 'hadn', 'hasn', 'haven', 'isn', 'll', 'mon', 'shouldn', 've', 'wasn', 'weren', 'won', 'wouldn'] not in stop_words."
2024-07-22 23:31:13 +03:00
O halde biz ya sı ı ı ı ı ı ı ı
kapsayacak biçimde değiştirmeliyiz ya da bu tı ı ı ı ı
için uyarı
2024-06-09 22:37:05 +03:00
sw += ['ain', 'aren', 'couldn', 'didn', 'doesn', 'don', 'hadn', 'hasn', 'haven', 'isn', 'll', 'mon',
'shouldn', 've', 'wasn', 'weren', 'won', 'wouldn']
Ayrı ı ı ı ı
oluşturulmuş default stop word listesi kullanı ı ı ı
2024-07-22 23:31:13 +03:00
olacaktı ı ı ı ı ı ı ı
biçimde bir düzenli ifade kaalı ı ı
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(token_pattern="[a-zA-Z-0-9']+")
2024-07-22 23:31:13 +03:00
Burada artı ı ı ı
"sözcüklerin içerisinde tek tı ı
Şimdi vektörizasyon işlemini sı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
2024-07-22 23:31:13 +03:00
df_sw = pd.read_csv('ReutersData/stopwords', header=None)
sw = df_sw.iloc[:, 0].to_list()
sw += ['ain', 'aren', 'couldn', 'didn', 'doesn', 'don', 'hadn', 'hasn', 'haven', 'isn', 'll', 'mon',
'shouldn', 've', 'wasn', 'weren', 'won', 'wouldn']
2024-06-09 22:37:05 +03:00
cv = CountVectorizer(dtype='uint8', stop_words=sw, encoding='latin-1')
cv.fit(training_texts + test_texts)
training_dataset_x = cv.transform(training_texts).todense()
test_dataset_x = cv.transform(test_texts).todense()
Kesitirim işlemi için yine daha önce yaratmı
predict_texts = []
fnames = []
for fname in os.listdir('PredictData'):
with open('PredictData/' + fname, encoding='latin-1') as f:
text = f.read()
predict_texts.append(text)
fnames.append(fname)
predict_dataset_x = cv.transform(predict_texts).todense()
CountVectorizer sı ı ı ı ı ı
vektörize edilmiş matris sözcüklerin sı ı ı ı
Örneğin bütünsel hali aşağı
#----------------------------------------------------------------------------------------------------------------------------
import os
import re
training_dict = {}
test_dict = {}
cats = set()
with open('ReutersData/cats.txt') as f:
for line in f:
toklist = line.split()
ttype, fname = toklist[0].split('/')
if ttype == 'training':
training_dict[fname] = toklist[1]
else:
if ttype == 'test':
test_dict[fname] = toklist[1]
cats.add(toklist[1])
vocab = set()
training_texts = []
training_y = []
for fname in os.listdir('ReutersData/training'):
with open('ReutersData/training/' + fname, encoding='latin-1') as f:
text = f.read()
training_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
training_y.append(training_dict[fname])
test_texts = []
test_y = []
2024-04-02 13:01:04 +03:00
for fname in os.listdir('ReutersData/test'):
2024-06-09 22:37:05 +03:00
with open('ReutersData/test/' + fname, encoding='latin-1') as f:
text = f.read()
test_texts.append(text)
words = re.findall('[a-zA-Z0-9]+', text.lower())
vocab.update(words)
test_y.append(test_dict[fname])
vocab_dict = {word: index for index, word in enumerate(vocab)}
import pandas as pd
df_sw = pd.read_csv('ReutersData/stopwords', header=None)
sw = df_sw.iloc[:, 0].to_list()
sw += ['ain', 'aren', 'couldn', 'didn', 'doesn', 'don', 'hadn', 'hasn', 'haven', 'isn',
'll', 'mon', 'shouldn', 've', 'wasn', 'weren', 'won', 'wouldn']
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='uint8', stop_words=sw, encoding='latin-1')
cv.fit(training_texts + test_texts)
training_dataset_x = cv.transform(training_texts).todense()
test_dataset_x = cv.transform(test_texts).todense()
2024-04-02 13:01:04 +03:00
import numpy as np
from sklearn.preprocessing import OneHotEncoder
2024-06-09 22:37:05 +03:00
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe.fit(np.array(list(cats)).reshape(-1, 1))
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
training_dataset_y = ohe.transform(np.array(training_y).reshape(-1, 1))
test_dataset_y = ohe.transform(np.array(test_y).reshape(-1, 1))
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-06-09 22:37:05 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Reuters')
2024-06-09 22:37:05 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(len(cats), activation='softmax', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
2024-06-09 22:37:05 +03:00
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
2024-06-09 22:37:05 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=10, validation_split=0.2)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-06-09 22:37:05 +03:00
eval_result = model.evaluate(test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-06-09 22:37:05 +03:00
# prediction
predict_texts = []
fnames = []
for fname in os.listdir('PredictData'):
with open('PredictData/' + fname, encoding='latin-1') as f:
text = f.read()
predict_texts.append(text)
fnames.append(fname)
predict_dataset_x = cv.transform(predict_texts).todense()
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
predict_result = model.predict(predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
for index, pi in enumerate(predict_indexes):
print(f'{fnames[index]} => {ohe.categories_[0][pi]}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Aslı ı ı
kümesinin yüklenmesi yine diğer veri kümelerinde olduğu gibi load_data fonksiyonuyla yapı
parametresi yine kelime haznesini belli bir sayı ı
bütün Reuters verileri kullanı ı ı ı
dokümanları ı ı ı
sı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
cats = ['cocoa','grain','veg-oil','earn','acq','wheat','copper','housing','money-supply',
2024-04-02 13:01:04 +03:00
'coffee','sugar','trade','reserves','ship','cotton','carcass','crude','nat-gas',
'cpi','money-fx','interest','gnp','meal-feed','alum','oilseed','gold','tin',
'strategic-metal','livestock','retail','ipi','iron-steel','rubber','heat','jobs',
'lei','bop','zinc','orange','pet-chem','dlr','gas','silver','wpi','hog','lead']
2024-06-09 22:37:05 +03:00
Ancak Tensorflow kütüphanesinin son versiyonları ı
get_label_names fonksiyonu ile verilmektedir.
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Tı ı ı ı
2024-07-22 23:31:13 +03:00
nesnesi biçiminde vermektedir. load_data fonksiyonu da yine bize sözcük numaraları
modülünde olduğu gibi x verilerindeki sayı ı ı
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Biz bu hazı ı ı ı ı ı ı ı ı ı
vektörizasyon yapmaktadı ı ı ı ı ı
sayı ı ı ı ı ı ı ı
vektörizasyon matrisini elde etmek daha uygun olacaktı
2024-04-02 13:01:04 +03:00
def vectorize(sequence, colsize):
2024-06-09 22:37:05 +03:00
dataset_x = np.zeros((len(sequence), colsize), dtype='uint8')
2024-04-02 13:01:04 +03:00
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
2024-05-20 13:45:43 +03:00
Aslı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Aşağı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import reuters
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = reuters.load_data()
2024-06-09 22:37:05 +03:00
vocab_dict = reuters.get_word_index()
2024-04-02 13:01:04 +03:00
import numpy as np
def vectorize(sequence, colsize):
2024-06-09 22:37:05 +03:00
dataset_x = np.zeros((len(sequence), colsize), dtype='uint8')
2024-04-02 13:01:04 +03:00
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
2024-06-09 22:37:05 +03:00
training_dataset_x = vectorize(training_dataset_x, len(vocab_dict) + 3)
test_dataset_x = vectorize(test_dataset_x, len(vocab_dict) + 3)
2024-04-02 13:01:04 +03:00
from sklearn.preprocessing import OneHotEncoder
2024-06-09 22:37:05 +03:00
ohe = OneHotEncoder(sparse_output=False, dtype='uint8')
ohe.fit(np.concatenate([training_dataset_y, test_dataset_y]).reshape(-1, 1))
training_dataset_y = ohe.transform(training_dataset_y.reshape(-1, 1))
test_dataset_y = ohe.transform(test_dataset_y.reshape(-1, 1))
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-06-09 22:37:05 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='Reuters')
2024-06-09 22:37:05 +03:00
model.add(Input((training_dataset_x.shape[1],)))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(len(ohe.categories_[0]), activation='softmax', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
2024-06-09 22:37:05 +03:00
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
2024-06-09 22:37:05 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=10, validation_split=0.2)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-06-09 22:37:05 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-06-09 22:37:05 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-06-09 22:37:05 +03:00
# prediction
cats = ['cocoa','grain','veg-oil','earn','acq','wheat','copper','housing','money-supply',
'coffee','sugar','trade','reserves','ship','cotton','carcass','crude','nat-gas',
'cpi','money-fx','interest','gnp','meal-feed','alum','oilseed','gold','tin',
'strategic-metal','livestock','retail','ipi','iron-steel','rubber','heat','jobs',
'lei','bop','zinc','orange','pet-chem','dlr','gas','silver','wpi','hog','lead']
import os
import re
word_numbers_list = []
fnames = []
for fname in os.listdir('PredictData'):
with open('PredictData/' + fname, encoding='latin-1') as f:
text = f.read()
words = re.findall('[a-zA-Z0-9]+', text.lower())
word_numbers = [vocab_dict[word] + 3 for word in words]
word_numbers_list.append(word_numbers)
fnames.append(fname)
predict_dataset_x = vectorize(word_numbers_list, len(vocab_dict) + 3)
predict_result = model.predict(predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
for index, pi in enumerate(predict_indexes):
print(f'{fnames[index]} => {cats[pi]}')
# reverse transformation test
rev_vocab_dict = {index: word for word, index in vocab_dict.items()}
convert_text = lambda text_numbers: ' '.join([rev_vocab_dict[tn - 3] for tn in text_numbers if tn > 2])
print(convert_text(word_numbers_list[0]))
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
2024-07-22 23:31:13 +03:00
yapı ı ı
2024-06-09 22:37:05 +03:00
modele ekler. Böylece alı ı
iletilir. Tabii bu durumda bizim ağa girdi olarak vektörleri değil yazı ı ı
zaten yazı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
tv = TextVectorization(...)
...
model = Sequential(name='IMDB')
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
model.add(Input((1, ), dtype='string'))
2024-06-09 22:37:05 +03:00
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
Burada ağı ı ı ı ı
2024-07-22 23:31:13 +03:00
vereceğiz. Bu yazı ı
çı ı ı ı ı ı ı
aldı ı ı ı ı
yazı
girdi katmanı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
TextVectorization sı ı ı ı
Sı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
tf.keras.layers.TextVectorization(
max_tokens=None,
standardize='lower_and_strip_punctuation',
split='whitespace',
ngrams=None,
output_mode='int',
output_sequence_length=None,
pad_to_max_tokens=False,
vocabulary=None,
idf_weights=None,
sparse=False,
ragged=False,
encoding='utf-8',
name=None,
**kwargs
)
2024-04-02 13:01:04 +03:00
2024-06-30 23:07:28 +03:00
Görüldüğü gibi bu parametrelerin hepsi default değer almı ı ı
sözüğün vektörel hale getirilmesi için kullanı ı
içeriyor gibi olmaktadı ı ı ı ı
belirtmektedir. Bu parametrenin default değerinin 'lower_and_strip_punctuation' biçiminde olduğuna dikkat ediniz. Bu durumda
yazı ı ı
örneğin yazı ı ı ı
2024-07-22 23:31:13 +03:00
de girilebilmektedir. Girilen fonksiyon eğitim sı ı ı ı ı ı
2024-06-30 23:07:28 +03:00
split parametresi sözcüklerin nası ı ı ı
2024-07-22 23:31:13 +03:00
birbirinden ayrı ı ı
sözcük haznesindeki numaralar biçiminde verilecektir. Bu parametrenin "count" biçiminde girilmesi uygundur. Eğer bu parametre
"count" biçiminde girilirse bu durumda yazı
2024-06-30 23:07:28 +03:00
vocabulary parametresi doğrudan sözcük haznesinin programcı ı
Bu durumda adapt işleminde sözcük haznesi adapt tarafı ı ı
TextVectorization sı ı ı ı
vermektedir. set_vocabulary metodu ise sözcük haznesini set etmek için kullanı ı
TextVectorization nesnesi yaratı ı ı ı
için sı ı ı ı ı ı
tv = TextVectorization(output_mode='count')
tv.adapt(texts)
2024-04-02 13:01:04 +03:00
2024-06-30 23:07:28 +03:00
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.layers import TextVectorization
texts = ['film çok güzeldi', 'film güzeldi', 'film çok kötüydü', 'film ortalama bir filmdi']
tv = TextVectorization(output_mode='count')
tv.adapt(texts)
result = tv(['film güzeldi, film', 'film kötüydü'])
print(result)
result = tv.get_vocabulary()
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de TextVectorization katmanı ı ı ı ı
2024-07-22 23:31:13 +03:00
bu TextVectoriation katmanı ı
2024-06-30 23:07:28 +03:00
tv = TextVectorization(output_mode='count')
tv.adapt(dataset_x)
model = Sequential(name='IMDB')
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Tabii artı ı
yazı
predict_df = pd.read_csv('predict-imdb.csv')
predict_result = model.predict(predict_df)
2024-04-02 13:01:04 +03:00
2024-06-30 23:07:28 +03:00
Aşağı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
2024-06-30 23:07:28 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
dataset_x = df['review']
dataset_y = (df['sentiment'] == 'positive').astype(dtype='uint8')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(df['review'], dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense, TextVectorization
tv = TextVectorization(output_mode='count')
tv.adapt(dataset_x)
model = Sequential(name='IMDB')
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=5, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# prediction
predict_df = pd.read_csv('predict-imdb.csv')
predict_result = model.predict(predict_df)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
44. Ders - 09/06/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-30 23:07:28 +03:00
Çok büyük verilerle eğitim, test hatta predict işlemi sorunlu bir konudur. Çünkü örneğin fit işleminde büyük miktarda
2024-06-09 22:37:05 +03:00
veri kümeleriyle eğitim ve test yapı ı
kümeleri eldeki belleğe sı ı
çok büyükse de bu teorik sanal bellek alanı ı ı ı
IMDB ya da Reuters örneklerinde vektörizasyon işlemi sonucunda çok büyük matrisler oluşmaktadı
2024-07-22 23:31:13 +03:00
çok büyük kı ı ı
fit, evaluate ve predict metotları ı ı ı ı
verilerle eğitilip test ve predict edilebilmektedir. Parçalı
sı ı ı
batch-bacth verilere tedarik edilerek yapı
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Parçalı ı ı
2024-07-15 13:23:34 +03:00
"üretici fonksiyon (generator)" ya da "PyDataset sı ı ı ı ı
üretici fonksiyon yoluyla sonra da PyDataset sı ı ı ı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
göreceğiz. Eskiden Keras'ta normal fit, evaluate ve predict metotları ı ı
predict_generator biçiminde parçalı ı ı ı ı ı ı
fit, evaluate ve predcit metotları ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Üretici fonksiyon yoluyla parçalı
Artı ı
2024-07-22 23:31:13 +03:00
fonksiyonden elde edilen verilerle yapı ı ı ı ı
2024-06-09 22:37:05 +03:00
kullanı ı ı ı
anlamı ı ı ı ı ı ı ı ı
verilmesi de yine uygulamacı ı ı ı ı ı
gerekir. Birincisi steps_per_epoch parametresidir. Bu parametre bir epoch işleminin kaç batch işleminden oluşacağı ı
İkinci parametre ise epochs parametresidir. Bu da yine toplam epoch sayı ı ı
1 olduğunu anı ı ı ı ı ı
gerekir. Çünkü toplam batch sayı ı ı ı
bir daha next işlemi yaparak üretici fonksiyonun bitmesine yol açmaktadı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı ı
2024-06-09 22:37:05 +03:00
Ancak bu örnekte x ve y verileri üretici fonksiyonlardan elde edilmiştir. Üretici fonksiyon içerisinde toplam
2024-07-22 23:31:13 +03:00
epochs * steps_per_epoch kadar yield işlemi yapı ı ı ı ı ı ı
2024-06-09 22:37:05 +03:00
rastgele verilerle yalnı ı ı ı
biçimde oluşturulmuşsa bir kalı ı ı ı
beklenir.)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-06-09 22:37:05 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
EPOCHS = 100
2024-06-09 22:37:05 +03:00
NFEATURES = 10
2024-04-02 13:01:04 +03:00
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
2024-06-09 22:37:05 +03:00
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
2024-04-02 13:01:04 +03:00
yield x, y
2024-06-09 22:37:05 +03:00
model = Sequential(name='Diabetes')
2024-07-15 13:23:34 +03:00
model.add(Input((NFEATURES, )))
2024-06-09 22:37:05 +03:00
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-06-09 22:37:05 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-06-09 22:37:05 +03:00
model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Yukarı ı ı ı ı ı
verilebilmektedir. Bunun için yine fit metodunun validation_data parametresine bir üretici fonksiyon nesnesi girilir. fit
metodu da her epcoh sonrası
yaparak bizden sı ı ı ı ı
2024-07-15 13:23:34 +03:00
üretici fonksiyon nesnesi yoluyla parça parça vermiş oluruz.
2024-06-09 22:37:05 +03:00
Aşağı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-06-09 22:37:05 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
EPOCHS = 100
NFEATURES = 10
2024-04-02 13:01:04 +03:00
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
2024-06-09 22:37:05 +03:00
VALIDATION_STEPS = 10
2024-04-02 13:01:04 +03:00
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
2024-06-09 22:37:05 +03:00
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
yield x, y
def validation_generator():
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
2024-04-02 13:01:04 +03:00
for _ in range(EPOCHS):
2024-07-15 13:23:34 +03:00
for _ in range(VALIDATION_STEPS):
2024-04-02 13:01:04 +03:00
yield x, y
2024-06-09 22:37:05 +03:00
model = Sequential(name='Diabetes')
2024-07-15 13:23:34 +03:00
model.add(Input((NFEATURES,)))
2024-06-09 22:37:05 +03:00
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-06-09 22:37:05 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-06-09 22:37:05 +03:00
model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH,
validation_data=validation_generator(), validation_steps=VALIDATION_STEPS)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:37:05 +03:00
Parçalı ı ı ı ı
yerine yine bir üretici fonksiyon nesnesi girilir. evaluate metodunun steps parametresi bizden test verilerinin kaç parça
olarak isteneceğini belirtmektedir. Yani programcı ı ı ı ı
bir örnek verilmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-06-09 22:37:05 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
EPOCHS = 100
NFEATURES = 10
2024-04-02 13:01:04 +03:00
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
2024-06-09 22:37:05 +03:00
VALIDATION_STEPS = 10
EVALUATION_STEPS = 15
2024-04-02 13:01:04 +03:00
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
2024-06-09 22:37:05 +03:00
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
yield x, y
def validation_generator():
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
2024-04-02 13:01:04 +03:00
for _ in range(EPOCHS):
for _ in range(VALIDATION_STEPS + 1):
yield x, y
2024-06-09 22:37:05 +03:00
def evaluation_generator():
for _ in range(EVALUATION_STEPS):
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
2024-04-02 13:01:04 +03:00
yield x, y
2024-06-09 22:37:05 +03:00
model = Sequential(name='Diabetes')
model.add(Input(NFEATURES, ))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_data=validation_generator(), validation_steps=VALIDATION_STEPS)
eval_result = model.evaluate(evaluation_generator(), steps=EVALUATION_STEPS)
#----------------------------------------------------------------------------------------------------------------------------
2024-06-30 23:07:28 +03:00
Benzer biçimde predict metodunda da kesitirimi yapı
2024-07-22 23:31:13 +03:00
predict metodunun x parametresine bir üretici fonksiyon nesnesi girilir. predcit metonunun da kestirim verilerininin kaç
parça olarak isteneceğine yönelik steps parametresi vardı ı ı ı ı ı
x değerlerini vermelidir. Aşağı
2024-06-09 22:37:05 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-06-09 22:37:05 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
EPOCHS = 100
NFEATURES = 10
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
VALIDATION_STEPS = 10
EVALUATION_STEPS = 15
PREDICTION_STEPS = 5
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
yield x, y
def validation_generator():
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
for _ in range(EPOCHS):
for _ in range(VALIDATION_STEPS + 1):
yield x, y
def evaluation_generator():
for _ in range(EVALUATION_STEPS):
x = np.random.random((BATCH_SIZE, NFEATURES))
y = np.random.randint(0, 2, BATCH_SIZE)
yield x, y
def prediction_generator():
for _ in range(PREDICTION_STEPS):
x = np.random.random((BATCH_SIZE, NFEATURES))
yield x
model = Sequential(name='Diabetes')
model.add(Input(NFEATURES, ))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-06-09 22:37:05 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-06-09 22:37:05 +03:00
model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_data=validation_generator(), validation_steps=VALIDATION_STEPS)
2024-04-02 13:01:04 +03:00
2024-06-09 22:37:05 +03:00
eval_result = model.evaluate(evaluation_generator(), steps=EVALUATION_STEPS)
predict_result = model.predict(prediction_generator(), steps=PREDICTION_STEPS)
2024-06-30 23:07:28 +03:00
#----------------------------------------------------------------------------------------------------------------------------
45. Ders - 29/06/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Şimdi de gerçekten bellekte büyük bir yer kaplayan ve vektörizasyon işlemi gerektiren bir örneği parçalı
2024-06-30 23:07:28 +03:00
ve test edelim. Bu örnek için IMDB veri kümesini kullanalı ı ı ı ı ı
işleminin nası ı ı ı ı
karı ı ı ı ı ı ı ı ı ı ı ı ı ı
ile belirlenebilmektedir. Bu paramerenin default değeri True biçimindedir.) Parçalı ı ı
parametresinin bir etkisi yoktur. Dolayı ı ı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
fonksiyon içerisinde yapı ı ı ı ı ı ı ı ı ı ı ı ı ı
2024-06-30 23:07:28 +03:00
uygun bir yöntem değildir. Bu durumda birkaç yöntem izlenebilir:
1) Veri kümesi yine read_csv fonksiyonu ile tek hamlede belleğe okunabilir. Her batch işleminde bellekteki ilgili batch'lik
kı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
bir tezat oluşturmaktadı ı
2024-06-30 23:07:28 +03:00
edilen matris olduğu için bu yöntem kullanı
2) Veri kümesi bir kez okunup dosyadaki kaydı ı ı ı ı ı
dizinin elemanları ı ı ı ı ı
yürütülebilir.
2024-07-15 13:23:34 +03:00
Pekiyi biz vektörizasyon işlemini TextVectorization sı ı ı ı ı
belleğe çekmek zorunda değil miyiz? Aslı ı ı ı ı
Dataset nesnesini de parametre olarak alabilmektedir. Bu sayede biz bir Dataset nesnesi oluşturarak adapt metodunun da
verileri parçalı ı ı ı ı ı ı
da aslı ı ı ı ı ı
fonksiyonlar yoluyla biz verileri fit metoduna parça parça verebilmekteyiz. Dosya nesneslerinin de dolaşı
olduğunu anı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
46. Ders - 30/06/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Örne üzerinde çalı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
47. Ders - 06/07/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı ı ı ı ı
karı ı ı ı ı ı ı ı ı
sayı ı ı ı ı
2024-07-15 13:23:34 +03:00
yazdı
2024-07-22 23:31:13 +03:00
# convert_imdb.py
2024-07-15 13:23:34 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv', encoding='latin-1')
for index, text in enumerate(df['review']):
rtext = text.replace('\n', ' ')
rtext = rtext.replace('\r', ' ')
df.iloc[index, 0] = rtext
df.to_csv('imdb.csv', index=False)
2024-07-22 23:31:13 +03:00
Burada program hedef olarak "imdb.csv" dosyası ı ı ı ı ı
biçiminde oluşturabiliriz:
2024-07-15 13:23:34 +03:00
def record_offsets(f, skiprows=1):
offsets = []
for i in range(skiprows):
f.readline()
offsets.append(f.tell())
while f.readline() != '':
offsets.append(f.tell())
offsets.pop()
return offsets
2024-07-22 23:31:13 +03:00
Burada biz her satı ı ı ı ı
işleminden sonra sakladı ı ı ı ı ı
dikkat ediniz. Programı ı ı ı ı
2024-07-15 13:23:34 +03:00
def data_generator(f, epochs, steps_per_epoch, batch_size, offsets):
reader = csv.reader(f)
for _ in range(epochs):
random.shuffle(offsets)
for batch_no in range(steps_per_epoch):
x = []
y = []
for offset in offsets[batch_no * batch_size: batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
y.append(1 if result[1] == 'positive' else 0)
yield tf.convert_to_tensor(x), tf.convert_to_tensor(y)
Bu örneğimizde sı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
import math
import random
import csv
import pandas as pd
import tensorflow as tf
2024-04-02 13:01:04 +03:00
EPOCHS = 5
BATCH_SIZE = 32
2024-07-15 13:23:34 +03:00
def record_offsets(f, skiprows=1):
offsets = []
for i in range(skiprows):
f.readline()
offsets.append(f.tell())
while f.readline() != '':
offsets.append(f.tell())
offsets.pop()
return offsets
f = open('imdb.csv', encoding='latin-1')
offsets = record_offsets(f)
def data_generator(f, epochs, steps_per_epoch, batch_size, offsets):
reader = csv.reader(f)
for _ in range(epochs):
random.shuffle(offsets)
for batch_no in range(steps_per_epoch):
x = []
y = []
for offset in offsets[batch_no * batch_size: batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
y.append(1 if result[1] == 'positive' else 0)
yield tf.convert_to_tensor(x), tf.convert_to_tensor(y)
df = pd.read_csv('imdb.csv')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense, TextVectorization
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
tv = TextVectorization(output_mode='count')
tv.adapt(df['review'])
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
model = Sequential(name='IMDB')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(data_generator(f, EPOCHS, math.ceil(len(offsets) / BATCH_SIZE), BATCH_SIZE, offsets),
batch_size=BATCH_SIZE, steps_per_epoch=math.ceil(len(offsets) / BATCH_SIZE), epochs=EPOCHS)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.legend(['Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
predict_result = model.predict(predict_df)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Peki parçalı ı ı ı ı
Evet bu işlemlerin hepsi parçalı ı
2024-07-22 23:31:13 +03:00
nesne olarak (ya da bir PyDataset nesnesi olarak) girilirse bu durumda her epoch'tan sonra sı
fonksiyondan (ya da PyDataset nesnesinden) elde edilecektir. Ancak bu durumda fit metodunun validation_steps parametresinde
kaç dolaşı ı
2024-07-15 13:23:34 +03:00
2024-07-22 23:31:13 +03:00
model.fit(..., validation_data=validation_generator(), validation_steps=100)
2024-07-15 13:23:34 +03:00
2024-07-22 23:31:13 +03:00
Burada sı ı ı ı ı
2024-07-15 13:23:34 +03:00
sı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
Test işlemi de benzer biçimde parçalı ı ı ı ı ı
bir üretici nesne (ya da bir PyDataset nesnesi) girilir. Test işlemi yapı ı ı ı
parametresiyle belirtilmektedir. Örneğin:
2024-07-15 13:23:34 +03:00
eval_result = model.evalute(test_generator(), steps=32)
Kestirim işleminde parçalı ı ı ı
verilerle yapı ı ı ı ı
PyDataset nesnesi) nesne gerilir. Yine metodun steps parametresi sı ı ı ı
(yani yield yapı ı ı
predict_result = model.predict(predict_generator(), steps=32)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Aşağı ı ı ı ı ı
kestirim işlemlerine örnek verilmiştir. Sı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
def training_validation_test_generator(f, epochs, steps, batch_size, offsets, shuffle=False):
2024-07-22 23:31:13 +03:00
reader = csv.reader(f)
for _ in range(epochs):
if shuffle:
random.shuffle(offsets)
for batch_no in range(steps):
x = []
y = []
for offset in offsets[batch_no * batch_size: batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
y.append(1 if result[1] == 'positive' else 0)
yield tf.convert_to_tensor(x), tf.convert_to_tensor(y)
2024-07-15 13:23:34 +03:00
Fonksiyonda eopchs * steps kadar yield işlemi yapı ı ı ı
amacı ı ı ı ı
1 olarak grilmiştir. Yukarı ı ı
Ancak biz burada parçalı ı ı
def predict_generator(f, steps, batch_size, offsets):
reader = csv.reader(f)
for batch_no in range(steps):
x = []
for offset in offsets[batch_no * batch_size:batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
yield tf.convert_to_tensor(x),
Parçalı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import math
import random
import csv
import pandas as pd
import tensorflow as tf
EPOCHS = 5
BATCH_SIZE = 32
TEST_RATIO = 0.2
VALIDATION_RATIO = 0.2
def record_offsets(f, skiprows=1):
offsets = []
for i in range(skiprows):
f.readline()
offsets.append(f.tell())
while f.readline() != '':
offsets.append(f.tell())
offsets.pop()
return offsets
f = open('imdb.csv', encoding='latin-1')
offsets = record_offsets(f)
random.shuffle(offsets)
test_split_index = int(len(offsets) * (1 - TEST_RATIO))
validation_split_index = int(test_split_index * (1 - VALIDATION_RATIO))
training_offsets = offsets[:validation_split_index]
validation_offsets = offsets[validation_split_index:test_split_index]
test_offsets = offsets[test_split_index:]
training_steps = math.ceil(len(training_offsets) / BATCH_SIZE)
validation_steps = math.ceil(len(validation_offsets)/BATCH_SIZE)
test_steps = math.ceil(len(test_offsets)/BATCH_SIZE)
def training_validation_test_generator(f, epochs, steps, batch_size, offsets, shuffle=False):
reader = csv.reader(f)
for _ in range(epochs):
if shuffle:
random.shuffle(offsets)
for batch_no in range(steps):
x = []
y = []
for offset in offsets[batch_no * batch_size: batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
y.append(1 if result[1] == 'positive' else 0)
yield tf.convert_to_tensor(x), tf.convert_to_tensor(y)
def predict_generator(f, steps, batch_size, offsets):
reader = csv.reader(f)
for batch_no in range(steps):
x = []
for offset in offsets[batch_no * batch_size:batch_no * batch_size + batch_size]:
f.seek(offset, 0)
result = next(reader)
x.append(result[0])
yield tf.convert_to_tensor(x),
df = pd.read_csv('imdb.csv')
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-07-15 13:23:34 +03:00
from tensorflow.keras.layers import Input, Dense, TextVectorization
tv = TextVectorization(output_mode='count')
tv.adapt(df['review'])
2024-04-02 13:01:04 +03:00
model = Sequential(name='IMDB')
2024-07-15 13:23:34 +03:00
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-07-15 13:23:34 +03:00
hist = model.fit(training_validation_test_generator(f,
EPOCHS, training_steps, BATCH_SIZE, training_offsets, True),
batch_size=BATCH_SIZE,
steps_per_epoch=training_steps,
epochs=EPOCHS,
validation_data=training_validation_test_generator(f, EPOCHS, validation_steps, BATCH_SIZE, validation_offsets),
validation_steps=validation_steps)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
2024-07-15 13:23:34 +03:00
plt.legend(['Loss'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-07-15 13:23:34 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-07-15 13:23:34 +03:00
eval_result = model.evaluate(training_validation_test_generator(f, 1, test_steps, BATCH_SIZE, test_offsets), steps=test_steps)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-07-15 13:23:34 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
predict_f = open('predict-imdb.csv')
predict_offsets = record_offsets(predict_f)
predict_steps = int(math.ceil(len(predict_offsets) / BATCH_SIZE))
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
predict_result = model.predict(predict_generator(predict_f, predict_steps, BATCH_SIZE, predict_offsets), steps=predict_steps)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
48. Ders - 07/07/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Parçalı ı ı ı
için tensorflow.keras.utils modülü içerisindeki PyDataset sı ı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
öncesine kadar bu amaçla Sequence isimli bir sı ı ı ı
içerisindeki Dataset sı ı ı ı ı ı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
2024-07-22 23:31:13 +03:00
Parçalı ı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı
sı ı ı ı ı ı ı ı ı ı
__getitem__ metodunu çağı ı ı ı ı ı ı
büyüklüğü kadar x ve y verisinden oluşan bir demetle geri dönmelidir. (Tabii aslı
defası ı ı ı ı
türünden bir nesne yaratarak o nesneyi girer. Örneğin:
2024-07-15 13:23:34 +03:00
class DataGenerator(PyDataset):
def __init__(self):
super().__init__()
pass
def __len__(self):
pass
def __getitem__(self, batch_no):
pass
...
model.fit(DataGenrator(...), epochs=100)
Tabii artı ı ı
2024-07-22 23:31:13 +03:00
bu yöntemde bir anlamı ı ı ı ı
2024-07-15 13:23:34 +03:00
Sı ı ı ı ı ı ı ı ı
__getitem__ metotları ı ı ı
edilecektir. Programcı ı ı ı ı ı
nesne girer. Örneğin:
model.fit(DataGenrator(...), epochs=100, validation_data=DataGenerator(....))
Ayrı ı ı ı ı ı ı ı ı
epoch bittiğinde fit tarafı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
Bu biçimdeki parçalı ı ı ı
metodu tarafı ı ı ı ı
sı ı ı
2024-07-15 13:23:34 +03:00
2024-07-20 14:48:03 +03:00
Bu yöntemde predict işlemi de yine benzer biçimde parçalı
işleminde bir epoch kavramı ı ı
2024-07-15 13:23:34 +03:00
Uygulamada parçalı ı ı ı
edilmektedir. Bu yöntemi uygulamak daha kolaydı ı ı ı
2024-04-02 13:01:04 +03:00
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
2024-07-15 13:23:34 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.utils import PyDataset
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
EPOCHS = 2
NFEATURES = 10
2024-04-02 13:01:04 +03:00
BATCH_SIZE = 32
2024-07-15 13:23:34 +03:00
class DataGenerator(PyDataset):
def __init__(self, batch_size, nfeatures, *, steps):
2024-04-02 13:01:04 +03:00
super().__init__()
2024-07-15 13:23:34 +03:00
self.batch_size = batch_size
self.nfeatures = nfeatures
self.steps = steps
2024-04-02 13:01:04 +03:00
def __len__(self):
2024-07-15 13:23:34 +03:00
return self.steps
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
def __getitem__(self, batch_no):
x = np.random.random((self.batch_size, self.nfeatures))
y = np.random.randint(0, 2, self.batch_size)
2024-04-02 13:01:04 +03:00
return x, y
def on_epoch_end(self):
2024-07-15 13:23:34 +03:00
print('shuffle')
model = Sequential(name='Test')
model.add(Input((NFEATURES, )))
model.add(Dense(16, activation='relu', name='Hidden-1'))
model.add(Dense(16, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
model.fit(DataGenerator(BATCH_SIZE, NFEATURES, steps=50), epochs=EPOCHS, validation_data=DataGenerator(BATCH_SIZE, NFEATURES, steps=5))
eval_result = model.evaluate(DataGenerator(BATCH_SIZE, NFEATURES, steps=10))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_result = model.predict(DataGenerator(BATCH_SIZE, NFEATURES, steps=1))
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
biz bir tane DataGenerator sı ı ı ı
işleminde aynı ı ı ı ı ı ı ı ı
benzerdir. Yukarı ı ı ı
etmekteyiz.
#----------------------------------------------------------------------------------------------------------------------------
import math
import random
import csv
import pandas as pd
import tensorflow as tf
from tensorflow.keras.utils import PyDataset
EPOCHS = 5
BATCH_SIZE = 32
TEST_RATIO = 0.2
VALIDATION_RATIO = 0.2
def record_offsets(f, skiprows=1):
offsets = []
for i in range(skiprows):
f.readline()
offsets.append(f.tell())
while f.readline() != '':
offsets.append(f.tell())
offsets.pop()
return offsets
f = open('imdb.csv', encoding='latin-1')
offsets = record_offsets(f)
random.shuffle(offsets)
test_split_index = int(len(offsets) * (1 - TEST_RATIO))
validation_split_index = int(test_split_index * (1 - VALIDATION_RATIO))
training_offsets = offsets[:validation_split_index]
validation_offsets = offsets[validation_split_index:test_split_index]
test_offsets = offsets[test_split_index:]
training_steps = math.ceil(len(training_offsets) / BATCH_SIZE)
validation_steps = math.ceil(len(validation_offsets)/BATCH_SIZE)
test_steps = math.ceil(len(test_offsets)/BATCH_SIZE)
class DataGenerator(PyDataset):
def __init__(self, f, steps, batch_size, offsets, *, shuffle=False, predict=False):
super().__init__()
self.f = f
self.steps = steps
self.batch_size = batch_size
self.offsets = offsets
self.shuffle = shuffle
self.predict = predict
self.reader = csv.reader(f)
def __len__(self):
return self.steps
def __getitem__(self, batch_no):
x = []
if not self.predict:
y = []
for offset in self.offsets[batch_no * self.batch_size: batch_no * self.batch_size + self.batch_size]:
f.seek(offset, 0)
result = next(self.reader)
x.append(result[0])
if not self.predict:
y.append(1 if result[1] == 'positive' else 0)
if not self.predict:
return tf.convert_to_tensor(x), tf.convert_to_tensor(y)
return tf.convert_to_tensor(x),
def on_pech_end(self):
random.shuffle(self.offsets)
df = pd.read_csv('imdb.csv')
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-07-15 13:23:34 +03:00
from tensorflow.keras.layers import Input, Dense, TextVectorization
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
tv = TextVectorization(output_mode='count')
tv.adapt(df['review'])
model = Sequential(name='IMDB')
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-07-15 13:23:34 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-07-15 13:23:34 +03:00
hist = model.fit(DataGenerator(f, training_steps, BATCH_SIZE, training_offsets, shuffle=True),
epochs=EPOCHS,
validation_data = DataGenerator(f, validation_steps, BATCH_SIZE, validation_offsets))
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.legend(['Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
eval_result = model.evaluate(DataGenerator(f, test_steps, BATCH_SIZE, test_offsets))
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-07-15 13:23:34 +03:00
# prediction
predict_f = open('predict-imdb.csv')
predict_offsets = record_offsets(predict_f)
predict_steps = int(math.ceil(len(predict_offsets) / BATCH_SIZE))
predict_result = model.predict(DataGenerator(f, predict_steps, BATCH_SIZE, predict_offsets, predict=True))
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
49. Ders - 13/07/2024 - Cumartesi
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Pekiyi biz parçalı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
konuda çok açı ı ı ı ı ı ı
görülmektedir. Yani birden fazla kez fit metodu çağrı ı ı ı
biz eğitimi farklı
2024-07-22 23:31:13 +03:00
birden fazla kez çağrı ı ı ı
eğitimler için daha aşağı ı ı
çağı ı ı ı ı ı ı ı ı ı
bulundurulmuştur:
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
train_on_batch
test_on_batch
predict_on_batch
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Ancak bu yöntemde sı ı ı ı ı ı ı
yapması
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
train_on_batch metodunun parametrik yapı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
train_on_batch(x, y=None, sample_weight=None, class_weight=None, return_dict=False)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Burada x ve y parametreleri parçalı ı ı
parametreleri ağı ı ı ı ı
2024-07-22 23:31:13 +03:00
olarak loss değerini ve metrik değerleri bir sözlük nesnesi biçiminde verir.
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
train_on_batch metodu ile parçalı ı ı ı
döngüsünü ve batch döngüsünü programcı ı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
for epoch in range(EPOCHS):
<eğitim veri kümesi karı ı ı ı
for batch_no in range(NBATCHES):
<bir batch'lik x ve y elde ediliyor>
model.train_on_batch(x, y)
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Tabii yukarı ı ı ı ı ı
yapması ı ı ı
de biz tüm epoch'lara ilişkin metrik değerleri elde edebiliyorduk. train_on_batch işlemleriyle eğitimde bu bu değerleri
bizim elde etmemiz gerekmektedir. train_on_batch metodunun return_dict parametresi True geçilirse batch işlemi sonucundaki
loss ve metik değerler bize bir sözlük biçiminde verilmektedir. Biz de bu değerlerden hareketle epoch'taki ortalama loss ve
metrik değerleri hesaplayabiliriz. Örneğin:
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
for epoch in range(EPOCHS):
<eğitim veri kümesi karı ı ı ı
for batch_no in range(NBATCHES):
<bir batch'lik x ve y elde ediliyor>
rd = model.train_on_batch(x, y, return_dict=True)
2024-07-22 23:31:13 +03:00
<batch'e ilişkin loss ve metrik değerler epoch için ortalama hesabı ı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Burada her spoch sonrası ı ı
ya da PyTorch kütüphanelerini aşağı ı
yapmak durumunda kalacaktı ı ı ı
değeri olarak kullanmaktadı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Bu yöntemde epoch sonrası ı ı ı ı ı
2024-07-22 23:31:13 +03:00
Yani programcı ı ı ı ı ı ı
amaçlı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
for epoch in range(EPOCHS):
<eğitim veri kümesi karı ı ı ı
for batch_no in range(NBATCHES):
<bir batch'lik x ve y elde ediliyor>
rd = model.train_on_batch(x, y, return_dict=True)
2024-07-22 23:31:13 +03:00
val_result = model.evaluate(...)
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Tabii burada evaluate işlemini de parçalı
fonksiyonunu kullanabilirsiniz. test_on_batch metodunun parametrik yapı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
test_on_batch(x, y=None, sample_weight=None, return_dict=False)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Kullanı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Test işlemi de tüm epoch'lar bittiğinde yine parçalı ı
2024-07-22 23:31:13 +03:00
yine benzer bir biçimde predict_on_batch metoduyla yapı ı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
predict_on_batch(x)
Metot kestirim değerleriyle geri dönmektedir. Örneğin:
for batch_no in range(NBATCHES):
<bir batch'lik x elde ediliyor>
2024-07-22 23:31:13 +03:00
predict_result = model.predict_on_batch(x)
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
50. Ders - 14/07/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Aşağı ı ı ı ı
Bu örnekte tüm veri kümesi tek hamlede DataFrame nesnesi olarak okunmuştur. Aslı ı
yapmı ı ı
hamlede okuyup xxx_on_batch metotları ı
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense, TextVectorization
EPOCHS = 5
BATCH_SIZE = 32
TEST_SPLIT_RATIO = .20
VALIDATION_SPLIT_RATIO = .20
def create_model(df):
tv = TextVectorization(output_mode='count')
tv.adapt(df['review'])
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
model = Sequential(name='IMDB')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
model.add(Input((1, ), dtype='string'))
model.add(tv)
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
return model
def train_test_model(training_df, validation_df, epochs, verbose = 1):
history_loss = []
history_accuracy = []
val_history_loss = []
val_history_accuracy = []
for epoch in range(epochs):
training_df = training_df.sample(frac=1)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
print('-' * 30)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
mean_loss, mean_accuracy = batch_train(training_df, int(np.ceil(len(training_df) / BATCH_SIZE)), model.train_on_batch, verbose=1)
history_loss.append(mean_loss)
history_accuracy.append(mean_accuracy)
if verbose == 1:
print(f'Epoch: {epoch + 1}')
print(f'Epoch mean loss: {mean_loss}, Epoch Binary Accuracy: {mean_accuracy}')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
val_mean_loss, val_mean_accuracy = batch_train(validation_df, int(np.ceil(len(validation_df) / BATCH_SIZE)), model.test_on_batch)
val_history_loss.append(val_mean_loss)
val_history_accuracy.append(val_mean_accuracy)
if verbose == 1:
print(f'Validation Loss: {val_mean_loss}, Validation Binary Accuracy: {val_mean_accuracy}')
return history_loss, history_accuracy, val_history_loss, val_history_accuracy
def batch_train(df, nbatches, batch_method, verbose=0):
loss_list = []
accuracy_list = []
for batch_no in range(nbatches):
x = tf.convert_to_tensor(df['review'].iloc[batch_no * BATCH_SIZE: batch_no * BATCH_SIZE + BATCH_SIZE], dtype='string')
y = tf.convert_to_tensor(df['sentiment'].iloc[batch_no * BATCH_SIZE: batch_no * BATCH_SIZE + BATCH_SIZE])
rd = batch_method(x, y, return_dict=True)
loss_list.append(rd['loss'])
accuracy_list.append(rd['binary_accuracy'])
if verbose:
print(f'Batch No: {batch_no}')
if verbose == 2:
print(f"Batch Loss: {rd['loss']}, Batch Binary Accuracy: {rd['accuracy']}")
mean_loss = np.mean(loss_list)
mean_accuracy = np.mean(accuracy_list)
return mean_loss, mean_accuracy
df = pd.read_csv('IMDB Dataset.csv').iloc[:10000, :]
df['sentiment'] = (df['sentiment'] == 'positive').astype(dtype='uint8')
df = df.sample(frac=1)
test_zone = int(len(df) * (1 - TEST_SPLIT_RATIO))
training_validation_df = df.iloc[:test_zone, :]
test_df = df.iloc[test_zone:, :]
validation_zone = int(len(training_validation_df) * (1 - VALIDATION_SPLIT_RATIO))
training_df = training_validation_df.iloc[:validation_zone, :]
validation_df = training_validation_df.iloc[validation_zone:, :]
model = create_model(df)
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
history_loss, history_accuracy, val_history_loss, val_history_accuracy = train_test_model(training_df, validation_df, EPOCHS)
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, EPOCHS))
plt.plot(range(EPOCHS), history_loss)
plt.plot(range(EPOCHS), val_history_loss)
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, EPOCHS))
plt.plot(range(EPOCHS), history_accuracy)
plt.plot(range(EPOCHS), val_history_accuracy)
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
# evaluation
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
eval_mean_loss, eval_accuracy = batch_train(test_df, int(np.ceil(len(test_df) / BATCH_SIZE)), model.test_on_batch)
print(f'Test Loss: {eval_mean_loss}, Test Binary Accuracy: {eval_accuracy}')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
# prediction
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
for i in range(int(np.ceil(len(predict_df) / BATCH_SIZE))):
predict_result = model.predict_on_batch(predict_df)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Kursumuzun bu noktası ı
NumPy ---> Vektörel işlemler yapan C'de yazı ı
kullanmaktadı
Pandas ---> Bu kütüphane sütunlu veri yapı ı ı ı ı ı ı
Kütüphanenin en önemli özelliği farklı ı ı
edilmesini sağlaması ı ı ı ı ı
scikit-learn ---> Bir makine öğrennesi kütüphanesidir. Ancak bu kütüphanede yapay sinir ağları
(minimal düzeydedir). Yani bu kütüphane yapay sinir ağları ı ı ı ı ı
scikit-learn kendi içerisinde NumPy, Pandas ve SciPy kütüphanelerini kullanmaktadı
SciPy ---> Genel amaçlı
yoktur. Ancak matematiğin çeşitli alanları
de kendi içerisinde NumPy ve Pandas kullanı ı ı ı
TensorFlow ---> Google tarafı ı
çok işlemcili ve çekirdekli sistemlerde matrisler (bunlara "tensor" de denilmektedir) üzerinde paralel programlama teknikleriyle
işlemler yapabilmek amacı ı ı
Keras ---> Yapay sinir ağı ı
kütüphane "backend" olarak farklı
içerisine dahil edilmiştir ve TensorFlow kütüphanesinin yüksek seviyeli bir katmanı
PyTorch ---> Tamamen TensorFlow kütüphanesinde hedeflenen işlemleri yapan taban bir yapay sinir ağı
kütüphanesidir. Facebook (Meta) tarafı
Theano --> TensorFlow, PyTorch SciPy benzeri bir taban kütüphanedir. Akademik çevreler tarafı
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Elemanları ı ı ı
0 olan elemanları ı ı ı ı
2024-07-22 23:31:13 +03:00
kabul edilen bir seyreklik oranı ı ı
veri yapı ı ı ı ı ı ı
Örneğin bir grup yazı ı ı ı
dönüştürmesi de bir seyrek matris oluşturmaktadı ı ı ı ı
sı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Seyrek matrislerin daha az yer kaplayacak biçimde tutulması ı ı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
ve onları ı ı ı ı ı
2024-07-22 23:31:13 +03:00
faklı ı ı
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Seyrek matrisleri ifade etmek için alternatif birkaç veri yapı ı ı ı
denilen veri yapı ı ı ı ı ı ı ı
biçimi aşağı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
{(34674,17000): 1, (542001, 170): 4, ...}
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Burada sözlüğün anahtarları ı ı ı
sütundaki matris değerlerinden oluşmaktadı ı
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
0 0 5
3 0 0
0 6 0
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
Buradaki dok sözlüğü şöyle olacaktı
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
{(0, 2): 5, (1, 0): 3, (2, 1): 6}
2024-07-15 13:23:34 +03:00
Aşağı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
class DokMatrix:
2024-07-15 13:23:34 +03:00
def __init__(self, nrows, ncols):
self._nrows = nrows
self._ncols = ncols
self._dok = {}
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
def __getitem__(self, index):
2024-04-02 13:01:04 +03:00
if not isinstance(index, tuple) or len(index) != 2:
2024-07-15 13:23:34 +03:00
raise TypeError('index must have twho dimension')
if index[0] < 0 or index[0] >= self._nrows:
raise IndexError('index out of range')
if index[1] < 0 or index[1] >= self._ncols:
raise IndexError('index out of range')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
return self._dok.get(index, 0)
def __setitem__(self, index, val):
if not isinstance(index, tuple) or len(index) != 2:
raise TypeError('index must have twho dimension')
if index[0] < 0 or index[0] >= self._nrows:
raise IndexError('index out of range')
if index[1] < 0 or index[1] >= self._ncols:
raise IndexError('index out of range')
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
self._dok[index] = val
@property
def shape(self):
return self._nrows, self._ncols
@property
def size(self):
return self._nrows * self._ncols
def __len__(self):
return self._nrows
@staticmethod
def array(a):
if not isinstance(a, list):
raise TypeError('argument must be Python list')
nrows = len(a)
ncols = len(a[0])
for i in range(1, nrows):
if len(a[i]) != ncols:
raise ValueError('matrix rows must have the same number of elements')
dm = DokMatrix(nrows, ncols)
for i in range(nrows):
for k in range(ncols):
if a[i][k] != 0:
dm._dok[(i, k)] = a[i][k]
return dm
2024-04-02 13:01:04 +03:00
def todense(self):
2024-07-15 13:23:34 +03:00
array = np.zeros((self._nrows, self._ncols))
for index, val in self._dok.items():
array[index] = val
return array
def __str__(self):
smatrix = ''
for i in range(self._nrows):
sline = ''
for k in range(self._ncols):
if sline != '':
sline += ' '
sline += str(self._dok.get((i, k), 0))
if smatrix != '':
smatrix += '\n'
smatrix += sline
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
return smatrix
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
def __repr__(self):
smatrix = ''
for index, val in self._dok.items():
if smatrix != '':
smatrix += '\n'
smatrix += f'({index[0]}, {index[1]}) ---> {val}'
return smatrix
a = [[1, 0, 3], [0, 0, 1], [5, 0, 0]]
dok = DokMatrix.array(a)
print(dok)
print('-' * 10)
dok[1, 1] = 8
print(dok)
print('-' * 10)
print(repr(dok))
2024-04-02 13:01:04 +03:00
2024-07-15 13:23:34 +03:00
#----------------------------------------------------------------------------------------------------------------------------
NumPy kütüphanesi içerisinde seyrek matrislerle işlem yapan sı ı ı
kütüphanesi içerisinde seyrek matrislerle ilgili işlemler yapan sı ı ı
doğrudan SciPy kütüphanesinin seyrek matris sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
DOK biçimindeki seyrek matrisler SciPy kütüphanesinde scipy.sparse modülü içerisindeki dok_matrix sı ı ı
Biz bir dok_marix sı ı ı ı
2024-07-22 23:31:13 +03:00
dizisiymiş gibi onu kullanabiliriz. Seyrek matrisi normal bir NumPy dizisine dönüştürmek için sı ı ı
2024-07-15 13:23:34 +03:00
metotları ı ı
from scipy.sparse import dok_matrix
dok = dok_matrix((10, 10), dtype='int32')
dok[1, 3] = 10
dok[3, 5] = 20
a = dok.todense()
print(dok)
print('-' * 20)
print(a)
dok_matrix sı ı ı ı ı ı ı ı ı ı
dı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import dok_matrix
dok = dok_matrix((1000, 1000), dtype='int32')
dok[3, 6] = 100
dok[30, 7] = 200
print(dok[3, 6])
print(dok[30, 60])
print(dok)
a = dok.todense()
print(a)
print(dok)
#----------------------------------------------------------------------------------------------------------------------------
Bir dok_matrix nesnesi Python listelerinden ya da NumPy dizilerinden de oluşturulabilir.
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import dok_matrix
dok = dok_matrix([[1, 0, 0], [1, 0, 0], [0, 0, 1]], dtype='int32')
print(dok)
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Bir seyrek matris nesnesi ile biz NumPy dizileri üzerinde yaptı ı ı
seyrek matrisi dilimleyebiliriz. Bu durumda yine bir seyrek matris elde ederiz. dok_matrix sı ı ı ı ı
anahtarları ı
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Biz seyrek matrislerin karşı ı ı ı ı ı
sahip seyrek matrislerde aynı ı ı
2024-07-15 13:23:34 +03:00
çarpabiliriz. Ancak bu işlemler yavaş olma eğilimindedir. Örneğin:
from scipy.sparse import dok_matrix
dok1 = dok_matrix((5, 5), dtype='int32')
dok1[1, 2] = 10
dok1[0, 1] = 20
dok2 = dok_matrix((5, 5), dtype='int32')
dok2[3, 2] = 10
dok2[4, 1] = 20
dok2[1, 2] = 20
result = dok1 + dok2
print(result)
result = dok1 * dok2
print(result)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import dok_matrix
import numpy as np
a = np.random.randint(0, 2, (10, 10))
b = np.random.randint(0, 2, (10, 10))
dok1 = dok_matrix(a, dtype='float32')
dok2 = dok_matrix(b, dtype='float32')
dok3 = dok1 + dok2
print(dok3)
dok3 = dok1 * dok2
print(dok3)
#----------------------------------------------------------------------------------------------------------------------------
2024-07-15 13:23:34 +03:00
Diğer bir seyrek matris veri yapı ı ı ı ı ı ı ı ı
2024-04-09 13:15:47 +03:00
0 olmayan elemanları ı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
tutulmaktadı ı ı ı ı ı
genel kullanı ı ı ı ı ı ı ı
Örneğin aşağı ı ı
[[ 0 0 10 20 0]
[15 0 0 0 40]
[12 0 51 0 16]
[42 0 18 0 16]
[ 0 0 0 0 0]]
Buradaki data listesi şöyle olacaktı
array([list([10, 20]), list([15, 40]), list([12, 51, 16]), list([42, 18, 16]), list([])], dtype=object)
rows lsistesi de şöyle olacaktı
array([list([2, 3]), list([0, 4]), list([0, 2, 4]), list([0, 2, 4]), list([])], dtype=object)
2024-07-22 23:31:13 +03:00
LIL matrisler de artimetik işlemlerde yavaştı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import lil_matrix
import numpy as np
lil1 = lil_matrix((100, 100), dtype='float32')
lil1[30, 32] = 10
lil1[35, 2] = 20
lil1[38, 27] = 30
lil1[36, 42] = 40
lil1[55, 21] = 50
print(lil1)
lil2 = lil_matrix(np.random.randint(0, 2, (100, 100)))
lil3 = lil1 + lil2
print(lil3)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
2024-07-15 13:23:34 +03:00
CSR (Compressed Sparse Row), ve CSC (Compressed Sparse Column) matrisleri genel veri yapı ı
benzemektedir. Bunlar adeta birbirlerinin tersi durumundadı
Bu veri yapı ı ı ı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
daha avantajlı ı ı ı ı
matrisin 0 olmayan bir elemanı
2024-07-15 13:23:34 +03:00
CSR veri yapı ı ı ı ı
2024-07-22 23:31:13 +03:00
sı ı ı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
özniteliklerinden elde edilebilmektedir. data dizisi sı ı ı
data dizisindeki elemanları ı ı ı ı ı ı
elemanları ı
2024-07-22 23:31:13 +03:00
oluşmaktadı
2024-07-15 13:23:34 +03:00
ise son indeksi belirtir.
Örneğin:
2024-04-02 13:01:04 +03:00
0, 0, 9, 0, 5
8, 0, 3, 0, 7
0, 0, 0, 0, 0
0, 0, 5, 0, 9
0, 0, 0, 0, 0
Burada söz konusu üç dizi şöyledir:
data: [9, 5, 8, 3, 7, 5, 9]
indices: [2, 4, 0, 2, 4, 2, 4]
indptr: [0, 2, 5, 5, 7, 7]
2024-04-09 13:15:47 +03:00
csr_matrix sı ı ı ı ı ı ı ı ı ı ı
elemana atama yapmak yavaş bir işlemdir. Çünkü bu işlemler yukarı ı ı
2024-07-15 13:23:34 +03:00
durumlarda DOK ya da LIL matrisler daha hı ı ı ı ı ı
elemana atama yapı ı ı ı ı ı ı ı
2024-04-09 13:15:47 +03:00
ve sonra da onları ı
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
CSR matrislerinde satı ı ı ı ı ı ı ı
elemanları ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import csr_matrix
import numpy as np
a = np.zeros((100, 100), dtype='float32')
for _ in range(100):
row = np.random.randint(0, 100, 1)
col = np.random.randint(0, 100, 1)
a[row, col] = np.random.randint(0, 100, 1)
csr = csr_matrix(a, dtype='float32')
print(csr)
csr2 = csr[2:4, :]
print(csr2)
2024-07-20 14:48:03 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
51. Ders - 20/07/2024 - Cumartesi
2024-07-20 14:48:03 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
csr matrislerin data, indices ve indptr örnek öznitelikleri yukarı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import csr_matrix
a = [[0, 0, 9, 0, 5], [8, 0, 3, 0, 7], [0, 0, 0, 0, 0], [0, 0, 5, 0, 9], [0, 0, 0, 0, 0]]
csr = csr_matrix(a)
print(csr.todense(), end='\n\n')
print(f'data: {csr.data}') # data: [9 5 8 3 7 5 9]
print(f'indices: {csr.indices}') # indices: [2 4 0 2 4 2 4]
print(f'indptr: {csr.indptr}') # indptr: [0 2 5 5 7 7]
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
CSC formatı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
arası ı ı ı ı ı ı
2024-07-20 14:48:03 +03:00
işlemlerin hepsi satı
2024-04-02 13:01:04 +03:00
0, 0, 9, 0, 5
8, 0, 3, 0, 7
0, 0, 0, 0, 0
0, 0, 5, 0, 9
0, 0, 0, 0, 0
data: [8, 9, 3, 5, 5, 7, 9]
indices: [1, 0, 1, 3, 0, 1, 3]
indptr: [0, 1, 1, 4, 4, 7]
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import csc_matrix
a = [[0, 0, 9, 0, 5], [8, 0, 3, 0, 7], [0, 0, 0, 0, 0], [0, 0, 5, 0, 9], [0, 0, 0, 0, 0]]
csc = csc_matrix(a)
print(csc.todense(), end='\n\n')
print(f'data: {csc.data}') # data: [8 9 3 5 5 7 9]
print(f'indices: {csc.indices}') # indices: [1 0 1 3 0 1 3]
print(f'indptr: {csc.indptr}') # indptr: [0 1 1 4 4 7]
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Yukarı ı ı ı ı ı ı ı
2024-04-09 13:15:47 +03:00
vardı ı ı ı
dönüştürebiliriz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
from scipy.sparse import csc_matrix
2024-07-20 14:48:03 +03:00
a = np.array([[0, 0, 10, 20, 0], [15, 0, 0, 0, 40], [12, 0, 51, 0, 16], [42, 0, 18, 0, 16], [0, 0, 0, 0, 0]])
print(a)
csc = csc_matrix(a, dtype='int32')
print(csc)
print(csc.todense())
csr = csc.tocsr()
print(csr)
dok = csr.todok()
print(dok)
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
lil = dok.tolil()
2024-04-02 13:01:04 +03:00
print(lil)
#----------------------------------------------------------------------------------------------------------------------------
Seyrek bir matris train_test_split fonksiyonuyla ayrı ı ı
2024-07-20 14:48:03 +03:00
işlemlerini yapmaktadı ı
örnek özniteliği ile elde edilebilir. train_test_split fonksiyonu seyrek matrisi de karı ı
Aşağı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.model_selection import train_test_split
dense = np.zeros((10, 5))
for i in range(len(dense)):
rcols = np.random.randint(0, 5, 2)
dense[i, rcols] = np.random.randint(0, 100, 2)
sparse_dataset_x = csr_matrix(dense)
dataset_y = np.random.randint(0, 2, 10)
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(sparse_dataset_x, dataset_y, test_size=0.2)
print(training_dataset_x)
print(training_dataset_y)
print(test_dataset_x)
print(test_dataset_y)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Seyrek matrislerin birbirlerine göre avantaj ve dezavantajları
2024-04-09 13:15:47 +03:00
- DOK matriste elemanlara okuma ya da yazma amaçlı ı ı
2024-07-20 14:48:03 +03:00
matris işlemlerinde etkin değildir. DOK matrisler dilimleme de de etkin değildir.
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
- LIL matrisler de okuma amaçlı ı ı ı ı
ve matris işlemlerinde yavaştı ı ı ı
Bu matrislerin matris işlemleri için CSR ve CSC formatları ı ı ı
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
- CSR matrisler satı ı ı ı
CSC de satı ı ı ı ı ı
2024-04-09 13:15:47 +03:00
değiştirmek (özellikle 0 olan elemanları ı
2024-07-20 14:48:03 +03:00
O halde biz eğer eleman değerleri değiştirilmeyecekse CSR ya da CSC matris kullanabiliriz. Ancak eleman değerleri
değiştirilecekse önce işlemlemlerimize DOK ya da LIL matrisle başlayı ı ı
başlamadan önce matrisimizi CSR ya da SCS formatı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
Aslı ı ı ı ı ı
OneHotEncoder sı ı ı ı ı ı ı ı
seyrek matrisini vermektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.preprocessing import OneHotEncoder
import numpy as np
a = np.array(['Mavi', 'Yeşil', 'Kı ı ı ı ı ı
ohe = OneHotEncoder()
result = ohe.fit_transform(a.reshape(-1, 1))
print(result)
2024-07-20 14:48:03 +03:00
print(type(result))
2024-04-02 13:01:04 +03:00
print(result.todense())
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
Benzer biçimde scikit-learn kütüphanesindeki CountVectorizer sı ı ı ı ı
vermektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.feature_extraction.text import CountVectorizer
2024-07-20 14:48:03 +03:00
texts = ['this film is very very good', 'I hate this film', 'It is good', 'I don\'t like it']
2024-04-02 13:01:04 +03:00
cv = CountVectorizer()
2024-07-20 14:48:03 +03:00
cv.fit(texts)
result = cv.transform(texts)
2024-04-02 13:01:04 +03:00
print(result)
print(result.todense())
#----------------------------------------------------------------------------------------------------------------------------
2024-07-20 14:48:03 +03:00
Seyrek matrisleri karı ı ı ı ı ı ı ı ı
2024-07-22 23:31:13 +03:00
kullanmadı ı ı ı ı ı ı
matrislerini karı ı ı ı ı ı ı ı
olarak vermektedir. Buradaki shuffle fonksiyonu birden fazla girdi alabilmektedir. Karı ı ı ı ı
için karı ı ı ı ı ı ı ı ı ı
result_x, result_y = shuffle(x, y)
2024-07-20 14:48:03 +03:00
2024-07-22 23:31:13 +03:00
Burada karı ı ı ı ı ı ı ı ı ı
2024-07-20 14:48:03 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.utils import shuffle
a = np.array([[0, 0, 10, 20, 0], [15, 0, 0, 0, 40], [12, 0, 51, 0, 16], [42, 0, 18, 0, 16], [0, 0, 0, 0, 0]])
csr = csr_matrix(a)
y = [10, 20, 30, 40, 50]
result_x, result_y = shuffle(csr, y)
print(csr.todense())
print(y)
print('-' * 15)
print(result_x.todense())
print(result_y)
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Seyrek matris sı ı ı ı ı ı ı ı ı ı ı
Aslı ı
bir seyrek matris varsa biz bunu Keras'ta nası
elde etmiş olalı ı ı ı ı ı ı
nası
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
Seyrek matrislerin Keras sinir ağları ı ı ı ı
2024-07-22 23:31:13 +03:00
1) Parçalı ı ı ı ı
2) Tensorflow kütüphanesinin Input katmanı ı ı
doğrudan dataset_x değerleri SciPy sparse matrisi olarak verilebilmektedir.
2024-07-20 14:48:03 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi tüm verilerin vektörizasyonunu CountVectorizer sı ı ı ı
parçalı ı
yapalı ı ı ı ı
Sonra DataGenerator sı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
import math
2024-04-02 13:01:04 +03:00
import pandas as pd
2024-07-20 14:48:03 +03:00
from tensorflow.keras.utils import PyDataset
import tensorflow as tf
from sklearn.utils import shuffle
EPOCHS = 5
BATCH_SIZE = 32
2024-04-02 13:01:04 +03:00
df = pd.read_csv('IMDB Dataset.csv')
2024-07-20 14:48:03 +03:00
from sklearn.feature_extraction.text import CountVectorizer
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
cv = CountVectorizer(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
dataset_x = cv.fit_transform(df['review'])
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.2)
training_steps = math.ceil(training_dataset_x.shape[0] / BATCH_SIZE)
validation_steps = math.ceil(validation_dataset_x.shape[0] / BATCH_SIZE)
test_steps = math.ceil(test_dataset_x.shape[0] / BATCH_SIZE)
class DataGenerator(PyDataset):
def __init__(self, sparse_x, y, steps, batch_size, predict=False):
super().__init__()
self.sparse_x = sparse_x
self.y = y
self.steps = steps
self.batch_size = batch_size
self.predict = predict
def __len__(self):
return self.steps
def __getitem__(self, batch_no):
x = self.sparse_x[batch_no * self.batch_size: batch_no * self.batch_size + self.batch_size]
if not self.predict:
y = self.y[batch_no * self.batch_size: batch_no * self.batch_size + self.batch_size]
return tf.convert_to_tensor(x.todense()), tf.convert_to_tensor(y)
else:
return tf.convert_to_tensor(x.todense()),
def on_epoch_end(self):
if not self.predict:
self.sparse_x, self.y = shuffle(self.sparse_x, self.y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='IMDB')
model.add(Input((training_dataset_x.shape[1], )))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(DataGenerator(training_dataset_x, training_dataset_y, training_steps, BATCH_SIZE),
validation_data = DataGenerator(training_dataset_x, training_dataset_y, validation_steps, BATCH_SIZE), epochs=EPOCHS)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.legend(['Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(DataGenerator(test_dataset_x, test_dataset_y, test_steps, BATCH_SIZE))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
df_predict = pd.read_csv('predict-imdb.csv')
predict_dataset_x = cv.transform(df_predict['review'])
predict_steps = math.ceil(predict_dataset_x.shape[0] / BATCH_SIZE)
predict_result = model.predict(DataGenerator(predict_dataset_x, None, predict_steps, BATCH_SIZE, True))
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
import math
import pandas as pd
from tensorflow.keras.utils import PyDataset
import tensorflow as tf
from sklearn.utils import shuffle
EPOCHS = 5
BATCH_SIZE = 32
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='uint8')
dataset_x = cv.fit_transform(df['review'])
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-07-20 14:48:03 +03:00
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.2)
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
training_steps = math.ceil(training_dataset_x.shape[0] / BATCH_SIZE)
validation_steps = math.ceil(validation_dataset_x.shape[0] / BATCH_SIZE)
test_steps = math.ceil(test_dataset_x.shape[0] / BATCH_SIZE)
class DataGenerator(PyDataset):
def __init__(self, sparse_x, y, steps, batch_size, predict=False):
2024-04-02 13:01:04 +03:00
super().__init__()
2024-07-20 14:48:03 +03:00
self.sparse_x = sparse_x
2024-04-02 13:01:04 +03:00
self.y = y
2024-07-20 14:48:03 +03:00
self.steps = steps
2024-04-02 13:01:04 +03:00
self.batch_size = batch_size
2024-07-20 14:48:03 +03:00
self.predict = predict
2024-04-02 13:01:04 +03:00
def __len__(self):
2024-07-20 14:48:03 +03:00
return self.steps
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
def __getitem__(self, batch_no):
x = self.sparse_x[batch_no * self.batch_size: batch_no * self.batch_size + self.batch_size]
if not self.predict:
y = self.y[batch_no * self.batch_size: batch_no * self.batch_size + self.batch_size]
return tf.convert_to_tensor(x.todense()), tf.convert_to_tensor(y)
else:
return tf.convert_to_tensor(x.todense()),
2024-04-02 13:01:04 +03:00
def on_epoch_end(self):
2024-07-20 14:48:03 +03:00
if not self.predict:
self.sparse_x, self.y = shuffle(self.sparse_x, self.y)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-07-20 14:48:03 +03:00
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
model = Sequential(name='IMDB')
2024-07-20 14:48:03 +03:00
model.add(Input((training_dataset_x.shape[1], )))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-07-20 14:48:03 +03:00
hist = model.fit(DataGenerator(training_dataset_x, training_dataset_y, training_steps, BATCH_SIZE),
validation_data = DataGenerator(training_dataset_x, training_dataset_y, validation_steps, BATCH_SIZE), epochs=EPOCHS)
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.legend(['Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
eval_result = model.evaluate(DataGenerator(test_dataset_x, test_dataset_y, test_steps, BATCH_SIZE))
2024-04-02 13:01:04 +03:00
2024-07-20 14:48:03 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
df_predict = pd.read_csv('predict-imdb.csv')
predict_dataset_x = cv.transform(df_predict['review'])
predict_steps = math.ceil(predict_dataset_x.shape[0] / BATCH_SIZE)
predict_result = model.predict(DataGenerator(predict_dataset_x, None, predict_steps, BATCH_SIZE, True))
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
Böylece biz artı ı
halletmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
EPOCHS = 5
BATCH_SIZE = 32
df = pd.read_csv('IMDB Dataset.csv').iloc[:1000, :]
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='uint8')
dataset_x = cv.fit_transform(df['review'])
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense
model = Sequential(name='IMDB')
model.add(Input((training_dataset_x.shape[1],), sparse=True))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
2024-07-20 14:48:03 +03:00
plt.legend(['Loss'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-07-20 14:48:03 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-07-20 14:48:03 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-07-20 14:48:03 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-07-20 14:48:03 +03:00
# prediction
df_predict = pd.read_csv('predict-imdb.csv')
predict_dataset_x = cv.transform(df_predict['review'])
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
52. Ders - 21/07/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Resimlerle ilgili işlemler yapabilmek için öncelikle resimlerin sayı ı
hakkı ı ı ı ı ı
Pixel ("picture element" sözcüklerinden uydurulmuştur) ekranda görüntülenebilen en küçük noktasal öğedir. Yani ekrandaki tüm
görüntü aslı ı ı ı
Örneğin ekranı ı ı ı ı ı ı ı ı ı ı
pixel olduğu ve toplam 1080 tane satı ı ı ı ı
pixel vardı ı ı
teknoloji zayı ı ı
grafik kartları ı ı ı
daha yüksektir.
Bugün kullandı ı ı ı ı ı ı
oluşturulmaktadı ı ı ı ı ı ı
0-255 arası ı ı ı ı ı ı ı
yeşil ı ı ı ı
tonal birleşimleriyle elde edilmektedir. (Burada bir uyarı ı ı
boyaları ı ı ı ı ı ı
örneğin Biz kı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
elde ettiğimiz renk sarı ı
farklı ı ı ı
de ifade edebiliriz. 2 ** 24 değeri yaklaşı ı ı ı ı
renkler borsa da insanı ı ı ı ı ı ı
renklerinin milyar düzeyine çı ı ı ı ı ı
Ekranda iki pixel arası ı ı ı ı ı ı ı
pixel ile oluşturulması ı ı
koordinat sisteminde sı ı ı ı ı
kı ı ı ı ı ı ı ı ı ı ı
artı ı ı ı ı
güç tüketimi LCD ekranda oluşmaktadı ı ı ı ı
gelmektedir.
Pekiyi ekran boyutunu sabit tutup çözünürlüğü küçültürsek ne olur? Bu durumda pixel'ler büyür ve görüntü daha büyür ancak
netlik azalı ı ı ı ı
ekran ve çözünürlük daha önemlidir. İşte buna DPI (Dot Per Inch) denilmektedir. DPI bir inch'te kaç pixel olduğunu belirtmektedir.
Çözünürlük sabit tutulup ekran büyütülürse DPI düşer, ekran küçültülürse DPI yükselir. Bugün kullandı ı ı ı ı
telefonları ı ı
Belli bir DPI'dan daha yüksek çözünürlük sağlamanı ı ı
Bilgisayar bilimlerinin sı ı ı ı ı
üzerinde işlemlerin nası ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bilgisayar ortamı ı ı
formatlar bitmap formatlardı ı ı
Dolayı ı ı
çok yer kaplama eğilimindedir. Örneğin 100x100 pixellik bir resim kabaca 100 * 100 * 3 byte yer kaplar. Bu yüzden resimler
üzerinde kayı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı
aslı ı
farmatlar resimleri çok az bozup çok iyi sı ı ı ı ı
2024-08-22 19:31:50 +03:00
JPEG gibi formatlar doğal formatlar değildir. Sı ı ı ı ı ı
görüntülenmeidir. Çünkü bu resimlerin büyütülüp küçültülmesinde (scale edilmesinde) görüntü bozulabilmektedir.
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Bugünkü bilgisayar sistemlerinde arka planda bir görüntü varken onun önüne bir görüntü getrilip arkadaki görüntü adeta bir
2024-07-22 23:31:13 +03:00
tül perdeden görünüyormuş gibi bir etki yaratı ı
bit operasyonuna sokulması ı ı ı ı ı
yapı ı ı ı ı ı ı ı
derecesini grafik kartı ı ı ı ı ı
belirten bu değere "alpha channel" denilmetedir.
Bazı ı ı ı ı ı
resim başka bir resmin üztüne bası ı ı ı ı ı ı ı
PNG formatı ı ı ı ı
bilgisi tutulmamaktadı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Siyah beyaz demek her pixel'in yalnı
ile ifade edilebilir. Ancak siyah beyaz resimlerde resim bir siluet gibi gözükmektedir. Gri tonlamalı
ise her pixel siyahı ı ı
fotoğraflardı ı ı ı ı ı
resimlerde grinin 256 tonu görüntülenebilmektedir. Dolayı ı ı
edilebilmektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Matplotlib kütüphanesinde bir resmi resim dosyası
NumPy dizisi biçiminde veren imread isimli bir fonksiyon vardı ı ı ı
resmin saf pixel değerlerini elde ederiz. Örneğin:
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
2024-07-22 23:31:13 +03:00
Bu örnekte biz bir NumPy dizisi elde etmiş olduk. Söz konusu resim renkli ir resim olduğu için elde edilen dizinin de shape
demeti (100, 1500, 3) biçimindedir. Yani söz konusu resim 1000x1500 pixel'lik bir resimdir, ancak resmin her pixel'i RGB
değerlerinden oluşmaktadı ı ı
i'inci satı
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Matplotlib kütüphanesinin imshow isimli fonksiyonu pixel bilgilerini alarak resmi görüntüler. Tabii imshow resmi orijinal
2024-07-22 23:31:13 +03:00
boyutuyla görüntülememektedir. imshow resmi ölçeklendirip figür büyüklüğünde görüntülemektedir. Örneğin:
image_data = plt.imread('AbbeyRoad.jpg')
plt.imshow(image_data)
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
Matplotlib bir resim üzerinde ondan parça almak, onu büyütmek, küçültmek gibi işlemler için uygun değildir. Bu tür işlemler
2024-04-09 13:15:47 +03:00
için Python programcı ı ı ı ı
Image Library (PIL ya da Pillow diye kı ı ı ı ı ı
bize pixel'lerini verir ve pixel'leri verilmiş resmi görüntüler.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
plt.imshow(image_data)
plt.show()
print(image_data.shape)
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Örneğin biz bir resmi ters çevirmek için resmin tüm satı ı ı ı ı
2024-07-22 23:31:13 +03:00
fonksiyonu pratik bir biçimde yapmaktadı ı ı
ve NumPy iyi araçlardı
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
image_data = plt.imread('AbbeyRoad.jpg')
plt.imshow(image_data)
plt.show()
result_image = np.flip(image_data, axis=1)
plt.imshow(result_image)
plt.show()
Burada pixel verileri yatay eksende döndürülmüştür.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
image_data = plt.imread('AbbeyRoad.jpg')
2024-07-22 23:31:13 +03:00
2024-04-02 13:01:04 +03:00
plt.imshow(image_data)
plt.show()
2024-07-22 23:31:13 +03:00
result_image = np.flip(image_data, axis=1)
plt.imshow(result_image)
plt.show()
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
#----------------------------------------------------------------------------------------------------------------------------
NumPy'da rot90 fonksiyonu resmim pixellerini 90 derece döndürmektedir. Fonksiyon resmin pixel verileriyle saat yönününün
tersinde kaç defa 90 derece döndürüleceğini (default değeri 1) bizden istemektedir. Örneğin:
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
mage_data = plt.imread('AbbeyRoad.jpg')
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
plt.imshow(image_data)
plt.show()
result_image = np.rot90(image_data, 3)
plt.imshow(result_image)
plt.show()
Burada resim 3 kere 90 derece döndürülmüştür.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-07-22 23:31:13 +03:00
Renkli resimleri imread fonksiyonu ile okuduğumuzda "row x col x 3" boyutunda bir matris elde ederiz. Gri tonlamalı
aynı ı
boyutlu bir matrisin eleman sayı ı ı ı ı ı ı
yoktur. Bazen gri tonlamalı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Pekiyi renkli bir resmi gri tonlamalı ı
2024-07-22 23:31:13 +03:00
renklerinin ortalaması ı ı
2024-04-09 13:15:47 +03:00
Örneğin:
2024-04-02 13:01:04 +03:00
2024-07-22 23:31:13 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
gray_scaled_image_data = np.mean(image_data, axis=2)
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
import numpy as np
gray_scaled_image_data = np.mean(image_data, axis=2)
plt.imshow(gray_scaled_image_data, cmap='gray')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
RGB bir resmi yukardaki gibi gri tonlamalı ı ı
2024-07-22 23:31:13 +03:00
ağı ı ı ı ı ı ı ı ı ı ı
resim gri tonlamalı ı ı ı ı
isimli fonksiyon ağı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
import numpy as np
gray_scaled_image_data = np.average(image_data, axis=2, weights=[0.3, 0.59, 0.11])
plt.imshow(gray_scaled_image_data, cmap='gray')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
53. Ders - 27/07/2024 - Cumartesi -
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Resim tanı ı ı
and Technology) denilen veri kümesidir. Bu veri kümesinde her biri 28x28 pixel'den oluşan gri tonlamalı ı
resimler çeşitli kişilerin 0 ile 9 arası ı ı ı ı
kestirilmesi" gibi resim tanı ı ı ı ı
kümesini zip'lenmiş CSV dosyaları ı ı
2024-04-02 13:01:04 +03:00
https://www.kaggle.com/oddrationale/mnist-in-csv
Buradan minist_train.csv ve mnist_test.csv dosyaları
2024-04-09 13:15:47 +03:00
Aşağı ı ı ı
2024-08-22 19:31:50 +03:00
edildiğinde %97 civarı ı
işlemi yapı ı ı ı ı ı ı
verilerinde "anti-aliasing" özelliği bulunmaktadı ı
kestirilecek resimleri oluşturduk. Pixel verileri eğitime sokulmadan önce min-max ölçeklemesi de yapı ı ı
[0, 255] arası ı
Modele çok fazla epoch uygulandı ı ı ı ı ı
belirlenmiştir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-08-22 19:31:50 +03:00
training_df = pd.read_csv('mnist_train.csv')
test_df = pd.read_csv('mnist_test.csv')
training_dataset_x = training_df.iloc[:, 1:].to_numpy(dtype='uint8')
training_dataset_y = training_df.iloc[:, 0].to_numpy(dtype='uint8')
test_dataset_x = test_df.iloc[:, 1:].to_numpy(dtype='uint8')
test_dataset_y = test_df.iloc[:, 0].to_numpy(dtype='uint8')
# one hot encoding for y data
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
# minmax scaling
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(5, 13))
2024-04-02 13:01:04 +03:00
for i in range(50):
plt.subplot(10, 5, i + 1)
2024-08-22 19:31:50 +03:00
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
2024-04-02 13:01:04 +03:00
plt.show()
2024-08-22 19:31:50 +03:00
"""
seven_x = training_dataset_x[training_dataset_y == 7]
for i in range(50):
plt.figure(figsize=(1, 1))
# plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = seven_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
plt.show()
"""
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
"""
for i in range(50):
plt.figure(figsize=(1, 1))
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
plt.show()
"""
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
model = Sequential(name='MNIST')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(128, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=20, validation_split=0.2)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
2024-04-02 13:01:04 +03:00
import numpy as np
2024-08-22 19:31:50 +03:00
import os
2024-04-02 13:01:04 +03:00
import glob
2024-08-22 19:31:50 +03:00
for path in glob.glob('Predict-Pictures/*.bmp'):
image = plt.imread(path)
gray_scaled_image = np.average(image, axis=2, weights=[0.3, 0.59, 0.11]).reshape(1, 28 * 28)
gray_scaled_image /= 255
model_result = model.predict(gray_scaled_image, verbose=0)
predict_result = np.argmax(model_result)
print(f'Real Number: {os.path.basename(path)[0]}, Prdicted Result: {predict_result}, Path: {path}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Aslı ı
fonksiyonu bize pixel verilerini üç boyutlu bir NumPy dizisi olarak vermektedir. Bizim bu verileri reshape ile 784'lük
2024-08-22 19:31:50 +03:00
iki boyutlu matrise dönüştürmemiz gerekir. Aşağı ı ı ı
yapı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import mnist
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = mnist.load_data()
2024-08-22 19:31:50 +03:00
training_dataset_x = training_dataset_x.reshape(-1, 28 * 28)
test_dataset_x = test_dataset_x.reshape(-1, 28 * 28)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
# one hot encoding for y data
2024-04-02 13:01:04 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
2024-08-22 19:31:50 +03:00
# minmax scaling
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(5, 13))
for i in range(50):
plt.subplot(10, 5, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
plt.show()
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
"""
seven_x = training_dataset_x[training_dataset_y == 7]
for i in range(50):
plt.figure(figsize=(1, 1))
# plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = seven_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
plt.show()
"""
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
"""
for i in range(50):
plt.figure(figsize=(1, 1))
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i].reshape(28, 28)
plt.imshow(picture, cmap='gray')
plt.show()
"""
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
model = Sequential(name='MNIST')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=20, validation_split=0.2)
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
2024-04-02 13:01:04 +03:00
import numpy as np
2024-08-22 19:31:50 +03:00
import os
2024-04-02 13:01:04 +03:00
import glob
2024-08-22 19:31:50 +03:00
for path in glob.glob('Predict-Pictures/*.bmp'):
image = plt.imread(path)
gray_scaled_image = np.average(image, axis=2, weights=[0.3, 0.59, 0.11]).reshape(1, 28 * 28)
gray_scaled_image /= 255
model_result = model.predict(gray_scaled_image, verbose=0)
predict_result = np.argmax(model_result)
print(f'Real Number: {os.path.basename(path)[0]}, Prdicted Result: {predict_result}, Path: {path}')
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
54. Ders - 28/07/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Evrişim (convolution) genel olarak "sayı ı
tekniktir. Bir verinin başka bir veriyle girişime sokulması ı
kullanı ı ı ı ı
2024-10-08 00:12:04 +03:00
uygulanmaktadı ı ı
2024-08-22 19:31:50 +03:00
Network)" denilmektedir ve İngilizce CNN biçiminde kı ı ı
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
Resimlerde evrişim işlemi pixel'lerin birbirleri ile ilişkili hale gelmesini sağlamaktadı
bağı ı ı ı ı
2024-08-22 19:31:50 +03:00
etkisi oluşturmaktadı ı
Bir resmin evrişim işlemine sokulması ı
2024-04-09 13:15:47 +03:00
(filter)" ya da "kernel" denilmektedir. Kernel herhangi bir boyutta olabilir. Kare bir matris biçiminde olması
uygulamada NxN'lik kare matrisler kullanı ı ı ı
işlemi şöyle yapı ı ı ı ı ı ı ı
2024-08-22 19:31:50 +03:00
işlemine sokulur. (Yani kernel'ı ı ı ı ı ı ı ı ı ı
Buradan bir değer elde edilir. Bu değer yeni resmin kernel ile çakı ı ı ı
üzerinde kaydı ı ı ı ı ı ı ı ı ı
sonucunda başka bir resim elde edilmiştir. Örneğin aşağı ı
2024-04-02 13:01:04 +03:00
a11 a12 a13 a14 a15
a21 a22 a23 a24 a25
a31 a32 a33 a34 a35
a41 a42 a43 a44 a45
a51 a52 a53 a54 a55
2024-08-22 19:31:50 +03:00
Kullandı ı ı ı
2024-04-02 13:01:04 +03:00
b11 b12 b13
b21 b22 b23
b31 b32 b33
Bu kernel resmin sol üst köşesi ile çakı ı ı ı ı
c11 = b11 * a11 + b12 * a12 + b13 * a13 + b21 * a21 + b22 * a22 + b23 * a23 + b31 * a31 + b32 * a32 + b33 * a33
Şimdi kernel'ı ı ı ı ı
c12 = b11 * a12 + b12 * a13 + b13 * a14 + b21 * a22 + b22 * a23 + b23 * a24 + b31 * a32 + b32 * a32 + b33 * a34
Şimdi kernel'ı ı ı
c13 = b11 * a13 + b12 * a14 + b13 * a15 + b21 * a23 + b22 * a24 + b23 * a25 + b31 * a33 + b32 * a34 + b33 * a35
Şimdi kernel'ı ı ı ı
c21 = b11 * a21 + b12 * a22 + b13 * a23 + b21 * a31 + b22 * a32 + b23 * a33 + b31 * a41 + b32 * a42 + b33 * a43
2024-10-08 00:12:04 +03:00
İşte bu biçimde işlemlere devam edersek aşağı
2024-04-02 13:01:04 +03:00
c11 c12 c13
c21 c22 c23
c31 c32 c33
2024-08-22 19:31:50 +03:00
Eğer işlemler yukarı ı ı
2024-04-02 13:01:04 +03:00
Hedef Resmin Genişliği = Ası
Hedef Resmin Yüksekliği = Ası
2024-08-22 19:31:50 +03:00
Örneğin ana resim 5X5'lik ve kernel'da 3X3'lik ise evrişim işleminin sonucunda elde edilecek resim 3X3'lük olacaktı
2024-04-02 13:01:04 +03:00
Görüldüğü gibi hedef resim ası ı ı ı ı ı
2024-08-22 19:31:50 +03:00
ası ı ı ı ı ı ı
İngilizce "padding" denilmektedir. Hedef resmin ası ı ı ı
kadar padding uygulanmalı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Toplam Padding Genişliği = Kernel Genişliği - 1
Toplam Padding Yüksekliği = Kernel Yüksekliği - 1
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Tabii bu toplam pading genişliği ve yüksekliği iki yöne eşit bir biçimde yaydı ı ı ı ı
evrişim işlemine sokulmadan önce dört taraftan büyütülmelidir. Örneğin 5x5'lik resme 3x3'lük kernel uygulamak isteyelim:
2024-04-02 13:01:04 +03:00
a11 a12 a13 a14 a15
a21 a22 a23 a24 a25
a31 a32 a33 a34 a35
a41 a42 a43 a44 a45
a51 a52 a53 a54 a55
2024-08-22 19:31:50 +03:00
Asl resmin padding'li hali şu biçimde görünecektir:
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
pad pad pad pad pad pad pad
pad a11 a12 a13 a14 a15 pad
pad a21 a22 a23 a24 a25 pad
pad a31 a32 a33 a34 a35 pad
pad a41 a42 a43 a44 a45 pad
pad a51 a52 a53 a54 a55 pad
pad pad pad pad pad pad pad
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Pekiyi padding'ler ası ı ı ı ı ı
Birincisi padding'leri 0 almak ikincisi ise ilk ve son n tane satı ı
tercih edilmektedir.
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Evrişim işleminde kaydı ı ı ı
denilmektedir. stride değeri artı ı ı ı ı
için stride değeri artı ı
2024-04-02 13:01:04 +03:00
Evrişim işlemi ile ne elde edilmek istenmektedir? Resimlerde evrişim işlemi resmi filtrelemek için kullanı ı
2024-08-22 19:31:50 +03:00
farklı ı ı ı
kullanı ı
resmin içerisindeki nesnelerin sı ı ı ı
çeşitli kaynaklardan edinilebilir.
2024-10-08 00:12:04 +03:00
Evirişim işlemini padding uygulamadan yapan basit bir fonksiyonu şöyle yazabiliriz:
2024-08-22 19:31:50 +03:00
import numpy as np
def conv(image, kernel):
image_height = image.shape[0]
image_width = image.shape[1]
kernel_height = kernel.shape[0]
kernel_width = kernel.shape[1]
target = np.zeros((image_height - kernel_height + 1, image_width - kernel_width + 1), dtype='uint8')
for row in range(image_height - kernel_height + 1):
for col in range(image_width - kernel_width + 1):
dotp = 0
for i in range(kernel_height):
for k in range(kernel_width):
dotp += image[row + i, col + k] * kernel[i, k]
target[row, col] = np.clip(dotp, 0, 255)
return target
Evrişim işleminin bu biçimde uygulanması
fonksiyonlardan faydalanı ı ı ı ı ı ı ı ı
kodları ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Aşağı ı ı ı
2024-10-08 00:12:04 +03:00
denenmiştir. Görüntü işlemede blur filtresi resmi bulanı ı ı ı
hale getirmekte kullanı ı ı
2024-08-22 19:31:50 +03:00
tutmalı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def conv(image, kernel):
image_height = image.shape[0]
image_width = image.shape[1]
kernel_height = kernel.shape[0]
kernel_width = kernel.shape[1]
target = np.zeros((image_height - kernel_height + 1, image_width - kernel_width + 1), dtype='uint8')
for row in range(image_height - kernel_height + 1):
for col in range(image_width - kernel_width + 1):
dotp = 0
for i in range(kernel_height):
for k in range(kernel_width):
dotp += image[row + i, col + k] * kernel[i, k]
target[row, col] = np.clip(dotp, 0, 255)
return target
import matplotlib.pyplot as plt
image = plt.imread('AbbeyRoad.jpg')
gray_scaled_image = np.average(image, axis=2, weights=[0.3, 0.59, 0.11])
blur_kernel = np.full((9, 9), 1 / 100)
convoluted_image = conv(gray_scaled_image, blur_kernel)
plt.figure(figsize=(10, 10))
plt.subplot(1, 2, 1)
plt.imshow(gray_scaled_image, cmap='gray')
plt.subplot(1, 2, 2)
plt.imshow(convoluted_image, cmap='gray')
plt.show()
sobel_kernel = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])
convoluted_image = conv(gray_scaled_image, sobel_kernel)
plt.figure(figsize=(10, 10))
plt.subplot(1, 2, 1)
plt.imshow(gray_scaled_image, cmap='gray')
plt.subplot(1, 2, 2)
plt.imshow(convoluted_image, cmap='gray')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Pekiyi evrişim işleminin yapay sinir ağları ı ı
2024-08-22 19:31:50 +03:00
olacak biçimde yürütülmektedir. Yani bir resmin sı ı ı ı ı
bir filtre olacağı ı ı ı ı ı ı
Biz kestirimin daha isabetli yapı ı ı ı ı ı ı
Yani ağ yalnı ı ı ı
yeterli değildir. Resim filtreden geçirildikten sonra yine Dense katmanlara sokulur. Yani filtreleme genellikle ön katmanlarda
yapı ı ı ı
bu filtreleri ağı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-04-09 13:15:47 +03:00
Aslı ı ı ı ı
girişlerinin ağı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
a11 a12 a13 a14 a15 a16
a21 a22 a23 a24 a25 a26
a31 a32 a33 a34 a35 a36
a41 a42 a43 a44 a45 a46
a51 a52 a53 a54 a55 a56
a61 a62 a63 a64 a65 a66
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Burada aşağı ı ı
2024-04-02 13:01:04 +03:00
b11 b12 b13
b21 b22 b23
b31 b32 b33
2024-04-09 13:15:47 +03:00
Bu kernel'ı ı ı ı ı ı ı
2024-08-22 19:31:50 +03:00
girdileri kernel'ı ı ı ı ı ı
evrişim işlemini sanki bir katmanmı ı ı ı
evrişim katmanı ı
katmandaki nöron sayı ı ı
Pekiyi bu katmandaki 16 nöronun her birine kaç tane xi değeri uygulanmaktadı
3 * 3 = 9 tane. O halde bu katmanda toplam 16 nöron vardı ı
edilmesi gereken nokta bu 16 nörona uygulanan girdilerin aslı ı ı ı ı
Dense katmanlarda olduğu gibi her xi için farklı ı ı ı ı ı
değeri kullanı ı ı ı
İşte 3 * 3 = 9 tane w değerinin konumlandı ı ı
toplama işlemine sokulacaktı ı ı ı ı
değerleri dot product işlemine sokulduğu için toplamda tek bir bias değeri söz konusu olmaktadı
eğitilebilir parametrelerin sayı ı ı
işlemine sokulup bias değeriyle toplanması
sokulmaktadı
Şimdi yukarı ı ı ı ı
x11 x12 x13
x21 x22 x23
x31 x32 x33
2024-04-02 13:01:04 +03:00
Biz de 2x2'lik aşağı ı ı
2024-08-22 19:31:50 +03:00
w11 w12
w21 w22
2024-04-02 13:01:04 +03:00
2024-04-09 13:15:47 +03:00
Bu işlemin sonucu olarak padding yapı ı ı ı
çı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
activation(x11 * w11 + x12 * w12 + x21 * w21 + x22 * w22 + b) --->
activation(x12 * w11 + x13 * w12 + x22 * w21 + x23 * w22 + b) --->
activation(x21 * w11 + x22 * w12 + x31 * w21 + x32 * w22 + b) --->
activation(x22 * w11 + x23 * w12 + x32 * w21 + x33 * w22 + b) --->
2024-04-02 13:01:04 +03:00
Burada toplam 4 nöron çı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
55. Ders - 03/08/2024 - Cumartesi
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Biz yukarı ı ı ı ı ı ı ı ı
nası ı ı ı ı ı ı
farklı ı ı ı ı ı ı
bir kanala uygulanması ı ı
genel olarak 3 farklı ı
adeta biz evrişimsel ağlarda renkli resimleri evrişim işlemine soktuktan sonra onlardan gri tonlamalı
gibi oluruz. Pekiyi bu işlemde kaç tane bias değeri kullanı ı ı
kullanı ı ı ı
Dolayı ı ı ı
Örneğin biz 10x10'luk bir RGB resme evrişim uygulamak isteyelim. Kullanacağı ı
Burada her kanal için ayrı ı ı ı
parametrelerin sayı ı ı ı
(yani kaydı ı ı ı
resmin RGB olmaktan çı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Aslı ı ı
3x3'lük 32 farklı ı ı ı
artı ı ı ı ı
resmi 3x3'lük filtre kullanarak padding uygulamadan 32 farklı ı
8x8x1'lik bir hedef resim elde ediyorduk. İşte 32 farklı
göre toplamda 8x8x32'lik bir resim elde edilmiş olur.
Şimdi de 32 filtre kullandı ı ı ı ı ı ı
Bir tane filtre için yukarı ı ı ı ı ı
32 tane olduğuna göre toplam eğitilebilir parametrelerin sayı ı
olacaktı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Pekiyi 10x10'luk resmimiz gri tonlamalı ı ı ı
ne olurdu? Bu durumda 3x3'lük toplam 32 farklı ı ı
olacağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi evrişimsel sinir ağları ı ı ı ı ı
ilişkilendirmektedir. Yani onlara bir bağlam kazandı ı ı ı
komşu pixel'lerle ilişkili hale gelmektedir. Evrişimin çı ı ı ı ı
ilişkilendirilmesini sağlar. İşte bu nedenle genel olarak evrişim katmanları
ağı ı ı ı ı ı ı
network)" denilmektedir. Bu durumda ağa evrişim katmanları ı ı ı
yapmı ı ı ı ı ı ı ı ı
Ancak uygulamacı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de evrişimsel ağları ı ı ı ı ı
tipik olarak Conv2D isimli bir sı ı ı ı ı ı ı
bu anlama gelmektedir. Aslı ı ı ı
iki boyutlu olduğu için Conv2D katmanı ı ı
Conv2D sı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
tf.keras.layers.Conv2D(
filters,
kernel_size,
strides=(1, 1),
padding='valid',
data_format=None,
dilation_rate=(1, 1),
groups=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs
)
Metodun ilk 4 parametresi önemlidir. Bu 4 parametre sı ı ı ı ı ı
stride miktarı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
conv2 = Conv2D(32, (3, 3), padding='same', activation='linear')
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Burada toplam 32 filtre uygulanmı ı ı ı ı ı
"valid" değeri "padding yapı ı ı ı ı
resimle aynı ı ı ı ı ı ı ı ı ı
burada strides parametresine bir şey girmedik. Bu parametrenin default değeri (1, 1) biçimindedir. Yani kaydı
birer birer yapı ı ı ı
alı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Evrişim katmanları ı ı ı ı
olduğu için ve Dense katmanı ı ı ı ı
indirgenmesi gerekmektedir. Çok boyutlu girdileri tek boyuta indirgemek için Keras'ta Flatten isimli bir katman bulundurulmuştur.
Örneğin:
2024-04-02 13:01:04 +03:00
model = Sequential(name='MNIST')
2024-08-22 19:31:50 +03:00
model.add(Input((28, 28, 1)))
model.add(Conv2D(32, (3, 3), name='Conv2D-1', activation='relu'))
2024-04-02 13:01:04 +03:00
model.add(Conv2D(64, (3, 3), name='Conv2D-2', activation='relu'))
model.add(Flatten(name='Flatten'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
Burada giri tonlamalı ı ı ı
gri tonlamalı ı ı ı ı
32 filtre sonraki Conv2D katmanı ı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
boyuta indirgendiğini görüyorsunuz. Aslı ı ı
dönüştürmek için eReshape((-1, )) biçiminde kullanı
2024-08-22 19:31:50 +03:00
2024-04-02 13:01:04 +03:00
Bu modelden şöyle bir özet elde edilmiştir:
2024-08-22 19:31:50 +03:00
Model: "MNIST"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv2D-1 (Conv2D) │ (None, 26, 26, 32) │ 320 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv2D-2 (Conv2D) │ (None, 24, 24, 64) │ 18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Flatten (Flatten) │ (None, 36864) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 128) │ 4,718,720 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 128) │ 16,512 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 10) │ 1,290 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 4,755,338 (18.14 MB)
Trainable params: 4,755,338 (18.14 MB)
Non-trainable params: 0 (0.00 B)
Burada birinci evrişim katmanı ı ı ı ı ı ı ı ı
Ancak Conv2D katmanı ı ı ı ı
çı ı ı ı ı ı ı ı ı
gibi olur. Birinci katmandaki eğitilebilir parametrelerin sayı ı ı ı ı ı
Toplamda 1 tane bias değeri evrişim sonucundaki değerle toplanacağı ı ı
3 * 3 + 1 = 10 tane olacaktı ı ı ı ı ı
(3 * 3 + 1) * 32 = 320 tane olacaktı ı ı ı ı
kanallı ı ı ı
filtreye ihtiyaç duyulacaktı ı
söz konusu olduğunda ikinci evrişim katmanı ı ı ı
evrişim katmanı ı ı ı ı ı ı
64 * (3 * 3 * 32 + 1) = 18496 olur. İkinci evirişim katmanı ı ı ı ı ı
adeta ikinci evirişm katmanı ı ı
katmanları ı ı ı ı ı ı ı
Flatten katmanı ı ı ı ı ı ı
dikkat ediniz. Artı ı ı
sayı ı ı ı ı ı ı ı
Dense katmana girdi yapı ı ı ı ı ı ı
tane olacaktı ı ı ı
son katmandaki eğitilebilir parametrelerin sayı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-08-22 19:31:50 +03:00
training_df = pd.read_csv('mnist_train.csv')
test_df = pd.read_csv('mnist_test.csv')
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
training_dataset_x = training_df.iloc[:, 1:].to_numpy(dtype='uint8')
training_dataset_y = training_df.iloc[:, 0].to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
test_dataset_x = test_df.iloc[:, 1:].to_numpy(dtype='uint8')
test_dataset_y = test_df.iloc[:, 0]
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
# one hot encoding for y data
2024-04-02 13:01:04 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
2024-08-22 19:31:50 +03:00
# reshape as 28x28x1
2024-04-02 13:01:04 +03:00
training_dataset_x = training_dataset_x.reshape(-1, 28, 28, 1)
test_dataset_x = test_dataset_x.reshape(-1, 28, 28, 1)
2024-08-22 19:31:50 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(5, 13))
for i in range(50):
plt.subplot(10, 5, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i]
plt.imshow(picture, cmap='gray')
plt.show()
# minmax scaling
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, Flatten
model = Sequential(name='MNIST')
model.add(Input((28, 28, 1), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=20, validation_split=0.2)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
2024-04-02 13:01:04 +03:00
import numpy as np
2024-08-22 19:31:50 +03:00
import os
2024-04-02 13:01:04 +03:00
import glob
2024-08-22 19:31:50 +03:00
for path in glob.glob('Predict-Pictures/*.bmp'):
image = plt.imread(path)
gray_scaled_image = np.average(image, axis=2, weights=[0.3, 0.59, 0.11])
gray_scaled_image = gray_scaled_image.reshape(1, 28, 28, 1)
gray_scaled_image /= 255
model_result = model.predict(gray_scaled_image, verbose=0)
predict_result = np.argmax(model_result)
print(f'Real Number: {os.path.basename(path)[0]}, Prdicted Result: {predict_result}, Path: {path}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Evrişimsel ağlarda evrişim katmanları ı ı
eğitilebilir parametrelerin sayı ı ı ı ı
Pratikte 28x28 gibi resimler çok küçük olduğundan kullanı
eğilimindedir. Ayrı ı ı ı ı ı
fazla olması ı ı ı
2024-04-02 13:01:04 +03:00
- Eğitim için gereken zaman fazlalaşı
- Çok nöron olması ı
2024-08-22 19:31:50 +03:00
- Eğitim sonucunda eğitim bilgilerinin saklanması ı
2024-04-02 13:01:04 +03:00
İşte bu tür resim tanı ı ı ı ı ı
2024-08-22 19:31:50 +03:00
Bunun için ilk akla gelecek yöntem evrişim katmanları ı ı ı ı
artı ı ı ı ı ı ı ı ı
denilen yöntemdir. Bu bağlamda genellikle pooling yöntemi tercih edilmektedir.
Pooling bir grup dikdörtgensel bölgedeki pixel'ler yerine onları
aslı ı ı ı
uyguladı ı ı ı ı
"Max Pooling" yönteminde dikdörtgensel bölgedeki en büyük eleman alı ı
elemanları ı ı ı
dikdörtgensel bölgedeki en belirgin özelliğin elde edilmesine yol açmaktadı ı
resimdeki pixel değerleri aşağı
2024-04-02 13:01:04 +03:00
112 62 41 52
200 15 217 21
58 92 81 117
0 21 45 89
2024-08-22 19:31:50 +03:00
Pooling uygulayacağı ı ı ı ı ı
ve toplam 4 bölge elde edilir:
2024-04-02 13:01:04 +03:00
112 62
200 15
41 52
217 21
58 92
0 21
81 117
45 89
2024-08-22 19:31:50 +03:00
Görüldüğü gibi pooling işleminde kaydı ı ı
Pooling yönteminde bu çerçevelerin en büyük elemanları ı ı ı
2024-04-02 13:01:04 +03:00
200 217
92 117
2024-08-22 19:31:50 +03:00
Bu işlemin sonucunda elde edilen matrisin ilkinin karekökü kadar olduğuna dikkat ediniz. Yani pooling çerçevesi resmi
üstel olarak küçültmektedir.
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Tabii pooling işlemleri üç boyutlu matrisler üzerinde de uygulanabilir. Örneğin evrişim katmanı ı ı ı ı
filtre kullanı ı ı ı ı ı ı
Örneğin 26x26x32'lik bir matris üzerinde 2x2 çerçeveli pooling işlemi yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Resimsel verilerde pooling işlemleri Keras'ta tipik olarak MaxPooling2D ve AveragePooling2D sı ı ı
Sı ı ı ı ı ı ı
MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs)
AveragePooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Metotları ı ı
2x2'lik çerçeve kullanı ı ı ı ı ı
kaydı ı ı
ile aynı ı ı ı
yapı ı ı
yatayda ve düşeyde 2 kaydı ı
3 kaydı ı ı ı ı
açmaktadı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Tipik olarak Pooling katmanları ı ı ı
sonra bir tane de MaxPooling2D ya da AveragePooling2D katmanı
model = Sequential(name='MNIST')
model.add(Input((28, 28, 1), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
Modelden şöyle bir özet bilgi edilmiştir:
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Model: "MNIST"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv2D-1 (Conv2D) │ (None, 26, 26, 32) │ 320 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ MaxPooling2D-1 (MaxPooling2D) │ (None, 13, 13, 32) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv2D-2 (Conv2D) │ (None, 11, 11, 64) │ 18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ MaxPooling2D-2 (MaxPooling2D) │ (None, 5, 5, 64) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Flatten (Flatten) │ (None, 1600) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 128) │ 204,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 128) │ 16,512 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 10) │ 1,290 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 241,546 (943.54 KB)
Trainable params: 241,546 (943.54 KB)
Non-trainable params: 0 (0.00 B)
Burada katmanlardaki eğitilebilir parametrelerin sayı ı ı ı ı ı ı ı ı ı ı
hesaplandı ı ı
- Burada yine birinci Conv2D katmanı ı ı ı ı
çı ı ı ı ı ı
- Birinci MaxPoolin2D katmanı ı ı ı ı ı
Pooling işlemindeki pencere genişliği 2x2 olduğu için bu katmanı ı ı ı
- İkinci Conv2D katmanı ı ı ı ı ı
11x11x64'lük bir nöron matrisidir (padding uygulanmadı ı
- İkinci MaxPooling2D katmanı ı ı ı ı ı
Tabiibu katmanda da eğitilebilir parameteler yoktur.
- Birinci Dense katmanı ı ı
nöron vardı ı ı
- İkinci Dense katmana 128 nöron girmekte ve bu katmandan 128 nöron çı ı
parametrelerin sayı ı ı
- Çı ı ı ı ı ı ı ı ı ı ı ı
parametrelerin sayı ı ı
Toplam eğitilebilir parametrelerin sayı ı ı ı ı
değeri ile karşı ı ı ı ı ı ı ı ı ı ı
kat civarı ı ı ı ı ı ı
anlaşı ı
MNIST örneğinin pooling uygulanmı ı ı ı ı ı ı ı
her bakı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
56. Ders - 04/08/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
MNIST veri kümesi için evrişim ve pooling uygulanmı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
EPOCHS = 5
training_df = pd.read_csv('mnist_train.csv')
test_df = pd.read_csv('mnist_test.csv')
training_dataset_x = training_df.iloc[:, 1:].to_numpy(dtype='uint8')
training_dataset_y = training_df.iloc[:, 0].to_numpy(dtype='uint8')
test_dataset_x = test_df.iloc[:, 1:].to_numpy(dtype='uint8')
test_dataset_y = test_df.iloc[:, 0]
# one hot encoding for y data
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
# reshape as 28x28x1
training_dataset_x = training_dataset_x.reshape(-1, 28, 28, 1)
test_dataset_x = test_dataset_x.reshape(-1, 28, 28, 1)
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 13))
for i in range(50):
plt.subplot(10, 5, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=12, fontweight='bold')
picture = training_dataset_x[i]
plt.imshow(picture, cmap='gray')
plt.show()
# minmax scaling
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten
model = Sequential(name='MNIST')
model.add(Input((28, 28, 1), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2)
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# prediction
import numpy as np
import os
import glob
for path in glob.glob('Predict-Pictures/*.bmp'):
image = plt.imread(path)
gray_scaled_image = np.average(image, axis=2, weights=[0.3, 0.59, 0.11])
gray_scaled_image = gray_scaled_image.reshape(1, 28, 28, 1)
gray_scaled_image /= 255
model_result = model.predict(gray_scaled_image, verbose=0)
predict_result = np.argmax(model_result)
print(f'Real Number: {os.path.basename(path)[0]}, Prdicted Result: {predict_result}, Path: {path}')
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi toplamda pooling işleminin bize sağladı ı ı ı ı
ile oldukça azaltı ı ı ı
sağlamaktadı ı ı ı ı ı ı
konumlandı ı ı ı ı ı
hazı ı ı ı ı
pooling katmanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi MaxPooling işlemi ile AveragePooling işlemi arası ı
Aslı ı ı ı
Genel olarak MaxPooling işleminin resim içeisindeki belirgin öğeleri daha iyi tespit ettiği söylenebilir. Bu da pek çok
resim tanı ı ı ı ı ı
ortalama bilginin elde edilmesini sağlamaktadı ı
kaybetme eğilimindedir. MaxPoooling işleminin işlem maliyetinin AveragePooling işleminden daha az olduğuna da dikkat ediniz.
Uygulamada genellikle MaxPooling işlemi tercih edilmektedir. Ancak yukarı ı
değişebilir. Eğer mümkünse deneme yönteminin uygulanması
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
MaxPooling2D ve AveragePooling2D katmanları ı ı ı
GlobalMaxPooling2D katman sı ı ı ı ı ı ı ı
bir değer elde edilmektedir. Yani bu katmanlar girdi olarak aldı ı ı ı
Dolayı ı ı ı ı ı ı
tf.keras.layers.GlobalAveragePooling2D(
data_format=None, keepdims=False, **kwargs
)
tf.keras.layers.GlobalMaxPool2D(
data_format=None, keepdims=False, **kwargs
)
Tabii bu katman nesnelerinden önce Conv2D katmanı ı ı ı
çı ı ı ı ı
tek bir değerin elde edilmesi gerektiğinde kullanı ı ı ı
Dense katmanlardan önce uygulanmaktadı
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi pooling çerçevesi hangi büyüklükte olmalı ı ı ı ı ı ı
onları ı ı
Bu çerçevenin artı ı ı ı ı
çerçeve genişliğinin de üzerinde çalı ı ı
eğer bu yönteme sapmayacaksanı
3x3'lük ya da 4x4'lik çerçeveleri tercih edebilirsiniz. Çünkü büyük resimlerde eğitilebilir parametrelerin sayı ı
boyuta gelebilmektedir. Büyük çerçeveler bunları ı ı ı ı
ayrı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Renkli resimlerin sı ı ı ı ı ı ı
Advanced Research) isimli veri kümesidir. Bu veri kümesi tensorflow.keras.datasets paketi içerisindeki cifar10 modülünde de
bulunmaktadı ı ı
farklı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
2024-08-22 19:31:50 +03:00
Veri kümesinin orijinal https://www.cs.toronto.edu/~kriz/cifar.html adresinden indirilebilir. (Bu bağlantı ı ı ı
veri kümesinin farklı ı ı ı
kğmesini indirebilirsiniz.) Veri kümesinin CSV biçimi de https://www.kaggle.com/datasets/fedesoriano/cifar10-python-in-csv
bağlantı ı ı
test verilerini bulundurmaktadı ı ı
olabilirler. Ya da verileri 5 dosyaya bölmelerinin nedeni az veriyle denemeler yapacak kişilerin küçük bir dosyayı ı ı
sağlamak da olabilir.) Ancak bu dosyalar Python'un pickle modülü ile seri hale getirilmiştir. Bu dosyalar pickle.load ile
deserialize yapı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
dict_keys([b'batch_label', b'labels', b'data', b'filenames'])
Bizim bu 5 eğitim dosyası ı ı
2024-04-02 13:01:04 +03:00
import pickle
import glob
x_lst = []
y_lst = []
for path in glob.glob('cifar-10-batches-py/data_batch_*'):
with open(path, 'rb') as f:
d = pickle.load(f, encoding='bytes')
x_lst.append(d[b'data'])
y_lst.append(d[b'labels'])
import numpy as np
training_dataset_x = np.concatenate(x_lst)
training_dataset_y = np.concatenate(y_lst)
with open('cifar-10-batches-py/test_batch', 'rb') as f:
d = pickle.load(f, encoding='bytes')
test_dataset_x = d[b'data']
test_dataset_y = d[b'labels']
2024-08-22 19:31:50 +03:00
Buradan elde ettiğimiz matrisler iki boyutludur. Evrişim katmanları ı
Ancak resmin orijinalleri maalesef tek boyutlu hale getirilirken standrat bir eksen sistemi uygulanmamı ı
boyutlar uç uca eklenmiştir:
Tek boyutlu resmin 0'ı
Tek boyutlu resmin 1'inci boyutu ---> Gerçek resmin 0'ı ı
Tek boyutlu resmin 2'inci boyutu ---> Gerçek resmin 1'inci boyutu
Bu nedenle tek boyut olarak elde ettiğmiz resimlerin klasik RGB boyutları ı
fonksiyonundan faydalanı ı ı
training_dataset_x = training_dataset_x.reshape(-1, 3, 32, 32)
training_dataset_x = np.transpose(training_dataset_x, [0, 2, 3, 1])
test_dataset_x = test_dataset_x.reshape(-1, 3, 32, 32)
test_dataset_x = np.transpose(test_dataset_x, [0, 2, 3, 1])
Burada transpose işleminde 3 boyut değil 4 boyut kullanı ı ı ı
oluşmaktadı ı
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
import matplotlib.pyplot as plt
plt.figure(figsize=(4, 20))
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
Tabii yine resimler üzerinde minmax ölçeklemesinin yapı ı
training_dataset_x = training_dataset_x / 255
test_dataset_x = training_dataset_x / 255
Artı ı
olduğu için ve biraz daha büyük olduğu için iki yerine üç evrişim katmanı ı ı ı ı
Dense katmanlardaki nöronları ı
model = Sequential(name='CIFAR10')
model.add(Input((32, 32, 3), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
Kestirim işlemini Internet'ten rastgele resimler bulup onları
resimler "Predict-Pictures" isimli bir dizinine yerleştirilmiştir. Bulunan resimlerin 32x32'lik boyuta ölçeklenmesi hazı
programlarla yapı ı
yapmak için sı ı ı
gibi kurulabilir:
pip install pillow
Kütüphanenin dokümantasyonuna aşağı ı
https://pillow.readthedocs.io/en/stable/
PIL kütüphanesini kullanarak bir resmin ölçeklendirilip save edilmesi kabaca şöyle yapı ı
# rescale-image.py
from PIL import Image
import glob
for path in glob.glob('Predict-Pictures/*.*'):
image = Image.open(path)
resized_image = image.resize((32, 32))
image.close()
resized_image.save(path)
Burada önce glob fonksiyonu ile dizindeki tüm resim dosyaları ı ı ı
sonra da yeni boyuttaki resim orijinal formatta save edilmiştir.
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pickle
import glob
2024-08-22 19:31:50 +03:00
EPOCHS = 100
2024-04-02 13:01:04 +03:00
x_lst = []
y_lst = []
for path in glob.glob('cifar-10-batches-py/data_batch_*'):
with open(path, 'rb') as f:
d = pickle.load(f, encoding='bytes')
x_lst.append(d[b'data'])
y_lst.append(d[b'labels'])
import numpy as np
training_dataset_x = np.concatenate(x_lst)
training_dataset_y = np.concatenate(y_lst)
with open('cifar-10-batches-py/test_batch', 'rb') as f:
d = pickle.load(f, encoding='bytes')
test_dataset_x = d[b'data']
test_dataset_y = d[b'labels']
training_dataset_x = training_dataset_x.reshape(-1, 3, 32, 32)
training_dataset_x = np.transpose(training_dataset_x, [0, 2, 3, 1])
test_dataset_x = test_dataset_x.reshape(-1, 3, 32, 32)
test_dataset_x = np.transpose(test_dataset_x, [0, 2, 3, 1])
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
import matplotlib.pyplot as plt
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(4, 20))
2024-04-02 13:01:04 +03:00
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
2024-08-22 19:31:50 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten
model = Sequential(name='CIFAR10')
model.add(Input((32, 32, 3), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
import numpy as np
import os
count = 0
hit_count = 0
for path in glob.glob('Predict-Pictures/*.*'):
image = plt.imread(path)
scaled_image = image / 255
model_result = model.predict(scaled_image.reshape(-1, 32, 32, 3), verbose=0)
predict_result = np.argmax(model_result)
fname = os.path.basename(path)
real_class = fname[:fname.index('-')]
predict_class = class_names[predict_result]
print(f'Real class: {real_class}, Predicted Class: {predict_class}, Path: {path}')
if real_class == predict_class:
hit_count += 1
count += 1
print('-' * 20)
print(f'Prediction accuracy: {hit_count / count}')
#----------------------------------------------------------------------------------------------------------------------------
57. Ders - 10/08/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
2024-08-22 19:31:50 +03:00
Keras'taki hazı ı ı
veri kümesi hazı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
import glob
EPOCHS = 5
2024-04-02 13:01:04 +03:00
from tensorflow.keras.datasets import cifar10
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar10.load_data()
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
2024-08-22 19:31:50 +03:00
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(4, 20))
2024-04-02 13:01:04 +03:00
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i, 0]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
2024-08-22 19:31:50 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten
model = Sequential(name='CIFAR10')
model.add(Input((32, 32, 3), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
2024-04-02 13:01:04 +03:00
import numpy as np
2024-08-22 19:31:50 +03:00
import os
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
count = 0
hit_count = 0
for path in glob.glob('Predict-Pictures/*.*'):
image = plt.imread(path)
scaled_image = image / 255
model_result = model.predict(scaled_image.reshape(-1, 32, 32, 3), verbose=0)
predict_result = np.argmax(model_result)
fname = os.path.basename(path)
real_class = fname[:fname.index('-')]
predict_class = class_names[predict_result]
print(f'Real class: {real_class}, Predicted Class: {predict_class}, Path: {path}')
if real_class == predict_class:
hit_count += 1
count += 1
print('-' * 20)
print(f'Prediction accuracy: {hit_count / count}')
#----------------------------------------------------------------------------------------------------------------------------
CIFAR-10 vei kümesinin 100 sı ı ı
veri kümesi gibidir. Ancak resimler 10 tane sı ı ı ı ı ı ı
resimlerin 10 tane sı ı ı ı ı ı ı
Bu veri kümesi de yine aşağı ı
https://www.cs.toronto.edu/~kriz/cifar.html
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Buradaki dosya indirilip açı ı ı ı
yine Python'ı ı ı ı ı ı ı
yine bir sözlük elde edilir. y verilerini temsil eden "fine_labels" "coarse_labels" anahtarları ı
100 sı ı ı ı ı ı
import pickle
with open('cifar-100-python/train', 'rb') as f:
training_dataset = pickle.load(f, encoding='bytes')
training_dataset_x = training_dataset[b'data']
training_dataset_y = training_dataset[b'fine_labels']
with open('cifar-100-python/test', 'rb') as f:
test_dataset = pickle.load(f, encoding='bytes')
test_dataset_x = test_dataset[b'data']
test_dataset_y = test_dataset[b'fine_labels']
Resimlerin ilişkin olduğu 100 sı ı
class_names = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman',
'worm'
]
Bu örnekte de yine kestirim için kullanı ı ı
dizine çektikten sonra aşağı ı ı ı ı ı
# rescale-image.py
from PIL import Image
import glob
for path in glob.glob('Predict-Pictures/*.*'):
image = Image.open(path)
resized_image = image.resize((32, 32))
image.close()
resized_image.save(path)
Aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
import pickle
import numpy as np
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
EPOCHS = 5
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
with open('cifar-100-python/train', 'rb') as f:
2024-04-02 13:01:04 +03:00
training_dataset = pickle.load(f, encoding='bytes')
training_dataset_x = training_dataset[b'data']
training_dataset_y = training_dataset[b'fine_labels']
2024-08-22 19:31:50 +03:00
with open('cifar-100-python/test', 'rb') as f:
2024-04-02 13:01:04 +03:00
test_dataset = pickle.load(f, encoding='bytes')
test_dataset_x = test_dataset[b'data']
test_dataset_y = test_dataset[b'fine_labels']
2024-08-22 19:31:50 +03:00
training_dataset_x = training_dataset_x.reshape(-1, 3, 32, 32)
training_dataset_x = np.transpose(training_dataset_x, [0, 2, 3, 1])
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
test_dataset_x = test_dataset_x.reshape(-1, 3, 32, 32)
test_dataset_x = np.transpose(test_dataset_x, [0, 2, 3, 1])
class_names = [
2024-04-02 13:01:04 +03:00
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
2024-08-22 19:31:50 +03:00
'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm'
2024-04-02 13:01:04 +03:00
]
2024-08-22 19:31:50 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(4, 20))
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten
model = Sequential(name='CIFAR100')
model.add(Input((32, 32, 3), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(512, activation='relu', name='Hidden-1'))
model.add(Dense(512, activation='relu', name='Hidden-2'))
model.add(Dense(100, activation='softmax', name='Output'))
model.summary()
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2)
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# prediction
import numpy as np
import glob
import os
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
count = 0
hit_count = 0
for path in glob.glob('Predict-Pictures/*.*'):
image = plt.imread(path)
scaled_image = image / 255
model_result = model.predict(scaled_image.reshape(-1, 32, 32, 3), verbose=0)
predict_result = np.argmax(model_result)
fname = os.path.basename(path)
real_class = fname[:fname.index('-')]
predict_class = class_names[predict_result]
print(f'Real class: {real_class}, Predicted Class: {predict_class}, Path: {path}')
if real_class == predict_class:
hit_count += 1
count += 1
print('-' * 20)
print(f'Prediction accuracy: {hit_count / count}')
#----------------------------------------------------------------------------------------------------------------------------
58. Ders - 10/08/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı
bulunmaktadı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pickle
with open('cifar-100-python/train', 'rb') as f:
training_dataset = pickle.load(f, encoding='bytes')
training_dataset_x = training_dataset[b'data']
training_dataset_y = training_dataset[b'fine_labels']
with open('cifar-100-python/test', 'rb') as f:
test_dataset = pickle.load(f, encoding='bytes')
test_dataset_x = test_dataset[b'data']
test_dataset_y = test_dataset[b'fine_labels']
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
import numpy as np
training_dataset_x = training_dataset_x.reshape(-1, 3, 32, 32)
training_dataset_x = np.transpose(training_dataset_x, [0, 2, 3, 1])
test_dataset_x = test_dataset_x.reshape(-1, 3, 32, 32)
test_dataset_x = np.transpose(test_dataset_x, [0, 2, 3, 1])
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
class_names = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman',
'worm']
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 25))
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, Dense, Flatten, MaxPooling2D
model = Sequential(name='CIFAR-100')
model.add(Conv2D(32, (3, 3), input_shape=(32, 32, 3), name='Conv2D-1', activation='relu'))
model.add(MaxPooling2D(name='Pooling-1'))
model.add(Conv2D(64, (3, 3), name='Conv2D-2', activation='relu'))
model.add(MaxPooling2D(name='Pooling-2'))
model.add(Conv2D(128, (3, 3), name='Conv3D-3', activation='relu'))
model.add(MaxPooling2D(name='Pooling-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(512, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(100, activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(training_dataset_x, ohe_training_dataset_y, epochs=20, batch_size=32, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Categorical Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, ohe_test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
image_data = image_data / 255
predict_result = model.predict(image_data.reshape(1, 32, 32, 3))
result = np.argmax(predict_result)
print(f'{path}: {class_names[result]}')
import itertools
for picture_data in itertools.islice(training_dataset_x[np.array(training_dataset_y) == class_names.index('bowl')], 100):
plt.figure(figsize=(1, 1))
plt.imshow(picture_data)
plt.show()
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Verilerin Artı ı ı ı ı
biridir. Elimizdeki eğitim veri kümesi kı ı ı
büyütmek isteyebiliriz. Bu konuya genel olarak "verilerin artı ı ı
Verilerin artı ı ı ı ı ı
değil ilgili konuya özgü tekniklerle veri artı ı ı ı ı ı ı ı ı
verilerin artı ı ı ı ı ı ı ı ı ı
- Resimsel verilerin artı ı ı
- Metinsel verilerin artı ı ı
- İşitsel (audio) verilerin artı ı ı
- Hareketli görüntü verilerinin artı ı ı
- Veri tabloları ı ı ı
- Zamansal (temporal/time series) verilerinin artı ı ı
Verilerin artı ı ı ı ı
sinir ağları ı ı ı ı ı ı ı ı
ve katman sı ı ı ı ı
Verilerin artı ı ı ı ı ı ı ı ı ı ı ı
önemli sorunlardan biridir. Veriler artı ı ı ı ı ı ı ı
Biz bu bölümde resimsel verilerin artı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Örneğin Cifar-100 veri kümesinde eğitim için kullanabileceğimiz toplam 50000 resim vardı ı ı ı
olduğuna göre her sı ı ı ı ı
yapabilir mi? Örneklerimizde "categorical accuracy" değerinin %30 ile %40 arası
resmin 30 ile 40 arası ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Bu veri kümesindeki "yengeç (crab)" resimlerini dikkate alalı
Burada ters dönmüş bir yengeç yoktur. Buradaki yengeç resimleri hep dik bir açı
kestirim yapı ı ı ı
yengeç resimleri üzerinde manipülasyonlar yaparak garklı
bu resimleri de dahil edebiliriz.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
Verilerin artı ı ı ı ı ı ı ı
olarak bu olan kitapları ı ı ı ı ı ı
bulmak mümkündür. Bu konuya odaklanmı ı ı ı
(2023)" isimli kitaptı ı ı ı ı ı ı
bir kitap değildir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Resimsel verilerin artı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
- Resmin Çevrilmesi (Flipping): Resimlerin yatay ve düşey yönde çevrilmesiyle yeni resimlerin elde edilmesi tekniğidir.
Örneğin bir resimde bir kişi sola bakarken o resmi yatay biçimde çevirirsek o kişi sağa bakar hale gelir.
- Resmin Kı ı ı ı
ilişkin bir tekniktir. Crop işlemi genellikle merkeze yönelik yapı ı
kayı ı ı
- Yeniden Boyutlandı ı ı
yönelik tekniklerdir. Örneğin böylece bir insan daha uzun boylu, daha zayı
- Resmi Tamamlama (Padding): REsmin kenarları ı ı
- Resmi Döndürme (Rotating): Resmi belirli bir açı
- Resmin Transpose Edilmesi (Translation): Resmin eksenlere göre değişik bir biçime dönüştürülmesi tekniğidir. Burada
geometrik dönüştürmeler yapı ı
- Gürültü Eklemesi (Noise Injection): Resme resimde olmayan gürültülerin eklenmesi tekdiğidir. Örneğin resim sanki
bir sis içerisinde çekilmiş gibi bir etki oluşturulabilir. Resme dumanlar eklenebilir. Resimdeki netliğin bozulması
sağlanabilir.
- Resmin Zoom Edilmesi (Zooming): Resmin zoom-in ya da zoom-out yapı
- Resmin Karanlı ı ı ı
faha aydı ı
- Resmin Saturasyonun Değiştirilmesi (Color Sturation): Resimdeki renk dougunlukları ı
kı ı ı ı ı ı
- Resimdeki Renklerin Ötelenmesi (Hue Shifting): Resimdeki renklerin frekansları ı
getirilmesine ilişkin tekniklerdir.
- Resimdeki Bazı ı
Örneğin koyu beyaz daha açı ı
- Resimdeki Bazı ı ı ı ı ı
dolguları ı ı
- Resimlerin Birleştirilmesi (Combining): Farklı ı
ilişkin tekniklerdir.
Resimsel verilerin artı ı ı ı
uygulamacı ı ı ı ı ı ı ı
zoom edilirken çok küçük büyütme küçültme uygulanabilir. Resme gürültü eklenirken küçük gürültüler tercih edilebilir.
Resim döndürülürken küçük döndürmeler uygulanabilir. Abartı ı ı ı ı
performasnı ı
Genellikle uygulamacı ı
flip işlemi arkaı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Pekiyi bir resim tanı ı ı ı ı ı ı
2024-08-22 19:31:50 +03:00
tekniklerle çoğaltı ı ı ı ı
iyi bir yöntemdir? İşte genellikle ikinci yöntem tercih edilmektedir. Yani çoğaltma işlemi eğitimin bir önişlemi olarak
eğitim sı ı ı ı ı ı ı ı
orijinal resimlerin saklanması
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Keras'ta resimlerin artı ı ı ı ı ı
keras.layers modülünde bulundurulmuş olan katman nesneleri şunlardı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
RandomFlip
RandomRotation
RandomZoom
RandomContrast
RandomCrop
RandomBrightness
RandomTranslation
Resize
Rescaling
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
RandomFlip katmanı ı
rastgele yatay, düşey ya da her iki yönde tam çevirmektedir. RandomRtotation katmanı
dönüş açı ı ı ı ı
olarak almaktadı ı ı ı ı ı
maksimum değeri dikkate alarak rastgele biçimde zoom eder. RandomContrast resmin kontrastı ı
için kullanı ı ı ı
em-boy parametresi almaktadı
bu işlem sonucunda resmi yeniden Resize sı ı ı ı
açı ı ı ı ı ı
akşam, öğleni sabah) çekilmiş gibi bir etki oluşmaktadı ı
Resize ve Rescaling sı ı ı ı ı ı ı
biz ölçeklemeyi resmin tüm pizellerini 255'e bölerek daha önceden yapmı ı ı
Ancak bu işlem bu sı ı
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
picture = plt.imread('Sample-Pictures/AbbeyRoad.jpg')
plt.figure(figsize=(9, 16))
plt.imshow(picture);
plt.show()
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.layers import RandomFlip, RandomRotation, RandomZoom, Rescaling, RandomCrop, Resizing,
RandomContrast, RandomBrightness
rf = RandomFlip('horizontal')
result = rf(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rr = RandomRotation(0.1)
result = rr(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rz = RandomZoom(0.2)
result = rz(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rs = Rescaling(0.50)
result = rs(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rc = RandomCrop(500, 500)
result = rc(picture).numpy()
plt.figure(figsize=(9, 16))
rs = Resizing(1000, 1000)
result = rs(result).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rc = RandomContrast(0.2)
result = rc(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
rc = RandomBrightness(0.7)
result = rc(picture).numpy()
plt.figure(figsize=(9, 16))
plt.imshow(result.astype('uint8'));
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
59. Ders - 18/08/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de yukarı ı ı ı
tek yapacağı ı ı
model = Sequential(name='CIFAR100')
model.add(Input((32, 32, 3), name='Input'))
model.add(RandomFlip('horizontal'))
model.add(RandomRotation(0.1))
model.add(RandomZoom(0.2))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(512, activation='relu', name='Hidden-1'))
model.add(Dense(512, activation='relu', name='Hidden-2'))
model.add(Dense(100, activation='softmax', name='Output'))
model.summary()
Burada Input katmanı ı ı
model.add(RandomFlip('horizontal'))
model.add(RandomRotation(0.1))
model.add(RandomZoom(0.2))
Böylece aslı
uygulamalarda artı ı ı ı ı ı ı ı ı ı
sokulmamaktadı ı ı ı ı
artı ı ı ı ı ı ı ı
rastgele biçimleri işleme sokulmaktadı ı ı ı
muhtemelen düşürmüş oluruz.
Aşağı ı ı ı ı ı
Ancak bu örneği denerken bu sayı ı ı ı
sistemlerinden faydalanı
#----------------------------------------------------------------------------------------------------------------------------
import glob
EPOCHS = 5
from tensorflow.keras.datasets import cifar100
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar100.load_data()
2024-04-02 13:01:04 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
2024-08-22 19:31:50 +03:00
2024-04-02 13:01:04 +03:00
class_names = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
2024-08-22 19:31:50 +03:00
'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm'
]
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(4, 20))
2024-04-02 13:01:04 +03:00
for i in range(30):
plt.subplot(10, 3, i + 1)
2024-08-22 19:31:50 +03:00
plt.title(class_names[training_dataset_y[i, 0]], pad=10)
2024-04-02 13:01:04 +03:00
plt.imshow(training_dataset_x[i])
plt.show()
2024-08-22 19:31:50 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, RandomFlip, RandomRotation, RandomZoom, Dense, Conv2D, MaxPooling2D, Flatten
model = Sequential(name='CIFAR100')
model.add(Input((32, 32, 3), name='Input'))
model.add(RandomFlip('horizontal'))
model.add(RandomRotation(0.1))
model.add(RandomZoom(0.2))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
2024-04-02 13:01:04 +03:00
model.add(Dense(512, activation='relu', name='Hidden-1'))
2024-08-22 19:31:50 +03:00
model.add(Dense(512, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(100, activation='softmax', name='Output'))
model.summary()
2024-08-22 19:31:50 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2)
2024-04-02 13:01:04 +03:00
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-08-22 19:31:50 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-08-22 19:31:50 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-08-22 19:31:50 +03:00
# prediction
import numpy as np
import os
count = 0
hit_count = 0
for path in glob.glob('Predict-Pictures/*.*'):
image = plt.imread(path)
scaled_image = image / 255
model_result = model.predict(scaled_image.reshape(-1, 32, 32, 3), verbose=0)
predict_result = np.argmax(model_result)
fname = os.path.basename(path)
real_class = fname[:fname.index('-')]
predict_class = class_names[predict_result]
print(f'Real class: {real_class}, Predicted Class: {predict_class}, Path: {path}')
if real_class == predict_class:
hit_count += 1
count += 1
print('-' * 20)
print(f'Prediction accuracy: {hit_count / count}')
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı
gerçekleştirilebilmektedir. Ancak bu işlemlerde Tensorflow kütüphanesinin başka özelliklerinin de kullanı ı
Biz henüz Tensorflow kütüphanesinin taban kullanı ı ı ı
sürecinde Keras'ı ı ı ı ı
manuel biçimde kullanabilir ya da bu fonksiyonlardan kendi özelleştirilmiş (custom) katman nesneleri oluşturabilir. Bu
fonksiyonları ı ı
https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
ImageDataGenerator isimli bir sı ı ı ı ı ı ı ı ı
Yani "artı ı ı ı ı ı ı ı ı ı ı ı
belirtilmiştir. Bu nedenle biz artı ı ı ı ı ı ı ı
incelerken bu sı ı ı ı ı ı ı ı ı
Sı ı ı ı ı
tf.keras.preprocessing.image.ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
zca_epsilon=1e-06,
rotation_range=0,
width_shift_range=0.0,
height_shift_range=0.0,
brightness_range=None,
shear_range=0.0,
zoom_range=0.0,
channel_shift_range=0.0,
fill_mode='nearest',
cval=0.0,
horizontal_flip=False,
vertical_flip=False,
rescale=None,
preprocessing_function=None,
data_format=None,
validation_split=0.0,
interpolation_order=1,
dtype=None
)
Bu sı ı ı ı ı
1) Uygulamacı ı ı ı ı ı ı ı ı
işlemlerini parametrelere argümanlar girerek belirler. Örneğin:
idg = ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest'
)
2) Daha sonra sı ı ı ı ı ı ı ı ı ı ı
Yani flow metodu her çağrı ı ı ı ı
flow metotları ı ı ı
vermektedir. üç floaw metodu vardı
flow
floaw_from_dataframe
flow_from_directory
3) Artı ı ı
üretici fonksiyonlar verilir. Örneğin:
hist = model.fit(idg.flow(x_train, y_train, batch_size=64), epochs=50)
Pekiyi bu sı ı ı ı ı ı ı ı ı ı ı ı ı
yerine bu işlemlerin tek tek katmanlara yaptı ı ı ı ı ı ı ı ı ı ı ı ı
yönelik katman nesneleri ve tensorflow.keras.preprocessing.image modülündeki fonksiyonlar zaten bu sı ı ı ı ı ı
daha modüler biçimde yapabilmektedir. Ancak ImageDataGenerator sı ı ı ı
resimlerden önişlem yapabilmektedir. İşte bu işlemi bağı ı
da tensorflow.keras.preprocessing modülüne eklenmiştir. Sonraki paragrafta bu fonksiyonun kullanı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
tensorflow.keras.preprocessing modülündeki image_dataset_from_directory isimli fonksiyon bir dizinden hareketle oradaki
resimleri kullanı ı ı
Sonra da bu fonksiyonu çağı ı
Anı ı ı
Anı ı ı ı ı ı ı ı ı ı ı
image_dataset_from_directory fonksiyonunun parametrik yapı ı
tensorflow.keras.preprocessing.image_dataset_from_directory(
directory,
labels='inferred',
label_mode='int',
class_names=None,
color_mode='rgb',
batch_size=32,
image_size=(256, 256),
shuffle=True,
seed=None,
validation_split=None,
subset=None,
interpolation='bilinear',
follow_links=False,
crop_to_aspect_ratio=False,
pad_to_aspect_ratio=False,
data_format=None,
verbose=True
)
Uygulamacı ı ı ı ı ı
ayrı ı ı ı ı ı ı ı
üzerinde çalı ı ı ı ı ı ı ı
Images
Apple
Orange
Tabii burada dizinlere istediğimiz isimleri verebiliriz. Ancak sı ı ı ı ı
edilmektedir. İşte uygulamacı
Fonksiyonun birinci parametresi resimlerin bulunduğu dizin'in yol ifadesini almaktadı ı ı
etiketlerin nası ı ı
2024-09-16 10:49:44 +03:00
yapı ı ı ı
2024-08-22 19:31:50 +03:00
başvurabilirsiniz. label_mode parametresi default olarak 'int' biçimdedir. Bu durumda her bir kategori bir int değerle
temsil edilmektedir. (Yani y değeri olarak int değerler elde edilecektir.) Eğer bu parametreye 'categorical' girilirse
2024-09-16 10:49:44 +03:00
burada y değerleri "one-hot encoding" biçiminde oluşturulur. Eğer bu parametreye 'binary' girilirse y değerleri 0, 1
2024-08-22 19:31:50 +03:00
biçiminde oluşturulmaktadı ı ı ı ı ı ı
için 'categorical' girilmelidir. class_names parametresi sı ı ı ı
sı ı ı ı ı
nası ı ı ı
'grayscale' ya da 'rgba' biçiminde de girilebilir. batch_size parametresi bir batch'lik resmin kaç resimden oluşacağı ı
belirtmektedir. Bu sı ı ı ı ı ı
batch_size değeri bu nesnede belirtilmektedir. Fonksiyonun image_size parametresi dizinlerdeki resimlerin hangi boyuta
çekileceğini belirtmektedir. Bu parametrenin default değeri (256, 256) biçimindedir. shuffle parametresi dizinlerden
elde edilen resimlerin her epoch'ta karı ı ı ı ı ı ı ı ı
2024-09-16 10:49:44 +03:00
için dokümanlara başvurulabilir.
Örneğin yukarı ı ı
Images
Apple
Orange
Biz bu dizinden resimleri aşağı
dataset = image_dataset_from_directory('Images', label_mode='binary', image_size=(128, 128), batch_size=1)
2024-08-22 19:31:50 +03:00
2024-09-16 10:49:44 +03:00
Artı ı
eğitimde kullanabiliriz. Bir Dataset nesnesi içerisindeki bilgiler sı ı ı
take metodunun parametrik yapı ı
2024-08-22 19:31:50 +03:00
2024-09-16 10:49:44 +03:00
take(count, name=None)
Metodun count parametresi Dataset nesnesinden kaç elemanı ı ı ı
elde edilmektedir. Bu count parametresinin image_dataset_from_directory fonunda girilen batch_size parametresi ile doğrudan
bir ilgisisi yoktur. batch_size parametresi dizinden bilgilerin kaçarlı ı ı ı ı
ilgili dizinlerdeki resimleri görüntüleyen bir örnek verilmiştir.
Biz image_dataset_from_directory fonksiyonunu yalnı
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
import tensorflow
from tensorflow.keras.preprocessing import image_dataset_from_directory
dataset = image_dataset_from_directory('Images', label_mode='binary', image_size=(128, 128), batch_size=1)
batch_data = dataset.take(2)
import matplotlib.pyplot as plt
for x, y in batch_data:
image = tensorflow.cast(x[0], 'uint8')
plt.title(str(int(y)))
plt.imshow(image)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
60. Ders - 07/09/2024 - Cumartesi
2024-08-22 19:31:50 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Bir modeli eğtirken ne kadar epoch uygulamak gerekir? Epoch uygularken şu durumları ı ı
- Modeldeki loss ya da metrik değerler iyileşmedikten sonra (örneğin loss değeri düşmedikten sonra) fazla epoch uygulamanı
bir yararı ı ı ı ı
bir yargı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
- Modeli eğitirken eğitimdeki loss ya da metrik değerlerin sı ı
iyileşirken diğerinin iyileşmemesi) epoch kaynaklı
- Modelin eğitilmesi sı ı ı ı
epoch'lar bittiğinden dolayı ı
iyi değerler oluştuğu halde son durumda daha kötü değerler oluşmuş durumdadı
Pekiyi bu durumda uygun epoch sayı ı ı ı ı
loss ve metirk değerleri gözle inceleyerek uygun epoch değerinin ne olacağı
kusurları ı ı ı ı ı
durumlarda bu yöntem genellikle çalı ı ı ı
değişebilmektedir. Gözle belirleme yöntemi yerine her epoch'ta callback mekanizması ı ı ı
modeli manuel bir biçimde sonlandı ı ı ı
Ancak bu işlemler için kullanı ı ı ı ı ı ı
ModelCheckpoint isimli sı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
EarlyStopping callback sı ı ı ı ı ı ı
eğitimin otomatik sonlandı ı ı ı ı ı ı
beklenir. Yukarı
EarlyStopping callback sı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0,
patience=0,
verbose=0,
mode='auto',
baseline=None,
2024-09-16 10:49:44 +03:00
restore_best_weights=False,
start_from_epoch=0
2024-04-02 13:01:04 +03:00
)
2024-09-16 10:49:44 +03:00
Burada monitor parametresi izlenecek metrik değeri belirtir. Loss ya da metrik değerin başı
sı
"val_loss" girilirse bu dası ı
parametreye "val_accuracy" girilmelidir. min_delta parametresi iyileşme için minimum aralı ı
değer "val_loss" için 0.01 girilirse ancak 0.01'den daha fazla bir düşüş iyileşme kabul edilir.) patience parametresi üst
üste kaç kez iyileşme olmazsa eğitimin sonlandı ı ı ı
verbose parametresi 1 girilirse ekrana bilgi yazı ı ı ı
bu parametre 1 olarak girilirse ekrana daha fazla bilgi yazı ı ı ı ı
"auto" biçiminde girilebilir. "min" iyileşmenin düşüşle sağlandı ı ı ı ı ı
"auto"" ise monitor parametresine göre bunun otomatik belirleneceği anlamı ı
için eşik değerin belirlenmesini sağlamaktadı ı ı
en iyi loss ya da metrik değerin bulunduğu epoch'a ilişkin nöron ağı ı
geçilirse (default durum) modelin sonlandı ı ı ı ı ı ı ı
parametresi yeni versiyonlarda eklenmiştir. Bu parametre bu mekanizmanı ı ı ı ı ı
belirtmektedir. Örneğin:
esc = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=EPOCHS,
Burada "val_loss" değerinde üst üste 3 kez iyileşme olmadı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Aşağı
sonlandı ı ı ı ı ı ı ı ı
arası ı ı ı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
...
val_loss: 16.5277 - val_mae: 2.9099
Epoch 17/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 15.6860 - mae: 2.7044 - val_loss: 16.0524 - val_mae: 2.8168
Epoch 18/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 15.7328 - mae: 2.6971 - val_loss: 16.0958 - val_mae: 2.8007
Epoch 19/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 19.8981 - mae: 2.8945 - val_loss: 15.7974 - val_mae: 2.7772
Epoch 20/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 13.1439 - mae: 2.5510 - val_loss: 17.2526 - val_mae: 2.8939
Epoch 21/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 14.5947 - mae: 2.5541 - val_loss: 15.7460 - val_mae: 2.7190
Epoch 22/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 11.9902 - mae: 2.4701 - val_loss: 17.3226 - val_mae: 2.8476
Epoch 23/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 12.7140 - mae: 2.4168 - val_loss: 17.7918 - val_mae: 2.8993
Epoch 24/200
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 15.0356 - mae: 2.5725 - val_loss: 16.6013 - val_mae: 2.6930
Epoch 24: early stopping
Restoring model weights from the end of the best epoch: 21.
Burada epoch'lardaki "val_loss" değerlerini inceleyiniz. Bu "val_loss" değerleri üst üste 3 kez iyileşmediğinde eğitim
sonlandı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
2024-09-16 10:49:44 +03:00
EPOCHS = 200
2024-04-02 13:01:04 +03:00
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
2024-09-16 10:49:44 +03:00
highway_class = df.iloc[:, 8].to_numpy()
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False)
ohe_highway = ohe.fit_transform(highway_class.reshape(-1, 1))
dataset_y = df.iloc[:, -1].to_numpy()
df.drop([8, 13], axis=1, inplace=True)
dataset_x = pd.concat([df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-09-16 10:49:44 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.preprocessing import StandardScaler
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.callbacks import EarlyStopping
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Sequential(name='Boston-Housing-Prices')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
2024-04-02 13:01:04 +03:00
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
2024-09-16 10:49:44 +03:00
model.compile('rmsprop', loss='mse', metrics=['mae'])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
esc = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True, verbose=1)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
2024-09-16 10:49:44 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
predict_df = pd.read_csv('predict-boston-housing-prices.csv', delimiter=r'\s+', header=None)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
highway_class = predict_df.iloc[:, 8].to_numpy()
ohe_highway = ohe.transform(highway_class.reshape(-1, 1))
predict_df.drop(8, axis=1, inplace=True)
predict_dataset_x = pd.concat([predict_df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x )
predict_result = model.predict(scaled_predict_dataset_x)
2024-04-02 13:01:04 +03:00
for val in predict_result[:, 0]:
print(val)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Aşağı
sonlandı ı ı ı ı ı ı ı ı
Programı ı ı ı ı ı ı ı ı
...
Epoch 11/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 11ms/step - categorical_accuracy: 0.8262 - loss: 0.5247 - val_categorical_accuracy: 0.6999 - val_loss: 1.1722
Epoch 12/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 15s 12ms/step - categorical_accuracy: 0.8330 - loss: 0.5094 - val_categorical_accuracy: 0.7127 - val_loss: 1.0260
Epoch 13/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 11ms/step - categorical_accuracy: 0.8380 - loss: 0.4906 - val_categorical_accuracy: 0.6487 - val_loss: 1.5351
Epoch 14/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 11ms/step - categorical_accuracy: 0.8349 - loss: 0.4990 - val_categorical_accuracy: 0.7041 - val_loss: 1.2637
Epoch 15/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 11ms/step - categorical_accuracy: 0.8427 - loss: 0.4849 - val_categorical_accuracy: 0.7015 - val_loss: 1.2270
Epoch 16/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 11ms/step - categorical_accuracy: 0.8454 - loss: 0.4817 - val_categorical_accuracy: 0.6969 - val_loss: 1.2923
Epoch 17/200
1250/1250 ━━━━━━━━━━━━━━━━━━━━ 14s 12ms/step - categorical_accuracy: 0.8418 - loss: 0.4924 - val_categorical_accuracy: 0.6973 - val_loss: 1.7678
Epoch 17: early stopping
Restoring model weights from the end of the best epoch: 12.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
import glob
EPOCHS = 200
2024-04-02 13:01:04 +03:00
from tensorflow.keras.datasets import cifar10
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar10.load_data()
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
2024-09-16 10:49:44 +03:00
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(4, 20))
2024-04-02 13:01:04 +03:00
for i in range(30):
plt.subplot(10, 3, i + 1)
plt.title(class_names[training_dataset_y[i, 0]], pad=10)
plt.imshow(training_dataset_x[i])
plt.show()
2024-09-16 10:49:44 +03:00
scaled_training_dataset_x = training_dataset_x / 255
scaled_test_dataset_x = test_dataset_x / 255
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.utils import to_categorical
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten
2024-04-02 13:01:04 +03:00
from tensorflow.keras.callbacks import EarlyStopping
2024-09-16 10:49:44 +03:00
model = Sequential(name='CIFAR10')
model.add(Input((32, 32, 3), name='Input'))
model.add(Conv2D(32, (3, 3), activation='relu', name='Conv2D-1'))
model.add(MaxPooling2D(name='MaxPooling2D-1'))
model.add(Conv2D(64, (3, 3), activation='relu', name='Conv2D-2'))
model.add(MaxPooling2D(name='MaxPooling2D-2'))
model.add(Conv2D(128, (3, 3), activation='relu', name='Conv2D-3'))
model.add(MaxPooling2D(name='MaxPooling2D-3'))
model.add(Flatten(name='Flatten'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
esc = EarlyStopping(monitor='val_categorical_accuracy', patience=5, restore_best_weights=True, verbose=1)
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
2024-09-16 10:49:44 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , ohe_test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
# prediction
import numpy as np
import os
count = 0
hit_count = 0
for path in glob.glob('Predict-Pictures/*.*'):
image = plt.imread(path)
scaled_image = image / 255
model_result = model.predict(scaled_image.reshape(-1, 32, 32, 3), verbose=0)
predict_result = np.argmax(model_result)
fname = os.path.basename(path)
real_class = fname[:fname.index('-')]
predict_class = class_names[predict_result]
print(f'Real class: {real_class}, Predicted Class: {predict_class}, Path: {path}')
if real_class == predict_class:
hit_count += 1
count += 1
print('-' * 20)
print(f'Prediction accuracy: {hit_count / count}')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
ModelCheckpoint sı ı ı ı ı ı ı ı ı ı
metodunun parametrik yapı ı
tf.keras.callbacks.ModelCheckpoint(
filepath,
monitor='val_loss',
verbose=0,
save_best_only=False,
save_weights_only=False,
mode='auto',
2024-09-16 10:49:44 +03:00
save_freq='epoch',
initial_value_threshold=None
2024-04-02 13:01:04 +03:00
)
2024-09-16 10:49:44 +03:00
Metodun birinci parametresi modelin save edileceği dosyanı ı ı ı
içeren biçimde) olabilmektedir. Metot birden fazla save işlemi yapacaksa bu parametrede dosya ismi kalı
kullanı ı ı
hangi loss ya da metrik değere dayalı ı ı ı
bilgi ekrana yazdı ı ı ı
parametresi yine EarlyStopping sı ı ı
parametre True geçilirse tüm model değil yalnı ı ı ı ı ı
val_loss değerinin en iyi olduğu durumdaki modeli save etmekse ModelCheckpoint nesnesini aşağı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
mcp = ModelCheckpoint('boston-checkpoint.keras', monitor='val_loss', save_best_only=True)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada save_best_only parametresi True girildiği için yalnı
Bu callback sı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı
için metodun birinci parametresine bir kalı ı
save_best_only parametresi False geçilirse tüm epoch'lardaki ağı ı ı
Eğer save_best_only parametresi True geçilirse bu durumda yalnı ı
uygun dosya isimleriyle save edilmektedir. Eğer dosya isminde bir kalı ı
False geçilirse son epoch'taki değerler save edilir. Eğer dosya isminde kalı ı
True geçilirse bu durumda en iyi model save edilmiş olacaktı ı ı
başka bir dosya üzerinde yap" anlamı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
- Metodun birinci parametresine kalı
kalı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
- Metodun birinci parametresine kalı ı
öncekine göre daha iyi olan epoch değerleri kalı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
- Metodun birinci parametresine kalı
değerler save edilir.
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Metodun birinci parametresine kalı ı
monitor değerleri save edilir.
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Kalı ı
değerini iki basamak olarak (tek basamaksa 0 ile doldurarak)" oluşturma anlamı ı ı ı ı
dokümanları
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
mcp = ModelCheckpoint('boston-checkpoint-{epoch:03d}.keras', monitor='val_loss', save_best_only=True)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada "val_loss" metrik değeri daha öncekilere göre iyi olan epoch ile karşı ı ı ı
(burada NN epoch numarası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
61. Ders - 08/09/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
Kodun ilgili kı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
mcp = ModelCheckpoint('Boston-Housing-{epoch:03d}.keras', monitor='val_loss', save_best_only=True)
esc = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True, verbose=1, mode='min')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=EPOCHS,
validation_split=0.2, callbacks=[mcp, esc])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada "val_loss" değerinde her yeni iyileşmede model "Boston-Housing-NNN.keras" ismiyle save edilecektir. Aynı
5 kez üst üste "val_loss" değeri iyileşmediği takdirde eğitim sonlandı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
EPOCHS = 200
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
highway_class = df.iloc[:, 8].to_numpy()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.preprocessing import OneHotEncoder
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
ohe = OneHotEncoder(sparse=False)
ohe_highway = ohe.fit_transform(highway_class.reshape(-1, 1))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_y = df.iloc[:, -1].to_numpy()
df.drop([8, 13], axis=1, inplace=True)
dataset_x = pd.concat([df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.model_selection import train_test_split
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
model = Sequential(name='Boston-Housing-Prices')
model.add(Input((training_dataset_x.shape[1], ), name='Input'))
model.add(Dense(64, activation='relu', name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
mcp = ModelCheckpoint('Boston-Housing-{epoch:03d}.keras', monitor='val_loss', save_best_only=True)
esc = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True, verbose=1, mode='min')
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=EPOCHS, validation_split=0.2, callbacks=[mcp, esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
2024-09-16 10:49:44 +03:00
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
predict_df = pd.read_csv('predict-boston-housing-prices.csv', delimiter=r'\s+', header=None)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
highway_class = predict_df.iloc[:, 8].to_numpy()
ohe_highway = ohe.transform(highway_class.reshape(-1, 1))
predict_df.drop(8, axis=1, inplace=True)
predict_dataset_x = pd.concat([predict_df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x )
predict_result = model.predict(scaled_predict_dataset_x)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
for val in predict_result[:, 0]:
print(val)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Kursumuzun bu noktası ı ı ı
öğrenmesini çeşitli biçimlerde kullanacağı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Aktarı ı ı ı
olan şeylerin başka öğrenmeleri etkilemesi sürecini" belirtmektedir. Örneğin İngilizce bilen bir kişi Almanca'yı ı
diller olduğu halde) daha kolay öğrenebilmektedir. Psikolojide aktarı
Eğer önceden öğrenilen malzemeler sonradan öğrenilecekleri olumlu biçimde destekliyorsa buna "pozitif aktarı
bir biçimde etkiliyorsa buna da "negatif aktarı
hiç klavye kullanmamı ı
olduğu gibi önceden öğrenilmiş malzemenin sonraki öğrenmede olumu bir biçimde kullanı ı ı ı
öğrenmesi sayesinde önceden eğitilmiş (pretrained) ağları ı ı ı
bir resim veritabanı ı ı ı ı ı ı ı ı ı ı
save edilmiş olabilir. Biz de kendi resim sı ı ı ı
eğitilmiş modelin bizim hedefimize yönelik eğitilmiş olması ı
100 farklı ı ı ı ı ı ı
bu tür modellerde aslı ı ı ı
eğitilmiş model bizim hedeflerimiz için eğitilmemiş olsa da yine bizim modelimizde önemli faydalar sağlayabilecektir.
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Aktarı ı ı ı
Şüphesiz aktarı
Keras'ta önceden eğitilmiş modelleri kullanamdan da başkaları ı
kullanabiliriz.
Tipik olarak önceden eğitilmiş modellerle aktarı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
1) Aktarı ı ı ı
kullanı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
2) Önceden eğitilmiş modelin çı ı ı ı ı ı ı
sinir ağı ı ı ı ı ı ı ı ı
önceden eğitilmiş modelin çı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Girdiler ---> önceden eğitilmiş model ---> uygulamacı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
3) Modelin uygulamacı ı ı
eklemiş olsa da modelin yine uygulamacı ı ı
kendi verileriyle ayrı ı ı
örtüşüyorsa ayrı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Keras'ı ı ı ı ı
nesneleri hep modelin sonuna ekleniyordu. Ayrı ı ı ı
çı ı ı ı ı ı
ağı ı ı ı ı ı ı
hem bir kategorik değer hem de gerçek bir değerden oluşabilmektedir. Örneğin bir resim ve bir yazı
olsun. Kişi resme balkı ı ı ı ı
içermektedir. Biz şimdiye kadar yalnı ı ı ı
Böyle bir modelin girdisi için iki girdi katmanı ı ı
bir girdi katmanı ı ı ı ı ı
bir yazı ı ı ı ı ı ı ı ı
sahip olan modeller de Sequential sı ı ı ı ı
kalabilmektedir. Bu nedenle bu tür uygulamalarda daha aşağı
model aslı ı ı
kütüphanedir. Sequential model aslı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
62. Ders - 14/09/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Ası ı ı ı
katman sı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dense1 = Dense(256, activation='relu', name='Dense-1')
dense2 = Dense(256, activation='relu', name='Dense-2')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada aslı ı ı ı ı ı ı ı
değerleri verilir. Metot da onları ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
result = dense1(data)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Şimdi bu çı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
result = dense2(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Yani aslı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
inp = Input(...)
d1 = Dense(...)
d2 = Dense(...)
d3 = Dense(...)
d4 = Dense(...)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
result = d1(inp)
result = d2(result)
result = d3(result)
out = d4(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Yukarı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
inp = Input(...)
result = Dense(...)(inp)
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(...)(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada önemli bir nokta üzerinde durmak istiyoruz. Tensorflow ve PyTorch gibi kütüphaneler bir çeşit "meta programlama"
kütüphaneleridir. Yani bu programlama modelinde önce işlemi yapacak kodlar oluşturulur. Sonra onlar çalı ı ı ı ı
hangi işlemlerin yapı ı ı ı ı ı ı ı ı ı
deyişle biz yukrı ı ı ı
kütüphanesinin 2'li versiyonları ı ı ı ı ı
eklenmiştir. Bu konuları ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Örneğin biz bir Dense katmanı ı ı
sonra artı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import numpy as np
from tensorflow.keras.layers import Dense
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
data = np.random.random((32, 8))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
d = Dense(16, activation='relu', name='Dense')
result = d(data).numpy()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Katman nesnelerinin bir grup satı ı ı ı ı ı ı ı ı ı ı
bir grup satı ı ı ı
oluşturulup bu dizi Dense katmana verilmiştir. Tensorflow'da katman nesneleri Tensor alı
yerine bazı ı ı ı
nesnesi elde edilmiştir. Biz de bu Tensor nesnesini yeniden NumPy dizisine dönüştürdük. Yukarı
NumPy dizisi (32, 16) boyutları ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Fonksiyonel olarak oluşturduğumuz yapı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
inp = Input(...)
result = Dense(...)(inp)
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Burada sonuçta bir girdi bir de çı ı ı ı ı
bir Model nesnesinin yaratı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı
tensörünü almaktadı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Model(inputs=inp, outputs=out, name='MyModel')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Aslı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Sequential('MyModel')
model.add(Input(...))
model.add(Dense(...)
model.add(Dense(...))
model.add(Dense(...))
model.add(Dense(...))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Aslı ı ı ı ı ı ı ı
yardı ı ı ı ı ı ı
Yani aslı ı ı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
class Sequential:
def __init__(self):
self.result = None
def add(self, layer):
if self.result is None:
self.inp = layer
self.result = self.inp
else:
self.result = self.result(layer)
def compile(self, *args):
self.model = Model(inputs=self.inp, outputs=self.result)
# ....
Tensör kavramı ı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Şimdi daha önce yapmı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras import Model
from tensorflow.keras.layers import Input, Dense
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
inp = Input((training_dataset_x.shape[1], ), name='Input')
result = Dense(64, activation='relu', name='Hidden-1')(inp)
result = Dense(64, activation='relu', name='Hidden-2')(result)
out = Dense(dataset_y.shape[1], activation='softmax', name='Output')(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Model(inputs=inp, outputs=out, name='FunctionalModel')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Görüldüğü gibi modelde bir girdi katmanı ı ı ı ı ı ı ı
verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
df = pd.read_csv('Iris.csv')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_x = df.iloc[:, 1:-1].to_numpy(dtype='float32')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.preprocessing import OneHotEncoder
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
ohe = OneHotEncoder(sparse_output= False)
dataset_y = ohe.fit_transform(df.iloc[:, -1].to_numpy().reshape(-1, 1))
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-09-16 10:49:44 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.preprocessing import StandardScaler
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Input
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
inp = Input((training_dataset_x.shape[1], ), name='Input')
result = Dense(64, activation='relu', name='Hidden-1')(inp)
result = Dense(64, activation='relu', name='Hidden-2')(result)
out = Dense(dataset_y.shape[1], activation='softmax', name='Output')(result)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Model(inputs=inp, outputs=out, name='FunctionalModel')
model.summary()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.compile('rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(14, 6))
plt.title('Categorcal Accuracy - Validation Categorical Accuracy', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-09-16 10:49:44 +03:00
scaled_test_dataset_x = ss.transform(test_dataset_x)
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
predict_dataset_x = pd.read_csv('predict-iris.csv').to_numpy(dtype='float32')
scaled_predict_dataset_x = ss.transform(predict_dataset_x)
import numpy as np
predict_result = model.predict(scaled_predict_dataset_x)
predict_indexes = np.argmax(predict_result, axis=1)
for pi in predict_indexes:
print(ohe.categories_[0][pi])
"""
predict_categories = ohe.categories_[0][predict_indexes]
print(predict_categories)
"""
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
oluşturulma biçimi önceki örnekle benzerdir:
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Input
inp = Input((training_dataset_x.shape[1], ), name='Input')
result = Dense(64, activation='relu', name='Hidden-1')(inp)
result = Dense(64, activation='relu', name='Hidden-2')(result)
out = Dense(1, activation='linear', name='Output')(result)
model = Model(inputs=inp, outputs=out, name='BostonHousingPrices')
model.summary()
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
highway_class = df.iloc[:, 8].to_numpy()
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False)
ohe_highway = ohe.fit_transform(highway_class.reshape(-1, 1))
dataset_y = df.iloc[:, -1].to_numpy()
df.drop([8, 13], axis=1, inplace=True)
dataset_x = pd.concat([df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Input
inp = Input((training_dataset_x.shape[1], ), name='Input')
result = Dense(64, activation='relu', name='Hidden-1')(inp)
result = Dense(64, activation='relu', name='Hidden-2')(result)
out = Dense(1, activation='linear', name='Output')(result)
model = Model(inputs=inp, outputs=out, name='BostonHousingPrices')
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x , test_dataset_y, batch_size=32)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
"""
import pickle
model.save('boston-housing-prices.h5')
with open('boston-housing-prices.pickle', 'wb') as f:
pickle.dump([ohe, ss], f)
"""
predict_df = pd.read_csv('predict-boston-housing-prices.csv', delimiter=r'\s+', header=None)
highway_class = predict_df.iloc[:, 8].to_numpy()
ohe_highway = ohe.transform(highway_class.reshape(-1, 1))
predict_df.drop(8, axis=1, inplace=True)
predict_dataset_x = pd.concat([predict_df, pd.DataFrame(ohe_highway)], axis=1).to_numpy()
scaled_predict_dataset_x = ss.transform(predict_dataset_x )
predict_result = model.predict(scaled_predict_dataset_x)
for val in predict_result[:, 0]:
print(val)
#----------------------------------------------------------------------------------------------------------------------------
2024-10-11 00:32:36 +03:00
Bir kestirim modelinde veriler farklı ı
2024-09-16 10:49:44 +03:00
diğerleri sayı ı ı
veri kümeleri de denilmektedir. ("Multimodal" sözcüğü aslı ı ı
Buradaki "modalite"" farklı ı ı
gibi karı ı ı ı ı ı
gerekmektedir. Farklı ı ı ı
gerekir. Tipik olarak bu girdi karmanları ı ı
Concatenate katmanı ı ı ı ı
inp1 = Input(...)
...
inp2 = Input(...)
...
result = Concatenate()([inp1, inp2])
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(...)(result)
Aslı ı ı ı ı ı ı
Concatenate katmanı ı
inp1 = Input(...)
...
inp2 = Input(...)
...
result = concatenate([inp1, inp2])
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(...)(result)
Bu biçimde birden fazla girdi katmanı ı ı ı ı
bir liste biçiminde (liste olması
model = Model(inputs=[inp1, inp2], outputs=out)
Burada şöyle bir model oluşturulmuştur:
inp1 ---> .... --->
Dense ---> Dense ----> Dense (output)
inp2 ---> ... ---->
Pekiyi yukarı ı ı ı
girdileri bir liste ile (liste olmak zorunda değil) ayrı ı
model.fit([training_dataset_x1, training_dataset_x2], training_dataset_y, ...)
Tabii yukarı ı ı
training_dataset_x2 veri kümeleri bu parçaları ı ı
metodunda yine x verileri bir liste biçiminde verilmelidir:
eval_result = model.evaluate([test_dataset_x1, test_dataset_x2], test_dataset_y)
Burada test verilerinin de iki parça haline oluşturulduğuna dikkat ediniz. test_datset_x1 ve test_dataset_x2 bu parçaları
temsil etmektedir.
Benzer biçimde kestirim işleminde de predict metodunda x verileri bir liste biçiminde (liste olmak zorunda değil) girilir.
Örneğin:
predict_result = model.predict([predict_dataset_x1, predict_dataset_x2])
Burada predict_dataset_x1 ve predict_dataset_x2 bu parçaları
Birden fazla girdiye sahip olan modellerde özellik ölçeklemesi iki model birleştirildiğinde uyumlu olacak biçimde yapı ı ı
Bunun için girişlere tür olarak aynı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
63. Ders - 15/09/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
örneği verilmiştir. Örnekte veri kümesinin nümerik kı ı ı ı ı ı ı ı
Concateb-nate katmanı ı ı ı ı ı
şöyledir:
inp1 = Input(shape=(training_dataset_x1.shape[1], ), name='Numeric-Input')
inp2 = Input(shape=(1, ), dtype='string', name='Text-Input')
tv = TextVectorization(output_mode='count')
tv.adapt(training_dataset_x2)
result = tv(inp2)
result = Concatenate()([inp1, result])
result = Dense(128, activation='relu', name='Hidden-1')(result)
result = Dense(128, activation='relu', name='Hidden-2')(result)
out = Dense(1, activation='linear', name='Output')(result)
model = Model(inputs=[inp1, inp2], outputs=[out], name='MixedRandomModel')
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
hist = model.fit([scaled_training_dataset_x1, training_dataset_x2], training_dataset_y,
batch_size=32, epochs=100, validation_split=0.2)
Bu örnekte "dataset.csv" dosyası ı ı
oluşturduğuğu CSV dosyası ı
"Yaş","Gelir","Harcamalar","Kredi_Skoru","İnternet_Aboneliği","Yorum","Puan"
56,39930,21657,733,3,"Güzel hizmet, ama daha iyi olabilir.",326
69,33285,35347,622,19,"Harika ürünler!",889
46,65863,15314,721,10,"Ürünler kaliteli, ama fiyatlar yüksek.",481
32,46704,28840,740,14,"Yine de memnun kaldı
60,48705,18662,683,19,"Yine de memnun kaldı
25,30555,27754,705,11,"Beklentilerimin altı
38,51323,17629,663,21,"Güzel hizmet, ama daha iyi olabilir.",946
56,96922,21324,724,6,"Beklediğimden daha iyi.",376
36,83915,35247,651,19,"Güzel hizmet, ama daha iyi olabilir.",651
40,40619,27558,647,14,"Kaliteli, ama fiyat biraz yüksek.",14
28,89274,26494,660,8,"İnternetten daha iyi bekliyordum.",899
28,51225,29943,616,2,"Harika ürünler!",695
41,56739,16692,639,22,"Harika ürünler!",480
.....
Kestirim için kullanı ı ı
"Yaş","Gelir","Harcamalar","Kredi_Skoru","İnternet_Aboneliği","Yorum"
61,37642,24599,716,18,"Yine de memnun kaldı
47,85556,14872,735,11,"Beklediğimden daha iyi."
55,63760,37547,672,9,"İnternetten daha iyi bekliyordum."
19,68192,20573,644,8,"Yine de memnun kaldı
38,34381,23691,616,21,"Hizmet çok iyi, teşekkürler."
50,49558,21482,676,8,"Kaliteli, ama fiyat biraz yüksek."
29,60782,14753,736,5,"Ürünler kaliteli, ama fiyatlar yüksek."
39,34782,11833,690,13,"Harika ürünler!"
61,84712,15928,705,7,"Beklentilerimin altı
42,49462,18645,700,21,"İnternetten daha iyi bekliyordum."
66,90030,16816,702,5,"Yeterli bir deneyim."
44,98519,27124,623,13,"Ürünler kaliteli, ama fiyatlar yüksek."
59,86411,17256,672,20,"Beklentilerimin altı
45,85206,28764,720,16,"Yine de memnun kaldı
33,76950,20549,705,14,"Yeterli bir deneyim."
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
# create-random-mixed-data.py
import pandas as pd
import numpy as np
import csv
import random
# Random veri üretimi için seed
np.random.seed(42)
random.seed(42)
num_rows = 10000
data = {
'Yaş': np.random.randint(18, 70, size=num_rows),
'Gelir': np.random.randint(30000, 100000, size=num_rows),
'Harcamalar': np.random.randint(10000, 40000, size=num_rows),
'Kredi_Skoru': np.random.randint(600, 750, size=num_rows),
'İnternet_Aboneliği': np.random.randint(1, 25, size=num_rows),
'Yorum': [random.choice(["Harika ürünler!", "Güzel hizmet, ama daha iyi olabilir.",
"Beklentilerimin altı ı
"Yeterli bir deneyim.", "İnternetten daha iyi bekliyordum.", "Hizmet çok iyi, teşekkürler.",
"Beklediğimden daha iyi.", "Kaliteli, ama fiyat biraz yüksek."])
for _ in range(num_rows)],
'Puan': np.random.randint(0, 1000, size=num_rows),
}
df = pd.DataFrame(data)
df.to_csv('dataset.csv', quoting=csv.QUOTE_NONNUMERIC, index=False)
print("Veri kümesi 'dataset.csv' olarak kaydedildi.")
# mixed-numeric-text-random.py
import pandas as pd
dataset = pd.read_csv('dataset.csv')
dataset_x = dataset.iloc[:, :-1]
dataset_y = dataset.iloc[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.1)
training_dataset_x1 = training_dataset_x.iloc[:, :-1].to_numpy(dtype='float32')
training_dataset_x2 = training_dataset_x.iloc[:, -1]
test_dataset_x1 = test_dataset_x.iloc[:, :-1].to_numpy(dtype='float32')
test_dataset_x2 = test_dataset_x.iloc[:, -1]
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x1)
scaled_training_dataset_x1 = ss.transform(training_dataset_x1)
scaled_test_dataset_x1 = ss.transform(test_dataset_x1)
from tensorflow.keras import Model
from tensorflow.keras.layers import Input, TextVectorization, Dense, Concatenate
inp1 = Input(shape=(training_dataset_x1.shape[1], ), name='Numeric-Input')
inp2 = Input(shape=(1, ), dtype='string', name='Text-Input')
tv = TextVectorization(output_mode='count')
tv.adapt(training_dataset_x2)
result = tv(inp2)
result = Concatenate()([inp1, result])
result = Dense(128, activation='relu', name='Hidden-1')(result)
result = Dense(128, activation='relu', name='Hidden-2')(result)
out = Dense(1, activation='linear', name='Output')(result)
model = Model(inputs=[inp1, inp2], outputs=[out], name='MixedRandomModel')
model.summary()
model.compile('rmsprop', loss='mse', metrics=['mae'])
hist = model.fit([scaled_training_dataset_x1, training_dataset_x2], training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Mean Absolute Error - Validation Mean Absolute Error Graph', fontsize=14, pad=10)
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate([scaled_test_dataset_x1, test_dataset_x2], test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_dataset = pd.read_csv('predict.csv')
predict_dataset_x1 = predict_dataset.iloc[:, :-1]
predict_dataset_x2 = predict_dataset.iloc[:, -1]
scaled_predict_dataset_x1 = ss.transform(predict_dataset_x1)
predict_result = model.predict([scaled_predict_dataset_x1, predict_dataset_x2])
for val in predict_result[:, 0]:
print(val)
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde çok çı ı ı ı ı
çı ı ı ı ı ı ı
Çok çı ı ı ı ı ı ı ı ı ı
tanesi "olumlu", "olumsuz" biçiminde iki sı ı ı ı ı ı ı ı
olarak şöyle gösterbiliriz:
Dense (sigmoid activation, binary_crossentropy loss, binary_accuracy metrics)
Input --> Dense ---> Dense
Dense (linear activation, mean_squared_error loss, mean_absolte_error metrics)
Bu modelin oluşturulması ı ı
inp = Input(..., name='Input')
result = Dense(..., name='Hidden-1')(inp)
result = Dense(..., name=''Hidden-2)(result)
out1 = Dense(..., name='Output-1')(result)
out2 = Dense(..., name='Output-2')(result)
model = Model(inputs=inp, outputs=[out1, out2])
Burada Model nesnesi oluşturulurken outputs parametresinin iki çı ı ı
dikkat ediniz. Pekiyi bu model nası
Çok çı ı ı ı ı ı ı
türüne göre farklı ı ı ı ı ı ı ı
loss fonksiyonunu kullanmak gerekir. Çı ı ı ı
loss fonksiyonunu kullanmak gerekir. Biz şimdiye kadar compile metodunda loss fonksiyonu olarak bir tane fonksiyon belirttik.
Ancak aslı ı ı ı ı ı ı
loss parametresinde bir liste (liste olmak zorunda değil) ya da sözlük girilebilir. Eğer loss fonksiyonları
buradaki sı ı ı ı ı ı
loss fonksiyonları ı
değerleri de loss fonksiyonları ı ı ı
model.compile(optimizer='rmsprop', loss=['binary_crossentropy', 'mse'], ...)
Ya da örneğin:
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_corssentropy', 'Output-2': 'mse'}, ...)
Pekiyi iki tane loss fonksiyonu olduğuna göre hangisi minimize edilmeye çalı ı ı
toplamanı ı ı ı ı ı ı
çı ı ı ı ı ı ı
Bu parametreye ağı ı ı ı ı
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_corssentropy, 'Output-2': 'mse'},
loss_weights={'Output-1': 1, 'Output-2': 0.1}, ...)
Bu örnekte toplam loss değeri hesaplanı ı ı ı ı
çarpı ı ı ı ı ı
Çok çı ı ı ı ı ı ı ı ı
göre değişmektedir. İşte her çı ı ı
zorunda değil) biçiminde belirtilebilmektedir. Örneğin:
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_corssentropy, 'Output-2': 'mse'},
loss_weights={'Output-1': 1, 'Output-2': 0.1}, metrics={'Output-1': ['binary_accuracy'], 'Output-2': ['mse']}, ...)
Ya da örneğin:
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_corssentropy, 'Output-2': 'mse'},
loss_weights={'Output-1': 1, 'Output-2': 0.1}, metrics=[['binary_accuracy'], ['mse']], ...)
Modelin test edilmesinde yine çı ı ı ı ı ı
biçiminde (liste olmak zorunda değil) girilmelidir. Örneğin:
eval_result = model.evaluate(test_dataset_x, [test_dataset_y1, test_dataset_y2])
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict metodu bize bir liste vermektedir. Listenin elemanları ı ı ı ı ı ı ı
değerleri de aslı
predict_result = model.predict(predict_data.reshape(1, -1))
print(predict_result[0][0, 0], predict_result[1][0, 0])
Aşağı ı ı
kümeleri rastgele değerlerle oluşturulmuştur.
#----------------------------------------------------------------------------------------------------------------------------
TOTAL_ITEM = 1000
NFEATURES = 10
from tensorflow.keras import Model
from tensorflow.keras.layers import Input, Dense
inp = Input(shape=(NFEATURES, ), name='Input')
result = Dense(64, activation='relu', name='Dense-1')(inp)
result = Dense(64, activation='relu', name='Dense-2')(result)
out1 = Dense(1, activation='sigmoid', name='Output-1')(result)
out2 = Dense(1, activation='linear', name='Output-2')(result)
model = Model(inputs=inp, outputs=[out1, out2])
model.summary()
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_crossentropy', 'Output-2': 'mse'}, loss_weights={'Output-1': 800.0, 'Output-2': 1.0}, metrics={'Output-1': ['binary_accuracy'], 'Output-2': ['mse']})
# generate random data
import numpy as np
dataset_x = np.random.random((TOTAL_ITEM, NFEATURES))
dataset_y1 = np.random.randint(0, 2, TOTAL_ITEM)
dataset_y2 = np.random.randint(0, 100, TOTAL_ITEM).astype('float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y1, test_dataset_y1, training_dataset_y2, test_dataset_y2 = train_test_split(dataset_x, dataset_y1, dataset_y2, test_size = 0.2)
hist = model.fit(training_dataset_x, [training_dataset_y1, training_dataset_y2], batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate(test_dataset_x, [test_dataset_y1, test_dataset_y2])
print(eval_result)
# generate random data for prediction
predict_data = np.random.random(NFEATURES)
predict_result = model.predict(predict_data.reshape(1, -1))
print(predict_result[0][0, 0], predict_result[1][0, 0])
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
64. Ders - 21/09/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yazı ı ı ı ı ı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
denilen tekniktir. Biz şimdiye kadar IMDB ve Retures gibi örneklerde yazı ı ı ı
kadar olan vektörlerle temsil ettik. Bu yöntemin en önemli dezavantajları ı ı
sözcükler arası ı ı
embedding" bu teknikten daha ileri bir tekniktir. Word embedding yukarı ı ı
bu teknikle hem sözcükler arası ı ı
2024-09-25 13:52:00 +03:00
Word embedding yönteminde yazı
edilmektedir. Örneğin yazı ı ı
yazı ı
vektör nası ı
2024-10-03 14:16:20 +03:00
Word Embedding yönteminde sözcüklere ilişkin vektörler oluşturulduktan sonra bunları ı ı ı
2024-09-25 13:52:00 +03:00
distances) birbirine yakı ı ı ı
nokta arası ı ı ı ı ı
uzaklı ı ı
arası ı ı ı
boyutlu uzay için bu formül genelleştirilebilir. Örneğin sözcükleri iki elemanlı ı
vektörler düzlemde (iki boyutlu uzayda) birer nokta belirtirler. Bu durumda birbirlerine yakı
birbirlerine daha yakı ı
uzunluğunda olursa aslı ı ı
Pekiyi Word Embedding işlemlerinde bu vektörler nası ı
Google'ı ı ı ı ı ı ı
Word2Vec algoritması ı ı ı ı ı ı ı ı ı
Embedding katmanı ı ı ı ı
katmanı ı ı ı ı ı
Word embedding işlemleri aslı ı ı ı ı
embedding işlemlerinin uygulanması ı ı ı ı ı
aslı ı ı
biçimde yapı
Yukarı ı ı ı
ağı ı ı ı ı ı ı ı ı ı ı ı ı ı
metodunun parametreleri şöyledir:
tf.keras.layers.Embedding(
input_dim,
output_dim,
embeddings_initializer='uniform',
embeddings_regularizer=None,
embeddings_constraint=None,
mask_zero=False,
weights=None,
lora_rank=None,
**kwargs
)
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
Embedding katmanı ı ı
sayı ı ı
değerler 8, 16, 32, 64 biçiminde alı ı ı ı
yazı ı ı ı ı ı
oluşsa bile girdi vektörleri vocabulary kadar olduğu için girdiler doğal olarak aynı ı
yazı ı ı ı ı ı
oluşuyormuş gibi bir biçime dönüştürmesi gerekmektedir. Bunun için genellikle "padding" yöntemi kullanı ı
eğer yazı ı ı ı ı ı ı ı ı
başı ı ı ı ı ı ı ı
o ağı ı ı ı ı ı
kullanı ı
...
2024-09-16 10:49:44 +03:00
model.add(Embedding(30000, 32, input_length=100))
2024-09-25 13:52:00 +03:00
...
Burada tüm yazı ı ı
yazı ı ı ı ı ı ı
Tensorflow'un ileri sürümlerinde artı ı ı ı ı
Bu nedenle artı ı ı ı ı ı
Input katmanı ı ı ı ı
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
...
model.add(Input((100, )))
model.add(Embedding(30000, 32))
...
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
Burada tüm yazı ı ı
Yazı
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
Embedding katmanı ı ı ı ı ı
katmanı ı ı ı ı ı ı ı ı
önce yine vocabulary'deki her sözcüğe birer numara vermesi sonra da yazı ı
gerekir.
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
Embedding katmanı ı ı ı ı ı
yukarı ı ı ı ı
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
pad_sequences fonksiyonun parametrik yapı ı
tf.keras.utils.pad_sequences(
sequences,
maxlen=None,
dtype="int32",
padding="pre",
truncating="pre",
value=0.0,
):
pad_sequences fonksiyonu her biri dolaşı ı ı
(Örneğin argüman NumPy dizilerinden oluşan listeler olabilir ya da listelerden oluşan listeler olabilir.) İkinci parametre
hedeflenen sütun uzunluğunu belirtir. (Yani bu parametre her yazı ı
parametresi hedef matristeki elemanları ı
işleminin baş taraftan mı ı ı ı ı ı ı
value parametresi ise padding yapı
Bu durumda sözcük numaraları ı
edilmektedir. Örneğin:
2024-09-16 10:49:44 +03:00
from tensorflow.keras.utils import pad_sequences
a = [[1, 2, 3], [3, 4, 5, 6, 7], [10], [11, 12]]
2024-09-25 13:52:00 +03:00
result = pad_sequences(a, 3, padding='post')
2024-09-16 10:49:44 +03:00
print(result)
2024-09-25 13:52:00 +03:00
Buradan şöyle bir çı ı
[[ 1 2 3]
[ 5 6 7]
[10 0 0]
[11 12 0]]
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Embedding katmanı ı ı ı ı ı ı ı ı ı ı ı
de belirlenen vektör uzunluğu kadar sütundan oluşmaktadı ı ı
vocabulary için vektörler oluşturmaktadı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
gibi Dense katmanları ı ı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
ya da Reshape katmanı
Örneğin:
Input --> Embedding --> Flatten/Reshape --> Dense --> Dense --> Dense (Çı ı ı
2024-09-25 13:52:00 +03:00
2024-10-08 00:12:04 +03:00
Ancak maalesef kursun yapı ı ı ı ı ı ı ı ı
sorunlara yol açabilmektedir. Bunun bir böcek olduğunu düşünüyoruz. Bu nedenle biz örneklerimizde Embedding katmanı ı ı ı ı ı
Reshape katmanı
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
Şimdi daha önce vektörizasyon yöntemiyle yapmı ı
her yorumun 250 sözcükten oluştuğunu varsayalı
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
TEXT_SIZE = 250
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
Bizim ilk olarak tüm yazı
numarası ı ı ı ı ı ı ı
işleminden sonra böyle bir sözlüğü bizim için oluşturuyordu. Örneğin:
2024-09-25 13:52:00 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
2024-10-03 14:16:20 +03:00
Bu işlemden sonra artı ı
bizim tüm yorumları ı
sözcüklere ayı ı ı ı ı ı ı
Örneğin:
2024-09-25 13:52:00 +03:00
text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
Ancak burada her yazı ı ı ı ı
getirmemiz gerekir:
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TEXT_SIZE, dtype='float32')
IMDB örneğinde anı ı ı ı ı ı ı ı
dataset_y de şöyle oluşturulabilir:
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
Artı ı ı
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
Şimde de modelimizi oluşturalı
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, Embedding, Reshape, Dense
2024-09-25 13:52:00 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((TEXT_SIZE, ), name='Input'))
model.add(Embedding(len(cv.vocabulary_), WORD_VECT_SIZE, name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-09-25 13:52:00 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Modelin summary metodu ile elde edilen özet bilgileri şöyledir:
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
Model: "IMBD-WordEmbedding"
2024-10-08 00:12:04 +03:00
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃ Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
2024-09-25 13:52:00 +03:00
│ Embedding (Embedding) │ (None, 250, 64) │ 6,521,344 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
2024-10-08 00:12:04 +03:00
│ Reshape (Reshape) │ (None, 16000) │ 0 │
2024-09-25 13:52:00 +03:00
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 256) │ 4,096,256 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 256) │ 65,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 1) │ 257 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 10,683,649 (40.75 MB)
Trainable params: 10,683,649 (40.75 MB)
Non-trainable params: 0 (0.00 B)
Burada Embedding katmanı ı ı ı ı ı ı ı
olduğunu anı ı ı ı ı
sayı ı ı ı ı ı ı ı ı
gerekir. Ancak bu sayı ı ı ı
2024-10-03 14:16:20 +03:00
uzunluğu (len(cv.vocabulary_) + 1 ) = 1,018,96 kadardı ı ı ı
2024-10-08 00:12:04 +03:00
Reshape katmanı ı ı ı
nörün vardı ı ı
+ 256 = 4,096,256 kadardı ı ı ı
eğitilebilir parametrelerin sayı ı ı ı ı ı ı ı ı
da 1 nöron olduğuna göre bu katmandaki eğitilebilir parametrelerin sayı ı ı
2024-09-25 13:52:00 +03:00
Şimdi de compile ve fit işlemlerini yapalı
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
Burada üst üste 5 kez val_loss değeri iyileştirilmezse eğitim sonlandı ı ı ı ı ı
biçimde indekslere dönüştürülüp predict metoduna verilmesi gerekir:
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
predict_text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())]
for text in predict_df['review']]
predict_dataset_x = pad_sequences(predict_text_vectors, TEXT_SIZE, dtype='float32')
predict_result = model.predict(predict_dataset_x)
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
Geri kalan işlemler benzer biçimde yürütülecektir. Aşağı
2024-09-16 10:49:44 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
TEXT_SIZE = 250
WORD_VECT_SIZE = 64
2024-09-16 10:49:44 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import re
2024-09-25 13:52:00 +03:00
text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
2024-09-16 10:49:44 +03:00
from tensorflow.keras.utils import pad_sequences
2024-09-25 13:52:00 +03:00
dataset_x = pad_sequences(text_vectors, TEXT_SIZE, dtype='float32')
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-09-16 10:49:44 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, Embedding, Reshape, Dense
2024-09-16 10:49:44 +03:00
2024-09-25 13:52:00 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((TEXT_SIZE, ), name='Input'))
model.add(Embedding(len(cv.vocabulary_) + 1, WORD_VECT_SIZE, name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-09-25 13:52:00 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
2024-09-16 10:49:44 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
2024-09-25 13:52:00 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
2024-09-16 10:49:44 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-09-16 10:49:44 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-09-16 10:49:44 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-09-25 13:52:00 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-09-16 10:49:44 +03:00
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-09-25 13:52:00 +03:00
2024-09-16 10:49:44 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-25 13:52:00 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
predict_text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_df['review']]
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_dataset_x = pad_sequences(predict_text_vectors, TEXT_SIZE, dtype='float32')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
2024-04-02 13:01:04 +03:00
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
Aslı ı ı
sı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
tf.keras.layers.TextVectorization(
max_tokens=None,
standardize='lower_and_strip_punctuation',
split='whitespace',
ngrams=None,
output_mode='int',
output_sequence_length=None,
pad_to_max_tokens=False,
vocabulary=None,
idf_weights=None,
sparse=False,
ragged=False,
encoding='utf-8',
name=None,
**kwargs
)
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Anı ı ı ı
vektör oluşturmak yerine onları ı ı ı
Eğer katmanda output_sequence_length parametresi spesifik bir değer olarak girilirse padding otomatik olarak yapı ı
Metodun max_tokens parametresi sözcük sayı ı ı ı ı ı ı ı ı
artı ı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
kendisi yapmaktadı ı ı ı ı
2024-09-25 13:52:00 +03:00
2024-10-08 00:12:04 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, TextVectorization, Embedding, Dense, Reshape
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-09-25 13:52:00 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Vocabulary'nin TextVectorization nesnesi üzerinde adapt işleminden sonra oluşturulduğunu anı ı ı
2024-10-08 00:12:04 +03:00
vocabulary genişliğini sı ı ı ı
katmanı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_result = model.predict(predict_df['review'])
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
TextVectoriation sı ı ı ı ı ı
kullanmaktadı ı ı ı ı ı ı ı ı
başarı ı ı ı ı ı ı ı
nedeni muhtemelen sözcüklerin elde edilme biçimidir.
TextVectorization sı ı ı ı
uygulamacı ı ı ı ı ı
de çağrı ı ı
geçirilmektedir. Bu paramterler için fonksiyon yazı ı
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
Örnek bir bütün olarak aşağı
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
TEXT_SIZE = 250
WORD_VECT_SIZE = 64
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
df = pd.read_csv('IMDB Dataset.csv')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
dataset_x = df['review']
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, TextVectorization, Embedding, Dense, Reshape
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-09-25 13:52:00 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-09-25 13:52:00 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
2024-09-25 13:52:00 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
2024-04-02 13:01:04 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
2024-09-25 13:52:00 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_result = model.predict(predict_df['review'])
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
Şimdi de word embedding işlemleri için görsel bir açı ı ı
birbirine yakı ı ı ı ı ı ı ı
daha uzak biçimde olması ı ı
bu işlemi yaparken sözcüklerin 2 elemanlı ı ı
modeli eğitilmiş sonra da Embedded katmanı ı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
gösterilmiştir. Elde edilen grafik incelendiğinde birbirine yakı ı ı
olduğunu, uzak anlamlı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
TEXT_SIZE = 250
WORD_VECT_SIZE = 64
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
cv.fit(df['review'])
import re
text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
2024-04-02 13:01:04 +03:00
from tensorflow.keras.utils import pad_sequences
2024-09-25 13:52:00 +03:00
dataset_x = pad_sequences(text_vectors, TEXT_SIZE, dtype='float32')
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
2024-04-02 13:01:04 +03:00
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, Embedding, Reshape, Dense
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((TEXT_SIZE, ), name='Input'))
model.add(Embedding(len(cv.vocabulary_) + 1, WORD_VECT_SIZE, name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-09-25 13:52:00 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
2024-04-02 13:01:04 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
2024-09-25 13:52:00 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
2024-04-02 13:01:04 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-09-25 13:52:00 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-09-25 13:52:00 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-09-25 13:52:00 +03:00
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-25 13:52:00 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
predict_text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())]
for text in predict_df['review']]
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_dataset_x = pad_sequences(predict_text_vectors, TEXT_SIZE, dtype='float32')
2024-04-02 13:01:04 +03:00
2024-09-25 13:52:00 +03:00
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
2024-04-02 13:01:04 +03:00
print('Positive')
else:
print('Negative')
2024-10-03 14:16:20 +03:00
#----------------------------------------------------------------------------------------------------------------------------
66. Ders - 28/09/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-09-25 13:52:00 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
2024-10-03 14:16:20 +03:00
vektörleri de kullanabiliriz. Çeşitli diller için önceden oluşturulmuş geniş kapasiteli ve büyük veri kümeleriyle eğitilmiş
2024-09-25 13:52:00 +03:00
hazı ı ı ı ı ı ı
bağlantı
https://fasttext.cc/docs/en/crawl-vectors.html
Glove algoritması ı ı ı ı
https://nlp.stanford.edu/projects/glove/
2024-10-03 14:16:20 +03:00
Benzer çalı ı ı ı ı
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
Genellikle bu sitelerden indirilen word embedding vektörleri text bir formattadı ı ı ı
2024-09-25 13:52:00 +03:00
bir sözcük ve o sözcüğüe ilişkin vektör değerleri kodlanmı ı ı ı ı ı
2024-10-03 14:16:20 +03:00
<sözcük> <değer> <değer> <değer> <değer> ....
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
Bu tür dosyaları ı ı ı ı ı ı ı ı
hangi uzunlukta vektörle ifade edileceği bilgisi yer almaktadı ı
word embedding vektör dosyası ı ı ı ı
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
2000000 300
2024-09-25 13:52:00 +03:00
2024-10-03 14:16:20 +03:00
Burada toplam 2,000,000 sözcük için veektörler bulunmaktadı ı
300 eleman uzunluğunda vektörden oluşmaktadı ı ı ı
sözcükler değil özel isimler, tireli sözcükler, kı ı
2024-09-25 13:52:00 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-10-03 14:16:20 +03:00
Hazı ı ı
sözlüğü haline getirmektir. Burada sözlüğün anahtarları ı
oluşturulabilir. Bu işlemi şöyle yapabiliriz:
FASTTEXT_WORD_EMBEDDING_FILE = R'C:\Users\aslan\Downloads\cc.en.300.vec'
import numpy as np
we_dict = {}
with open(FASTTEXT_WORD_EMBEDDING_FILE, 'r', encoding='utf-8') as f:
for line in f:
tokens = line.rstrip().split(' ')
we_dict[tokens[0]] = np.array([float(vecdata) for vecdata in tokens[1:]], dtype='float32')
Burada FASTTEXT_WORD_EMBEDDING_FILE bizim aşağı ı ı ı ı
(Bu dosya çok uzun olduğu için dosyayı
https://fasttext.cc/docs/en/crawl-vectors.html
Dosya buradaki liste içerisindeki "English: bin, text" bağlantı ı
300'lük bir vektörle oluşturulmuştur.
Pekiyi biz neden bu dosyayı ı ı ı
nesnesi haline getirdik? İşte aslı ı ı ı ı ı ı
değil gerekli satı ı ı ı ı ı ı
nesnesi üzerinde sı ı ı ı ı ı ı
dosyayı
nesnesi de bellekte çok yer kaplayacaktı
Pekiyi bundan sonra ne yapacağı ı ı ı ı ı ı ı
Biz bu sözcük numaraları ı ı ı ı ı ı
katmanı ı ı ı ı ı ı ı
kullanı ı ı ı ı
katman doğrudan bu matristeki vektörleri kullanacaktı
model.add(Embedding(VOCAB_LEN, WORD_VECT_SIZE, weights = [pretrained_matrix], name='Embedding'))
Buradaki pretrained_matrix hazı ı ı
Embedding katmanı ı ı ı
katman nesnelerinde trainable isimli bir parametre ve bu parametreyi temsil eden bir öznitelik vardı
ya da öznitelik False biçimde geçilirse ilgili katman "eğitimde yokmuş gibi ancak kestirim ve test işlemlerinde
varmı ı ı ı ı ı
model.add(Embedding(VOCAB_LEN, WORD_VECT_SIZE, weights = [pretrained_matrix], trainable=False, name='Embedding'))
Tabii uygulamacı ı ı ı
durumda trainable patametresi False geçilmez. Bu parametrenin default durumu zaten True biçimdedir.
Fakat burada dikkat edilmesi gereken başka bir nokta daha vardı
vektörlerin matristeki satı ı ı ı
"fine" sözcüğünün numarası ı ı
ilişkin vektör olmalı ı
karşı ı ı ı ı
bu katman nesnesindeki get_vocabulary metodu bize zaten numaralarla uyumlu sözcük listesini vermektedir. O halde biz bu listeden
hareketle bir döngü içerisinde weights parametresi için gereken matrisi (pretrained_matrix) aşağı
pretrained_matrix = np.zeros((len(vocab_list), WORD_VECT_SIZE), dtype='float32')
for index, word in enumerate(vocab_list):
vect = we_dict.get(word)
if vect is None:
vect = np.zeros(WORD_VECT_SIZE)
pretrained_matrix[index] = vect
Burada önce IMDB'deki sözcüklerin sayı ı ı
kadar (örneğimizde 300) sütuna sahip içi sı ı
eğitilmiş vektörlerin bulunduğu sözlükte aranmı ı ı ı ı ı
Örneğin bütün olarak kodları ı ı ı ı
kadar iyi olmaması
#----------------------------------------------------------------------------------------------------------------------------
TEXT_SIZE = 250
WORD_VECT_SIZE = 300
FASTTEXT_WORD_EMBEDDING_FILE = R'C:\Users\aslan\Downloads\cc.en.300.vec'
import numpy as np
we_dict = {}
with open(FASTTEXT_WORD_EMBEDDING_FILE, 'r', encoding='utf-8') as f:
for line in f:
tokens = line.rstrip().split(' ')
we_dict[tokens[0]] = np.array([float(vecdata) for vecdata in tokens[1:]], dtype='float32')
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import re
text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TEXT_SIZE, dtype='float32')
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
import numpy as np
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, Embedding, Reshape, Dense
2024-10-03 14:16:20 +03:00
pretrained_matrix = np.zeros((len(cv.vocabulary_), WORD_VECT_SIZE), dtype='float32')
for index, word in enumerate(cv.vocabulary_):
vect = we_dict.get(word)
if vect is None:
vect = np.zeros(WORD_VECT_SIZE)
pretrained_matrix[index] = vect
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((TEXT_SIZE, ), name='Input'))
model.add(Embedding(len(cv.vocabulary_), WORD_VECT_SIZE, weights=[pretrained_matrix], name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-10-03 14:16:20 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_df = pd.read_csv('predict-imdb.csv')
predict_text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_df['review']]
predict_dataset_x = pad_sequences(predict_text_vectors, TEXT_SIZE, dtype='float32')
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
67. Ders - 29/09/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı
kalmı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TEXT_SIZE = 250
WORD_VECT_SIZE = 300
FASTTEXT_WORD_EMBEDDING_FILE = R'C:\Users\aslan\Downloads\cc.en.300.vec'
import numpy as np
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
we_dict = {}
with open(FASTTEXT_WORD_EMBEDDING_FILE, 'r', encoding='utf-8') as f:
for line in f:
tokens = line.rstrip().split(' ')
we_dict[tokens[0]] = np.array([float(vecdata) for vecdata in tokens[1:]], dtype='float32')
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import re
text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TEXT_SIZE, dtype='float32')
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
import numpy as np
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, Embedding, Reshape, Dense
2024-10-03 14:16:20 +03:00
pretrained_matrix = np.zeros((len(cv.vocabulary_), WORD_VECT_SIZE), dtype='float32')
for index, word in enumerate(cv.vocabulary_):
vect = we_dict.get(word)
if vect is None:
vect = np.zeros(WORD_VECT_SIZE)
pretrained_matrix[index] = vect
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((TEXT_SIZE, ), name='Input'))
model.add(Embedding(len(cv.vocabulary_), WORD_VECT_SIZE, weights=[pretrained_matrix], name='Embedding'))
2024-10-08 00:12:04 +03:00
model.add(Reshape((-1, ), name='Reshape'))
2024-10-03 14:16:20 +03:00
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_df = pd.read_csv('predict-imdb.csv')
2024-10-08 00:12:04 +03:00
predict_text_vectors = [[cv.vocabulary_[word] + 1 for word in re.findall(r'(?u)\b\w\w+\b', text.lower())]
for text in predict_df['review']]
2024-10-03 14:16:20 +03:00
predict_dataset_x = pad_sequences(predict_text_vectors, TEXT_SIZE, dtype='float32')
predict_result = model.predict(predict_dataset_x)
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
2024-10-08 00:12:04 +03:00
2024-10-03 14:16:20 +03:00
#----------------------------------------------------------------------------------------------------------------------------
İçerisinde zamana dayalı
Eğer bir zamansal veri kümesindeki her satı ı ı
"zaman serileri (time series)" biçiminde isimlendirilmektedir. Örneğin yağmurun yağı ı ı
10 dakikada bir hava durumuna ilişkin ölçüm alı ı ı ı
serileri" de denilmektedir. Çünkü bu ölçümler birbirinden kopuk değil zaman içerisinde birbirlerini izlemektedir. Yağmur
bir anda yağmamaktadı ı ı ı
anlaşı ı
sı ı ı
veriler üzerinde resmin pixel'lerini ilişkilendirebilmek için "evrişim (convoluiton)" uygulamı ı
için de benzer biçimde evrişim uygulanabilmektedir. Böylesi bir evrişim işlemi zaman serisi verilerinin tek tek değil birbiriyle
ilişkili biçimde ele alı ı ı ı
Aslı ı ı ı ı
değildir. Yazı ı
sonra gelen sözcüklerle ilişkilendirilirse daha iyi anlamlandı ı ı ı ı ı ı
işlemi uygulanabilir. Biz daha önce resimler üzerinde evrişim uygulamı ı
işlemi" denilmektedir. Bunun nedeni o örneklerde alı ı ı ı ı ı
zamansal verilerde uygulanan evrişim tek boyutludur. Tek boyutlu evrişim demek filtrenin tek boyutta kaydı ı ı
Metin anlamlandı ı
Tek boyutlu evrişim işleminde filtre büyüklüğü tek boyutludur (yani tek bir sayı ı
satı ı ı ı ı ı ı ı
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
...............
2024-04-02 13:01:04 +03:00
Bunlar evrişime sokulacak verileri temsil ediyor olsun. Filteyi (kernel) 3 olarak olarak almı ı
aşağı ı ı
2024-10-03 14:16:20 +03:00
F F F F F F F F
F F F F F F F F
F F F F F F F F
Buradaki filte ilk üç satı ı ı ı ı ı ı ı
kaydı ı ı ı ı ı ı ı ı ı ı ı ı
olduğunu varsayalı ı ı ı ı
ise (N - K + 1, 1) boyutunda olacaktı ı ı
ile 8 elemanlı ı ı ı ı ı
XXXXXXXX -> sözcük
XXXXXXXX -> sözcük
XXXXXXXX -> sözcük
XXXXXXXX -> sözcük
XXXXXXXX -> sözcük
XXXXXXXX -> sözcük
Şimdi biz 2 uzunlukta bir filtre ile tek boyutlu evrişim uygulamak isteyelim. Bu durumda filtenin yapı ı ı
FFFFFFFF
FFFFFFFF
Biz bu filtreyi "padding uygulamadan" yukarı ı ı
R
R
R
R
R
Burada R değerleri filtre matrisi ile sözcüklere ilişkin word embedding matrisinin çakı ı ı ı
ve sonrası ı ı ı ı
bir matris elde etmiş olduk. Tabii biz birden fazla filtre de uygulayabiliriz. Örneğin toplamda 16 filtre uygularsak elde
2024-10-08 00:12:04 +03:00
edeceğimiz matris (16, 5, 1) boyutunda olacaktı ı ı ı ı ı
gibi çok boyutlu bir yapı ı
R R R R R R R .... R R R
R R R R R R R .... R R R
R R R R R R R .... R R R
R R R R R R R .... R R R
.....
Burada çı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-10-03 14:16:20 +03:00
Keras'ta tek boyutlu evirişim işlemi için Conv1D katman sı ı ı ı ı ı ı
yapı ı
tf.keras.layers.Conv1D(
filters,
kernel_size,
strides=1,
padding='valid',
data_format=None,
dilation_rate=1,
groups=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs
)
Metodun ilk parametresi filtre sayı ı ı
boyut tek bir sayı ı ı
vardı ı ı ı
kaydı ı ı ı ı
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
68. Ders - 05/10/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
şöyledir:
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
TextVectorization --> Embedding --> Conv1D --> Flatten/Reshape --> Dense --> Dense --> Dense (Output)
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
Model Keras'ta aşağı
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
model.add(Conv1D(128, 3, activation='relu', padding='same', name='Conv1D'))
model.add(Reshape((-1, ), name='Reshape'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
Burada görüldüğü gibi Embedding katmanı ı ı ı
2024-10-03 14:16:20 +03:00
2024-10-08 00:12:04 +03:00
Model: "IMBD-WordEmbedding"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ text_vectorization_2 │ (None, 250) │ 0 │
│ (TextVectorization) │ │ │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Embedding (Embedding) │ (None, 250, 64) │ 11,630,208 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv1D (Conv1D) │ (None, 250, 128) │ 24,704 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Reshape (Reshape) │ (None, 32000) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 256) │ 8,192,256 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 256) │ 65,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 1) │ 257 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 19,913,217 (75.96 MB)
Trainable params: 19,913,217 (75.96 MB)
Non-trainable params: 0 (0.00 B)
Burada TextVectorization katmanı ı ı ı ı ı ı ı ı ı
Bu sözcük numaraları ı ı ı ı ı ı ı
vektörler olduğunu görüyorsunuz. Anı ı ı ı
vektör uzunluğunun çarpı ı ı ı ı ı
olduğu görülmektedir. Modelimizdeki sözcük haznesi (vocabulary) uzunluğu TextVectorization get_vocabulary() metodu ile elde
edildiğinde 181722 olduğu görülmektedir. O halde bu katmandaki eğitilebilir parametrelerin sayı ı
değeri elde edilmektedir. Conv1D katmanı ı ı ı ı ı ı
bir filtre uygulanmı ı ı ı ı ı ı
Şimdi bu katmandaki eğitilebilir parametrelerin sayı ı ı ı
işlemindeki eleman sayı ı ı
dot-product yapı ı ı ı ı
tane olacaktı ı ı ı ı ı ı ı ı ı ı
vardı ı ı ı ı ı
çı ı ı ı ı ı ı ı ı
bir problem yarattı ı ı ı ı ı ı
biçimindedir. Tabii Reshape katmanı
parametrelerin sayı ı ı ı ı
sonraki Dense katmana sokulduğunda buradaki eğitilebilir parametrelerin sayı ı ı
katmanı ı ı ı ı ı ı ı ı ı
parametrelerin sayı ı
Uygulamanı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-10-03 14:16:20 +03:00
TEXT_SIZE = 250
2024-10-08 00:12:04 +03:00
WORD_VECT_SIZE = 64
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
2024-10-08 00:12:04 +03:00
dataset_x = df['review']
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, TextVectorization, Conv1D, Embedding, Dense, Reshape
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D'))
model.add(Reshape((-1, ), name='Reshape'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
2024-10-08 00:12:04 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
2024-10-08 00:12:04 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-10-08 00:12:04 +03:00
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
2024-04-02 13:01:04 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
2024-10-08 00:12:04 +03:00
plt.legend(['Accuracy', 'Validation Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-10-08 00:12:04 +03:00
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-10-08 00:12:04 +03:00
predict_df = pd.read_csv('predict-imdb.csv')
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
predict_result = model.predict(predict_df['review'])
for presult in predict_result[:, 0]:
if (presult > 0.5):
2024-04-02 13:01:04 +03:00
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Aslı ı ı ı
azaltmak ve bazı
işlemleri iki boyutlu değil tek boyutludur. Tek boyutlu "pooling" işlemleri için MaxPooling1D ve AveragePooling1D sı ı ı
bulundurulmuştur.
Tek boyutlu pooling işlemlerinde pool_size parametresi için tek bir sayı ı ı ı ı ı
işlemi burada belirtilen satı ı ı ı ı ı
Örneğin pooling işlemine sokacağı ı
2024-04-02 13:01:04 +03:00
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
2024-10-08 00:12:04 +03:00
x x x x x x x x x x
x x x x x x x x x x
Burada MaxPooling1D sı ı ı ı ı ı ı ı ı ı
sütunları ı ı ı ı ı ı ı
için de yapı ı ı ı ı ı ı ı
edilecektir. Yukarı ı ı
olacaktı
P P P P P P P P P P ==> ilk üç satı ı ı ı
P P P P P P P P P P ==> sonraki üç satı ı ı ı
P P P P P P P P P P ==> sonraki üç satı ı ı ı
Tı ı
işlemleri bir kez değil üst üste birden fazla kez uygulanmaktadı
Pekiyi metinsel işlemlerde MaxPooling1D katmanı ı ı ı ı
bağlı ı
Max pooling işlemi o bölgedeki en önemli sözcüklere dikkat edilmesini sağlamaktadı
sı ı ı ı ı ı ı ı
tf.keras.layers.MaxPool1D(
pool_size=2,
strides=None,
padding='valid',
data_format=None,
name=None,
**kwargs
)
ttf.keras.layers.AveragePooling1D(
pool_size,
strides=None,
padding='valid',
data_format=None,
name=None,
**kwargs
)
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
Metotlardaki pool_size parametresi pooling uygulanacak satı ı ı ı
Bu parametrelerin default değerleri None biçimindedir. Bu durumda kaydı
yapı ı
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
Aşağı
uygulanmı ı ı
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
TextVectorization --> Embedding --> Conv1D --> MaxPooling1D --> Conv1D --> MaxPooling1D --> Conv1D --> MaxPooling1D
Flatten/Reshape --> Dense --> Dense --> Dense (Output)
Model Keras'ta şöyle kurulmuştur:
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-1'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-1'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-2'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-2'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-3'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-3'))
model.add(Reshape((-1, ), name='Reshape'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Modelden elde edilen özet görüntü (summary) şöyledir:
Model: "IMBD-WordEmbedding"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ text_vectorization │ (None, 250) │ 0 │
│ (TextVectorization) │ │ │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Embedding (Embedding) │ (None, 250, 64) │ 11,630,208 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv1D-1 (Conv1D) │ (None, 250, 128) │ 24,704 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ MaxPooling1D-1 (MaxPooling1D) │ (None, 125, 128) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv1D-2 (Conv1D) │ (None, 125, 128) │ 49,280 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ MaxPooling1D-2 (MaxPooling1D) │ (None, 63, 128) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Conv1D-3 (Conv1D) │ (None, 63, 128) │ 49,280 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ MaxPooling1D-3 (MaxPooling1D) │ (None, 32, 128) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Reshape (Reshape) │ (None, 4096) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-1 (Dense) │ (None, 256) │ 1,048,832 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden-2 (Dense) │ (None, 256) │ 65,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Output (Dense) │ (None, 1) │ 257 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 12,868,353 (49.09 MB)
Trainable params: 12,868,353 (49.09 MB)
Non-trainable params: 0 (0.00 B)
Burada MaxPooling1D katmanları ı ı ı
Örnek bir bütün olarak aşağı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
TEXT_SIZE = 250
WORD_VECT_SIZE = 64
2024-04-02 13:01:04 +03:00
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
2024-10-08 00:12:04 +03:00
dataset_x = df['review']
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
from sklearn.model_selection import train_test_split
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, TextVectorization, Conv1D, MaxPooling1D, Embedding, Dense, Reshape
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(tv.vocabulary_size(), WORD_VECT_SIZE, name='Embedding'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-1'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-1'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-2'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-2'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-3'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-3'))
model.add(Reshape((-1, ), name='Reshape'))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
from tensorflow.keras.callbacks import EarlyStopping
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_df = pd.read_csv('predict-imdb.csv')
predict_result = model.predict(predict_df['review'])
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
AveragePooling1D ve MaxPooling1D katmanları ı ı ı
ve GlobalMaxPooling1D isimleriyle bulundurulmuştur. Tı ı
işlemlerinde de bu katmanlar tek bir çı ı ı ı
üretir. Örneğin bu katmanı
en büyük değerini elde edecektir. Bu değerler de toplamda 128 tane olacaktı ı ı
olduğu gibi evrişim katmanları ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-10-11 00:32:36 +03:00
69. Ders - 06/10/2024 - Pazar
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
vektörleri kullanı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TEXT_SIZE = 250
WORD_VECT_SIZE = 300
FASTTEXT_WORD_EMBEDDING_FILE = R'C:\Users\aslan\Downloads\cc.en.300.vec'
import numpy as np
we_dict = {}
with open(FASTTEXT_WORD_EMBEDDING_FILE, 'r', encoding='utf-8') as f:
for line in f:
tokens = line.rstrip().split(' ')
we_dict[tokens[0]] = np.array([float(vecdata) for vecdata in tokens[1:]], dtype='float32')
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
dataset_x = df['review']
dataset_y = (df['sentiment'] == 'positive').to_numpy(dtype='uint8')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
2024-10-08 00:12:04 +03:00
from tensorflow.keras.layers import Input, TextVectorization, Embedding, Conv1D, MaxPooling1D, Dense, Reshape
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
tv = TextVectorization(output_sequence_length=TEXT_SIZE, output_mode='int')
tv.adapt(dataset_x)
vocab_list = tv.get_vocabulary()
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
pretrained_matrix = np.zeros((len(vocab_list), WORD_VECT_SIZE), dtype='float32')
for index, word in enumerate(vocab_list):
vect = we_dict.get(word)
if vect is None:
vect = np.zeros(WORD_VECT_SIZE)
pretrained_matrix[index] = vect
model = Sequential(name='IMBD-WordEmbedding')
model.add(Input((1, ), dtype='string', name='Input'))
model.add(tv)
model.add(Embedding(len(vocab_list), WORD_VECT_SIZE, weights=[pretrained_matrix], name='Embedding'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-1'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-1'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-2'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-2'))
model.add(Conv1D(128, 3, padding='same', name='Conv1D-3'))
model.add(MaxPooling1D(2, padding='same', name='MaxPooling1D-3'))
model.add(Reshape((-1, )))
model.add(Dense(256, activation='relu', name='Hidden-1'))
model.add(Dense(256, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
2024-10-08 00:12:04 +03:00
esc = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(14, 6))
plt.title('Epoch - Loss Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(14, 6))
plt.title('Epoch - Binary Accuracy Graph', pad=10, fontsize=14)
plt.xticks(range(0, 300, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Accuracy', 'Validation Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_df = pd.read_csv('predict-imdb.csv')
predict_result = model.predict(predict_df['review'])
for presult in predict_result[:, 0]:
if (presult > 0.5):
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Tek boyutlu evrişim ve pooling işlemleri yalnı ı
veri kümelerinde de uygulabilmektedir. Gerçi izlen paragraflarda biz zamansal veriler için daha iyi performans gösteren
geri beslemeli (recurrent) ağları ı
bir örnek vermek istiyoruz.
Zamansal verilerle (temporal data) ilgili klasik bir örnek "hava durumunun tahmin edilmesi" olabilir. Örneğin hava sı ı ı
birtakı ı ı ı ı
çalı ı ı ı ı ı ı ı ı
sı ı ı ı
o andaki verileri gö zönüne alarak hava sı ı ı ı ı ı ı
tahminin daha isabetli yapı ı ı ı ı ı ı
fiyatı ı ı ı
değil geçmişe de bakı ı
oluşturmaktadı
Hava durumu tahminine örnek için kullanı
bir veri kümesidir . Bu veri kümesi aşağı ı
https://www.kaggle.com/datasets/mnassrib/jena-climate?resource=download
Bu siteden veri kümesi indirilip açı ı ı
aşağı
"Date Time","p (mbar)","T (degC)","Tpot (K)","Tdew (degC)","rh (%)","VPmax (mbar)","VPact (mbar)","VPdef (mbar)","sh
(g/kg)","H2OC (mmol/mol)","rho (g/m**3)","wv (m/s)","max. wv (m/s)","wd (deg)"
01.01.2009 00:10:00,996.52,-8.02,265.40,-8.90,93.30,3.33,3.11,0.22,1.94,3.12,1307.75,1.03,1.75,152.30
01.01.2009 00:20:00,996.57,-8.41,265.01,-9.28,93.40,3.23,3.02,0.21,1.89,3.03,1309.80,0.72,1.50,136.10
01.01.2009 00:30:00,996.53,-8.51,264.91,-9.31,93.90,3.21,3.01,0.20,1.88,3.02,1310.24,0.19,0.63,171.60
01.01.2009 00:40:00,996.51,-8.31,265.12,-9.07,94.20,3.26,3.07,0.19,1.92,3.08,1309.19,0.34,0.50,198.00
01.01.2009 00:50:00,996.51,-8.27,265.15,-9.04,94.10,3.27,3.08,0.19,1.92,3.09,1309.00,0.32,0.63,214.30
01.01.2009 01:00:00,996.50,-8.05,265.38,-8.78,94.40,3.33,3.14,0.19,1.96,3.15,1307.86,0.21,0.63,192.70
...............................
Dosyada bir başlı ı ı ı ı
ölçülerek saklanması ı ı ı ı
Veri kümesinde eksik veri bulunmamaktadı
Jena Climate örneğinde bizim amacı ı ı ı ı ı
etmek olsun. Böyle bir modelin eğitimi için bizim bazı ı ı
karşı ı ı ı ı ı ı
= 144 satı ı ı
eşleştirmemiz gerekir. Bu işlemler çeşitli biçimlerde yapı ı ı ı ı
de vardı ı
alı ı
bilgileri genellikle "özellik mÜhendisliği (feature engineering)" teknikleriyle bileşene ayrı ı ı
biçiminde veri kümesine eklenir. Tarih bilgisinin aylara, günlere ya da haftanı ı ı ı
bir bilgiler gibi ele alı ı ı ı ı ı
veri kümesinde tarih bilgisinin ay ve gün bileşenlerinden faydalanı ı
kestirimde önemli bir bilgi oluşturabilmektedir. Gerçi zaman serisi tarzı ı
kendisinin yakalaması ı ı
sütunları ı ı ı
gerekir. Buradaki sütunları ı ı ı ı ı
anlamları ı
Veri kümesini aşağı ı
import pandas as pd
df = pd.read_csv('jena_climate_2009_2016.csv')
Biz tarih ve zaman bilgisi sütununu Pandas'ı
df['Date Time'] = pd.to_datetime(df['Date Time'])
Artı ı
yazı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
2024-10-08 00:12:04 +03:00
df = pd.read_csv('jena_climate_2009_2016.csv')
df['Month'] = df['Date Time'].str[3:5]
df['Hour-Minute'] = df['Date Time'].str[11:16]
df.drop(['Date Time'], axis=1, inplace=True)
df = pd.get_dummies(df, columns=['Month', 'Hour-Minute'], dtype='int8')
dataset = df.to_numpy('float32')
Bir günün kaç 10 dakikadan oluştuğunu aşağı
PREDICTION_INTERVAL = 24 * 60 // 10 # 144
Biz evirişim katmanı ı ı ı
matrisler biçiminde istemektedir. Yani bizim sinir ağı
gerekir. dataset_x ve dataset_y veri kümelerini hazı ı ı ı ı
gerekir. Tabii burada kaydı ı ı ı ı
olması
<ilk 144'lük satı
<Sonraki 144'lük satı
<Sonraki 144'lük satı
<Sonraki 144'lük satı
....
Tabii burada oluşturulacak matris çok büyük olabilir. Bunun için kaydı ı
Ya da bu tür durumlarda parçalı
<BURADA KALDIK>
Tabii bu işlemin yapı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TIME_PERIOD = 24 * 60 // 10
import pandas as pd
df = pd.read_csv('jena_climate_2009_2016.csv')
dttm = df.iloc[:, 0]
df.iloc[:, 0] = dttm.str[10:]
df = pd.get_dummies(df, columns=['Date Time'], dtype='int8')
dataset_df_y = df.iloc[:, 1]
dataset_df_x = df.drop('T (degC)', axis=1)
dataset_x = dataset_df_x.iloc[:-TIME_PERIOD].to_numpy()
dataset_y = dataset_df_y.iloc[TIME_PERIOD:].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
mms = StandardScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential(name='Boston-Housing-Price')
model.add(Dense(128, activation='relu', input_dim=training_dataset_x.shape[1], name='Hidden-1'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dropout(0.2, name='Dropout-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=10, restore_best_weights=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
2024-10-08 00:12:04 +03:00
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
2024-04-02 13:01:04 +03:00
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
2024-10-08 00:12:04 +03:00
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-10-08 00:12:04 +03:00
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-10-08 00:12:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı
frame'ler tipik zamansal verilerdir. Biz yukarı
yaratmaya çalı ı ı ı ı
Geri beslemeli ağlar aslı ı ı ı ı ı ı ı
ağa uygulanması ı ı ı ı
Çı ı ı ı ı ı ı
Örneğin bir yazı ı ı ı ı ı ı
için bir hafı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdiye kadar üzerinde çalı ı ı ı
"geri beslemeli ağlar (feed backword networks)" üzerinde duracağı
ile ifade edilmektedir. Bu nedenle geri beslemeli ağlar için genellikle İngilizce "recurrent newural networks" terimi kullanı ı
Bu da "RNN" biçiminde kı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Geri beslemeli ağlardaki geri besleme bir katman biçiminde oluşturulmaktadı
girdiler tek hamede değil parça parça verilir. Girdinin her parçası ı ı ı ı
parçası ı ı ı ı ı
bir hafı ı ı ı ı ı ı ı ı ı ı ı ı ı
gibi dense katmanlara verilir. Yani geri besleme katmanı ı ı
Geri besleme katmanı ı ı ı ı ı ı
Biz parçalı ı ı ı ı ı ı ı ı ı ı
işleme sokulması ı ı ı ı ı ı ı
değerleri şöyle olacaktı
geri besleme katmanı ı ı ı
Pekiyi girdi katmanı ı ı
Bu durumda 32'lik giriş uygulandı ı ı ı ı ı ı ı ı ı
gibi işleme sokulacaktı ı ı ı
bağlandı ı ı ı ı ı ı
söz konusu olacaktı ı ı
32 * 64 + 64 * 64 + 64 = 6208 tane olacaktı
Aşağı ı ı ı ı ı ı ı ı
kaç parça olduğunu), INPUT_FEATURES parçalı ı ı ı ı ı
Bu programda zamansal her veri uygulandı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
TIMESPEC = 100 # ardı ı ı ı
INPUT_FEATURES = 32 # girdi katmanı ı ı
RECURRENT_LAYER_SIZE = 64 # geri besleme katmanı ı ı
def activation(x):
return np.maximum(0, x)
inputs = np.random.random((TIMESPEC, INPUT_FEATURES))
W = np.random.random((RECURRENT_LAYER_SIZE, INPUT_FEATURES))
U = np.random.random((RECURRENT_LAYER_SIZE, RECURRENT_LAYER_SIZE))
b = np.random.random((RECURRENT_LAYER_SIZE,))
outputs = []
output_t = np.random.random((RECURRENT_LAYER_SIZE,))
for input_t in inputs:
output_t = activation(np.dot(W, input_t) + np.dot(U, output_t) + b)
outputs.append(output_t)
total_outputs = np.concatenate(outputs, axis=0)
print(total_outputs)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi yukarı ı ı ı ı ı ı ı
Bu geri besleme katmanı ı ı ı ı ı ı ı
düzleştirildikten sonra dense katmana bağlanabilir. Yalnı ı ı ı ı ı
Dolayı ı ı
Aslı ı ı ı ı ı ı ı ı ı ı
__init__ metodunun parametrik yapı ı
tf.keras.layers.SimpleRNN(
units,
activation='tanh',
use_bias=True,
kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal',
bias_initializer='zeros',
kernel_regularizer=None,
recurrent_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
recurrent_constraint=None,
bias_constraint=None,
dropout=0.0,
recurrent_dropout=0.0,
return_sequences=False,
return_state=False,
go_backwards=False,
stateful=False,
unroll=False,
**kwargs
)
Buradaki nunits geri besleme katmanı ı ı ı ı ı
biçiminde alı ı ı
return_sequences isimli parametredir. Bu parametre True geçilirse (default durum False biçimdedir) bu durumda katman her zamansal girişin çı ı ı ı
biriktirir. Eğer bu parametre True geçilmezse bu biriktirme yapı ı ı ı ı ı ı
Pekiyi SimpleRNN katmanı ı ı ı ı ı ı ı ı ı
Keras bu durumda bu matrisib her bir satı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı
ağlar da aslı ı ı ı
Bu sözcükler de bir vektörle ifade edilmelidir. Biz her sözcüğü bir vektörle ifade edebilmemiz gerekir. Bunun için ise akla word embedding
yöntemi gelmektedir. O halde yazsal örneklerde tipik olarak SimpleRNN katmanı ı ı ı ı ı ı ı ı
deyişle yazı ı ı ı ı ı ı ı ı
şöyle olacaktı
Embedding --> SimpleRNN --> Dense ---> Dense ---> Dense (output)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Daha önce üzerinde çalı ı ı ı ı ı
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Flatten, Dense
model = Sequential(name='IMDB-SimpleRNN')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(SimpleRNN(64, name='SimpleRNN', return_sequences=True))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Dense-1'))
model.add(Dense(128, activation='relu', name='Dense-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Burada önce bir Embedding katman kullanı ı ı ı ı ı
64'lü zamansal değerler elde edilmiştir. Bu 64'lü girişler 64 nörondan oluşan SimpleRNN katmanı ı ı ı
katmanı ı ı ı
bir matris biçiminde biriktirilmiştir. Sonra bunlar Flatten katmanı
katmanı ı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import numpy as np
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
import re
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Flatten, Dense
model = Sequential(name='IMDB-SimpleRNN')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(SimpleRNN(64, name='SimpleRNN', return_sequences=True))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Dense-1'))
model.add(Dense(128, activation='relu', name='Dense-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı
biraz daha güçlendirebilmektedir. Tabii bir SimpleRNN katmanı ı ı ı
return_sequences=True yapı ı ı ı
bekleyecektir. Birden fazla SimpleRNN katmanı ı ı ı ı ı ı ı
SimpleRNN --> SimpleRNN --> Dense(output)
Burada İkinci SimpleRNN katmanı ı ı ı ı ı ı ı
Aşağı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import numpy as np
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
import re
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Flatten, Dense
model = Sequential(name='IMDB-SimpleRNN')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(SimpleRNN(32, name='SimpleRNN-1', return_sequences=True))
model.add(SimpleRNN(32, name='SimpleRNN-2', return_sequences=True))
model.add(Flatten(name='Flatten'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
yönündedir. Daha çnce yapmı ı ı
geri besleme IMDB örneğinde fayda sağlamayacak mı ı ı ı ı ı
bu hafı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay sinir ağları ı
Bu bağlamda çeşitli düzenleme teknikleri geliştirilmiştir. En yaygı
düzenlemeleridir. Biz burada dropout düzenlemeleri üzerinde duracağı ı ı ı
2024-10-08 00:12:04 +03:00
Dropout düzenlemesi 2014 yı ı ı ı ı ı ı
rastgele biçimde katmandan atı ı ı ı ı ı
belli bir olası ı ı ı ı ı ı ı ı ı ı
değerler çok kullanı ı ı ı ı ı ı ı ı
Buradaki atı ı ı ı ı ı ı ı ı ı ı
Yani örneğin biz dropout olsı ı ı ı ı ı ı ı
kesinlikle bir tanesinin atı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Keras'ta dropout işlemi Dropout isimli bir katman ile temsil edilmiştir. Dropout sı ı ı ı
yapı ı
tf.keras.layers.Dropout(rate, noise_shape=None, seed=None, **kwargs)
Metodun birinci parametresi droput olası ı ı ı ı ı ı ı ı
Eğitim sı ı ı ı ı ı ı ı ı ı ı
işlemler yapı ı
Katmandaki nöronları ı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
ortadan kaldı ı ı ı ı ı ı ı ı ı ı ı ı
kadar artı ı ı ı ı ı ı ı ı ı
artı ı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
Dropout işlemi yalnı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.layers import Dropout
import numpy as np
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype='float')
dropout_layer = Dropout(0.8, input_dim=10)
result = dropout_layer(data, training=True)
print(result)
result = dropout_layer(data, training=True)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de IMDB örneğinde Dropout kullanalı ı ı ı
Embedding --> SimpleRNN --> Dropout(0.3) --> Dense ---> Dropout (0.3) --> Dense (output)
Buradaki dropout olası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import numpy as np
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
import re
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, Dropout, SimpleRNN, Flatten, Dense
model = Sequential(name='IMDB-SimpleRNN')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(SimpleRNN(64, name='SimpleRNN', return_sequences=True))
model.add(Dropout(0.3, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(128, activation='relu', name='Dense-1'))
model.add(Dropout(0.3, name='Dropout-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Zamansal verilerle ilgili bir örnek "hava sı ı ı ı ı ı ı ı ı ı
2024-10-08 00:12:04 +03:00
Belli veriler eşliğinde o andaki ya da belli zaman sonrası ı ı
ölümleri alı ı ı ı ı ı ı ı ı ı
Birbirini izleyen birtakı ı ı ı ı ı ı ı
olaylar sonucunda bir bağlam içerisinde değişmektedir.
2024-04-02 13:01:04 +03:00
Hava durumu tahmini için "Jena Climate" isimli bir veri kümesi vardı ı ı
https://www.kaggle.com/datasets/mnassrib/jena-climate?resource=download
Bu veri kümesi 10'ar dakikalı ı ı
Veri sütunlardan biri (üçüncü sütun) hava sı ı ı ı ı
2024-10-08 00:12:04 +03:00
Örneğin tipik olarak "gelecek kestirimi" yani şimdiki değerlerden hareketle belli bir zaman sonraki hava sı ı ı ı
edilmesi gibi örneklerde bu veri kümesinden deneme amaçlı ı ı
Jena Climate örneğinde bizim amacı ı ı ı ı ı
olsun. Böyle bir modelin eğitimi için bizim bazı ı ı ı
gelen y değerleri (havanı ı ı ı ı ı
ilerideki değerlerdir. O halde bizim eğitim verilerini oluştururken her x için 144 ilerideki y değerini eşleştirmemiz gerekir.
Bu işlemler çeşitli biçimlerde yapı ı ı ı ı ı
bilgisinin bizim için önemi yoktur. Ancak ölçümün yapı ı ı ı
olabilir. Pekiyi zamansal veri hangi ölçek türündendir? İşte tarih ve zaman bilgileri uygulamaya göre aralı
ya da nominal (kategorik) ölçekte değerlendirilebilir. Eğer zaman bilgisi kategorik bir bilgi olarak ele alı
encoding" yapı ı ı ı ı ı
kullanı ı ı
2024-04-02 13:01:04 +03:00
TIME_PERIOD = 24 * 60 // 10 # 144
import pandas as pd
df = pd.read_csv('jena_climate_2009_2016.csv')
dttm = df.iloc[:, 0]
df.iloc[:, 0] = dttm.str[10:]
df = pd.get_dummies(df, columns=['Date Time'], dtype='int8')
dataset_df_y = df.iloc[:, 1]
dataset_df_x = df.drop('T (degC)', axis=1)
dataset_x = dataset_df_x.iloc[:-TIME_PERIOD].to_numpy()
dataset_y = dataset_df_y.iloc[TIME_PERIOD:].to_numpy()
Tabii bu işlemin yapı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TIME_PERIOD = 24 * 60 // 10
import pandas as pd
df = pd.read_csv('jena_climate_2009_2016.csv')
dttm = df.iloc[:, 0]
df.iloc[:, 0] = dttm.str[10:]
df = pd.get_dummies(df, columns=['Date Time'], dtype='int8')
dataset_df_y = df.iloc[:, 1]
dataset_df_x = df.drop('T (degC)', axis=1)
dataset_x = dataset_df_x.iloc[:-TIME_PERIOD].to_numpy()
dataset_y = dataset_df_y.iloc[TIME_PERIOD:].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
mms = StandardScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential(name='Boston-Housing-Price')
model.add(Dense(128, activation='relu', input_dim=training_dataset_x.shape[1], name='Hidden-1'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dropout(0.2, name='Dropout-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=10, restore_best_weights=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Yukarı ı ı
isimli sembolik sabitimiz son kaç ölçümün değerinin geri beslemeye sokulacağı ı
kadar sonraki hava sı ı ı ı ı ı
birere birer kaydı ı ı ı
verilerle eğitim denenmelidir. Biz de aşağı ı ı ı ı
sı ı ı ı ı ı ı ı ı
Bu durumda bizim bu mettotta x verisi olarak (BATCH_SIZE, RECURRENT_TIME_PERIOD, x.shape[1]) boyutunda bir bilgiyle geri
dönmemiz gerekir. Benzer biçimde y verisi için de BATCH_SIZE kadar veri oluşturmamı
biz saat 10:00'dan itibaren 10'ar dakika aralı ı ı ı ı ı
Yukarı ı ı ı ı
kullanarak tahmin yapmak istemekteyiz.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
PREDICT_TIME_PERIOD = 24 * 60 // 10 # 144
RECURRENT_TIME_PERIOD = 50
BATCH_SIZE = 32
import pandas as pd
df = pd.read_csv('jena_climate_2009_2016.csv')
dttm = df.iloc[:, 0]
df.iloc[:, 0] = dttm.str[10:]
df = pd.get_dummies(df, columns=['Date Time'], dtype='int8')
dataset_y = df.iloc[:, 1].to_numpy()
dataset_x = df.drop('T (degC)', axis=1).to_numpy()
from sklearn.model_selection import train_test_split
2024-10-08 00:12:04 +03:00
temp_training_dataset_x, test_dataset_x, temp_training_dataset_y, test_dataset_y =
train_test_split(dataset_x, dataset_y, test_size=0.2, shuffle=False)
2024-04-02 13:01:04 +03:00
from sklearn.preprocessing import StandardScaler
mms = StandardScaler()
mms.fit(temp_training_dataset_x)
temp_scaled_training_dataset_x = mms.transform(temp_training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
2024-10-08 00:12:04 +03:00
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y =
train_test_split(temp_scaled_training_dataset_x, temp_training_dataset_y, test_size=0.2, shuffle=False)
2024-04-02 13:01:04 +03:00
import numpy as np
from tensorflow.keras.utils import Sequence
class DataGenerator(Sequence):
def __init__(self, x, y, batch_size, shuffle=True):
super().__init__()
self.x = x
self.y = y
self.batch_size = batch_size
self.shuffle = shuffle
self.total_batch = (len(x) - (PREDICT_TIME_PERIOD + RECURRENT_TIME_PERIOD)) // self.batch_size
self.indexes = list(range(self.total_batch))
def __len__(self):
return self.total_batch
def __getitem__(self, batch_no):
start_index_x = self.indexes[batch_no] * self.batch_size;
start_index_y = start_index_x + RECURRENT_TIME_PERIOD + PREDICT_TIME_PERIOD
stop_index_y = start_index_x + RECURRENT_TIME_PERIOD + PREDICT_TIME_PERIOD + self.batch_size
y = np.zeros(self.batch_size)
x = np.zeros((self.batch_size, RECURRENT_TIME_PERIOD, self.x.shape[1]))
for i in range(self.batch_size):
x[i] = self.x[start_index_x + i:start_index_x + RECURRENT_TIME_PERIOD + i]
y = self.y[start_index_y: stop_index_y]
return x, y
def on_epoch_end(self):
if self.shuffle:
np.random.shuffle(self.indexes)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import SimpleRNN, Flatten, Dense, Dropout
model = Sequential(name='Jena-Climate')
model.add(SimpleRNN(32, name='SimpleRNN-1', input_shape=(RECURRENT_TIME_PERIOD, training_dataset_x.shape[1]), return_sequences=True))
model.add(Flatten(name='Flatten'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Dense(128, activation='relu', input_dim=training_dataset_x.shape[1], name='Hidden-1'))
model.add(Dropout(0.2, name='Dropout-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=10, restore_best_weights=True)
2024-10-08 00:12:04 +03:00
hist = model.fit(DataGenerator(training_dataset_x, dataset_y, BATCH_SIZE),
validation_data=DataGenerator(validation_dataset_x, validation_dataset_y, BATCH_SIZE, False),
batch_size=BATCH_SIZE, epochs=200, callbacks=[esc])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(DataGenerator(scaled_test_dataset_x, test_dataset_y, BATCH_SIZE))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_data = test_dataset_x[1000:1000 + RECURRENT_TIME_PERIOD].reshape(1, RECURRENT_TIME_PERIOD, -1)
predict_result = model.predict(predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Geri beslemeli ağlarda (RNN) çı ı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
"vanishing gradient" denilen matematiksel problem yüzünden yüzeyselleşmektedir. Başka bir deyişle ağ eğitim sı ı
veriler üzerinde hafı ı ı ı
Çı ı ı ı ı
bunun matematiksel açı ı ı ı ı
İşte geçmişin ağda daha iyi hatı ı ı
Bunlardan en önemlilerinden biri LSTM (Long Short Term Memory) modeldir.
LSTM modelinde yine SimpleRNN modelinde olduğu gibi bir önceki çı ı ı
bileşeni daha eklenmiştir. Bu girdi bileşeni ağı ı ı ı
ağa eklenen ilave "carry" girişinin nası ı ı
Ancak ağa eklenen bu yeni giriş ağı ı ı ı ı ı
modülünde LSTM isimli bir sı ı ı ı ı ı ı ı ı ı ı ı
ağa eklediği eğitilebilir parametrelerin sayı ı ı ı ı ı
kadar olmaktadı
Aşağı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import numpy as np
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
import re
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dropout, Flatten, Dense
model = Sequential(name='IMDB-SimpleRNN')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(LSTM(64, name='LSTM', return_sequences=True))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(64, activation='relu', name='Dense-1'))
model.add(Dropout(0.2, name='Dropout-21'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Ağa uzun dönem hafı ı ı
ağa üçüncü bir giriş uygulanmaktadı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
LSTM ile GRU arası ı ı
- GRU katmanı ı ı
Solayı ı ı ı ı ı
yalı
- GRU katmanı ı ı ı ı ı ı ı
eğitim verileri için bu nedenden dolayı
- LSTM katmanı ı ı ı ı ı ı
değişebilmektedir.
Yukarı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
import numpy as np
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
import re
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
from tensorflow.keras.utils import pad_sequences
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, GRU, Dropout, Flatten, Dense
model = Sequential(name='IMDB-GRU')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(GRU(64, name='GRU', return_sequences=True))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(64, activation='relu', name='Dense-1'))
model.add(Dropout(0.2, name='Dropout-21'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Geri beslemeli ağlarda biz önceki çı ı ı ı
problem yüzünden geçmişe ilişkin hafı ı ı
geçmişin daha iyi anı ı ı ı ı ı ı ı ı
Örneğin metinlerin anlamlandı ı ı ı
sonradan anlaşı ı ı
Bu durumda eğer o dükannı ı ı ı ı
Örneğin İngilizce'de "the book on the table ..." biçimindeki bir cümlede kitabı ı ı ı
Ancak "masanı ı ı ı ı ı ı ı ı
açı ı ı
İşte geri beslemenin önceki çı ı ı ı ı ı ı ı ı ı
ilişkilendirilmesi daha iyi bir öğrenmeye yol açabilektedir. Bu tür geri beslemeli ağlara "çift yönlü (bidriectional)" geri beslemeli ağlar
denilmektedir. Çift yönlü geri besleme ağı ı ı ı ı ı ı ı ı
Ancak bazı
Çift yönlü geri beslemenin her zaman tek yönlü geri beslemeden daha iyi sonuç vereceği söylenemez. Uygulamacı ı
denemesi tavsiye edilmektedir.
Keras'ta çift yönlü geri besleme işlemi tensorflow.keras.layers modülündeki Bidirectional sı ı ı ı ı ı ı ı ı
oluşturulmuştur. Biz bu sı ı ı ı ı ı ı
metodunun parametrik yapı ı
tf.keras.layers.Bidirectional(
layer,
merge_mode='concat',
weights=None,
backward_layer=None,
**kwargs
)
Bu durumda bizim ağı ı ı ı ı ı
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dropout, Flatten, Dense
model = Sequential(name='IMDB-LSTM-Bidirectional')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(Bidirectional(LSTM(64, name='LSTM', return_sequences=True), name='Bidirectional'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(64, activation='relu', name='Dense-1'))
model.add(Dropout(0.2, name='Dropout-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(df['review'])
2024-09-16 10:49:44 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import re
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.utils import pad_sequences
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
2024-04-02 13:01:04 +03:00
from sklearn.model_selection import train_test_split
2024-09-16 10:49:44 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dropout, Flatten, Dense
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Sequential(name='IMDB-LSTM-Bidirectional')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(Bidirectional(LSTM(64, name='LSTM', return_sequences=True), name='Bidirectional'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(64, activation='relu', name='Dense-1'))
model.add(Dropout(0.2, name='Dropout-2'))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.summary()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.callbacks import EarlyStopping
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
esc = EarlyStopping(patience=5, restore_best_weights=True)
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
2024-09-16 10:49:44 +03:00
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
2024-04-02 13:01:04 +03:00
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
2024-09-16 10:49:44 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
2024-04-02 13:01:04 +03:00
plt.show()
2024-09-16 10:49:44 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
TExT_SIZE = 250
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import pandas as pd
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
df = pd.read_csv('IMDB Dataset.csv')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.feature_extraction.text import CountVectorizer
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
cv = CountVectorizer()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
cv.fit(df['review'])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import numpy as np
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import re
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
text_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in df['review']]
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.utils import pad_sequences
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
dataset_x = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from sklearn.model_selection import train_test_split
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, Bidirectional, GRU, Dropout, Flatten, Dense
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model = Sequential(name='IMDB-GRU')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(Bidirectional(GRU(64, name='GRU', return_sequences=True), name='Bidirectional'))
model.add(Dropout(0.2, name='Dropout-1'))
model.add(Flatten(name='Flatten'))
model.add(Dense(64, activation='relu', name='Dense-1'))
model.add(Dropout(0.2, name='Dropout-21'))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
model.add(Dense(1, activation='sigmoid', name='Output'))
2024-04-02 13:01:04 +03:00
model.summary()
2024-09-16 10:49:44 +03:00
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
from tensorflow.keras.callbacks import EarlyStopping
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
esc = EarlyStopping(patience=5, restore_best_weights=True)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
hist = model.fit(training_dataset_x, training_dataset_y, epochs=100, batch_size=32, validation_split=0.2, callbacks=[esc])
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
import matplotlib.pyplot as plt
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
2024-04-02 13:01:04 +03:00
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
2024-09-16 10:49:44 +03:00
predict_texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
predict_vectors = [[cv.vocabulary_[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(text_vectors, TExT_SIZE, padding='post', truncating='post')
predict_result = model.predict(predict_data)
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
for result in predict_result[:, 0]:
if result > 0.5:
print('Positive')
else:
print('Negative')
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
2024-09-16 10:49:44 +03:00
Metinsel çı ı ı ı ı ı
Bu sayede belli bir tarza uygun yapay yazı ı
Biz basit bir model üzerinde duracağı ı ı
harfleri tahmin edebilecek bir sinir ağı ı
elde ederiz. Böylece problemi belli uzunlukta yazı ı ı ı
30 karakter olarak belirleyelim. Yazarı ı ı ı
bunu bir veri kümesi biçimine dönülştürebiliriz. Böylece 30 karakter verildiğinde 31'inci karakteri tahmin edebilen bir
model elde edilmiş olur. Biz de ilk 30 karakter uydurarak sürkli kaydı
Buradaki model çok sı ı ı ı ı
yöntemi ile sayı ı ı ı
one-hot encoding yapı ı
2024-04-02 13:01:04 +03:00
2024-09-16 10:49:44 +03:00
Pekiyi yukarı ı
lojistik regresyondaki sı ı ı ı ı ı ı ı ı
ayrı ı ı ı ı ı
bu uygulama sözcük temelinde de yürütülebilir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Resim tanı ı
azaltmak amacı ı ı ı ı ı
bu mimariler pek çok endüstriyel uygulamada tercih edilmektedir. Örneğin "denset" ya da "resnet" denilen mimariler resim tanı
en yaygı ı ı ı ı ı ı
İşte bu nedenle bu popüler ve yeni derin ağ mimarileri tensorflow.keras.aplication modülünde hazı ı
Hazı ı ı ı ı ı ı ı ı
oluşturulmaktadı ı ı ı ı ı ı
Kers içerisinde hazı ı ı
ağı ı ı
Yukarı ı ı ı ı ı ı
modellere göre daha fazla zaman almaktadı
Örneğin biz popüler bir mimari olan densenet121'i kullanmak isteyelim. Bunun için önce bir DenseNet121 nesnesi yaratı ı
from tensorflow.keras.applications.densenet import DenseNet121
dn121 = DenseNet121(include_top=False, weights=None, input_shape=(32, 32, 3))
Nesne yaratı ı ı
"imagenet" girilebilir. Eğer bu parametre "imagenet" olarak girilirse model eğitilirken ağı ı
veritabanı ı ı ı ı ı
bulundurulup bulundurulmayacağı
DenseNet121 nesnesi kendi içerisinde modelin katmanları ı ı ı ı ı ı ı ı ı
programcı ı ı ı ı ı ı ı ı ı ı ı
tensörünü vermektedir. Uygulamacı ı ı ı ı
Örneğin:
from tensorflow.keras.applications.densenet import DenseNet121
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model
dn121 = DenseNet121(include_top=False, input_shape=(32, 32, 3), weights=None)
result = Flatten(name='Flatten')(dn121.output)
out = Dense(10, activation='softmax', name='Output')(result)
model = Model(inputs=dn121.input, outputs=out)
model.summary()
Modelin output katmanı ı ı ı ı
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import cifar10
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar10.load_data()
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
from tensorflow.keras.applications.densenet import Resnet101
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model
rn101 = Resnet101(include_top=False, input_shape=(32, 32, 3), weights=None)
result = Flatten(name='Flatten')(rn101.output)
out = Dense(10, activation='softmax', name='Output')(result)
model = Model(inputs=rn101.input, outputs=out)
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping('val_loss', patience=5, verbose=1, restore_best_weights=True)
hist = model.fit(training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=100, callbacks=[esc], validation_split=0.2)
model.save('cifar10.h5')
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Categorical Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, ohe_test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
image_data = image_data / 255
predict_result = model.predict(image_data.reshape(1, 32, 32, 3))
result = np.argmax(predict_result)
print(f'{path}: {class_names[result]}')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer hazı ı ı ı ı ı
ilişkin hazı ı ı ı ı ı
verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import cifar10
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar10.load_data()
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
from tensorflow.keras.applications.densenet import ResNet101
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model
rn101 = ResNet101(include_top=False, input_shape=(32, 32, 3), weights=None)
result = Flatten(name='Flatten')(rn101.output)
out = Dense(10, activation='softmax', name='Output')(result)
model = Model(inputs=rn101.input, outputs=out)
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping('val_loss', patience=5, verbose=1, restore_best_weights=True)
hist = model.fit(training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=100, callbacks=[esc], validation_split=0.2)
model.save('cifar10.h5')
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Categorical Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
eval_result = model.evaluate(test_dataset_x, ohe_test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
image_data = image_data / 255
predict_result = model.predict(image_data.reshape(1, 32, 32, 3))
result = np.argmax(predict_result)
print(f'{path}: {class_names[result]}')
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesi uygulamaları ı ı ı
uygulamacı ı ı ı ı ı ı ı ı
- Özellik seçimi (feature selection)
- Özelliklerin indirgenmesi (dimentionality feature reduction)
- Verilerin ölçeklendirmesi (feature scaling)
2024-05-20 13:45:43 +03:00
- Kategorik verilerin sayı ı ı ı
2024-04-02 13:01:04 +03:00
- Verilerin kullanı ı
- Model seçimi (model selection)
- Modelin çeşitli parametrelerinin (hyperparameters) uygun biçimde ayarlanması
- Modelin kullanı ı
Yukarı ı ı ı ı ı ı
Bir ML probleminde karşı ı ı ı ı ı
Örneğin bir resim tanı ı ı ı
ne olması ı ı ı ı ı ı
belirlenmektedir. Bu tür araçlar bu sı ı ı ı ı
Auto ML araçları ı ı ı ı ı ı ı
yöntemleri uygulamak için oluşturulmuştur. Bazı ı ı ı
uygulamaları ı ı
Yapay sinir ağları ı ı ı ı ı ı ı ı
kullanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
AutoKeras aracı ı
https://autokeras.com/
Bu sitede oldukça basit örneklerle aracı ı ı ı ı ı ı
AutoKeras'ı ı
pip install autokeras
Biz kütüphaneyi aşağı ı
import autokeras as ak
AutoKeras kütüphanesinde temelde 6 sı ı ı
ImageClassifier
ImageRegressor
TextClassifier
TextRegressor
StructuredDataClassifier
StructuredDataRegressor
ImageClassifier sı ı ı ı ı ı ı ı ı ı ı ı ı ı
tespit etme problemi), TextClassifier sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
konu ile alaka dercesini tespit etmeye çalı ı ı ı ı ı ı ı
sı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
Bu sı ı ı ı ı ı
2024-04-02 13:01:04 +03:00
kendisi yapmaz. Bu işlemleri zaten bu sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
ImageClassifier sı ı ı ı ı ı
1) Önce ImageClassifer sı ı ı ı ı ı ı ı ı ı
autokeras.ImageClassifier(
num_classes=None,
multi_label=False,
loss=None,
metrics=None,
project_name="image_classifier",
max_trials=100,
directory=None,
objective="val_loss",
tuner=None,
overwrite=False,
seed=None,
max_model_size=None,
**kwargs
)
Görüldüğü gibi parametreler default değerler almaktadı ı ı ı ı ı ı
Default durumda sı ı ı ı ı ı ı ı ı ı
belirlenmeye çalı ı ı
tutulursa o kadar iyi sonuç elde edilir. Ancak en iyi modelin bulnması ı ı ı
demekle yalnı ı ı ı ı ı ı ı ı
değerlendirilmektedir. Dolayı ı ı ı ı
Yüksek değerler fit işleminin birkaç gün sürmesine yol açabilmektedir. Bunun için uygulamacı
objective parametresi model karşı ı ı ı ı ı ı ı ı ı
ile ayarlanmaktadı ı ı
False değeri metodun daha önce oluşturulnuş olan bilgileri kullanacağı ı ı
değerleri onun üzerine yazazağı ı
2) Modelin derlenmesi işlemi uygulamacı ı ı ı ı ı
tamamen Keras'taki fit metodu gibidir. fit metodu için programcı
Metodun parametreleri Keras'ta gördüğümüz gibidir. epochs parametresi her denenecek model için ne kadar epoch uygulanacağı ı
batch_size parametresi default durumda 32'dir. fit işlemi sı ı ı ı
gray scale resimler için widthxheightx1 biçiminde resimler kullanı ı ı
3) En iyi model AutoKeras tarafı ı ı ı ı
evaluate metodu kullanı ı
4) Elde edilen en iyi model istenirse Keras'ı ı ı ı ı ı ı ı
metodu kullanı ı ı ı ı
model nesnesi üzerinde uygulayabilir.
Yukarı ı ı ı
proje bir daha çalı ı ı ı ı ı ı ı
yer not alı ı
Aşağı ı ı ı ı ı ı ı
5'te tuttuk.
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import cifar100
class_names = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman',
'worm']
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = cifar100.load_data()
import autokeras as ak
ic = ak.ImageClassifier(max_trials=5, overwrite=True)
hist = ic.fit(training_dataset_x, training_dataset_y, epochs=5)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Categorical Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['categorical_accuracy'])
plt.plot(hist.epoch, hist.history['val_categorical_accuracy'])
plt.legend(['Categorical Accuracy', 'Validation Categorical Accuracy'])
plt.show()
model = ic.export_model()
eval_result = ic.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
model.summary()
model.save('image-classifier-best-model.h5')
import numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
image_data = image_data / 255
predict_result = model.predict(image_data.reshape(1, 32, 32, 3))
result = np.argmax(predict_result)
print(f'{path}: {class_names[result]}')
#----------------------------------------------------------------------------------------------------------------------------
ImageRegressor sı ı ı ı ı ı ı ı ı ı
ImageClassifier sı ı ı ı ı
autokeras.ImageRegressor(
output_dim=None,
loss="mean_squared_error",
metrics=None,
project_name="image_regressor",
max_trials=100,
directory=None,
objective="val_loss",
tuner=None,
overwrite=False,
seed=None,
max_model_size=None,
**kwargs
)
Bu sı ı ı ı ı ı ı ı ı
biçiminde kategorik bir veridir. Ancak biz bunu sanki sayı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import mnist
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = mnist.load_data()
import autokeras as ak
ir = ak.ImageRegressor(max_trials=5)
hist = ir.fit(training_dataset_x, training_dataset_y, epochs=5)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
model = ir.export_model()
model.summary()
model.save('image-classifier-best-model.h5')
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
TextClassifer sı ı ı ı ı ı ı ı ı ı ı
TextClassifier sı ı ı ı ı ı ı ı ı ı ı ı
işleminde training_dataset_x yazı
ya da sayı ı ı ı ı
yazı ı ı ı
yalnı ı ı
Aşağı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
dataset_x = df['review'].to_numpy()
dataset_y = df['sentiment'].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
import autokeras as ak
tc = ak.TextClassifier(max_trials=3)
hist = tc.fit(training_dataset_x, training_dataset_y, epochs=10)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
model = tc.export_model()
model.summary()
model.save('text-classifier-best-model.h5')
eval_result = tc.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
for predict_text in texts:
predict_result = tc.predict(texts)
if predict_result[0, 0] > 0.5:
print('Positive')
else:
print('Negative')
model.save('imdb.h5')
#----------------------------------------------------------------------------------------------------------------------------
Şimdiye kadar kullanmadı ı ı ı ı
olmadı ı ı ı
çoğu çeşitli makine öğrenmesi teknikleriyle oluşturulmuştur. Veri kümesi "spam_ham_dataset.csv" ismiyle aşağı ı
https://www.kaggle.com/datasets/venky73/spam-mails-dataset?resource=download
Burada Pandas'ı ı ı
label_num aynı ı ı ı ı ı ı ı
AutoKeras'ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('spam_ham_dataset.csv')
dataset_x = df['text'].to_numpy()
dataset_y = df['label_num'].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y)
import autokeras as ak
tc = ak.TextClassifier(max_trials=3)
hist = tc.fit(training_dataset_x, training_dataset_y, epochs=10)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['binary_accuracy'])
plt.plot(hist.epoch, hist.history['val_binary_accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
model = tc.export_model()
model.summary()
model.save('text-classifier-best-model.h5')
eval_result = tc.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
texts = ['the movie was very good. The actors played perfectly. I would recommend it to everyone.', 'this film is awful. The worst film i have ever seen']
for predict_text in texts:
predict_result = tc.predict(texts)
if predict_result[0, 0] > 0.5:
print('Positive')
else:
print('Negative')
model.save('imdb.h5')
#----------------------------------------------------------------------------------------------------------------------------
Resim ve yazı ı ı ı ı ı ı ı ı ı ı ı ı
parametrik yapı ı
autokeras.StructuredDataClassifier(
column_names=None,
column_types=None,
num_classes=None,
multi_label=False,
loss=None,
metrics=None,
project_name="structured_data_classifier",
max_trials=100,
directory=None,
objective="val_accuracy",
tuner=None,
overwrite=False,
seed=None,
max_model_size=None,
**kwargs
)
StructuredDataClassifer sı ı ı
sayı ı ı ı ı ı ı
bunları ı ı ı ı
Bu sı ı ı ı ı ı ı ı
hazı ı ı ı
edilmeye çalı ı ı
Modelden elde edilen history verilerinin içerisinde val_xxx verileri bulunmayabilir. Çünkü model denemesi yapı ı ı
veriler az ise biz validation_split ile belirtsek bile validation verileri kullanı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('titanic.csv')
dataset_x = df.drop(columns=['Survived'], axis=1)
dataset_y = df['Survived'].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
import autokeras as ak
sdc = ak.StructuredDataClassifier(max_trials=10, overwrite=True)
hist = sdc.fit(training_dataset_x, training_dataset_y, epochs=100, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Binary Accuracy Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(hist.epoch, hist.history['accuracy'])
plt.legend(['Binary Accuracy', 'Validation Binary Accuracy'])
plt.show()
model = sdc.export_model()
model.summary()
model.save('text-classifier-best-model.tf', save_format='tf')
eval_result = sdc.evaluate(test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Son AutoKeras sı ı ı ı ı ı ı ı ı
için kullanı ı ı ı ı ı ı ı ı
autokeras.StructuredDataRegressor(
column_names=None,
column_types=None,
output_dim=None,
loss="mean_squared_error",
metrics=None,
project_name="structured_data_regressor",
max_trials=100,
directory=None,
objective="val_loss",
tuner=None,
overwrite=False,
seed=None,
max_model_size=None,
**kwargs
)
AutoKeras modellerinde yine callback nesneleri kullanı ı ı ı ı ı ı
parametresine EarlyStopping callback nesnesi yerleştirirsek bu durumda denen model belirlediğimiz patience değerine bağlı ı ı
Aşağı ı ı ı ı ı ı
faydalanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı
1) Denetimli Öğrenme (Supervised Learning)
2) Denetimsiz Öğrenme (Unsupervised Learning)
3) Pekiştirmeli Öğrenme (Reinforcement Learning)
Biz şimdiye kadar "yapay sinir ağları ı ı ı ı
istatistiksel ve matematiksel başka yöntemlerle de gerçekleştirilebilmektedir.
Denetimli öğrenme diye x ve y verileri arası
Yani denetimli öğrenmede bir eğitim süreci vardı ı
kayı ı ı ı
değerleri arası ı ı
Denetimsiz (unsupervised) modellerde elimizde yalnı ı ı ı ı
Denetimsiz öğrenmede biz modele birtakı ı ı ı
bunları ı ı
kayı ı ı ı ı
Model de aslı ı ı ı ı
getirebilmektedir. Burada dikkat edilmesi gereken nokta bir eğitim sürecinin olmaması ı ı
Evet yapı
Denetimsi öğrenme için çeşitli yöntemler bulunmaktadı
denilen yöntem ile ilgilidir. Bu nedenle denetimsiz öğrenme denildiğinde akla ilk gelen yöntem kümeleme yöntemidir.
Biz de önce kümeleme yöntemlerini göreceğiz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde "sı ı ı ı ı ı ı
Sı ı ı ı ı ı ı ı ı
oluşturulması ı ı ı ı ı ı ı ı ı
2024-05-20 13:45:43 +03:00
oluşturulmaya çalı ı ı ı ı ı ı ı
(unsupervised)" bir yöntem grubunu belirtmektedir.
Elimizde hem x ve hem y verileri varken genellikle denetimli öğrenme yöntemleri tercih edilmektedir. Ancak bazen elimizde
yeteri kadar x verileri olduğu halde y verileri olmayabilir. Örneğin anomali içeren banka işlemlerini tespit etmek isteyelim.
Elimizde anomali içerdiğini açı ı
denetimli öğrenme uygun yöntem olmaktan çı ı ı ı
isteyelim. Elimizde virüslü dosyalarla virisiz dosyalar bulunuyor olabilir. Ancak virüs yöntemleri sürekli değişebilmektedir.
Bu durumda yeni veriler daha oluşmadan biz eğitimi yapamayı ı
edilmektedir.
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2024-05-20 13:45:43 +03:00
Kümeleme işlemleri aslı
(cluster analysis)" denilmektedir. Ancak son yirmi yı ı ı
başlandı ı ı
istatis bağlamı ı ı ı
2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kümeleme benzer olanları ı ı
2024-05-20 13:45:43 +03:00
Yani bir veri kümesinde satı ı ı ı ı
sezgisi ile ilgili bir kavramdı ı
İşte bir veri tablosundaki satı ı
dayandı ı ı ı ı
benzer değildir. Ancak uzaklı ı ı ı ı ı
uzaklı ı ı ı ı ı ı
"hamming uzaklı ı ı ı ı
problemlerde bazen tercih edilebilmektedir.
İki boyutlu kartezyen koordinat sistemni aslı
her bir satı ı ı ı ı ı
sqrt((ax - bx) ** 2 + (ay - by) ** 2) biçimindedir. N boyutlu uzaydaki iki nokta arası ı ı
Her boyun karşı ı ı ı ı ı ı ı ı
iki nokta arası ı ı ı ı
2024-04-02 13:01:04 +03:00
import numpy as np
def euclidean_distance(a, b):
return np.sqrt(np.sum((a - b) ** 2))
a = np.array([1, 4, 6, 2])
b = np.array([4, 2, -1, 7])
d = euclidean_distance(a, b)
print(d)
Öklit uzaklı ı
Öklit uzaklı ı ı
from scipy.spatial import distance
a = np.array([1, 4, 6, 2])
b = np.array([4, 2, -1, 7])
dst = distance.euclidean(a, b)
Ökltit uzaklı ı ı ı ı ı ı ı ı ı ı ı ı
iki nokta arası ı ı ı ı
olmak üzere sum(abs(ai - bi)) biçimindedir. Numpy'da bu uzaklı
import numpy as np
def manhattan_distance(a, b):
return np.sum(np.abs(a - b))
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
mdist = manhattan_distance(a, b)
print(mdist)
Manhattan uzaklı ı
from scipy.spatial.distance import cityblock
mdist = cityblock(a, b)
print(mdist)
Özellikle görüntü işleme gibi sayı ı ı ı ı ı ı
Hamming uzaklı ı ı ı ı ı ı ı ı ı
ankara
ayazma
Bu iki yazı ı ı ı
from scipy.spatial.distance import hamming
a = np.array([1, 0, 0, 1])
b = np.array([1, 1, 0, 0])
hdist = hamming(a, b)
print(hdist) # 0.5
Kosinüs uzaklı ı ı ı ı ı ı ı ı
Aslı ı ı ı ı ı ı
Uzaklı ı ı ı ı ı ı ı ı ı
üç sütüunda oluşan aşağı
F1 F2 F3
0.2 123 1234678
0.4 567 2567865
0.7 328 1876345
... ... ...
Burada iki nokta arası ı ı
O halde bizim bu tür uygulamalarda sütunları ı ı
ölçeklemesi uygulamalı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yüzün üzerinde kümeleme algoritması ı ı ı
Ancak bazı ı ı ı ı ı ı ı
bakı ı ı
1) Ağı ı
2) Bağlantı ı
3) Yoğunluk Temelli (Density Based) Algoritmalar
4) Dağı ı
5) Bulanı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kümeleme algortimaları ı ı ı ı
Algoritmik karmaşı ı ı
K-Means algoritması ı
1) Küme sayı ı ı ı ı ı ı ı ı ı ı ı
bizzat uygulamacı ı ı ı ı
2) k tane küme için işin başı ı ı
3) Tüm noktaları ı ı ı ı ı ı ı ı
dahil edilir. Artı ı ı ı
4) Kümelerin yeni ağı ı ı ı ı ı
her boyutun kendi araları ı ı ı ı ı ı ı ı
centroidx = (ax + bx + cx) / 3
centroidy = (ay + by + cy) / 3
centroidz = (az + bz + cz) / 3
Aslı ı
5) Tüm noktaları ı ı ı ı ı ı ı ı
Böylece bazı ı
6) Eğer yeni ağı ı ı ı ı ı ı
Bu algoritmik yönteme "Lloyd" algoritması
Bu yöntemde performas ölçütü olarak neyi kullanabiliriz? En çok kullanı
Atalet her noktanı ı ı ı ı ı ı ı
K-Means yönteminde algoritma ratgele alı ı ı ı ı ı ı ı ı ı ı ı ı
rastgele alı ı ı ı ı ı ı ı ı ı ı ı ı ı
aynı ı ı ı ı ı ı
algoritmayı ı ı ı ı
Algoritmanı ı ı ı ı ı
Pekiyi biz KMeans algoritması ı ı ı
basit bir biçimde noktanı ı ı ı ı ı ı ı
Aşağı
yapı ı
kmeans(dataset, nclusters, centroids=None)
Fonksiyonun birinci parametresi kümelenecek olan noktaları ı ı
parametre başlangı ı ı ı ı ı ı
bir biçimde alı ı ı ı
içerisinde bulunduğu bilgisidir. İkinci eleman NumpPy dizilerinden oluşan bir liste biçimindedir. Bu listenin içerisindeki dizilerde sı ı
kümedeki noktalar bulunmaktadı ı ı ı ı ı ı ı ı ı
karelerinin toplamı ı
Aşağı ı ı ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import numpy as np
from scipy.spatial.distance import euclidean
def kmeans(dataset, nclusters, centroids=None):
nrows = dataset.shape[0]
clusters = np.full(nrows, -1)
if centroids == None:
centroids = rand_centroids(dataset, nclusters)
change_flag = True
while change_flag:
change_flag = False
for i in range(nrows):
min_val = np.inf
min_index = -1
for k in range(nclusters):
if not np.any(np.isnan(centroids[k])):
result = euclidean(dataset[i], centroids[k])
if result < min_val:
min_val = result
min_index = k
if clusters[i] != min_index:
change_flag = True
clusters[i] = min_index
for i in range(nclusters):
idataset = dataset[clusters == i]
centroids[i] = np.mean(idataset, axis=0) if len(idataset) else np.nan
dataset_clusters = []
inertia = 0
for i in range(nclusters):
idataset = dataset[clusters == i]
dataset_clusters.append(idataset)
inertia += np.sum((idataset - centroids[i]) ** 2) if len(idataset) > 0 else 0
return clusters, dataset_clusters, centroids, inertia
def rand_centroids(dataset, nclusters):
ncols = dataset.shape[1]
centroids = np.zeros((nclusters, ncols), dtype=np.float32)
for i in range(ncols):
maxi = np.max(dataset[:, i])
mini = np.min(dataset[:, i])
rangei = maxi - mini
centroids[:, i] = mini + rangei * np.random.random(nclusters)
return centroids
dataset = np.loadtxt('points.csv', delimiter=',', dtype='float32')
clusters, dataset_clusters, centroids, inertia = kmeans(dataset, NCLUSTERS)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(dataset_clusters[i][:, 0], dataset_clusters[i][:, 1])
plt.scatter(centroids[:, 0], centroids[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
legends.append('Centroids')
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
K-Means kümeleme algoritması ı ı ı ı
parametrik yapı ı
KMeans(n_clusters=8, *, init='k-means++', n_init='warn', max_iter=300, tol=0.0001, verbose=0, random_state=None, copy_x=True, algorithm='lloyd')
Metodun birinci parametresi ayrı ı ı ı ı ı ı ı ı
nası ı ı
algoritmanı ı ı ı ı ı ı
Ancak güncel versiyonlarda 1 değeri kullanı ı ı ı ı ı
belirtmektedir. Bu parametrenin default değerinin 300 olduğunu görüyorsunuz. Yani algoritma 300 adı ı
sonlandı ı ı ı ı
"llyod" biçimindedir. K-Means algoritmaları ı ı ı ı ı ı ı ı ı ’ ı ı
LLyod algoritması ı ı ı ı ı ı ı ı ı ı ı
söz konusu olabilmektedir.
KMeans nesnesi yaratı ı ı
iki boyutlu bir matris biçiminde bizden alı ı
önemli bilgiler elde edilebilmektedir:
cluster_centers_: Bu öznitelik nihai durumdaki ağı ı
labels_: Her noktanı ı ı ı ı ı ı
aslı ı
inertia_: Bu öznitelik tüm noktaları ı ı ı ı ı ı ı
n_iter_: Bu öznitelik sonuca varmak için kaç iterasyonun uygulandı ı ı
n_features_in_: Veri kümesindeki sütunları ı ı ı
Sı ı ı ı ı ı
ağı ı ı ı ı ı
transform işlemi yapar. Ancak bu sı ı ı
km.fit(dataset)
result = km.transform(dataset)
işlemi ile:
result = fit_transform(dataset)
aynı ı ı ı ı ı ı ı ı ı ı
elde ederiz.
Sı ı ı ı ı ı
aldı ı ı ı ı ı ı ı ı ı ı
Sı ı ı ı ı
predict_result = km.fit(dataset).predict(dataset)
İşleminin eşdeğeri şöyledir:
predict_result = fit_predict(dataset)
Aşağı ı ı ı ı ı ı ı ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',', dtype='float32')
import matplotlib.pyplot as plt
plt.title('Points')
plt.scatter(dataset[:, 0], dataset[:, 1])
plt.show
from sklearn.cluster import KMeans
km = KMeans(n_clusters=NCLUSTERS, n_init=10)
km.fit(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[km.labels_ == i, 0], dataset[km.labels_ == i, 1])
plt.scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
legends.append('Centroids')
plt.legend(legends)
plt.show()
x = np.array([[1, 2], [5, 7], [8, 9]], dtype='float32')
result = km.transform(x)
print(result)
predict_result = km.predict(x)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de K-Means kümeleme yöntemini daha önce yaptı ı ı ı ı
veri kümesinde ilk sütun sı ı ı ı ı ı ı ı ı ı ı
olduğunu biliyoruz. O zaman biz bu veri kümesini üç kümeye ayı ı ı
Aşağı ı ı
Bizim iki boyutlu grafik çizebilmemiz için iki özelliğin olması
denilen teknik ile iki özelliğe indirgeyip grafiği öyle çizdik.
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.cluster import KMeans
km = KMeans(n_clusters=NCLUSTERS, n_init=20)
km.fit(scaled_dataset)
print(km.labels_)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(decomposed_dataset[km.labels_ == i, 0], decomposed_dataset[km.labels_ == i, 1])
# plt.scatter(centroids[:, 0], centroids[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
plt.show()
import numpy as np
predict_data = np.array([[5.0,3.5,1.6,0.6], [4.8,3.0,1.4,0.3], [4.6,3.2,1.4,0.2]], dtype='float64')
transformed_predict_data = mms.transform(predict_data)
predict_result = km.predict(transformed_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
K-Means yönteminde bizim işin başı ı ı ı ı ı
Bazen problemin kendi içeisinde zaten küme sayı ı ı ı
Ama biz hangi resmin hangiyi meyveye ilişkin olduğunu bilmiyor olalı ı
Ancak hangi meyvelerin hangi resimlerle ilişkili oludğunu bilmemekteyiz. Tabii pek çok durumda biz küme sayı ı ı
En iyi küme syaı ı ı ı ı
1) Dirsek Yötmei (Elbow Method)
2) Silhouette Yöntimi (Silhouette Method)
Dirsek yönteminde önce 1'den başlanarak n'e kadar küme sayı ı ı ı
(Toplam ataletin KMeans sı ı ı ı ı ı ı ı ı ı ı
uzaklı ı ı ı ı ı ı
Bu grafikta eğrinin yataya geçtiği nokta gözle tespit edilir. Eğrinin yataya geçtiği noktaya "dirsek noktası
Aşağı ı ı
aşağı ı ı
total_inertias = [KMeans(n_clusters=i, n_init=10).fit(dataset).inertia_ for i in range(1, 10)]
fit metodu nesnenin kendisine geri döndüğü için kompaks bir yazı ı ı
Aşağı ı ı ı ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from sklearn.cluster import KMeans
total_inertias = [KMeans(n_clusters=i, n_init=10).fit(dataset).inertia_ for i in range(1, 10)]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Elbow Graph')
plt.plot(range(1, 10), total_inertias, marker='o', markersize=12)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de zambak veri kümesi için dirsek yöntemiyle küme sayı ı ı ı ı ı
3 (4 de olabilir) olarak belirlenmiştir. Dirsek noktası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.cluster import KMeans
total_inertias = [KMeans(n_clusters=i, n_init=10).fit(scaled_dataset).inertia_ for i in range(1, 15)]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Elbow Graph')
plt.plot(range(1, 15), total_inertias, marker='o', markersize=12)
plt.xticks(range(1, 15))
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Silhouette yönteminde yine 2'den başlanarak belli sayı
denilen bir değer elde edilmektedir. Bu değerin en yüksek olduğu kme sayı ı ı ı ı ı
Silhouette skor sklearn.metrics modülündeki silhouette_score isimli fonksiyonla elde edilebilmektedir. Bu fonksiyona parametre olarak
veri kümesi ve kümelenmiş sonuçlar (yani labels_ değeri) verilmektedir. Silhouette skor işlemi tek kümeyle yapı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from sklearn.cluster import KMeans
km_labels = [KMeans(n_clusters=i, n_init=10).fit(dataset).labels_ for i in range(2, 10)]
from sklearn.metrics import silhouette_score
sc_list = []
for index, labels in enumerate(km_labels, 2):
sc = silhouette_score(dataset, labels)
print(f'{index} ---> {sc}')
sc_list.append(sc)
optimal_cluster = np.array(sc).argmax() + 2 + 1
print(f'optimal cluster: {optimal_cluster}')
km = KMeans(n_clusters=optimal_cluster, n_init=10).fit(dataset)
print(km.labels_)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.cluster import KMeans
km_labels = [KMeans(n_clusters=i, n_init=10).fit(dataset).labels_ for i in range(2, 15)]
import numpy as np
from sklearn.metrics import silhouette_score
sc_list = []
for index, labels in enumerate(km_labels, 2):
sc = silhouette_score(dataset, labels)
print(f'{index} ---> {sc}')
sc_list.append(sc)
optimal_cluster = np.array(sc).argmax() + 2 + 1
print(f'optimal cluster: {optimal_cluster}')
km = KMeans(n_clusters=optimal_cluster, n_init=10).fit(dataset)
print(km.labels_)
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı
içeren (mixed biçimde olan) veri kümelerinde kümeleme işlemi nası ı ı ı
Bazı ı ı ı ı ı ı
kategorik sütun da içeren veri kümeleri için uzaklı ı ı ı ı
değiştirebilmektedir. Bunun "Gower" uzaklı ı ı ı
henüz bu "gower" uzaklı ı ı ı ı ı ı
sinir ağları ı ı ı ı
kümesinden atmak olabilir.
Aşağı ı ı
Bu veri kümesini aşağı ı
https://www.kaggle.com/datasets/dev0914sharma/customer-clustering?resource=download
Bu veri kümesinde şu sütunlar bulunmaktadı
Nurada "Sex" iki kategorili, "Marital status" iki kategorili, "Education" 4 kategorili, "Occupation" 3 kategorili ve "Settlement size" 3
2024-05-20 13:45:43 +03:00
kategorili sütunlardı
2024-04-02 13:01:04 +03:00
uyguladı ı ı
Bu örnekte optimal küme sayı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('segmentation-data.csv')
df.drop(labels=['ID'], axis=1, inplace=True)
ohe_df = pd.get_dummies(df, columns=['Education', 'Occupation', 'Settlement size'])
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(ohe_df.to_numpy())
from sklearn.cluster import KMeans
total_inertias = [KMeans(n_clusters=i, n_init=10).fit(scaled_dataset).inertia_ for i in range(1, 100)]
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 8))
plt.title('Elbow Graph')
plt.plot(range(1, 100), total_inertias, marker='o')
plt.xticks(range(1, 100, 5))
plt.show()
km_labels = [KMeans(n_clusters=i, n_init=10).fit(scaled_dataset).labels_ for i in range(2, 100)]
import numpy as np
from sklearn.metrics import silhouette_score
sc = np.array([silhouette_score(scaled_dataset, labels) for labels in km_labels])
optimal_cluster = np.array(sc).argmax() + 2 + 1
print(f'optimal cluster: {optimal_cluster}')
km = KMeans(n_clusters=optimal_cluster, n_init=100)
km.fit(scaled_dataset)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
transformed_dataset = pca.fit_transform(scaled_dataset)
plt.figure(figsize=(20, 16))
plt.title('Clustered Points')
for i in range(1, optimal_cluster + 1):
plt.scatter(transformed_dataset[km.labels_ == i, 0], transformed_dataset[km.labels_ == i, 1])
plt.show()
plt.figure(figsize=(20, 16))
plt.title('Clustered Points')
for i in range(1, optimal_cluster + 1):
plt.scatter(transformed_dataset[km.labels_ == i, 0], transformed_dataset[km.labels_ == i, 1])
xmean = np.mean(transformed_dataset[km.labels_ == i, 0])
ymean = np.mean(transformed_dataset[km.labels_ == i, 1])
plt.text(xmean, ymean, f'{i}')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de MNIST veri kümesine K-Means yöntemini uygulayalı
binlerce resim vermiş olsun. Bu resimleri veren kişi bu resimlerin 10 farklı
hangi olguya ilişkin olduğunu resmi veren kişi bilmesin. Bu durumda kişi bizden bu resimleri 10 farklı ı ı ı
Biz de K-Means yöntemiyle bunu yapmaya çalı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
K-Means yöntemi uç değerlerden oldukça etkilenmektedir. Bu nedenle uygulamacı ı
uygun olur. İleride göreceğimiz başka yöntemler bu uç değerlerden fazlaca etkilenmemektedir. K-Means algoritma karmaşı ı ı ı ı ı ı
bir yöntemdir. K-Means yönteminde en önemli noktalardan biri başlanı ı ı ı
yönteminin başlangı ı ı ı ı
denilen algoritmadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Çok kullanı ı
denilen yöntem grubudur. Bu yöntem grubu kendi içerisinde "agglomerative" ve "divisive" olmak üzere ikiye ayrı ı
yöntemler "aşağı ı ı ı
agglomerative yöntemler tercih edilmektedir. Bu yöntemlere de "agglomerative hiyerarşik kümeleme" denilmektedir.
Agglomerative kümeleme algoritması ı
1) Önce her nokta ayrı ı ı
2) Tüm noktalarla tüm noktalar arası ı ı ı
3) En yakı ı ı ı
Dolayı ı ı ı ı
arası ı ı ı
birleştirme yapı ı
Algoritmadaki önemli noktalar şunlardı
- Yine noktalar arası ı ı ı ı ı ı
- Birden fazla noktadan oluşan küme tek nokta olarak nası ı ı ı ı
burada birkaç hesaplama yöntemi kullanı
Min Yöntemi: Kümelerin en yakı ı ı ı ı
Max Yöntemi: Kümelerin en uzak elemanları ı ı
Grup Ortalaması ı ı ı ı ı ı ı
dikkate alı ı
Ward Yöntemi: Noktalarla kümenin tüm noktaları ı ı ı ı ı
olarak dikkate alı ı
Uygulamada en fazla "ward yöntemi" denilen yöntem kullanı ı
Agglomerative hiyerarşik kümelemede hangi noktaları
çizilebilmektedir. Buna "dendrogram" denilmektedir.
Agglomaerative hiyerarşik kümelemede her kümeleme işleminde aynı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Agglomerative hiyerarşik kümeleme işlemleri için scikit-learn kütüphanesinde AgglomerativeClustering isimli bir sı ı
Sı ı ı ı ı
sklearn.cluster.AgglomerativeClustering(n_clusters=2, *, affinity='deprecated', metric=None, memory=None,
connectivity=None, compute_full_tree='auto', linkage='ward', distance_threshold=None, compute_distances=False)
Metodun n_clusters parametresi oluşturulacak nihai küme sayı ı ı ı ı
yerine "metric" kullanı ı ı ı ı ı ı ı
metric ismi kullanı ı ı ı ı
yöntemini belirtmektedir. Buradaki None default değeri "Öklit uzaklı ı ı ı
sanki "euclidean" girmiş gibi oluruz. linkage parametresi kümeye ilişkin noktaları ı ı ı
Bu parametreye şu değerler girilebilir: "ward", "average", "complete ya da maximum", "single". Bu parametrenin default değeri "ward"
biçimdedir. Bu durum kümenin tüm noktaları ı ı ı ı ı ı
grup ortalaması ı ı ı ı ı
Metodun diğer parametreleri çok önemli değildir.
AgglomerativeClustering nesnesi yaratı ı ı ı ı ı ı ı
fit işleminden sonra sonuçlar nesnenin özniteliklerinden alı ı
nclusters_: Elde edilen müme sayı ı ı ı ı ı ı
parametresi için bir değer girilirse bu durumda bu eşik uzaklı ı ı ı
bu durumda __init__ metodunun birinci parametresi None girilmelidir. Çünkü küme sayı ı ı ı ı ı
için bir değer girilirse aynı ı
labels_: Tı ı ı ı ı ı ı ı ı ı ı
n_features_in_: fit işlemine sokulan veri kğmesindeki sütun sayı ı ı
distances_: Eğer nesne yaratı ı
uzaklı
Aşağı ı ı ı ı ı ı ı ı
"points.csv" dosyası ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from sklearn.cluster import AgglomerativeClustering
ac = AgglomerativeClustering(n_clusters=NCLUSTERS, affinity='euclidean', linkage='ward', compute_distances=True)
ac.fit(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[ac.labels_ == i, 0], dataset[ac.labels_ == i, 1])
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdide Agglomerative kümeleme yöntemini "zambak veri kümesine (iris.csv)" uygulayalı ı
edilen sonuçlarla kaşı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.cluster import KMeans
km = KMeans(n_clusters=NCLUSTERS, n_init=20)
km.fit(scaled_dataset)
print(km.labels_)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(decomposed_dataset[km.labels_ == i, 0], decomposed_dataset[km.labels_ == i, 1])
# plt.scatter(centroids[:, 0], centroids[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
plt.show()
import numpy as np
predict_data = np.array([[5.0,3.5,1.6,0.6], [4.8,3.0,1.4,0.3], [4.6,3.2,1.4,0.2]], dtype='float64')
transformed_predict_data = mms.transform(predict_data)
predict_result = km.predict(transformed_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
KMeans sı ı ı ı ı ı ı ı ı ı
olduğunu hesaplayı ı ı ı ı ı ı ı ı
bir ağı ı ı ı ı ı ı ı
temelinde yapı ı ı ı ı ı ı
özniteliğini vermektedir. Başka bir deyişle:
result = ac.fit_predict(dataset)
işlemi ile aşağı
ac.fit(dataset)
result = ac.labels_
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirtildiği gibi elimizde zaten hangi noktaları ı ı
burada kestirim amacı ı ı ı ı ı
olduğu bilindiği halde kümeleme yöntemlerini kullanabiliriz. Örneğin mademki elimizde zambak verilerinin hangi sı ı
bu yöntemlerin başarı ı ı ı ı
orijinal sı ı ı ı ı ı ı
her çalı ı ı ı ı ı ı ı ı ı
AgglomerativeClustering sı ı ı ı ı
numaralı
Aşağı ı ı ı
iki boyutlu grafik çizilmiştir. Burada farklı ı ı ı ı ı ı ı ı ı
küme numaları ı ı ı ı ı ı ı ı
kümeleri uyuşmamaktadı
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.cluster import KMeans
km = KMeans(n_clusters=NCLUSTERS, n_init=20)
km.fit(scaled_dataset)
print(km.labels_)
from sklearn.cluster import AgglomerativeClustering
ac = AgglomerativeClustering(n_clusters=NCLUSTERS, affinity='euclidean', linkage='ward')
ac.fit(scaled_dataset)
print(ac.labels_)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(decomposed_dataset[ac.labels_ == i, 0], decomposed_dataset[ac.labels_ == i, 1])
different_rows = km.labels_ != ac.labels_
plt.scatter(decomposed_dataset[different_rows,0], decomposed_dataset[different_rows,1], color='red')
# plt.scatter(centroids[:, 0], centroids[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn içerisinde kümeleme ve sı ı ı ı
modülü içerisindedir. make_blobs fonksiyonu belli bir merkezden hareketle onun çevresinde rastgele noktalar üretmektedir. Fonksiyonun parametrik yapı ı
şöyledir:
sklearn.datasets.make_blobs(n_samples=100, n_features=2, *, centers=None, cluster_std=1.0,
center_box=(-10.0, 10.0), shuffle=True, random_state=None, return_centers=False)
Buradaki n_samples parametresi üretlecek noktaları ı ı ı
oluşacağı ı ı ı ı
cluster_std parametresi rastgele noktaları ı ı ı ı ı ı
büyütülürse noktalar daha merkezden uzak üretilmektedir. center_box parametresi ikili bir demet almaktadı
aralı ı ı ı ı ı
Bu parametreye spesifik bir değer girilirse hep aynı ı ı ı ı
noktalar elde edilmektedir.
Fonksiyon bize normal olarak iki elemanlı ı ı ı
onları ı ı ı ı
Demetin üçüncü elemanı ı ı
Aşağı ı ı ı
kümelenmiştir.
#----------------------------------------------------------------------------------------------------------------------------
NCLUSTERS = 3
from sklearn.datasets import make_blobs
dataset, labels = make_blobs(n_samples=1000, n_features=2, centers=3, cluster_std=1)
print(dataset)
print(labels)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Random Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.show()
from sklearn.cluster import KMeans
km = KMeans(n_clusters=NCLUSTERS, n_init=20)
km.fit(dataset)
plt.figure(figsize=(10, 8))
plt.title('K-Means Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[km.labels_ == i, 0], dataset[km.labels_ == i, 1])
plt.show()
from sklearn.cluster import AgglomerativeClustering
ac = AgglomerativeClustering(n_clusters=NCLUSTERS, affinity='euclidean', linkage='ward')
ac.fit(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[ac.labels_ == i, 0], dataset[ac.labels_ == i, 1])
# plt.scatter(centroids[:, 0], centroids[:, 1], 60, color='red', marker='s')
legends = [f'Cluster-{i}' for i in range(1, NCLUSTERS + 1)]
plt.show()
dataset, labels, centers = make_blobs(n_samples=100, n_features=2, centers=3, cluster_std=1, return_centers=True)
plt.figure(figsize=(10, 8))
plt.title('Random Points')
for i in range(NCLUSTERS):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.scatter(centers[:, 0], centers[:, 1], 60, color='red', marker='s')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
sklearn.datasets modülünde make_classification isimli benzer bir fonksiyon da bulunmaktadı ı ı ı
problemleri için rastgele noktalar üretmektedir. Fonksiyonun parametrik yapı ı
sklearn.datasets.make_classification(n_samples=100, n_features=20, *, n_informative=2, n_redundant=2, n_repeated=0,
n_classes=2, n_clusters_per_class=2, weights=None, flip_y=0.01, class_sep=1.0, hypercube=True,
shift=0.0, scale=1.0, shuffle=True, random_state=None)
Fonksiyonun birinci parametresi üretilecek nokta sayı ı ı ı ı ı
parametresi ise üretilecek noktaları ı ı ı ı ı ı
Fonksiyon yine bize ikili bir demet verir. Demetin birinci elemanı ı ı ı ı ı
make_classification fonksiyonu standart normal dağı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_classification
dataset, labels = make_classification(100, 10, n_classes=3)
print(dataset)
print(labels)
#----------------------------------------------------------------------------------------------------------------------------
sklearn.datasets modülü içerisindeki make_circles isimli fonksiyon eliptik tarzda veri üretmek için kullanı ı
Eliptik tarzda veriler birbirlerini çevreleyen tarzda verilerdir. Bunlar özellikle bazı ı ı ı ı
Fonksiyonun parametrik yapı ı
sklearn.datasets.make_circles(n_samples=100, *, shuffle=True, noise=None, random_state=None, factor=0.8)
Fonksiyon her zaman iki sütuna ilişkin nokta üretmektedir. Fonksiyonun birinci parametresi üretileceknoktaları ı ı ı
Default durumda fonksiyon iki sı ı ı ı ı
iki elemanlı ı ı ı
dataset, labels = make_circles((100, 200))
Burada 100 tane 0, 200 tane 1 sı ı ı ı ı ı ı
ayarlamak için kullanı ı ı ı ı ı ı ı ı
biribirinden uazaklaşı ı
Bu parametre 0 ile 1 arası ı ı
kullanı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_circles
dataset, labels = make_circles(100, factor=0.8, noise=0.05)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(2):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Agglomerative hiyerarşik kümelemede sı ı ı
"dendrogram" denilmektedir. scikit-learn kütüphanesinde doğrudan dendrogram çizmek için fonksiyonlar yoktur. Ancak SciPy
kütüphanesinde scipy.cluster.hierarchy modülü içerisinde bunun için linkage ve dendrogram isimli iki fonksiyon bulunmaktadı
Burada ası
matris vermektedir. Fonksiyonun parametrik yapı ı
scipy.cluster.hierarchy.linkage(y, method='single', metric='euclidean', optimal_ordering=False)
Fonksiyon zorunlu olarak yalnı ı ı ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
Burada toplam 12 tane veri vardı ı
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from scipy.cluster.hierarchy import linkage
linkage_data = linkage(dataset)
print(linkage_data)
Şöyel bir matris elde edilmiştir:
[[ 0. 9. 1. 2. ]
[10. 12. 1. 3. ]
[ 2. 4. 1. 2. ]
[ 8. 14. 1. 3. ]
[ 3. 6. 1. 2. ]
[ 1. 7. 1. 2. ]
[13. 15. 1.41421356 6. ]
[16. 17. 1.41421356 4. ]
[11. 19. 1.41421356 5. ]
[ 5. 18. 2. 7. ]
[20. 21. 2.23606798 12. ]]
Matris her zaman toplam nokta sayı ı ı
belirtmektedir. Nokta sayı ı ı ı ı ı
belirtir. Her birleştirmeye N'den başlanarak sı ı ı ı ı
Her birleştirmede sı ı ı ı ı ı
satı ı ı ı ı
ise 10 numaralı ı ı ı
O halde burada önce 0 ile 9 birleştirilmiş bir küme elde edilmiş sonra da bu küme ile 10 birleştirilmiştir. Tabii burada el edilen yeni küme 12
numaralı ı ı ı ı ı ı
Son sütun ise oluşturulan o kümedeki nokta sayı ı ı
Linkage bilgisi elde edildikten sonra dendrogram fonksiyonu ası ı
parametreye sahiptir:
scipy.cluster.hierarchy.dendrogram(Z, p=30, truncate_mode=None, color_threshold=None, get_leaves=True,
orientation='top', labels=None, count_sort=False, distance_sort=False, show_leaf_counts=True, no_plot=False,
no_labels=False, leaf_font_size=None, leaf_rotation=None, leaf_label_func=None, show_contracted=False,
link_color_func=None, ax=None, above_threshold_color='C0')
Burada zorunlu parametre ilk parametre olan linkage bilgileridir. Biz bu ilk parametreye linkage fonksiyonundan elde ettiğimiz
matrisi geçeririz. Fonksiyonun parametreleri için SciPy dokümanları
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from scipy.cluster.hierarchy import linkage, dendrogram
linkage_data = linkage(dataset)
print(linkage_data)
dendrogram(linkage_data, orientation='top')
#----------------------------------------------------------------------------------------------------------------------------
K-Means yöntemiyle Agglomerative Hiyerarşik kümeleme yöntemlerini şöyle karşı ı
- K-Means algoritması ı ı ı ı ı ı
sı ı ı ı ı ı ı
yöntemin SLINK, CLink gibi özelleştirilmiş gerçekleştirimlerinde karmaşı ı
hı ı ı
- K-Means algoritması ı ı ı ı ı ı ı ı
Halbuki Agglomerative kğmelemede her zaman aynı
- K-Means yönteminde her kümenin bir ağı ı ı ı
yöntemde atalet kavramı ı ı
- K-Means yöntemin dendrogram çilemez. Halbuki Agglomerative yöntemde hangi kümenin hangi kümeyle birleştirileceğini belirten bir
dendrogram çizilebilmektedir.
- K-Means yönteminde ağı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı
sı ı ı ı
- K-Means yönteminde küme sayı ı ı ı
aslı ı
için kümeleme tek hamlede yapı ı ı ı
- K-Means ve Agglomerative yöntemin her ikisi de küresel (spherical) olmayan veri kümelerinde başarı ı ı
bir merkez etrafı ı ı ı ı
gibi fonksiyonlar elde ettiğimiz birbirini kapsayan çembersel verilerde bu iki yöntem de başarı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
sayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_circles
dataset, labels = make_circles(100, factor=0.9, noise=0.08)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Random Points')
for i in range(2):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.show()
from sklearn.cluster import KMeans
km = KMeans(n_clusters=2, n_init=20)
km.fit(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('K-Means Clustered Points')
for i in range(2):
plt.scatter(dataset[km.labels_ == i, 0], dataset[km.labels_ == i, 1])
plt.show()
from sklearn.cluster import AgglomerativeClustering
ac = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
ac.fit(dataset)
plt.figure(figsize=(10, 8))
plt.title('Agglomerative Clustered Points')
for i in range(2):
plt.scatter(dataset[ac.labels_ == i, 0], dataset[ac.labels_ == i, 1])
plt.show()
import numpy as np
kmeans_accuracy = np.sum(km.labels_ == labels) / len(labels)
agglomerative_accuracy = np.sum(ac.labels_ == labels) / len(labels)
print(f'K-Means accuracy: {kmeans_accuracy}')
print(f'Agglomerative accuracy: {agglomerative_accuracy}')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kümelede diğer çok kullanı ı
kümeleme yöntemlerinde "yoğunluk (density)" en önemli unsurdur. Bir bölge yoğunsa onun bir küme belirtmesi olası ı
nası ı ı ı
Bu parametrelere "eps (epsilon)" ve "min_samples" denilmektedir. Eps dairesel bölgenin yarı ı ı
bölgenin yoğun kabul edilebilmesi için gerekli olan minimum nokta sayı ı ı ı ı
daire içerisinde en az 10 nokta varsa o daire alanı ı
bir geometrik şekildir. Eğer boyut sayı ı ı ı ı
vardı ı ı ı
benzerdir.
İki boyutlu kartezyen koordinat sisteminde boyutlar x ve y olmak üzere merkezi (a, b) noktası ı ı
(x - a) ** 2 + (y - b) ** 2 = r ** 2
Üç boyutlu uzay için merkez koordinatı ı
(x - a) ** 2 + (y - b) ** 2 + (z - c) ** 2= r ** 2
N boyutlu uzayı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yoğunluk tabanlı ı ı ı ı
Algoritmanı ı ı ı ı ı
Ana Noktalar (Core Points): Eğer bir nokta merkez kabul edildiğinde onun eps yarı ı ı
Bu durumda bir nokta belirlenen eps ve min_samples değerlerine göre ya ana noktadı
Bir Ana Noktadan Doğrudan Erişilebilen Noktalar (Direct Reachable Points): Bir ana noktanı ı
doğrudan erişilen noktaları ı
Ana Bir Noktanı ı ı ı
bir ana noktas ise o ana noktanı ı ı ı
Yani yoğunluk yoluyla erişilebilen noktalar "dostumun dostu dostumdur" gibi geçili olarak devam etmektedir. Bu geçişlilik yoğunluk
yoluyla erişilebilen noktaları ı
Bir Ana Noktanı ı ı ı ı ı ı ı ı ı ı
Sı ı ı ı ı
Gürültü Noktaları ı ı ı
denilmektedir. Gürültü noktaları ı ı
Bu durumda algoritma şöyle işletilir:
1) Önce "Kalan Noktalar Kümesi", "Gürültü Noktaları ı
yerleştirilir. Gürültü Noktaları
2) Kalan Noktalar Kümesinden rastgele bir nokta alı ı ı ı ı
Gürültü Noktaları ı ı ı
elde edilir. Bu noktalar Kalan Noktalar Kümesinden çı ı ı ı ı
girmiş olan bir nokta sonra bir kümeye dahil edilebilmektedir.
3) Yeniden 2. Adı
K tane küme ve bir de Gürültü Noktaları
Algoritmadaki önemli noktalar şunlardı
- Bu algoritmada yoğun bölgeler bir küme olarak elde edilmektedir. Kğmeler arası ı ı ı ı
bir durum söz konusudur. Örneğin kı ı ı ı
- Bu algoritmada biz algoritmaya yalnı ı ı ı ı ı ı
algoritma tarafı
- Bu algoritmada iki hyper parametre vardı ı ı ı ı
- Algortimada yine bir uzaklı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
DBSCAN algoritması ı ı ı ı ı
yapı ı
class sklearn.cluster.DBSCAN(eps=0.5, *, min_samples=5, metric='euclidean', metric_params=None, algorithm='auto', leaf_size=30, p=None, n_jobs=None)
Metodun ilk parametresi yarı ı ı
minimum nokta sayı ı ı ı ı
DBSCAN sı ı ı ı ı ı ı ı ı ı ı
oluşan bilgiler alı ı ı ı ı ı
labels_: Bu öznitelik hangi noktaları ı ı
core_sample_indices_: Ana noktaları ı ı
components_: Ana noktaları
n_features_in_: Veri kümesindeki sütun sayı ı
DBSCAN algoritması ı ı ı
küme sayı ı ı ı ı ı ı ı
o kadar değildir. Ancak genel olarak min_samples 1 olmaması ı ı ı
en normal durumdur. Örneğin iki özellikli (yani kartezyen koordinat sisteminde gösterebileceğimiz) noktalar söz konusu olduğunda bu değerin en az üç
olması ı ı ı ı
min_samples parametresini bwlirleyip daha sonra epsilon parametresiyle oynayarak nihai ayarlamayı
Aşağı ı ı ı ı
7,8
2,4
6,4
3,2
6,5
5,7
3,3
1,4
5,4
7,7
7,6
2,1
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from sklearn.cluster import DBSCAN
dbs = DBSCAN(eps=2, min_samples=3)
dbs.fit(dataset)
nclusters = np.max(dbs.labels_) + 1
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(dataset[dbs.labels_ == i, 0], dataset[dbs.labels_ == i, 1])
plt.scatter(dataset[dbs.labels_ == -1, 0], dataset[dbs.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de zambak veri kümesini DBSCAN algoritması ı ı ı
Bu durumda biz örneğin min_samples parametresini 5'te utarak epsilon değeriyle oynayabiliriz. Aşağı
epsilon=0.42 değerleriyle kümeleme yapı ı ı ı ı ı ı ı
işaretlenmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
import numpy as np
from sklearn.cluster import DBSCAN
dbs = DBSCAN(eps=0.42, min_samples=5)
dbs.fit(dataset)
nclusters = np.max(dbs.labels_) + 1
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(decomposed_dataset[dbs.labels_ == i, 0], decomposed_dataset[dbs.labels_ == i, 1])
plt.scatter(decomposed_dataset[dbs.labels_ == -1, 0], decomposed_dataset[dbs.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends, loc='lower right')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Bir merkez etrafı ı
hiyerarşik kümeleme yöntemlerinin iyi çalı ı ı ı
iç ve dı
Aşağı
ile kümelendirilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_circles
dataset, labels = make_circles(100, factor=0.5, noise=0.02)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Random Points')
for i in range(2):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.show()
import numpy as np
from sklearn.cluster import DBSCAN
dbs = DBSCAN(eps=0.3, min_samples=3)
dbs.fit(dataset)
nclusters = np.max(dbs.labels_) + 1
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(dataset[dbs.labels_ == i, 0], dataset[dbs.labels_ == i, 1])
plt.scatter(dataset[dbs.labels_ == -1, 0], dataset[dbs.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir yoğunluk tabanlı ı ı ı ı ı ı
bir uzantı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı
min_samples değerini belirler. Epsilon değerini belirlemez. Algoritma değişik epsilon değerleri çin bir yoğun grafiği oluşturmaktadı
Algoritmada iki önemli kavram vardı
Ana Uzaklı ı ı ı ı
minimum epsilon değerini belirtir. Bir noktayı ı ı ı
kadar noktanı ı ı ı ı ı ı ı ı
Erişilebilir Uzaklı ı ı ı ı ı ı ı
İşte erişilebilir uzaklı ı ı ı ı ı ı ı ı ı
biçimindedir.
Algoritma her noktanı ı ı ı ı ı ı
çok nokta olabildiği halde epsilon=5 ile epsilon=8 arası
yoğunlukları ı
OPTICS algoritması ı ı
Sı ı ı ı ı
class sklearn.cluster.OPTICS(*, min_samples=5, max_eps=inf, metric='minkowski', p=2, metric_params=None,
cluster_method='xi', eps=None, xi=0.05, predecessor_correction=True, min_cluster_size=None,
algorithm='auto', leaf_size=30, memory=None, n_jobs=None)
Metotta bir epsilon parametre yoktur. Yalnı ı ı
Bu parametre ana uzaklı ı ı ı
erişim uzaklı ı ı ı ı ı ı
Aşağı ı ı ı ı
değerini vermekteyiz. Algoritma bu örnekte iki küme oluşturmuştur. Hiçbir noktayı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
from sklearn.cluster import OPTICS
optics = OPTICS(min_samples=3)
optics.fit(dataset)
nclusters = np.max(optics.labels_) + 1
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(dataset[optics.labels_ == i, 0], dataset[optics.labels_ == i, 1])
plt.scatter(dataset[optics.labels_ == -1, 0], dataset[optics.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
Bu 6 kümenin dı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
import numpy as np
from sklearn.cluster import OPTICS
optics = OPTICS(min_samples=5)
optics.fit(dataset)
nclusters = np.max(optics.labels_) + 1
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(decomposed_dataset[optics.labels_ == i, 0], decomposed_dataset[optics.labels_ == i, 1])
plt.scatter(decomposed_dataset[optics.labels_ == -1, 0], decomposed_dataset[optics.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends, loc='lower right')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
iç ve dı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_circles
dataset, labels = make_circles(1000, factor=0.5, noise=0.02)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Random Points')
for i in range(2):
plt.scatter(dataset[labels == i, 0], dataset[labels == i, 1])
plt.show()
import numpy as np
from sklearn.cluster import OPTICS
optics = OPTICS(min_samples=40)
optics.fit(dataset)
nclusters = np.max(optics.labels_) + 1
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(dataset[optics.labels_ == i, 0], dataset[optics.labels_ == i, 1])
plt.scatter(dataset[optics.labels_ == -1, 0], dataset[optics.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Yoğunluk tabanlı ı ı ı ı ı
- OPTICS algoritması ı ı
faydalanı ı
- OPTICS algoritması ı ı ı
oluşturulmaktadı
- OPTICS algoritması ı ı ı
Bu nedenle OPTICS algortiması ı
- DBSCAN algortiması ı ı ı ı
sağlanabilmektedir.
- Hem DBSCAN hem de OPTICS algoritmaları
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biz giriş derslerinde "varyans" kavramı ı ı ı
varyans terimi çok kullanı ı ı ı ı ı ı
olduğu halde bunlar için iki farklı ı
Standart sapma ve varyans değerlerin ortalama etrafı ı
standart sapması ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kovaryans (covariance) iki olgunun birlikte değişimi ya da doğrusallı ı
Örneğin bu olgular x ve yolsun. Eğer x artarken tutarlı ı ı ı
değişkenin kovaryasnları ı
azalı ı ı ı
bu iki değişken arası ı
Kovaryans için değişken arası ı
import numpy as np
def cov(x, y):
return np.sum((x - np.mean(x)) * (y - np.mean(y))) / len(x)
NumPy kütüphanesindeki cov fonksiyonu iki boyutlu NumPy dizileriyle ya da tek boyutlu Numpy dizileriyle çalı
cov fonksiyonu bize bir kovaryans matrisi verir. Yani her değişkenin her değişkenle kovaryasları
Tabii bu matris simetrik bir matrisir. Default durumda cov fonksiyonu n - 1'değerine bölme yapmaktadı
yaptı ı ı ı ı ı ı
Çünkü cov(x, x) zaten var(x) anlamı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def cov(x, y):
return np.sum((x - np.mean(x)) * (y - np.mean(y))) / len(x)
x = np.array([1, 2, 3, 4, 5])
y = np.array([3, 6, 8, 10, 12])
result = cov(x, y)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Değişkenlerin arası ı
negatif bir kovaryans oluşturmaktadı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def cov(x, y):
return np.sum((x - np.mean(x)) * (y - np.mean(y))) / len(x)
x = np.array([1, 2, 3, 4, 5])
y = np.array([3, 5, 8, 9, 12])
result = cov(x, y)
print(result)
result = np.cov(x, y, ddof=0)
print(result)
import matplotlib.pyplot as plt
plt.title('Covariance')
plt.plot(x, y, marker='o')
plt.show
#----------------------------------------------------------------------------------------------------------------------------
n tane değişkenin birbirlerine göre kovaryansları ı
aslı
Default durumda cov fonksiyonu satı ı ı ı ı ı ı
değişkenimiz olsun:
a = np.array([1, 2, 3, 4, 5])
b = np.array([2, 6, 1, 7, 4])
c = np.array([30, 23, 45, 16, 12])
Biz bu üç değişkenin birbirlerine göre kovaryansları ı
>>> a = np.array([1, 2, 3, 4, 5])
>>> b = np.array([2, 6, 1, 7, 4])
>>> c = np.array([30, 23, 45, 16, 12])
>>> np.cov([a, b, c], ddof=0)
array([[ 2. , 1. , -8.6 ],
[ 1. , 5.2 , -20.2 ],
[ -8.6 , -20.2 , 135.76]])
Aynı ı
>>> a = np.array([[1, 2, 3, 4, 5], [2, 6, 1, 7, 4], [30, 23, 45, 16, 12]])
>>> np.cov(a, ddof=0)
array([[ 2. , 1. , -8.6 ],
[ 1. , 5.2 , -20.2 ],
[ -8.6 , -20.2 , 135.76]])
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kovaryans iki değişkenin birlikte değişimi hakkı ı ı
zordur. Yani başka bir deyişle x ile y arası ı ı ı ı ı ı
standardize edilmiş haline "korelasyon katsayı ı ı ı
Ancak en çok kullanı ı ı ı
değişkenin kovaryansları ı ı ı ı ı
Pearson korelasyon katsayı ı ı
aralı ı ı ı ı ı ı
korelasyo katsayı ı ı ı
diğeri azalı ı ı
ilişki doğrusal olmaya yaklaşmaktadı ı ı
korelasyon katsayı ı ı
Özellikle sosyal bilimlerde ve sağlı ı ı
bakmaktadı ı ı ı
İki değişken arası
0-0.2 ise çok zayı
0.2-0.4 arası ı
0.4-0.6 arası
0.6-0.8 arası
0.8–
İki olgu arası ı ı ı ı
İki olgu arası ı ı ı
vakaları ı ı ı
çı ı
Pearson korelasyon katsayı ı
gibi kullanı ı
>>> a = np.array([1, 2, 3, 4, 5])
>>> b = np.array([2, 6, 1, 7, 4])
>>> c = np.array([30, 23, 45, 16, 12])
>>> np.corrcoef([a, b, c])
array([[ 1. , 0.31008684, -0.52191231],
[ 0.31008684, 1. , -0.76026287],
[-0.52191231, -0.76026287, 1. ]])
Buradaki matrisin yine simetrik olduğuna dikkat ediniz. Köşegen elemanları ı ı ı ı
kaynaklanmaktadı ı ı ı ı ı
bölme işlemi dikkatle incelenirse n-1 ya da n'e bölümün aslı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Veri biliminde ve makine öğrenmesinde veri kümesinde çok fazla sütun (yani özellik) bulunması ı ı ı ı
Çok fazla sütun çok fazla işlem anlamı ı ı ı ı
bellek kullanı ı ı ı
Ancak veri kümesinde çok fazla sütunun buluması ı ı ı
artı ı ı ı ı
O halde çok fazla sütunun daha az sütuna indirgenmesi önemli önişlem faaliyetlerinden biridir. Buna "boyutsal özellik indirgemesi (dimentionality
feature reduction)" denilmektedir. Boyutsal özellik indirgemesi çeşitli Auto ML araçları ı ı
Tabii bunun için verilerin iti bir biçimde analiz edilmesi gerekir.
Boyutsal özellik indirgemesi n tane sütundan k < n koşulunu sağlayan k tane sütunun elde edilmesi sürecidir. Bu süreç iki alt gruba
ayrı ı
1) n tane sütundan bazı ı ı ı
2) n tane sütundan onu temsil eden (ancak bu n tane sütunun hiçbirini içermeyen) k tane sütun elde etmeye çalı
Biz de burada belli başlı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Eksik Değerli Sütunları ı ı
veri kümesinden çı ı ı ı ı
atı ı ı ı ı
bu sütunları ı ı
Düşük Varyans Filtrelemesi (Low Variance Filtering): Bir sütunun varyansı ı
Örneğin veri kümesinde hep aynı
Tabii ki hayı ı ı ı ı ı
biri de az bilgiye sahip olan sütunları ı ı
sütunları ı ı ı ı
m tane sütunu atmak yerine belli bir eşik değeri belirlenip o eşik değerinin aşağı ı ı
sütunlardaki skala farklı ı ı ı ı ı ı ı ı ı
aynı ı
Aşağı ı
bu veri kümesi 8 sütuna indirgenmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(dataset_x)
scaled_dataset_x = mms.transform(dataset_x)
import numpy as np
feature_vars = np.var(scaled_dataset_x, axis=0)
sorted_arg_vars = np.argsort(feature_vars)
reduced_dataset_x = np.delete(dataset_x, sorted_arg_vars[:5], axis=1)
print(reduced_dataset_x)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
sütuna indirgenmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset_x = df.iloc[:, 1:-1].to_numpy(dtype='float32')
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(dataset_x)
scaled_dataset_x = mms.transform(dataset_x)
import numpy as np
feature_vars = np.var(scaled_dataset_x, axis=0)
sorted_arg_vars = np.argsort(feature_vars)
reduced_dataset_x = np.delete(dataset_x, sorted_arg_vars[:1], axis=1)
print(reduced_dataset_x)
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn içerisinde sklearn.feature_selection modülünde VarianceThreshold isimli bir sı ı ı ı ı
eşik değerinden küçük olan sütunları ı ı ı ı ı ı ı ı ı ı ı ı
Nesne yaratı ı ı
sı ı ı ı
Aşağı ı ı ı ı
ile düşük varyans filtrelemesi yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(dataset_x)
scaled_dataset_x = mms.transform(dataset_x)
from sklearn.feature_selection import VarianceThreshold
vt = VarianceThreshold(0.04)
reduced_dataset_x = vt.fit_transform(scaled_dataset_x)
print(reduced_dataset_x.shape)
#----------------------------------------------------------------------------------------------------------------------------
Yüksek Korelasyon Filtrelemesi Yöntemi (High Correlation Filtering): İki sütun söz konusu olsun. Biri diğerinin iki katı
sahip olsun. Bu iki sütunun bir arada bulunması ı ı ı ı
İşte birden fazla sütun birbirleriyle yüksek derecede korelasyon içeriyorsa bu sütunları ı
atı
Yüksek korelasyon filtrelemesi manuel bir biçimde yapı ı ı ı ı
Dolayı ı ı ı ı ı ı
yüksek korelasyonu olan sütunları ı ı
standardize edilmiş bir değer vermektedir. Tabii yüksek korelasyon filtrelemesi yapı ı ı ı
Pozitif yüksek korelasyon da negatif yüksek korelasyon da neticede aynı ı
Yüksek korelasyon filtrelemesini yapmak biraz daha zahmetlidir. Çünkü korelasyon matrisi büyük olabilir. Bizim de bu büyük matrisi
incelememiz gerekebilir. Ayrı ı ı
bizim iki sütunuzmuzun korelasyonları ı
başka ölçütleri de göz önüne alabilir. Örneğin düşük varyansa sahip olanı
da atmak isteyebilir.
Yüksek korelasyonlu sütunları ı
Heapmap grafikleri matplotlib içerisinde yoktur Ancak seaborn kütüphanesinde bulunmaktadı
konfigüre edilebilmektedir) yüksek değerler açı ı ı
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
import numpy as np
feature_corrs = np.abs(np.corrcoef(dataset_x, rowvar=False))
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 9))
sns.heatmap(data=feature_corrs, annot=True)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Korelasyon matrisinde yüksek olan satı ı ı
nokta korelasyon matrisinin simetrik olması ı ı ı ı ı ı ı
yüksek korelasyonlu sütunları ı
#----------------------------------------------------------------------------------------------------------------------------
CORR_THRESHOLD = 0.75
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
import numpy as np
feature_corrs = np.abs(np.corrcoef(dataset_x, rowvar=False))
eliminated_features = []
for i in range(feature_corrs.shape[0]):
for k in range(feature_corrs.shape[1]):
if i != k and i not in eliminated_features and feature_corrs[i, k] > CORR_THRESHOLD:
eliminated_features.append(i)
print(eliminated_features)
reduced_dataset_x = np.delete(dataset_x, eliminated_features, axis=1)
print(reduced_dataset_x.shape)
#----------------------------------------------------------------------------------------------------------------------------
En çok kullanı
yöntemdir. Bu yötemde orijinal n tane sütuna sahip olan veri kümesi k < n olmak üzere k tane sütuna indirgenmektedir. Ancak
bu yöntemde elde edilen k sütunlu veri kümesinin sütunları ı ı
kümesini temsil eden tamamen farklı ı ı ı
n boyutlu uzaydaki noktalar dönüştürülerek en yüksek varyans sağlanacak biçimde k < n boyutlu uzaydaki noktalara dönüştürülmektedir.
Şüphesiz n tane özelliğe sahip olan veri kümesini k tane özelliğe indirgediğimiz zaman orijinal veri kümesinin temsili zayı ı
Ancak bu yöntem bu veri kümesindeki zayı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Temel bileşenler analizi sklearn.decomposition modülü içerisindeki PCA isimli sı ı ı ı ı ı ı
scikit-learn sı ı ı ı ı ı ı ı ı ı ı
metotları ı ı ı ı ı ı ı
class sklearn.decomposition.PCA(n_components=None, *, copy=True, whiten=False,
svd_solver='auto', tol=0.0, iterated_power='auto', n_oversamples=10, power_iteration_normalizer='auto', random_state=None)
Burada zorunlu olan ilk parametre indirgenme sonucunda elde edilecek sütun sayı ı ı ı ı
önce fit işlemi yapı ı ı ı
yapı ı ı
Eğer veri kümesinin sütunları ı ı ı ı
PCA işlemi için en uygun özellik ölçeklemesi yöntemi "standart ölçekleme" yani StandardScaler sı ı ı
Ancak MinMAx ölçeklemesi de kullanı
Aşağı ı ı ı ı
bu 13 sütunu 10'a indirdik.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
from sklearn.decomposition import PCA
pca = PCA(10)
pca.fit(scaled_dataset_x)
reduced_dataset_x = pca.transform(scaled_dataset_x)
print(dataset_x.shape)
print(reduced_dataset_x.shape)
#----------------------------------------------------------------------------------------------------------------------------
Şüphesiz PCA işleminde bir biçimde "pedict" yapı ı ı ı ı
getirmek gerekir. Yukarı ı
edilen veri kümesini kullanacağı ı
Tabii predict veri kümsi eitimde kullanı
Aşağı ı ı ı
Daha sonra normalize edilmiş veri kğmesi PCA işlemine sokularak 10 sütuna indirgenmiştir. Daha sonra da yapay sinir ağı
eğitim, test ve kestirim işlemleri yapı ı ı ı ı
Bu örnek yalnı ı ı ı ı ı ı ı ı ı
Veri kümesinin birtakı ı ı ı ı ı
peşi sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.decomposition import PCA
pca = PCA(10)
pca.fit(scaled_training_dataset_x)
reduced_training_dataset_x = pca.transform(scaled_training_dataset_x)
reduced_test_dataset_x = pca.transform(scaled_test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Boston-Housing-Price')
model.add(Dense(64, activation='relu', input_dim=reduced_training_dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(reduced_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(reduced_test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
import numpy as np
predict_data = np.array([[0.11747, 12.50, 7.870, 0, 0.5240, 6.0090, 82.90, 6.2267, 5, 311.0, 15.20, 396.90, 13.27]])
scaled_predict_data = ss.transform(predict_data)
reduced_predict_data = pca.transform(scaled_predict_data)
predict_result = model.predict(reduced_predict_data)
for val in predict_result[:, 0]:
print(val)
model.save('boston.h5')
import pickle
with open('boston.pickle', 'wb') as f:
pickle.dump(ss, f)
pickle.dump(pca, f)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi biz n tane sütuna sahip olan bir veri kümesini kaç sütuna indirgemeliyiz? Bu indirgenecek sütun sayı ı ı ı
Öncelikle PCA işleminin matematiksel temelinde "açı ı
edilen her sütun için "açı ı ı ı ı
ası ı ı ı ı
tüm veri kümesindeki bilgilerin yüzde 40'ı ı ı ı ı ı ı
indirgenmiş olan veri kümesinin ası ı ı ı
Programı ı ı ı ı ı ı
1 ---> 0.471296101808548
2 ---> 0.5815482139587402
3 ---> 0.6771341562271118
4 ---> 0.7431014180183411
5 ---> 0.8073177337646484
6 ---> 0.8578882217407227
7 ---> 0.89906907081604
8 ---> 0.929538369178772
9 ---> 0.9508417248725891
10 ---> 0.9677831530570984
11 ---> 0.9820914268493652
12 ---> 0.9951147437095642
13 ---> 1.0000001192092896
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
import numpy as np
from sklearn.decomposition import PCA
for i in range(1, dataset_x.shape[1] + 1):
pca = PCA(i)
pca.fit(scaled_dataset_x)
total_ratio = np.sum(pca.explained_variance_ratio_)
print(f'{i} ---> {total_ratio}')
#----------------------------------------------------------------------------------------------------------------------------
O halde PCA işleminde indirgenecek sütun sayı ı ı ı ı ı
yöntemde uygulamacı ı ı ı ı ı ı ı ı ı ı
İkinci yöntemde uygulamacı ı ı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TARGET_RATIO = 0.7
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
import numpy as np
from sklearn.decomposition import PCA
for i in range(1, dataset_x.shape[1] + 1):
pca = PCA(i)
pca.fit(scaled_dataset_x)
total_ratio = np.sum(pca.explained_variance_ratio_)
if total_ratio >= TARGET_RATIO:
break
print(f'Number of features: {i}')
#----------------------------------------------------------------------------------------------------------------------------
İkinci yöntemde uygulamacı ı ı ı ı ı ı
düşey eksende açı ı
doğru hareket etmektedir. İşte eğrinin yatay seyire geçtiği bokta gözle tesipt edilir.
Aşağı ı ı
Dolayı ı ı ı ı
uygun olduğu görülmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
import numpy as np
from sklearn.decomposition import PCA
total_ratios = []
for i in range(1, dataset_x.shape[1] + 1):
pca = PCA(i)
pca.fit(scaled_dataset_x)
total_ratio = np.sum(pca.explained_variance_ratio_)
total_ratios.append(total_ratio)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 8))
plt.title('Optimal number of Featured')
plt.plot(range(1, dataset_x.shape[1] + 1), total_ratios, color='red')
plt.plot(range(1, dataset_x.shape[1] + 1), total_ratios, 'bo', color='blue')
plt.legend(['Total explained variance ratio'])
plt.xlabel('Nuber of Features')
plt.ylabel('Ratio')
plt.xticks(range(1, dataset_x.shape[1] + 1))
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de MNIST örneğinde (784 özellik) toplam açı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import mnist
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = mnist.load_data()
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
for i in range(9):
plt.subplot(3, 3, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=14)
plt.imshow(training_dataset_x[i], cmap='gray')
plt.show()
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
scaled_training_dataset_x = training_dataset_x.reshape(-1, 784) / 255
scaled_test_dataset_x = test_dataset_x.reshape(-1, 784) / 255
import numpy as np
from sklearn.decomposition import PCA
total_ratios = []
for i in range(1, 300):
pca = PCA(i)
pca.fit(scaled_training_dataset_x)
total_ratio = np.sum(pca.explained_variance_ratio_)
total_ratios.append(total_ratio)
print(i, end=' ')
import pickle
with open('mnist.pickle', 'wb') as f:
pickle.dump(total_ratios, f)
import matplotlib.pyplot as plt
plt.figure(figsize=(30, 8))
plt.title('Optimal number of Featured')
plt.plot(range(1, 300), total_ratios, color='red')
plt.plot(range(1, 300), total_ratios, 'bo', color='blue')
plt.legend(['Total explained variance ratio'])
plt.xlabel('Nuber of Features')
plt.ylabel('Ratio')
plt.xticks(range(1, 300, 10))
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
PCA işleminin diğer bir kullanı ı ı ı ı
Biz de zaten daha önceki örneklerimizde zambak veri kümesini kümeledikten sonra bu yöntemle grafiğini çizmiştik.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anomalilerin tespit edilmesi (anomaly detection) makine öğrenmesinin popüler konuları
olabilir. Burada bazı ı ı ı ı ı
isteyebiliriz. İngilizce "anomalarin tespit edilmesi (anomaly detection)" terimi yerine "outliers", "novelties", "noise", "deviations", "exceptions"
gibi terimler de kullanı
Anomalilerin tespit edilmesi pek çok alanda kullanı
tespit edilmeye çalı ı ı ı ı
anomalilerin otomatik tespiti gibi pek çok faydalı ı
öğrenme yöntemleriyle yapı ı ı ı
Elimizde anamolai içeren ve içermeyen bilgiler varsa biz eğitimli yöntemlerle kestirim yapabiliriz. Ancak genellikle bu tür durumlarda
elimizde yeteri kadar anomali içeren veri bulunmaz. Bu nedenle bu konuda daha çok "denetimsiz öğrenme yöntemleri" kullanı ı
Anomalalierin tespit edilmesi için pek çok yöntemden faydalanı
- Yoğunluk Tabanlı
- Destek Vektör Makineleri (Support Vector Machines)
- Bayes Ağları
- Saklı
- Kümeleme Esası
- Bulanı ı ı
- Boyutsal Özellik İndirgemesi ve Yükseltmesi Esası
Biz burada "kümeleme esası ı
üzerinde duracağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
anomali içeren noktalar tespit edilmiştir. Aşağı ı
anomalileri tespit ediniz.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
import numpy as np
from sklearn.cluster import DBSCAN
dbs = DBSCAN(eps=0.65, min_samples=5)
dbs.fit(dataset)
nclusters = np.max(dbs.labels_) + 1
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(decomposed_dataset[dbs.labels_ == i, 0], decomposed_dataset[dbs.labels_ == i, 1])
plt.scatter(decomposed_dataset[dbs.labels_ == -1, 0], decomposed_dataset[dbs.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends, loc='lower right')
plt.show()
anomaly_data = dataset[dbs.labels_ == -1]
print(f'Number of points with anomly: {len(anomaly_data)}')
#----------------------------------------------------------------------------------------------------------------------------
OPTICS kümeleme algoritması ı ı ı ı
değerini veriyorduk. Bu durumda min_samples değeri değiştirilerek gürültü noktaları ı ı ı ı ı ı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
import numpy as np
from sklearn.cluster import OPTICS
optics = OPTICS(min_samples=5 )
optics.fit(dataset)
nclusters = np.max(optics.labels_) + 1
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(decomposed_dataset[optics.labels_ == i, 0], decomposed_dataset[optics.labels_ == i, 1])
plt.scatter(decomposed_dataset[optics.labels_ == -1, 0], decomposed_dataset[optics.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends, loc='lower right')
plt.show()
anomaly_data = dataset[optics.labels_ == -1]
print(f'Number of points with anomly: {len(anomaly_data)}')
#----------------------------------------------------------------------------------------------------------------------------
Anomalilerin tespit edilmesi için KMeans kümeleme yöntemi de kullanı ı ı
oluşturacak biçimde belirleriz. Böylece noktaları ı ı ı ı ı
çalı ı ı ı ı ı ı ı ı ı
bulabiliriz. Aşağı ı ı ı
K-Means yöntemi ile anomali tespiti zayı
sonuç vermektedir.
#----------------------------------------------------------------------------------------------------------------------------
NANOMALY_POINTS = 5
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
import numpy as np
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=1)
distances = kmeans.fit_transform(scaled_dataset)
arg_sorted_distances = np.argsort(distances[:, 0])
anomaly_points = dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
print(anomaly_points)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
decomposed_normal_points = decomposed_dataset[arg_sorted_distances[:-NANOMALY_POINTS]]
decomposed_anomaly_points = decomposed_dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('K-Means Anomaly Detection')
plt.scatter(decomposed_normal_points[:, 0], decomposed_normal_points[:, 1], color='blue')
plt.scatter(decomposed_anomaly_points[:, 0], decomposed_anomaly_points[:, 1], color='red')
plt.legend(['Normal Points', 'Anomaly Points'])
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de biraz daha gerçekçi bir örnek üzerinde çalı ı ı
toplanmı ı ı ı
Bu sütun veri kümesinden atı
işlem anomali içermemektedir, "1" ise içermektedir. Veri kümesindeki toplam satı ı ı ı ı
anomali içermektedir. Veri kümesi aşağı ı
https://www.kaggle.com/datasets/mlg-ulb/creditcardfraud?resource=download
Veri kümesi üzerinde PCA işlemi uygulanmı ı ı ı ı ı ı
örnekte özellik ölçeklemesi yapmayacağı
Aşağı ı
nokta anomali olarak tespit edilmiştir. DBSCAN parametreleriyle oynayarak anomali miktarı ı
Buradaki kredi kart verilerini sayı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('creditcard.csv', dtype='float32')
dataset = df.iloc[:100000, 1:-1].to_numpy()
dataset_y = df.iloc[:100000, -1].to_numpy()
import numpy as np
from sklearn.cluster import DBSCAN
dbs = DBSCAN(eps=10, min_samples=5)
dbs.fit(dataset)
nclusters = np.max(dbs.labels_) + 1
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Clustered Points')
for i in range(nclusters):
plt.scatter(decomposed_dataset[dbs.labels_ == i, 0], decomposed_dataset[dbs.labels_ == i, 1])
plt.scatter(decomposed_dataset[dbs.labels_ == -1, 0], decomposed_dataset[dbs.labels_ == -1, 1], marker='x', color='black')
legends = [f'Cluster-{i}' for i in range(1, nclusters + 1)]
legends.append('Noise Points')
plt.legend(legends, loc='lower right')
plt.show()
anomaly_data = dataset[dbs.labels_ == -1]
print(f'Number of points with anomly: {len(anomaly_data)}')
original_anomaly_indices = np.where(dataset_y == 1)
dbscan_anomaly_indices = np.where(dbs.labels_ == -1)
intersect_anomalies = np.intersect1d(original_anomaly_indices, dbscan_anomaly_indices)
success_ratio = len(intersect_anomalies) / (dataset_y == 1).sum()
print(f'Success ratio: {success_ratio}') # %26
#----------------------------------------------------------------------------------------------------------------------------
K-Means yöntemi ile kredi kart verileri üzerinde anomali tespiti de aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
NANOMALY_POINTS = 2000
import pandas as pd
df = pd.read_csv('creditcard.csv', dtype='float32')
dataset = df.iloc[:, 1:-1].to_numpy()
dataset_y = df['Class'].to_numpy()
import numpy as np
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=1)
distances = kmeans.fit_transform(dataset)
arg_sorted_distances = np.argsort(distances[:, 0])
anomaly_points = dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
print(anomaly_points)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
decomposed_normal_points = decomposed_dataset[arg_sorted_distances[:-NANOMALY_POINTS]]
decomposed_anomaly_points = decomposed_dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('K-Means Anomaly Detection')
plt.scatter(decomposed_normal_points[:, 0], decomposed_normal_points[:, 1], color='blue')
plt.scatter(decomposed_anomaly_points[:, 0], decomposed_anomaly_points[:, 1], color='red')
plt.legend(['Normal Points', 'Anomaly Points'])
plt.show()
original_anomaly_indices = np.where(dataset_y == 1)
kmeans_anomaly_indices = arg_sorted_distances[-NANOMALY_POINTS:]
intersect_anomalies = np.intersect1d(original_anomaly_indices, kmeans_anomaly_indices)
print(len(intersect_anomalies))
#----------------------------------------------------------------------------------------------------------------------------
Özellik indirgemesi ve yükseltmesi yoluyla anomali tespiti yapı
PCA işlemi ile k < n olmak üzere k tane sütuna indirgenir. Sonra yeniden bu noktalar n tane sütuna yükseltilir. Bu işlemler sonucunda
orijinal noktalarla indirgenip yükseltilmiş noktalar arası ı ı ı ı
Pekiyi bu yöntemde özellikleri kaça kadar düşürmeliyiz? Aslı ı ı ı ı
aşağı ı
Aşağı
yükselitlmiş noktalar arası ı ı
#----------------------------------------------------------------------------------------------------------------------------
NANOMALY_POINTS = 20
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_dataset = mms.fit_transform(dataset)
from sklearn.decomposition import PCA
pca = PCA(n_components=1)
decomposed_dataset = pca.fit_transform(scaled_dataset)
inverse_transformed_dataset = pca.inverse_transform(decomposed_dataset)
import numpy as np
distances = np.sqrt(np.sum((scaled_dataset - inverse_transformed_dataset) ** 2, axis=1))
arg_sorted_distances = np.argsort(distances)
anomaly_indices = arg_sorted_distances[-NANOMALY_POINTS:]
anomaly_points = dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
print(anomaly_points)
from sklearn.decomposition import PCA
pca_graph = PCA(n_components=2)
decomposed_dataset = pca_graph.fit_transform(dataset)
decomposed_normal_points = decomposed_dataset[arg_sorted_distances[:-NANOMALY_POINTS]]
decomposed_anomaly_points = decomposed_dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('K-Means Anomaly Detection')
plt.scatter(decomposed_normal_points[:, 0], decomposed_normal_points[:, 1], color='blue')
plt.scatter(decomposed_anomaly_points[:, 0], decomposed_anomaly_points[:, 1], color='red')
plt.legend(['Normal Points', 'Anomaly Points'])
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
1000 tane anomali noktası ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
NANOMALY_POINTS = 1000
import pandas as pd
df = pd.read_csv('creditcard.csv', dtype='float32')
dataset = df.iloc[:, 1:-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.decomposition import PCA
pca = PCA(n_components=10)
decomposed_dataset = pca.fit_transform(dataset)
inverse_transformed_dataset = pca.inverse_transform(decomposed_dataset)
import numpy as np
distances = np.sqrt(np.sum((dataset - inverse_transformed_dataset) ** 2, axis=1))
arg_sorted_distances = np.argsort(distances)
anomaly_indices = arg_sorted_distances[-NANOMALY_POINTS:]
anomaly_points = dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
print(anomaly_points)
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
decomposed_dataset = pca.fit_transform(dataset)
decomposed_normal_points = decomposed_dataset[arg_sorted_distances[:-NANOMALY_POINTS]]
decomposed_anomaly_points = decomposed_dataset[arg_sorted_distances[-NANOMALY_POINTS:]]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('K-Means Anomaly Detection')
plt.scatter(decomposed_normal_points[:, 0], decomposed_normal_points[:, 1], color='blue')
plt.scatter(decomposed_anomaly_points[:, 0], decomposed_anomaly_points[:, 1], color='red')
plt.legend(['Normal Points', 'Anomaly Points'])
plt.show()
original_anomaly_indices = np.where(dataset_y == 1)
pca_anomaly_indices = arg_sorted_distances[-NANOMALY_POINTS:]
intersect_anomalies = np.intersect1d(original_anomaly_indices, pca_anomaly_indices)
success_ratio = len(intersect_anomalies) / (dataset_y == 1).sum()
print(f'Success ratio: {success_ratio}')
#----------------------------------------------------------------------------------------------------------------------------
İstatistiksel sı ı ı ı ı ı
bazı ı ı ı ı ı ı ı ı
Naive Bayes yömntemi grup olarak "denetimli (supervised)" bir yöntemdir. Yöntemin temeli ünlü olası ı ı ı
"Bayes kuralı ı ı ı ı ı
İstatistikte koşiullu olası ı ı ı ı ı ı ı ı ı
Koşullu olası ı ı ı ı ı ı ı
Yani buradaki olası ı
P(A|B) olası ı ı ı ı ı ı ı ı ı
P(A|B) = P(A, B) / P(B)
Burada P(A, B) P(A kesişim B) ile aynı ı ı ı ı ı
P(A, B) = P(A|B) / P(B)
Şimdi de P(B|A) olası ı ı ı ı
p(B|A) = P(A, B) / P(A)
Buradan da P(A, B) olası ı ı ı
P(A, B) = p(B|A) / P(A)
İki eşitliğin sol tarafı ı
P(A|B) * P(B) = P(B|A) * P(B)
O halde aşağı
P(A|B) = P(B|A) * P(A) / P(B)
P(B|A) = P(A|B) * P(B) / P(A)
Bu eşitliklere "Bayes Kuralı
Olası ı ı ı ı ı ı ı ı
biçimindedir. Örneğin:
"Bir şirket çalı ı ı ı ı
sigara içtiği biliniyor. Buna göre şirketteki sigara odası ı ı ı ı ı
Bu soruda bize verilenler şunlardı
P(sigara içiyor|üniversite mezunu) = 6 / 46
P(sigara içiyor|üniversite mezunu değil) = 22 / 54
Bizden istenen de şudur:
P(üniversite mezunu|sigara içiyor)
Bayes formülünde bunları ı
P(üniversite mezunu|sigara içiyor)= P(sigare içiyor|üniversite mezunu) * P(üniversite mezunu) / P(sigara içiyor)
P(üniversite mezunu|sigara içiyor) = (6 / 46) * (46 / 100)) / (28 / 100)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir olayı ı ı ı ı ı ı ı ı
"istatistiksel bağı ı ı ı ı
olayları ı ı ı ı ı ı ı
Bir olay oluşsa da olmamı ı ı ı ı ı ı ı ı ı ı
P(A|B) koşuluu olası ı ı ı ı ı ı ı
A'nı ı ı ı ı
P(A, B) = P(A|B) * P(B) olduğuna göre A ve B istatistiksel olarak bağı ı
P(A, B) = P(A) * P(B)
Buna olası ı ı ı ı ı ı ı ı ı ı
olası ı ı ı ı ı ı ı ı
Ancak doğada pek çok olay istatistiksel olarak bağı ı ı ı ı ı
Örneğin bir kişinin kalp hastası ı ı ı ı ı ı
yatkı ı ı ı ı
İkiden fazla sitatistiksel olarak bağı ı ı ı ı
P(A, B, C, D, E) = P(A) * P(B) * P(C) * P(D) * P(E)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Elimizde kategorik değerlern oluşan x1, x2, x3, ..., xn sütunları ı
kategoriden oluşan bir Y sı ı ı ı ı
olduğunu koşullu olası ı ı ı ı ı ı
bunları ı ı ı
P(Yk|x1, x2, x3, ..., xn) = P(x1, x2, x3, ..., xn|Yk) * P(Yk) / P(x1, x2, x3, ..., xn)
Burada naive bir varsayı ı ı ı ı ı ı
elde ederiz. (Bu varsayı ı ı
P(Yk|x1, x2, x3, ..., xn) = (P(x1|Yk) * (x2|Yk) * P(x3|Yk) * ... * P(xn|Yk) * P(Yk)) / (P(x1) * P(x2) * P(x3) * ... * P(xn))
Burada Yk demekle Y'nin ayrı ı ı ı ı
olası ı ı ı ı ı ı ı ı ı
argmax (k = 1, ..., m) = P(x1|Yk) * (x2|Yk) * P(x3|Yk) * ... * P(xn|Yk)
Buerada eşitliğin sağ tarafı ı ı ı
bağı ı ı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı
bir sı ı ı ı
Genellikle sütunları ı ı ı ı ı
başvurulabimektedir:
1) Değerleri ayrı
2) Değerleri normal dağı ı
Genellikle değerlerin normal dağı ı ı
sütunları ı ı ı ı ı
fonksiyonundan hareketle elde edilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Naive Bayes yönteminde eğer sütunlar yalnı ı ı ı ı ı ı ı
daha uygun olmaktadı ı ı ı ı ı ı ı ı ı ı ı ı
Bu iki durum yazı ı ı ı ı ı ı ı ı ı ı
sözcüklerin sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Naive Bayes yöntemi ile sı ı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı
CategoricalNB: Bütün sütunları ı ı ı ı ı ı
GaussianNB: Sütunları ı ı ı ı ı ı ı
BernoullyNB: Sütunları ı ı ı ı ı ı
yazı ı ı ı
MultinomialNB: Sütunları ı ı ı ı ı ı ı
sı ı ı ı ı
Gaussian Naive Bayes yönteminde programcı ı ı ı ı
normal dağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
Burada scikit-learn içerisindeki GaussianNB sı ı ı ı ı ı
veriden hareketle kitlenin "iyi huylu (Benign)" mu yoksa "kötü huylu mu (Malign)" olduğunu anlamak için kullanı ı
dosyası ı
https://www.kaggle.com/datasets/uciml/breast-cancer-wisconsin-data
Aslı
sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
"""
import numpy as np
import pandas as pd
df = pd.read_csv("data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
"""
from sklearn.datasets import load_breast_cancer
bc = load_breast_cancer()
dataset_x = bc.data
dataset_y = bc.target
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(training_dataset_x, training_dataset_y)
predict_result = gnb.predict(test_dataset_x)
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(predict_result, test_dataset_y)
print(accuracy)
#----------------------------------------------------------------------------------------------------------------------------
Naive Bayes yönteminde artı ı ı ı ı ı
yapmı ı ı ı ı
metotlar bulunmaktadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Naive Bayes yönteminin şimdiye kadar gördüğümüz ve henüz görmedğimiz yöntemlere göre avantajları ı
edilebilir:
- Kategorik sütunları
Ancak karı ı
- Naive Bayes yöntemi az sayı ı ı
yapay sinir ağları ı ı
- Naive Bayes yöntemi basit aritmetik hesaplara dayalı ı ı ı
hesaplama zamanı ı ı ı ı ı ı ı
eğilimindedir.
- Naive Bayes yöneteminin gerçekleştirimi nispeeten diğer yöntemlere göre daha kolaydı
- Yöntem metinsel sı ı ı ı ı
- Naive Bayes yöntemi artı ı ı
- Naive Bayes yöntemi sütunları ı ı ı ı ı
çoğu kez mümkün olamamaktadı ı ı ı ı
diğer sütunda havadaki nem oranı ı ı ı ı ı ı
uygulanmaktadı ı ı
- Veri kümesinde hiç bulunmayan x verileri tahmin edilmeye çalı ı ı ı
uygulanmaktadı ı ı ı ı ı
- Naive Bayes yöntemi kategorik olmayan sütunlarda alternatif yöntemlere göre daha düşük performans gösterme eğilimindedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lojistik olmayan regresyon problemlerinin istatistiksel çözümü için en çok kullanı
denilen yöntemdir. Doğrusal regresyon noktaları
elde edilebilirse bu durumda kestirim yapı
Pekiyi noktaları ı
bu noktaları ı ı ı ı ı
Eğer sütun sayı ı ı ı
denilmektedir. Yani basit doğrusal regresyon aşağı
x Y
10 12.3
13.2 18.2
14.3 19.8
... ...
Basit doğrusal regresyonda elde edilmek istenen doğru denklemi şöyle ifade edilebilir:
y = B0 + B1x
Genellikle istatistikte katsayı ı ı ı ı ı ı
Eğer veri kümesinde iki sütun olsaydı
y = B0 + B1x1 + B2x2
N boyutlu uzayı ı ı
nası
kolaylı
y = B0 + B1x1 + B2x2 + B3... + Bnxn
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Basit doğrusal regresyonda noktaları
- Önce minimize edilecek fonksiyon belirlenmektedir. Minime edilecek fonksyon noktaları
elde edilen y değerlerinin farkları ı ı ı
alı ı ı ı
(Y - (B0 + B1 x)) ** 2
- Bu değerleeri minimize eden B0 ve B1 değerleri birkaç biçimde elde edilebilmektedir. En basit yol buradaki fonksiyonun B0 ve B1 için
parçalı ı ı ı
veren formüle "en küçük karerler (least square)" formülü de denilmektedir. Burada text ekrandan dolayı
Ancak Internet'te Bo ve B1 değerlerini veren en küçük kareler formülünü kolaylı
Aşağı ı
yazı ı ı ı ı
2,4
3,5
5,7
7,10
7,8
8,12
9.5,10.5
9,15
10,17
13,18
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def linear_regression(x, y):
a = np.sum((x - np.mean(x)) * (y - np.mean(y)))
b = np.sum(((x - np.mean(x)) ** 2))
b1 = a / b
b0 = (np.sum(y) - b1 * np.sum(x)) / len(x)
return b0, b1
dataset = np.loadtxt('points.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
b0, b1 = linear_regression(dataset_x, dataset_y)
x = np.linspace(0, 15, 100)
y = b0 + b1 * x
import matplotlib.pyplot as plt
plt.title('Simple Linear Regression')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.xticks(range(1, 15))
plt.show()
predict_data = 12.9
predict_result = b0 + predict_data * b1
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
nümerik analiz yöntemleriyle "gradient descent" denilen algortmik yolla da elde edilebilmektedir. Nümerik optimizasyon hakkı
bölümlerde bilgiler verilecektir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
sahip değildir. Bu alanlarda kullanı ı ı ı ı ı
(multiplelinear regression)" ile karşı ı ı ı ı ı
doğrusal regresyon modellerine istatistikte "çoklu doğrusal regresyon (multiple linear regression)" denilmektedir. Çoklu doğrusal
regresyon aslı ı
elde edilecek beta değerleri boyut sayı ı ı ı ı ı
hyperplane denklemi şöyle olacaktı
y = B0 + B1x1 + B2x2 + B3x3 + B4x4 + B5x5
Çoklu doğrusal regresyon için Beta katsayı ı ı ı ı
Aşağı
https://eli.thegreenplace.net/2014/derivation-of-the-normal-equation-for-linear-regression
Aşağı
Bu fonksiyonda yapı ı ı ı ı ı
en küçük kareler yöntemi uygulanmı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def multiple_linear_regression(x, y):
ones = np.ones((len(x), 1))
x = np.append(ones, x, axis=1)
beta = np.linalg.inv(x.T @ x) @ x.T @ y
return beta;
dataset = np.loadtxt('dataset.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
beta = multiple_linear_regression(dataset_x.reshape(-1, 1), dataset_y)
x = np.linspace(0, 15, 100)
y = beta[0] + beta[1] * x
import matplotlib.pyplot as plt
plt.title('Simple Linear Regression')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.xticks(range(1, 15))
plt.show()
predict_data = 12.9
predict_result = beta[0] + predict_data * beta[1]
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal regresyon için özellik ölçeklemesi yapmaya gerek yoktur. Çünkü yöntemin matematiksel temelinde ölçekleme gerekmemektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı
LinearRegression isimli bir sı ı ı ı ı ı ı ı ı ı ı ı
scikit-learn sı ı ı ı ı ı ı ı
sklearn.linear_model.LinearRegression(*, fit_intercept=True, copy_x=True, n_jobs=None, positive=False)
Sı ı ı
lr = LinearRegression()
Nesne yaratı ı ı ı ı ı ı
lr.fit(dataset_x, dataset_y)
fit işleminden sonra nesnenin coef_ örnek özniteliği beta katsayı ı ı
kestirim işlemi manuel bir biçimde intercept_ ve coef_ örnek özniteikleri kullanı ı ı ı
bu işlemi yapan predict metodu vardı
Aşağı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(dataset_x.reshape(-1, 1), dataset_y)
x = np.linspace(0, 15, 100)
y = lr.intercept_ + lr.coef_[0] * x
import matplotlib.pyplot as plt
plt.title('Simple Linear Regression')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.xticks(range(1, 15))
plt.show()
predict_data = 12.9
predict_result = lr.intercept_ + predict_data * lr.coef_[0]
print(predict_result)
predict_data = np.array([[12.9], [4.7], [6.9]])
predict_result = lr.predict(predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi bir doğrusal regresyon uygulandı ı ı ı ı ı
ölçütler kullanı ı ı
elde edilen doğrunun noktaları
R^2 değeri "açı ı ı
gerçek değerlerin arası ı ı ı ı ı ı ı
toplamı ı ı ı ı ı ı ı
doğruları ı ı
belirlemeye sahip değildir. Yani R^2 değeri yüksek olduğu halde kestirim beklenen kadar güçlü olmayabilir. Ya da R^2 değeri
yüksek olmadı ı ı
R^2 değeri LinearRegression sı ı ı ı ı
fit işlemini yapmı ı ı
yapı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Genel olarak bu haliyle yapay sinir ağı ı
sonuç verdiği görülmektedir. Ancak çoklu doğrusal regresyon da bu veri kümesi için kötü bir sonuç vermemektedir.
Örnekte çoklu doğrusal regresyonun R^2 değeri de yzdı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lr.score(test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
print()
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Boston-Housing-Price')
model.add(Dense(64, activation='relu', input_dim=training_dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2, verbose=0)
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.title('Epoch-Loss Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['loss'])
plt.plot(hist.epoch, hist.history['val_loss'])
plt.legend(['Loss', 'Validation Loss'])
plt.show()
plt.figure(figsize=(15, 5))
plt.title('Epoch-Mean Absolute Error Graph', fontsize=14, fontweight='bold')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.xticks(range(0, 210, 10))
plt.plot(hist.epoch, hist.history['mae'])
plt.plot(hist.epoch, hist.history['val_mae'])
plt.legend(['Mean Absolute Error', 'Validation Mean Absolute Error'])
plt.show()
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi her türlü veri kğmesine doğrusal regresyon uygulayabilir miyiz? Bunun yanı ı ı ı
veri kümesinin sütunları ı ı ı ı ı
benzer bir ilişki varsa iyi bir yöntem olabilmektedir. Eğer veri tablosunun sütunları ı
bir ilişki yoksa buı ı ı
Noktaları ı ı ı ı ı ı ı ı ı ı ı
bakı ı ı ı ı
Aşağı ı ı
R^2 çok düşük çı ı ı ı ı ı ı
Bu tür durumlarda yapay sinir ağları
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from sklearn.datasets import make_blobs
dataset, _ = make_blobs(n_samples=100, centers=1, center_box=(0, 0))
dataset_x = dataset[:, 0].reshape(-1, 1)
dataset_y = dataset[:, 1]
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(dataset_x, dataset_y)
x = np.linspace(-5, 5, 100)
y = lr.predict(x.reshape(-1, 1))
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Lşnear Regression with Circuler Data')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.show()
r2 = lr.score(dataset_x, dataset_y)
print(f'R^2 = {r2}')
cor = np.corrcoef(dataset_x.flatten(), dataset_y)
print(cor)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi dataset_x veri kümesi çok sütun içeriyorsa bu durumda bu veri kümesi için doğrusal regresyonun uygun olup olmadı ı
nası ı
eşleşsinler. İşte bunun için iki yöntem uygulanabilir:
1) Biz önce doğrusal regresyonu uygulayı ı ı
iyi bir fikir olmadı ı
2) Veri kümesinin sütunları ı ı
iyi sonuç vermeyeceğini düşünürüz.
Pekiyi ikinci yöntemde bazı ı ı ı ı
x1, x2, x3, x4 sütunları ı ı
ne yapmalı ı ı ı
uygulayabilir. Yani uygulamacı ı ı ı ı ı
regresyonda tüm sütunları ı ı ı ı
fonksiyonu uygulanabilir. Bu fonksiyon uygulanarak heatmap grafiğin çizilmesi de görsel olarak tespitin yapı ı ı ı ı
Aşağı ı ı
sütunlar alı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
CORR_THREASHOLD = 0.45
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lr.score(test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
print()
import numpy as np
concat_dataset = np.concatenate((dataset_x, dataset_y.reshape(-1, 1)), axis=1)
corr = np.abs(np.corrcoef(concat_dataset, rowvar=False))
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 8))
sns.heatmap(data=corr, annot=True)
plt.show()
selected_cols, = np.where(corr[:-1, -1] > CORR_THREASHOLD)
print(selected_cols)
selected_training_dataset_x = training_dataset_x[:, selected_cols]
selected_test_dataset_x = test_dataset_x[:, selected_cols]
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(selected_training_dataset_x, training_dataset_y)
predict_result = lr.predict(selected_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lr.score(selected_test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal regresyonun diğer önemli bir problemi de "multi-collinearity" denilen problemdir. Eğer doğrusal regresyon için kullanı
x veri kümesindeki bazı ı ı ı
regresyona sokulması ı ı ı ı
bir tanesini alı ı ı ı ı ı ı
seçilenlerin arası ı ı ı ı
bir tanesini muhafaza ederek diğerlerini atabiliriz. Pekiyi bu işlem nası ı
de faydalanarak gözle tespitin yapı ı ı
Araları ı
kullanı ı ı ı
Yüksek skor alan sütunları ı ı ı ı ı ı
Bu yöntemi uygulayan scikit-learn ya da scipy içerisinde hazı
modülünde variance-inflation_factor isimli bir fonksiyon bulunmaktadı ı ı ı ı
Aşağı
pip install statsmodels
variance_infaltion_factor fonksiyonun iki parametresi vardı ı
İkinci parametre sütun numarası ı ı ı ı ı ı
Pekiyi fonksiyonun geri döndürdüğü VIF değeri nası ı ı ı
- Eğer 1 ise sütunun diğerleri ile korelasyonu yoktur.
- Eğer 1 ile 5 arası ı
- 5'ten büyük ise sütun diğer sütunlarla yüksek bir korelasyon içerisindedir.
O halde bizim iki yöntemi karma etmemiz gerekmektedir. Yani biz hem Y ile yüksek korelasyonu olan x sütunları ı ı ı
kendi araları ı ı ı ı
Aşağı ı
yazdı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
CORR_THREASHOLD = 0.45
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
import numpy as np
concat_dataset = np.concatenate((dataset_x, dataset_y.reshape(-1, 1)), axis=1)
corr = np.abs(np.corrcoef(concat_dataset, rowvar=False))
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 8))
sns.heatmap(data=corr, annot=True)
plt.show()
selected_cols, = np.where(corr[:-1, -1] > CORR_THREASHOLD)
print(selected_cols)
from statsmodels.stats.outliers_influence import variance_inflation_factor
vifs = np.array([variance_inflation_factor(training_dataset_x, i) for i in range(training_dataset_x.shape[1])])
for i, vif in enumerate(vifs):
print(f'{i} ---> {vif}')
selected_cols, = np.where(vifs < 5)
print(selected_cols)
#----------------------------------------------------------------------------------------------------------------------------
Matematiksel optimizasyonlar temelde iki yöntemle yapı
1) Sembolik (ya da analitik) çözümlerden
2) Nümerik çözümler
Sembolik ya da analitik çözüm demek bilinen matematik kurallarla çözümü farmüllere indirgeyip değişkenleri bu formüllerde yerlerine
koyarak yapı ı
Ancak bazı
yavaş yavaş hedefe yaklaşma yoluna gidilir. Bunun için çeşitli yöntemler geliştirilmiştir. Hdefe bu biçimde varan çözümlere genel olarak
"nümerik çözümler" denilmektedir. Makine öğrenmesi uygulamarı ı ı
ya da analitik yolla çözülememektedir. Bu nedenle bu problemlerin çoğu nümerik yolla çözülürler.
Sembolik ya da analitik çözüm daha kesin bir sonuca varı ı ı ı ı
Ancak bazı ı ı
sağlarlar. Dolayı ı ı ı
sembolik ya da analitik çözümünün mümkün olmaması ı ı ı ı
işlemleri bu biçimdedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn içerisindeki LinearRegression sı ı ı ı ı ı ı ı
Bu sı ı ı ı ı ı ı
yardı ı ı
modelleri aslı ı
iteratif nümerik analiz yöntemleriyle "gradient descent" optimizasyon tekniği ile çözülmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lasso regresyonu en küçüğk kareler yöntemine mutlak değer içeren bir ceza puanı ı ı ı
regresyon modelinin nümerik analiz yöntemiyle iteratif çözülmesinde kullanı
bu ceza puanı ı ı ı
etmektedir. Yani Lasso regresyonu kendi içerisinde zaten yukarı ı ı ı ı ı
Lasso regresyonunda en küçük kareler yöntemine eklenen bu ceza puanı
Lasso regresyonunda ceza puanı ı ı
bu parametrenin uygulamacı ı ı ı ı
sütun elimine edilir. Bu parametre düşürülürse daha az sütun elimine edilmektedir. Bu bağlamda lamda parametresi bir "hyperparametre"dir.
Lasso regresyonunun sembolik ya da analitik çözümü yapı ı ı ı ı
Lasso regresyonunun en küçük kareler yönteminden bir farkı ı
Lasso regresyonunda "özellik ölçeklemesi" gerekmektedir. Gnel olarak "standart ölçekleme (standard scaling)" tercih edilmektedir.
Ancak "min-max ölçeklemesi" de benzer sonuçları
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lasso regeresyonu sklearn.linear_model modülünün içerisindeki LAsso sı ı ı ı ı ı ı ı
scikit-learn sı ı ı ı ı ı ı ı ı
class sklearn.linear_model.Lasso(alpha=1.0, *, fit_intercept=True, precompute=False, copy_x=True,
max_iter=1000, tol=0.0001, warm_start=False, positive=False, random_state=None, selection='cyclic')
Metodun en önemli parametresi L1 düzenlemesinde söz konusu olan bizim lamda dediğimiz parametredir. Bizim lamda dediğimiz
bu parametreye scikit-learn içerisinde alpha denilmektedir. Bu parametrenin default değerinin 1 olduğuna dikkat ediniz.
Daha sonra yaratı ı ı ı ı ı
kullanı ı ı
Lasso regresyonu kendi içerisinde özellik seçimi yapacağı ı ı ı ı ı ı ı ı ı ı ı ı
olabilmektedir. Bu katsayı ı ı ı ı ı ı ı ı ı
Aşağı ı ı
seçilmiştir. Bu seçim soncunda iki sütun atı ı ı ı ı
Tabii kestirim bulunulurken kestirilmek istenen x değerlerinin de yine aynı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.linear_model import Lasso
lasso = Lasso(alpha=0.1)
lasso.fit(scaled_training_dataset_x, training_dataset_y)
print(f'Intercept: {lasso.intercept_}')
print(f'Coefficients: {lasso.coef_}')
test_predict_result = lasso.predict(scaled_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lasso.score(scaled_training_dataset_x, training_dataset_y)
print(f'R^2: {r2}')
import numpy as np
predict_data = np.array([[0.98843, 0.00, 8.140, 0, 0.5380, 5.813, 100.00, 4.0952, 4, 307.0, 21.0, 394.54, 19.88], [0.75026, 0.00, 8.140, 0, 0.5380, 5.9240, 94.10, 4.3996, 4, 307.0, 21.00, 394.33, 16.30]])
scaled_predict_data = ss.transform(predict_data)
predict_result = lasso.predict(scaled_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Lasso regresyonundaki alpha parametresini otomatik ayarlamaı ı ı
uygun bir değeri seçebilir.
Aşağı ı ı ı ı
"mean absolute error" değerinin en düşük olduğu alpha değeri tespit edilmeye çalı ı ı ı
önemsemeyiniz. Daha önceden de belirttiğimiz gibi R^2 değeir doğrusal regresyonun iyiiğine ilişkin bir ölçüt olması ı
her zaman kestirim gücünü yordayamamktadı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
import numpy as np
from sklearn.linear_model import Lasso
for alpha in np.arange(0, 2, 0.05):
print(f'Alpha: {np.round(alpha, 2):.2F}')
lasso = Lasso(alpha=alpha)
lasso.fit(scaled_training_dataset_x, training_dataset_y)
test_predict_result = lasso.predict(scaled_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lasso.score(scaled_training_dataset_x, training_dataset_y)
print(f'R^2: {r2}')
print('------------------------------------------------')
#----------------------------------------------------------------------------------------------------------------------------
Lasso regresyonunun bir benzerine "Ridge Regresyonu" denilmektedir. Ridge regresyonu da tı ı
seçimi yapmaktadı ı ı ı ı ı ı
coef_ katsayı ı ı ı ı ı ı ı ı
Ridge regresyonun temel mantı ı
Bu ceza terimine "L2 Düzenlemesi (L2 Regulation)" da denilmektedir. Ridge regresyonundaki ceza teriminde de bir lamda parametresi vardı
Yine bu lamda parametresi yükseltilirse daha fazla sütunun etkisi azaltı ı ı ı ı
Lamda parametresi düşürülürse daha az sütun 0'a yaklaştı ı ı
Ridge regresyonunda da yine özellik ölçeklemesi yapı ı ı ı
ölçeklemesi de benzer sonuçları
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Ridge regresyonu için scikit-learn kütüphanesinde sklearn.linear_model modülünde Ridge isimli bir sı ı
Sı ı ı ı ı
class sklearn.linear_model.Ridge(alpha=1.0, *, fit_intercept=True, copy_x=True, max_iter=None, tol=0.0001,
solver='auto', positive=False, random_state=None)
Sı ı ı ı ı ı ı ı ı ı ı
Aşağı ı ı ı
sütun katsayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.linear_model import Ridge
ridge = Ridge(alpha=3)
ridge.fit(scaled_training_dataset_x, training_dataset_y)
print(f'Intercept: {ridge.intercept_}')
print(f'Coefficients: {ridge.coef_}')
test_predict_result = ridge.predict(scaled_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = ridge.score(scaled_training_dataset_x, training_dataset_y)
print(f'R^2: {r2}')
import numpy as np
predict_data = np.array([[0.98843, 0.00, 8.140, 0, 0.5380, 5.813, 100.00, 4.0952, 4, 307.0, 21.0, 394.54, 19.88], [0.75026, 0.00, 8.140, 0, 0.5380, 5.9240, 94.10, 4.3996, 4, 307.0, 21.00, 394.33, 16.30]])
scaled_predict_data = ss.transform(predict_data)
predict_result = ridge.predict(scaled_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Elastic Net regresyonu denilen regresyon modeli de aslı ı ı
biçimidir. Yani ceza terimi içerisinde hem L1 düzenlemesi hem de L2 düzenlemesi bulunmaktadı ı ı
biçiminde iki heyper parametresi vardı ı
Burada hem bazı ı ı ı ı
gereksinim duyulması ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Elistic Net regresyon modeli scikit-learn kütüphanesinde linear_model modülündeki ElasticNet isimli sı ı
Sı ı ı ı ı
class sklearn.linear_model.ElasticNet(alpha=1.0, *, l1_ratio=0.5, fit_intercept=True, precompute=False, max_iter=1000,
copy_x=True, tol=0.0001, warm_start=False, positive=False, random_state=None, selection='cyclic')
Burada alpha parametresi yine temel bir hyper parametredir. Hem L1 düznlemesi üzerinde hem de L2 düzüenlemesi üzerinde etkili olmaktadı
l1_ratio parametresi ise L1 düzenlemesinin L2 düzenlemesine göre etkisini belirlemektedir. l1_ratio default olarak 0.5 değerindedir.
Yani bu durumda L1 düzenlemesi de L2 düzenlemesi de aynı ı
değerini değiştirip bunları
ElasticNet sı ı ı ı ı ı ı ı
Aşağı ı ı ı
ElsticNet diğerlerinden daha iyi sonuç verebilmektedir. Ancak parametrelerin ayarlanması
yanı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
import numpy as np
from sklearn.linear_model import ElasticNet
for ratio in np.arange(0.1, 1, 0.05):
print(f'Alpha: 0.5, L1 Ratio: {ratio}')
elasticnet = ElasticNet(alpha=0.1, l1_ratio=ratio)
elasticnet.fit(scaled_training_dataset_x, training_dataset_y)
test_predict_result = elasticnet.predict(scaled_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = elasticnet.score(scaled_training_dataset_x, training_dataset_y)
print(f'R^2: {r2}')
print('------------------------------------------------')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biz şimdiye kadar doğrusal regresyon gördük. Doğrusal regresyon noktaları
Tabii "doğru" sözcüğü iki boyutlu uzaya ilişkin bir terimdir. Çok bouyutlu uzayda doğru yerine o uzayı
olur kş buna da biz "hyperplane" demiştik. Tek özelliğe sahip veri kümelerinin belirttiği iki boyutlu uzayla çok özelliğe sahip
veri kümelerinin belirttiği çok boyutlu uzaydaki işelmler genel itibari ile benzerdir.
Tek teğişkenli bir polinomun genel biçimi şöyledir:
P(x) = a0 + a1 x + a2 x^2 + a3 x^3 + ... + an x^n
Tabii değişken sayı ı ı ı
içeren daha karmaşı
P(x1, x2) = a0 + a1x1 + a2x2 + a3 x1x2 + a4 * x1^2 + a5 x2^2 + a6 x1^2 x2 + a7 x1x2^2 a8 x1^3 + a9 x2^3 + .... +
Örneğin üç değişkenli bir polinomun genel biçimi de şöyle olacaktı
P(x1, x2, x3) = a0 + a1 x1 + a2 x2 + a3 x3 + a4 x1 x2 + a4 x1 x3 + a5 x2 x3 + a5 x1 x2 x3 + a6 x1^2 x2 + a7 x1 x2^2 + a8 x2 x3^ + ....
Görüldüğü gibi polinomsal regresyonda veri kümesindeki özellikler arttı ı ı
artmaktadı
Her ne kadar noktaları ı ı
görüldüğü üzere bu durum tahmin edilmesi gereken parametrelerin sayı ı ı ı ı ı
Biz eğri geçirmenin avantajı ı
Bir polinomun derecesi onun en yüksek üssüyle belirtilmektedir. Pekiyi biz noktaları ı ı ı
Şüphesiz derece arttı ı ı ı ı ı ı
belirtitğimiz gibi polinomun derecesi yüksek tutulursa bu durumda tahmin edilecek parametrelerin sayı ı ı
polinomun bulunması ı ı ı
İkinci derece, üçüncü derece polinomlar modeli çok karmaşı
overfitting durumuna da yol açabilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi polinomsal regresyonun katsayı
noktaları
P(x1, x2) = a0 + a1 x1 + a2 x2 + a3 x1 x2 + a4 x1^2 + a5 x2^2 + a6 x1 x2^2 + a7 x1^2 x2 + a8 x1^3 + a9 x2^3
Burada görükldüğü gibi 9 tane tahmin edilmesi gereken katsayı ı ı
tahmin edilecektir?
İşte aslı
regresyonun doğrusal regresyona dönüştürülmesine "polinomsal transformasyon (polynomial transformation)" denilmektedir. Biz burada
bu transformasyonun nası ı ı ı ı ı ı ı ı ı ı
değişken yapı ı ı ı ı ı
P(x1, x2) = a0 + x1 a1 + x2 a2 + x1 x2 a3 + x1^2 a4 + x2^2 a5 + x1 x2^2 a6 +x1^2 x2 a7 + x1^3 a8 + x2^3 a9
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Polinomsal regresyon sckit-learn kütüphanesinde iki aşamada çözülür. Birinci aşamada x katsayı
sokularak doğrusal regresyon biçimine getirilir. İkinci aşamda ise doğrusal regresyon çözümü yapı ı
Polinomsal regresyon için polinomsal transformasyon sklearn.preprocessing modülündeki PolynomialFeatures sı ı ı ı ı
Sı ı ı ı ı
class sklearn.preprocessing.PolynomialFeatures(degree=2, *, interaction_only=False, include_bias=True, order='C')
Metodun ilk parametresi noktaları ı ı
diğer sckit-learn sı ı ı ı ı
yapı ı ı ı
kullanı
gibi sı ı ı
Orijinal verilerin m satı ı ı ı
Ancak sütunları ı ı ı ı
PolynomialFeatures ile dönüştürmek isteyelim. Bu durumda fit_transform metodu ile elde edilecek dönüştürülmüş matrisin boyutları ı
Çünkü burada bulunmak istenen polinom P(x) = a0 + a1 x + a2 x^2 biçimindedir ve burada 3 terim vardı
PolynomialFeatures sı ı ı ı ı ı
polinomsal regresyondaki katsayı ı ı ı
sonucunda elde edilen R^2 değeri yine bize polinomsal regresyonun uygunluğu konusunda bilgi vermektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Önce doğrusal regresyonun uygun olmadı ı ı ı
2,4
3,5
5,7
7,10
7,8
8,12
9.5,10.5
9,15
10,17
13,18
Burada ilk sütun x verileri ikinci sütun Y verileridir. Dolayı ı
R^2 değeri 0.69 gibi düşük bir değerdir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(dataset_x.reshape(-1, 1), dataset_y)
x = np.linspace(0, 100, 1000)
y = lr.predict(x.reshape(-1, 1))
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Polynomial Data Inappropriate Linear Regression')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.show()
r2 = lr.score(dataset_x.reshape(-1, 1), dataset_y)
print(f'R^2: {r2}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de yukarı ı ı
P(x) = a0 + a1 x + a2 x^2 + a3 x^3
Burada toplam 4 tane terim sayı ı ı ı ı ı
ederiz. O halde aslı ı ı
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
from sklearn.preprocessing import PolynomialFeatures
pf = PolynomialFeatures(degree=3)
transformed_dataset_x = pf.fit_transform(dataset_x.reshape(-1, 1))
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(transformed_dataset_x, dataset_y)
Burada doğrusal regresyondan elde ettiğimiz katsayı ı ı ı ı
katsayı ı ı ı ı
P(x) = lr.coef_[0] + lr.coef_[1] * x + lr.coef_[2] * x ** 2 + lr.coef_[3] * x ** 3
Tabii tahminleme yapmak için x değerlerini yukarı ı ı
polinomun genel biçimi çok daha fazla terim içerecektir. Burada tahminleme için yine aynı
önce PolynomialFeatures sı ı ı ı
sokulabilir. Örneğin:
predict_data = np.array([4, 14, 67])
transformed_predict_data = pf.transform(predict_data.reshape(-1, 1))
predict_result = lr.predict(transformed_predict_data)
print(predict_result)
Aşağı ı ı
noktaları
2,4
3,5
5,7
7,10
7,8
8,12
9.5,10.5
9,15
10,17
13,18
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
from sklearn.preprocessing import PolynomialFeatures
pf = PolynomialFeatures(degree=3)
transformed_dataset_x = pf.fit_transform(dataset_x.reshape(-1, 1))
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(transformed_dataset_x, dataset_y)
x = np.linspace(0, 110, 1000)
transformed_x = pf.transform(x.reshape(-1, 1))
y = lr.predict(transformed_x)
# y = lr.coef_[0] + lr.coef_[1] * x + lr.coef_[2] * x ** 2 + lr.coef_[3] * x ** 3
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Polynomial Data Inappropriate Linear Regression')
plt.scatter(dataset_x, dataset_y, color='blue')
plt.plot(x, y, color='red')
plt.show()
r2 = lr.score(transformed_dataset_x, dataset_y)
print(f'R^2: {r2}')
predict_data = np.array([4, 14, 67])
transformed_predict_data = pf.transform(predict_data.reshape(-1, 1))
predict_result = lr.predict(transformed_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı
sütunları ı ı ı ı ı ı ı ı
sütunlu veri kümesinin sokulacağı ı
P(x) = a0 + a1 x1 + a2 x2 + a3 x1 x2 + a4 x1^2 + a5 x2^2 + a6 x1^2 x2 + a7 x2^2 x1 + a8 x1^3 + a9 x2^3
Görüldüğü gibi toplam 10 tane terim vardı ı
tutulursa underfitting ya da overfitting kaçı ı ı ı ı
çı ı ı
Aşağı ı ı ı ı ı ı ı
kadar hı ı ı ı
Sütun Sayı ı ı ı
2 --> 10
3 --> 20
4 --> 35
5 --> 56
6 --> 84
7 --> 120
8 --> 165
9 --> 220
10 --> 286
11 --> 364
12 --> 455
13 --> 560
14 --> 680
15 --> 816
16 --> 969
17 --> 1140
18 --> 1330
19 --> 1540
20 --> 1771
21 --> 2024
22 --> 2300
23 --> 2600
24 --> 2925
25 --> 3276
26 --> 3654
27 --> 4060
28 --> 4495
29 --> 4960
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
print('Sütun Sayı ı ı ı
for i in range(2, 30):
dataset_x = np.random.random((100, i))
dataset_y = np.random.random(100)
pf = PolynomialFeatures(degree=3)
transformed_dataset_x = pf.fit_transform(dataset_x)
print(f'{i} --> {transformed_dataset_x.shape[1]}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
1) LinearRegression
2) PolynomialFeatures --> LinearRegresson
3) PolynomialFeatures --> Lasso
Elde edilen sonuçlar şöyle olmuştur:
Mean Absolute Error: 3.578927993774414
R^2 = 0.7665389566180016
Mean Absolute Error: 3.879051685333252
R^2 = 0.7380310070920353
Mean Absolute Error: 2.180447816848755
R^2 = 0.8993317696045933
Bu denemelerden en iyi sonuç önce ikinci derece polinomun Lasso regresyonu ile uygulnaması
değişik performanslar elde edilmiştir. İyi bir alpha değeri 0.005 biçimindedir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lr.score(test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
print()
from sklearn.preprocessing import PolynomialFeatures
pf = PolynomialFeatures(degree=2)
transformed_training_dataset_x = pf.fit_transform(training_dataset_x)
lr = LinearRegression()
lr.fit(transformed_training_dataset_x , training_dataset_y)
transformed_test_dataset_x = pf.transform(test_dataset_x)
predict_result = lr.predict(transformed_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lr.score(transformed_test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
print()
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Lasso
ss = StandardScaler()
scaled_transformed_training_dataset_x = ss.fit_transform(transformed_training_dataset_x)
scaled_transformed_test_dataset_x = ss.transform(transformed_test_dataset_x)
lasso = Lasso(alpha=0.005, max_iter=100000)
lasso.fit(scaled_transformed_training_dataset_x , training_dataset_y)
predict_result = lasso.predict(scaled_transformed_test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(predict_result, test_dataset_y)
print(f'Mean Absolute Error: {mae}')
r2 = lasso.score(scaled_transformed_test_dataset_x, test_dataset_y)
print(f'R^2 = {r2}')
print()
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinin pek çok alanı
genellikle "minimizasyon" biçiminde karşı ı ı ı
1) Fonksiyonun türevinin sı ı
2) Adı ı ı ı
Makine öğrenmesindeki optimizasyon işlemlerinde daha önce de bahsettiğimiz gibi genel olarak sembolik değil nümerik analiz
yöntemleri kullanı ı
Gradient descent fonksiyonu minimum yapan değerlerin bulunması
bulunması ı
Optimizasyon işleminde minimize edilecek fonksiyona "kayı
Optimizasyonun amacı ı ı
probleme dayalı ı
fonksiyon bir loss fonksiyonudur. Biz doğursal regresyonda bu fonksiyonu minimum yapan değerleri elde etmek isteriz.
Bir fonksiyonu minimum yapan değerlerin elde edilmesi fonksiyonun türevinin sı ı ı
Ancak yukarı ı
iteratif biçimde hedefe yavaş yavaş varı ı ı ı
Makine öğrenmesinde genellikle veri kümemizde birdenfazla sütun vardı ı
anlamı ı ı ı ı ı
Böylece bir grup türev ifadesi elde edilir. Fonksiyonları ı ı ı
da denilmektedir. Parçalı
Gradient vektör minimum noktaya varmak için bir doğrultu vermektedir. Gradeient descent yöntemde belli bir x değerindne işlem başlatı ı
Sonra gradient vektörden bir değer elde edilir. Bu değer bu x değerindne çı ı ı ı ı ı
yaklaşı ı
Bir fonksiyonun birinci türevini sı ı ı
Bu minimum noktalardan biri "global minimum (global minima)" noktası ı ı ı
önemli problemlerinden biridir. Burada çeşitli yöntemler kullanı
Gradient descent yöntemlerde gradient vektör doğrultusunda ilerlerken ilerleme adı ı
noktaya yaklaşma büyük adı ı ı ı ı ı ı ı ı
Eğer ilerleme küçük adı ı ı ı ı ı ı
Bu ilerleme adı ı ı ı ı ı ı
hedefe yakı ı ı ı ı ı ı ı ı ı
hedef daha düşük bir duyarlı ı ı
belirtir. Uygulamacı ı
Gradient descent yönteminde bir minimum noktanı ı
<belli bir x değereinden işleme başlanı
<loss fonksiyonundan gradient vektör elde edilir>
while True:
error = <x değeri gradient vektöre sokulur>
x = x - error
y_new = loss(x)
if abs(y_new, y_old) < epsilon:
break
y_old = y_new
Aşağı
Buradaki LEARNING_RATE göreli adı ı ı ı ı ı ı ı
Tabii burada fonksiyon çok değişkenli ise (yani veri kümesi birden fazla sütundan oluşyorsa) x = x - error işlemi her değişken için yaoı ı
#----------------------------------------------------------------------------------------------------------------------------
# loss = x^2 - 4
# gradient vect = [2x]
import numpy as np
EPSILON = 0.000000000001
LEARNING_RATE = 0.00001
def loss(x):
return x ** 2 - 4
x = -10
y_old = loss(x)
while True:
error = (2 * x) * LEARNING_RATE
x -= error
y_new = loss(x)
if np.abs(y_new - y_old) < EPSILON:
break
y_old = y_new
print(x, loss(x))
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de doğursal regresyonu gradeint descent yöntemle çözmeye çalı ı ı ı ı ı
türevlerini alarak gradient vektörü elde ederiz. Sonra da adı ı ı ı ı ı
nası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('points.csv', dtype=np.float32, delimiter=',')
dataset_x = dataset[:, 0]
dataset_y = dataset[:, 1]
def loss(ypred, y):
return np.sum(np.abs(y - ypred)) / len(ypred)
def linear_regression_gradient(x, y, *, epsilon, learning_rate):
N = len(x)
b0 = 0
b1 = 0
prev_loss = 0
while True:
ypred = b0 + b1 * x
df_b1 = (-2 / N) * np.sum(x * (y - ypred))
df_b0 = (-2 / N) * np.sum(y - ypred)
b0 = b0 - df_b0 * learning_rate
b1 = b1 - df_b1 * learning_rate
next_loss = loss(y, ypred)
if np.abs(prev_loss - next_loss) < epsilon:
break
prev_loss = next_loss
return b0, b1
b0, b1 = linear_regression_gradient(dataset_x, dataset_y, epsilon=0.000000001, learning_rate=0.001)
x = np.linspace(1, 15, 100)
y = b0 + b1 * x
import matplotlib.pyplot as plt
plt.title('Linear Regression with Gradient Descent')
figure = plt.gcf()
figure.set_size_inches((10, 8))
plt.xlabel('x')
plt.ylabel('y')
plt.scatter(dataset[:, 0], dataset[:, 1], color='blue')
plt.plot(x, y, color='red')
plt.show()
print(f'Slope = {b1}, Intercept={b0}')
#----------------------------------------------------------------------------------------------------------------------------
Gradient descent optimizasyon işleminde birbirine benzeyen üç terim kullanı ı
Stochastic Gradient Descent.
Batch Gredient Descent yönteminde her iterasyonda eğitim veri kümesinin tamamı ı ı
yapı ı ı ı ı ı
Eğer veri kümesindne her defası ı ı ı
En çok "Stochastic Gradient Descent" yöntemi tercih edilmektedir. Örneğin eğitim veri kümemizde 100 satı ı ı
gradient vektöre sokup 100 değer elde edip bu 100 değerden elde ettiğimiz toplam sonuç ile ilerlemeyi yaparsak "Batch Gradient Descent" uygulamı
Eğer biz bu 100 satı ı ı ı ı
toplamda çok kez yapı ı ı ı ı ı
tek tek yaparsak "Stochastic Gradient Descent" uygulamı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal regresyon (en küçük kareler, Lasso, Ridge, ElasticNet) ve Polinomsal regresyon sı ı ı
(yani lojistik olmayan) regresyon problemlerinde kullanı ı ı ı ı
problemlerde kullanı ı
genel olarak sı ı ı ı ı
klasik sı ı ı ı
İstatistikte "lojistik regresyon" denildiğinde default olarak iki sı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı
İstatistikte "lojistik regresyona" "logit regresyonu" ya da kı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İstatistikte iki sı ı ı ı ı ı ı
0 ve 1'lerden oluşan Y değerleri dikkate alı ı
Çünkü oluşturulan bu doğruda x değerlerine karşı ı ı
oluşturulan bu regresyon doğrusu x'ler Y değerlerini 0 ve 1 olarak vermemktedir. [-sonsuz, +sonsuz] aralı
"sigmoid fonksiyonu" devreye girmektedir. Oluşturulan regresyon doğrusunda x değerine karşı
sigmoid fonksiyonu bu değeri [0, 1] aralı ı ı
değer aslı ı ı ı ı ı ı ı
o kadar yüksektir. Benzer biçimde bu değer ne kadar 0'a yakı ı ı ı
bu sigmoid fonksiyonundan elde edilen değerin 0.5'ten büyük olup olmadı ı
Sigmoid fonksiyonun tanı ı ı ı
değeri 0.5'tir. Sigmodi fonksiyonu S harfi biçimindedir.
İstatistiksel lojistik regresyonda regresyon doğrusu "en küçük kareler, lasso, ridge, elastic net" gibi yöntemlerle oluşturulmamaktadı
İsmine "maximum likelihood" denilen bir yöntemle oluşturulmaktadı
"gradient descent" yöntemlerle oluşturulmaktadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde N boyutlu uzaydaki noktaları ı ı ı ı ı ı
denilmektedir. Örneğin biz x1 ve x2 özelliklerine sahip bir kümesindeki noktaları ı ı ı
Bu tür ayrı ı ı ı ı ı ı ı ı ı
n boyutlu uzayda bir hyperplane ile ayrı ı ı ı ı ı
oluşturup bunu sigmoid fonksiyonuna soktuğumuzda ve 0.5'i karar noktası ı
hyperplane ile ayrı ı ı ı ı ı ı
iyi çalı
İki sı ı ı ı ı
bu veri kümesine "doğrusal olarak ayrı ı ı
doğrusal olarak ayrı ı ı ı ı
doğrusal olmayan bir fonksiyon le ayrı ı ı ı ı ı ı ı ı
lojistik regresyona göre çok daha iyi bir sonuç vermektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lojistik regresyonun bir çeşit doğrusal olarak ayrı ı
için elde edilen doğru denklemi sigmoid fonksiyonunda yerine konursa şöyel bir durum oluşacaktı
p(x) = 1 / (1 + e ^ -f(x))
Burada f(x) regresyon doğrusunu belirtiyor olsun. Bir olayı ı ı ı ı ı ı ı ı
Odds Ratio bahislerde çokça kullanı ı ı ı ı
p(x) / ( 1- p(x)) = e ^ f(x)
Sı ı ı ı ı
log (p(x) / (1 - p(x))) = f(x)
Eşitliğin sol tarafı ı ı ı
bir doğru ile ayrı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde lojistik regresyonun gerçekleştirilmesi genellikle tersten yapı ı
elde etmeye çalı ı ı
ki x noktaları ı ı ı ı ı
bu değerlerin belirttiği sı ı ı ı ı ı ı
fonksiyona sokulması ı ı ı ı ı ı
bu noktaları ı ı ı ı ı ı ı ı
minimize edilecek fonksiyon: (sigmoid(f(x)) - Y)^2
Tabii bu yöntem aslı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
Problemde kullanı ı ı
x1,x2,class
-0.017612,14.053064,0
-1.395634,4.662541,1
-0.752157,6.538620,0
-1.322371,7.152853,0
0.423363,11.054677,0
0.406704,7.067335,1
0.667394,12.741452,0
-2.460150,6.866805,1
0.569411,9.548755,0
-0.026632,10.427743,0
0.850433,6.920334,1
1.347183,13.175500,0
1.176813,3.167020,1
-1.781871,9.097953,0
-0.566606,5.749003,1
0.931635,1.589505,1
-0.024205,6.151823,1
-0.036453,2.690988,1
-0.196949,0.444165,1
1.014459,5.754399,1
1.985298,3.230619,1
-1.693453,-0.557540,1
-0.576525,11.778922,0
-0.346811,-1.678730,1
-2.124484,2.672471,1
1.217916,9.597015,0
-0.733928,9.098687,0
-3.642001,-1.618087,1
0.315985,3.523953,1
1.416614,9.619232,0
-0.386323,3.989286,1
0.556921,8.294984,1
1.224863,11.587360,0
-1.347803,-2.406051,1
1.196604,4.951851,1
0.275221,9.543647,0
0.470575,9.332488,0
-1.889567,9.542662,0
-1.527893,12.150579,0
-1.185247,11.309318,0
-0.445678,3.297303,1
1.042222,6.105155,1
-0.618787,10.320986,0
1.152083,0.548467,1
0.828534,2.676045,1
-1.237728,10.549033,0
-0.683565,-2.166125,1
0.229456,5.921938,1
-0.959885,11.555336,0
0.492911,10.993324,0
0.184992,8.721488,0
-0.355715,10.325976,0
-0.397822,8.058397,0
0.824839,13.730343,0
1.507278,5.027866,1
0.099671,6.835839,1
-0.344008,10.717485,0
1.785928,7.718645,1
-0.918801,11.560217,0
-0.364009,4.747300,1
-0.841722,4.119083,1
0.490426,1.960539,1
-0.007194,9.075792,0
0.356107,12.447863,0
0.342578,12.281162,0
-0.810823,-1.466018,1
2.530777,6.476801,1
1.296683,11.607559,0
0.475487, 12.040035,0
-0.783277,11.009725,0
0.074798,11.023650,0
-1.337472,0.468339,1
-0.102781,13.763651,0
-0.147324,2.874846,1
0.518389,9.887035,0
1.015399,7.571882,0
-1.658086,-0.027255,1
1.319944,2.171228,1
2.056216,5.019981,1
-0.851633,4.375691,1
-1.510047,6.061992,0
-1.076637,-3.181888,1
1.821096,10.283990,0
3.010150,8.401766,1
-1.099458,1.688274,1
-0.834872,-1.733869,1
-0.846637,3.849075,1
1.400102,12.628781,0
1.752842,5.468166,1
0.078557,0.059736,1
0.089392,-0.715300,1
1.825662,12.693808,0
0.197445,9.744638,0
0.126117,0.922311,1
-0.679797,1.220530,1
0.677983,2.556666,1
0.761349,10.693862,0
-2.168791,0.143632,1
1.388610,9.341997,0
0.317029,14.739025,0
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv('logistic-points.csv')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
dataset_x = np.append(dataset_x, np.ones((dataset_x.shape[0], 1)), axis=1)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Points for Logistic Regression')
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], color='blue', marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], color='green', marker='^')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend(['class 0', 'class 1'])
plt.show()
def sigmoid(x):
return 1.0 / (1 + np.exp(-x))
def gradient_descent_logistic(dataset_x, dataset_y, learning_rate=0.001, epoch=50000):
weights = np.ones((dataset_x.shape[1], 1))
for k in range(epoch):
h = sigmoid(np.matmul(dataset_x, weights))
error = dataset_y - h
weights = weights + learning_rate * np.matmul(dataset_x.transpose(), error)
return weights
weights = gradient_descent_logistic(dataset_x, dataset_y.reshape(-1, 1))
x1 = np.linspace(-5, 5, 1000)
x2 = (-weights[2] - weights[0] * x1) / weights[1]
plt.figure(figsize=(10, 8))
plt.title('Points for Logistic Regression')
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], color='blue', marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], color='green', marker='^')
plt.plot(x1, x2, color='red')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend(['class 0', 'class 1', 'regression line'])
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı
hazı ı ı ı ı ı ı ı ı ı
class sklearn.linear_model.LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1,
class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)
Metodun birinci parametresi doğru denkleminin elde edilmesinde kullanı
en küçük kareler yöntemi, 'l1' geçilirse Lasso regresyonu, 'l2' geçilirde Ridge regresyonu ve 'elasticnet' geçilirse Elastic Net regresyonu
uygulanmaktadı ı
LogisticRegression nesnesi yaratı ı ı ı ı ı
Sı ı ı ı ı ı ı
numaraları ı ı ı ı ı ı ı ı ı ı
satı ı ı ı ı ı ı ı
gerçek Y değerleriyle oranı ı
Sı ı ı ı ı ı
B0 + B1 x1 + B2 x2 + ... + Bn xn = 0 biçiminde verilmektedir. Dolayı ı
Normal olarak lojistik regresyon işlemlerinde özellik ölçeklemesi yapmaya gerek yoktur. Ancak LogisticRegression sı ı ı ı
"l1", "l2" elasticnet" seçildiğinde resgülasyon uygulandı ı
None değeri "en küçük kareler" yönteminin uygulanacağı ı
Ancak ne olursa olsun özellik ölçeklemesi LogisticRegression sı ı ı ı
Aşağı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv('logistic-points.csv')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
dataset_x = np.append(dataset_x, np.ones((dataset_x.shape[0], 1)), axis=1)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.title('Points for Logistic Regression')
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], color='blue', marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], color='green', marker='^')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend(['class 0', 'class 1'])
plt.show()
def sigmoid(x):
return 1.0 / (1 + np.exp(-x))
def gradient_descent_logistic(dataset_x, dataset_y, learning_rate=0.001, epoch=50000):
weights = np.ones((dataset_x.shape[1], 1))
for k in range(epoch):
h = sigmoid(np.matmul(dataset_x, weights))
error = dataset_y - h
weights = weights + learning_rate * np.matmul(dataset_x.transpose(), error)
return weights
weights = gradient_descent_logistic(dataset_x, dataset_y.reshape(-1, 1))
x1 = np.linspace(-5, 5, 1000)
x2 = (-weights[2] - weights[0] * x1) / weights[1]
plt.figure(figsize=(10, 8))
plt.title('Points for Logistic Regression')
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], color='blue', marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], color='green', marker='^')
plt.plot(x1, x2, color='red')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend(['class 0', 'class 1', 'regression line'])
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi istatistiksel lojistik regresyon ile yapay sinir ağları
gerçekleştirilen lojistik regresyon arası ı ı ı ı ı ı
Bu konuda şunlar söylenebilir:
- Çeşitli yöntemlerin hangisinin daha iyi sonuç vereceğini verilerin dağı ı ı ı ı ı
Dolayı ı ı ı
Zaten "automated araçlar" aslı ı
- İstatistiksel lojistik regresyon yukarı ı ı ı
veri kümeleri için çok uygun bir yöntemdir. Veri kümesindeki noktalar bir doğru ile ayrı ı ı ı ı ı
performansı ı
- Yapay sinir ağları ı ı ı ı
ayrı ı ı ı
- Az sayı ı ı ı ı
Yapay sinir ağları ı
- Naive Bayes yöntemi ön koşulları ı
eğilimindedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
Bu veri kümesinde LogisticRegression ve yapay sinir ağları ı
Üç yöntemden elde edilen değerler şunlardı
LogisticRegression accuracy score: 0.9649122807017544
GaussianNB accuracy score: 0.9210526315789473
NeuralNet accuracy score: 0.9649122807017544
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
# LogisticRegression Solution
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
lr.fit(scaled_training_dataset_x, training_dataset_y)
predict_result = lr.predict(scaled_test_dataset_x)
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(f'LogisticRegression accuracy score: {score}')
# Naive Bayes Solution
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(training_dataset_x, training_dataset_y)
predict_result = gnb.predict(test_dataset_x)
score = accuracy_score(predict_result, test_dataset_y)
print(f'GaussianNB accuracy score: {score}')
# Neural Net Solution
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='BreastCancer')
model.add(Dense(64, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, verbose=0)
predict_result = (model.predict(scaled_test_dataset_x) > 0.5).astype(int)
score = accuracy_score(predict_result, test_dataset_y)
print(f'NeuralNet accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı ı
lojistik regresyon problemleri de aslı ı ı ı ı
Burada sigmoid fonksiyonu yerine softmax fonksiyonukullanı ı
2024-05-20 13:45:43 +03:00
doğru elde edilmektedir. Lojistik regresyon uygularken Y verileri üzerinde "one-hot encoding" uygulanmaz. Y verileri LabelEncoding
2024-04-02 13:01:04 +03:00
yapı ı ı ı
Aşağı ı ı ı ı ı ı ı
ayrı ı ı ı ı ı ı ı ı ı ı ı
elde edilmiştir. Bunun nedeni şüphesiz kümlerin birbirlerinden oldukça ayrı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset_x = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
dataset_y = le.fit_transform(df.iloc[:, -1])
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
# LogisticRegression Solution
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(f'Multinomial LogisticRegression score: {score}')
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
scaled_training_dataset_x = mms.fit_transform(training_dataset_x)
scaled_test_dataset_x = mms.fit_transform(test_dataset_x)
# Neural Net Solution
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse=False)
ohe_training_dataset_y = ohe.fit_transform(training_dataset_y.reshape(-1, 1))
ohe_test_dataset_y = ohe.fit_transform(test_dataset_y.reshape(-1, 1))
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Iris')
model.add(Dense(64, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(3, activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(scaled_training_dataset_x, ohe_training_dataset_y, batch_size=32, epochs=200, verbose=0)
predict_result_softmax = model.predict(scaled_test_dataset_x)
import numpy as np
predict_result = np.argmax(predict_result_softmax, axis=1)
score = accuracy_score(test_dataset_y, predict_result)
print(f'Neural Net score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de MNIST örneğini istatistiksel multinomial lojistik regresyonla çözmeye çalı ı ı
regresyona uygun bir veri kümesi değildir. Çünkü veri kümesinde 784 tane sütun vardı
başarı ı ı
LogisticRegresson accuracy score: 0.9203
Simple Neural Net accuracy score: 0.9768
Görüldüğü gibi resim tanı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df_training = pd.read_csv('mnist_train.csv')
df_test = pd.read_csv('mnist_test.csv')
training_dataset_x = df_training.iloc[:, 1:].to_numpy()
training_dataset_y = df_training.iloc[:, 0].to_numpy()
test_dataset_x = df_test.iloc[:, 1:].to_numpy()
test_dataset_y = df_test.iloc[:, 0].to_numpy()
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000)
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(f'LogisticRegresson accuracy score: {score}')
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='MNIST')
model.add(Dense(256, activation='relu', input_dim=784, name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(training_dataset_x, ohe_training_dataset_y, epochs=20, batch_size=32)
import numpy as np
softmax_predict_result = model.predict(test_dataset_x)
predict_result = np.argmax(softmax_predict_result, axis=1)
score = accuracy_score(test_dataset_y, predict_result)
print(f'Simple Neural Net accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
İki sı ı ı ı ı ı ı ı ı ı ı
fazla olduğunda sı ı ı ı ı ı ı ı ı
Her hyperplane bir kümeyi ayrı ı ı ı ı ı ı ı
elde edilen değerler softmax işlemine sokulmaktadı ı ı ı ı ı ı
Tabii buradaki "ayı ı
olması ı
Çok sı ı ı ı ı
çok sı ı ı ı ı ı
Sonra da istatistiksel lojistik regresyon uygulanı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from sklearn.datasets import make_blobs
dataset_x, dataset_y = make_blobs(n_features=2, centers=3, cluster_std=0.5, random_state=100)
colors = ['red', 'green', 'blue']
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 8))
for i in range(3):
plt.scatter(dataset_x[dataset_y == i, 0], dataset_x[dataset_y == i, 1], color=colors[i])
plt.show()
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(dataset_x, dataset_y)
x = np.linspace(-15, 15, 300)
plt.figure(figsize=(12, 8))
plt.xlim(-20, 20)
plt.ylim(-20, 20)
for i in range(len(lr.coef_)):
plt.scatter(dataset_x[dataset_y == i, 0], dataset_x[dataset_y == i, 1], color=colors[i])
y = (-lr.intercept_[i] - lr.coef_[i, 0] * x) / lr.coef_[i, 1]
plt.plot(x, y, color=colors[i])
plt.show()
print(lr.score(dataset_x, dataset_y))
#----------------------------------------------------------------------------------------------------------------------------
Destek Vektör Makineleri (Support Vector Machine - SVM) son yı
temel olarak sı ı ı ı ı ı
Aslı ı ı ı
gerçek sı ı ı ı ı ı ı ı
dayandı ı ı ı ı ı ı ı ı ı ı
noktalar arası ı ı ı ı ı ı ı ı ı
kullanlmaktadı ı ı ı ı
uzaklı ı ı ı ı ı ı ı ı ı ı
"destek vektörleri (support vectors)" denilmektedir. Amaç destek vektörlerinin hyperplane'e toplam uzaklı ı ı
Terminolojide en yakı ı ı ı ı
hyperplane'nin elde edilmesidir.
Noktalar doğrusal olarak ayrı ı ı ı
eğilimindedir. Ancak bu durumda da destek vektör makinelerinin daha adil bir hyperplane oluşturduğu söylenebilir. Yani destek vektör makineleri
bu durumda da sı ı ı ı ı ı
kestirime etkisi olabilmektedir.
Aslı ı ı
ayrı ı ı ı ı ı ı
hale getirmektedir. Bu işlemin nası ı ı ı ı ı ı ı ı ı ı ı ı ı
İstatistiksel lojistik regresyonda böyle bir "kernel trick" yapı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Destek vektö makineleri için scikit-learn kütüphanesinde sklearn.svm modülü içerisinde SVM isimli bir sı ı
Sı ı ı ı ı
class sklearn.svm.SVC(*, C=1.0, kernel='rbf', degree=3, gamma='scale', coef0=0.0, shrinking=True, probability=False,
tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape='ovr', break_ties=False, random_state=None
Buradaki en önemli, parametre "kernel" parametresidir. Değişik veri kümeleri için değişik kernel trick yöntemleri uygulanabilmektedir.
Scikit-learan şu kernel trick yöntemlerini desteklemektedir: "linear", "poly", "rbf", "sigmoid", "precomputed". Bu parametrenin default değeri
"rbf" biçimindedir. "rbf" kernel doğrusal olarak ayrı ı ı ı
kernel istatistik lojistik regresyonda olduu gibi kernel trick uygulamadan ayrı ı
yapmaktadı ı ı ı ı
Nesne yaratı ı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı ı
score metodu önce predict işlemi yapı ı
Sı ı ı ı ı ı ı
b0 + b1x1 + b2x2 + ... + bnxn = 0 denkleminin katsayı ı ı ı
için geçerlidir. Sı ı ı ı ı
değerlerini vermektedir.
Aşağı ı ı
ve LogisticRegression işlemi yapı ı ı ı ı ı
Bu örnekte skor olarak şunlar elde edilmiştir:
SVC score: 0.96
Logistic score: 0.95
Görüldüğü gibi destek vektör makineleri %1 oranı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('logistic-points.csv', delimiter=',', skiprows=1)
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.svm import SVC
svc = SVC(kernel='linear')
svc.fit(dataset_x, dataset_y)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(dataset_x, dataset_y)
x = np.linspace(-4, 4, 1000)
y_svc = -(svc.intercept_ + svc.coef_[0, 0] * x) / svc.coef_[0, 1]
y_logistic = -(lr.intercept_ + lr.coef_[0, 0] * x) / lr.coef_[0, 1]
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 10))
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], marker='^')
plt.plot(x, y_svc)
plt.plot(x, y_logistic)
plt.scatter(svc.support_vectors_[dataset_y[svc.support_] == 0, 0], svc.support_vectors_[dataset_y[svc.support_] == 0, 1], color='red', marker='o')
plt.scatter(svc.support_vectors_[dataset_y[svc.support_] == 1, 0], svc.support_vectors_[dataset_y[svc.support_] == 1, 1], color='red', marker='^')
plt.legend(['Class-1', 'Class-2', 'Support Vector Machine', 'Logistic Regression', "Support Vectors"])
plt.show()
svc_score = svc.score(dataset_x, dataset_y)
logistic_score = lr.score(dataset_x, dataset_y)
print(f'SVC score: {svc_score}')
print(f'Logistic score: {logistic_score}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
SVC ve LogisticRegression işlemleri yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
from sklearn.datasets import make_blobs
dataset_x, dataset_y = make_blobs(n_samples=100, n_features=2, centers=2, center_box=[-5, 5])
from sklearn.svm import SVC
svc = SVC(kernel='linear')
svc.fit(dataset_x, dataset_y)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(dataset_x, dataset_y)
x = np.linspace(np.min(dataset_x[:, 0]), np.max(dataset_x[:, 0]), 1000)
y_svc = -(svc.intercept_ + svc.coef_[0, 0] * x) / svc.coef_[0, 1]
y_logistic = -(lr.intercept_ + lr.coef_[0, 0] * x) / lr.coef_[0, 1]
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 10))
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], marker='^')
plt.plot(x, y_svc)
plt.plot(x, y_logistic)
plt.scatter(svc.support_vectors_[dataset_y[svc.support_] == 0, 0], svc.support_vectors_[dataset_y[svc.support_] == 0, 1], color='red', marker='o')
plt.scatter(svc.support_vectors_[dataset_y[svc.support_] == 1, 0], svc.support_vectors_[dataset_y[svc.support_] == 1, 1], color='red', marker='^')
plt.legend(['Class-1', 'Class-2', 'Support Vector Machine', 'Logistic Regression', "Support Vectors"])
plt.show()
svc_score = svc.score(dataset_x, dataset_y)
logistic_score = lr.score(dataset_x, dataset_y)
print(f'SVC score: {svc_score}')
print(f'Logistic score: {logistic_score}')
#----------------------------------------------------------------------------------------------------------------------------
İç içe dairesel noktalar lojistik regresyon başarı ı ı ı
edebilmektedir. Aşağı
SVC "rbf" kernel ve LogisticRegression işlemleri uygulanmı ı ı ı
Ancak destek vektör makineleri %100'lük bir sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_circles
dataset_x, dataset_y = make_circles(n_samples=100)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
svc.fit(dataset_x, dataset_y)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(dataset_x, dataset_y)
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 10))
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], marker='^')
plt.legend(['Class-1', 'Class-2', 'Support Vector Machine', 'Logistic Regression'])
plt.show()
svc_score = svc.score(dataset_x, dataset_y)
logistic_score = lr.score(dataset_x, dataset_y)
print(f'SVC score: {svc_score}')
print(f'Logistic score: {logistic_score}')
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi biz destek vektör makinelerinde hangi kernel'ı ı ı ı ı
genel dağı ı ı ı ı
hakkı ı ı ı
SVC "rbf" kernel hemen her zaman LogisticRegression sı ı
Yapay Sinir ağları
Ancak ne olursa olsun uygulanacak yöntem verilerin dağı ı ı ı ı
alternatif yöntemlerin denenip en iyi sonucu veren yöntemin tercih edilmesi gerçerli bir yöntemdir.
Aşağı ı ı ı ı
uygulanı ı ı ı ı ı ı ı ı
çok belirgin değildir. Şu sonuçlar elde edilmiştir:
SVC accuracy: 0.725
LogisticRegression accuracy: 0.525
Neural Net accuracy: 0.73
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tabii destek vektör makineleri çok sı ı ı ı ı
üç sı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.datasets import make_blobs
dataset_x, dataset_y = make_blobs(n_samples=100, n_features=2, centers=3, cluster_std=5, random_state=12345)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
svc.fit(dataset_x, dataset_y)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(dataset_x, dataset_y)
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 10))
plt.scatter(dataset_x[dataset_y == 0, 0], dataset_x[dataset_y == 0, 1], marker='o')
plt.scatter(dataset_x[dataset_y == 1, 0], dataset_x[dataset_y == 1, 1], marker='^')
plt.scatter(dataset_x[dataset_y == 2, 0], dataset_x[dataset_y == 2, 1], marker='v')
plt.legend(['Class-1', 'Class-2', 'Class-3'])
plt.show()
svc_score = svc.score(dataset_x, dataset_y)
logistic_score = lr.score(dataset_x, dataset_y)
print(f'SVC score: {svc_score}')
print(f'Logistic score: {logistic_score}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de gerçek örnekler üzerinde SVC işlemini uygulayalı
Aşağı ı ı
- SVC ("rbf" kernel)
- LogisticRegression
- Naive Bayes
- Neural Net
Elde edilen sonuçlar şöyledir:
SVC accuracy score: 0.956140350877193
LogisticRegression accuracy score: 0.9649122807017544
GaussianNB accuracy score: 0.9210526315789473
NeuralNet accuracy score: 0.956140350877193
Burada istatistiksel lojistik regresyon en iyi sonucu vermiştir. Bunun nedeni noktaları ı ı ı ı
kaynaklanmaktadı ı ı ı ı
edilmiştir.
SVC accuracy score: 0.9649122807017544
LogisticRegression accuracy score: 0.9649122807017544
GaussianNB accuracy score: 0.9210526315789473
NeuralNet accuracy score: 0.956140350877193
Görüldüğü bini noktalar doğrusal olarak ayrı ı ı
iyi sonuç verme eğilimindedir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.svm import SVC
svc = SVC(kernel='linear')
svc.fit(scaled_training_dataset_x, training_dataset_y)
# LogisticRegression Solution
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
lr.fit(scaled_training_dataset_x, training_dataset_y)
# Naive Bayes Solution
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(training_dataset_x, training_dataset_y)
# Neural Net Solution
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='BreastCancer')
model.add(Dense(64, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=200, verbose=0)
from sklearn.metrics import accuracy_score
predict_result_svc = svc.predict(scaled_test_dataset_x)
score_svc = accuracy_score(test_dataset_y, predict_result_svc)
predict_result_lr = lr.predict(scaled_test_dataset_x)
score_lr = accuracy_score(test_dataset_y, predict_result_lr)
predict_result_gnb = gnb.predict(test_dataset_x)
score_gnb = accuracy_score(test_dataset_y, predict_result_gnb)
predict_result_nn = (model.predict(scaled_test_dataset_x) > 0.5).astype(int)
score_nn = accuracy_score(test_dataset_y, predict_result_nn)
print(f'SVC accuracy score: {score_svc}')
print(f'LogisticRegression accuracy score: {score_lr}')
print(f'GaussianNB accuracy score: {score_gnb}')
print(f'NeuralNet accuracy score: {score_nn}')
#----------------------------------------------------------------------------------------------------------------------------
Destek vektör makineleri genel olarak resim ve yazı ı ı ı ı ı ı
göre daha iyi bir performans gösterme eğilimindedir. Tabii yukarı
deneyip en iyi yöntemleri uygulamak gerekir.
Aşağı ı ı ı
LogisticRegresson accuracy score: 0.9203
Simple Neural Net accuracy score: 0.9789
SVC accuracy score: 0.9792
Görüldüğü gibi destek vektör makineleri "rbf" kernel ile iyi bir sonuç vermiştir. Tabii bu örnekteki yapay sinir ağı
iki saklı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df_training = pd.read_csv('mnist_train.csv')
df_test = pd.read_csv('mnist_test.csv')
training_dataset_x = df_training.iloc[:, 1:].to_numpy()
training_dataset_y = df_training.iloc[:, 0].to_numpy()
test_dataset_x = df_test.iloc[:, 1:].to_numpy()
test_dataset_y = df_test.iloc[:, 0].to_numpy()
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000)
lr.fit(training_dataset_x, training_dataset_y)
predict_result = lr.predict(test_dataset_x)
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(f'LogisticRegresson accuracy score: {score}')
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='MNIST')
model.add(Dense(256, activation='relu', input_dim=784, name='Hidden-1'))
model.add(Dense(128, activation='relu', name='Hidden-2'))
model.add(Dense(10, activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
hist = model.fit(training_dataset_x, ohe_training_dataset_y, epochs=20, batch_size=32)
import numpy as np
softmax_predict_result = model.predict(test_dataset_x)
predict_result = np.argmax(softmax_predict_result, axis=1)
score = accuracy_score(test_dataset_y, predict_result)
print(f'Simple Neural Net accuracy score: {score}')
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
svc.fit(training_dataset_x, training_dataset_y)
predict_result = svc.predict(test_dataset_x)
score = accuracy_score(test_dataset_y, predict_result)
print(f'SVC accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Destek vektör makineleri yanı ı ı ı ı
scikit-learn içerisindeki sklearn.svm modülünde bulunan SVR sı ı ı
kullanı ı ı ı ı ı ı ı ı
class sklearn.svm.SVR(*, kernel='rbf', degree=3, gamma='scale', coef0=0.0, tol=0.001, C=1.0, epsilon=0.1,
shrinking=True, cache_size=200, verbose=False, max_iter=-1)
Buradaki kernel paranetresi yine default durumda "rbf" olarak alı ı ı ı
Sı ı ı ı ı ı ı ı
hyperplane'e ilişkin katsayı ı ı ı ı
elde edilebilmektedir. Destek vektör makineleri lojistik olmayan regresyon problemlerine uygulanı ı ı ı
Lojistik olmayan regresyon modellerinde destek vektör makineleri LinearRegression, Lasso, Ridge, ElasticNet resgresyonları
çoğu kez daha kötü sonuç verme eğilimindedir. Ancak problemden probleme bu durum değişebilmektedir.
Aşağı ı ı ı ı
gerçekleştirilmiştir. Bu sonuçlar LinearRegression ve Lasso regresyonu sonuçları ı ı ı ı ı
SVR Mean Absolute Error: 3.7860139251590907
LinearRegression Mean Absolute Error: 3.578927993774414
Lasso Mean Absolute Error: 3.5663931369781494
#----------------------------------------------------------------------------------------------------------------------------
Doğrudan makine yapay zeka ve makine öğrenmesinin bir konusu olmasa da optimizasyon işlemlerinde sı ı ı
"doğrusal programlama (linear programming)" denilen bir konu vardı ı ı ı
programlama ile bir ilgisi yoktur. Üniversitelerde bu konu "yöneylem araştı ı
bölümlerinde gösterilmektedir.
Yöneylem araştı ı ı ı ı ı ı ı ı ı ı ı ı ı
geliştirilmiştir. Yöneylem araştı ı ı ı ı ı ı ı ı
alt alanları ı
- Doğrusal programalama
- Doğrusal olmayan programlama
- Tamsayı ı
- Graflar üzerinde optimizasyon işlemleri
- Ulaştı
- Çok amaçlı
Ancak alanı ı ı ı ı ı ı ı ı
bir fonksiyonun maximum ve minimum değerlerinin" araştı ı ı ı ı ı ı
birinci dereceden doğrusal fonksiyonlar olduğunu belirtmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal programalamada doğrusal kı ı ı ı ı
birleştiren doğurnun her noktası ı ı
özel noktalar vardı ı
Böylece sonsuz sayı ı ı ı ı
en çok tercih edileni "Simplex" denilen algoritmadı ı ı
denilmektedir. Bugün doğrusal karar modelleri genellikle "revised simplex" denilen algoritmayla çözülmektedir. Simplex algoritması
tüm uç noktaları ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal programalama problemleri genellikle gerçek yaşamdan hareketle sözel bir biçimde ortaya konmaktadı
sözel anlatı ı ı
modeli demekle onun matematiksel terimlerle biçimsel ifadesi kastedilmektedir.
Doğrusal programlamada ayarlanması
Kı ı ı
kı ı ı ı
a11 x1 + a12 x2 + a13 x3 + ... + a1n xn <= b1
a21 x1 + a22 x2 + a23 x3 + ... + a2n xn <= b2
a31 x1 + a32 x2 + a33 x3 + ... + a3n xn <= b3
...
am1 x1 + am2 x2 + am3 x3 + ... + amn xn <= bm
Burada toplam n değişken ve m tane kı ı ı ı ı ı ı
Ax <= b
Burada A katsayı
a11 a12 a13 ... a1n
a21 a22 a23 ... a2n
a31 a32 a33 ... a3n
...
am1 am2 am3 ... amn
x ise aşağı
x1
x2
x3
...
xn
b de bir sütun vektörüdür:
b1
b2
b3
...
bm
Doğrusal programlamada Ax <= b gibi bir kı ı ı ı ı ı
Genellikle bu fonksiyon Z biçiminde isimlendirilmektedir. Buna "amaç fonksiyonu (objective function)" denilmektedir. O halde
amaç fonksiyonun genel biçimi şöyledir:
Zmin ya da Zmax = c1 x1 + c2 x2 + c3 x3 + ... + cn xn
Bu amaç fonksiyonu da matrisel biçimde şöyle ifade edilebilir:
Zmin, Zmax = Cx
Burada C bir satı ı
c1 c2 c3 ... cn
Kı ı ı ı ı ı ı ı ı ı
değişken kı ı ı ı ı ı ı ı ı ı ı
x >= 0
Doğrusal karar modellerinin matematiksel gösterimi iki biçimde yapı ı
tük kı ı ı ı ı
şöyldir:
Ax <= b
x >= 0
Zmax = Cx
ya da
Ax >= b
x >= 0
Zmin = Cx
Standart biçim ise şöyledir:
Ax = b
x >= 0
Zmin ya da Zmax = Cx
Genellikle kanonik biçim karşı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğrual programalama modeline bir örnek şöle olabilir:
Bir çiftçinin buğday, mı ı ı ı ı
mı ı
daha fazla yer ayı ı ı ı ı ı ı
arazinin %30'undan daha fazla yer ayı ı ı ı ı
ayı ı
Şimdi problemin matematriksel modelini oluşturalı
x1: ekilecek buğdayı
x2: ekilecek mı ı ı
x3: ekilecek arpanı
Sorda bir en büyükleme yapı ı
Zmax = 150 x1 + 220 x2 + 180 x3
Eğer problemin kı ı ı ı ı ı ı ı ı ı ı ı
x1 <= 150 (buğday için en fazla 150 hektar yer ayrı ı ı
x3 <= 120 (arpa için en fazla 120 hektar yer ayrı ı ı
x1 >= 80 (buğday için en az 80 hektar yer ayrı ı ı
x2 <= 90 (mı ı ı ı ı
x1, x2, x3 >= 0 (negatif üretim yapı
Buradaki matematiksel model ne kanonik ne de standart biçime uygundur. Çünkü kı ı ı ı ı ı ı
Biz kı ı ı ı
x1 >= 80
ile
-x1 <= -80
aynı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Beslenem ya da diyet tarzı ı ı ı
verilebilir:
Bir kişi sadece et, süt ve yumurta yiyerek diyet yapmaktadı
10 mg D vitamini alması ı ı ı ı
100 mg C, 10 mg D ve 70 birim kolesterol vardı
kolesterol vardı ı
yumurtanı
programlama modelini oluşturunuz.
Burada yine önce değişkenleri isimlendirmek gerekir:
x1: Kilogram olarak tüketilecek et miktarı
x2: Litre olarak tüketilecek süt miktarı
x3: Düzine olarak tüketilecek yumurta miktarı
Problemde istenen en az para harcayarak diyet yapmaktı
Zmin = 800 x1 + 3700 x2 + 275 x3
Tabii hiçbir şey tüketmezsek para da harcamayı ı ı ı ı ı ı ı
x1 + x2 + 10 x3 >= 15 (A vitamini kı ı ı
100 x1 + 10 x2 + 10 x3 >= 30 (C vitamini, kı ı ı
10 x1 + 100 x2 + 10 x3 >= 10 (D vitamini kı ı ı
70 x1 + 50 x2 + 120 <= 80 (Kolesterol kı ı ı
Bu değerlerin hiçbiri negatif olamamaktadı
x1, x2, x3 >= 0
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python kullanarak doğrusal karar modellerinin çözümü için çeşitli kütüphaneler oluşturulmuştur. Bunlardan en yaygı ı ı
SciPy'ı ı ı
duracağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
SciPy i scipy.optimize paketinde bulunan linprog fonksiyonu doğrusal karar modelleri için yaygı ı ı
linprog fonksiyonunun parametrik yapı ı
scipy.optimize.linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='highs',
allback=None, options=None, x0=None, integrality=None)
linprog fonksiyonunu kullanabilmek için modelin aşağı ı
Zmin = Cx
Ax <= b ya da Ax = b
Yani modelin bir minimizasyon biçiminde olması ı ı ı ı
ise amaç fonksiyonunun negatifi alı ı ı ı ı ı ı
eşitsizliğin iki tarafı ı ı ı
Fonksiyonun parametreleri NumPy dizisi olmak zorundadı ı
parametresi "<=" kı ı ı ı ı ı ı ı ı ı ı ı
eki "upper bound" sözcüklerinden kı ı ı ı ı ı ı ı ı ı ı ı ı
b değerlerini belirtmektedir. method parametresi kullanı ı
Simplex yaygı ı ı ı ı ı
Fonksiyonun bounds parametresi değişkenler üzerindeki kı ı ı ı ı
Bu parametreye iki elemanlı ı ı
Örneğin:
[(0, 100), (10, None), (None, None)]
Buradaki None değerleri minimum için eksi sonnsuz, maksimum için artı ı
linprog fonksiyonu çağrı ı ı ı ı
fun özniteliği amaç fonksiyonunun değerini, success isimli bool türden öznitelik modelin optimal çözümünün oluğ olmadı ı ı
int türden status özniteliği çözümün başarı ı ı ı
varı ı ı ı ı ı ı ı
bilgileri bize birkaç satı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi aşağı ı ı
Kı ı
x1 + 2 x2 <= 6
2 x1 + x2 <= 8
-x1 + x2 <= 1
x2 <= 2
Zmax = 3 x1 + 2 x2
x1, x2 >= 0
Burada katsayı
c = np.array([-3, -2])
aub = np.array([[1, 2], [2, 1], [-1, 1], [0, 1]])
bub = np.array([6, 8, 1, 2])
Problem bir maksimizasyon problemi olduğu için negatif ile çarpı
elde edilecek amaç fonksiyonunun değeri de negatif ile çarpı ı ı
con: array([], dtype=float64)
fun: -12.666666666636761
message: 'Optimization terminated successfully.'
nit: 5
slack: array([9.95203919e-12, 1.99413819e-11, 3.00000000e+00, 6.66666667e-01])
status: 0
success: True
x: array([3.33333333, 1.33333333])
-----------
Maximum value: 12.666666666636761
Optimal values of variables: [3.33333333 1.33333333]
#----------------------------------------------------------------------------------------------------------------------------
from scipy.optimize import linprog
import numpy as np
c = np.array([-3, -2])
aub = np.array([[1, 2], [2, 1], [-1, 1], [0, 1]])
bub = np.array([6, 8, 1, 2])
result = linprog(c, aub, bub)
print(result)
print('-----------')
print(f'Maximum value: {-result.fun}')
print(f'Optimal values of variables: {result.x}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Kı ı
6 x1 + 4 x2 <= 120
3 x1 + 10 x2 <= 180
x1, x2 >= 0
Zmax = 45 x1 + 5 5x2
Burada katsayı
c = np.array([-45, -55])
aub = np.array([[6, 4], [3, 10]])
bub = np.array([120, 180])
Şu sonuçlar elde edilmiştir:
con: array([], dtype=float64)
fun: -1274.9999989391895
message: 'Optimization terminated successfully.'
nit: 4
slack: array([9.93566687e-08, 1.50681728e-07])
status: 0
success: True
x: array([ 9.99999999, 14.99999999])
-----------
Maximum value: 1274.9999989391895
Optimal values of variables: [ 9.99999999 14.99999999]
#----------------------------------------------------------------------------------------------------------------------------
from scipy.optimize import linprog
import numpy as np
c = np.array([-45, -55])
aub = np.array([[6, 4], [3, 10]])
bub = np.array([120, 180])
result = linprog(c, aub, bub)
print(result)
print('-----------')
print(f'Maximum value: {-result.fun}')
print(f'Optimal values of variables: {result.x}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Kı ı
x1 + x2 + 10 x3 >= 15
10 x2 + 10 x3 >= 30
100 x1 + 100 x2 + 10 x3 >= 10
70 x1 + 50 x2 + 120 x3 <= 80
x1, x2, x3 >= 0
Zmin = 2.25 x1 + 26 x2 + 0.21 x3
Şu sonuçlar elde edilmiştir:
con: array([], dtype=float64)
fun: 115.01558512059408
message: 'The algorithm terminated successfully and determined that the problem is infeasible.'
nit: 5
slack: array([ -4.44573877, 18.95368497, 507.92526722, -256.85002807])
status: 2
success: False
x: array([0.77252132, 4.35243834, 0.54293016])
-----------
Maximum value: 115.01558512059408
Optimal values of variables: [0.77252132 4.35243834 0.54293016]
#----------------------------------------------------------------------------------------------------------------------------
from scipy.optimize import linprog
import numpy as np
c = np.array([2.25, 26, 0.21])
aub = np.array([[-1, -1, -10], [0, -10, -10], [-100, -100, -10], [70, 50, 120]])
bub = np.array([-15, -30, -10, 80])
result = linprog(c, aub, bub)
print(result)
print('-----------')
print(f'Minimum value: {result.fun}')
print(f'Optimal values of variables: {result.x}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
Kı ı
x11 + x21 + x31 = 700
x12 + x22 + x32 = 300
x13 + x23 + x33 = 900
x14 + x24 + x34 = 600
x15 + x25 + x35 = 500
x11 + x12 + x13 + x14 + x15 <= 1200
x21 + x22 + x23 + x24 + x25 <= 1200
x31 + x32 + x33 + x34 + x35 <= 1200
x11, x12, x13, x14, x15, x21, x22, x23, x24, x25, x31, x32, x33, x34, x35 >= 0
Zmin = 8 x11 + 12 x12 + 9 x13 + 8 x14 + 0 * x15 + 11 x21 + 9 x22 + 16 x23 + 0 x24 + 8 x25 + 14 x31 + 0 x32 + 10 x33 + 9 x34 + 12 x35
Bu modelde 15 değişken vardı ı ı ı ı ı
c = np.array([8, 12, 9, 8, 0, 11, 9, 16, 0, 8, 14, 0, 10, 9, 12], dtype='float')
aub = np.array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]], dtype='float')
bub = np.array([1200, 1200, 1200])
aeq = np.array([[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], dtype='float')
beq = np.array([700, 300, 900, 600, 500])
Çözümden şu sonuçlar elde edilmiştir:
con: array([1.35525499e-06, 5.77492301e-07, 1.74413185e-06, 1.16082060e-06,
9.66381037e-07])
fun: 14599.999973663016
message: 'Optimization terminated successfully.'
nit: 6
slack: array([2.33400647e-06, 6.00000001e+02, 2.58888008e-06])
status: 0
success: True
x: array([6.99999998e+02, 4.39881404e-09, 4.00994684e-07, 1.23736337e-08,
4.99999999e+02, 2.84052512e-07, 4.48746365e-09, 8.47347710e-10,
5.99999999e+02, 2.08544710e-08, 8.93021817e-08, 2.99999999e+02,
8.99999998e+02, 1.82418488e-08, 3.59282936e-08])
-----------
Maximum value: 14599.999973663016
Optimal values of variables: [6.99999998e+02 4.39881404e-09 4.00994684e-07 1.23736337e-08
4.99999999e+02 2.84052512e-07 4.48746365e-09 8.47347710e-10
5.99999999e+02 2.08544710e-08 8.93021817e-08 2.99999999e+02
8.99999998e+02 1.82418488e-08 3.59282936e-08]
Burada çöümdeki değişken değerleri 0'a çok yakı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.optimize import linprog
import numpy as np
c = np.array([8, 12, 9, 8, 0, 11, 9, 16, 0, 8, 14, 0, 10, 9, 12], dtype='float')
aub = np.array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]], dtype='float')
bub = np.array([1200, 1200, 1200])
aeq = np.array([[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], dtype='float')
beq = np.array([700, 300, 900, 600, 500])
result = linprog(c, aub, bub, aeq, beq)
print(result)
print('-----------')
print(f'Maximum value: {result.fun}')
print(f'Optimal values of variables: {result.x}')
#----------------------------------------------------------------------------------------------------------------------------
PuLP kütüphanesi daha kolay anlaşı ı ı ı
aşağı ı
pip install pulp
Kütüphanein dokümantasyonu aşağı ı ı
https://coin-or.github.io/pulp/
PuLP kütüphanesinin kullanı ı ı ı
1) pulp.LpProblem sı ı ı ı ı ı ı ı
minimizasyon mu olduğu belirtilir. Örneğin:
lp = pulp.LpProblem('District_School_Problem', pulp.LpMaximize)
2) Modeldeki değişkenler pulp.LpVariable türünden sı ı ı ı
alt ve üst limitler verilir. Alt ve üst limitlerin default değerleri eksi sonsuz ve artı
x1 = pulp.LpVariable(name='x1', lowBound=0)
x2 = pulp.LpVariable(name='x2', lowBound=0)
3) Kı ı ı ı ı ı ı
operatör metotları ı
lp += x1 + 2 * x2 <= 6
lp += 2 * x1 + x2 <= 8
lp += -x1 + x2 <= 1
lp += x2 <= 2
4) Amaç fonksiyonu da benzer biçimde oluşturulmaktadı ı ı ı ı ı ı
olduğunu anlamaktadı
lp += 3 * x1 + x2
5) Modeli çözmek için LpProblem sı ı ı ı ı ı
lp.solve()
6) LpProblem sı ı ı ı ı ı
7) Çözüm elde edildikten sonra değişkenlerin değerleri pulp.value fonksiyonu ile elde edilebilmektedir. Amaç fonksiyonun değeri de
pulp.value(lp.objective) çağrı ı ı ı ı ı ı ı ı
constraints özniteliği ise kı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
Kı ı
x1 + 2 x2 <= 6
2 x1 + x2 <= 8
-x1 + x2 <= 1
x2 <= 2
Zmax = 3 x1 + 2 x2
x1, x2 >= 0
Programdan şu sonuçlar elde edilmiştir:
x1 = 3.3333333
x2 = 1.3333333
Maximum value = 12.666666500000002
#----------------------------------------------------------------------------------------------------------------------------
import pulp
lp = pulp.LpProblem('Model-1', pulp.LpMaximize)
x1 = pulp.LpVariable(name='x1', lowBound=0)
x2 = pulp.LpVariable(name='x2', lowBound=0)
lp += x1 + 2 * x2 <= 6
lp += 2 * x1 + x2 <= 8
lp += -x1 + x2 <= 1
lp += x2 <= 2
lp += 3 * x1 + 2 * x2
print(lp)
lp.solve()
print(f'x1 = {pulp.value(x1)}')
print(f'x2 = {pulp.value(x2)}')
print(f'Maximum value = {pulp.value(lp.objective)}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi aşağı
Kı ı
6x1 + 4x2 <= 120
3x1 + 10x2 <= 180
x1, x2 >= 0
Zmax = 45x1 + 55x2
Programdan şu sonuçlar elde edilmiştir:
x1 = 10.0
x2 = 15.0
Maximum value = 1275.0
#----------------------------------------------------------------------------------------------------------------------------
import pulp
lp = pulp.LpProblem('Model-2', pulp.LpMaximize)
x1 = pulp.LpVariable(name='x1', lowBound=0)
x2 = pulp.LpVariable(name='x2', lowBound=0)
lp += 6 * x1 + 4 * x2 <= 120
lp += 3 * x1 + 10 * x2 <= 180
lp += 45 * x1 + 55 * x2
print(lp)
lp.solve()
print(f'x1 = {pulp.value(x1)}')
print(f'x2 = {pulp.value(x2)}')
print(f'Maximum value = {pulp.value(lp.objective)}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de aşağı
Kı ı
x1 + x2 + 10 x3 >= 15
10 x2 + 10 x3 >= 30
100 x1 + 100 x2 + 10 x3 >= 10
70 x1 + 50 x2 + 120 x3 <= 80
x1, x2, x3 >= 0
Zmin = 2.25 x1 + 26 x2 + 0.21 x3
Programı ı ı ı ı
x1 = 0.0
x2 = 4.0
x3 = -1.0
Minimum value = 103.79
#----------------------------------------------------------------------------------------------------------------------------
import pulp
lp = pulp.LpProblem('Model-3', pulp.LpMinimize)
x1 = pulp.LpVariable(name='x1', lowBound=0)
x2 = pulp.LpVariable(name='x2', lowBound=0)
x3 = pulp.LpVariable(name='x3', lowBound=0)
lp += x1 + x2 + 10 * x3 >= 15
lp += 10 * x2 + 10 * x3 >= 30
lp += 100 * x1 + 100 * x2 + 10 * x3 >= 10
lp += 70 * x1 + 50 * x2 + 120 * x3 <= 80
lp += 2.25 * x1 + 26 * x2 + 0.21 * x3
print(lp)
lp.solve()
print(f'x1 = {pulp.value(x1)}')
print(f'x2 = {pulp.value(x2)}')
print(f'x3 = {pulp.value(x3)}')
print(f'Minimum value = {pulp.value(lp.objective)}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de aşağı
Kı ı
x11 + x21 + x31 = 700
x12 + x22 + x32 = 300
x13 + x23 + x33 = 900
x14 + x24 + x34 = 600
x15 + x25 + x35 = 500
x11 + x12 + x13 + x14 + x15 <= 1200
x21 + x22 + x23 + x24 + x25 <= 1200
x31 + x32 + x33 + x34 + x35 <= 1200
x11, x12, x13, x14, x15, x21, x22, x23, x24, x25, x31, x32, x33, x34, x35 >= 0
Zmin = 8 x11 + 12 x12 + 9 x13 + 8 x14 + 0 * x15 + 11 x21 + 9 x22 + 16 x23 + 0 x24 + 8 x25 + 14 x31 + 0 x32 + 10 x33 + 9 x34 + 12 x35
Programı ı ı ı ı
X12 = 0.0
x13 = 0.0
x14 = 0.0
x15 = 500.0
x21 = 0.0
x22 = 0.0
x23 = 0.0
x24 = 600.0
x25 = 0.0
x31 = 0.0
x32 = 300.0
x33 = 900.0
x34 = 0.0
x35 = 0.0
Minimum value = 14600.0
#----------------------------------------------------------------------------------------------------------------------------
import pulp
lp = pulp.LpProblem('Model-4', pulp.LpMinimize)
names = [f'x{i}{k}' for i in range(1, 4) for k in range(1, 6)]
variables = [pulp.LpVariable(name, lowBound=0) for name in names]
x11, x12, x13, x14, x15, x21, x22, x23, x24, x25, x31, x32, x33, x34, x35 = variables
lp += x11 + x21 + x31 == 700
lp += x12 + x22 + x32 == 300
lp += x13 + x23 + x33 == 900
lp += x14 + x24 + x34 == 600
lp += x15 + x25 + x35 == 500
lp += x11 + x12 + x13 + x14 + x15 <= 1200
lp += x21 + x22 + x23 + x24 + x25 <= 1200
lp += x31 + x32 + x33 + x34 + x35 <= 1200
lp += 8 * x11 + 12 * x12 + 9 * x13 + 8 * x14 + 0 * x15 + 11 * x21 + 9 * x22 + 16 * x23 + 0 * x24 + 8 * x25 + 14 * x31 + 0 * x32 + 10 * x33 + 9 * x34 + 12 * x35
print(lp)
lp.solve()
for variable in variables:
print(f'{variable.name} = {pulp.value(variable)}')
print(f'Minimum value = {pulp.value(lp.objective)}')
#----------------------------------------------------------------------------------------------------------------------------
Doğrusal karar modellerinde çok fazla değişken bulunabilmektedir. Bu durumda modelin bir dosyada oluşturulup yüklenmesi
işlemleri kolaylaştı ı ı ı ı ı ı ı ı ı
öğrenebilirsiniz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Gerçek dünyadaki pek çok problem bir graf problemi biçiminde ele alı ı ı
algoritmalar dünyası ı
Bir graf düğümlerden ve yollardan (düğümler arası ı ı
de denilmektedir. Yollar ise İngilizce'de "edge" biçiminde ifade edilmektedir. Graflar "yönlü (directed)" ya da "yönsüz (undirected)"
olabilmektedir. Eğer düğümler arası ı ı
bunlara da yönsüz graf denilmektedir. Yönsüz graf demek aslı
A ---- B
Burada A düğümünden B düğümüne de B düğümünden A düğümüne de bir yol olduğu varsaylı
her kavşak noktası ı ı
Graflarda düğümlere ve yollara bilgiler iliştirilebilmektedir. Örneğin düğümler şehirleri temsil ediyorsa onları ı
söz konusu olabilir. Yollara bilgi iliştirilmesiyle çok karşı ı ı ı ı
bilgisi iliştirilebilir.
Bir grafta tüm düğümlere tek bir yerden gelinebiliyorsa bu tür graflara "ağaç (tree)" da denilmektedir.
Yukarı ı ı ı ı ı
çeşitli algoritmalar uygulanmaktadı ı ı ı ı
uzaklı ı ı
graf algoritmaları
Graf algoritmaları ı ı ı ı ı ı ı
kullanı ı ı
"Boost Graph Library (BGL)" denilen kütüphanedir. Python'da çeşitli seçenkler söz konusudur. Ancak "Netwokx" ve "iGraph" denilen kütüphaneler
diğerlerinden daha fazla tercih edilmektedir. Biz de kurusumuzun bu bölümünde "networkx" kütüphanesini tanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
newtworx kütüphanesi aşağı
pip install networkx
Kürüphanenin dokümantasyonuna aşağı ı
https://networkx.org/documentation/stable/index.html
Genellikle programcı ı
import networkx as nx
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir graph oluşturmak için önce bir graph nesnesi yaratmak gerekir. Dört çeşit graph nesneleri vardı
Graph sı ı ı ı ı ı ı ı ı ı ı
MultiGraph ve MultiDiGraph sı ı ı
Graf nesnesi yaratı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph', date='26/02/2023')
#----------------------------------------------------------------------------------------------------------------------------
Grafa düğüm (vertex/node) eklemek için add_node metodu kullanı ı ı ı
Düğüm anahtarı
bilgi (networkx kütüphanesinde iliştirilen bilgilere "attribute" denilmektedir) iliştirilebilir. Bunun için isimli parametreler kullanı ı
Örneğin:
import networkx as nx
g = nx.Graph(title='Test Graph'')
g.add_node('A', count=10)
g.add_node('B', count=20)
Tabii düğümlere aynı ı
bilgiler içerir.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph')
g.add_node('A', count=100)
g.add_node('B', count=200)
g.add_node('C', count=300)
g.add_node('D', count=400)
g.add_node('E', count=500)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
bir nesne verilirse metot o nesneyi dolaşı ı ı ı ı ı
Aşağı ı ı ı
dolaşı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.DiGraph(title='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', count=30)
g.add_node('D', count=40)
g.add_nodes_from('FGH')
g.add_nodes_from(range(10))
print(g.nodes)
#----------------------------------------------------------------------------------------------------------------------------
add_nodes_from metodunda isimli parametreler girilirse bunlar eklenen tüm düğümlere iliştirilir. Aşağı
bilgilierinin herpsi 50 olacaktı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.DiGraph(title='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', count=30)
g.add_node('D', count=40)
g.add_nodes_from('FGH', count=50)
print(g.nodes)
#----------------------------------------------------------------------------------------------------------------------------
add_nodes_from metodunda aslı ı ı ı ı ı
düğüme iliştirilecek bilgileri belirten sözlük nesnesi olmalı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph')
g.add_node('A', count=100)
g.add_node('B', count=200)
g.add_node('C', count=300)
g.add_node('D', count=400)
g.add_node('E', count=500)
g.add_nodes_from([('I', {'count': 700}), ('J', {'count': 800})])
print(g.nodes)
#----------------------------------------------------------------------------------------------------------------------------
Graph sı ı ı ı ı
elde etmek için onun anahtarı ı ı
nodes örnek özniteliğinin bize verdiği nesne bir "view" nesnesidir. Yani bu nesne üzerinde değişiklik yapı ı ı ı
graf üzerinde değişiklik yapı ı ı ı ı ı
biz düğümlerin anahtarları ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph')
g.add_node('A', count=100)
g.add_node('B', count=200)
g.add_node('C', count=300)
g.add_node('D', count=400)
g.add_node('E', count=500)
g.add_nodes_from([('I', {'count': 700}), ('J', {'count': 800})])
d = g.nodes['D']
print(d) # {'count': 400}
for node in g.nodes:
print(node)
#----------------------------------------------------------------------------------------------------------------------------
nodes örnek özniteliği ile verilen nesne bir sözlük gibi davrandı ı
keys ve values uygulanabilir. get metodu yine anahtar yoksa ikinci parametresiyle belirtilen değere geri dönmektedir.
items metodu dolaşı ı ı ı ı
birinci elemanı ı ı ı ı
keys metodu bize anahtarlardan oluşan dolaşı ı
vermektedir. nodes örnek özniteliğinin data isimli bir metodu da vardı ı ı ı ı ı
demetler elde edilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph')
g.add_node('A', count=100)
g.add_node('B', count=200)
g.add_node('C', count=300)
g.add_node('D', count=400)
g.add_node('E', count=500)
g.add_nodes_from([('I', {'count': 700}), ('J', {'count': 800})])
d = g.nodes.get('Z', 'Not found')
print(d) # Not found
for t in g.nodes.items():
print(t)
for name, count in g.nodes.items():
print(f'{name} ---> {count}')
for key in g.nodes.keys():
print(key)
for value in g.nodes.values():
print(value)
#----------------------------------------------------------------------------------------------------------------------------
Grafa düğümler eklendikten sonra artı ı ı
metodu kullanı ı ı ı ı ı ı ı ı
aynı ı
g.add_edge('A', 'B', length=100, density=0.3)
Aslı ı ı ı
eklemektedir. Yani biz henüz bulunmayan düğümlere yol ekleyebiliriz.
Başlangı ı ı ı ı
graf türlerinden olması
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(title='Test Graph')
g.add_node('A', count=100)
g.add_node('B', count=200)
g.add_node('C', count=300)
g.add_node('D', count=400)
g.add_node('E', count=500)
g.add_edge('A', 'B', length=100)
g.add_edge('A', 'C', length=200)
g.add_edge('B', 'D', length=150)
g.add_edge('E', 'F', lenght=500) # F düğümü yok ama bu sı
#----------------------------------------------------------------------------------------------------------------------------
Oluşturulan grafı ı ı ı
algoritmaları ı ı ı ı
"kamada kawai" algoritması ı ı ı ı ı ı
bulundurulmayacağı ı ı
belirlemekte kullanı ı
Bunun default değeri 10'dur. font_size parametresi düğüm içerisindeki ve yollardaki yazı ı
node_color isimli parametre düğümlerin renklerini belirtir. Buraya tek bir renk girilirse tm düğümler aynı
Ancak bir renk dizisi girilirse bu durumda her düğüm ayrı
önce graf o algoritma fonksiyonuna verilir. Bu fonksiyon bir sözlük nesnesi geri döndürür. O sözlük nesnesi draw ya da draw_networkx
metotları ı
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24,
node_color=['yellow', 'green', 'red', 'magenta', 'yellow', 'pink', 'brown'], arrowsize=20)
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.DiGraph(ntitle='Test Graph')
g.add_node('A')
g.add_node('B')
g.add_node('C')
g.add_node('D')
g.add_edge('A', 'B', length=150)
g.add_edge('A', 'C', length=125)
g.add_edge('C', 'D', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=85)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('G', 'D', length=72)
g.add_edge('D', 'G', length=200)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color=['yellow', 'green', 'red', 'magenta', 'yellow', 'pink', 'brown'], arrowsize=20)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
draw_networkx_nodes (düğümleri çizer)
draw_networkx_edges (yolları
draw_networkx_labels (düğüm içerisindeki yazı ı
draw_networkx_edge_labels (yollardaki yazı ı
Aslı ı ı ı ı
yapabiliriz:
pos = nx.kamada_kawai_layout(g)
nx.draw_networkx_nodes(g, pos, node_size=1200, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'], alpha=0.5)
nx.draw_networkx_labels(g, pos, font_color='black', font_weight='bold')
nx.draw_networkx_edges(g, pos, width=2, node_size=1200)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.DiGraph(ntitle='Test Graph')
g.add_node('A')
g.add_node('B')
g.add_node('C')
g.add_node('D')
g.add_edge('A', 'B', length=150)
g.add_edge('A', 'C', length=125)
g.add_edge('C', 'D', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=85)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('G', 'D', length=72)
g.add_edge('D', 'G', length=200)
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color=['yellow', 'green', 'red', 'magenta', 'yellow', 'pink', 'brown'], arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'))
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Birden fazla yol da tek hamlede add_edges_from metoduyla grafa eklenebilir. Bu metodun birinci parametresi iki elemanlı
içeren bir liste olmalı ı
g.add_edges_from([('A', 'B'), ('A', 'C'), ('C', 'A'), ('B', 'D')])
Aslı ı
ilgili yola ilişkin bilgileri içeren sözlük nesneleri olmak zorundadı
g.add_edges_from([('A', 'B', {'length': 100}), ('A', 'C', {'length': 150}), ('C', 'D', {'length': 200}),
('B', 'D', {'length': 130}), ('C', 'B', {'length': 180}), ('D', 'A', {'length': 220})])
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(ntitle='Test Graph')
g.add_edges_from([('A', 'B', {'length': 100}), ('A', 'C', {'length': 150}), ('C', 'D', {'length': 200}), ('B', 'D', {'length': 130}), ('C', 'B', {'length': 180}), ('D', 'A', {'length': 220})])
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Bir graftaki yolları ı ı
bir nesne vermektedir. Biz graftaki belli bir yolun bilgilerini köşeli parantez ile ya da get metodu ile iki düğümün anahtarı ı
elde edebiliriz. Örneğin:
val = g.edges['A', 'B']
Burada biz A ile B düğümleri arası ı
Python'da aşağı
val = g.edges[('A', 'B')]
Yine edges örnek özniteliği ile biz get metodunu kullanabiliriz. Ancak metodun birinci parametresi iki elemanlı
olmalı ı
val = g.edges.get(('A', 'B'), 'Not found')
Burada A ve B düğümleri arası
yerine 'Not Found' yazı ı ı ı ı ı ı ı
keys bize yollara ilişkin düğümleri ikişerli demet biçiminde dolaşı
for t in g.edges.keys():
print(t)
Tabii yollara ilişkin düğümleri unpack yaparak da elde edebiliriz:
for node1, node2 in g.edges.keys():
print(node1, node2)
values metodu da bize yollara ilişkin bilgileri temsil eden sözlük nesnelerini dolaşmakta kullanabileceğimiz dolaşı
bir nesne vermektedir.
Örneğin:
for d in g.edges.values():
print(d)
Burada her dolaşı
Tabii edges elemanı ı ı
bulunduğu sözlük nesnesini dolaşı
for t in g.edges.items():
print(t)
Burada biz her dolaşı ı ı ı ı
ikinci elemanı
for (node1, node2), d in g.edges.items():
print(node1, node2, d)
#----------------------------------------------------------------------------------------------------------------------------
Yönlü graflar DiGraph sı ı ı ı ı ı ı ı ı ı ı ı ı
DiGraph sı ı ı ı ı ı ı ı ı
iki düğüm arası
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yönlü graflarda bir düğümden gidilebilecek düğümler Graph sı ı ı ı ı
metotları
for node in g.predecessors('A'):
print(node)
for node in g.successors('A'):
print(node)
Yönsüz graflarda bir düğüm ile bağlantı ı
bir sözlük gibi davranmaktadı
Örneğin:
for node in g.adj['B']:
print(node)
Burada A düğümünün doğrudan bağlı
ile aynı ı
Graph sı ı ı ı ı
Bazen grafta belli bir yolun olup olmadı ı ı ı ı ı ı ı ı ı
Bir grafta her düğüme giren ve çı ı ı ı ı ı ı ı
Bu metot parametreli bir biçimde de kullanı
Bir düğüme gelen yollar yönlü Graph sı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Graflardan düğümler ve yollar silinebilir. Graph sı ı ı ı ı
silmek için kullanı ı
bir yolu silmek için ise Graph sı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.DiGraph(ntitle='Test Graph')
g.add_edge('A', 'B', length=10)
g.add_edge('A', 'C', length=20)
g.add_edge('C', 'D', length=30)
g.add_edge('D', 'A', length=40)
g.add_edge('C', 'B', length=35)
g.add_edge('D', 'B', length=40)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
g.remove_edge('A', 'B')
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
2024-10-08 00:12:04 +03:00
Graf dünyası
2024-04-02 13:01:04 +03:00
0 "iki düğüm arası ı ı ı ı
01100
00110
01011
01000
10100
komşuluk matrisinden bir graf oluşturmak için from_numpy_aray fonksiyonu kullanı
Numpy dizisini, belirtir. create_using parametresi yaratı ı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
import numpy as np
a = np.array([[0, 1, 1, 0, 0], [0, 0, 1, 1, 0], [0, 1, 0, 1, 1], [0, 1, 0, 0, 0], [1, 0, 1, 0, 0]])
g = nx.from_numpy_array(a, create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
import numpy as np
a = np.random.randint(0, 2, (10, 10))
print(a)
g = nx.from_numpy_array(a, create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.circular_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
from_edgelist isimli fonksiyon bir ikili demetlerden oluşan bir Python listesi alı
Tabii burada düğüm anahtarları ı ı ı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
a = [(0, 1), (1, 3), (2, 4), (4, 2), (2, 1), (3, 4), (3, 0), (4, 1), (2, 3), ('A', 3), ('B', 0)]
print(a)
g = nx.from_edgelist(a, create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
from_pandas_adjecency ve from_pandas_edlist fonksiyonları ı ı
ters işi yapan to'lu biçimleri de vardı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir grafı ı ı
biçimdeki dosyadan okuma yapar:
a b c d
b c d
...
Burada satı ı ı ı ı ı
yukarı ı ı ı
Aşağı ı ı ı
A B C
C B A
B C D
D A C B
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.read_adjlist('test.txt', create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
read_multiline_adjlist fonksiyonu yukarı ı ı ı ı ı ı ı
olduğu bilgisi belirtilir. Örneğin:
a 2
b
c
d 1
e
Burada a düğümü aşağı ı ı ı ı ı ı ı ı
bağlantı ı ı
Aşağı ı ı ı
A 5
B
C
D
E
F
B 2
C
D
C 3
A
D
F
D 2
A
B
E 3
A
C
D
F 1
E
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.read_multiline_adjlist('test.txt', create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
read_edgelist isimli fonksiyon her satı ı ı ı ı
A B {'weight': 10}
B C {'weight': 30}
C D
...
Burada iki düğüm anahtarı ı ı ı
Aşağı ı
A B {'weight': 10}
B C {'weight': 30}
C A {'weight': 40}
D A {'weight': 50}
D A
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.read_edgelist('test.txt', create_using=nx.DiGraph)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos=pos, with_labels=True, node_size=1500, font_size=24, node_color='green', arrowsize=20)
nx.draw_networkx_edge_labels(g, pos=pos, font_size=20, edge_labels=nx.get_edge_attributes(g, 'length'),)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Graflar üzerinde test işlemleri için başkaları ı ı
isimli veri kümesidir. Bu veri kümesinin orijinal formatı ı ı
iki farklı
knut-miles.csv
knut-miles-weghted.csv
Birinci dosya read_adjlist fonksiyonuyla, ikinci dosya ise read_weighted_edgelist fonksiyonuyla okunmalı ı
düğümler arası ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bizim graf veri yapı ı ı ı ı ı ı ı ı
şehirler arası ı ı ı ı ı
Biz de bir şehirden diğerine en kı ı ı ı
Ancak bunları ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
En kı ı
ve yol uzunlukları ı ı
2024-04-19 00:21:20 +03:00
uzunluğu olduğunu belirlemekte kullanı ı
nlamı ı ı
2024-04-02 13:01:04 +03:00
ilgili yolda 'weight' isimli bir bilgi yoksa uzunluk 1 alı ı
iki düğüm arası ı ı ı
ilgili yolun uzunluğu hesaplanarak bulunabilir. Ancak bunun için de shortest_path_length isimli bir fonksiyon bulundurulmuştur.
Bu fonksiyonlarda kaynak düğüm belirtilmezse her düğümden hedefe giden en kı
Eğer hedef düğüm belirtilmezse bu duurmda kaynaktan her düğüme gidilen en kı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(name='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', lenght=30)
g.add_node('D', length=40)
g.add_edge('A', 'B', length=150)
g.add_edge('C', 'A', length=125)
g.add_edge('D', 'C', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=140)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('D', 'G', length=200)
g.add_edges_from([('H', 'I'), ('I', 'J'), ('H', 'A')], length=128)
g.add_edges_from([('J', 'H', {'length': 143}), ('J', 'C', {'length': 450}), ('E', 'C', {'length': 148})])
g.add_edge('G', 'I', length=200)
import matplotlib.pyplot as plt
figure = plt.gcf()
figure.set_size_inches((12, 12))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'])
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
result = nx.shortest_path(g, 'F', 'I', weight='length')
print(result)
length = nx.shortest_path_length(g, 'F', 'I', weight='length')
print(f'Shortest path from F to I: {length}')
all_shortest_path_from_F = nx.shortest_path(g, 'F', weight='length')
print(all_shortest_path_from_F)
all_shortest_path_to_F = nx.shortest_path(g, target='F', weight='length')
print(all_shortest_path_to_F)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(name='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', lenght=30)
g.add_node('D', length=40)
g.add_edge('A', 'B', length=150)
g.add_edge('C', 'A', length=125)
g.add_edge('D', 'C', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=140)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('D', 'G', length=200)
g.add_edges_from([('H', 'I'), ('I', 'J'), ('H', 'A')], length=128)
g.add_edges_from([('J', 'H', {'length': 143}), ('J', 'C', {'length': 450}), ('E', 'C', {'length': 148})])
g.add_edge('G', 'I', length=200)
import matplotlib.pyplot as plt
figure = plt.gcf()
figure.set_size_inches((12, 12))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'])
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
result = nx.shortest_path(g, 'F', 'I', weight='length')
print(result)
length = nx.shortest_path_length(g, 'F', 'I', weight='length')
print(f'Shortest path from F to I: {length}')
all_shortest_path_from_F = nx.shortest_path(g, 'F', weight='length')
print(all_shortest_path_from_F)
all_shortest_path_to_F = nx.shortest_path(g, target='F', weight='length')
print(all_shortest_path_to_F)
#----------------------------------------------------------------------------------------------------------------------------
En küçük örten ağaç (minimum spanning tree) gerçek hayatta da uygulaması ı
Burada graftaki tüm düğümlere erişen minimum uzunlukta bir ağaç elde edilmeye çalı ı ı
2024-04-19 00:21:20 +03:00
Gerçek hayatta bu problem bütün noktaları ı ı ı
kullaı ı
2024-04-02 13:01:04 +03:00
başka bir eve de döşeyebiliriz. Bir biçimde su tüm evlere girmelidir. Ancak bu yapı ı
Networkx kütüphanesinde en küçük örten ağaö için minimum_spannig_edges isimli bir fonksiyon bulundurulmuştur.
2024-04-19 00:21:20 +03:00
Aşağı ı
edgelist parametresi bir demet listesi biçiminde girilirse (ki zaten minimum_sapnning_edge fonksi,yonu öyle bir çı ı
2024-04-02 13:01:04 +03:00
bu durumda fonksiyon yalnı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(name='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', lenght=30)
g.add_node('D', length=40)
g.add_edge('A', 'B', length=150)
g.add_edge('C', 'A', length=125)
g.add_edge('D', 'C', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=140)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('D', 'G', length=200)
g.add_edges_from([('H', 'I'), ('I', 'J'), ('H', 'A')], length=128)
g.add_edges_from([('J', 'H', {'length': 143}), ('J', 'C', {'length': 450}), ('E', 'C', {'length': 148})])
g.add_edge('G', 'I', length=200)
import matplotlib.pyplot as plt
figure = plt.gcf()
figure.set_size_inches((12, 12))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'])
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
mst = nx.minimum_spanning_edges(g, weight='length')
list_mst = list(mst)
print(f'Minimum spanning tree: {list_mst}')
figure = plt.gcf()
figure.set_size_inches((10, 10))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'])
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
nx.draw_networkx_edges(g, pos, edgelist=list(list_mst), width=5, edge_color='red')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok karşı ı ı
düğümden hedef düğüme su taşı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
için maximum_flow isimli bir fonksiyon bulundurulmuştur. Bu fonksiyon bize kaynaktan hedefe toplam taşı ı ı
hangi düğümden hangi düğüme hangi miktarda su taşı ı ı ı ı
yerine elektirk tellerindeki kapasite ya da başka bir oldu da söz konusu olabilir. Problem gerçek hayattaki pek çok olguya uygulanabilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(name='My Graph')
g.add_node('A', count=10)
g.add_node('B', count=20)
g.add_node('C', lenght=30)
g.add_node('D', length=40)
g.add_edge('A', 'B', length=150)
g.add_edge('C', 'A', length=125)
g.add_edge('D', 'C', length=15)
g.add_edge('A', 'F', length=175)
g.add_edge('E', 'D', length=65)
g.add_edge('E', 'F', length=90)
g.add_edge('A', 'E', length=140)
g.add_edge('F', 'B', length=185)
g.add_edge('B', 'E', length=60)
g.add_edge('D', 'G', length=200)
g.add_edges_from([('H', 'I'), ('I', 'J'), ('H', 'A')], length=128)
g.add_edges_from([('J', 'H', {'length': 143}), ('J', 'C', {'length': 450}), ('E', 'C', {'length': 148})])
g.add_edge('G', 'I', length=200)
import matplotlib.pyplot as plt
figure = plt.gcf()
figure.set_size_inches((12, 12))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True, node_color=['yellow', 'brown', 'yellow', 'red', 'purple', 'gray', 'pink', 'green', 'magenta', 'red'])
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
maximum_flow = nx.maximum_flow(g, 'F', 'I', capacity='length')
print(maximum_flow)
#----------------------------------------------------------------------------------------------------------------------------
Graf boyama denilen graf algoritması ı ı
farklı ı ı ı ı ı
Ancak bu problemde boyama renklerinin bir maliyeti olduğu için minimum sayı ı ı ı ı
sayı ı ı
isimlerindee değerleri de renk indekslerinden oluşmaktadı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.Graph(name='My Graph')
d = [('A', 'B', {'length': 3}), ('A', 'D', {'length': 6}), ('A', 'E', {'length': 9}), ('B', 'C', {'length': 2}), ('B', 'D', {'length': 4}), ('B', 'E', {'length': 9}), ('C', 'D', {'length': 2}), ('C', 'F', {'length': 8}), ('C', 'G', {'length': 9})]
g.add_edges_from(d)
import matplotlib.pyplot as plt
figure = plt.gcf()
figure.set_size_inches((12, 12))
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
result = nx.equitable_color(g, 5)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Gerçek hayatta sı ı ı ı ı
denilen problemdir. Bu problemde bir satı ı ı ı ı
her şehre yalnı ı ı ı ı
çok alternatif rota vardı ı ı ı ı ı ı ı
bir biçimde karşı ı ı ı ı ı ı ı ı
problemlerin çözüm alanı ı ı ı
arası ı ı ı ı ı ı
Networkx kütüphanesinde gezgin satı ı
fonksiyonuyla gerçekleştirilmiştir. Fonksiyon grafı ı ı ı ı ı
bir önemi yoktur.
Aşağı ı ı ı ı ı ı ı ı ı ı ı ı
neresi olduğunun önemi yoktur.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
import numpy as np
g = nx.complete_graph(['A', 'B', 'C', 'D', 'E', 'F', 'G'])
for edge in g.edges:
g.edges[edge]['length'] = np.random.randint(0, 100)
import matplotlib.pyplot as plt
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold', font_color='red', label_pos=0.4)
plt.show()
from networkx.algorithms.approximation import traveling_salesman_problem
result = traveling_salesman_problem(g, weight='lenght')
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Networkx kütüphanesinde test amacı ı ı ı
ya da yollara bilgi iliştirmezler bilginin programcı ı ı
bir graf oluşturmaktadı ı ı ı ı
bir sayı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
import numpy as np
g = nx.complete_graph(10)
for edge in g.edges:
g.edges[edge]['length'] = np.random.randint(0, 100)
import matplotlib.pyplot as plt
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold',
font_color='red', label_pos=0.4)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
cycle_graph fonksiyonu n tane düğümden oluşan ve bir tur oluşturan bir fonksiyondur.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.cycle_graph(10)
import matplotlib.pyplot as plt
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold',
font_color='red', label_pos=0.4)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
star_graph fonksiyonu bir merkezden diğer düğümlere tek bir yolun olduğu bir graf üretir.
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.star_graph(10)
import matplotlib.pyplot as plt
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold',
font_color='red', label_pos=0.4)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
wheel_graph fonksiyonu çı ı
#----------------------------------------------------------------------------------------------------------------------------
import networkx as nx
g = nx.wheel_graph(10)
import matplotlib.pyplot as plt
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, node_size=1200, with_labels=True)
nx.draw_networkx_edge_labels(g, pos, edge_labels=nx.get_edge_attributes(g, 'length'), font_weight='bold',
font_color='red', label_pos=0.4)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Çeşitli dokümanlarda birtakı ı ı
en ünlüsü ve en yaygı ı ı ı ı ı ı ı
gördüğümüz grafa benzer çizimlerin çoğu bu utility programla yapı ı
Graphviz "dot" denilen mini bir dil kullanmaktadı ı ı
script oluşturur. Bunu bir dosya biçiminde save eder. Geleneksel olarak bir "dot" script dosyaları ı ı ı
2024-04-19 00:21:20 +03:00
"dot" verilmektedir. Bu dosyayı ı ı ı ı ı
çalı ı ı ı
2024-04-02 13:01:04 +03:00
dot -T png sample.gv -o sample.png
Örnek bir script dosyası
digraph G {
main -> parse -> execute;
main -> init;
main -> cleanup;
execute -> make_string;
execute -> printf
init -> make_string;
main -> printf;
execute -> compare;
compare -> cleanup;
}
graphviz utility'sinin dokümantasyonu aşağı ı ı
https://graphviz.org/documentation/
#----------------------------------------------------------------------------------------------------------------------------
Python'da graphviz utility'si ile programlama yoluyla işlem yapabilmek için graphviz isimli bir kütüphane bulundurulmuştur.
Tabii bu kütüphane Python'ı ı ı ı
pip install graphviz
Aşağı ı ı
https://graphviz.readthedocs.io/en/stable/manual.html
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python graphviz kütüphanesi aslı ı ı ı ı ı
Ktüphanenin ayrı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import graphviz
dot = graphviz.Digraph('Test Graph', format='png')
dot.node('A')
dot.node('B')
dot.node('C')
dot.edge_attr.update(arrowhead='vee', arrowsize='2')
dot.edge('A', 'B', label='100')
dot.edge('B', 'C', label='200')
dot.edge('A', 'D', label='300')
print(dot.source)
dot.render('test.dot')
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde kimi zaman tercih edilebilecek yöntemlerden biri de "karar ağaçları
Bu yöntemin özü oldukça basittir. Yöntemde sütuna dayalı ı
Sorunun doğru olduğu durumda ve yanlı
bir sütuna dayalı ı ı
bir ağaç elde edilir. Ağaç ikili (binary) bir ağaçtı ı ı ı
Bölme ve soru sorma konusundaki detaylar şöyledir:
- Bir soru bir sütuna dayalı ı ı
sayı ı ı
kadı ı ı ı ı
Soru şöyle olabilir: "X2 > 10". Burada da yine veri kümesi X2'nin 10'dan büyük olup olmaması ı ı
- Ağaçta her soru sonucunda veri kümesi iki parçaya ayrı ı ı
aynı ı
- Bir sütuna dayalı ı ı
sorusu aşağı
Pekiyi bu soruları ı ı
Ağacı ı ı ı ı ı ı
ağacı ı ı ı ı
Bu durumda maksimum bir derinlikte işlemler kesilebilir.
Pekiyi ağaç oluşturulduktan sonra kesitirim nası ı ı ı ı
sorularak yapraklara kadar ilerlenir. İlgili yaprağa ulaşı ı ı ı ı ı
yukarı ı ı ı
duruma bakı
Her ne kadar buradaki anlatı ı ı ı ı ı ı
benzer biçimde kullanı
Karar ağaçları ı ı ı ı ı
Ancak yukarı ı ı ı ı ı ı ı
Tabii yöntemin en önemli tarafı ı ı ı ı
bir kavram ile ilgilidir.
Karar ağaçları ı ı
kestirimi bu ağacı ı
Karar ağaçları ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn kütüphanesinde karar ağaçları ı ı
DecisionTreeClassifier sı ı ı ı ı ı ı ı ı
için kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
DecisionTreeClassifier sı ı ı ı ı ı
class sklearn.tree.DecisionTreeClassifier(*, criterion='gini', splitter='best', max_depth=None, min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, class_weight=None, ccp_alpha=0.0)
criterion parametresi bölme konusunda kullanı ı ı ı
iki algoritma tercih ediilmektedir: "gini impurity" ve "shannon entorpy". Bu parametre "gini" olarak girilirse (default) "gini impurity"
algoritması ı ı ı ı
girilebilir. Bu parametre girilmezse yapraklar homojen hale getirilene kadar bölme devam ettirilir. Ancak uygulamacı
belli bir maksimum derinlik belirleyebilir.
Nesne yaratı ı ı ı ı ı ı ı ı
isimli metodu predict işlemini yapı ı
Aşağı ı ı ı ı ı ı
2024-04-19 00:21:20 +03:00
Nesne yaratı ı
bu karar ağacı ı
kullanı ı ı
2024-04-02 13:01:04 +03:00
export_graphviz(dtc, out_file='breast-cancer.dot')
Sonra da örnekte oluşturulan u graphviz dosyası
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("breast-cancer-data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
"""
from sklearn.datasets import load_breast_cancer
bc = load_breast_cancer()
dataset_x = bc.data
dataset_y = bc.target
"""
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
dtc.fit(training_dataset_x, training_dataset_y)
predict_result = dtc.predict(test_dataset_x)
print(predict_result)
"""
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(score)
"""
score = dtc.score(test_dataset_x, test_dataset_y)
print(score)
from sklearn.tree import export_graphviz
export_graphviz(dtc, out_file='breast-cancer.dot')
import graphviz
dot = graphviz.Source.from_file(filename='breast-cancer.dot')
dot.view()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
Dolayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset_x = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
dataset_y = le.fit_transform(df.iloc[:, -1])
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
dtc.fit(training_dataset_x, training_dataset_y)
predict_result = dtc.predict(test_dataset_x)
print(predict_result)
"""
from sklearn.metrics import accuracy_score
score = accuracy_score(test_dataset_y, predict_result)
print(score)
"""
score = dtc.score(test_dataset_x, test_dataset_y)
print(score)
from sklearn.tree import export_graphviz
export_graphviz(dtc, out_file='iris.dot')
import graphviz
dot = graphviz.Source.from_file(filename='iris.dot')
dot.view()
#----------------------------------------------------------------------------------------------------------------------------
Karar ağaçları ı ı ı ı ı
Ancak lojistik olmayan regresyon problemlerinde karar ağaçları
daha kötü performans gösterme eğilimindedir. Karar ağaçları ı ı
eğitim veri kümesindeki y değerlerinden oluşmaktadı
değerler değil birer sı ı ı
elde edilmemektedir.
Karar ağaçları
sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
yapı ı
class sklearn.tree.DecisionTreeRegressor(*, criterion='squared_error', splitter='best', max_depth=None, min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, ccp_alpha=0.0)
Buradaki önemli parametreler DecisionTreeClassifer sı ı ı ı ı ı ı ı ı
işlşemi ve predict yapı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
yapraklardaki değerlerin eğitim veri kümesindeki y değerlerindne biri olduğu görülecektir. Yani biz bu yöntemle bir evin fiyatı ı
tahmin ederken her zaman zaten mevcut bir evin fiyatı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.tree import DecisionTreeRegressor
dtr = DecisionTreeRegressor()
dtr.fit(training_dataset_x, training_dataset_y)
predict_result = dtr.predict(test_dataset_x)
print(predict_result)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'Mean Absolute Error: {mae}')
score = dtr.score(test_dataset_x, test_dataset_y)
print(f'R^2: {score}')
from sklearn.tree import export_graphviz
export_graphviz(dtr, out_file='boston.dot')
import graphviz
dot = graphviz.Source.from_file(filename='iris.dot')
dot.view()
#----------------------------------------------------------------------------------------------------------------------------
Karar ağaçları ı ı ı ı ı ı
entropi düşer, homojenite azaldı
bu kümenin entropisi yüksektir. Entropi hesabı ı ı ı
ya da "Gini index'i" yöntemidir. Shannon entropisinin formülü şöyledir:
Toplam (-pi * log2 pi)
Karar ağaçları ı ı ı ı
itibaren yapı ı ı ı ı
İşte algoritma muhtemel bölme yerlerini tespit edip sanki o yerlerden bölme yapı ı ı ı
Burada yapı ı ı ı ı ı ı
olan yerden bölme yapı ı ı ı ı ı ı
entropilerinin düşük olması ı ı
O zaman algoritma şöyle davranmaktadı
1) Alternatif bölme noktaları ı
2) alternatif bölme noktaları ı ı
entropisini çı ı ı
Pekiyi sütun tespit edildikten sonra bölmenin hangi noktalardan yapı ı ı ı ı
kategorik ise genellikle tüm kategorik değerlerden bölme yapı ı
genellikle belli percentile noktaları
Pekiyi bölme için hangi sütunun seçileceğine nası ı
Mecburen her sütun için yukarı ı ı
sonra bölme yeri tespit edilmemektedir. Tüm sütunlar dikkate alı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi karar ağaçları ı ı ı
bazı ı ı
denenip bir kararı ı ı ı
- Karar ağaçları ı ı ı ı ı ı
Böyle bir gereksinim varsa karar ağaçları
- Bilgilerin aşama aşama elde edildiği durumlarda (doktor muayenesi gibi) olayı ı ı ı
Kişiler karar ağaçları
- Karar ağaçları ı ı
anlamı
- Karar ağaçları ı ı ı ı ı ı
bir grup doğru ile yapı ı
- İstatistiksel lojistik regresyon uç değerlerden karar ağaçları ı
alternatif olarak düşünülebilir.
- Sütunları ı ı
veri kümelerinde karar ağaçları ı ı ı
- Karar ağaçları ı ı ı
gerekir.
- Karar ağaçları ı ı
alabilmektedir. Yani karar ağaçları ı ı ı
ciddi boyutlara varavbilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde ve istatistikte "ensemble" yöntemler demekle "bir grup yöntemin bir arada kullanı ı ı ı
"Ensemble" sözcüğü "topluluk" gibi bir anlama gelmektedir. Dolayı ı
gibi isimlerle de ifade edilebilmektedir.
Ensemble yöntemler değişik kategorilere ayrı ı ı
duracağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Ensemble yöntemlerden en sı ı ı ı ı
problemlerinde kullanı ı ı ı ı ı
En yüksek oyu alan sı ı ı ı ı
söz konusu olsun. Biz de bu problemi alternatif olarak A, B, C, D ve E yöntemleriyle çözmüş olalı
kestirimde bu 5 yöntemi ayrı ı ı ı ı
A -> yes
B -> no
C -> yes
D -> no
E -> yes
Burada oylma sonucunda "yes" değeri "no" değerinden daha fazla oy almı ı
kararı ı
Oylama yönteminde tamamen farklı ı ı ı ı
sokulabilmektedir.
Aşağı ı ı ı ı ı
Bu veri kümesini Excel dosyası ı ı
https://archive.ics.uci.edu/ml/machine-learning-databases/00429/
Burada Excel dosyası ı
ondalı ı ı ı ı ı
DecisionTreeClassifier, GaussianNB, LogisticRegression yöntemleri ile problem çzöülmüş sonra kestirilecek değerler için
oylama yapı ı ı ı ı
yapı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
svc.fit(scaled_dataset_x, dataset_y)
# LogisticRegression Solution
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
lr.fit(scaled_dataset_x, dataset_y)
# Naive Bayes Solution
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(scaled_dataset_x, dataset_y)
# Decision Tree
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
dtc.fit(scaled_dataset_x, dataset_y)
from scipy.stats import mode
def voting_classifier(estimators, predict_data):
result = np.zeros((len(estimators), len(predict_data)))
for i, estimator in enumerate(estimators):
result[i] = estimator.predict(predict_data)
print(result[i])
return mode(result, axis=0, keepdims=True).mode
import numpy as np
predict_data = np.array([
[2, 17, 5.25, 3, 1, 63],
[2, 23, 11.75, 12, 3, 72],
[2, 27, 8.75, 2, 1, 6],
[2, 15, 4.25, 1, 1, 6]
])
scaled_predict_data = ss.transform(predict_data)
estimators = [gnb, svc, lr, dtc]
result = voting_classifier(estimators, scaled_predict_data)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Oylama yöntemi ortalama esası ı ı ı ı ı ı
sonucu 0 ya da 1 olarak değil 0 ile 1 arası ı ı
Çok sı ı ı
Ortalama yöntemi özellikle lojistik olmayan regresyon problemlerinde kullanı ı
çözeriz. Sonra kestirim aşaması ı
ortalaması ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Oylama yöntemi için scikit-learn içerisinde sklearn.ensemble modülünde VotingClassifier ve VotingRegressor sı ı ı
Sı ı ı ı ı ı ı
class sklearn.ensemble.VotingClassifier(estimators, *, voting='hard', weights=None, n_jobs=None, flatten_transform=True, verbose=False)
class sklearn.ensemble.VotingRegressor(estimators, *, weights=None, n_jobs=None, verbose=False)
Metotları ı ı
yönteme ilişkin sı ı ı ı ı ı
Yani biz istersek her yönteme farklı ı ı ı ı ı ı
VotingClassifier sı ı ı ı ı ı ı
"hard" (default değer) tamamen kestirilen sı ı ı ı ı ı ı ı ı ı
olası ı ı ı ı
Sı ı ı ı ı ı ı ı ı ı ı ı
VotingClassifier için "accuracy" değerini, VotingRegressor sı ı ı
Aşağı ı ı ı ı
uygulanmı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_dataset_x = ss.transform(dataset_x)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
from sklearn.ensemble import VotingClassifier
vc = VotingClassifier([('SVC', svc), ('LogisticRegression', lr), ('GaussianNB', gnb), ('DecisionTreeClassifier', dtc)])
vc.fit(scaled_dataset_x, dataset_y)
import numpy as np
predict_data = np.array([
[2, 17, 5.25, 3, 1, 63],
[2, 23, 11.75, 12, 3, 72],
[2, 27, 8.75, 2, 1, 6],
[2, 15, 4.25, 1, 1, 6]
])
scaled_predict_data = ss.transform(predict_data)
predict_result = vc.predict(scaled_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
elde edilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
from sklearn.ensemble import VotingClassifier
vc = VotingClassifier([('SVC', svc), ('LogisticRegression', lr), ('GaussianNB', gnb), ('DecisionTreeClassifier', dtc)])
vc.fit(scaled_training_dataset_x, training_dataset_y)
score = vc.score(scaled_test_dataset_x, test_dataset_y)
print(f'Accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı ı
Örnekte kestirim için LinearRegression, SVR ve DecisionTreeRegressor sı ı ı ı
İşlemler scikit-learn içerisindeki VotingRegressor sı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
dataset_df = df[df.iloc[:, 3] != '?']
dataset_ohe_df = pd.get_dummies(dataset_df, columns=[7])
dataset = dataset_ohe_df.to_numpy(dtype='float32')
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
from sklearn.svm import SVR
svr = SVR()
from sklearn.tree import DecisionTreeRegressor
dtr = DecisionTreeRegressor()
from sklearn.ensemble import VotingRegressor
vr = VotingRegressor([('LinearRegression', lr), ('SVR', svr), ('DecisionTreeRegressor', dtr)])
vr.fit(scaled_training_dataset_x, training_dataset_y)
r2_score = vr.score(scaled_test_dataset_x, test_dataset_y)
print(f'R^2: {r2_score}')
from sklearn.metrics import mean_absolute_error
predict_test_result = vr.predict(scaled_test_dataset_x)
mae_result = mean_absolute_error(test_dataset_y, predict_test_result)
print(f'Mean absolute error: {mae_result}')
#----------------------------------------------------------------------------------------------------------------------------
Çok kullanı
örnekleme yapı ı
kullanı ı ı ı
edilir. Örneğin veri kümemizde 1000 tane satı ı
veri kümesi oluşturabiliriz. Bu işleme "boostrap" işlemi denilmektedir. Bagging yönteminde bir tane sı ı ı
regresyon yöntemi seçilir. Sonra oluşturulan bu alt kümelerle bu model eğitilerek çok sayı ı ı ı
yöntemi olarak DecisinTreeClassifier kullanı ı ı
100 ayrı ı ı ı ı ı ı
Buradan bir oylama yaparak sonucu kestiririz.
Bagging yöntemi özellikle karar ağaçları ı ı ı ı ı ı
başka tahminleyicilerle kullanı ı ı ı ı
örneklemenin daha iyi sonuç verdiğini göstermektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bagging yöntemi için scikit-learn içerisinde sklearn.ensemble modülünde BaggingClassifier ve BaggingRegressor sı ı ı
Sı ı ı ı ı ı ı ı
class sklearn.ensemble.BaggingClassifier(estimator=None, n_estimators=10, *, max_samples=1.0, max_features=1.0,
bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None,
random_state=None, verbose=0, base_estimator='deprecated')
class sklearn.ensemble.BaggingRegressor(estimator=None, n_estimators=10, *, max_samples=1.0, max_features=1.0,
bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None,
random_state=None, verbose=0, base_estimator='deprecated')
Metotları ı ı
Bu parametre girilmezse default olarak BaggingClassifier için DecisionTreeClassifier, BeggingRegressor için DecisionTreeRegressor
sı ı ı ı ı ı ı ı ı ı
n_estimators parametreleri kaç tane örnek oluşturulacağı ı ı ı
oluşturulacağı ı ı ı ı ı
olarak verilebileceği gibi doğrudan bir sayı ı ı ı
da kullanı ı ı ı ı
(Yöntemleri bulanları ı ı
sütunları ı ı ı
biçiminde isimler verilmiştir. Ancak BaggingClassifier ve BaggingRegressor sı ı ı ı ı ı
seçebilmektedir. Yani aslı ı ı ı ı ı ı
parametreleri satı ı ı ı ı
Default durumda iadeli seçim uygulanmaktadı ı
mi iadesiz mi yapı ı ı ı
önemdedir. Default değerlerle geçilebilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
satı ı ı ı ı ı ı
yönteminin %2 civarı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("breast-cancer-data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
"""
from sklearn.datasets import load_breast_cancer
bc = load_breast_cancer()
dataset_x = bc.data
dataset_y = bc.target
"""
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier(random_state=45678)
dtc.fit(training_dataset_x, training_dataset_y)
score = dtc.score(test_dataset_x, test_dataset_y)
print(f'Single DecisionTreeClassifier score: {score}')
from sklearn.ensemble import BaggingClassifier
bc = BaggingClassifier(DecisionTreeClassifier(), 100, max_samples=0.70, random_state=13456)
bc.fit(training_dataset_x, training_dataset_y)
score = bc.score(test_dataset_x, test_dataset_y)
print(f'Bagging DecisionTreeClassifier score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
yöntemi uygulanmı ı
Single DecisionTreeRegressor Mean Absolute Error: 3.261764769460641
Single DecisionTreeRegressor R^2: 0.5655777616751758
BaggingRegressor Mean Absolute Error: 1.4358725589864394
BaggingRegressor R^2: 0.9256567952768898
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir ensemble yöntem grubuna da "stacking" denilmektedir. Bu yöntemde problem n tane tahminleyici ile çözülür. Kestirim yapı ı
bu modellerdne kestirilen değerler başka bir meta modele verilir. Kesitimin nihai sonucu bu metamodelin verdiği sonuç olur.
Tabii eğitim sı ı
Stacking yöntemi scikit-learn içerisindeki sklearn.ensemble modülünde bulunan StackingClassifier ve StackingRegressor sı ı ı
yoluyla uygulanabilmektedir. Sı ı ı ı ı ı ı
class sklearn.ensemble.StackingClassifier(estimators, final_estimator=None, *,
cv=None, stack_method='auto', n_jobs=None, passthrough=False, verbose=0)
class sklearn.ensemble.StackingRegressor(estimators, final_estimator=None, *, cv=None,
n_jobs=None, passthrough=False, verbose=0)
Metotları ı ı
Demetlerin birinci elemanı ı ı
Metotları ı
sı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
kullanı ı ı ı ı ı
LogisticRegression yöntemi kullanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.svm import SVC
svc = SVC(kernel='rbf')
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000000)
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
from sklearn.ensemble import StackingClassifier
sc = StackingClassifier([('SVC', svc), ('LogisticRegression', lr), ('GaussianNB', gnb), ('DecisionTreeClassifier', dtc)])
sc.fit(scaled_training_dataset_x, training_dataset_y)
score = sc.score(scaled_test_dataset_x, test_dataset_y)
print(f'Accuracy score: {score}')
import numpy as np
predict_data = np.array([
[2, 17, 5.25, 3, 1, 63],
[2, 23, 11.75, 12, 3, 72],
[2, 27, 8.75, 2, 1, 6],
[2, 15, 4.25, 1, 1, 6]
])
scaled_predict_data = ss.transform(predict_data)
predict_result = sc.predict(scaled_predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
kullanı ı ı ı ı
default olarak RidgeCV sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
dataset_df = df[df.iloc[:, 3] != '?']
dataset_ohe_df = pd.get_dummies(dataset_df, columns=[7])
dataset = dataset_ohe_df.to_numpy(dtype='float32')
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(training_dataset_x)
scaled_training_dataset_x = ss.transform(training_dataset_x)
scaled_test_dataset_x = ss.transform(test_dataset_x)
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
from sklearn.svm import SVR
svr = SVR()
from sklearn.tree import DecisionTreeRegressor
dtr = DecisionTreeRegressor()
from sklearn.ensemble import StackingRegressor
sr = StackingRegressor([('LinearRegression', lr), ('SVR', svr), ('DecisionTreeRegressor', dtr)])
sr.fit(scaled_training_dataset_x, training_dataset_y)
r2_score = sr.score(scaled_test_dataset_x, test_dataset_y)
print(f'R^2: {r2_score}')
from sklearn.metrics import mean_absolute_error
predict_test_result = sr.predict(scaled_test_dataset_x)
mae_result = mean_absolute_error(test_dataset_y, predict_test_result)
print(f'Mean absolute error: {mae_result}')
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir grup ensemble yöntemlere "boosting" denilmektedir. Boosting yönteminin de çeşitli varyasyonları ı ı
AdaBoosting ve GradientBoosting yöntemleridir.
AdaBoosting yönteminde problem bir tahminleyici ile çözülür. Buna "zayı
Sonra bu tahminleyicide yanlı ı ı
Burada problem yeniden çözülürken zayı ı ı ı ı ı ı
algoritması ı ı
tahmin edilmiş olan bazı ı ı ı ı
tahmin edilebilecektir. Üçünxü aşamda benzer yöntem devam ettirilir. Yani ikinci aşamda yanlı ı ı ı ı ı
yükseltilmektedir. Böylece üçüncü bir model oluşturulmuş olur. Bu biçimde n defa algoritma devam ettirilir. Böylece bu işlemin
sonucunda elimizde n tane farklı ı ı ı ı ı
bu n tane modele sokulur ve oylama yöntemi uygulanı
AdaBoosting yöntemi aslen sı ı ı ı ı
scikit-learn kütüphanesi içerisinde AdaBoostClassifier ve AdaBoosRegressor isimli iki sı ı ı ı ı ı
metotları
class sklearn.ensemble.AdaBoostClassifier(estimator=None, *, n_estimators=50, learning_rate=1.0, algorithm='SAMME.R',
random_state=None, base_estimator='deprecated')
class sklearn.ensemble.AdaBoostRegressor(estimator=None, *, n_estimators=50, learning_rate=1.0, loss='linear',
random_state=None, base_estimator='deprecated')
Metotları ı
sı ı ı ı ı ı ı ı ı ı
n_estimator parametresi kullanı ı ı ı ı ı ı ı
Diğer parametreler daha ayrı ı ı ı ı ı ı ı ı ı
AdaBoostClassifier için "accuracy" değerini, AdaBoostRegressor için "R^2" değerini hesaplamaktadı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
abc = AdaBoostClassifier(dtc, n_estimators=100)
abc.fit(training_dataset_x, training_dataset_y)
score = abc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
yönteminin DecisionTreeRegressor nesnesi ile kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
dataset_df = df[df.iloc[:, 3] != '?']
dataset_ohe_df = pd.get_dummies(dataset_df, columns=[7])
dataset = dataset_ohe_df.to_numpy(dtype='float32')
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
dtr = DecisionTreeRegressor()
abr = AdaBoostRegressor(dtr, n_estimators=100)
abr.fit(training_dataset_x, training_dataset_y)
score = abr.score(test_dataset_x, test_dataset_y)
print(f'R^2 score: {score}')
from sklearn.metrics import mean_absolute_error
predict_test_result = abr.predict(test_dataset_x)
mae_result = mean_absolute_error(test_dataset_y, predict_test_result)
print(f'Mean absolute error: {mae_result}')
#----------------------------------------------------------------------------------------------------------------------------
Boosting yöntemlerinden bir diğerine de "Gradient Boosting" denilmektedir. Bu yöntemde problem bir kez çözülür. Sonra gerçek değerlerle
tahmin edilen değerler arası ı ı ı
bir önceki değerler sanki gerçek değerlermiş gibi işlemler yürütülmektedir. Burada da yine her adı ı
En sonunda yine oylama yapı
scikit-learn içersinde Gradient Boosting işlemini yapan iki sı ı ı ı ı ı
__init__ metotları ı ı ı
class sklearn.ensemble.GradientBoostingClassifier(*, loss='log_loss', learning_rate=0.1, n_estimators=100, subsample=1.0,
criterion='friedman_mse', min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3,
min_impurity_decrease=0.0, init=None, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None,
warm_start=False, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001, ccp_alpha=0.0)
class sklearn.ensemble.GradientBoostingRegressor(*, loss='squared_error', learning_rate=0.1, n_estimators=100,
subsample=1.0, criterion='friedman_mse', min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0,
max_depth=3, min_impurity_decrease=0.0, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0,
max_leaf_nodes=None, warm_start=False, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001, ccp_alpha=0.0
Bu sı ı ı ı ı ı ı
sı ı ı
Sı ı ı ı ı ı ı ı
sayı ı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier()
gbc.fit(training_dataset_x, training_dataset_y)
score = gbc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('auto-mpg.data', delimiter=r'\s+', header=None)
df = df.iloc[:, :-1]
dataset_df = df[df.iloc[:, 3] != '?']
dataset_ohe_df = pd.get_dummies(dataset_df, columns=[7])
dataset = dataset_ohe_df.to_numpy(dtype='float32')
dataset_x = dataset[:, 1:]
dataset_y = dataset[:, 0]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=1234)
from sklearn.ensemble import GradientBoostingRegressor
gbr = GradientBoostingRegressor()
gbr.fit(training_dataset_x, training_dataset_y)
score = gbr.score(test_dataset_x, test_dataset_y)
print(f'R^2 score: {score}')
from sklearn.metrics import mean_absolute_error
predict_test_result = gbr.predict(test_dataset_x)
mae_result = mean_absolute_error(test_dataset_y, predict_test_result)
print(f'Mean absolute error: {mae_result}')
#----------------------------------------------------------------------------------------------------------------------------
RandomForest Yöntemi burada açı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Çok kullanı
TPOT kütüphanesi ağı ı ı ı
Kütüphaneye daha sonraları ı ı
kütüphaneyi kullanmaktadı ı ı
sı ı ı ı
TPOT çeşitli modelleri dener. Denemeler sı ı ı ı ı
için arka planda "genetik algoritmalar" kullanı ı
çalı ı ı
TPOT kütüphanesinin ana web sayfası ı ı
http://epistasislab.github.io/tpot/
TPOT pek çok işlemi kendisi yapmaktadı ı
gibi. TPOT kendis içerisinde genetik algoritmaları ı ı ı ı
nispeten basit bir arayüz sunmaktadı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı
Otomatik makine öğrenmesi araçları ı ı ı
için çokça bilgisayar zamanı ı ı ı
TPOT ile iyi bir model bulunduktan sonra elde edilen modele ilişkin Python kodları
TPOT'tan bağı ı ı ı
TPOT kütüphanesinin kurulumu şöyle yapı
pip install tpot
Aslı ı ı ı ı ı ı ı ı ı
kullanı ı
tpot data/mnist.csv -is , -target class -o tpot_exported_pipeline.py -g 5 -p 20 -cv 5 -s 42 -v 2
Eğer TPOT'u komut satı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
TPOT ile sı ı ı ı ı ı ı ı ı ı ı ı ı
class tpot.TPOTClassifier(generations=100, population_size=100,
offspring_size=None, mutation_rate=0.9,
crossover_rate=0.1,
scoring='accuracy', cv=5,
subsample=1.0, n_jobs=1,
max_time_mins=None, max_eval_time_mins=5,
random_state=None, config_dict=None,
template=None,
warm_start=False,
memory=None,
use_dask=False,
periodic_checkpoint_folder=None,
early_stop=None,
verbosity=0,
disable_update_check=False,
log_file=None
)
Buradaki generations, population_size, offspting_size, mutation_rate model aramsı ı
belirtmektedir. Genel olarak bu değerler yükseltildikçe modelin iyileşme olası ı ı
çözüm için çok zamanı ı ı ı ı
default değerlerde bı
Uygulamacı ı
bekleme zamı ı ı ı
TPOT da bu kadar süre içerisinde en uygun metofu bulmaya çalı ı ı
Ancak siz gerçek uygulamalarda bu değeri yükseltmelisiniz. Tabii bazen buradaki zamandan daha önce de model araması
Metodun max_eval_time_mins parametresi oluşturualan her bir modelin sı ı ı ı
parametre default değerle (5 dakika) geçilmektedir. Metdun verbosity parametresi TPOT çalı ı ı ı
belirtmektedir. Bu değer 0, 1, 2, 3 olabilir. Metodun config_dict paranmetresi uygulanacak modeller ve onları
uygulamacı ı ı ı ı ı ı ı ı
http://epistasislab.github.io/tpot/using/#customizing-tpots-operators-and-parameters
Metodun score parametresi test işleminde kullanı ı ı
Sı ı ı ı ı ı ı ı ı
ise test işlemini yapmaktadı ı ı ı ı ı
TPOT kategorik verilerin sayı ı ı
yapabilmektedir) Bunun için programcı ı
uygulamacı ı ı ı ı ı ı ı ı
Aşağı ı ı ı ı ı
burada maksimum süre olarak 5 dakika aldı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("breast-cancer-data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
"""
from sklearn.datasets import load_breast_cancer
bc = load_breast_cancer()
dataset_x = bc.data
dataset_y = bc.target
"""
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy scor: {score}')
import numpy as np
2024-10-08 00:12:04 +03:00
predict_data = np.array([[15.1,22.02,97.26,712.8,0.09056,0.07081,0.05253,0.03334,0.1616,0.05684,0.3105,0.8339,2.097,29.91,0.004675,
0.0103,0.01603,0.009222,0.01095,0.001629,18.1,31.69,117.7,1030,0.1389,0.2057,0.2712,0.153,0.2675,0.07873],
[11.52,18.75,73.34,409,0.09524,0.05473,0.03036,0.02278,0.192,0.05907,0.3249,0.9591,2.183,23.47,0.008328,0.008722,0.01349,0.00867,
0.03218,0.002386,12.84,22.47,81.81,506.2,0.1249,0.0872,0.09076,0.06316,0.3306,0.07036]])
2024-04-02 13:01:04 +03:00
predict_result = tpc.predict(predict_data)
print(predict_result)
tpc.export('automated-tpot-breastcancer.py')
#----------------------------------------------------------------------------------------------------------------------------
TPOTClassifier sı ı ı ı ı ı ı
ilişkin kaynak kodlar hemen kullanı ı ı ı ı
Yukarı ı ı
import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 1.0
exported_pipeline = ExtraTreesClassifier(bootstrap=False, criterion="gini", max_features=0.6000000000000001, min_samples_leaf=7, min_samples_split=16, n_estimators=100)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Burada üretilen kodda çeşitli düzenlemelerin yapı ı ı
- Kod içerisinde 'PATH/TO/DATA/FILE' ve 'COLUMN_SEPARATOR' kı ı ı
- Modelin ürettiği kodda hedeh sütun sayı ı ı ı ı
kendisi yapmaktadı ı ı ı ı ı ı ı
- Üretilen kodda target sütunu CSV dosyası ı ı ı ı ı ı
Tabii üretilen koddaki ası ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı ı
bazı ı ı ı ı ı ı ı
model elde edilmiş ve test edilmiştir. Export edilen model şöyledir:
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.impute import SimpleImputer
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
imputer = SimpleImputer(strategy="median")
imputer.fit(training_features)
training_features = imputer.transform(training_features)
testing_features = imputer.transform(testing_features)
# Average CV score on the training set was: 0.8399093863882596
exported_pipeline = make_pipeline(
MinMaxScaler(),
RandomForestClassifier(bootstrap=False, criterion="entropy", max_features=0.35000000000000003, min_samples_leaf=8, min_samples_split=4, n_estimators=100)
)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Buradan görüldüğü gibi TPOT bizim için karar ağaçları
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('titanic.csv')
dataset_y = df['Survived'].to_numpy()
df_dataset_x = df.drop(['PassengerId', 'Survived', 'Name', 'Ticket', 'Cabin'], axis=1)
df_dataset_x['Sex'] = (df_dataset_x['Sex'] == 'male').astype('int')
dataset_x = pd.get_dummies(df_dataset_x, ['Embarked']).to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy scor: {score}')
tpc.export('automated-tpot-titanic.py')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
kendisi yapmaktadı ı ı
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MaxAbsScaler, MinMaxScaler
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 0.9314285714285715
exported_pipeline = make_pipeline(
MinMaxScaler(),
MaxAbsScaler(),
MLPClassifier(alpha=0.01, learning_rate_init=0.01)
)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Buradan da görüldüğü gibi TPOT önce sütunları
tek saklı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy scor: {score}')
tpc.export('automated-tpot-cryotherapy.py')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
Species,Weight,Length1,Length2,Length3,Height,Width
Bream,242,23.2,25.4,30,11.52,4.02
Bream,290,24,26.3,31.2,12.48,4.3056
Bream,340,23.9,26.5,31.1,12.3778,4.6961
...
Bu veri kümesi aslı ı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı
dönüştürmeyi TPOT kendisi de yapabilmektedir.)
Veri kümesine aşağı ı
https://www.kaggle.com/datasets/aungpyaeap/fish-market
Export edilen model şöyledir:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 0.9686153846153847
exported_pipeline = LinearSVC(C=15.0, dual=False, loss="squared_hinge", penalty="l2", tol=1e-05)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('cryotherapy.csv', delimiter=';')
dataset_x = df.iloc[:, :-1].to_numpy()
dataset_y = df.iloc[:, -1].to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2)
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy scor: {score}')
tpc.export('automated-tpot-cryotherapy.py')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de MNIST örneğini TPOT ile çözmeye çalı ı ı ı
oluşuyordu. Biz de bu veri kümesini iki boyutlu bir dizi biçiminde oluşturup TPOTClassifier sı ı ı ı
TPOT tarafı
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 0.5617666666666666
exported_pipeline = GaussianNB()
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Buradan elde edilen sonuç %55 gibi kötü bir değerdir. Bunun bir nedeni model araması ı ı ı ı
yapı ı ı ı ı ı ı
Öte yandan resim sı ı ı ı
Programı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df_training = pd.read_csv('mnist_train.csv')
df_test = pd.read_csv('mnist_test.csv')
training_dataset_x = df_training.iloc[:, 1:].to_numpy()
training_dataset_y = df_training.iloc[:, 0].to_numpy()
test_dataset_x = df_test.iloc[:, 1:].to_numpy()
test_dataset_y = df_test.iloc[:, 0].to_numpy()
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy scor: {score}')
tpc.export('automated-tpot-mnist.py')
#----------------------------------------------------------------------------------------------------------------------------
TPOT ile lojistik olmayan regresyon işlemleri için TPOTRegressor sı ı ı ı ı ı ı ı
yapı ı
class tpot.TPOTRegressor(generations=100, population_size=100,
offspring_size=None, mutation_rate=0.9,
crossover_rate=0.1,
scoring='neg_mean_squared_error', cv=5,
subsample=1.0, n_jobs=1,
max_time_mins=None, max_eval_time_mins=5,
random_state=None, config_dict=None,
template=None,
warm_start=False,
memory=None,
use_dask=False,
periodic_checkpoint_folder=None,
early_stop=None,
verbosity=0,
disable_update_check=False)
Metodun parametrik yapı ı ı ı ı
zaman içerisinde bulunacağı ı ı ı ı ı ı ı ı
kategorik verilerin sayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı
TPOT yalnı ı ı
kütüphanesi de TPOT tarafı ı ı ı ı
export edilen model şöyledir:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: -9.49656867980957
exported_pipeline = XGBRegressor(learning_rate=0.1, max_depth=6, min_child_weight=3, n_estimators=100, n_jobs=1, objective="reg:squarederror", subsample=0.8500000000000001, verbosity=0)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Görüldüğü gibi burada xgboost kütüphanesinden faydalanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTRegressor
tpr = TPOTRegressor(max_time_mins=5, verbosity=3)
tpr.fit(training_dataset_x, training_dataset_y)
predict_result = tpr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'Mean Absolute Error: {mae}')
tpr.export('automated-tpot-boston.py')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de sağlı ı
"insurance.csv" ismiyle aşağı ı
https://www.kaggle.com/code/bbhatt001/predictors-of-medical-expenses/input
"insurance.csv" veri kümesinde "sex", "smoker" ve "region" sütunları ı ı
sayı ı ı ı
TPOT tarafı
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: -21051246.4
exported_pipeline = XGBRegressor(learning_rate=0.1, max_depth=2, min_child_weight=8, n_estimators=100, n_jobs=1, objective="reg:squarederror", subsample=0.55, verbosity=0)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Programı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('insurance.csv')
dataset_y = df['charges'].to_numpy(dtype='float32')
df_dataset_x = df.drop(['charges'], axis=1)
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df_dataset_x['sex'] = le.fit_transform(df_dataset_x['sex'])
df_dataset_x['smoker'] = le.fit_transform(df_dataset_x['smoker'])
df_dataset_x = pd.get_dummies(df_dataset_x, ['region'])
dataset_x = df_dataset_x.to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTRegressor
tpr = TPOTRegressor(max_time_mins=5, verbosity=3)
tpr.fit(training_dataset_x, training_dataset_y)
predict_result = tpr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'Mean Absolute Error: {mae}')
tpr.export('automated-tpot-insurance.py')
#----------------------------------------------------------------------------------------------------------------------------
İstatistiksel ve matematiksel yöntemlerle model araması ı ı
"auto-sklearn" isimli araçtı ı ı ı
karşı ı ı ı ı ı ı ı ı ı
lojistik olmayan regresyon problemlerinde daha başarı ı
Auto-sklearn kütüphanesi de scikit-learn kütüphanesi üzerine oturtulmuştur. Yani bu kütüphane de oluşturduğu modellerde sckit-learn
sı ı ı ı ı
Maalesef auto-sklearn kütüphanesi aşı ı ı ı ı ı ı ı ı ı ı ı ı
Bu nedenle auto-sklearn kütüphanesini ya Linux'ta (ya da biraz uğraşarak macOS sistemlerinde) çalı ı ı ı ı
Linux içerisinde "Anaconda" dağı ı ı ı ı ı ı
masaüstü görüntüsüne sahip olduğu için Windows'a alı ı ı ı ı
Auto-sklearn kütüphanesinin resmi sitesi aşağı
https://automl.github.io/auto-sklearn/master/#
Dokümanalara ve örnek programlara bu siteden erişilebilir.
Auto-sklearn kütüphanesi Linux'ta şöyle kurulabilir:
pip install auto-sklearn
Auto-sklearn kütüphanesi de tı ı ı
yapmaktadı ı ı
Ancak auto-sklearn de tı ı ı ı
uygulamacı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Auto-sklearn genel kullanı ı ı
vardı ı ı ı ı ı ı
regresyon problemleri için AutoSklearnRegressor sı ı ı ı ı ı ı
AutoSklearnClassifier sı ı ı ı ı ı
class autosklearn.classification.AutoSklearnClassifier(time_left_for_this_task=3600, per_run_time_limit=None,
initial_configurations_via_metalearning=25, ensemble_size: int | None = None,
ensemble_class: Type[AbstractEnsemble] | Literal['default'] | None = 'default',
ensemble_kwargs: Dict[str, Any] | None = None, ensemble_nbest=50, max_models_on_disc=50,
seed=1, memory_limit=3072, include: Optional[Dict[str, List[str]]] = None, exclude: Optional[Dict[str, List[str]]] = None,
resampling_strategy='holdout', resampling_strategy_arguments=None, tmp_folder=None, delete_tmp_folder_after_terminate=True,
n_jobs: Optional[int] = None, dask_client: Optional[dask.distributed.Client] = None, disable_evaluator_output=False,
get_smac_object_callback=None, smac_scenario_args=None, logging_config=None, metadata_directory=None,
metric: Scorer | Sequence[Scorer] | None = None, scoring_functions: Optional[List[Scorer]] = None,
load_models: bool = True, get_trials_callback: SMACCallback | None = None,
dataset_compression: Union[bool, Mapping[str, Any]] = True, allow_string_features: bool = True)
Tabii bu parametrelerin çok azı ı ı ı ı ı ı ı
belirlemek amacı
dakika cinsinden değil saniye cinsindendir. Metodun per_run_time_limit parametresi spesifik denenen bir model için maksimum harcanacak
zamanı
AutoSklearnClassifier nesnesi yaratı ı ı ı
metodu ile tahminleme yapı
Araştı ı ı
DataFrame nesnesi olarak vermektedir. show_models metodu araştı
elde edilen en iyi modelin başarı ı ı ı ı ı
Aşağı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("breast-cancer-data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from autosklearn.classification import AutoSklearnClassifier
aslc = AutoSklearnClassifier(time_left_for_this_task=5*60)
aslc.fit(training_dataset_x, training_dataset_y)
df_lb = aslc.leaderboard(top_k=3)
print(df_lb)
models_dict = aslc.show_models()
print(models_dict)
predict_result = aslc.predict(test_dataset_x)
print(predict_result)
score = aslc.score(test_dataset_x, test_dataset_y)
print(f'Accuracy Score: {score}') # 0.9649
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
kütüphanesinin sı ı ı
göstermektedir.
Aşağı ı ı ı ı ı ı ı ı
toplam 5 dakika zaman kullanması ı ı
TPOT Accuracy scor: 0.956140350877193
AutoSklearn Accuracy Score: 0.9649122807017544
Görüldüğü gibi auto-sklearn az da olsa TPOT'tan daha iyi sonuç vermiştir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv("breast-cancer-data.csv")
dataset_x = df.iloc[:, 2:-1].to_numpy()
dataset_y = np.zeros(len(df))
dataset_y[df['diagnosis'] == 'M'] = 1
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
# TPOT
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'TPOT Accuracy score: {score}') # 0.9561
# AutoSklearn
from autosklearn.classification import AutoSklearnClassifier
aslc = AutoSklearnClassifier(time_left_for_this_task=5*60)
aslc.fit(training_dataset_x, training_dataset_y)
score = aslc.score(test_dataset_x, test_dataset_y)
print(f'AutoSklearn Accuracy Score: {score}') # 0.9649
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
bir süre kullanı ı ı
TPOT Accuracy scor: 0.9666666666666667
AutoSklearn Accuracy Score: 0.9666666666666667
Görüldüğü gibi buradaki başarı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset_x = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
dataset_y = le.fit_transform(df.iloc[:, -1])
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTClassifier
tpc = TPOTClassifier(max_time_mins=5, verbosity=3)
tpc.fit(training_dataset_x, training_dataset_y)
score = tpc.score(test_dataset_x, test_dataset_y)
print(f'TPOT Accuracy scor: {score}')
# AutoSklearn
from autosklearn.classification import AutoSklearnClassifier
aslc = AutoSklearnClassifier(time_left_for_this_task=5*60)
aslc.fit(training_dataset_x, training_dataset_y)
score = aslc.score(test_dataset_x, test_dataset_y)
print(f'AutoSklearn Accuracy Score: {score}')
#----------------------------------------------------------------------------------------------------------------------------
Auto-sklearn ile lojistik olmayan regresyon problemleri için AutoSklearnRegressor sı ı ı ı ı ı ı ı
parametrik yapı ı
class autosklearn.regression.AutoSklearnRegressor(time_left_for_this_task=3600, per_run_time_limit=None,
initial_configurations_via_metalearning=25, ensemble_size: int | None = None,
ensemble_class: Type[AbstractEnsemble] | Literal['default'] | None = 'default', ensemble_kwargs: Dict[str, Any] | None = None,
ensemble_nbest=50, max_models_on_disc=50, seed=1, memory_limit=3072, include: Optional[Dict[str, List[str]]] = None,
exclude: Optional[Dict[str, List[str]]] = None, resampling_strategy='holdout', resampling_strategy_arguments=None,
tmp_folder=None, delete_tmp_folder_after_terminate=True, n_jobs: Optional[int] = None,
dask_client: Optional[dask.distributed.Client] = None, disable_evaluator_output=False, get_smac_object_callback=None,
smac_scenario_args=None, logging_config=None, metadata_directory=None, metric: Scorer | Sequence[Scorer] | None = None,
scoring_functions: Optional[List[Scorer]] = None, load_models: bool = True, get_trials_callback: SMACCallback | None = None,
dataset_compression: Union[bool, Mapping[str, Any]] = True, allow_string_features: bool = True)
Görüldüğü metodun çok fazla parametresi vardı ı
time_left_for_this_task parametresidir. Bu parametre sı ı ı ı ı ı ı ı
Sı ı ı ı ı ı ı ı ı ı ı ı
score metodu ile de regresyonun başarı
başarı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı
değeri elde edilip yazdı ı ı ı ı ı ı ı ı
Elde edilen değerler şöyledir:
TPOT Mean Absolute Error: 2.407825001548432
AutoSklearn Mean Absolute Error: 2.3694112300872803
Burada auto-sklearn biraz daha iyi bir sonucun elde edilmesine yol açmı ı ı
kütüphanenin performansları ı ı ı ı ı
Genetik algoritmalarda iyi bir soncun elde edilmesi için nispeten daha fazla zamana ihtiyaç vardı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('housing.csv', delimiter=r'\s+', header=None)
dataset_x = df.iloc[:, :-1].to_numpy(dtype='float32')
dataset_y = df.iloc[:, -1].to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTRegressor
tpr = TPOTRegressor(max_time_mins=5, verbosity=3)
tpr.fit(training_dataset_x, training_dataset_y)
predict_result = tpr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'TPOT Mean Absolute Error: {mae}')
from autosklearn.regression import AutoSklearnRegressor
aslr = AutoSklearnRegressor(time_left_for_this_task=5*60)
aslr.fit(training_dataset_x, training_dataset_y)
predict_result = aslr.predict(test_dataset_x)
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'AutoSklearn Mean Absolute Error: {mae}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
TPOT ve auto-sklearn uygulanmı ı ı ı
TPOT Mean Absolute Error: 2281.1085680343954
AutoSklearn Mean Absolute Error: 1955.048485072691
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('insurance.csv')
dataset_y = df['charges'].to_numpy(dtype='float32')
df_dataset_x = df.drop(['charges'], axis=1)
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df_dataset_x['sex'] = le.fit_transform(df_dataset_x['sex'])
df_dataset_x['smoker'] = le.fit_transform(df_dataset_x['smoker'])
df_dataset_x = pd.get_dummies(df_dataset_x, ['region'])
dataset_x = df_dataset_x.to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from tpot import TPOTRegressor
tpr = TPOTRegressor(max_time_mins=5, verbosity=3)
tpr.fit(training_dataset_x, training_dataset_y)
predict_result = tpr.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f' TPOT Mean Absolute Error: {mae}')
from autosklearn.regression import AutoSklearnRegressor
aslr = AutoSklearnRegressor(time_left_for_this_task=5*60)
aslr.fit(training_dataset_x, training_dataset_y)
predict_result = aslr.predict(test_dataset_x)
mae = mean_absolute_error(test_dataset_y, predict_result)
print(f'AutoSklearn Mean Absolute Error: {mae}')
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde "pipeline (boru hattı ı ı
bazı ı ı ı ı
peşi sı ı
Bilindiği gibi scikit-learn kütüphanesi yapay sinir ağı
öğrenmesi işlemleri için oluşturulmuş bir kütüphanedir. İşte sckit-learn kütüphanesinde de bir dizi işlemler bir pipeline
biçiminde oluşturulabilmekte ve sanki bu bir dizi işlem tek bir işlemmiş gibi tek hamlede işleme sokulabilmektedir.
Yukarı ı ı ı ı ı ı ı
Sckit-learn içerisinde pipleine meknizaması ı ı ı ı ı ı ı
sı ı ı ı
Pipeline mekanizaması ı ı ı ı ı ı ı ı ı
türünden nesne oluşturmak için kullanı ı ı ı ı
işlem yapmak amacı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PipeLine sı ı ı ı ı ı ı ı ı
class sklearn.pipeline.Pipeline(steps, *, memory=None, verbose=False)
Burada ası ı ı ı
Demetlerin birinci elemanı ı ı ı
oluşmalı ı ı ı
Pipeline nesnesi oluşturulduktan sonra artı ı ı ı ı ı ı
aslı
pipeline = Pipeline(steps=[('MinMax Scaling', MinMaxScaler()), ('DBScan', KMeans(n_clusters=3))])
pipeline.fit(dataset)
Burada biz fit işlemi yapmakla aslı ı
kullanarak fit yapmı
Pipeline sı ı ı ı ı
yapar. Son estimator nesnesi üzerinde de predict işlemini yapar. Örneğin:
predict_result = pipeline.predict(predict_data)
Burada predcit_data üzerinde önce transform işlemi yapı ı ı ı ı
predict metoduna sokulacaktı
Görüldüğü gibi bu pipeline işleminde amaç peşi sı ı ı ı
"çokbiçimli (polymophic)" bir sı ı ı ı ı ı
metrotları ı
Pipeline sı ı ı ı ı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset = df.iloc[:, 1:-1].to_numpy()
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans
from sklearn.pipeline import Pipeline
pipeline = Pipeline(steps=[('MinMax Scaling', MinMaxScaler()), ('DBScan', KMeans(n_clusters=3))])
pipeline.fit(dataset)
import numpy as np
predict_data = np.array([[7.7, 3.0, 6.1, 2.3], [6.3, 3.4, 5.6, 2.4], [6.4, 3.1, 5.5, 1.8]])
predict_result = pipeline.predict(predict_data)
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Örneğin biz önce standart ölçekleme yapı ı ı ı
regresyon uygulayacak olalı
scaler = StandardScaler()
pca = PCA(n_componenets=5)
logistic = LogisticRegression(max_iter=10000, tol=0.1)
pipeline = Pipeline(steps=[("scaler", scaler), ("pca", pca), ("logistic", logistic)])
pipeline.fit(training_dataset_x, training_dataset_y)
Aşağı ı ı ı
önce MinMaxScaler işlemi, sonra PCA işlemi sonra da lojistik regresyon işlemi yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df_training = pd.read_csv('mnist_train.csv')
df_test = pd.read_csv('mnist_test.csv')
training_dataset_x = df_training.iloc[:, 1:].to_numpy()
training_dataset_y = df_training.iloc[:, 0].to_numpy()
test_dataset_x = df_test.iloc[:, 1:].to_numpy()
test_dataset_y = df_test.iloc[:, 0].to_numpy()
from sklearn.preprocessing import MinMaxScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
mms = MinMaxScaler()
pca = PCA(n_components=100)
lr = LogisticRegression(max_iter=1000)
from sklearn.pipeline import Pipeline
pipeline = Pipeline(steps=[('MinMaxScaler', mms), ('PCA', pca), ('LogisticRegression', lr)])
pipeline.fit(training_dataset_x, training_dataset_y)
score = pipeline.score(test_dataset_x, test_dataset_y)
print(score)
#----------------------------------------------------------------------------------------------------------------------------
Pipeline sı ı ı ı ı ı
transformer ve estimator nesnelerini almaktadı ı ı ı ı
Fonksiyon bize Pipeline nesnesi vermektedir. Fonksiyonun tek faydası
Fonksiyonun parametrik yapı ı
sklearn.pipeline.make_pipeline(*steps, memory=None, verbose=False)
Fonksiyon trasnformet ve estimator nesnelerini tek tek komut satı ı ı ı
mms = MinMaxScaler()
pca = PCA(n_components=100)
lr = LogisticRegression(max_iter=1000)
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(mms, pca, lr)
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df_training = pd.read_csv('mnist_train.csv')
df_test = pd.read_csv('mnist_test.csv')
training_dataset_x = df_training.iloc[:, 1:].to_numpy()
training_dataset_y = df_training.iloc[:, 0].to_numpy()
test_dataset_x = df_test.iloc[:, 1:].to_numpy()
test_dataset_y = df_test.iloc[:, 0].to_numpy()
from sklearn.preprocessing import MinMaxScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
mms = MinMaxScaler()
pca = PCA(n_components=100)
lr = LogisticRegression(max_iter=1000)
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(mms, pca, lr)
pipeline.fit(training_dataset_x, training_dataset_y)
score = pipeline.score(test_dataset_x, test_dataset_y)
print(score)
#----------------------------------------------------------------------------------------------------------------------------
Pipeline konusuyla ilgili olan çok kullanı ı ı ı ı ı ı ı ı
üzerinde hazı ı ı ı
2024-05-20 13:45:43 +03:00
sütununu "one-hot encoding" işlemine sokmak isteyelim. Bir sütununu da eksik veriler nedeniyle impute etmek isteyelim. Bu işlemi
2024-04-02 13:01:04 +03:00
ColumnTransformer sı ı ı ı ı ı ı ı ı ı ı ı
ColumnTransformer sı ı ı ı ı ı
class sklearn.compose.ColumnTransformer(transformers, *, remainder='drop', sparse_threshold=0.3, n_jobs=None,
transformer_weights=None, verbose=False, verbose_feature_names_out=True)
Metodun en önemli parametresi ilk parametresidir. Bu parametre "transformer" nesnelerinden oluşmaktadı ı
demetlerden oluşan bir liste biçiminde oluşturulmaktadı ı
Bu isim herhangi bir biçimde girilebilir. İkinci eleman transformer nesnesinin kendisini belirtmektedir. Üçüncü eleman veri kümesindeki
hangi sütunları ı ı
ilgili sütunlar üzerinde işlemler yapı ı ı ı ı ı ı
üzerinde işlem yapı ı ı ı ı
edilmektedir. Normal olarka bu parametre "drop" geçildiğinde yalnı ı ı
birleştirilerek sonuç oluşturulur. remainder parametresi "passthrough" geçilirse üzerinde hiç işlem yapı ı
bulundurulmaktadı
ColumnTransformer nesnesi yaratı ı ı ı ı ı ı
Her transformer nesnesinin fit_transform metodundan ürettiği değer sonrakine verilmektedir. Tabii fit_transform yerine önce fit sonra
transform işlemi de yapı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
X,Y,Z
a,12.3,red
a,3.4,green
b,5.9,red
c,nan,blue
c,4.9,red
b,nan,blue
a,8.2,blue
b,9.2,green
b,nan,red
a,6.45,blue
c,4.32,green
c,12,green
2024-05-20 13:45:43 +03:00
Burada bizim amacı ı ı
2024-04-02 13:01:04 +03:00
ColumnTransformer nesnesini şöyle oluşturabiliriz:
mean_imputer = SimpleImputer(strategy='mean')
frequent_imputer = SimpleImputer(strategy='most_frequent')
ohe = OneHotEncoder(sparse=False)
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('OneHotEncoder', ohe, [0, 2]),
('SimpleImputer (Mean)', mean_imputer, [1])],
remainder='drop')
2024-05-20 13:45:43 +03:00
Buarada önce 0 ve 2 numaralı ı
2024-04-02 13:01:04 +03:00
il ve ikinci işlemin sonuçları
Yukarı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('transformer-1.csv')
data = df.to_numpy()
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
mean_imputer = SimpleImputer(strategy='mean')
frequent_imputer = SimpleImputer(strategy='most_frequent')
ohe = OneHotEncoder(sparse=False)
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('OneHotEncoder-0', ohe, [0, 2]),
('SimpleImputer (Mean)-1', mean_imputer, [1])],
remainder='drop')
data_result = ct.fit_transform(data)
print(data_result)
#----------------------------------------------------------------------------------------------------------------------------
ColumnTransformer sı ı ı ı ı
fark aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
df = pd.DataFrame({'X': ['a', 'b', 'c', 'a', 'c'], 'Y': [3, 5, np.nan, 9, 2], 'Z': [1, 2, 3, 4, 5]})
data = df.to_numpy()
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
mean_imputer = SimpleImputer(strategy='mean')
ohe = OneHotEncoder(sparse=False)
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('OneHotEncoder', ohe, [0]),
('SimpleImputer', mean_imputer, [1])], remainder='drop')
data_result = ct.fit_transform(data)
print(data_result)
ct = ColumnTransformer([('OneHotEncoder', ohe, [0]),
('SimpleImputer', mean_imputer, [1])], remainder='passthrough')
data_result = ct.fit_transform(data)
print(data_result)
#----------------------------------------------------------------------------------------------------------------------------
Maalesef ColumnTransformer sı ı ı ı ı
2024-05-20 13:45:43 +03:00
sonucunu "one-hot encoding" işlemine sokmak isteyebiliriz. Ancak ColumnTransformer sı ı ı ı
2024-04-02 13:01:04 +03:00
Örneğin "transformer-2.csv" dosyası
X,Y,Z
a,12.3,red
a,3.4,green
b,5.9,red
c,nan,nan
c,4.9,red
b,nan,blue
a,8.2,green
b,9.2,green
b,nan,nan
a,6.45,blue
c,4.32,nan
c,12,blue
2024-05-20 13:45:43 +03:00
Burada bizim 0'ı ı
2024-04-02 13:01:04 +03:00
Bunu tek aşamada yapamamaktayı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('transformer-2.csv')
data = df.to_numpy()
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
mean_imputer = SimpleImputer(strategy='mean')
frequent_imputer = SimpleImputer(strategy='most_frequent')
ohe = OneHotEncoder(sparse=False)
from sklearn.compose import ColumnTransformer
ct1 = ColumnTransformer([('SimpleImputer (Mean)', mean_imputer, [1]),
('SimpleImputer (Most Frequent)', frequent_imputer, [2])],
remainder='passthrough')
data_result = ct1.fit_transform(data)
print(data_result)
ct2 = ColumnTransformer([('OneHotEncoder', ohe, [1, 2])],
remainder='passthrough')
data_result = ct2.fit_transform(data_result)
print(data_result)
#----------------------------------------------------------------------------------------------------------------------------
Tabii biz İki ColumnTransformer nesnesini Pipeline ile birbirine de bağlayabiliriz. Örneğin:
ct1 = ColumnTransformer([('SimpleImputer (Mean)', mean_imputer, [1]),
('SimpleImputer (Most Frequent)', frequent_imputer, [2])],
remainder='passthrough')
ct2 = ColumnTransformer([('OneHotEncoder', ohe, [1, 2])],
remainder='passthrough')
pipeline = make_pipeline(ct1, ct2)
data_result = pipeline.fit_transform(data)
print(data_result)
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('transformer-2.csv')
data = df.to_numpy()
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
mean_imputer = SimpleImputer(strategy='mean')
frequent_imputer = SimpleImputer(strategy='most_frequent')
ohe = OneHotEncoder(sparse=False)
from sklearn.compose import ColumnTransformer
ct1 = ColumnTransformer([('SimpleImputer (Mean)', mean_imputer, [1]),
('SimpleImputer (Most Frequent)', frequent_imputer, [2])],
remainder='passthrough')
ct2 = ColumnTransformer([('OneHotEncoder', ohe, [1, 2])],
remainder='passthrough')
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(ct1, ct2)
data_result = pipeline.fit_transform(data)
print(data_result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de "insurance" örneğini LinearRegression regresyon yoluyla çözerken için Pipeline mekanizması ı ı
dosyası ı
age,sex,bmi,children,smoker,region,charges
19,female,27.9,0,yes,southwest,16884.924
18,male,33.77,1,no,southeast,1725.5523
28,male,33,3,no,southeast,4449.462
33,male,22.705,0,no,northwest,21984.47061
32,male,28.88,0,no,northwest,3866.8552
2024-05-20 13:45:43 +03:00
Burada sex, smoker sütunları ı ı ı
2024-04-02 13:01:04 +03:00
sokulmalı ı ı ı ı ı
ct = ColumnTransformer([('OrdinalEncode', OrdinalEncoder(), [1, 4]),
('OneHotEncoder', OneHotEncoder(sparse=False), [5])], remainder='passthrough')
pipeline = make_pipeline(ct, MinMaxScaler(), LinearRegression())
Burada biz orijinal veri kümesinin 0'ı ı ı ı ı ı
bu iki sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
metodu bizim pipeline mekanizması ı
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('insurance.csv')
dataset_y = df['charges'].to_numpy(dtype='float32')
dataset_x = df.drop(['charges'], axis=1).to_numpy()
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.2, random_state=12345)
from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, MinMaxScaler
from sklearn.linear_model import LinearRegression
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('OrdinalEncode', OrdinalEncoder(), [1, 4]),
('OneHotEncoder', OneHotEncoder(sparse=False), [5])], remainder='passthrough')
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(ct, MinMaxScaler(), LinearRegression())
pipeline.fit(training_dataset_x, training_dataset_y)
predict_result = pipeline.predict(test_dataset_x)
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_dataset_y, predict_result)
print(mae)
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı ı
1) Denetimli Öğrenme (Supervied Learning)
2) Denetimsiz Öğrenme (Unsupervised Learning)
3) Pekiştirmeli Öğrenme (Reinforcement Learning)
Biz denetimli öğrenme ve denetimsiz öğrenmenin temel yöntemlerini uygulamalı
yöntemler grubunu inceleyeceğiz. Pekiştirme öğrenme makine öğrenmesinde ilginç bir konudur. Pekiştirmeli öğrenme yapay zeka kavramı ı
halk arası ı ı ı ı ı ı ı ı
Pekiştirmeli öğrenme psikolojideki "edimsel koşullanma (operant conditioning)" denilen kavramdan hareketle geliştirilmiştir. Edimsel
koşullanma canlı
Bu öğrenme biçiminde organizma bir eylemde bulunur. Bu eylem sonucunda hoşa giden bir durum oluşursa bu hoşa giden durumu yeniden oluşturabilmek için
organizma eylemi yineler. Böylece yinelenen eylem davranı ı ı ı
hoşuna gidecek uyaranlara "pekiştireç (reinforecer)" denilmektedir. Eylem ne kadar pekiştirilirse o kadar iyi öğrenilir.
Pekiştireçler bir ödelül (reward) niteliğindedir. Örneğin çocuk arzu edeilen bir davranı ı ı
o davranı ı ı
psikolog tarafı ı ı ı ı
Ancak kuramı ı ı ı
Skinner konunun epey ayrı ı ı ı ı ı ı
şekillendirmede önemini göstermiştir. Skinner'a göre iki tür pekiştireç vardı
organizamaya haz veren uyaranlardı ı ı
Hem pozitif hem de negatif pekiştirilecek sonuçta organizma için daha iyi bir durum sağlarlar. Örneğin arabalarda emniyet kemeri takı ı ı
bir ses çı ı ı ı
bir uygulama haline gelir. Burada emniyet kemeri takı ı ı ı ı
uygulanması ı ı ı ı ı ı ı
pekiştirme tarifesi denilmektedir. Eğer pekiştireç belli miktar arzu edilen davranı ı ı ı
tarififesi denir. Eğer pekiştireç sabit zamanlarda veriliyorsa buna sabit zamanlı ı ı
tarife denilmektedir. Örneğin çalı ı
kişi tesadüfi belli zamanlarda ödül almaktadı ı
Bir çocuk her soruyu doğru bildiğinde ödül veriliyorsa ya da her n tane soruyu doğru bildiğinde ödül veriliyorsa bu türlü bir pekiştirmeye
"sabit oranlı
buna da "değişken oranlı
Ceza da bir çeşit edimsel koşullanma süreci oluşturmaktadı ı ı
Eylem karşı ı ı
iyi bir işlev görmemektedir. Çünkü ceza ortadan kalktı ı ı ı ı ı ı ı ı
gibi bir etkisi de vardı ı ı ı
"ikincil cezalar" denir. Yaramazlı ı
cezaya örnektir. Yani ikincil cezada aslı ı
cezalar yerine ikincil cezalar tercih edilmelidir.
Pekiyi edimsel koşullanma sonucunda öğrenilmiş bir davranı ı ı ı
verilmezse ne olur? Örneğin bir çocuk ağladı ı ı ı
ağlama davranı ı ı ı ı ı
oluşur. Yani öğrenilen davranı
Bazı ı ı ı ı
maruz kalabilmektedir. Örneğin etrafı ı ı ı ı ı ı
onun ödül aldı ı ı ı ı ı
denilmektedir.
2024-05-20 13:45:43 +03:00
Psikolojide organizmanı ı
2024-04-02 13:01:04 +03:00
hafı ı ı
Eskidne bilişsel faaliyetler "bilişsel psikoloji" içerisinde ele alı ı
ismine "bilişsel nörobilim (cognitive neuroscience)" denilen yeni bir bilim dalı ı ı ı ı ı
konuya yaklaşmaktadı ı ı ı ı ı ı ı ı
bulundurarak öğrenme bilişsel unsurlar da içermektedir. Halbuki edimsel koşullanmada bilişsel faaliyetler en az düzeydedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Makine öğrenmesinde pekiştirmeli öğrenme tamamen psikolojideki edimsel koşullanma süreci taklit edilerek modellenmektedir.
Makine (yazı ı ı ı ı
hedefi gerçekleştirmeyi öğrenir. Pekiştirmeli öğrenmede bazı ı ı ı ı ı
Yazı ı ı ı ı ı
denilmektedir. Sı ı ı ı ı ı ı
Çevre (Environment): Etmenin içinde bulunduğu ortama denilmektedir. Örneğin bir labirentte yol bulmaya çalı
labirent çevreyi oluşturmaktadı ı
Eylem (Action): Etmenin çevre içerisinde yaptı ı
yukarı ı ı ı
"eylem alanı
Durum (Status): Çevrenin içinde bulunduğu hale "durum" denilmektedir. Örneğin etmen bir hareket yaptı ı ı ı ı
Yani bu eylemde çevrede bir değişilik olmaktadı ı
artı ı ı ı ı
Ödül/Ceza (Reward/Penalty): Ödül ve ceza pekiştirmeli öğrenmenin önemli bir unsudurur. Eemen bir eylem yaptı ı
değişikliği olur. Bu durumda etmen bir ödül ya da ceza alabilir. Etmenin amacı ı ı
Yani pekiştirmeli öğrenmede bir eyleme ödül ya da ceza verilmezse öğrenme gerçekleşmez. Ödül ile ceza aynı ı
Bir eylem ödülle de tekrarlanabilir. Ceza almayarak da tekrarlanabilir.
Bir çevre (environment) deterministik olabilir ya da olmayabilir. Deterministik çevre demek çevrenin belli bir durumunda belli bir eylem yapı ı ı
ne olacağı ı ı
durumda belli bir eylem yapı ı ı ı
Bir çevre ayrı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı ı
Ancak etmen bir eylem yaptı ı ı ı ı
sürekli çevre ayrı ı ı
Bir çevredeki öğelerin durumları ı
Gözlemlenebilir bir çevrede sonsuz sayı ı
Eğer biz çevredeki öğelerin durumları ı
Bazen çevrenin bazı ı ı ı
çevreler denilmektedir. Çevredeki gözlemlenebilen bütün öğelere "gözlem alanı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiştirmeli öğrenme pek alanda kullanı
Etmen pekiştirmeli öğrenme ile yeni bir durum karşı ı ı
uyum sağlayabilmektedir. Pekiştirmeli öğrenme finansal sistemlerde de kullanı
sağlamak için etmenin ne yapması
uygulanabilmektedir. Benzer biçimde ne zaman ne kadar stok tutulacağı ı ı
öğrenme kullanı ı ı ı ı ı ı
Oyun programları
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiştirme öğrenme çalı ı ı ı
nedenle bu konuda çalı ı ı
çevreleri kendileir oluşturmak yerine bu hazı
Pekiştirmeli öğrenme için çevre oluşturan çeşitli simülatör yazı ı ı ı
denilen kurumun geliştirmiş olduğu "gym" kütüphanesidir. OpenAI son zamanlarda ChatGPT'nin son versiyonları
tarafı ı ı ı ı ı ı
yapay zeka çalı ı ı ı ı ı ı
işbirliğine de girişmiştir. Yine son zamanlarda gym simülatörleri OpenAI bünyesinden çı ı
gym ortamı ı ı ı ı ı ı
https://www.gymlibrary.dev/
OpenAI kurumunun gym kütüphanesi dı ı ı
Google'ı ı
gym ortamı ı
pip install gym
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
gym kütüphanesi içerisindeki simülatörlere "çevre (envirionment)" denilmektedir. Bu simülatörler çeşitli ana başlı ı
gruplandı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Cart Pole isimli simülatörde hareketli bir parçaya (araba) bağlı ı ı
dik tutulması ı ı
Yalnı ı ı ı
simülatörde etmen için iki eylem tanı ı ı
Bu simülatörde çevreden (environment) elde edilecek bilgiler dört tanedir: Arabanı ı ı ı
direğin o andaki açı ı ı ı ı ı ı ı ı
karar verilmektedir. Başka bir deyişle amaç direğin 12 dereceden daha az bir açı ı ı ı
eğer direk 12 derece açı ı ı ı ı ı
0.05 arası ı ı ı
1) Arabaya bağlı ı ı ı ı
2) Arabanı ı ı ı ı ı ı
3) 500 defadan fazla eylem yapı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
gym kütüphanesinin Mountain Car isimli simülatöründe yine bir araç vardı ı
bulunur. Bu araca soldan ya da sağdan sabit bir kuvvet uygulanabilmeketedir. Amaç bu aracı
erişmesini sağlamaktı ı ı ı ı ı
Arabaya uygulanacak üç eylem vardı ı
uygulandı ı ı
biçimde çözülebilmektedir. Arabaya önce soldan sürekli kuvvet uyguları ı ı ı ı
Bu durumda arabaya ters yönde kuvvet uyguları ı ı ı
kendi kendine öğrenilmesidir. Simülatörde araba her eylem sonucunda eğer hedefe (bayrağa) ulaşamamı ı
Ödül ile cezanı ı ı ı ı ı ı ı ı
Başlangı ı ı ı ı
1) Araba bayrak noktası ı ı ı
2) 200 eylemden dfaha fazla eylem uygulanmı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Taxi isimli simülatörde 5x5'lik bir matris içerisinde 4 tane durak vardı ı
çalı ı ı ı ı ı
duvarlar da vardı ı ı ı ı
Dört taksi durağı ı ı ı ı ı ı
bı ı ı ı ı ı ı
Bu similatörde etmenin (taksinin) 6 tane eylemi vardı ı ı
belli bir andaki durum sayı ı
Yolcu o sı ı ı ı
olabilir (4 seçenek). Dolayı ı ı
Simülatörün verdiği ödül/ceza puanları
- Eğer yolcu doğru yerde bı ı ı
- Eğer yolcu yanlı ı ı ı ı ı ı
- Her adı
Pekiştirmeli öğrenmede ödülün en büyüklenmesi ve cezanı ı
hedefine varmaya çalı ı
Bu oyunda bitme koşulu yoktur.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Frozen Lake (donmuş göl) isimli simülatörde 4x4'lük ya da 8x8'lik bir göl vardı
kı ı ı ı ı
Simülatör kaygan (slippery) ya da kaygan olmayan modda çalı ı ı
gitmektedir. Ancak kaygan modda etmen bir yöne gitmek isterken o yöne dik olan bir yöne de kayma neticesinde gidebilir. Örneğin
kaygan modda etmen sağa gitmek istesin. Sağ yöne dik olan yön yukarı ı ı ı ı
aşağı ı ı ı ı
1/3 olası ı
Bu simülatörde etmenin yapacağı ı ı ı ı
elde edilen durum bilgisi yani gözlem uzayı ı
Simülatör deliğe düşmede ve hedefe varamayan her adı ı ı ı
oyun bitmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lunar Lander (Aya inme) isimli simülatörde bir ay aracı ı ı ı ı ı ı
Etmen için (ay aracı ı ı ı ı ı ı
motorları ı ı ı
x ve y eksenindeki doğrusal hı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
yere deyip deymediği bilgisi (2 tane). Oyunun sonlanma koşulları ı
- Ay aracı ı ı ı ı
- Ay aracı ı ı ı ı ı ı ı ı
Simülatör eğer ay aracı ı ı ı
ödül verilmektedir. Eğer ay aracı ı ı ı
Eğer ay aracı ı ı ı ı ı ı ı ı
Sol ve sağ motorlar çalı ı ı ı ı ı ı
puan ödül verilmektedir.
Amaç en etkin biçimde ve en az ceza alacak biçimde (yani en yumuk ve hı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
gym kütüphanesinde bol miktarda atari oyunları ı ı ı ı
Bu oyunda hareket eden oyuncuyu 4 hayalet öldürmeye çalı ı ı ı ı
Büyük yopaklar oyuncuya kuvvet kazandı ı ı
yiyebilir hale gelir. Oyuncu hayalete yakalnı ı ı
hayaletlerin hı ı ı ı
Oyunun başka ayrı ı ı ı
Pac-Man simülasyonunda simülatörün konfigürasyonuna göre eylemler değişebilmektedir. Temel eylem oyuncunun dört yönden birine gitmesi ya da
hiçbir yere gitmemesidir. Oyunda gözlem uzayı ı ı ı
resmi bize her adı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tuğla kı ı ı ı ı ı ı
Amaç topla tüm tuğlaları ı ı ı
oyunu başlatan "fire" düğmesine basmak, hiçbir şey yapmamak. Oyun bize gözlemolarak yine o andaki durumu bir gri tonlamalı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
gym simülatörlerinde son zamanlarda bazı ı ı ı ı ı ı ı
olan 0.26 arası ı
dikkate alı
gym simülatörleri şu adı ı ı
1) Her simülatörün bir ismi vardı
make isimli fonksiyon simülatörün ismini ve bazı ı
denilen bir nesne verir. Çevre nesneleri farklı ı ı ı ı ı ı
import gym
env = gym.make('CartPole-v1)
Eskiden make işlemi sı ı ı
artı ı
env = gym.make('CartPole-v1, render_mode='human')
2) Çevre nesnesi elde edildikten sonra reset metodu çağrı
başladı ı
aranbanı ı ı ı ı ı ı ı ı ı
obs = env.reset()
3) Etmene eylem yaptı ı ı ı ı ı ı ı ı ı
parametreye sahiptir. Tabii step metotları
eylem 0 ya da 1'den oluşmaktadı ı ı ı ı ı ı ı ı ı
0.21 versiyonunda dörtlü bir demete geri dönerken 0.26'lı
0.21 versiyonundaki dörtlü demetin birinci elemanı ı
İkinci eleman eylem sonucunda elde edilecek ödülü belirtmektedir. (Tabii eğer bu değer pozitifse bir ödül, negatifse biz ceza söz konusudur.)
Demetin üçüncü elemanı
Demtin son elemanı ı ı ı
obs, reward, done, info = env.step(action)
Ancak kütüphanein 0.26'lı ı ı ı
trunacted diye isimlendirilen simülatörün erken sonlanı ı ı ı ı
obs, reward, done, truncated, info = env.step(action)
Eğer bu info değerleri ile ilgilenilmiyorsa okunabilirliği artı ı
obs, reward, done, _ = env.step(action)
step metodunun geri dönüş değerine ilişkin demete "truncation" elemanı ı
demete geri dönmekteydi.
step metodu bir kez değil bir döngü içerisinde çağrı ı ı ı ı
while True:
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
4) reset ve step işlemlerinden sonra simülatörün durumunu görüntülemek için çevre sı ı ı ı ı ı
Bu metot make fonksiyonunda belirtilen render_mode parametresine göre görüntüleme yapmaktadı
biçimindedir. gym kütüphanesi simülatörü görüntülemek için "pygame" isimli bir programı ı ı ı
bu programı ı
5) En sonunda simülatörü çevre sı ı ı ı
Simülatör çalı ı ı ı ı ı ı ı ı ı
Aslı ı ı ı ı ı ı
çevre nesnelerinin action_space isimli bir örnek özniteliği vardı
n örnek özniteliği toplam eylemlerin sayı ı ı ı ı ı
Örneğin biz simülatöre rastegele eylemleri şöyle yaptı
while True:
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
Simülatörün 0.26'lı ı ı ı ı ı ı ı
while True:
action = env.action_space.sample()
obs, reward, done, truncated, _ = env.step(action)
if done or truncated:
break
env.render()
Çevre nesnelerinin observation_space isimli örnek öznitelikleri yine bir space nesnesi vermektedir. Buradan elde edilen space
nesnesinin en önemli iki örnek özniteliği low ve high öznitelikleridir. low özniteliği bize gözlem alanı ı
vermektedir. high ise en tüksek değerlerini verir. Yine bu space nesnesinin sample metodu rastgele bir gözlem değerini bize verir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('CartPole-v1')
obs = env.reset()
env.render()
while True:
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
çalı ı ı ı ı ı ı ı ı
faydalanı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('MountainCar-v0', render_mode='human')
obs = env.reset()
env.render()
action = 2
counter = 0
while True:
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
if abs(obs[1]) < 0.001:
action = 0 if action == 2 else 2
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Taxi simülatörü yine make fonksiyonu ile aşağı ı ı
env = gym.make('Taxi-v3')
Daha sonra simülatör reset edilir ve oradan gözlem değerleri elde edilir. Taxi simülatöründe bir tane gözlem değeri vardı
bir sayı ı ı
obs = env.reset()
Burada simülatörün durumu tek bir değerler bize verşlmektedir. Bu değerin anlamı
arabanı ı ı ı ı ı ı ı
Burada arabanı ı ı
0, 1, 2, 3, 4 ile temsil edilmeketedir. Bu değerler sı ı ı ı ı
yine 0, 1, 2, 3 ile temsil edilir ve bunlar da R, G, Y, B ile eşleştirilmiştir.
Simülatörde durakları ı
R -> (0, 0)
G -> (0, 4)
Y -> (4, 0)
B -> (4, 3)
Bu değeri set eden ve reset eden çevre sı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı
durağı ı ı ı
env.encode(2, 2, 2, 1)
Out[55]: 249
Bu sayı
2 * 100 + 2 * 20 + 2 * 4 + 1 = 249
Dokğmante edilmemiş olsa da kaynak kodlara bakı ı ı
örnek özniteliğinin kullanı ı ı ı ı
belirli bir durumdan başlayabiliriz. Örneğin taksinin 2'nci satı ı ı
olması ı ı ı ı ı ı ı
import gym
env = gym.make('Taxi-v3')
obs = env.reset()
val = env.encode(2, 2, 1, 0)
env.env.s = val
env.render()
Çevre sı ı ı ı ı ı ı ı ı
Demetin ilk elemanı ı ı ı ı ı
dördüncü elemanı ı ı ı ı
elde ederiz:
import gym
env = gym.make('Taxi-v3')
obs = env.reset()
val = env.encode(2, 2, 1, 0)
row, col, passenger, drop = env.decode(val)
print(row, col, passenger, drop)
Burada aktardı ı ı ı ı
buradaki bilgiler simülatörür sonraki versiyonları ı ı ı
Programcı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Taksi simülatöründe taksiyi hareketli bir biçimde göstermek için şöyle bir yöntem kullanı ı
'ansi' girilirse render metodu ekrana bir şey basmaz ancak "ansi teminal karakterleri" denilen karakterlerden oluşan bir yazı
verir. Bu yazı ı ı ı ı ı ı ı ı
s = env.render(mode='ansi')
print(s)
Burada aslı ı ı ı ı
env.render()
render metodu zaten default durumda ekrana batı ı ı ı ı ı
başı ı ı ı ı ı ı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import time
import gym
env = gym.make('Taxi-v3')
obs = env.reset()
env.render()
for i in range(100):
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
s = env.render(mode='ansi')
print('\x1b[1J' + s, end='')
time.sleep(0.5)
#----------------------------------------------------------------------------------------------------------------------------
Frozenlake sümülatörü de benzer biçimde kullanı ı ı
Bu değer kişinin bulunduğu yerin "satı ı ı ı
4 tanedir:
0 --> Sola
1 --> Aşağı
2 --> Sağa
3 --> Yukarı
Simülatörden amaç etmene S noktası ı
hedefe vardı ı ı ı ı
Aşağı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import time
import gym
env = gym.make('FrozenLake-v1', map_name="8x8")
obs = env.reset()
env.render()
for i in range(100):
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
s = env.render(mode='ansi')
print('\x1b[1J' + s, end='')
if done:
break
time.sleep(0.5)
#----------------------------------------------------------------------------------------------------------------------------
MsPacman oyununa ilişkin simülatörün kullanı ı ı ı ı ı
pip install gym[atari]
pip install gym[accept-rom-license]
MsPacman oyununda her bir eylem sonrası
Bu görüntü bize (210, 160, 3) biçiminde RGB bir resim olarak verilmektedir. Örneğin biz simülatörü reset edip elde ettiğimiz
gözlem değerine ilişkin resmi aşağı
import gym
env = gym.make("MsPacman-v4")
obs = env.reset()
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.imshow(obs)
Simülatörde etmenin yapacağı ı
0 --> NOOP
1 --> UP
2 --> RIGHT
3 --> LEFT
4 --> DOWN
5 --> UPRIGHT
6 --> UPLEFT
7 --> DOWNRIGHT
8 --> DOWNLEFT
Ancak oyun belli bir süre başlamamaktadı ı
Aşağı ı ı ı ı ı ı
sonra hareketler başlamaktadı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make("MsPacman-v4", full_action_space=False)
obs = env.reset()
import matplotlib.pyplot as plt
for i in range(1000):
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
if done:
break
plt.figure(figsize=(10, 10))
plt.imshow(obs)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Tuğla kı ı
0 --> NOOP
1 --> FIRE
2 --> RIGHT
3 --> LEFT
Oyunda başlangı ı
Yine her eylemden sonra simülatör bize o andaki oyunun resimini (210, 160, 3) boyutları
Oyunda toplam 5 hak vardı ı
Oyunda tuğlalar kı ı ı ı ı ı ı ı ı
için Atari'nin orijinal dokümanları
https://atariage.com/manual_html_page.php?SoftwareID=889
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make("Breakout-v4")
obs = env.reset()
obs, reward, done, _ = env.step(1)
import matplotlib.pyplot as plt
for i in range(1000):
action = env.action_space.sample()
obs, reward, done, _ = env.step(action)
if done:
break
plt.figure(figsize=(10, 10))
plt.imshow(obs)
plt.show()
print('\x1b[1J')
#----------------------------------------------------------------------------------------------------------------------------
Pekiştirmeli öğrenmede kullanı ı ı ı ı ı ı ı
yöntemdir. Buradaki "Q" harfi "Quality (kalite)" sözcüğünden hareketle uydurulmuştur.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Q-Learning yönteminde ismine Q-Tablosu denilen bir tablo kullanı ı
Bu tablonun satı ı ı ı ı ı
etmenin içinde bulunduğu durum 5 farklı
Q-Tablosu şöyle olacaktı
A1 A2 A3
S1
S2
S3
S4
Burada matris 5x3 = 15 tane eleman içerecektir. Başlangı
A1 A2 A3
S1 0 0 0
S2 0 0 0
S3 0 0 0
S4 0 0 0
Ancak zamanla öğrenme gerçekleştiğinde tablo yavaş yavaş dolmaya başlar. Nihayetinde dolu bir tablo haline gelir. Örneğin:
A1 A2 A3
S1 0.2 0.5 0.3
S2 0.8 0.6 0.1
S3 0.2 0.7 0.2
S4 0.3 0.2 0.6
Q-Tablosunun dolmuş olduğunu varsayalı ı
Örneğin reset durumunda etmen S3 durumunda olsun. S3 satı ı
en kaliteli yani puanı ı ı
başka bir durum oluşacaktı ı ı
Bu kezmen yine A2 eylemini yapar. Şimdi artı ı
Bu durumda etmen en iyi eylem olan A1 eylemini gerçekleştirecektir. Özetle Q-Tablosu hangi durumdaki eylemin en iyi eylem olduğunu vermektedir.
Q-Learning yöntemini uygulayabilmek için bizim şu bilgilere gereksinimimiz vardı
- Ortamdaki tüm durumları
- Belli bir durumdaki eylemlerin neler olduğu bilgisine
- Q-Tablosunun nası
Q-Tablosu tipik olarak bir matris biçimindedir. Baştan seyrek (sparse) görünümdedir. Bazı ı
Bu durumda Q-Tablosunun bir matris biçiminde değil bir sözlük biçiminde oluşturulması
Belli bir ortamdaki tüm durumları ı ı ı
Belli bir durumsal özelliğin sürekli olması ı ı ı ı ı
haline getirilmesi gerekmektedir. Yani bizim sürekli durum özelliklerini ayrı
aracı ı ı ı ı ı ı ı ı ı
getirilip sonlu sayı ı ı ı ı ı ı
uzaklı ı ı ı ı ı ı ı ı
similatöründe arabanı ı ı ı ı ı ı ı
bölersek her 0.096'lı ı ı ı ı ı ı
CartPole simülatöründeki konum bilgisini 100 eşit parçaya böldüğümüzde biz her 0.096'lı ı ı ı
göre araba sı ı ı
kaybederiz. Ancak bu sefer de Q-Tablosunu büyütmüş oluruz.
Şimdi daha önce görmüş olduğumuz gym simülatörlerinde bu durum bilgisinin ve eylemlerin neler olacağı ı
- CartPole simülatöründe her eylem sonrası ı
aracı ı ı ı ı ı ı ı ı ı
satı ı ı ı ı
ayrı ı ı
direğin açı ı ı ı
Bu durumda Q-Tablosunun satı ı ı ı ı ı ı
Yani burada Q-Tablosunun 100 milyon satı ı ı ı ı
Yanı ı ı ı ı ı ı ı ı ı ı
Böyle bir NumPy dizisinin float32 dtype özelliği ile yaratı ı ı ı ı
Yani 1GB civarı ı ı ı ı
dönüştürebiliriz? Burada en makul çözüm iki boyutlu matris kullanmak yerine beş boyutlu bir matris kullanmaktı
qtable[arabanı ı ı ı ı ı ı ı ı
Burada ilk dört bilgiyi verdiğimizde biz iki elemanlı
qresult = qtable[arabanı ı ı ı ı ı ı ı ı
Burada qresult iki elemanlı ı
- MountainCar simülatöründe gözlem değerleri iki tanedir: Arabanı ı ı ı
değerlerdir. O halde Q-Tablosunu oluşturmak için bu iki değerin ayrı ı ı ı
hı ı ı ı ı ı ı
elemandan oluşacaktı ı ı ı ı ı ı ı
O halde Q-Tablosu örnekte (100, 100, 3)'lük bir NumPy dizisi olabilir:
qtable[arabanı ı ı ı
Yine biz iki bilgiyi verdiğimizde üç elemanlı
qresult = qtable[arabanı ı ı ı
- Taxi simülatöründe o andaki durum bilgisi "taksinin satı ı ı
yolcunun nerede bı ı ı ı ı
edilmekteydi. Buradaki durum bilgisi ayrı ı ı ı ı ı
"Arabayı ı ı ı ı
- 80x8'lik Frozen Lake simülatöründe kişi 8x8'lik matrisel alanda herhangi bir hücrede bulunabiliyordu. Bu matrisel hücre "kişinin
bulunduğu satı ı ı ı
durum bilgisi 64 taneydi. Bu simülatörde etmenin yapacağı ı ı
toplam 4 taneydi. O halde bu simülatördeki Q-Tablosu (64, 4)'lük bir NumPy dizisi olmalı ı
- MsPacman oyununda ekrandaki resim 210X160 pixel çözünürlüğündedir. Her pixel RGB olarak 256x256x250'lı
göre toplam olası ı ı ı ı ı
farklı ı ı ı ı
oluşturulması ı ı
- Breakout (tuğla kı ı ı ı ı ı
MsPacman'de olduğu gibidir. Burada toplam hareketlerin sayı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi Q-Tablosunun doldurulması ı ı
Q(St, At) = Q(St, At) + alpha * (Rt + gamma * max(St+1, a) - Q(St, At))
Buradaki terimlerin anlamlaı
Q(St, At): Belli bir t durumunda (yani Q tablosunun belli bir satı ı ı ı ı ı
A sütununun kesiştiği hücreyi belirtir. Tablonun bu değeri güncellenecektir. Yani etmen belli bir durumdayken belli bir eylemi
yaptı ı ı ı
alpha: [0, 1] aralı ı ı ı ı ı ı
belirlenmektedir.
gamma: [0, 1] aralı ı ı ı
belirlenmektedir.
Rt: Etmen St durumundayken At eylemini yaptı ı
max(St+1, a): Etmen St durumundayken At eylemini yaptı ı
satı ı ı ı ı
adı ı ı ı ı ı ı
Formüldeki alpha ve gamma sabitlerini görmezden gelelim. Pekiyi bu formal bize ne anlatmaktadı
çı ı ı ı ı ı
mevcut durumunu iyileştirmek ister. Yani örneğin iyi bir durumdan yüksek değerli ancak daha kötü bir duruma geçmek bir iyileştirme
anlamı
Q-Tablosu baştan sı ı ı ı ı ı
şey ödül ya da cezadı
Şimdi tablonun güncellenmesi üzerinde çalı ı
Gxx
xxx
xxx
Burada amaç etmenin (0, 0) noktası ı
0 puan verelim. Q Tablosu aşağı ı
L R U D
S0 0 0 0 0
S1 0 0 0 0
S2 0 0 0 0
S3 0 0 0 0
S4 0 0 0 0
S5 0 0 0 0
S6 0 0 0 0
S7 0 0 0 0
S8 0 0 0 0
Şimdi etmenin (0, 1) pozsiyonunda olduğunu düşünelim ve Sola hareket etmek istediğini varsayalı
GAx
xxx
xxx
Etmenin durumu şu anda S1'dir. O halde tabloda güncellenecek hücre (S1, L ) hücresidir. Formülde alpha = 0.90, gamma = 1 alalı
Formülde ilgili değerleri yerine koyalı
Q(S1, L) = Q(S1, L) + 0.90 * (1 + 1 * 0 - 0)
Q(s1, L) = 0.90
Şimdi Q tablosunda bir hücreyi güncellemiş olduk:
L R U D
S0 0 0 0 0
S1 0.9 0 0 0
S2 0 0 0 0
S3 0 0 0 0
S4 0 0 0 0
S5 0 0 0 0
S6 0 0 0 0
S7 0 0 0 0
S8 0 0 0 0
Şimdi etmenin (1, 1) durumunda olduğunu ve yukarı ı ı
istemektedir.
Gxx
xAx
xxx
O halde Q tablosu şöyle güncellenecektir:
Q(S4, U) = Q(S4, U) + 0.90 * (0 + 1 * 0.90 - 0)
S(S4, U) = 0.81
Şimdi Q-Tablosu şu duruma gelecektir:
L R U D
S0 0 0 0 0
S1 0.9 0 0 0
S2 0 0 0 0
S3 0 0 0 0
S4 0 0 0.81 0
S5 0 0 0 0
S6 0 0 0 0
S7 0 0 0 0
S8 0 0 0 0
Şimdi etmenin (2, 1) hücresinde olduğunu ve yukarı
Gxx
xxx
xAx
Konum olarak (2, 1) S7'dir. O halde güncellenecek hücre Q(S7, U) hücresidir. Q formülünde değerleri yerine koyalı
Q(S7, U) = Q(S7, U) + 0.90 * (0 + 1 * 0.81 - 0)
Q(S7, U) = 0.729
Q Tablosu şu hele gelecektir:
L R U D
S0 0 0 0 0
S1 0.9 0 0 0
S2 0 0 0 0
S3 0 0 0 0
S4 0 0 0.81 0
S5 0 0 0 0
S6 0 0 0 0
S7 0 0 0.729 0
S8 0 0 0 0
Burada görüldüğü gibi tablo yavaş eğitim sı ı ı ı ı ı
Pekiyi şimdi etmenin S7'de olduğunu düşünelim ve etmenin hedefe varmak istediğini varsayalı ı ı
bakı ı ı ı
iyi eylem yine yukarı ı ı
Yani tablo dolduğunda etmen nerede olursa olsun hedefe varmak için en iyi eylemi artı ı ı
İşte işin başı ı ı ı ı ı
Q(St, At) = Q(St, At) + alpha * (Rt + gamma * max(St+1, a) - Q(St, At))
O halde ödül ya da ceza olmazsa bu öğrenme gerçekleşemez.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Q_learning algoritması ı ı ı ı
Biz bilmediğimiz bir bölgeyi nası ı ı
yerleri de kullanarak biraz bildiğimiz yerlerden hareket ederek bilmediğimiz rastgele sokaklara gireriz. Gitgide bildiğimiz alanı
genişletiriz. Sürekli bildiğimiz yerlerde dolaşı ı ı ı
O halde biraz rastegele biraz da öğrenilmiş yerleri kullanma stratejisini uyguları ı
benzer biçimde uygulanmaktadı
denilmektedir.
Eğer bir bölgede hiçbir yeri bilmiyorsak önce rastgele yerlerde daha fazla dolaşı ı
biraz da rastgele yerlerde dolaşmaya çalı ı ı ı ı
Epsilon greedy denilen keşif/işletme stratejisinde bir epsilon değeri alı ı ı ı ı ı ı
1 - epsilon olası ı ı ı ı
if np.random.uniform(0, 1) < EPSILON:
# keşif
else:
# işletme
Burada EPSILON değerinin 0.20 olduğunu varsayalı ı ı ı
Bu sayı ı ı ı
etmen hangi konumdaysa %20 olası ı ı ı ı ı
pozisyonda %20 olası ı ı ı ı
oynayacaktı ı ı ı ı
import numpy as np
EPOCHS = 100
EPSILON = 0.20
for i in range(EPOCHS):
if np.random.uniform() < EPSILON:
print('Exploration')
else:
print('Explotation')
Başlangı ı ı ı
keşif yapı ı ı ı ı ı ı ı ı
başı ı ı ı ı
İngilizce "epsilon decay" denilmektedir.
Epsilon decay işlemi için en basit yöntemlerden biri keşfetme olası ı ı ı
eğitim sı ı ı
import numpy as np
EPOCHS = 200
EPSILON = 0.20
EPSILON_MIN = 0.20
for i in range(EPOCHS):
epsilon = max(1 - i / EPOCHS, EPSILON_MIN)
if np.random.uniform() < epsilon:
print('keşif')
else:
print('işletme')
Burada keşif oranı ı
Epsilon düşürme işlemi döngü değişkeninin belli bir değerle çarparak da sağlanabilir. Örneğin:
import numpy as np
EPOCHS = 200
DECAY_RATE = 0.99
EPSILON_MIN = 0.20
epsilon = 1
for i in range(0, EPOCHS):
epsilon = epsilon * DECAY_RATE
epsilon = max(epsilon, EPSILON_MIN)
if np.random.uniform() < epsilon:
print('keşif')
else:
print('işletme')
Burada 1 değeri her defası ı ı
keşfin daha da düşürülmesi engellenmiştir.
Epsilon değirini düşürmek için üstel fonksiyonlar da yaygı ı ı
yüksek bir değerden gittikçe düşüm yapabilmektedir. Buradaki M sabit bir deeğerdir. Örneğin M değeri 0.01 gibi alı
import numpy as np
EPOCHS = 200
M = 0.01
EPSILON_MIN = 0.20
for i in range(0, EPOCHS):
epsilon = np.exp(-M * i)
epsilon = max(epsilon, EPSILON_MIN)
if np.random.uniform() < epsilon:
print('keşif')
else:
print('işletme')
Yine epsilon değerini azaltmak için ters karekök (inverse square root) yöntemi de kullanı
1 / sqrt(1 + i * DECAY_RATE)
biçiminde azaltı ı
import numpy as np
EPOCHS = 300
DECAY_RATE = 0.08
EPSILON_MIN = 0.20
epsilon = 1
for i in range(EPOCHS):
epsilon = 1 / np.sqrt(1 + i * DECAY_RATE)
epsilon = max(epsilon, EPSILON_MIN)
print(epsilon)
-
#----------------------------------------------------------------------------------------------------------------------------
Şimdi artı ı ı ı
Eğitimin bir fonksiyon tarafı ı ı
fonksiyonunun parametrik yapı ı ı ı ı ı ı ı ı
gerekir. Fonksiyonun Gym çevre nesnesini (environment) alması ı ı ı
bir epoch'ta eğer done koşulu sağlanmazsa maksimum kaç yineleme yapı ı
def train(env, alpha = 0.90, gamma = 1, epochs = 20000, max_iter = 1000):
pass
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 20000
MAX_ITER_DEF = 1000
ALPHA_DEF = 0.1
GAMMA_DEF = 0.6
EPSILON = 0.20
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, max_iter = MAX_ITER_DEF):
qtable = np.zeros((env.observation_space.n, env.action_space.n))
for _ in range(epochs):
obs = env.reset()
for i in range(max_iter):
if np.random.uniform() < EPSILON:
action = env.action_space.sample()
else:
action = np.argmax(qtable[obs])
next_obs, reward, done, _ = env.step(action)
qtable[obs, action] = qtable[obs, action] + alpha * (reward + gamma * np.max(qtable[next_obs]) - qtable[obs, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
count = 0
while True:
print('\x1b[1J' + env.render(mode='ansi'), end='')
action = np.argmax(qtable[obs])
obs, reward, done, _ = env.step(action)
if done:
break
count += 1
time.sleep(0.5)
return count
env = gym.make('Taxi-v3')
qtable = train(env)
count = execute(env, qtable)
print(count)
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 20000
MAX_ITER_DEF = 1000
ALPHA_DEF = 0.1
GAMMA_DEF = 0.6
DECAY_RATE = 0.99
EPSILON_MIN = 0.20
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, max_iter = MAX_ITER_DEF):
qtable = np.zeros((env.observation_space.n, env.action_space.n))
epsilon = 1
for _ in range(epochs):
obs = env.reset()
for i in range(max_iter):
epsilon = epsilon * DECAY_RATE
epsilon = max(epsilon, EPSILON_MIN)
if np.random.uniform() < epsilon:
action = env.action_space.sample()
else:
action = np.argmax(qtable[obs])
next_obs, reward, done, _ = env.step(action)
qtable[obs, action] = qtable[obs, action] + alpha * (reward + gamma * np.max(qtable[next_obs]) - qtable[obs, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
count = 0
while True:
print('\x1b[1J' + env.render(mode='ansi'), end='')
action = np.argmax(qtable[obs])
obs, reward, done, _ = env.step(action)
if done:
break
count += 1
time.sleep(0.5)
return count
env = gym.make('Taxi-v3')
qtable = train(env, epochs=10000)
count = execute(env, qtable)
print(count)
#----------------------------------------------------------------------------------------------------------------------------
Frozen-Lake simülatöründe ödül mekanizması ı ı ı
hedefe varı ı ı ı ı ı ı ı ı ı
eğitimi zorlaştı ı ı ı ı
kötü eylemlerde negatif biçimde azaltı ı ı
Frozen-Lake simülatöründe deliğe düşülmesi durumunda etmene yüksek bir ceza vereceğiz. Pekiyi deliğe düşmeyi nasl anlayacağı
İşte eğer done olmuşsa ve ödül de sı ı ı ı
puanlaması ı
next_obs, reward, done, _ = env.step(action)
if reward == 0:
reward = -20 if done else -1
Artı ı
- Deliğe düşülmesi durumunda -20 puan ceza
- Deliğe düşülmeden hedefe varı ı
- Hedefe varı ı
Aşağı ı ı ı
olarak en basit epsilon greedy yöntemi kullanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 20000
MAX_ITER_DEF = 1000
ALPHA_DEF = 0.6
GAMMA_DEF = 0.9
EPSILON = 0.2
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, max_iter = MAX_ITER_DEF):
qtable = np.zeros((env.observation_space.n, env.action_space.n))
for _ in range(epochs):
obs = env.reset()
for i in range(max_iter):
if np.random.uniform() < EPSILON:
action = env.action_space.sample()
else:
action = np.argmax(qtable[obs])
next_obs, reward, done, _ = env.step(action)
if reward == 0:
reward = -20 if done else -1
qtable[obs, action] = qtable[obs, action] + alpha * (reward + gamma * np.max(qtable[next_obs]) - qtable[obs, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
print('\x1b[1J' + env.render(mode='ansi'), end='')
count = 0
while True:
action = np.argmax(qtable[obs])
obs, reward, done, _ = env.step(action)
print('\x1b[1J' + env.render(mode='ansi'), end='')
if done:
break
count += 1
time.sleep(0.5)
return count
env = gym.make('FrozenLake-v1', map_name='8x8', is_slippery=False)
qtable = train(env, epochs=10000)
count = execute(env, qtable)
print(count)
#----------------------------------------------------------------------------------------------------------------------------
Anı ı
1/3 olası ı ı ı ı ı ı
FFF
HXF
FFF
Etmen X durumunda olsun. Artı ı ı ı ı ı ı
O halde buarada en güvenli eylem sağa gitmektir.
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 50000
MAX_ITER_DEF = 1000
ALPHA_DEF = 0.6
GAMMA_DEF = 0.9
EPSILON = 0.2
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, max_iter = MAX_ITER_DEF):
qtable = np.zeros((env.observation_space.n, env.action_space.n))
for _ in range(epochs):
obs = env.reset()
for i in range(max_iter):
if np.random.uniform() < EPSILON:
action = env.action_space.sample()
else:
action = np.argmax(qtable[obs])
next_obs, reward, done, _ = env.step(action)
if reward == 0:
reward = -50 if done else -5
qtable[obs, action] = qtable[obs, action] + alpha * (reward + gamma * np.max(qtable[next_obs]) - qtable[obs, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
print('\x1b[1J' + env.render(mode='ansi'), end='')
count = 0
while True:
action = np.argmax(qtable[obs])
obs, reward, done, _ = env.step(action)
print('\x1b[1J' + env.render(mode='ansi'), end='')
if done:
break
count += 1
time.sleep(0.5)
return count
env = gym.make('FrozenLake-v1', map_name='8x8', is_slippery=True)
qtable = train(env)
count = execute(env, qtable)
print(count)
#----------------------------------------------------------------------------------------------------------------------------
CartPole simülatöründe anı ı ı ı
Simülatörde toplam iki eylem vardı ı ı ı ı ı
toplam dört gözlem değeri vardı ı ı ı ı ı ı ı ı ı
sürekli değişkenlerdne oluşuyordu. Biz CartPole örneğini Q-Learning algoritması ı
getireceğiz. Tabii sürekli verileri ayrı ı ı ı ı
CartPole örneğinde şöyle bir problem de vardı ı ı ı
maksimum açı ı ı ı ı ı
bu değerleri öncelikle -sonsuz, +sonsuz aralı ı ı ı ı
CartPole örneğinde şu noktalara dikkat etmemiz gerekmektedir:
- Sürekli verilen kaç parçaya ayrı ı
- Eğitimde uygulanacak tekrar (epoch) sayı ı
- Uygun bir epsilon decay işlemi
- Modelin alpha ve gamma hyper parametreleri
Sürekli değerlerin ayrı ı ı
daha uzun bir eğitimin gerekeceği anlamı ı
Bu noktaları ı
uygulanması ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 150000
ALPHA_DEF = 0.5
GAMMA_DEF = 0.95
EPSILON = 0.2
DISCRETE_STATES = 40
def obs2states(env, obs):
state_intervals = (env.observation_space.high - env.observation_space.low) / DISCRETE_STATES
states = np.round((obs - env.observation_space.low) / state_intervals).astype(int)
return np.clip(states, 0, DISCRETE_STATES - 1)
return states
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, verbose=1):
env.observation_space.low[1] = -10
env.observation_space.low[3] = -10
env.observation_space.high[1] = 10
env.observation_space.high[3] = 10
nactions = env.observation_space.shape[0]
nobservations = env.action_space.n
qtable = np.zeros((DISCRETE_STATES, ) * nactions + (nobservations, ))
for i in range(epochs):
if verbose == 1 and i % 1000 == 0:
print(f'{i} ', end='')
obs = env.reset()
while True:
x, v, angle, vangle = obs2states(env, obs)
if np.random.uniform() < EPSILON:
action = env.action_space.sample()
else:
states = obs2states(env, obs)
x, v, angle, vangle = states
action = np.argmax(qtable[x, v, angle, vangle])
next_obs, reward, done, _ = env.step(action)
next_x, next_v, next_angle, next_vangle = obs2states(env, next_obs)
qtable[x, v, angle, vangle, action] = qtable[next_x, next_v, next_angle, next_vangle, action] + alpha * (reward + gamma * np.max(qtable[next_x, next_v, next_angle, next_vangle]) - qtable[next_x, next_v, next_angle, next_vangle, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
env.render()
count = 0
while True:
x, v, angle, vangle = obs2states(env, obs)
action = np.argmax(qtable[x, v, angle, vangle])
obs, reward, done, _ = env.step(action)
env.render()
if done:
break
count += 1
time.sleep(0.1)
return count
env = gym.make('CartPole-v1')
qtable = train(env)
count = execute(env, qtable)
print(count)
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı
çalı ı ı ı ı ı ı ı ı ı ı
arabanı ı ı ı ı
Bu örnekte de sürekli verilerin ayrı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import gym
EPOCHS_DEF = 20000
ALPHA_DEF = 0.60
GAMMA_DEF = 0.90
EPSILON = 0.2
DISCRETE_STATES = 80
def obs2states(env, obs):
state_intervals = (env.observation_space.high - env.observation_space.low) / DISCRETE_STATES
states = np.round((obs - env.observation_space.low) / state_intervals).astype(int)
return np.clip(states, 0, DISCRETE_STATES - 1)
return states
def train(env, alpha = ALPHA_DEF, gamma = GAMMA_DEF, epochs = EPOCHS_DEF, verbose=1):
nactions = env.observation_space.shape[0]
nobservations = env.action_space.n
qtable = np.zeros((DISCRETE_STATES, ) * nactions + (nobservations, ))
for i in range(epochs):
if verbose == 1 and i % 1000 == 0:
print(f'{i} ', end='')
obs = env.reset()
while True:
x, v = obs2states(env, obs)
if np.random.uniform() < EPSILON:
action = env.action_space.sample()
else:
states = obs2states(env, obs)
x, v = states
action = np.argmax(qtable[x, v])
next_obs, reward, done, _ = env.step(action)
next_x, next_v = obs2states(env, next_obs)
qtable[x, v, action] = qtable[next_x, next_v, action] + alpha * (reward + gamma * np.max(qtable[next_x, next_v]) - qtable[next_x, next_v, action])
obs = next_obs
if done:
break
return qtable
import time
def execute(env, qtable):
obs = env.reset()
env.render()
count = 0
while True:
x, v = obs2states(env, obs)
action = np.argmax(qtable[x, v])
obs, reward, done, _ = env.step(action)
env.render()
if done:
break
count += 1
time.sleep(0.1)
return count
env = gym.make('MountainCar-v0')
qtable = train(env)
count = execute(env, qtable)
print(count)
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Q-Learning algoritması ı ı ı
- Q-Tablosunun çok büyük olduğu durumda tablonun doldurulması ı
- Sürekli gözlem değerlerinin bulunduğu durumda bunları ı
bir Q-Tablosunun oluşması ı
- Yönetmin bellek gereksinimi Q-Tabloları ı ı
- Gözlem değerlerinin çok fazla olması ı
İşte Q-Learning algoritması ı ı ı ı ı ı
Deep Q-Learning yöntemi nispeten yeni bir yöntemdir. Yöntem hakkı ı ı ı ı ı
zaman içerisinde hı ı ı ı ı ı
- Q-Tablosu sütunları ı ı ı ı ı
Q değerine sahip sütunundaki eylemi tercih ediyorduk. İşte bir satı ı ı
bunu bir kestirim problemi haline getirip bu kestirim sinir ağı ı ı ı ı ı
gözlem bilgilerinden oluşacak çı ı ı ı ı
satı
- Durumlardan Q değerlerinin elde edilmesinin sinir ağı ı ı
kurtulmuş oluruz. Çünkü biz sinir ağı ı
- Durumlardan Q değerlerinin sinir ağı
- Yöntemin sinir ağı ı ı ı ı ı ı ı ı ı ı
- Yöntemde sinir ağı ı ı
sinir ağı
model = Sequential(name='Cartpole-DeepLearning')
model.add(Dense(64, activation='relu', input_dim=env.observation_space.shape[0], name='Dense-1'))
model.add(Dense(64, activation='relu', name='Dense-2'))
model.add(Dense(env.action_space.n, activation='linear', name='Output'))
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
Burada ağda bir girdi katmanı ı ı ı ı ı ı ı ı ı
env.observation_space.shape[0] kadar olduğuna dikkat ediniz. Yani girdi katmanı ı ı
gözlem uzayı ı ı ı ı
toplam env.action_space.n tane nöronun bulunduğuna dikkat ediniz. Yani model bize her eylem için Q değerlerini verecektir.
Tabii buradaki sinir ağı
göre ona göre evrişimli ve çok katmanlı ı ı ı
- Yönetmin en önemli noktaları ı ı ı
uygulayarak bir değer elde ediyorduk. Bu değeri de Q tablosunun ilgili satı ı ı
ismine "replay buffer" denilen bir veri yapı ı ı ı ı ı ı ı
içerisine kaydedilir. Bu replay buffer veri yapı ı ı ı ı ı
(state, action, reward, next_state)
Burada o anda etmenin için bulunduğu durum demetin "state" elemanı ı ı
ile temsil edilmiştir. Demetin "reward" ile temsil edilen üçüncü elemanı ı ı
belirtmektedir. Nihayet demetin son "next_state" elemanı
bu bilgilere gereksinimiz vardı ı ı ı ı
Bunun için Python standart kütüphanesindeki collections modülünde bulunan deque (double-ended-queue) sı ı ı ı
replay buffer oluşturulduktan sonra bunun içerisinden rastgele k tane eleman seçilir. Sonra bu elemanlar ağı ı ı
Deep Q-Learning yönteminin tipik gerçekleştirimi maddeler haline şöyledir:
1) Probleme uygun bir sinir ağı
2) Bir replay buffer oluşturulur. Bu buffer son n tane "durum, eylem, ödül ve sonraki durumdan" oluşan bir veri yapı ı ı ı ı
n tane aşağı ı
(state, action, reward, next_state)
Bu replay buffer "son n tane elemanı ı ı ı ı
kullanı
3) Bir epoch döngüsü oluşturulur. Bu epoch döngüsü içerisinde etmene eylemler yaptı ı ı
yukarı ı
4) Bu replay buffer'dan "BATCH_SIZE < n" kadar rastgele eleman seçilir. Bu elemanlar sinir ağı ı ı ı
Burada eğitim sı ı ı
sonraki durumun en yüksek Q değerine gereksinim duyulmaktadı ı
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import random
import time
import collections
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
DEF_EPOCHS = 1000
DEF_BATCH_SIZE = 32
DEF_BUFFER_SIZE = 200
EPSILON = 0.20
EPSILON_INIT = 0.95
EPSILON_MIN = 0.20
DECAY_RATE = 0.95
ALPHA = 0.01
GAMMA = 0.95
def train(env, epochs = DEF_EPOCHS, batch_size=DEF_BATCH_SIZE, buffer_size = DEF_BUFFER_SIZE, verbose=1):
model = Sequential(name='Cartpole-DeepLearning')
model.add(Dense(64, activation='relu', input_dim=env.observation_space.shape[0], name='Dense-1'))
model.add(Dense(64, activation='relu', name='Dense-2'))
model.add(Dense(env.action_space.n, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
deq = collections.deque(maxlen=buffer_size)
epsilon = EPSILON_INIT
for i in range(epochs):
if verbose == 1:
print(f'{i} ')
obs = env.reset()
while True:
if np.random.uniform() < epsilon:
action = env.action_space.sample()
else:
qvalues = model.predict(obs.reshape(1, -1))[0]
action = np.argmax(qvalues)
obs_next, reward, done, _ = env.step(action)
deq.append((obs, action, reward, obs_next))
if len(deq) > batch_size:
sample = random.sample(deq, batch_size)
batch_x = np.zeros((batch_size, env.observation_space.shape[0]))
batch_y = np.zeros((batch_size, env.action_space.n))
for index, (obs_s, action_s, reward_s, obs_next_s) in enumerate(sample):
qvals = model.predict(obs_next_s.reshape(1, -1))
next_max_qval = np.max(qvals[0])
print(next_max_qval )
target_qvals = ALPHA * (reward_s + GAMMA * next_max_qval)
qvals[0, action_s] = target_qvals
batch_x[index] = obs_s
batch_y[index] = qvals
model.fit(batch_x, batch_y, batch_size=batch_size, epochs=1, verbose=0)
obs = obs_next
if done:
break
epsilon *= DECAY_RATE
epsilon = np.max([epsilon, EPSILON_MIN])
return model
def execute(env, model):
obs = env.reset()
while True:
env.render()
action = np.argmax(model.predict(obs.reshape(1, -1))[0])
obs, reward, done, _ = env.step(action)
if done:
break
time.sleep(0.5)
env.close()
import gym
env = gym.make('CartPole-v1')
model = train(env)
execute(env, model)
#----------------------------------------------------------------------------------------------------------------------------
import random
import time
import collections
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
DEF_EPOCHS = 1000
DEF_BATCH_SIZE = 32
DEF_BUFFER_SIZE = 200
EPSILON = 0.20
EPSILON_INIT = 0.95
EPSILON_MIN = 0.20
DECAY_RATE = 0.95
ALPHA = 0.01
GAMMA = 0.95
def train(env, epochs = DEF_EPOCHS, batch_size=DEF_BATCH_SIZE, buffer_size = DEF_BUFFER_SIZE, verbose=1):
model = Sequential(name='Cartpole-DeepLearning')
model.add(Dense(64, activation='relu', input_dim=env.observation_space.shape[0], name='Dense-1'))
model.add(Dense(64, activation='relu', name='Dense-2'))
model.add(Dense(env.action_space.n, activation='linear', name='Output'))
model.summary()
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
deq = collections.deque(maxlen=buffer_size)
epsilon = EPSILON_INIT
for i in range(epochs):
if verbose == 1:
print(f'{i} ')
obs = env.reset()
while True:
if np.random.uniform() < epsilon:
action = env.action_space.sample()
else:
qvalues = model.predict(obs.reshape(1, -1))[0]
action = np.argmax(qvalues)
obs_next, reward, done, _ = env.step(action)
deq.append((obs, action, reward, obs_next))
if len(deq) > batch_size:
sample = random.sample(deq, batch_size)
batch_x = np.zeros((batch_size, env.observation_space.shape[0]))
batch_y = np.zeros((batch_size, env.action_space.n))
for index, (obs_s, action_s, reward_s, obs_next_s) in enumerate(sample):
qvals = model.predict(obs_next_s.reshape(1, -1))
next_max_qval = np.max(qvals[0])
print(next_max_qval )
target_qvals = ALPHA * (reward_s + GAMMA * next_max_qval)
qvals[0, action_s] = target_qvals
batch_x[index] = obs_s
batch_y[index] = qvals
model.fit(batch_x, batch_y, batch_size=batch_size, epochs=1, verbose=0)
obs = obs_next
if done:
break
epsilon *= DECAY_RATE
epsilon = np.max([epsilon, EPSILON_MIN])
return model
def execute(env, model):
obs = env.reset()
while True:
env.render()
action = np.argmax(model.predict(obs.reshape(1, -1))[0])
obs, reward, done, _ = env.step(action)
if done:
break
time.sleep(0.5)
env.close()
import gym
env = gym.make('CartPole-v1')
model = train(env)
execute(env, model)
#----------------------------------------------------------------------------------------------------------------------------
Bizim yukarı ı ı ı ı
Genellikle bu yöntemler DQN (Deep Q Learning) olarak bilinmektedir. Biz bu yöntemlerde en iyi q değerlerini tahmin edecek
bir sinir ağı ı ı ı ı ı
denilen yeni yöntemler gelişirilmiştir. Bu policy gradient yöntemler çeşitli alt gruplara ayrı ı
yöntemlerin algoritmik yapı ı ı ı
bu yöntemleri uygulayacağı
DQN yöntemleriyle son 10 senedir geliştirilmiş olan policy gradient yöntemler arası ı ı ı ı
- DQN yöntemi en iyi Q değerlerinin bulunmaı ı
hedeflemektedir Yani DQN yönteminde Q değerlerinden hareketle en iyi eylem tespit edilmeye çalı ı ı
yöntemlerde doğrudan en iyi eylkemklerin tepsit edilmeye çalı ı
- DQN yöntemi ayrı ı ı
söz konusu olduğu durumlarda tercih edilmektedir.
Son 10 yı ı ı ı
- Vanilla Policy Gradient (VPG)
- Trust Region Policy Optimization (TRPO)
- Proximal Policy Optimization (PPO)
- Actor-Critic Methods
- Asynchronous Actor-Critic (A2C)
- Asynchronous Advantage Actor-Critic (A3C)
- Natural Policy Gradient (NPG)
- Trust-PCL
Tabii bu yöntemlerin hepsi yapay sinir ağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yüksek seviyeli pekiştirmeli öğrenme kütüphanelerinin en önemlilerinden biri OpenAI kurumunun (ChatGPT'yi geliştiren kurum)
oluşturduğu "Stable Baselines" isimli kütüpahnedir. OpenAI bu kütüphaneyi geliştirmiş olmakla birlikte artı
geliştirmeyi bı ı ı
Tensorflow kütüphanesi kullanı ı ı ı
Kütüphanenin 3 versiyonu aşağı
pip install stable-baselines3
Kütüphaneyi kullanı ı ı ı ı
kurulması ı ı
pip install stable-baselines3[extra]
Kütüphanenin 3 versiyonun dokümantasyonuna aşağı ı
https://stable-baselines3.readthedocs.io/en/master/
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Stable Baselines kütüphanesi tüm problemlerin gym simülatörleri gibi ifade edildiği varsayı ı
Yani bizim Stable baselines kütüphanesini "gym" ile birlikte kullanmamı
problemlerini çözmek için bizim problememizi "gym" ortamı ı ı
problemi için "custom environment" oluşturması
Programcı ı ı ı ı ı
çoğu "Policy Gradient" denilen son 10 senedir geliştirilen algoritmalardı ı
sı ı ı ı ı ı ı
A2C
DDPG
DQN
HER
PPO
SAC
TD3
Bu algoritmaları ı ı ı ı
o algoritmaya ilişkin bir sı ı ı ı
yapı ı ı ı ı ı
metottan elde edilir. Model sı ı ı ı ı ı ı
yüklemek için kullanı ı ı ı ı ı ı ı ı
1) Öncelikle gym similatör nesnesi (gym environmet) oluşturulur.
2) Algoritma belirlenir ve algoritması ı ı
3) Eğitim model nesnelerinin learn metoduyle yapı ı
4) Artı ı ı ı ı ı ı ı ı ı ı
5) Eğitim bilgilerinin save edilmesi için model sı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi CartPole similatörünü Stable Baselines kütüphanesi ile çözmeye çalı ı
yaratmamı
import gym
env = gym.make('CartPole-v0')
Bundan sonra kullanı ı ı ı ı ı ı ı
Deep Q Learning algoritması ı ı ı ı ı ı ı
class stable_baselines3.dqn.DQN(policy, env, learning_rate=0.0001, buffer_size=1000000, learning_starts=50000,
batch_size=32, tau=1.0, gamma=0.99, train_freq=4, gradient_steps=1, replay_buffer_class=None,
replay_buffer_kwargs=None, optimize_memory_usage=False, target_update_interval=10000,
exploration_fraction=0.1, exploration_initial_eps=1.0, exploration_final_eps=0.05,
max_grad_norm=10, stats_window_size=100, tensorboard_log=None,
policy_kwargs=None, verbose=0, seed=None, device='auto', _init_setup_model=True)
Burada metodun policy parametresi kullanı ı
olarak resimsel işlemler için (örneğin Atari oyunları
olabilmektedir. Metodun ikinci parametresi gym simülatörünü almaktadı ı ı
parametrelerdir. Tabii bu parametreler default değerlerle geçilebilir. Örneğin:
from stable_baselines3.dqn import DQN
model = DQN('MlpPolicy', env)
Artı ı ı ı ı ı ı ı ı ı ı ı ı ı
learn metodunun parametrik yapı ı
learn(total_timesteps, callback=None, log_interval=4, tb_log_name='DQN', reset_num_timesteps=True, progress_bar=False
Metodun birinci parametresi similatörün eğitim sı ı ı ı ı
büyük geçilirse o kadar iyi bir sonuç elde edilir ancak eğitim zamanı ı
model.learn(1000000)
Artı ı ı ı ı ı
predict(observation, state=None, episode_start=None, deterministic=False
Metot bize uygulanacak eylemi ve oluşacak yeni durumu vermektedir. Biz genellikle yalnı
Aşağı
Policy Gradient yöntemlerine göre daha düşük başarı ı ı ı ı ı
iyileşme sağlanmaktadı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('CartPole-v1')
from stable_baselines3.dqn import DQN
model = DQN('MlpPolicy', env)
model.learn(500000)
obs = env.reset()
import time
count = 0
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
env.render()
time.sleep(0.5)
count += 1
if done:
break
env.close()
print(f'Total count: {count}')
#----------------------------------------------------------------------------------------------------------------------------
Stable Baselines kütüphanesindeki A2C (Asycnchronous Actor Critic) algoritması
Örneğin CartPole simülatöründe A2C açı ı ı ı ı ı
parametrik yapı ı
classstable_baselines3.a2c.A2C(policy, env, learning_rate=0.0007, n_steps=5, gamma=0.99, gae_lambda=1.0, ent_coef=0.0,
vf_coef=0.5, max_grad_norm=0.5, rms_prop_eps=1e-05, use_rms_prop=True, use_sde=False, sde_sample_freq=-1,
normalize_advantage=False, stats_window_size=100, tensorboard_log=None, policy_kwargs=None, verbose=0,
seed=None, device='auto', _init_setup_model=True)
Yine metodun ilk parametresi sı ı ı ı ı
normal uygulamakar için "MlpPolicy" olarak resimsel işlemler için (örneğin Atari oyunları
için MultiInputPolicy biçiminde olabilmektedir. Diğer parametreler A2C algoritması
Aşağı ı ı ı ı
tam başarı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('CartPole-v1')
from stable_baselines3.a2c import A2C
model = A2C('MlpPolicy', env)
model.learn(250000)
obs = env.reset()
count = 0
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
env.render()
count += 1
if done:
break
env.close()
print(f'Total count: {count}')
#----------------------------------------------------------------------------------------------------------------------------
PPO (Proximal Policy Optimization) isimli algoritma en yeni algoritmalardan biridir. Bu algoritma da Policy Gradient
denilen sı ı ı ı ı ı ı ı ı
classstable_baselines3.ppo.PPO(policy, env, learning_rate=0.0003, n_steps=2048, batch_size=64, n_epochs=10, gamma=0.99,
gae_lambda=0.95, clip_range=0.2, clip_range_vf=None, normalize_advantage=True, ent_coef=0.0, vf_coef=0.5,
max_grad_norm=0.5, use_sde=False, sde_sample_freq=-1, target_kl=None, stats_window_size=100, tensorboard_log=None,
policy_kwargs=None, verbose=0, seed=None, device='auto', _init_setup_model=True)
Yine sı ı ı ı ı ı
PPO yöntemi pek çok uygulamada A2C ve ve DQN yöntemlerinden daha iyi sonuç vermektedir. Bu durum CartPole simülatöründe de
açı
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('CartPole-v1')
from stable_baselines3.ppo import PPO
model = PPO('MlpPolicy', env)
model.learn(50000)
obs = env.reset()
count = 0
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
env.render()
count += 1
if done:
break
env.close()
print(f'Total count: {count}')
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
Bu epoch miktarı ı ı
daha hı ı ı
Bu tür problemlerde default parametrelerle arzu edilen sonuç elde edilemiyorsa hyper parametrelerle oynak gerekir.
En önemli hyper parametreler şüphesiz n_epochs, learning_rate ve learn metodundaki adı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('MountainCar-v0')
from stable_baselines3.ppo import PPO
model = PPO('MlpPolicy', env, learning_rate=0.01, n_epochs=50)
model.learn(50000)
obs = env.reset()
count = 0
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
env.render()
count += 1
if done:
break
env.close()
print(f'Total count: {count}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de ayrı ı ı ı
en iyi algoritmalardan biri DQN'dir. Ancak burada da hyper parametrelerin probleme özgü biçimde iyi ayarlnamaı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import gym
from stable_baselines3 import DQN
env = gym.make('Taxi-v3')
model = DQN('MlpPolicy', env, exploration_fraction=0.01, learning_rate=0.001, buffer_size=50000)
model.learn(total_timesteps=1000000)
import time
obs = env.reset()
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(int(action))
if done:
break
print( '\x1b[1J' + env.render(mode='ansi'))
time.sleep(0.2)
env.close()
model.save('taxi.model')
del model
model = DQN.load('taxi.model')
obs = env.reset()
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(int(action))
if done:
break
print( '\x1b[1J' + env.render(mode='ansi'))
time.sleep(0.2)
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı
Yani ilgili Algoritma sı ı ı ı ı
oluşturmak için make_vec_env isimli bir fonksiyon kullanı ı ı ı
stable_baselines3.common.env_util.make_vec_env(env_id, n_envs=1, seed=None, start_index=0, monitor_dir=None,
wrapper_class=None, env_kwargs=None, vec_env_cls=None,
vec_env_kwargs=None, monitor_kwargs=None, wrapper_kwargs=None)
Fonksiyonun birinci parametresi simülatör nesnesini ikinci parametresi ise oluşturulacak simülatör nesne sayı ı ı
Bu fonksiyonun geri döndürdüğü nesne doğrudan algorima sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı
Uygulamacı ı ı ı ı ı ı
ifade edebilmeleri gerekmektedir. Buna "gym için custom simülatör (environment)" yazı ı
yazı ı ı ı ı
1) gym.Env sı ı ı ı ı
from gym import Env
class MyEnv(Env):
pass
2) Programcı ı ı ı ı ı ı ı ı ı
elemanlar şunlardı
- observation_space isimli örnek özniteliği
- action_space isimli örnek özniteliği
- reset metodu
- step metodu
- render metodu (zorunlu değil)
- close metodu (zorunlu değildir)
observation_space örnek özniteliği simülatörümüzün içinde bulunduğu durumun maksimum ve minimum değerlerini vermektedir.
Eğer simülatörün durum bilgileri sürekli ise (MounCar, CartPole simülatörlerinde olduğu gibi) bu observation_space
örnek özniteliği Box denilen bir sı ı ı ı ı
gibi= bu durumda bu örnek özniteliği Discrete isimli bir sı ı ı
Box nesnesi oluşturulurken low ve high parametrelerine durum bilgisinin en düşük ve en yüksek değerleri girilir. Eğer durum bilgisi
birden fazla bilgiden oluşuyorsa ve bu bilgilerinin hepsinin en düşük ve en yüksek değerleri aynı
shape belirtilerek kolay bir biçimde oluşturulabilmektedir. Örneğin:
Box(low=-1.0, high=2.0, shape=(3, 4), dtype=np.float32)
Burada toplam 3x4'lük 12 tane durumsal bilginin olduğunu bunları
olduğunu anlamaktayı ı ı ı
bu low ve high değerlerini bir liste biçiminde tel tek belirtmemiz gerekir. Tabii bu durumda artı ı
kalmamaktadı
Box(low=np.array([-1.0, -2.0]), high=np.array([2.0, 4.0]), dtype=np.float32)
Burada iki tane durum bilgisinin olduğunu bunları
olduğunu anlamaktayı
Eğer durum bilgileri ayrı ı ı ı ı ı ı
yalnı ı ı ı ı ı
Örneğin:
Discrete(500)
Burada simülatörde ayrı ı ı
Programcı ı ı ı ı ı ı ı ı ı
hep ayrı ı ı ı
vardı ı ı ı ı ı ı ı ı ı ı ı
onları ı ı ı ı ı ı
Programcı ı ı ı ı ı ı
bundan dörtlü demet veren step metodunu yazmalı ı ı ı ı ı
obs, reward, done, info = env.step(action)
Programcı ı ı ı ı
Nihayet close metodunda programcı ı ı ı ı ı ı ı ı
close metodu çağrı ı
Aşağı ı ı ı ı
varmaya çalı ı ı ı ı ı ı
şöyle ayarlanmı ı
- Deliğe düşme -10 puan
- Deliğe düşmeden hedefe vararamayan eylem -1 puan
- Hedefe varan eylem 10 puan
Sı ı ı ı ı ı ı ı
X X G
A . .
. . X
#----------------------------------------------------------------------------------------------------------------------------
"""
Actions:
LEFT = 0
UP = 1
RIGHT = 2
DOWN = 3
"""
import numpy as np
from gym import Env
from gym.spaces import Discrete
GOAL_POS = 2
class GoalPositionError(Exception):
def __str__(self):
return "Agent already at goal position"
class HolePositionError(Exception):
def __str__(self):
return "Agent already at hole position"
class MyEnv(Env):
def __init__(self):
super().__init__()
self.observation_space = Discrete(9)
self.action_space = Discrete(4)
self._holes = [0, 1, 8]
self._pos_dict = {3: (5, 0, 4, 6), 4: (3, 1, 5, 7), 5: (4, 2, 3, 8), 6: (8, 3, 7, 0), 7: (6, 4, 8, 1) }
def reset(self):
none_holes = list(set(range(self.observation_space.n)).difference(self._holes + [GOAL_POS]))
self._agent_pos = np.random.choice(none_holes)
return self._agent_pos
def step(self, action):
if self._agent_pos == GOAL_POS:
raise GoalPositionError()
if self._agent_pos in self._holes:
raise HolePositionError()
newpos = self._pos_dict.get(self._agent_pos)[action]
self._agent_pos = newpos
if newpos in self._holes:
reward = -10
done = True
elif newpos == GOAL_POS:
reward = 10
done = True
else:
reward = -1
done = False
return newpos, reward, done, {}
def render(self, text=False):
s = ''
for row in range(3):
for col in range(3):
pos = row * 3 + col
if pos in self._holes:
if self._agent_pos == pos:
s += 'Q '
else:
s += 'X '
elif pos == GOAL_POS:
if self._agent_pos == pos:
s += 'Q '
else:
s += 'G '
elif pos == self._agent_pos:
s += 'A '
else:
s += '. '
s += '\n'
if text:
return s
else:
print(s)
from stable_baselines3.ppo import PPO
env = MyEnv()
model = PPO('MlpPolicy', env, learning_rate=0.1, n_epochs=100)
model.learn(30000)
import time
obs = env.reset()
print('\x1b[1J' + env.render(text=True), end='')
time.sleep(1)
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
print('\x1b[1J' + env.render(text=True), end='')
time.sleep(1)
if done:
break
#----------------------------------------------------------------------------------------------------------------------------
Yukarı
ve başka birtakı ı
parametrik hale getirilmiştir. MyEnv sı ı ı ı ı ı
def __init__(self, rowsize = 3, colsize = 3, goal_pos = 2, holes = [0, 1, 8], hole_reward=-10, step_reward=-1, goal_reward=10
Sı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir pekiştirmeli öğrenme kütüphanesi "keras-rl" isimli kütüphanedir. Kütüphane aşağı
pip install keras-rl
Kütüphanesinin dokümantasyonu biraz zayı ı
Projenin web sayfası ı ı
https://github.com/keras-rl/keras-rl
Dokğmantasyon için aşağı ı ı
https://keras-rl.readthedocs.io/en/latest/
Keras-rl kütüphanesinde de hazı ı ı ı ı ı ı
1) Programcı ı ı
import gym
env = gym.make('CartPole-v1')
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizer import Adam
model = Sequential(name='Cartpole-DeepLearning')
model.add(Flatten(input_shape=(1,) + env.observation_space.shape), name='Flatten')
model.add(Dense(64, activation='relu', input_dim=env.observation_space.shape[0], name='Dense-1'))
model.add(Dense(64, activation='relu', name='Dense-2'))
model.add(Dense(env.action_space.n, activation='linear', name='Output'))
model.summary()
2) Bir policy nesnesi yaratı ı
from rl.policy import EpsGreedyQPolicy
policy = EpsGreedyQPolicy(eps=0.2)
Çeşitli policy sı ı ı ı ı
3) Daha sonra bir memory nesnesi yaratı ı ı ı ı
from rl.memory import SequentialMemory
memory = SequentialMemory(limit=50000, window_length=1)
4) Bundan sonra bir Agent nesnesi oluşturulur. Çeşitli algoritmalar için çeşitli agent sı ı ı ı
from rl.agents.dqn import DQNAgent
agent = DQNAgent(model, nb_actions=env.action_space.n, memory=memory, policy=policy, nb_steps_warmup=10, target_model_update=1e-2)
Görüldüğü gibi agent sı ı ı ı ı
"policy" nesnesi sı ı ı
5) Daha sonra agent nesnesi ile compile ve fit işlemleri yapı ı
agent.compile(Adam(lr=1e-3, metrics=['mae']))
agent.fit(env, nb_steps=10000)
Burada fit işleminde environment nesnesinin de metoda verildiğine dikkat ediniz. Tı ı
olduğu gibi bu kütüphane için de "custom environment" oluşturulabilmektedir.
6) Artı
obs = env.reset()
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
env.close()
Keras-rl kürüphanesi Stable Baselines kütüphanesine göre daha zayı
sonra geliştirilmeye başlanmı ı
Keras-rl kütüphanesi için örnek kodlar aşağı ı
https://github.com/keras-rl/keras-rl/tree/master/examples
Aşağda Cartplo simülatörünün keras-rl ile çözümü örnek olarak verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import gym
env = gym.make('CartPole-v1')
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizer import Adam
model = Sequential(name='Cartpole-DeepLearning')
model.add(Flatten(input_shape=(1,) + env.observation_space.shape), name='Flatten')
model.add(Dense(64, activation='relu', input_dim=env.observation_space.shape[0], name='Dense-1'))
model.add(Dense(64, activation='relu', name='Dense-2'))
model.add(Dense(env.action_space.n, activation='linear', name='Output'))
model.summary()
from rl.policy import EpsGreedyQPolicy
policy = EpsGreedyQPolicy(eps=0.2)
from rl.memory import SequentialMemory
memory = SequentialMemory(limit=50000, window_length=1)
from rl.agents.dqn import DQNAgent
agent = DQNAgent(model, nb_actions=env.action_space.n, memory=memory, policy=policy, nb_steps_warmup=10, target_model_update=1e-2)
agent.compile(Adam(lr=1e-3, metrics=['mae']))
agent.fit(env, nb_steps=10000)
obs = env.reset()
while True:
action, _ = model.predict(obs)
obs, reward, done, _ = env.step(action)
if done:
break
env.render()
env.close()
#----------------------------------------------------------------------------------------------------------------------------
Sinir ağları ı ı ı ı
- Tensorflow
- PyTorch
- Theano
Tensorflow Google firması ı ı ı
Facebook firması ı ı ı
daha genel amaçlı ı ı
kitap ve kaynak bulunmaktadı
Tensorflow ve PyTorch kütüphaneleri üzerine oturtulmuş daha yüksek seviyeli kütüphaneler bulunmaktadı
denilmektedir. Örneğin Keras kütüphanesi aslı ı
Her iki kütüphane de ilk çı ı ı
geçmişe doğru uyumu bozan önemli farklı ı ı
Biz kurusumuzda önce PyTorh kütüphanesinin genel kullanı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch kütüphanesinin dokümantasyonuna aşağı ı
https://pytorch.org/docs/stable/index.html
Pytorch kütüphanesi aşağı
pip install torch
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch kütüphanesinde ana öğe "tensör" denilen veri yapı ı ı ı
Yani NumPy dizileri ile Numpy'da yapı ı ı
makine öğrenmesi ve özellikle de sinir ağları ı ı ı ı ı
dizisine benze de farklı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch kütüphanesinin import ismi "torch" biçimindedir. Tipik olarak kütüphane aşağı
import torch
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch'da ilk öğrenilecek şey tensör yaratmaktı ı ı
Bir tensör yaratmanı ı ı
parametresinde tensörü oluşturan değerler Python listesi biçiminde ya da NumPy dizisi biçiminde verilebilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import torch
t1 = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(type(t1))
import numpy as np
a = np.random.random((10, 10))
t2 = torch.tensor(a)
print(t2)
#----------------------------------------------------------------------------------------------------------------------------
PyTorch'da da tı ı
PyTorch kütüphanesindeki dtype diğerlerinde olduğuı ı ı ı ı
default olarak tensor değerlerine de bakı ı ı
PyTorch'ta dtype türü yazı ı ı ı ı ı
torch modülünün içerisindeki sı ı ı
Eğer bir tensör NumPy dizisiniden oluşturuluyorsa ve tensor fonksiyonunda dtype belirtilmemişse tensör nesnesinin dtype türü
NumPy nesnesinden alı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32)
print(t)
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='float32')
t = torch.tensor(a)
print(t)
#----------------------------------------------------------------------------------------------------------------------------
torch.empty fonksiyonu ilkdeğer verilmemiş belli bir boyutta tensör oluşturmakta kullanı ı
elemanları ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.empty((10, 10), dtype=torch.int32)
print(t)
#----------------------------------------------------------------------------------------------------------------------------
Tı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t1 = torch.zeros((10, 10), dtype=torch.int32)
print(t1)
t2 = torch.ones((10, 10), dtype=torch.int32)
print(t2)
#----------------------------------------------------------------------------------------------------------------------------
torch.full fonksiyonu tı ı ı
#----------------------------------------------------------------------------------------------------------------------------
t = torch.full((5, 5), 10, dtype=torch.float32)
print(t)
#----------------------------------------------------------------------------------------------------------------------------
torch.rand fonksiyonu 0 ile 1 arası ı
torch.randint fonksiyonu belli aralı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t1 = torch.rand((10, 10), dtype=torch.float32)
print(t1)
t2 = torch.randn((10, 10), dtype=torch.float32)
print(t2)
t3 = torch.randint(10, 20, (10, 10), dtype=torch.int32)
print(t3)
#----------------------------------------------------------------------------------------------------------------------------
torch.eye fonksiyonu birim matric biçiminde tensör oluşturmaktadı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.eye(10, dtype=torch.float32)
print(t)
#----------------------------------------------------------------------------------------------------------------------------
Pytorch tensörleri torch.Tensor isimli bir sı ı ı ı ı ı ı
bize tensörün boyutları ı ı ı ı ı ı ı ı
tensörün boyutları ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
print(type(t.shape))
print(t.shape)
print(t.shape[0], t.shape[1])
print(len(t.shape))
#----------------------------------------------------------------------------------------------------------------------------
Tensor sı ı ı ı ı ı
de belirtilebilmektedir. Buna tensörün "device" bilgisi denilmektedir. Device bilgisi default olarak "cpu" biçimindedir.
Tensör yaratan fonksiyonları ı ı ı
işleme sokulmaktadı
yüklenmiş olması ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir tensörün içerisindekileri torch.Tensor sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
a = t.numpy()
print(type(a))
print(a)
#----------------------------------------------------------------------------------------------------------------------------
torch.tensor fonksiyonu ile biz zaten bir NumPy dizisinden de Tensor nesnesi elde edebiliyorduk. Ancak istenirse torch.from_numpy fonksiyonuyla da
benzer işlem yapı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
import numpy as np
a = np.random.random((5, 5))
t = torch.from_numpy(a)
print(t)
#----------------------------------------------------------------------------------------------------------------------------
Bir tensör nesnesinin elemanları
Tensör nesnelerinin elemanları
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32)
print(t)
x = t[1, 1]
print(x)
t[1, 1] = 100
print(t)
y = t[1:2, 0:3]
print(y)
t[1:2, 0:3] = 0
print(t)
#----------------------------------------------------------------------------------------------------------------------------
Tı ı ı
nesnesi toplanabilir, çı ı ı
kütüphanesindekine oldukça benzemektedir.
#----------------------------------------------------------------------------------------------------------------------------
import torch
t1 = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32)
t2 = torch.tensor([[9, 8, 7], [6, 5, 4], [3, 2, 1]], dtype=torch.float32)
result = t1 + t2
print(result)
result = t1 * 2 + t2
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Bir tensör içerisinde tek bir eleman varsa (bu eleman çok boyutlu bir tensörün içerisinde de olabilir) o eleman Tensor
sı ı ı ı
eleman önce köşeli parantez operatöryle alı ı ı ı
verdiğini anı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
t = torch.tensor([[[1]]], dtype=torch.float32)
val = t.item()
print(val)
t = torch.rand((5, 5))
val = t[3, 2].item()
print(val)
#----------------------------------------------------------------------------------------------------------------------------
torch.Tensor sı ı ı ı ı ı ı
tensör nesnesi vermektedir. Aslı ı ı ı ı ı
tensör nesnesi olmak üzere foo da bir matematiksel metot olmak üzere:
result = t.foo(...)
işlemlerinin çoğu:
result = torch.foo(t, ...)
biçiminde de yapı
NumPy kütüphanesindeki axis kavramı ı ı ı ı ı ı ı
Bazı
- max
- min
- argmax
- argmin
- sin, cos, tan, asin, acons, atan
- log, log10, exp
- sqrt
- pow
...
Bunları ı ı ı ı ı
dim=0 sütun temelinde işlemler için, dim=1 satı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pytorch temel olarak bir yapay sinir ağı ı ı
oluşturulabilmektedir. Aynı ı ı ı ı ı
eklenti oluşturan yan projelerde bulunmaktadı ı ı ı ı ı
hazı
PyTorch bir kütüphane olarak Tensorflow'a göre daha "nesne yönelimli" tasarlanmı ı ı ı ı
yaparak işlemlerini yürütebilmektedir. Bu bağlamda bazı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı
dendiğni söylemiştik. Ecosystem içerisindeki yüksek seviyeli önemli kütüphaneler şunlardı
TorchVision: Tamamen görüntü işleme ile ilgili işlemler oluşturulmuş kütüphanedir. Örneğn resimlerin sı ı ı ı ı
bu torchvision paketinden faydalanı
TorchText: Metinsel işlemler için kullanı ı ı ı ı ı
öğelerden faydalanı
TorchAudio: Voice processing işlemleri için bulundurulmuş yüksek seviyeli kütüpahenedi.r
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch kütüphanesinde de hazı ı ı ı ı ı ı ı ı
torchvision paketindedir. Yazı ı ı ı ı ı ı ı ı
öğeler için torchaudio, hareketli görüntüsel öğeler için torchvideo gibi yüksek düzeyli paketler ana kütüphaneye entegre edilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch modelinde önemli kavramladan biri "dataset" kavramı ı ı ı ı ı ı
PyTorch içerisindeki hazı ı ı ı ı
Tabii programcı ı ı ı ı ı ı ı ı ı ı
oluşturulmaktadı ı ı ı ı ı ı ı ı ı ı
yazmalı ı ı ı ı ı ı
amaçlara denk düşen Dataset sı ı ı ı ı ı ı ı
dataset sı ı ı ı ı ı ı ı ı
verilerini alarak bize protokole uygun bir dayaset nesnesi vermektedir. Örneğin:
from torch.utils.data import TensorDataset
dataset = TensorDataset(training_dataset_x, training_dataset_y)
Artı ı
bize iki elemanlı ı ı
Aslı ı
Örneğin:
dataset = TensorDataset(x, y, z)
Tabii tipik olarak biz veri kümesi için x ve y değerlerini TensorDataset sı ı ı
TensorDataset sı ı ı ı
Örneğin biz bu sı ı ı ı ı ı ı
Dolayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Programcı ı ı ı
Yukarı ı ı ı ı ı ı ı ı
Ya da TensorDataset gibi hazı ı ı
Aşağı
Burada hazı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
import torch
training_tensor_x = torch.tensor(training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.from_numpy(test_dataset_x)
test_tensor_y = torch.from_numpy(test_dataset_y)
from torch.utils.data import TensorDataset
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, test_tensor_y)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
zaten bize PyTorch kütüphanesinin istediği Dataset nesnesi biçiminde verilmektedir. Örneğin resimsel verilerin sı ı ı ı ı ı ı
ve veri kümeleri barı ı ı ı ı ı ı
Örneğin torchvision.datasets modülündeki CIFAR10 isimli sı ı ı ı
Dataset sı ı ı ı ı
parametresiyle girilmektedir. train parametresi True ise eğitim veri kümesi için False ise test veri kümesi için Dataset nesneleri oluşturulur.
download parametresi True geçilirse veriler Internet'ten indirilir. False geçilirse indirilmiş veriler doğurdan kullanı ı
durumunda veriler zaten indirilmişse bir daha indirilmez.
Bu veri kümelerinin data isimli örnek öznitelikleri x verilerinin hepsini bize numpy dizisi olarak vermektedir. Benzer biçimde bu veri
kümelerinin targets örnek öznitelikleri de y değerlerini bize NumPy dizisi olarak vermektedir.
Bu biçimde hazı ı
default durumda x verilerini PIL.Image (Python Image Library'deki Image sı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from torchvision.datasets import CIFAR10
training_dataset = CIFAR10(root='cifar100-data', train=True, download=True)
test_dataset = CIFAR10(root='cifar10-data', train=False, download=True)
x, y = training_dataset[0]
print(type(x), type(y)) # <class 'PIL.Image.Image'> <class 'int'>
#----------------------------------------------------------------------------------------------------------------------------
torchvision içerisindeki hazı ı ı ı ı
hazı ı ı ı ı ı
nesneleri girilir. Bu sı ı ı ı ı ı ı
değerlerini bize nihai değer olarak verirler. Böylece veriler indirilirken aynı ı ı ı
x verileri için target_transform parametresi y verileri için belirtilen nesnelerin __call__ metotları ı ı ı
sı ı ı ı ı
import torch
from torchvision.datasets import CIFAR10
import numpy as np
class MyTransformer:
def __call__(self, image):
return torch.tensor(np.array(image))
training_dataset = CIFAR10(root='cifar10-data', train=True, download=True, transform=MyTransformer())
test_dataset = CIFAR10(root='cifar10-data', train=False, download=True, transform=MyTransformer())
x, y = training_dataset[0]
print(type(x), type(y))
Aslı ı
isimli bir sı ı ı ı ı ı
Bir grup önişlemi peşi sı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı ı
orada belirtilen önişlemleri sı ı ı ı ı ı ı ı ı
class Compose:
def __init__(self, args):
self.args = args
def __call__(self, x):
for arg in self.args:
x = arg(x)
return x;
Örneğin:
from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose, ToTensor, Normalize
training_dataset = CIFAR10(root='cifar10-data', train=True, download=True, transform=Compose([ToTensor(), Normalize((0, 0, 0), (1, 1, 1))]))
test_dataset = CIFAR10(root='cifar10-data', train=False, download=True, transform=Compose([ToTensor(), Normalize((0, 0, 0), (1, 1, 1))]))
x, y = training_dataset[0]
print(type(x), type(y))
#----------------------------------------------------------------------------------------------------------------------------
from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose, ToTensor, Normalize
training_dataset = CIFAR10(root='cifar10-data', train=True, download=True, transform=Compose([ToTensor(), Normalize((0, 0, 0), (1, 1, 1))]))
test_dataset = CIFAR10(root='cifar10-data', train=False, download=True, transform=Compose([ToTensor(), Normalize((0, 0, 0), (1, 1, 1))]))
x, y = training_dataset[0]
print(type(x), type(y))
#----------------------------------------------------------------------------------------------------------------------------
Dataset sı ı ı
İşte bunun için DataLoader sı ı ı ı ı ı ı ı
DataLoader nesnesi oluşturulurken Dataset nesnesi ve batch_size miktarı
karı ı ı ı ı ı ı
batch_size kadar veri tensör nesnesi olarak elde edilmektedir. Dolaşı ı ı
Bu durumda son yinelemede kalan miktarda veri elde edilir. Örneğin:
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, training_tensor_y)
training_dataloader = DataLoader(training_dataset, batch_size=32, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)
for x, y in training_dataloader:
print(type(x), x.shape)
Aşağı
CSV dosyası
oluşturulmuştur.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
import torch
training_tensor_x = torch.tensor(training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.from_numpy(test_dataset_x)
test_tensor_y = torch.from_numpy(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, training_tensor_y)
training_dataloader = DataLoader(training_dataset, batch_size=32, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)
for x, y in training_dataloader:
print(type(x), x.shape)
#----------------------------------------------------------------------------------------------------------------------------
Artı ı ı ı ı
bir sı ı ı ı ı
tamamen başka bir anlama gelmektedir.). Örneğin:
from torch.nn import Module
class MyModule(Module):
pass
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Programcı ı ı ı ı ı ı ı ı
metot biçimindedir. Eğitim sı ı ı ı ı
Yapay sinir ağı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı
Örneğin:
from torch.nn import Module
class MyModule(Module):
def __init__(self):
super().__init__()
def forward(self, batch_x):
pass
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pytorch'ta katman nesneleri için torch.nn modülünde çeşitli sı ı
Linear isimli katmandı ı ı ı ı ı ı ı ı
sonraki katmanı ı ı ı ı ı ı ı ı ı
belirtiliyordu. Ancak PyTorch'ta katman nesnelerinde hem girdi nöron sayı ı ı ı ı ı
Anı ı ı ı ı ı ı ı ı
çı ı ı ı ı
parametrelerin sayı ı ı ı
en sonunda bir aktivasyon fonksiyonuna sokuluyordu. Oysa PyTorch'ta Linear isimli katman yalnı ı
Bu dot product değerini aktivasyon fonksiyonuna sokmamaktadı ı
nöronda elde edilen dot product değerinin aktivasyon fonksiyonuna sokulmaması ı ı
aynı ı ı ı ı ı
biz dot product yapmadan nöronun girdisini aktivasyon fonksiyonuna sokarak çı ı ı
parametreye sahip olmadı ı ı ı ı ı ı
sahipse her katman için ayrı ı
Türettiğimiz Module sı ı ı ı ı ı
oluşturulup sı ı ı ı ı ı ı ı ı
atanması
from torch.nn import Module, Linear
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
def forward(self, batch_x):
pass
Katman nesnelerinin de dtype bilgisi vardı
yaptı ı ı ı ı ı ı
dtype türünün FataLoader nesnesinden elde edilen tensörlerin dtype türleriyle uyuşması
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Module sı ı ı ı ı ı ı ı ı
metodu self parametresinin yanı ı
veri kümesindeki bir batch kadar bilgi geçirilmektedir. Yani metot çağrı ı ı ı
ve veri kümesindeki özellik sayı ı ı
Pekiyi forward metodunda biz ne yapmalı ı ı
bir batch_size kadar bilgiyi yapay sinir ağı ı ı ı ı ı ı ı
geri döndürmeliyiz. Yani özetle forward metodunun batch_x parametresi bir batch kadar bilgiyi içeren bir tensördür. Bu bir batch'lik
bilgiyi biz yapay sinir ağı ı ı ı ı ı ı ı
Tı ı ı ı ı ı ı ı ı ı ı
__call__ metotları ı ı ı ı ı ı ı
ReLU sı ı ı ı ı ı ı
tensörü bu katman nesnelerinin __call__ metotları ı ı ı ı ı ı
Önceki katmanı ı ı ı ı ı ı ı
from torch.nn import Module, Linear, ReLU
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, batch_x):
x = self.hidden1(batch_x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
import torch
training_tensor_x = torch.tensor(training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.from_numpy(test_dataset_x)
test_tensor_y = torch.from_numpy(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, training_tensor_y)
training_dataloader = DataLoader(training_dataset, batch_size=32, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)
from torch.nn import Module, Linear, ReLU
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, batch_x):
x = self.hidden1(batch_x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
mm = MyModule(training_tensor_x.shape[1])
#----------------------------------------------------------------------------------------------------------------------------
Module sı ı ı ı ı ı ı
fonksiyon çağı ı ı ı ı ı ı ı ı ı ı ı
aslı ı
Aşağı ı ı ı ı ı ı ı ı ı ı ı
forwrad metodunun çağrı ı
#----------------------------------------------------------------------------------------------------------------------------
import torch
from torch.nn import Module, Linear, ReLU, Sigmoid
class MyModule(Module):
def __init__(self):
super().__init__()
self.linear1 = Linear(10, 64)
self.linear2 = Linear(64, 64)
self.linear3 = Linear(64, 1)
self.relu = ReLU()
self.sigmoid = Sigmoid()
def forward(self, x):
x = self.linear1(x)
x = self.relu(x)
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.sigmoid(x)
return x
x = torch.rand(32, 10)
mm = MyModule()
result = mm(x) # bu forward metodunun çağrı ı ı
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı ı
Sequential isimli sı ı ı ı ı ı ı ı ı
argüman olarak veririz. Sı ı ı ı ı ı
Örneğin:
from torch.nn import Sequential
sequential = Sequential(
Linear(training_tensor_x.shape[1], 64),
ReLU(),
Linear(64, 64),
ReLU(),
Linear(64, 1))
Biz burada bir modül nesnesi oluşturmuş olduk. Adeta bu Sequential sı ı ı ı
yapmaktadı ı ı ı
Bu durumda demetlerin ilk elemanı ı
from torch.nn import Sequential
from collections import OrderedDict
sequential = Sequential(OrderedDict([
('hidden1', Linear(training_tensor_x.shape[1], 64)),
('relu1', ReLU()),
('hidden2', Linear(64, 64)),
('relu2', ReLU()),
('output', Linear(64, 1))
]))
Burada verdiğimiz isimler doğrudan sı ı ı ı
anahtarları ı ı ı
eklenme sı ı ı ı ı ı
standart kütüphanede collections modülü içerisine OrderedDict sı ı ı ı ı ı ı
sı ı ı ı ı ı
normal sözlükler kullanı
Aşağı ı ı ı ı ı ı ı ı ı
örnek verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('housing.csv')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
import torch
training_tensor_x = torch.tensor(training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.from_numpy(test_dataset_x)
test_tensor_y = torch.from_numpy(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, test_tensor_y)
training_dataloader = DataLoader(training_dataset, batch_size=32)
test_dataloader = DataLoader(test_dataset, batch_size=32)
from torch.nn import Sequential, Linear, ReLU
from collections import OrderedDict
sequential = Sequential(OrderedDict([
('hidden1', Linear(training_tensor_x.shape[1], 64)),
('relu1', ReLU()),
('hidden2', Linear(64, 64)),
('relu2', ReLU()),
('output', Linear(64, 1))
]))
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi Dataset nesnesi ve Dataloader nesnesini oluşturduk. Yapay sinir ağı ı ı ı ı ı
Şimdi ne yapacağı ı ı ı ı ı
fonksiyona ve minimizasyon işlemini yapan bir algoritmaya gereksinim vardı ı ı ı
"loss" fonksiyonu, bunu minimize etmek için kullanı
O halde bizim eğitim için bir loss fonksiyonuna bir de optimizasyon algoritması ı ı ı ı
algortimaları ı ı ı ı ı ı ı ı ı ı
türünden nesneler yaratı ı ı ı ı ı ı ı ı ı ı
Aşağı ı ı ı ı ı ı ı ı ı ı ı
y değerleri ikili kategorik değerlerdir. loss nesnesinin __call__ metodu "Binary Cross Entropy" değerini bize vermektedir.
#----------------------------------------------------------------------------------------------------------------------------
import torch
from torch.nn import BCELoss
loss = BCELoss()
yhat = torch.rand(64)
y = torch.randint(0, 2, (64, ), dtype=torch.float)
result = loss(yhat, y)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Optimizer sı ı ı ı ı ı ı ı
from torch.optimn import Adam
optimizer = Adam(params)
Optimizasyon sı ı ı ı
katman nesnelerinin içerisindedir. Onları ı ı ı ı
İşte PyTorch'ta Module sı ı ı ı ı
alı
nesnesi biçiminde vermektedir. (Yani burada yapı ı ı ı ı
ilişkin nesneler tipik olarak şöyle yaratı ı ı
from torch.optimn import Adam
optimizer = Adam(mm.parameters())
Optimizer algoritma sı ı ı ı ı ı ı
belirten parametredir. Bazı ı ı ı ı ı ı ı ı ı
SGD (Stochastic Gradient Descent) sı ı ı ı
from torch.optim import SGD
optimizer = SGD(sequential.parameters(), lr=0.001)
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
import torch
training_tensor_x = torch.tensor(training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.from_numpy(test_dataset_x)
test_tensor_y = torch.from_numpy(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, training_tensor_y)
training_dataloader = DataLoader(training_dataset, batch_size=32, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)
from torch.nn import Linear, ReLU
from torch.nn import Sequential
sequential = Sequential(
Linear(training_tensor_x.shape[1], 64),
ReLU(),
Linear(64, 64),
ReLU(),
Linear(64, 1))
from torch.nn import MSELoss
from torch.optim import SGD
loss = MSELoss()
optimizer = SGD(sequential.parameters(), lr=0.001)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı
Keras'taki gibi tek bir metotla yapı ı
programcı ı ı ı ı ı ı ı ı
epoch döngüsüdür. Yani veri kümesinin kaç defa gözden geçirileceğini belirtir. İçteki döngü ise batch döngüsüdür. İçteki döngüde veri kümesi
batch batch elde edilmeli, bir batch'lik bilgi sinir ağı ı
sokulmalı ı
Tabii iç döngüde veri kümesini batch batch ele almak için DataLoader sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
PyTorch'ta sinir ağı ı ı ı
- İç içe iki döngü oluşturulmalı ı ı ı ı ı
Örneğin:
for epoch in range(EPOCHS):
for x, y in dataloader:
...
Burada iç döngüde DataLoader nesnesi dolaşı ı ı ı ı ı ı ı
bilgiyi x ve y olarak vermektedir. Artı ı
- Batch işlemleri yapı ı ı
her döngüde sı ı ı ı ı ı
optimizer.zero_grad()
PyTorch tensörler üzerinde otomatik gradient hesap yapabilmektedir. Optimizer nesnesi de default durumda bu gradient değerleri üst
üste toplar. Bu kümülatif toplam bazı
Bundan sonra bir batch'lik x verisi sinir ağı ı ı
fonksiyon çağı ı ı ı ı ı ı ı ı ı ı ı ı ı
biz elde etmekteydik. Örneğin:
pred_y = mm(x)
- Bir batch'lik x değeri sinir ağı
sokularak loss değeri hesaplanmalı ı
lossval = loss(pred_y.flatten(), y)
Sinir ağı ı ı ı
bizden tek boyutlu y değerlerini almak istemektedir. Bu nedenle ağdan elde edilen değer Tensor sı ı ı ı
ile tek boyuta indirgenmiştir.
- Loss değeri elde edildikten sonra buradan optimizasyon için ilerlenecek doğrultunun elde edilmesi gerekmektedir. Başka bir
deyişle bu loss değerinden hareketle her bir özellik için gradient vektörlerinin hesaplanması ı ı ı ı
backward metotları ı ı
lossval.backward()
Bu metot graf üzerinde geriye giderek gradient hesapları ı ı
- Artı ı ı ı ı ı ı ı
optimizer.step()
Böylece eğitim kodu aşağı ı ı
from torch.nn import MSELoss
from torch.optim import Adam
loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
EPOCHS = 1000
for epoch in range(EPOCHS):
for x, y in dataloader:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = loss(pred_y.flatten(), y)
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
BATCH_SIZE = 32
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
test_tensor_x = torch.tensor(test_dataset_x)
test_tensor_y = torch.tensor(scaled_test_dataset_x)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_tensor_x, training_tensor_y)
test_dataset = TensorDataset(test_tensor_x, test_tensor_y)
dataloader = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU
from torch.nn import Module
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, x):
x = self.hidden1(x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
mm = MyModule(training_tensor_x.shape[1])
from torch.nn import MSELoss
from torch.optim import Adam
mse_loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
for epoch in range(EPOCHS):
for x, y in dataloader:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
print(epoch, end=' ')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de elde ettiğimiz modeli test edelim. Modelin test edilmesi oldukça basittir. Test verilerini modül nesnesine sokarak tek
hamlede bütün değerleri tahmin edip metrik bir değer elde edebiliriz. Yukarı
"mean squared error" ve "mean absolute error" olsun. İşin bu kı ı ı ı ı ı
ile de yapabiliriz. "Mean Absolute Error" işlemi PyTorch'ta L1Loss isimli sı ı
Aşağı ı ı ı
fonksiyonları ı ı ı ı ı ı
dizisi istediklerine dikkat ediniz.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
BATCH_SIZE = 32
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
training_dataset_x, test_dataset_x, training_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
scaled_training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
scaled_test_tensor_x = torch.tensor(scaled_test_dataset_x)
test_tensor_y = torch.tensor(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(scaled_training_tensor_x, training_tensor_y)
dataloader = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU
from torch.nn import Module
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, x):
x = self.hidden1(x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
mm = MyModule(scaled_training_tensor_x.shape[1])
from torch.nn import MSELoss, L1Loss
from torch.optim import Adam
mse_loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
for epoch in range(EPOCHS):
for x, y in dataloader:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
print(epoch, end=' ')
print()
predict_y = mm(scaled_test_tensor_x)
mae_loss = L1Loss()
mse = mse_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Squared Error: {mse}')
mae = mae_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Absolute Error: {mae}')
from sklearn.metrics import mean_squared_error, mean_absolute_error
mse = mean_squared_error(test_dataset_y, predict_y.detach().numpy())
print(f'Mean Squared Error: {mse}')
mae = mean_absolute_error(test_dataset_y, predict_y.detach().numpy())
print(f'Mean Absolute Error: {mae}')
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı
Keras'ta fit metodu tarafı ı ı
programcı ı ı ı
Sı ı ı
ikiye ayı ı ı ı ı
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_validation_dataset_x = mms.transform(validation_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
Pekiyi bir epoch'taki sı ı
metirk değerin ortlaması ı ı ı
tek tek elde ettiğimiz metrik değerlerin ortalaması ı ı ı ı
bizim bir listede toplamamaı ı ı
bu biçimde kendisi yapmaktadı ı
edilen metrik değerlerin ortalaması ı
Şimdi sı ı ı ı ı ı
sonra eğitimden bağı ı ı ı ı
1) Önce tı ı ı ı ı ı ı
2) Sonra ppoch döngüsünün içerisinde eğitim döngüsünün altı ı ı
değil sı ı ı ı ı ı ı ı
da çalı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı
Böylece modelin bozulması ı ı ı ı
sı ı ı ı ı ı ı ı
bir bağlam yönetim nesnesi vermektedir. Bu nesnenin __enter__ metodu eval metodunu çağı ı ı
with torch.no_grad():
pass
Pekiyi train ve eval modları ı ı ı ı ı ı ı ı ı ı ı ı ı
modelde dropout işlemleri eğitim sı ı ı ı ı ı ı ı ı ı
tensörler için otomatik gradient hesapları ı ı ı ı ı
oluşturabilmektedir.
Aşağı ı ı
test işlemi de yine batch batch yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
BATCH_SIZE = 32
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_validation_dataset_x = mms.transform(validation_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
scaled_training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
scaled_validation_tensor_x = torch.tensor(scaled_validation_dataset_x)
validation_tensor_y = torch.tensor(validation_dataset_y)
scaled_test_tensor_x = torch.tensor(scaled_test_dataset_x)
test_tensor_y = torch.tensor(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(scaled_training_tensor_x, training_tensor_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
validation_dataset = TensorDataset(scaled_validation_tensor_x, validation_tensor_y)
validation_dl = DataLoader(validation_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_dataset = TensorDataset(scaled_test_tensor_x, test_tensor_y)
test_dl = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU
from torch.nn import Module
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, x):
x = self.hidden1(x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
mm = MyModule(scaled_training_tensor_x.shape[1])
from torch.nn import MSELoss, L1Loss
from torch.optim import Adam
mse_loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
training_mse_list = []
validation_mse_list = []
training_count = np.ceil(len(training_dataset_x) / BATCH_SIZE)
validation_count = np.ceil(len(validation_dataset_x) / BATCH_SIZE)
test_count = np.ceil(len(test_dataset_x) / BATCH_SIZE)
for epoch in range(EPOCHS):
mm.train()
total_mse = 0
for x, y in training_dl:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
training_mean_mse = total_mse / training_count
training_mse_list.append(training_mean_mse )
mm.eval()
total_mse = 0
for x, y in validation_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
validation_mean_mse = total_mse / validation_count
validation_mse_list.append(validation_mean_mse)
print(f'#{epoch}: loss: {training_mean_mse}, validation loss: {validation_mean_mse}')
import matplotlib.pyplot as plt
plt.plot(range(EPOCHS), training_mse_list)
plt.plot(range(EPOCHS), validation_mse_list)
plt.legend(['Training MSE', 'Validaition MSE'])
plt.show()
mae_loss = L1Loss()
total_mse = 0
total_mae = 0
for x, y in test_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
maeval = mae_loss(pred_y.flatten(), y)
total_mae += maeval.item()
test_mean_mse = total_mse / test_count
test_mean_mae = total_mae / test_count
print(f'Test Mean Squared Error: {test_mean_mse}')
print(f'Test Mean Aboslute Error: {test_mean_mae}')
"""
predict_y = mm(scaled_test_tensor_x)
mse = mse_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Squared Error: {mse}')
mae = mae_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Absolute Error: {mae}')
"""
#----------------------------------------------------------------------------------------------------------------------------
PyTorch'ta kestirim nası ı ı ı ı ı
__call__ metodunu çağı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
BATCH_SIZE = 32
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_validation_dataset_x = mms.transform(validation_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
scaled_training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
scaled_validation_tensor_x = torch.tensor(scaled_validation_dataset_x)
validation_tensor_y = torch.tensor(validation_dataset_y)
scaled_test_tensor_x = torch.tensor(scaled_test_dataset_x)
test_tensor_y = torch.tensor(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(scaled_training_tensor_x, training_tensor_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
validation_dataset = TensorDataset(scaled_validation_tensor_x, validation_tensor_y)
validation_dl = DataLoader(validation_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_dataset = TensorDataset(scaled_test_tensor_x, test_tensor_y)
test_dl = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU
from torch.nn import Module
class MyModule(Module):
def __init__(self, input_size):
super().__init__()
self.input_size = input_size
self.hidden1 = Linear(input_size, 64)
self.hidden2 = Linear(64, 64)
self.output = Linear(64, 1)
self.relu = ReLU()
def forward(self, x):
x = self.hidden1(x)
x = self.relu(x)
x = self.hidden2(x)
x = self.relu(x)
x = self.output(x)
return x
mm = MyModule(scaled_training_tensor_x.shape[1])
from torch.nn import MSELoss, L1Loss
from torch.optim import Adam
mse_loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
training_mse_list = []
validation_mse_list = []
training_count = np.ceil(len(training_dataset_x) / BATCH_SIZE)
validation_count = np.ceil(len(validation_dataset_x) / BATCH_SIZE)
test_count = np.ceil(len(test_dataset_x) / BATCH_SIZE)
for epoch in range(EPOCHS):
mm.train()
total_mse = 0
for x, y in training_dl:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
training_mean_mse = total_mse / training_count
training_mse_list.append(training_mean_mse )
mm.eval()
total_mse = 0
for x, y in validation_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
validation_mean_mse = total_mse / validation_count
validation_mse_list.append(validation_mean_mse)
print(f'#{epoch}: loss: {training_mean_mse}, validation loss: {validation_mean_mse}')
import matplotlib.pyplot as plt
plt.plot(range(EPOCHS), training_mse_list)
plt.plot(range(EPOCHS), validation_mse_list)
plt.legend(['Training MSE', 'Validaition MSE'])
plt.show()
mae_loss = L1Loss()
total_mse = 0
total_mae = 0
for x, y in test_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
maeval = mae_loss(pred_y.flatten(), y)
total_mae += maeval.item()
test_mean_mse = total_mse / test_count
test_mean_mae = total_mae / test_count
print(f'Test Mean Squared Error: {test_mean_mse}')
print(f'Test Mean Aboslute Error: {test_mean_mae}')
"""
predict_y = mm(scaled_test_tensor_x)
mse = mse_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Squared Error: {mse}')
mae = mae_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Absolute Error: {mae}')
"""
import numpy as np
predict_data = np.array([[0.11747, 12.50, 7.870, 0, 0.5240, 6.0090, 82.90, 6.2267, 5, 311.0, 15.20, 396.90, 13.27]])
scaled_predict_tensor = torch.tensor(mms.transform(predict_data), dtype=torch.float32)
predict_result = mm(scaled_predict_tensor).item()
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Tabii biz Module sı ı ı ı ı ı ı ı ı ı ı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
BATCH_SIZE = 32
dataset = np.loadtxt('housing.csv', dtype='float32')
dataset_x = dataset[:, :-1]
dataset_y = dataset[:, -1]
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.20)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.20)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_validation_dataset_x = mms.transform(validation_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
scaled_training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
scaled_validation_tensor_x = torch.tensor(scaled_validation_dataset_x)
validation_tensor_y = torch.tensor(validation_dataset_y)
scaled_test_tensor_x = torch.tensor(scaled_test_dataset_x)
test_tensor_y = torch.tensor(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(scaled_training_tensor_x, training_tensor_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
validation_dataset = TensorDataset(scaled_validation_tensor_x, validation_tensor_y)
validation_dl = DataLoader(validation_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_dataset = TensorDataset(scaled_test_tensor_x, test_tensor_y)
test_dl = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU, Sequential
mm = Sequential(Linear(dataset_x.shape[1], 64), ReLU(), Linear(64, 64), ReLU(), Linear(64, 1))
from torch.nn import MSELoss, L1Loss
from torch.optim import Adam
mse_loss = MSELoss()
optimizer = Adam(mm.parameters(), lr=0.001)
training_mse_list = []
validation_mse_list = []
training_count = np.ceil(len(training_dataset_x) / BATCH_SIZE)
validation_count = np.ceil(len(validation_dataset_x) / BATCH_SIZE)
test_count = np.ceil(len(test_dataset_x) / BATCH_SIZE)
for epoch in range(EPOCHS):
mm.train()
total_mse = 0
for x, y in training_dl:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
training_mean_mse = total_mse / training_count
training_mse_list.append(training_mean_mse )
mm.eval()
total_mse = 0
for x, y in validation_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
validation_mean_mse = total_mse / validation_count
validation_mse_list.append(validation_mean_mse)
print(f'#{epoch}: loss: {training_mean_mse}, validation loss: {validation_mean_mse}')
import matplotlib.pyplot as plt
plt.plot(range(EPOCHS), training_mse_list)
plt.plot(range(EPOCHS), validation_mse_list)
plt.legend(['Training MSE', 'Validaition MSE'])
plt.show()
mae_loss = L1Loss()
total_mse = 0
total_mae = 0
for x, y in test_dl:
pred_y = mm(x)
lossval = mse_loss(pred_y.flatten(), y)
total_mse += lossval.item()
maeval = mae_loss(pred_y.flatten(), y)
total_mae += maeval.item()
test_mean_mse = total_mse / test_count
test_mean_mae = total_mae / test_count
print(f'Test Mean Squared Error: {test_mean_mse}')
print(f'Test Mean Aboslute Error: {test_mean_mae}')
"""
predict_y = mm(scaled_test_tensor_x)
mse = mse_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Squared Error: {mse}')
mae = mae_loss(test_tensor_y, predict_y.flatten()).item()
print(f'Mean Absolute Error: {mae}')
"""
import numpy as np
predict_data = np.array([[0.11747, 12.50, 7.870, 0, 0.5240, 6.0090, 82.90, 6.2267, 5, 311.0, 15.20, 396.90, 13.27]])
scaled_predict_tensor = torch.tensor(mms.transform(predict_data), dtype=torch.float32)
predict_result = mm(scaled_predict_tensor).item()
print(predict_result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi ikili sı ı ı ı ı ı ı
üzerinde ikili sı ı ı ı ı ı ı
olarak "binary cross entropy" alı ı ı ı ı ı
Accuracy ölçümü basit bir biçimde manuel ya da sckit-learn kullanı ı
içerisindeki torchmetrics isimli pakette bulunan Accuracy sı ı ı ı ı ı ı
gibi yüklenmesi gerekmektedir:
pip install torchmetrics
#----------------------------------------------------------------------------------------------------------------------------
EPOCHS = 200
BATCH_SIZE = 32
import pandas as pd
dataset_df = pd.read_csv('breast-cancer-data.csv')
dataset_x = dataset_df.iloc[:, 2:-1].to_numpy(dtype='float32')
dataset_y = (dataset_df['diagnosis'] == 'M').to_numpy(dtype='float32')
from sklearn.model_selection import train_test_split
temp_dataset_x, test_dataset_x, temp_dataset_y, test_dataset_y = train_test_split(dataset_x, dataset_y, test_size=0.15)
training_dataset_x, validation_dataset_x, training_dataset_y, validation_dataset_y = train_test_split(temp_dataset_x, temp_dataset_y, test_size=0.15)
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
scaled_validation_dataset_x = mms.transform(validation_dataset_x)
scaled_test_dataset_x = mms.transform(test_dataset_x)
import torch
scaled_training_tensor_x = torch.tensor(scaled_training_dataset_x)
training_tensor_y = torch.tensor(training_dataset_y)
scaled_validation_tensor_x = torch.tensor(scaled_validation_dataset_x)
validation_tensor_y = torch.tensor(validation_dataset_y)
scaled_test_tensor_x = torch.tensor(scaled_test_dataset_x)
test_tensor_y = torch.tensor(test_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(scaled_training_tensor_x, training_tensor_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE, shuffle=True)
validation_dataset = TensorDataset(scaled_validation_tensor_x, validation_tensor_y)
validation_dl = DataLoader(validation_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_dataset = TensorDataset(scaled_test_tensor_x, test_tensor_y)
test_dl = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)
from torch.nn import Linear, ReLU, Sigmoid, Sequential
model = Sequential(Linear(dataset_x.shape[1], 64), ReLU(), Linear(64, 64), ReLU(), Linear(64, 1), Sigmoid())
from torch.nn import BCELoss, L1Loss
from torch.optim import Adam
from torchmetrics import Accuracy
import numpy as np
bce_loss = BCELoss()
optimizer = Adam(model.parameters(), lr=0.001)
training_bce_list = []
validation_bce_list = []
training_count = np.ceil(len(training_dataset_x) / BATCH_SIZE)
validation_count = np.ceil(len(validation_dataset_x) / BATCH_SIZE)
test_count = np.ceil(len(test_dataset_x) / BATCH_SIZE)
for epoch in range(EPOCHS):
model.train()
total_bce = 0
for x, y in training_dl:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = model(x)
lossval = bce_loss(pred_y.flatten(), y)
total_bce += lossval.item()
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
training_mean_bce = total_bce / training_count
training_bce_list.append(training_mean_bce )
model.eval()
total_mse = 0
for x, y in validation_dl:
pred_y = model(x)
lossval = bce_loss(pred_y.flatten(), y)
total_mse += lossval.item()
validation_mean_bce = total_mse / validation_count
validation_bce_list.append(validation_mean_bce)
print(f'#{epoch}: loss: {training_mean_bce}, validation loss: {validation_mean_bce}')
import matplotlib.pyplot as plt
plt.plot(range(EPOCHS), training_bce_list)
plt.plot(range(EPOCHS), validation_bce_list)
plt.legend(['Training MSE', 'Validaition MSE'])
plt.show()
accuracy = L1Loss()
accuracy = Accuracy(task='binary')
total_bce = 0
total_accuracy = 0
for x, y in test_dl:
pred_y = model(x)
lossval = bce_loss(pred_y.flatten(), y)
total_bce += lossval.item()
accuracy.update(pred_y.flatten(), y)
total_accuracy += accuracy.compute()
test_mean_bce = total_bce / test_count
test_mean_accuracy = total_accuracy / len(test_dl)
print(f'Test Mean BCE Loss: {test_mean_bce}')
print(f'Test Accuracy: {test_mean_accuracy}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de evrişim içeren bir resim sı ı ı ı ı
kümesinde her biri 32x32'lik RGB resimler bulunuyordu. Bu resimler aşağı
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
Bu tür veri kümeleri torchvision içerisinde hazı ı ı ı ı
bu verileri indirerek bize Dataset nesnesi biçiminde veriyordu.
Aşağı
1) Bu örnekte evrişim katmanı ı ı ı ı ı ı ı ı
verilen resimler 32X32X3 boyutları ı ı ı
2) Softmax sı ı ı ı ı ı ı ı ı ı
BATCH_SIZE X 10 biçiminde bir tensörü bize vermektedir.
3) loss fonksiyonu olarak CrossEntropyLoss alı ı ı ı ı
fonksiyonu çağrı ı ı
4) Eğitim sı ı ı ı ı ı ı ı ı ı ı ı ı ı
her batch işlemindeki isabet sayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
BATCH_SIZE = 32
EPOCHS = 5
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose, Normalize, ToTensor
compose = Compose([ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
from torchvision.transforms import ToTensor
training_dataset = CIFAR10(root='cifar10x-data', train=True, download=True, transform=compose)
test_dataset = CIFAR10(root='cifar10-data', train=False, download=True, transform=compose)
from torch.utils.data import DataLoader
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE)
test_dl = DataLoader(test_dataset, batch_size=BATCH_SIZE)
from torch.nn import Module, Linear, ReLU, Softmax, CrossEntropyLoss
class CifarModule(Module):
def __init__(self):
super().__init__()
self.linear1 = Linear(32 * 32 * 3, 128)
self.linear2 = Linear(128, 128)
self.linear3 = Linear(128, 10)
self.relu = ReLU()
self.softmax = Softmax(dim=1)
def forward(self, x):
x = x.view(x.shape[0], -1) # x = torch.flatten(x, 1)
x = self.linear1(x)
x = self.relu(x)
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.softmax(x)
return x
from torch.optim import Adam
import torch
cm = CifarModule()
loss = CrossEntropyLoss()
optimizer = Adam(cm.parameters())
epoch_losses = []
for epoch in range(EPOCHS):
losses = []
for x, y in training_dl:
optimizer.zero_grad()
pred_y = cm(x)
lossval = loss(pred_y.type(torch.float32), y)
lossval.backward()
optimizer.step()
losses.append(lossval.item())
mean_epoch_loss = sum(losses) / len(losses)
epoch_losses.append(mean_epoch_loss)
print(f'Epoch #{epoch}, MSELoss: {mean_epoch_loss}')
total = 0
for x, y in test_dl:
pred_y = cm(x)
result = pred_y.argmax(dim=1)
total += torch.sum(result == y)
accuracy = total / len(test_dataset)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
sklearn kütüphanelerini kullanarak da yapabilirdik. Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
BATCH_SIZE = 32
EPOCHS = 5
import numpy as np
training_dataset = np.loadtxt('cifar10-train.csv', delimiter=',', skiprows=1, dtype=np.uint8)
training_dataset_x = training_dataset[:, :-1]
training_dataset_y = training_dataset[:, -1]
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
training_dataset_x = mms.fit_transform(training_dataset_x).astype('float32')
import torch
training_dataset_x = torch.from_numpy(training_dataset_x)
training_dataset_y = torch.from_numpy(training_dataset_y)
from torch.utils.data import TensorDataset, DataLoader
training_dataset = TensorDataset(training_dataset_x, training_dataset_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE)
from torch.nn import Module, Linear, ReLU, Softmax, CrossEntropyLoss
class CifarModule(Module):
def __init__(self):
super().__init__()
self.linear1 = Linear(32 * 32 * 3, 128)
self.linear2 = Linear(128, 128)
self.linear3 = Linear(128, 10)
self.relu = ReLU()
self.softmax = Softmax(dim=1)
def forward(self, x):
x = x.view(x.shape[0], -1) # x = torch.flatten(x, 1)
x = self.linear1(x)
x = self.relu(x)
x = self.linear2(x)
x = self.relu(x)
x = self.linear3(x)
x = self.softmax(x)
return x
from torch.optim import Adam
import torch
cm = CifarModule()
loss = CrossEntropyLoss()
optimizer = Adam(cm.parameters())
epoch_losses = []
for epoch in range(EPOCHS):
losses = []
for x, y in training_dl:
optimizer.zero_grad()
pred_y = cm(x)
lossval = loss(pred_y.type(torch.float32), y)
lossval.backward()
optimizer.step()
losses.append(lossval.item())
mean_epoch_loss = sum(losses) / len(losses)
epoch_losses.append(mean_epoch_loss)
print(f'Epoch #{epoch}, MSELoss: {mean_epoch_loss}')
#----------------------------------------------------------------------------------------------------------------------------
CIFAR1-10 örneğini şimdi de evrişim katmanları ı
Aşağı ı ı ı ı ı ı ı ı ı ı
__init__ metodunun ilk parametresi resimdeki "channel sayı ı ı ı
Metodun ikinci parametresi kullanı ı ı ı ı ı ı
Bu üçüncü parametre iki elemanlı ı
üzere bu değerde olur. Metodun dördüncü parametresi yine kaydı
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
EPOCHS = 20
BATCH_SIZE = 32
import pickle
import glob
x_lst = []
y_lst = []
for path in glob.glob('cifar-10-batches-py/data_batch_*'):
with open(path, 'rb') as f:
d = pickle.load(f, encoding='bytes')
x_lst.append(d[b'data'])
y_lst.append(d[b'labels'])
import numpy as np
training_dataset_x = np.concatenate(x_lst)
training_dataset_y = np.concatenate(y_lst)
with open('cifar-10-batches-py/test_batch', 'rb') as f:
d = pickle.load(f, encoding='bytes')
test_dataset_x = d[b'data']
test_dataset_y = d[b'labels']
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
training_dataset_x = training_dataset_x.reshape(-1, 3, 32, 32)
from tensorflow.keras.utils import to_categorical
ohe_training_dataset_y = to_categorical(training_dataset_y)
ohe_test_dataset_y = to_categorical(test_dataset_y)
import torch
from torch.utils.data import TensorDataset, DataLoader
training_dataset_tensor_x = torch.tensor(training_dataset_x, dtype=torch.float32)
training_dataset_tensor_y = torch.tensor(ohe_training_dataset_y, dtype=torch.float32)
training_dataset = TensorDataset(training_dataset_tensor_x, training_dataset_tensor_y)
training_dl = DataLoader(training_dataset, batch_size=BATCH_SIZE)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
from torch.nn import Sequential, Conv2d, Linear, ReLU, Flatten, Softmax, Module
class MyModule(Module):
def __init__(self):
super().__init__()
self.layer1 = Conv2d(3, 32, kernel_size=(3, 3), padding=1)
self.layer2 = Conv2d(32, 64, kernel_size=(3, 3), padding=1)
self.layer3 = Flatten()
self.layer4 = Linear(65536, 10)
self.layer5 = Softmax(dim=1)
self.relu = ReLU()
def forward(self, x):
#print(x.shape)
x = self.layer1(x)
#print(x.shape)
#x = self.relu(x)
#print(x.shape)
x = self.layer2(x)
#print(x.shape)
x = self.relu(x)
#print(x.shape)
x = self.layer3(x)
#print(x.shape)
x = self.layer4(x)
#print(x.shape)
x = self.layer5(x)
#print(x.shape)
return x
model = MyModule()
"""
model = Sequential(
Conv2d(3, 32, kernel_size=(3, 3), padding=1),
ReLU(),
self.layer2 = Conv2d(32, 64, kernel_size=(3, 3), padding=1),
ReLU(),
Flatten(),
Linear(84480, 10),
Softmax(dim=1)
)
"""
from torch.optim import Adam
from torch.nn import CrossEntropyLoss
optimizer = Adam(model.parameters(), lr=0.001)
ce_loss = CrossEntropyLoss()
training_ce_list = []
training_count = np.ceil(len(training_dataset_x) / BATCH_SIZE)
for epoch in range(EPOCHS):
model.train()
total_ce = 0
count = 0
for x, y in training_dl:
optimizer.zero_grad() # gradient'lerin kümülatif olmaması ı
pred_y = model(x)
lossval = ce_loss(pred_y.flatten(), y.flatten())
total_ce += lossval.item()
lossval.backward() # gradient vektörleri hesaplar
optimizer.step() # modelin w parametrelerini günceller
count += 1
print(f'\x1b[1JEpoch {epoch + 1}: {int(count/training_count* 100)}%', end='')
training_mean_ce = total_ce / training_count
training_ce_list.append(training_mean_ce)
print(f'#{epoch}: loss: {training_mean_ce}')
import matplotlib.pyplot as plt
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
image_data = image_data / 255
image_data = image_data.reshape(1, 32, 32, 3)
image_data = np.transpose(image_data, [0, 3, 1, 2])
image_tensor_data = torch.tensor(image_data, dtype=torch.float32)
predict_result = model(image_tensor_data)
result = predict_result.argmax()
print(f'{path}: {class_names[result]}')
#----------------------------------------------------------------------------------------------------------------------------
TensorFlow kütüphanesi Google öncülüğünde açı
pek çok yüksek seviyeli kütüphane TensorFlow kullanı ı ı ı ı ı
oluşturulmuştur. Ancak kütüphanenin 2'li verisyonları ı ı ı
nispeten uzun süredir kullanı ı ı
Kütüphanenin 1'li versiyonları ı ı
Böylece bir graf oluşturuluyor sonra bu graf çalı ı ı ı ı ı ı ı
bu biçimdeki kullanı ı ı
Bu yeni çalı
Kütüphanenin 1'li versiyonları ı ı ı ı
belirttiğimiz gibi zor bir kullanı ı ı
Eskiden Keras kütüphanesi TenserFlow ile yazı ı
kütüphanesinin kendi bünyesine katı ı ı ı ı ı ı ı
Keras kullanmaya başladı ı ı ı ı
vardı ı ı ı ı ı
faydalanmaktadı
TensorFlow kütüphanesine yeni başlayanlar artı ı ı
Ancak eski graf sistemi yine de işlemlerin daha hı ı ı ı ı ı ı ı ı
Biz daha önce Keras kullanarak sinir ağları ı ı
NumPy dizilerini kullandı ı ı ı
TensorFlow kütüphanesinin Tensor nesneleriyle yapmaktadı ı ı
NumPy dizileri verdiğimizde aslı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------------
TensorFlow kütüphanesinde de tı ı ı ı
benzemekle birlikta yapay sinir ağları ı ı ı
#------------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------------
Tensorflow kütüphanesinin son versiyonu aşağı
pip install tensorflow
Kütüphane genellikle tf ismiyle aşağı
import tensoflow as tf
#------------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------------
Tensör yaratmanı ı ı ı ı ı ı ı ı
Eğer dtype belirtilmezse default olarak dtype türü tamsayı ı ı ı ı
TensorFlow kütüphanesinde dtype türü için NumPy dtype türleri değil TensorFlow içerisindeki dtype türleri
kullanı ı
büyük ölçüde C/C++ kullanı ı ı ı ı
tf.float32
tf.float64
tf.int8
tf.int16
tf.int32
tf.int64
tf.uint8
tf.string
tf.bool
dtype türleri yine istenirse isimsel biçimde de belirtilebilmektedir. Örneğin:
import tensorflow as tf
t = tf.constant([[1, 2, 3], [4, 5, 6]], dtype='float32')
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=tf.int32)
print(t)
#------------------------------------------------------------------------------------------------------------------
Tabii dtype yine numpy kütüphanesinde olduğu gibi isimsel biçimde verilebilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='float32')
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.constant fonksiyonunda dolaşı
shape parametresi kullanı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8], shape=(2, 4), dtype='float32')
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.constant fonksiyonunda girilen listenin ya da demetin boyutu ne olursa olsun biz shape parametresi yoluyla onun
boyutları ı
t = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]] , shape=(9, ), dtype='float32')
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]], shape=(9, ), dtype='float32')
print(t)
#------------------------------------------------------------------------------------------------------------------
NumPy'da olduğu gibi skaler değerlerin boyutsal bir özellikleri yoktur. Yani bunlar için shape=() biçimndedir.
Örneğin:
t = tf.constant(10 , dtype='float32')
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant(10, dtype='float32')
print(t)
#------------------------------------------------------------------------------------------------------------------
Tabii biz istersek bir NumPy dizisinden de tensöt yaratabiliriz. Bu durumda tensör nesnesinin dtype türü NumPy dizisinden
alı ı
a = np.array([1, 2, 3, 4, 5], dtype=np.float32)
t = tf.constant(a)
#------------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------------
tensör yaratmanı ı
tensör elde edilmektedir. Örneğin:
t = tf.convert_to_tensor([1, 2, 3, 4, 5], dtype=tf.float32)
print(t2)
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
a = np.random.random((5, 5))
t = tf.convert_to_tensor(a)
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.zeros fonksiyonu tı ı ı
Ancak default dtype=tf.float32'dir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.zeros((5, 5))
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.ones fonksiyonu da np.ones gibi içi 1'lerden oluşan bir tensör yaratmaktadı
Ancak default dtype=tf.float32'dir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.ones((5, 5))
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.fill fonksiyonu da np.fill fonksiyonuna benzemektedir. Belli bir değerden bir tensör oluşturmaktadı
Bu fonksiyonun dtype parametresi yoktur. dtype doldurulacak değerin türünden hareketle belirlenmektedir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.fill((5, 5), 10.)
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.range isim olarak Python'daki range fonksiyonuna benzese de işlev olarak Numpy'daki np.arange fonksiyonuna
benzemektedir. Belli bir aralı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.range(20)
print(t)
t = tf.range(10, 20, 0.2)
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.linspace fonksiyonu da Numpy'daki np.linspace fonksiyonuna benzemektedir. Ancak dtype parametresi almamaktadı
default durumda dtype=tf.float64 alı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.linspace(-10, 10, 50)
print(t)
#------------------------------------------------------------------------------------------------------------------
Bir tensör nesnesinin dtype bilgisi dtype isimli örnek özniteliği ile, shape bilgisi ise shape isimli örnek
özniteliği ile elde edilebilir. shape örnek özniteliği bize boyut bilgisini TensorShape isimli bir sı ı
vermektedir. TensorShape bir tensör nesnesi değildir. Biz shape örnek özniteliği ile boyutları ı
TensorShpape sı ı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)
print(t.dtype)
print(t.shape)
#------------------------------------------------------------------------------------------------------------------
Bir tensörün boyut bilgisi istenirse tf.shape fonksiyonuyla da elde edilebilir. shape örnek özniteliğinden farklı
tf.shape fonksiyonu boyut bilgisini bize Tensor nesnesi olarak vermektedir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)
shape = tf.shape(t)
print(shape)
#------------------------------------------------------------------------------------------------------------------
tf.rank fonksiyonu tensörün boyut sayı ı ı
Boyut sayı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)
rank = tf.rank(t)
print(repr(rank))
#------------------------------------------------------------------------------------------------------------------
skaler değerlerin rank'leri 0'dı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant(10, dtype=tf.float32)
rank = tf.rank(t)
print(repr(rank))
#------------------------------------------------------------------------------------------------------------------
Bir tensörün boyutsal bilgisini değiştirmek için tf.reshape fonksiyonu kullanı ı
metodu yoktur.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=tf.float32)
k = tf.reshape(t, shape=(2, 4))
print(t)
print(k)
#------------------------------------------------------------------------------------------------------------------
tf.reshape fonksiyonuna örnek
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.reshape(tf.range(30), (6, 5))
print(t)
#------------------------------------------------------------------------------------------------------------------
Bir tensör nesnesinin elemanları
tensör nesnesi olmaktadı ı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.reshape(tf.range(30), (6, 5))
k = t[1, 0]
print(k)
k = t[2:4, 1:3]
print(k)
#------------------------------------------------------------------------------------------------------------------
tf.size fonksiyonu ile tensördeki toplam eleman sayı ı
örnek özniteliği ya da metot karşı ı ı ı
olarak elde edilebilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.reshape(tf.range(30), (6, 5))
size = tf.size(t)
print(size)
print(size.numpy())
#------------------------------------------------------------------------------------------------------------------
Bir tensör nesnesinin içerisindeki değrler numpy metodu ile numpy dizisi biçiminde elde edilebilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.reshape(tf.range(30), (6, 5))
a = t.numpy()
print(t)
#------------------------------------------------------------------------------------------------------------------
Anı ı
nesneleri bulunuyordu. Biz tf.constant fonksiyonuyla ya da tf.convert_to_tensor fonksiyonuyla tensor yarattı ı ı
içeriği değiştirilemeyen tensör oluşturuyordu. İçeriği değiştirilebilen tensörler fonksiyonla değil tf.Variable isimli bir
sı ı ı ı ı ı ı
Eğitim sı ı ı ı ı
olanak sağlamaktadı
tf.Variable nesnesi tf.Variable sı ı ı ı ı ı ı ı
bir liste biçiminde ya da NumPy dizisi biçiminde verilebilmektedir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.Variable([1, 2, 3, 4, 5], dtype=tf.float32)
print(t)
#------------------------------------------------------------------------------------------------------------------
Variable sı ı ı ı ı ı ı
aynı ı ı ı
atanacak olanan değer assign metoduna bir Python listesi, NumPy dizisi biçiminde verilebilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.Variable([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=tf.float32)
print(t)
t.assign([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
print(t)
#------------------------------------------------------------------------------------------------------------------
assign metodu ile atanacak olanan değer assign metoduna bir Python listesi, NumPy dizisi biçiminde verilebilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
vt = tf.Variable([[1, 2, 3], [4, 5, 6], [7, 8, 9]], shape=(3, 3), dtype=tf.float32)
print(vt)
a = np.random.randint(0, 100, (3, 3))
vt.assign(a)
print(vt)
#------------------------------------------------------------------------------------------------------------------
assign metodu ile atama yapı ı ı ı
türlerinin uyuşması
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
vt = tf.Variable([[1, 2, 3], [4, 5, 6], [7, 8, 9]], shape=(3, 3), dtype=tf.float32)
print(vt)
ct = tf.constant(np.random.randint(0, 100, (3, 3)), dtype=tf.float32)
vt.assign(ct)
print(vt)
#------------------------------------------------------------------------------------------------------------------
Variable nesnesi de bir skaler biçiminde olabilir. Biz bu skaler nesneye yine assign metodu ile değer atayabiliriz.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
v = tf.Variable(1)
print(v)
v.assign(2)
print(v)
#------------------------------------------------------------------------------------------------------------------
Variable tensör içerisindeki değeri toplayarak ve çı ı
kullanı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
vt = tf.Variable([1, 2, 3, 4, 5], dtype=tf.float32)
vt.assign_add([10, 20, 30, 40, 50])
print(vt)
#------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
v = tf.Variable(1)
print(v)
v.assign_add(10)
print(v)
v.assign_sub(3)
print(v)
#------------------------------------------------------------------------------------------------------------------
Rassal sayı ı ı
tf.random.uniform fonksiyonu iki aralı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.random.uniform((5, 5), 0, 10)
print(t)
t = tf.random.uniform((5, 5), 0, 10, dtype=tf.int32)
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.random.normal fonksiyonu belli bir ortalama ve standart sapmaya ilişkin belli boyutta rassal değerlerden oluşan
tensör oluşturmaktadı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.random.normal((5, 5), 0, 3)
print(t)
#------------------------------------------------------------------------------------------------------------------
tf.random.shuffle fonksiyonu bizden bir tensör alı ı ı ı ı
her zaman ilk eksene göre yapı ı ı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5])
print(t)
k = tf.random.shuffle(t)
print(k)
t = tf.random.uniform((5, 5), 0, 10, dtype=tf.int32)
print(t)
k = tf.random.shuffle(t)
print(k)
#------------------------------------------------------------------------------------------------------------------
Tensör sı ı ı ı ı ı ı ı ı
artimetik işlemlere sokabiliriz. Bu durumda tı ı ı ı ı
Ancak işleme sokulacak tensörlerin dtype türlerinin aynı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = tf.constant([[1, 3, 5], [2, 4, 6], [1, 2, 3]])
c = a + b
print(c)
c = a * b
print(c)
#------------------------------------------------------------------------------------------------------------------
Yine aritmetik işlemlerde Numpy'da olduğu gibi "broadcasting" uygulanmaktadı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = tf.constant([1, 3, 5])
c = a + b
print(c)
#------------------------------------------------------------------------------------------------------------------
Matrisel çarpı ı ı ı ı
Tabii tf.matmul fonksiyonunda iki boyutlu matrislerin uygun şekillerde olması
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = tf.constant([[1], [3], [5]])
c = tf.matmul(a, b)
print(c)
b = tf.constant([[1, 2, 3]])
c = tf.matmul(b, a)
print(c)
#------------------------------------------------------------------------------------------------------------------
Tabii iki tensör tı ı ı ı
bool bir vektör elde edilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = tf.constant([[4, 5, 6], [7, 3, 2], [4, 9, 8]])
c = a > b
print(c)
c = a == b
print(c)
#------------------------------------------------------------------------------------------------------------------
Yine Tensorflow'da da bool indeksleme yapı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([8, 12, 43, 23, 19])
result = a > 20
b = a[result]
print(b)
#------------------------------------------------------------------------------------------------------------------
Matematiksel işlemlerin önemli bölümü tf.math modülündeki fonksiyonlarla yapı ı
isimlendirilmiş olan fonksiyonlar axis parametresi almaktadı
aynı ı ı
reduce_mean, reduce_std, reduce_min, reduce_max axis parametresi alab önemli fonksiyonlardı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
b = tf.math.reduce_sum(a, axis=0) # np.sum(a, axis=0)
print(b)
b = tf.math.reduce_sum(a, axis=1) # np.sum(a, axis=1)
print(b)
b = tf.reduce_mean(a, axis=0) # no.mean(a, axis=0)
print(b)
#------------------------------------------------------------------------------------------------------------------
tf.math modülündeki bazı ı ı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
b = tf.constant([[3, 2, 1], [7, 4, 6], [1, 3, 5]])
print(a)
c = tf.add(a, b) # c = a + b
print(c)
c = tf.multiply(a, b) # c = a * b
print(c)
#------------------------------------------------------------------------------------------------------------------
dot product işlemi için birkaç benzer fonksiyon bulundurulmuştur. tf.tensordat fonksiyonu iki tensör üzerinde dot product
işlemi yapar. Fonksiyondaki axes parametresi tipik olarak 1 biçiminde geçilir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
x = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)
y = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)
z = tf.tensordot(x, y, axes=1)
print(z)
#------------------------------------------------------------------------------------------------------------------
tf.math modülünde segment_xxx biçiminde isimlendirilmiş olan fonksiyonlar tensörü segment'teki aynı ı
blümlere ayı ı ı ı ı ı ı ı
Örneğin:
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
segment = tf.constant([0, 0, 1, 1, 1, 2, 2, 2])
Burada 0'lara karşı ı ı ı ı ı
ve 2'lere karşı ı ı ı ı ı
1 2
3 4 5
6 7 8
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
segment = tf.constant([0, 0, 1, 1, 1, 2, 2, 2])
result = tf.math.segment_sum(t, segment)
print(result)
#------------------------------------------------------------------------------------------------------------------
segment'li işlemlere örnek
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
segment = tf.constant([1, 1, 1, 2, 2, 2, 3, 3])
result = tf.math.segment_sum(t, segment)
print(result)
#------------------------------------------------------------------------------------------------------------------
Çok boyutlu diziler üzerinde de segment'li işlemler yapı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9], [3, 2, 1]])
segment = tf.constant([0, 0, 1, 1])
result = tf.math.segment_sum(t, segment)
print(result)
#------------------------------------------------------------------------------------------------------------------
segment_xxx fonksiyonları ı ı ı ı
numaralar sı ı ı ı ı ı ı
isimli zorunlu bir parametresi de vardı
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
segment = tf.constant([0, 0, 1, 1, 1, 2, 1, 0])
result = tf.math.unsorted_segment_sum(t, segment, num_segments=3)
print(result)
#------------------------------------------------------------------------------------------------------------------
unsorted_segment_xxx fonksiyonları ı ı
#------------------------------------------------------------------------------------------------------------------
,import tensorflow as tf
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
segment = tf.constant([2, 2, 2, 1, 1, 1, 3, 3])
result = tf.math.unsorted_segment_sum(t, segment, num_segments=5)
print(result)
#------------------------------------------------------------------------------------------------------------------
math modülündeki argmax ve argmin NumPy'daki gibi en büyük ve en küçük elemanları ı ı
elde etmektedir.
#------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
t = tf.constant([10, 21, 32, 42, 5, 6, 72, 8])
result = tf.argmax(t)
print(result)
result = tf.argmin(t)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka ve makine öğrenmesi uygulamaları ı ı
hizmetlerinin en yaygı ı ı ı
- Goodle Cloud Platform (Vertex AI)
- Amazon Web Services (Sage Maker)
- Microsodt Azure
- IBM Watson
Bu servislerin hepsinin ortak birtakı ı ı
- Bu platformlar bize CPU ve bellek sağlamaktadı ı ı ı
etmemize gerek kalmaz. Pek çok modelin eğitimi günlerce sürebilmektedir. Bunun için makinenin evde tutulması
- Bu platformlar "ölçeklenebilir (scalable)" çözümler sunmaktadı
- Bu platformlar "deployment" için kullanı
uzaktan yapı ı ı ı
cep telefonumuzdaki uygulamalardan yapabiliriz. Böylece uygulamamı ı ı ı
hale gelmektedir.)
- Bu platformlar kendi içerisinde "Automated ML" araçları ı ı ı ı ı
kişiler de bu Automated ML araçları ı
Yukarı ı ı ı ı ı
verilmektedir. Bu platformalara "yapay ze makine öğrenmesi" unsurları ı
yapay zeka ve makine öğrenmesi kı ı ı ı ı ı ı ı
hatta bunlar için sertifikasyon sı ı ı ı ı ı ı
Tabii yukarı ı ı ı ı
ilişkilidir. Yani ne kadar kullanı ı ı ı
bu platformun kaynakları ı ı ı ı
olmalı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bütün cloud sistemlerinde makine öğrenmesi işlemleri yapı ı
Data + Model + Hesaplama
Üzerinde çalı ı ı ı ı
edilir. Model manuel ya da otomatik bir biçimde oluşturulmaktadı ı ı
sistemleri yoluyla model üzerinde eğitim, kestirim gibi işlemler yapmamı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Google Cloud Platform (kı ı ı ı
GCP 2008’ ı ’ ı
GCP’ ı ı ı ı ı
GCP’ ı
https://cloud.google.com/
GCP işlemlerini yapabilmek için kontrol panele (konsol ortamı
https://console.cloud.google.com
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
GCP’ ı ı
Projenin yaratı ı ı ı ı
Proje aktif hale geldiğinde proje sayfası ı ı ı ı
gerekir. Yukarı ı ı ı
Projenin "dashboard" denilen ana bir sayfası ı ı ı ı ı
bulunmaktadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
GCP’ ı ı ı ı
Benzer biçimde yine veritabları ı ı ı ı
bulunmaktadı
GCP içerisinde birtakı ı ı
hizmetini seçmek gerekir. Ancak Google bu noktada sı ı ı ı
Tı ı ’ ı ı ı ı ı ı ı ı
Bucket adeta cloud alanı ı ı ı
Bucket yaratı ı ı ı ı ı
verilere hangi sı ı ’ ’ ı
Bir bucket yaratı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
yerel makinemize install edip işlemleri hiç Web arayüzünü kullanmadan bu araçlarla da yapabilmekteyiz. Bu araçlar bizim
istediğimiz komutları ı ı ı ı ı ı
Web tabalı ı ı ı
Yerel makinemize aşağı ı ı ı ı
https://cloud.google.com/storage/docs/gsutil_install
Örneğin gsutil programı ı ı
gsutil cp covid.csv gs:/kaanaslan-test-bucket
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
GCP içerisindeki Auto ML aracı ı
kullanabilirisniz. Vertex AI'ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tipik olarak Vertex-AI'da işlemn yapma aşamaları
1) Veri kümesi bucket içerisine upload edilir. (Bu işlem Dataset oluşturulurken de yapı
2) Dataset oluşturulur.
3) Eğitim işlemi yapı ı
4) Deployment ve Test işlemleri yapı ı
5) Kestirim işlemleri yapı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Vertex AI'da ilk yapı ı ı
Buradan Create düğmesine bası ı ı ı
ancak aynı ı ı
kestirim yapacaksak "Tabular" sekmesinden "Regression/Classification" seçilmelidir. Daytaset yaratı ı ı
bir CSV dosyası ı ı
bulunmaktadı
* Upload CSV files from your computer
* Select CSV files from Cloud Storage
* Select a table or view from BigQuery
Biz yerel bilgiyasarı ı ı ı ı ı
Eğer zaten CSV dosyası ı ı ı
GCP içerisindeki veritabanı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Dataset oluşturulduktan sonra artı ı ı
Training sayfası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Training işleminde peşi sı ı
yapı ı ı ı ı
"Model details" aşaması ı
Bu aşamada "Advanced Options" düğmesine bası ı ı ı ı
test verileri ve sı ı ı ı
ile geçilebilir. Bundan sonra karşı ı ı ı ı ı
sorulmaktadı ı ı
değerlerle geçilebilir. En sonunda "Compute and pricing" aşaması
zamanı ı ı ı
https://cloud.google.com/vertex-ai/pricing
Burada "Budget" eğitim için maksimum ne kadar zaman ayrı ı ı
saat olarak, resim sı ı ı
En sonunda "Start Training" ile eğitim başlatı ı ı ı
Eğitim bittikten sonra biz eğitim hakkı ı
Eğer problem lojistik olmayan regresyon problemi ise modelin başarı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kesitirim işlemlerinin yapı ı
Modelin deploy edilmesi demek cloud sistemi içerisinde dı ı ı ı
kestirimi uzaktan programlama yoluyla da yapabiliriz. Deployment işlemi "Prediction" sekmesinden girilerek yapı
"Model Registry" sekmesninden de yapı ı ı ı ı ı
model için bir isim verilmekte ve ona bir versiyon numarası ı
tutulursa erişim o kadar hı ı ı ı ı ı ı ı ı
en düşük sayı ı
Burada eğitimin başka bir makinede yapı ı ı ı ı ı
Modelimiz deploy edildikten sonra kullanı ı ı ı ı
bu deployment işlemini silebilirsiniz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Deployment işleminden sonra artı ı ı
Web API'leriyle ya da bunları ı
işlemini programlama yoluyla yapacaksanı ı ı
pip install google-cloud-aiplatform
Bundan sonra aşağı ı ı ı
from google.cloud import aiplatform
aiplatform.init(....)
predict işlemi için Training sekmesinden Deploy & Test sekmesini kullanmak gerekir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Birden fazla predict işlemi "batch predict" denilen sekme ile yapı ı ı ı
oluşturur. Bu CSV dosyası ı
işlemi başlatı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de Vertex AI ile resim sı ı ı ı ı ı ı
gerçekleştirilmektedir:
1) Resimler Google cloud'ta bir bucket'e upload edilir.
2) Resimler bir CSV dosyası
kullanı ı
3) Bu CSV dosyası
4) Training işlemi yapı ı
5) Deployment ve EndPoint ataması ı ı
6) Kestirim işlemi görsel atayüz yoluyla ya da WEB API'leri ya da Pythonkoduyla yapı ı
Burada Dataset oluşturulurken bizden bir CSV dosyası ı ı ı ı
dosyanı ı ı ı
dosyanı ı ı ı
dosyanı ı ı ı
dosyanı ı ı ı
Örneğin:
gs://kaanaslan-test-bucket/ShoeVsSandalVsBootDataset/Boot/boot (1).jpg,boot
gs://kaanaslan-test-bucket/ShoeVsSandalVsBootDataset/Boot/boot (10).jpg,boot
gs://kaanaslan-test-bucket/ShoeVsSandalVsBootDataset/Boot/boot (100).jpg,boot
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Metin sı ı ı ı ı ı
bulunudurulup dosyalar bucket içerisine upload edilebilir yine resim sı ı ı ı
metinlere ilişkin dosyalardan ve onları ı ı ı ı ı ı ı
CSV dosyası ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Amazon firması ı ı
denilmektedir. AWS iki yüzün üzerinde servis barı ı ı ı ı ı
platformun öğrenilmesi ayrı ı ı
için nası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
AWS ortamı ı
oldukça benzemektedir. Google Cloud Platform'daki "Vertex AI" servisinin Amazonda'ki mantı ı ı ı
isimli servistir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
AWS'nin ana kontrol paneline aşağı ı
console.aws.amazon.com
Tabii AWS hizmeti almak için yine bir kayı ı ı ı ı ı
bilgileri istenmektedir. Ancak AWS diğerlerinde olduğu gibi "kullanı ı
AWS'nin konsol ekranı ı ı ı ı ı
yapı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
SageMaker'a geçildiğinde onun da bir "dash board" denilen kontrol paneli vardı ı
manuel işlemler yapabiliriz. Ancak SageMaker'ı ı ı
zahmetsiz kullanabilmek için ismine "Studio" denilen Web tabanlı ı ı ı
benzer "Studio Lab" denilen bedava bir ortam da eklenemiştir. Kullanı ı ı
SageMaker içerisinde "Studio"ya geçebilmek için en az bir "kullanı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
AWS'nin veri saklamak için çeşitli servisleri vardı
S3 servisinde de tı ı ı ı ı
dosyalar upload edilmektedir. Amazon "veri merkezlerini (data centers)" "bölge (zone)" denilen alnlarla bölümlere ayı ı ı
Server'lar bu bölgelerin içerisindeki veri merkezlerinin içerisinde bulunmaktadı ı ı
servis verilmeyebilmetedir. Kullanı ı ı ı ı ı
Bir bucket yaratmak için ona "dünya genelinde tek olan (unique)" bir isim vermek gerekir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
SageMaker Studio'da Auto-ML etkinlikleri için Autopilot denilen uygulama kullanı ı ı ı
AutoML seçilebilir. Autopilot'ta bir Auto-ML çalı ı
oluşturabilmek için "File/New/Create AutoML Experiment" seçilebilir ya da doğrudan Auto ML (Autopilot) penceresinde de
"Create Autopilot Experiment" seçilebilir. Yeni bir experiment yaratı ı ı ı
yeri sorulmaktadı ı ı
kestirimde kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Eğitim işlemi bittiğinde veri dosyanı ı ı
ilgili çeşitli dosyalar bulundurulur. Buradaki iki dosya önemlidir:
SageMakerAutopilotDataExplorationNotebook.ipynb
SageMakerAutopilotCandidateDefinitionNotebook.ipynb
Buradaki "SageMakerAutopilotDataExplorationNotebook.ipynb" dosyası ı ı
raporlanı ı ı ı
nası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kestirim yapabilmek için EndPoint oluşturulmuş olması ı ı ı ı ı
bir server'a deploy edilmesi egrekmektedir. Deploy işlemi sonucunda bize bir EndPoint verilir. Biz de bu EndPoint'i kullanarak
Web arayüzü ile ya da Python programı
AWS'de uzaktan Python ile işlem yapabilmek için "sagemaker" ve "boto3" gibi kütüphaneler oluşturulmuştur. Kütüphaneler şöyle yüklenebilir.
pip install sagemaker
pip install boto3
sagemaker kütüphanesi Web arayüzü ile yapı ı
kesitirm (prediction) gibi işlemleri yapabilmek için kullanı ı
sagemaker kütüphanesi ile uzaktan işlemlerin yapı ı ı ı ı ı ı
bağlantı ı
https://sagemaker.readthedocs.io/en/stable/overview.html
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
boto3 kütüphanesi ile uzaktan işlemler yapı ı ı ı ı ı
bizim AWS kaynakları ı
ikincisi de “aws_secret_access_key”. Amazon servisleri uzaktan erişimler için “public key/private key” kriptografi uygulamaktadı
Bu parola bilgileri Session nesnesi yaratı ı ı
import boto3
session = boto3.Session(aws_access_key_id=XXXXX', aws_secret_access_key='YYYYY')
Session nesnesi yaratı ı ı ı ı ı ı
s3 = session.resource('s3')
Aslı ı ı ı
“~/.aws/credentials” dosyası ı ı ı
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
Burada yukarı ı ı ı ı ı ı
1) https://console.aws.amazon.com/iam/ Adresinden IAM işlemlerine gelinir.
2) Users sekmesi seçilir
3) Kullanı ı
4) "Security credentials" sekmesi seçilir.
5) Buradan Create Acces Key seçilir.
İşlemler sı ı ı ı ı
gibi bu anahtarlar özel bir dosyanı ı ı ı
içerisine yazı ı ı ı ı
session = boto3.Session()
Bu dosya bu bilgiler Amazon'un komut satı ı ı ı ı ı ı ı ı ı
bağlantı
https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
Bu iki anahtarı ı ı
aws configure
Biz programlama yoluyla uzaktan bu bucket işlemlerini yapabiliriz. Örneğin tüm bucket'lerin isimleri aşağı
for bucket in s3.buckets.all():
print(bucket.name)
Belli bir bucket'teki dosya aşağı
s3 = boto3.client('s3')
s3.download_file('kaanaslan-test-bucket', 'x.txt', 'y.txt')
Burada söz konusu bucket içerisindeki "x.txt" dosyası
Uzaktan predict işlemi yine boto3 kütüphanesi ile yapı ı
import boto3
session = boto3.Session(aws_access_key_id='AKIAWMMTXFTMCYOF352A',aws_secret_access_key='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', region_name='eu-central-1')
predict_data = '''6,148,72,35,0,33.6,0.627,50
1,85,66,29,0,26.6,0.351,31'
'''
client = session.client('runtime.sagemaker')
response = client.invoke_endpoint(EndpointName='diabetes-test', ContentType='text/csv', Accept='text/csv', Body=predict_data)
result = response['Body'].read().decode()
print(result)
Burada Session sı ı ı ı ı
metodu çağrı ı ı ı
içerisinde yapmaktadı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Microsoft Azure 2009 yı ı ı ı
öğrenmesine ilişkin servisleri eklemiştir. Microsoft Azure daha önce görmüş olduğumuz Google Cloud Platform ve Amazon AWS
sistemine benzetilebilir. Benzer hizmetler Azure üzerinde de mevcuttur. Azure ML de hiç kod yazmadan fare hareketleriyle
ve Auto MLaraçları ı ı ı ’
tüm yapı ı ı ı ’
sertifikasyon süreçleri oluşturmuştur. Bu konuda sertifika sı ı ı ı ı ı
çok ayrı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Azure kullanı ı ı ı ı ı ı
açı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı
Ancak kullanmadı ı ı ı ı ı ı
kullajı ı ı
Azure sistemini e-posta ve parola ile girildikten sonra ana yönetim sayfası ı ı ı
doğrudan aşağı ı
https://portal.azure.com
Azure'ün ana sayfası
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Azure Machine Learning sayfası ı ı ı ı
için bir klasör gibi bir organizasyon oluşturmaktadı ı ı
Ancak bir "workspace" oluştururken bizim bir "kaynak grubuna (resource group)" ihtiyacı ı ı
kaynak grubu oluşturulmuş olmalı ı ı
seçilir. Kaynak grubu birtakı ı ı ı ı
kaynak grupları ı ı
sayfası ı ı
Kaynak Grupları ı ı
o kaynak grubunun bölgesi de belirtilir.
Workspace oluştururken bizden bazı
Ancak bizim workspace'e bir isim vermemiz ve onun yer alacağı ı
sonra nihayet workspace oluşturulacaktı
gerek yoktur. Farklı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Microsoft da tı ı ı
Buna "Machine Learning Studio" ya da kı
geçebiliriz. Auto ML işlemleri için Studio'da "Automated ML" sekmesine tı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Machine Learning Studio'da Auto ML işlemlerini başlatmak için "Automated ML" sayfası
Daha önceden de gördüğümüz gibi bu tür Cloud Platformları ı
1) Storage (Eğitim için veri kümesisi barı ı ı ı ı
2) CPU (Eğitimi yapabilmek için gereken makine)
3) Model (Çeşitli yöntemlerle veri kğmesine uygun en iyi ML modeli)
4) Deployment ya da EndPoint (Hedef modelin konuşlandı ı ı ı
Microsoft Azure sisteminde de "New Automated ML Job" işleminin ilk aşaması ı ı ı ı
sorulmaktadı
daha önceden oluşturulabilir. Azure sisteminde upload edilmiş veri kümelerine "data asset" denilmektedir. "New Automated ML Job"
işleminde toplam dört aşama bulunmaktadı
1) Select data asset: Bu aşamada üzerinde çalı ı ı
önceden "data asset" biçiminde oluşturulmuş olabilir ya da bu aşamada oluşturulabilir.
2) Configure job: Burada işlem için önemli bazı ı ı ı
Veri kümesindeki tahmin edilecek hedef sütun belirtilmektedir. Eğitim için kullanı
sorulmaktadı ı
maknesi (compute instance) bulunmuyor olabilir. Bu durumda bir hesaplama makinesinin (yani eğitimde kullanı
yaratı ı ı ı
makinesini daha önceden bu işlemden bağı ı ı ı
3) Select task and settings: Burada bize problemin türü sorulmaaktadı ı
bir sı ı ı
4) Hyperparameter Configuration: Bu aşamad bize sı ı ı ı ı
Bu aşamalardan geçildikten sonra Auto-ML en iyi modelleri bulmak için işlemleri başlatı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Auto-ML aracı
üzerine tı ı ı ı ı
GUI'den kestirim yapı ı ı ı
Ancak bu kodda api_key kı ı ı ı ı
Örneğin burada Consume sekmesindeki kod aşağı
hesaba erişim için gereken "api key" boş bı ı ı ı ı ı
belirttiğimiz gibi bu API key Consume sekmesinden Primary Key alanı ı
verilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
import urllib.request
import json
import os
import ssl
def allowSelfSignedHttps(allowed):
# bypass the server certificate verification on client side
if allowed and not os.environ.get('PYTHONHTTPSVERIFY', '') and getattr(ssl, '_create_unverified_context', None):
ssl._create_default_https_context = ssl._create_unverified_context
allowSelfSignedHttps(True) # this line is needed if you use self-signed certificate in your scoring service.
# Request data goes here
# The example below assumes JSON formatting which may be updated
# depending on the format your endpoint expects.
# More information can be found here:
# https://docs.microsoft.com/azure/machine-learning/how-to-deploy-advanced-entry-script
data = {
"Inputs": {
"data": [
{
"age": 0,
"sex": "example_value",
"bmi": 0.0,
"children": 0,
"smoker": "example_value",
"region": "example_value"
}
]
},
"GlobalParameters": 0.0
}
body = str.encode(json.dumps(data))
url = 'https://kaanaslantestworkspace-wyndx.northeurope.inference.ml.azure.com/score'
# Replace this with the primary/secondary key or AMLToken for the endpoint
api_key = ''
if not api_key:
raise Exception("A key should be provided to invoke the endpoint")
# The azureml-model-deployment header will force the request to go to a specific deployment.
# Remove this header to have the request observe the endpoint traffic rules
headers = {'Content-Type':'application/json', 'Authorization':('Bearer '+ api_key), 'azureml-model-deployment': 'automl457b251af41-1' }
req = urllib.request.Request(url, body, headers)
try:
response = urllib.request.urlopen(req)
result = response.read()
print(result)
except urllib.error.HTTPError as error:
print("The request failed with status code: " + str(error.code))
# Print the headers - they include the requert ID and the timestamp, which are useful for debugging the failure
print(error.info())
print(error.read().decode("utf8", 'ignore'))
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
daha az kod yazarak da yapı ı
pip install azureml
pip install azureml-core
pip install azureml-data
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import json
from pathlib import Path
from azureml.core.workspace import Workspace, Webservice
service_name = 'automl245eb70546-1',
ws = Workspace.get(
name='KaanWorkspace',
subscription_id='c06cf27d-0995-4edd-919a-47fd40f4a7ae',
resource_group='KaanAslanResourceGroup'
)
service = Webservice(ws, service_name)
sample_file_path = '_samples.json'
with open(sample_file_path, 'r') as f:
sample_data = json.load(f)
score_result = service.run(json.dumps(sample_data))
print(f'Inference result = {score_result}')
#----------------------------------------------------------------------------------------------------------------------------
Azure'ün Machine Learning servisinde diğerlerinde henüz olmayan "designer" özelliği de bulunmaktadı
sürükle bı
Machine Learning Stdudio'da soldaki "Designer" sekmesi seçilir. Bu sekme seçildiğinde karşı ı ı ı ı
Biz hazı ı ı ı ı
oluşturabiliriz.
Model oluştururken sol taraftaki pencerede bulunan iki sekme kullanı ı
kümelerini göstermektedir. Component sekmesi ise sürüklenip bı ı
bir kutucuk ile temsil edilmiştir. Kod yazmak yerine bu bileşenler tasarı ı ı ı ı
birbirlerine bağlanı ı ı ı ı
özellikler görüntülenebilir. Bu bağlam menüsünde pek çok bileşen için en önemli seçenek "Edit node name" seçenğidir. Bu seçenekte
bileşene ilişkin özenmli bazı
Eğer model için şablon kullanmayı ı ı
tasarı ı ı ı ı
Veri kümesini belirledikten sonra biz veri kümesindeki bazı
"Select Columns in Dataset" bileşeni seçilir. Veri kümesinin çı ı ı ı
"Select Columns in Dataset" bileşeninde bağlam menüsünden "Edit node name" seçilir. Buradan da "Edit columns" seçilerek
sütunlar belirlenir.
Bu işlemden sonra eksik veriler üzerinde işlemlerin yapı ı ı
ekranı ı ı ı
Bundan sonra veri kümesini eğitim ve test olmak üzere ikiye ayı ı ı
Bu bileşende "Edit node names" yapı ı ı ı ı ı ı
belirlemeler girilebilir.
Bu işlemden sonra "Özellik Ölçeklemesi (Feature Scaling)" yapı
Bu bileşende "Edit node names" seçildiğinde biz ölçekleme üzerinde belirlemeleri yapabilecek duruma geliriz.
Bu aşamalardan sonra artı ı ı ı
Bu bileşenin iki girişi vardı ı
birinci girişi olan "Untrained model" girişine ise problemin türünü belirten bir bileşen bağlanı
için çeşitli bileşenler vardı ı ı ı ı ı
Eğitime ilişkin hyper parametreler bu bileşende belirtilmektedir.
Eğtim işleminden sonra sı ı ı
bileşeninin iki girişi vardı ı ı ı
"Split Data" bileşeninin ikinci çı ı ı ı
Model Designer'da oluşturulduktan sonra artı ı ı ı
Burada artı ı ı ı ı ı
gereken üç unsur "Data" + "Model" + "CPU" biçimindeydi.)
Nihayet işlemleri başlatı
Azure Designer'daki tüm bileşenler (components) aşağı ı ı
https://learn.microsoft.com/en-us/azure/machine-learning/component-reference/component-reference?view=azureml-api-2
Biz Inference Pipeline işlemini yaptı ı ı ı
için model bir "Web Service Output" bileşeni eklemektedir. Bu "Web Service Output" bileşeni kestirim çı ı ı ı
bir web servis biçiminde verileceği anlamı ı
modelimize bir "Web Service Input" bileşeni de ekliyordu. Bu bileşen de girdilerin web service tarafı ı ı ı
belirtmekteydi. Designer'ı ı ı ı ı ı
eklenmemektedir. Web Service Input bileşeni eklendikten sonra artı
kestirilecek sütunu çı ı ı ı ı ı ı ı
bileşenine değil doğrudan ApplyTransformation bileşenine bağlanması
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Desginer'ı ı ı ı ı ı ı ı ı
regresyon probleminin adı ı ı ı ı ı ı
https://learn.microsoft.com/en-us/azure/machine-learning/tutorial-designer-automobile-price-train-score?view=azureml-api-1
#----------------------------------------------------------------------------------------------------------------------------
IBM'in Cloud Platformu da en çok kullanı
cloud platformu içerisinde makine öğrenmesine ilişkin servisler bulundurmaktadı
Watson denilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
IBM Cloud platformu için yine bir hesap açı ı
yapı ı ı ı ı ı ı
"user id" gibi kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
IBM Cloud platformuna login olunduktan sonra karşı ı ı ı ı ı
"Create Resource" seçilerek kaynak yaratı ı ı
kaynağı ı
"IBM Watson Studio" ortamı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
IBM Watson Studio'ya geçildiğinde öncelikle bir projenin yaratı ı
Proje bir isim verilir. Sonra projenin yaratı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Proje yaratı ı ı ı
için "Auto AI" seçilebilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Auto AI seçildiğinde yaratı
ile ilişkilendirilmelidir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Watson Studio'da Auto AI projesinde bizden öncelikle veri kümesinin yüklenmesi istenmektedir. Veri kümesi yüklendikten sonra
bu veri kümesinin ardı ı ı ı ı ı
belirleriz. Uygulamacı
"Experiment Settings" düğmesiyle yapı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Modeller oluşturulduktan sonra bunlar performansa göre iyiden kötüye doğru sı ı
Modeller save edilirken istenirse model kodları
çekilip IBM Python kütüphanesi kurulduktan sonra yerel makinede de çalı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Deployment işlemi için önce bir "deployment space" yaratı ı ı ı
modelin çı ı ı
Assets kı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Deployment sonrası ı ı
diğer cloud platfotrmları ı
aşağı
pip install ibm-watson-machine-learning
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
