2024-04-02 13:01:04 +03:00
#----------------------------------------------------------------------------------------------------------------------------
Yapay Zeka ve Makine öğrenmesi
UNIX/Linux Sistem Programalama Kursu
Sı ı ı
Eğitmen: Kaan ASLAN
Bu notlar Kaan ASLAN tarafı ı ı ı
(Notları
Son Güncelleme: 30/03/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
1. Ders - 23/12/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tanı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
2. Ders - 24/12/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python gözden geçirmesine başlandı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
3. Ders - 06/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python gözden geçirmesine devam edildi.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
4. Ders - 07/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python gözden geçirmesine devam edildi.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
5. Ders - 13/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python gözden geçirmesine devam edildi.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
6. Ders - 14/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Python gözden geçirmesine devam edildi.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
7. Ders - 20/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
NumPy kütüphanesinin gözden geçirilmesine başlandı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
8. Ders - 21/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
NumPy kütüphanesinin gözden geçirilmesine devam edildi ve Pandas kütüphanesinin gözden geçirilmesine başlandı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
9. Ders - 27/01/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kurumuzun ilk bölümünde zeka, yapay zeka, öğrenme, makine öğrenmesi ve veeri bilimi kavramları ı
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ı
(Raymond Catell aslı ı ı
ve "akı ı ı ı ı
iken akı ı ı ı
genişleterek ona görsel işitsel yetileri, belleğe erişimle ilgili yetileri, tepki zamanları
yönelik yetileri ve okuma yazma becerilerini de eklemiştir. Nihayet John Carroll zeka ile ilgili 460 yeteneği faktör analizine
sokarak üç katmanlı
benimsediği zeka anlayı ı ı
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ı ı ı
belirtmektedir. Yapay zeka terimi ilk kez 1955 yı ı ı
zekanı ı ı ı ı ı ı
olduğu varsayı ı ı
makineler tarafı ı ı ı ı ı ı
- 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ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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’ ı ı ı
Yapay zeka çalı ı ı ı ı
- Mantı ı ı ı ı ı
adlı ı ı ı
- Matematikteki Gelişmeler: 1930’
fonksiyonel notasyonla hesaplanabilirliği araştı ı ı ı ’
systems)" üzerindeki çalı ı ı ı
- Turing Makineleri: Alan Turing’ ’ ı ı ı
tasarladı ı ı ı ı ı ı ı
etkili olmuştur. (Turing mekinelerinin çeşitli modelleri vardı ı
analizinde ve algoritmik karmaşı ı ı ı ı ı ı
- 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ı ı ı ı ı ı ı ı
edilmektedir. Yapay zeka terimi de bu konferansta katı ı ı ı ı ı
ilk programlama dillerinden biri olan Lisp’ ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
10. Ders - 28/01/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka çalı ı ı ı ı ı
finansman sı ı ı ı ı ı ı ı ı ı ı ı ı
"Kı ı ı ı ı ı ı ı ı ı ı
çalı ı ı ı
1956-1974 yapay zekanı ı ı ı ı ı
üzerinde çalı ı ı ı ı ı
daraltı ı ı ı ı ı ı ı
elde edilen çeşitli başarı ı
- 1958 yı ı ı ı ı
durum 90'lı ı ı ı ı ı ı
- 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ı ı ı
1987-1993 yı ı ı ı ı ı ı
kaynakları
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ı ı
bir yapay zeka faaliyeti olarak ele alı ı ı ı ı ı
bir yapay zeka faaliyeti olarak görülüyorken artı ı ı
ele alı ı ı
yapay zeka alanı ı ı ı ı ı ı ı ı
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ı ı ı ı ı ı ı
genişletmiştir.
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)
4) Bilişsel Öğrenme (Cognitive Learning):
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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)
Nötr uyaran artı
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ı ı ı ı
tipik bir örnektir. Bu deneyde Pavlov köpeğe yemek gösterdiğinde (koşulsuz uyaran) köpek salya salgı ı
köpeğin salya salgı ı
yemeği göstermiş ve bu işlemi bir süre tekrarlamı ı ı ı ı
nötr uyaran koşullu uyaran haline gelmiştir) salgı ı ı ı
daha önce yapmadı ı
Klasik koşullanma süreci pek çok hayvan üzerinde denenmiştir. Hayvanları
öğrenebilmektedir. Birinci kuşak davranı ı ı ı ı ı ı
de fobilerin çoğunda klasik koşullanmanı ı
çok kı ı ı ı
yeniden karanlı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı ı
olduğu" sonucunu çı ı ı ı
koşullanmayı
ası ı ı
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ı ı ı
durumu ortadan kaldı ı ı ı
- Ö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.
#----------------------------------------------------------------------------------------------------------------------------
Sosyal bilişsel öğrenmeye Bu yönteme "taklit yoluyla öğrenme" ya da model alarak öğrenme" de denilmektedir. Biz başkaları ı
taklit ederek de davranı ı ı ı ı
hale getirilmiştir. Aslı ı
değil dolaylı ı ı
dikkat ediniz. Çünkü bu süreçte kişinin başkaları ı ı ı ı ı
sonuçlar çı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biliş (cognition) organizmanı
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 çı ı ı ı ı ı
yerine getirilmesi de gitgide iyileştirilir. Bu süreç çeşitli algoritmalarla ve yöntemlerle değişik biçimlerde ve
yaklaşı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka alanı ı ı ı
İstatistik: İstatistik temelde iki bölüme ayrı ı
- Betimsel istatistik (descriptive statistics)
- Sonuç çı ı ı
Betimsel istatistik verilerin gruplanması
betimleyici istatistik "zaten var olan durumu" betimlemektedir. Sonuç çı ı ı
Makine öğrenmesi istatistiğin kestirimsel yöntemlerini açı ı
karar ağaçları ı ı ı ı
Ancak bu istatistiksel yöntemler makine öğrenmesi temelinde genişletilmiş ve dinamik bir biçime dönüştürülmüştür.
Matematik: Makine öğrenmesi uygulamaları ı ı
matematiğin çok değişkenli fonksiyonlar, limit, türev gibi konuları ı ı ı
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.)
Bilgisayar Bilimleri (Computer Science): Bilgiişlem ve programlama etkinlikleriyle ilgili geniş kapsamlı ı ı
Bilgisayar bilimlerindeki teknikler ve yöntemler kullanı ı
İlgili Konudaki Özel Bilgiler: Şüphesiz her türlü algoritmik yöntem için bir biçimde hedeflenen konuda belli bir bilgi
birikiminin var olması
çalı ı
bilmeyen iyi bir programcı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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:
- Son yı ı ı
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ı ı ı ı
Bu nedenle Python diğer disiplinlerden gelip de veri analizi ve makine öğrenmesi uygulaması
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.
- Python dilinin veri analizi için diğer dillere göre daha erken yola çı ı ı
araştı ı ı ı
Pekiyi Python dilinin veri analizi ve makine öğrenmesi konusunda hangi dezavantajları ı ı
sı
- Python nispeten yavaş bir dildir. Bu yavaşlı ı
programları ı ı ı ı ı ı ı ı ı
veri analizi ve makine öğrenmesinde kullanı ı
ile yazı ı ı ı ı ı ı
- Python yüksek seviyeli bir dil olduğu için dilin olanakları ı ı ı
Pekiyi Python genel olarak yavaş bir dilse bu durum veri analizi ve makine öğrenmesi uygulamaları ı
İşte Python'ı ı ı ı ı ı ı ı ı ı
olmaktan çı ı ı ı ı
ana dil olarak kullanı ı ı
demekle projeyi Python'da hı ı ı
kodlamayı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bilgisayar teknolojisinin gelişmesine paralel olarak veri toplama ve depolama olanakları ı ı
analizinde yeni bir dönemin başladı ı ı ı
daha fazla miktarda veriyle karşı ı ı ı ı ı ı ı ı ı ı
"veri bilimi (data science)" 2000'li yı ı ı ı ı
tanı ı ı ı ı
(insights) elde edilmesine yönelik çalı ı ı ı ı ı ı
"veri bilimcisi (data scientist)" denilmektedir. (Bu bağlamda veri bilimcisinin bir bilim insanı ı ı ı ı
istiyoruz.)
Aslı ı ı ı ı
"veri bilimi" terimi gereksiz biçimde uydurulmuş bir terimdir ve aslı ı
Ancak ne olursa olsun son 30 senedir verilerin işlenmesi ve bunlardan faydalı ı ı ı ı ı ı
işlemlerin klasik istatistiksel çalı ı ı ı ı
olsa da- kendini kabul ettirmiş ve yaygı ı ı
İstatistik ile veri bilimi arası ı ı ı
farklı ı ı ı ı ı
örneklemlerden ziyade çok daha büyük verilerle uğraşma eğilimindedir. İstatistiksel çalı
odaklanı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
12. Ders - 04/02/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İ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ı ı
Aritmetik ortalama hesaplamak için çeşitli kütüphanelerde çeşitli fonksiyonlar hazı ı ı
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şı
NumPy kütüphanesindeki mean fonksiyonu axis temelinde (yani satı
>>> 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])
Pandas kütüphanesinde Series ve DataFrame sı ı ı ı ı ı ı
sı ı ı ı
>>> 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ı ı ı ı
yapı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir merkezi eğilim ölçüsü de "medyan (median)" denilen ölçüdür. Medyan sayı ı ı
ortadaki değerdir. Ancak sayı ı ı ı ı ı ı
ortalaması ı ı
ortalamadan daha fazla zaman alan bir işlemdir. Çünkü medyan için önce değerlerini sı ı ı
medyan işlemi O(N log N) karmaşı ı ı
median isimli fonksiyonla yapı
>>> 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ı ı ı ı ı
Mod işlemi genel olarak O(N log N) karmaşı ı ı ı ı
Sonra yan yana aynı
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ı
modülü içerisindeki mode fonksiyonu kullanı
ModeResult isimli bir sı ı ı ı ı ı ı ı ı ı ı
count örnek öznitelikleri en çok yinelenen değerleri ve onları ı ı ı ı ı ı
demet özelliği gösterdiği için demet gibi de kullanı
Örneğin:
>>> 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]])
Pandas kütüphanesinde Series ve DataFrame sı ı ı ı ı ı
>>> 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ı ı ı ı ı
bazı ı ı ı ı ı ı ı ı
Eğer biz değerleri ortalamadan çı ı ı ı ı ı ı
uzaklı ı ı ı ı ı ı ı ı ı ı
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ı ı ı ı
alı ı ı ı ı ı ı
ç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ı ı ı ı ı ı ı ı
Aynı ı ı
problemlerinde uygun bir işlem olduğunu göreceğiz.)
Standart sapma, değerlerin ortalamadan farkları ı ı ı ı ı
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ı
bölüneceğini" belirtir. Örneğin ddof=0 ise n'e bölme ddof=1 ise (n - 1)'e bölme uygulanı
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
#----------------------------------------------------------------------------------------------------------------------------
Python'ı ı ı
bulunmaktadı
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ı ı ı ı ı ı ı ı ı
Yine NumPy'daki variance fonksiyonundaki ddof default olarak 0, Pandas'taki ddof ise 1'dir.
Pekiyi neden standart sapma varken ayrı
aslı ı ı ı ı ı
bu hesaba ayrı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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
#----------------------------------------------------------------------------------------------------------------------------
13. Ders - 10/02/2024 - Cumartesi
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir deney sonucunda oluşacak durum baştan tam olarak belirlenemiyorsa böyle deneylere "rassal deney (random experiment)"
denilmektedir. Örneğin bir paranı ı ı ı ı ı ı
rassal bir deneydir. Benzer biçimde bir zarı ı ı ı ı ı ı
deneylerdir. Bir deneyin sonucu önceden bilinebiliyorsa bu tür deneylere "deterministik deneyler" de denilmektedir.
Bazı ı
tam olarak kestirilememektedir. Önceden sonucu tam olarak kestirilemeyen süreçlere "olası ı
"stokastik (stochastic)" süreçler denilmektedir.
Deterministik süreçlerle olası ı ı ı ı ı
süreç diye bir şey yoktur. Her şey deterministiktir. Bir sürecin olası ı ı
belirleyemememizden" kaynaklanmaktı ı ı ı ı ı ı
olası ı
olayı ı
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ı ı ı
bir paranı ı ı ı ı ı ı ı ı
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
kuvvet kümesi içerisindeki olaylardı ı ı
Örnek uzayı ı ı ı
atı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Olası ı ı ı ı ı ı ı ı ı ı ı ı ı
(relative frequency)" tanı ı ı ı ı ı ı
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
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ı ı ı ı
olası ı ı ı ı
1) Örnek uzayı ı ı ı ı ı ı ı ı ı ı ı
olma olası ı ı ı ı ı ı ı ı ı
P({1, 2, 3, 4, 5, 6}) = 1'dir. Buradaki P({1, 2, 3, 4, 5, 6}) bir zarı ı ı ı
anlamı ı
2) Herhangi bir olayı ı ı ı ı ı ı ı
belirtilmektedir. O halde olası ı ı ı
3) Bir kümenin olası ı ı ı ı ı ı ı
zarı ı ı ı ı ı ı ı ı ı ı ı ı
yoksa Bu iki kümenin birleşimlerinin olası ı ı ı ı ı
olmak üzere eğer bu iki olay ayrı ∪
Bu üç kural kabul edildiğinde kümeler teorisi, permütasyon, kombinasyon gibi işlemlerle tüm olası
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Olası ı ı ı
Her ne kadar "rassal değişken" teriminde bir "değişken" sözcüğü geçiyorsa da aslı
Rassal değişken bir rassal deney ile ilgilidir. Bir rassal deneyde örnek uzayı ı ı ı ı
reel bir değere eşleyen bir fonksiyon belirtmektedir. Rassal değişkenler genellikle "sözel biçimde" ifade edilirler.
Ancak bir fonksiyon belirtirler. Rassal değişkenler matematiksel gösterimlerde genellikle büyük harflerle belirtilmektedir.
Örneğin:
- R rassal değişkeni "iki zar atı ı ı ı ı ı ı ı ı
bir fonksiyondur. Örnek uzayı ı ı
şöyle belirtilebilir:
R: S -> R
Burada R'nin örnek uzayı ı ı ı ı
yapmaktadı
(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ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Her rassal değişkenin belli bir değer alması ı ı ı ı ı ı ı ı ı
toplamı ı ı ı ı
Yani P(R = 5) ile aslı ı ı ı ı ı
"bu değerlerden herhangi birinin oluşması ı ı ı ı ı ı ı ı
Bir rassal değişkenin olası ı ı ı ı ı ı ı
parantezleri bazı ı
derken bazı ı
belirttiğini ve bu kümenin olası ı ı ı ı ı
K rassal değişkeni rastgele seçilen bir insanı ı ı
onları ı ı ı ı ı
60'tan küçük olması ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Rassal değişkenler tı ı
olabilmektedir. Eğer bir rassal değişken (yani fonksiyon) teorik olarak belli bir aralı ı
alabiliyorsa böyle rassal değişkenlere "sürekli (continous)" rassal değişkenler denilmektedir. Ancak bir rassal değişken
belli bir aralı ı ı
değişkenler denilmektedir. Örneğin "iki zarı ı ı ı ı ı
Çünkü yalnı
süreklidir. Çünkü teorik olarak belli bir aralı ı ı
etmekteyiz. Ancak aslı ı ı ı
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ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka ve makine öğrenmesinde sürekli rassal değişkenler daha fazla karşı ı ı ı
değişkenler ve onları ı ı ı ı
Sürekli bir rassal değişkenin aralı ı ı ı ı ı ı
sürekli rassal değişkenlrin aralı ı ı ı ı ı ı ı ı
fonksiyonları ı
olası ı ı ı ı ı ı
Biz de örneğin P{x0 < X < x1} olası ı ı ı
Bir fonksiyonun olası ı ı ı
kalan alanı ı ı ı ı ı ı
denilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı ı
"normal dağı ı ı ı ı ı ı
Ancak yukarı ı ı ı ı ı
belirlenmiştir. Tabii bu fonksiyon eğrileri birer kalı ı ı ı ı ı
Gauss eğrisi oluşturulabilir. Gauss eğtisinin iki öenmli parametrik bilgisi "orta noktası ı ı ı ı ı
ya da şişmanlı ı ı
Bu durumda örneğin sürekli rassal değişkenlerle ilgili bir soru şöyle olabilir: "Kişlerin zekaları ı
sapması ı ı ı ı ı ı ı ı
Burada bize rassal değişkenin olası ı ı ı ı
için tek yapacağı ı ı
Pekiyi rassal değişkenimiz başkaları ı ı
değişkenin olası ı ı ı ı ı ı ı ı ı ı
olası ı ı ı
aslı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
14. Ders - 11/02/2024 - Pazar
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Doğada en fazla karşı ı ı ı ı ı ı ı ı ı ı ı ı ı
yoğunluk fonksiyonu çan eğrisine benzemektedir. Normal dağı ı ı ı
Ortalama çan eğrisinin orta noktası ı ı ı
Çan eğrisine teknik olarak "Gauss Eğrisi", Gauss eğrisine ilişkin olası ı
denilmektedir.
Gauss fonksiyonu simetrik bir fonksiyondur. Bu fonksiyon ortalama etrafı
hı ı ı
sı ı ı ı ı
Gauss fonksiyonu bir olası ı ı ı
simetirk olduğuna göre ortalamanı ı ı
Değişik ortalama ve standart sapmaya ilişkin sonsuz sayı ı ı
normal dağı ı ı ı ı ı
"Z değerleri" denilmektedir.
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ğı ı ı ı ı ı ı ı
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ı ı ı
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)
def draw_gauss(mu = 0, std = 1, fstart= 0, fstop = 0):
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()
draw_gauss(100, 15, 85, 115)
#----------------------------------------------------------------------------------------------------------------------------
Kümülatif dağı ı ı ı ı
fonksiyondur. Genellikle F harfi gösterilmektedir. Örneğin F(x0) aslı ı ı ı
F(x0) değeri aslı ı ı ı
deyişle sürekli dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı
"merkezi limit teoremi (central limit theorem)" ile daha iyi anlaşı
ele alacağı ı ı ı ı ı ı ı
Bizim de Python programcı ı ı ı ı ı
1) Belli bir x değeri için eksi sonsuzdan o x değerine kadar eğri altı ı ı
aslı ı ı ı
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ı ı
değerinin elde edilmesi)
4) Normal dağı ı ı ı ı ı ı
maddede belirtelen işleme sokarsak normal dağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı
isimli bir sı ı ı ı ı ı ı ı ı ı
NormalDist nesnesi yaratı ı
ortalama için sı ı ı ı
import statistics
nd = statistics.NormalDist(100, 15)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
NormalDist sı ı ı ı
toplam alanı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
Şöyle bir soru sorulduğunu düşünelim: "İnsanları ı ı ı ı ı
Bu durumda zeka puanı ı ı ı ı ı ı ı
P{X > 140} olası ı ı ı ı ı ı ı
olmadı ı ı
nd = statistics.NormalDist(100, 15)
result = 1 - nd.cdf(140)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı ı ı ı ı
Bu tablolar belli bir Z değeri için (standart normal dağı ı ı ı ı ı ı
fonksiyonun değerini vermektedir. Örnek bir Z tablosu aşağı
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ı ı ı ı ı ı ı ı
böyle bir tablo kullanması ı ı
Pekiyi bu Z tabloları ı ı ı ı ı
kümülatif olaı ı ı ı ı ı ı ı ı
transpoze edilebilmektedir. Ortalaması ı ı ı ı ı
Z değeri şöyle hesaplanmaktadı
Z = (x - mu) / std
Örneğin ortalaması ı ı ı ı ı
değeri 2.66'dı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Belli bir kümülatif olası ı ı ı ı ı ı ı ı
Örneğin standart normal dağı ı ı ı ı ı
nd = statistics.NormalDist()
result = nd.inv_cdf(0.99)
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.inv_cdf(0.99)
print(result) # 2.32
#----------------------------------------------------------------------------------------------------------------------------
Belli bir x değeri için Gauss fonksiyonunda ona karşı ı ı ı
için standart normal dağı ı ı
nd = statistics.NormalDist()
result = nd.pdf(0)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
import statistics
nd = statistics.NormalDist()
result = nd.pdf(0)
print(result) # 0.3989422804014327
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı ı ı ı ı ı ı ı
bize bir liste olarak n tane float değer verir. Örneğin:
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
plt.hist(result, bins=30)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı
bulundurulmuştur. Ancak bu fonksiyon bir tane rastgele sayı
#----------------------------------------------------------------------------------------------------------------------------
import random
result = [random.gauss(100, 15) for _ in range(10000)]
import matplotlib.pyplot as plt
plt.hist(result, bins=30)
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ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı
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ğı ı
için kullanı ı ı ı ı ı ı
noktayı ı ı ı
bölen değil de diğer noktalardan bölen değerler için "percentage point" de denilmektedir. Örneğin normal dağı ı
noktası ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm
result = norm.ppf([0.50, 0.68, 0.95], 100, 15)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
norm nesnesinin ilişkin olduğu sı ı ı
y değerlerini vermektedir. Metodun parametrik yapı ı
pdf(x, loc=0, scale=1)
#----------------------------------------------------------------------------------------------------------------------------
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)
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
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()
#----------------------------------------------------------------------------------------------------------------------------
Normal dağı ı ı ı ı ı
olası ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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()
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok karşı ı ı ı ı ı ı ı ı
Burada dağı ı ı ı ı ı ı ı ı
bir alandı ı ı ı ı ı ı ı ı ı
olası ı
f(x) = {
1 / (b - a) a < x < b
0 diğer durumlarda
}
Sürekli düzgün dağı ı ı ı ı ı ı ı
Ancak SciPy içerisinde stats modülünde uniform isimli bir singleton nesne bulunmaktadı ı ı ı
cdf, ppf, pdf ve rvs metotları ı ı ı ı
Örneğin:
result = uniform.pdf(15, 10, 10)
Burada aslı ı ı ı ı
Tabii aslı ı ı ı ı
result = uniform.cdf(15, 10, 10)
Burada a = 10, b = 20 olan bir sürekli düzgün dağı ı
göre elde edilecek bu değer 0.5'tir. uniform nesnesinin metotları
parametrenin a'dan uzaklı ı ı
tüm dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
plt.title('Continupos Uniform Distribution', fontweight='bold')
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
#----------------------------------------------------------------------------------------------------------------------------
Düzgün dağı ı ı ı ı
random modülünde bulnan random fonksiyonu 0 ile 1 arası ı ı
düzgün dağı ı ı ı ı
0 ile 1 arası ı ı ı
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ı ı ı
bir sürekli dağı ı ı ı ı ı ı ı ı ı ı ı
ismiyle yayı ı ı ı ı ı
t dağı ı ı ı ı ı ı ı ı ı ı
(degrees of freedom)" denilen bir değere göre değişir. t dağı ı ı ı ı
t dağı ı ı ı ı ı ı ı
"daha az yüksek ve biraz daha şişman" gibi gözükmektedir. t dağı ı ı ı ı ı ı ı ı ı
standart normal dağı ı ı ı
Yani serbestlik derecesi >= 30 durumunda artı ı ı ı ı ı ı
farklı ı ı
t dağı ı ı ı ı ı ı ı ı ı ı
anlaşı ı ı ı ı ı ı
t dağı ı ı ı ı ı ı ı ı ı ı
testlerinde" kullanı ı ı ı ı
anakütle standart sapması ı ı ı ı ı ı ı ı ı
standart sapması ı ı ı
büyüklüğü >= 30 olduğu durumda zaten t dağı ı ı ı ı ı ı ı
yoğun kullanı ı ı ı ı ı ı ı ı
oluştursa tercih edilebilmektedir.
t dağı ı ı ı
"örneklem büyüklüğünden bir eksik değeri" belirtir. Örneğin örneklem büyüklüğü 10 ise serbestlik derecesi 9'dur. Serbestlik
derecesi (dolayı ı ı ı ı ı ı ı ı ı ı
gibi n >= 30 durumunda artı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
t dağı ı ı ı ı ı ı ı
bulunmamaktadı ı ı ı
kullanı ı ı ı ı ı
önce x değerlerini sonra serbestlik derecesini, sonra da ortalama değeri ve standart sapma değerini parametre olarak almaktadı
Ancak yukarı ı ı ı ı ı ı ı ı
anlaşı ı
Aşağı ı ı ı ı ı ı
olası ı ı ı ı ı ı
standart normal dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
plt.legend(['Standart Normal Dağı ı ı ı ı ı ı ı
y = t.pdf(x, 30)
plt.plot(x, y, color='red')
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
üzerine çizilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, t
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-5, 5, 1000)
plt.figure(figsize=(15, 10))
plt.title('Değişik Serbestlik Derecelerine İlişkin t Dağı ı ı
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)
y_norm = norm.pdf(x)
plt.plot(x, y_norm, color='blue')
df_info = [(2, 'red'), (5, 'green'), (10, 'black')]
for df, color in df_info:
y_t = t.pdf(x, df)
plt.plot(x, y_t, color=color)
plt.legend(['Standart Normal Dağı ı
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Tabii standart normal dağı ı ı ı ı ı ı ı ı ı ı
kümülatif olası ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, t
x = [-0.5, 0, 1, 1.25]
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]
#----------------------------------------------------------------------------------------------------------------------------
Biz bu konuda sürekli dağı ı ı ı ı ı ı ı ı ı ı ı ı ı
değişik olayları ı ı ı ı ı ı ı
ele alacağı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı ı ı ı
kesikli (discrete) dağı ı ı
Kesikli dağı ı ı ı ı ı ı
fonksiyonlar elde edilemeyecek yalnı ı ı ı ı ı ı
eşleyen fonksiyonlara "olası ı
olası ı ı ı ı ı ı ı
doğrudan rassal değişkeninin ilgili noktadaki olası ı ı ı ı ı ı ı
f(x) olmak üzere her x için f(x) değerlerinin toplamı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tı ı ı ı ı ı ı ı ı ı ı
vardı ı ı ı ı ı ı ı ı
kesikli dağı ı ı ı ı ı ı ı ı ı ı
P(X = x) = (e^-lambda * lambda^x) / x!
Dağı ı ı ı ı ı ı ı ı ı ı
değeri belirtmektedir. Lamda ise ortalama olay sayı ı ı
bir değer olabilir. Ancak x değerleri 0, 1, 2, ... n biçiminde 0 ve pozitif tamsayı ı
Yukarı ı ı ı ı ı ı ı ı
karşı ı ı ı ı ı ı ı
"bir futbol maçı ı ı ı ı ı ı ı
olabilir. Bir olgunun poisson dağı ı ı ı ı ı ı
iki yandan uzaklaştı ı ı ı
Poisson dağı ı ı ı ı
bulunmamaktadı ı ı
işlemler kolaylı ı
SciPy'da kesikli dağı ı ı ı
kullanı ı ı ı ı
Burada "pmf" ismi "probability mass function" sözcükleridnen kı ı ı ı
SciPy'daki poisson nesnesinin fonksiyonları
Örneğin maçlardaki gol sayı ı ı ı ı ı ı ı ı
Bu durumda bir maçta 5 gol olma olası ı ı ı
result = poisson.pmf(5, 2)
print(result) # 0.03608940886309672
Yukarı ı ı ı ı ı ı ı ı
Sonra kişiden bazı ı ı ı ı ı ı
soruyu nası ı ı ı ı
(x değeri de dahil olmak üzere) kümülatif olası ı ı ı ı ı ı ı
result = 1 - poisson.cdf(2, 2)
print(result) # 0.3233235838169366
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
grafiğini andı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import poisson
import matplotlib.pyplot as plt
plt.title('Poisson Distribution with Lambda 2', fontweigght='bold')
x = range(0, 40)
y = poisson.pmf(x, 2)
plt.scatter(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Poisson dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import poisson
import matplotlib.pyplot as plt
plt.title('Poisson Distribution with Lambda 100', fontweight='bold')
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ğı ı ı ı ı
ilikin olduğu sı ı ı ı ı
bernoulli.pmf(0, 0.7)
buradan 0.3 değeri elde edilecektir.
----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok karşı ı ı ı ı ı ı ı ı ı ı ı ı
(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ı ı ı ı ı
Aslı ı ı ı ı ı ı ı ı
bahsettiğimiz paranı ı ı ı
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ğı ı ı ı
kullanı ı ı ı ı ı ı
belirtmektedir. Bu fonksiyonlarda birinci parametre "olumlu gerçekleşme sayı ı ı ı ı ı
ve üçüncü parametre de "olumlu gerçekleşme olsaı ı ı ı ı ı
atı ı ı ı ı
binom.pmf(3, 5, 0.5)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Şüphesiz "sonuç çı ı ı
theorem)" denilen teoremdir. Bu teorem George Pólya tarafı ı ı
Bu teoreme göre bir "anakütleden (population)" çekilen belli büyüklükteki örneklerin (samples) ortalamaları ı ı
Örneğin elimizde 1000,000 elemanlı ı
ortalamaları ı ı ı ı ı
denilmektedir. Bu işleme de genel olarak "örnekleme (sampling)" denir. Örneğimizdeki 1000,000 elemanı
sayı ı ı ı ı
elde ederek histogram çizebiliriz. Bu histogramı
Aşağı ı ı ı ı ı
oluşturulmuştur. Sonra bu anakütle içerisinden 10,000 tane 50'lik rastgele örnekler seçilmiştir. Sonra bu seçilen örneklerin
ortalamaları ı ı ı ı ı ı ı ı ı
benzemesi gerekmektedir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
POPULATION_RANGE = 1_000_000_000
POPULATION_SIZE = 1_000_000
NSAMPLES = 10000
SAMPLE_SIZE = 50
population = np.random.randint(0, POPULATION_RANGE, POPULATION_SIZE)
samples = np.random.choice(population, (NSAMPLES, SAMPLE_SIZE))
samples_means = np.mean(samples, axis=1)
plt.hist(samples_means, bins=50)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Tabii yukarı
#----------------------------------------------------------------------------------------------------------------------------
import random
import statistics
POPULATION_RANGE = 1_000_000_000
POPULATION_SIZE = 1_000_000
NSAMPLES = 10000
SAMPLE_SIZE = 50
population = random.sample(range(POPULATION_RANGE), POPULATION_SIZE)
samples_means = [statistics.mean(random.sample(population, SAMPLE_SIZE)) for _ in range(NSAMPLES)]
samples_means_mean = statistics.mean(samples_means)
import matplotlib.pyplot as plt
plt.title('Central Limit Theorem', fontweight='bold')
plt.hist(samples_means, bins=50)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Merkezi limit teoremine göre örnek ortalamaları ı ı ı ı ı ı ı
(Yani bir anakütleden çekilen örnek ortalamaları ı ı ı ı ı
bu durum aşağı
Mu = Mu-xbar (Mu yerine mu sembolü xbar yer yerine de x üstü çizgi olduğunu varsayı ı
Aşağı ı ı ı ı
ortalaması ı ı
örneği almamı ı ı ı ı
elde edilebilir. Bu aşağı
328392407820232468120659145980537063071733850478231049855714233423603813357488386226050559849769116542462344220085901
45569291064005813572729171162888456999821437660641232861427083961136203001102459836375149013720622748800690778924980000
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.pyplot as plt
POPULATION_RANGE = 1_000_000_000
POPULATION_SIZE = 1_000_000
NSAMPLES = 10000
SAMPLE_SIZE = 50
population = np.random.randint(0, POPULATION_RANGE, POPULATION_SIZE)
samples = np.random.choice(population, (NSAMPLES, SAMPLE_SIZE))
population_mean = np.mean(population)
samples_means = np.mean(samples, axis=1)
samples_means_mean = np.mean(samples_means)
plt.hist(samples_means, bins=50)
plt.show()
print(f'Anakütle ortalaması
print(f'Örnek ortalamaları ı ı
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı ı ı ı
ortalaması ı ı ı ı ı ı ı
merkezi limit teoremine göre örnek ortalamaları ı ı ı
Yani örnek ortalamaları ı ı ı ı ı
örnek büyüklüğünü belirtmektedir. Örnek ortalamaları ı ı
Görüldüğü gibi eğer örnek ortalamaları ı ı ı ı
standart hata azaltı ı ı ı ı
Aşağı ı ı ı ı ı ı
uygunluğu gösterilmektedir. Bu bu örnekte de aslı ı ı ı ı ı
değerlerden bir sapma söz konusu olacaktı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
POPULATION_RANGE = 1_000_000_000
POPULATION_SIZE = 1_000_000
NSAMPLES = 10000
SAMPLE_SIZE = 50
population = np.random.randint(0, POPULATION_RANGE, POPULATION_SIZE)
samples = np.random.choice(population, (NSAMPLES, SAMPLE_SIZE))
population_mean = np.mean(population)
population_std = np.std(population)
samples_means = np.mean(samples, axis=1)
samples_means_mean = np.mean(samples_means)
sample_means_std = np.std(samples_means)
plt.hist(samples_means, bins=50)
plt.show()
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.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı
1.000,000,000'a kadar rastgele değerlerden anakütleyi oluşturduk. Yukarı ı
aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
POPULATION_RANGE = 1_000_000_000
POPULATION_SIZE = 1_000_000
population = np.random.randint(0, POPULATION_RANGE, POPULATION_SIZE)
plt.hist(population, bins=50)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
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ğı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Sonuç çı ı ı ı ı ı ı ı ı ı
test etmek gerekebilir. Bunun için anakütleden bir örnek alı ı ı ı ı ı ı ı
belli bir "güven düzeyinde (confidence level)" belirlenir. Buna "normallik testleri" denilmektedir. Aslı
gözle de üstünkörü yapı ı ı
eğrisine benziyorsa biz anakütlenin de normal dağı ı ı ı
dağı ı ı ı ı ı ı
dağı ı ı
açı ı ı ı
bulunan fonksiyonlarla yapı
Hipotez testleri kursumuzun ikinci bölümde ele alı ı
belirli güven düzeyi içerisinde doğrulanı ı ı ı ı ı ı
hipotezi, bunun tersini belirten, yani arzu edilmeyen durumu belirten hipoteze de H1 hipotezi denilmektedir. Örneğin normallik
testindeki H0 ve H1 hipotezleri şöyle oluşturulabilir:
H0: Seçilen örnek normal bir anakütleden gelmektedir.
H1: Seçilen örnek normal dağı ı
scipy.stats modülündeki kstest fonksiyonunun ilk iki parametresi zorunlu parametrelerdir. Birinci parametre anakütleden rastgele
seçilen örneği alı ı ı ı ı ı ı ı
Ancak bu parametre kolaylı ı ı ı ı ı
test etmek amacı ı
Fonksiyonun diğer parametrelerini SciPy dokümanları
biçimde kullanacağı
kstest fonksiyonu çağrı ı ı
ikinci elemanı ı
büyük olup olmadı ı ı ı ı ı ı
değeri 0.01 gibi küçük tutabilirsiniz. Yukarı ı
H0: Seçilen örnek normal dağı ı
H1: Seçilen örnek normal dağı ı
Eğer "p değeri belirlediğimiz kritik değereden (0.05) büyükse H0 hipotezi kabul edilir, H1 hipotezi reddedilir. Eğer p değeri
bu kritik değerden küçükse H0 hipotezi reddelip, H1 hipotezi kabul edilmektedir. Yani özetle bu p değeri 0.05 gibi bir kritik
değerden büyükse örnek normal dağı ı
dağı ı
Aşağı ı ı ı ı
fonksiyonuna sokulmuştur.
#----------------------------------------------------------------------------------------------------------------------------
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ğı ı ı ı ı ı ı ı
test yapı ı ı ı ı ı ı
15 olan bir dağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, uniform, kstest
sample_norm = norm.rvs(100, 15, size=1000)
result = kstest(sample_norm, 'norm', args=(100, 15))
print(result.pvalue)
sample_uniform = uniform.rvs(100, 100, size=1000)
result = kstest(sample_uniform, norm.cdf, args=(100, 100))
print(result.pvalue)
#----------------------------------------------------------------------------------------------------------------------------
Shapiro-Wilk testi de tamamen benzer biçimde uygulanmaktadı ı ı ı
tek bir parametresi vardı ı ı
standart sapmaya ilişkin olabilir. Yani bizim dağı ı ı ı
gerekmemektedir.
Aşağı ı ı ı ı ı ı
seçilip Shapiro-Wilk testine sokulmuştur. Buradan elde edine pvalue değerlerine dikkat ediniz.
#----------------------------------------------------------------------------------------------------------------------------
from scipy.stats import norm, uniform, shapiro
sample_norm = norm.rvs(100, 15, size=1000)
result = shapiro(sample_norm)
print(result.pvalue)
sample_uniform = uniform.rvs(100, 100, size=1000)
result = shapiro(sample_uniform)
print(result.pvalue)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi Kolmogorov-Simirnov testi ile Shapiro-Wilk testi arası ı ı ı ı ı ı
spesifik farklı ı ı ı ı
Shapiro-Wilk testinin kullanı ı ı ı
testi Kolmogorov-Simirnov testine göre daha iyi bir sonunun elde edilmesine yol açmaktadı
testini tercih edebilirsiniz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İstatistikte örneğe dayalı ı ı ı ı
(parameter estimation)" denilmektedir. Parametre tahmini "noktasal olarak (point estimate)" ya da "aralı
(interval estimate)" yapı ı ı ı
tahmin edilmesi önemli bir konudur. Böylece biz anakütlenin tamamı ı ı ı ı
anakütle ortalaması ı ı ı ı
aralı ı ı ı ı
kullanı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bizim anakütle ortalaması ı ı ı ı ı
standart sapması ı ı
o örneğin ortalaması ı ı ı
Örneğin seçtiğimiz güven düzeyi %95 olsun. Bu durumda bizim örneğimiz örnek ortalamaları ı ı ı ı ı ı
soldan 0.025 ve sağdan 0.975 kümülatif olası ı ı ı ı
bu aralı ı ı ı ı ı ı ı ı ı ı
ortalaması ı ı ı
içerisinde bu aralı ı ı ı ı
dağı ı ı ı ı ı ı
yoluyla" da yapabiliriz.
Ö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)
print(f'{lower_bound}, {upper_bound}') # 105.20454606435501, 112.79545393564499
Burada biz anakütlenin standart sapması ı ı ı ı ı ı ı
hesaplayabildik. Buradan elde ettiğimiz güven aralı ı ı
105.20454606435501, 112.79545393564499
Güven düzeyini yükseltirsek güven aralı ı ı ı ı
olalı
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
Burada güven aralı ı ı ı
104.01192800234102, 113.98807199765896
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)
print(f'{lower_bound}, {upper_bound}') # 105.20454606435501, 112.79545393564499
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı ı ı ı
noktadan sonra bu daraltma azalmaya başlamaktadı
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ı ı ı ı ı ı
bizim örnekleri >= 30 biçiminde seçmemiz uygun olur.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi eskiden bilgisayarları ı ı ı ı
hale getirmek için ortalaması ı ı ı ı ı ı
tablosu dendiğini anı ı ı ı ı ı
değerleri dendiğini anı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı ı ı ı
güven aralı ı ı ı
Z değerine aşağı ı ı ı
Z = (X - mu) / sigma
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
print(f'{lower_bound}, {upper_bound}') # 105.20454606435501, 112.79545393564499
#----------------------------------------------------------------------------------------------------------------------------
Ö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
girilmelidir. Metodun ikinci ve üçüncü parametreleri örnek ortalamaları ı ı ı ı ı
belirtir. Tabii ikinci parametre elde etmiş olduğumuz örneğin ortalaması ı ı ı
bir demetle geri döner. Demetin ilk elemanı ı
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)
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ı ı ı ı
edilmştir. Bu örneğe dayanı ı
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ı ı ı
anakütle ortalaması ı ı ı ı ı ı
standart sapması ı ı ı ı ı ı ı ı ı ı
t dağı ı ı ı ı ı ı ı ı
durumda örneğin standart sapması ı ı ı ı ı ı ı ı ı ı ı
serbestlik derecesi denilen bir değere sahip olduğunu anı ı ı
Ayrı ı ı ı ı ı ı
standart sapması ı ı ı ı ı ı
Burada bölmenin neden (N - 1)'e yapı ı ı ı ı ı ı ı ı
bu konuyu açı ı ı
değil s harfiyle belirtilmektedir.
Anı ı ı ı ı
freedom)" deniyordu. Standart sapma ya da varyans hesabı ı ı
default 0 iken Pandas'da 1'dir. Bu ddof parametresi (N - değer)'deki değeri belirtmektedir. Yani ddof = 0 ise bölme N'e ddof = 1 ise
bölme (N - 1)'e yapı ı
Şimdi anakütleden aşağı ı
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)
print(f'[{lower_bound}, {upper_bound}]')
Burada örneğin standart sapması ı ı ı ı ı ı ı ı ı
değil t dağı ı ı ı ı ı ı
örnek büyüklüğünün bir eksik değeri olarak alı ı ı ı ı ı ı
Örneklem dağı ı ı ı ı ı ı ı ı
sem isimli bir fonksiyon da bulunmaktadı ı ı
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)
Serbestlik derecesi 30'dan sonra artı ı ı ı ı ı ı ı ı ı ı ı
örnek büyüklüğü 35'tir. Örnek büyüklüğü >= 30 durumunda t dağı ı ı ı ı
bu örnekte t dağı ı ı ı ı ı ı ı ı
t dağı ı ı ı ı ı ı ı
Genellikle t tabloları ı ı ı
durumunda t tablosu yerine Z tabloları ı ı ı ı ı ı ı ı
için N >= 30 durumunda da t dağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Tı ı ı ı
bulunmaktadı ı ı ı ı ı ı ı ı
yapı ı
interval(confidence, df, loc=0, scale=1)
Buradaki confidence parametresi yine "güven düzeyini (confidence level)" belirtmektedir. df parametresi serbestlik derecesini
belirtir. loc ve scale parametreleri de sı ı
parametresine biz örneğimizin ortalaması ı ı ı ı ı ı ı
Tabii örneklem dağı ı ı ı ı ı ı ı
değerlerini bir demet biçiminde geri döndürmektedir. Örneğin:
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}]')
#----------------------------------------------------------------------------------------------------------------------------
Ana kütlenin standart sapması ı
ana kütlenin normal dağı ı ı ı ı
örnek yeteri kadar büyükse (tipik olarak >= 30) ana kütlenin hesaplamalarda normal dağı ı ı
t dağı ı ı ı ı ı
>= 30) t dağı ı ı ı ı
Pekiyi örneğimiz küçükse (tipik oalrak < 30) ve ana kütle normal dağı ı ı ı ı ı ı
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ğı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Her türlü veri analizi, veri bilimi ve makine öğrenmesi uygulaması ı
aşaması ı ı ı
Günümüzde sensör teknolojilerinin de gelişmesiyle verilerin otomatik olarak toplanması ı ı ı ı
birtakı ı
doğal akı ı ı ı ı ı
eğitim amacı ı
sitelere üye olmanı ı ı
önceden de belirttiğimiz gibi en yaygı ı ı ı
Bu durumda verileri kullanı ı ı ı
çı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Veriler toplandı
"verilerin hazı ı ı
temel işlemler üzerinde duracağı ı ı ı ı ı
getirilmesi tipik olarak aşağı
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ı ı ı ı ı ı ı
k tane sütun haline getirilmesi sürecine boyutsal özellik indirgemesi denilmektedir. Bu konu kursumuzda ileride ayrı
ele alı ı
6) Verilerin Çoğaltı ı ı
uygulayabilmek için sayı ı ı ı ı ı ı
yeni verilerin oluşturulması ı ı ı ı ı
Örneğin bir resimden döndürülerek pek çok resim elde edilebilir. Benzer biçimde örneğin bir resmin çeşitli kı ı ı
yeni resimler oluşturulabilir. Özellik mühendisliğinin "sütun eklemeye yönelik", verilerin çoğaltı ı ı ı
yönelik" bir süreç olduğuna dikkat ediniz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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.
2) Rastgele Oluşan Ekisik Veriler (Missing At Random - (MAR): Burada eksik veriler bir kalı ı ı
başka sütunları ı
olması ı ı ı ı
yanlı
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ı ı ı ı ı
fonksiyonu bir süredir yazı ı ı ı ı
farklı
np.float64 NaN değeri olarak ele almaktadı
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ı ı ı ı ı
bool türden bir DataFrame ya da Series nesnesi vermektedir. bool üzerinde sum işlemi yapı ı ı
değerler 1 olarak işleme girer. Dolayı ı ı ı ı ı
isna fonksiyonunun diğer bir ismi isnull biçimindedir.
2) Eksik verilerin toplam sayı ı
df.isna().sum().sum() ya da pd.isna(df).sum().sum()
isna fonksiyonu (ya da metodu) sütunsan temelde eksik verilerin sayı ı ı ı ı
verecektir.
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
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
"Melbourne Housing Snapshot (MHS)" veri kümesinin eksik veri bakı ı ı
gibi yapı ı
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
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı ı ı
kümesi ile ne yapmak istediğimize bağlı ı ı
içeren sütunlar atı ı ı ı ı ı
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.
Her ne kadar bu sütun tamsayı
yine yuvarlama da uygulayabiliriz. Örneğin:
impute_val = df['BuildingArea'].mean().round()
df['BuildingArea'] = df['BuildingArea'].fillna(impute_val) # eşdeğeri df['Car'].fillna(impute_val, inplace=True)
Veri kümesinin YearBuilt sütunu binanı ı ı ı ı ı
sahiptir? Aslı ı ı ı ı ı ı ı
ölçek olarak değerlendirilebilir. Ancak genellikle bu tür yı ı ı
olabilmektedir. O halde biz bu sütunun ortalama değeri olarak medyan işlemi uygulayabiliriz:
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)
Pandas'taki DataFrame ve Series sı ı ı ı ı ı
birden fazla değer olabilecğei için bu değerlerin hepsinin verilmesi tercih edilmiştir.) Dolayı ı
ilk elemanı ı
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ı ı
SimpleImputer sı ı ı ı ı ı
dizisi geçirecekseniz onun iki boyutlu olması ı
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')
...
SimpleImputer sı ı ı ı
kullanı
bu parametreyle belirtmemiz gerekir. Örneğin:
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ı ı ı ı ı ı
dizi vermiş olalı ı ı ı ı ı ı ı ı ı
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
parametresi ise hang, sütun sayı ı ı ı ı
Fonksiyonu şöyle yazabiliriz:
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
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)
#----------------------------------------------------------------------------------------------------------------------------
LabelEncoder sı ı ı ı ı ı ı
hangi etiketlerin hangi sayı ı ı ı
onun yazı ı ı ı ı
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ı ı ı ı ı
"one hot encoding" denilen biçimde sayı ı ı ı
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')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kategorik verilerin 0'dan itibaren LabelEncoder ya da OridnalEncoder sı ı ı ı ı ı ı
Çü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
...
Burada 3 renk olduğunu düşünelim. Bunun "one hot encoding" dönüştürmesi şöyle olacaktı
Kı ı ı
1 0 0
1 0 0
0 1 0
1 0 0
0 0 1
0 1 0
0 0 1
...
Eğer sütundaki kategori sayı ı ı ı
ikili sütunlar 0 ve 1 biçiminde kodlanabilir. (Yani bu işlem LabelEncoder sı ı ı ı
iki kategori içeren sütunları ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
"One hot encoding" yapmanı ı
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
"One hot encoding" yapı ı
vererek atama yapı ı ı
ö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
olduğuna dikkat ediniz. Çünkü birden fazla sütun tek hamlede "one hot encoding" yapı ı ı ı
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
Burada "RenkTercihi"nin yanı ı
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ı ı ı ı ı
"one hot encoding" işleminden önce NumPy dizisine geçip hiç isimlerini oluşturmadan geri kalan kı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
One hot encoding yapmanı ı
bizden bir DataFrame, Series ya da dolaşı ı
geçirirsek fonksiyon oldukça akı ı ı ı ı
eder. Yalnı ı ı ı ı
nesnesi verir. Pandas ile çalı ı ı ı
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 çı ı ı
Biz bir DataFrame nesnesinin tüm yazı ı ı ı ı ı ı
isteyebiliriz. Bu durumda fonksiyon DataFrame nesnesinin diğer sütunları ı
transformed_df = pd.get_dummies(df, columns=['Meslek'], dtype='uint8')
Biz burada yalnı ı
"one hot encoding" yapı ı
"test.csv" dosyası ı ı ı ı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir "one hot encoding" uygulama yöntemi de "tensorflow.keras" kütüphanesindeki "to_categorical" fonksiyonudur. Bazen
zaten Keras ile çalı ı
sayı ı ı
uygulamalı ı ı ı
seçeneklere göre kullanı ı
bulunnaktadı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
"One hot encoding" yapmanı ı ı
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
Burada sütunda üç farklı ı ı ı ı ı ı
RenkTercihi
-----------
0
1
2
2
1
0
1
3 farklı ı
1 0 0
0 1 0
0 0 1
Sonrada bu birim matris bir dizi ile indekslenirse "one hot encoding" işlemi gerçekleştirilir.
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')
#----------------------------------------------------------------------------------------------------------------------------
"One hot encoding" işleminin bir versiyonuna da "dummy variable encoding" denilmektedir. Şöyle ki: "One hot encoding" işleminde
n tane kategori için n tane sütun oluşturuluyordu. Halbuki "dummy variable encoding" işleminde n tane kategori için n - 1
tane sütun oluşturulmaktadı ı ı ı
Kı ı ı
Mavi Yeşil
0 0 (Kı ı ı
1 0 (Mavi)
0 1 (Yeşil)
Görüldüğü gibi kategorilerden biri (burada "Kı ı ı ı ı ı ı
eksiltilmiştir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
"Dummy variable encoding" işlemi için farklı ı ı ı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
Sütundaki kategori sayı ı
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ı
sı ı ı ı
başka kodlamaları ı ı ı
yöntem aslı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Binary encoding yönteminde her kategori "ikilik sistemde bir syayı ı
kategori olsun. Bu kategoriler 0'dan 255'e kadar numaralandı ı ı ı
ifade edilebilir. Örneğin bir kategorinin sayı ı ı ı ı
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
BinaryEncoder sı ı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
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
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay zeka ve makine öğrenmesi alanı ı ı ı
"derin öğrenme (deep learning)" denilen yöntemler gelmektedir. Biz de bu bölümde belli bir derinlikte bu konuları ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay Sinir ağları ı ı
tarafı ı ı ı ı
ortaya atı ı ı ı ı ı ı ı
yı ı ı ı ı ı
henüz elektronik bilgisayarları ı ı ı
bir CPU gücü gerekmekteydi. Bu nedenle özellikle 1960 yı
ağları ı ı
hepten artmı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı
- Finansal uygulamalar (portföy yönetimi, kredi değerlendirmesi, sahtecilik, gayrimenkul değerlemesi, döviz fiyatları ı
- 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 çı ı ı ı ı ı ı
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.
Makine öğrenmesindeki yapay sinir ağları ı ı ı ı ı
Ancak artı ı ı ı
yerine yalnı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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)
Artı ı ı ı
edilecektir. Buradaki XW işleminin artı ı ı
X matrisi bir satı ı
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.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir sinir ağı ı ı ı
çı ı ı ı ı ı ı
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ğı ı ı
Örneğin biz bir dairenin fiyatı ı ı ı ı
şu verilerin toplandı ı ı ı
- 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ı ı ı ı ı ı ı ı ı
ağı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı
kestirim yapmak istediğimizde ağı ı ı ı ı
bize çı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı
lojistik regresyon terimi yerine daha çok "sı ı ı ı ı
de kullanacağı ı ı ı
terimini kullanacağı ı ı ı ı
ile bir ilgisi yoktur. Buradaki "lojistik" sözcüğü mantı
"statistics" terimlerinin birleştirilmesiyle uydurulmuştur.
Lojistik olsun ya da olması ı ı ı
sürecidir. Örneğin:
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ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Sı ı ı ı ı ı ı ı ı ı
problemlerinde eğer çı ı ı ı ı ı ı ı ı ı ı
(binary classification)" problemleri denilmektedir. Örneğin bir film hakkı ı ı ı ı
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ğı
"doğrusal olarak ayrı ı ı ı ı ı ı
çoklu regresyon problemleri çözülebilmektedir. Her ne kadar tek bir nöron bile bazı
karmaşı ı ı ı ı ı ı ı ı
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ı ı ı ı ı
nöron sayı ı ı ı ı ı ı
bir sinir ağı ı ı
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ğı ı ı ı ı
katmanlardaki nöron sayı ı ı ı ı ı ı ı
gibi özel ve zor problemlerde saklı ı ı ı ı ı ı
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)
df[['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']] = si.fit_transform(df[['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']])
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)
df[['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']] = si.fit_transform(df[['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']])
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)
df[['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']] = si.fit_transform(df[['Glucose', 'BloodPressure',
'SkinThickness', 'Insulin', 'BMI']])
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ı ı ı ı ı
çı ı ı ı ı ı ı
çoklu sı ı ı
isimli loss fonksiyonları
Optimizasyon algoritmaları ı ı ı
performans göstermektedir. En çok kullanı ı ı ı
"gradient descent" denilen genel optimizasyon yöntemini farklı ı ı
ilerleyen bölümlerinde ele alı ı
compile metodunda optimizasyon algoritması ı ı ı
sı ı
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ı ı ı
denilen metrik fonksiyon, çoklu sı ı ı
problemleri için de "mean_absolute_error" isimli metrik fonksiyon sı ı ı ı ı ı ı
problemi için biz eğitim sı ı ı ı
compile metodunu şöyle çağı ı ı
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ı ı
fit metodunda batch_size parametresiyle belirtilmektedir. Bu değer girilmezse batch_size 32 olarak alı ı
çok uygulama için uygun bir değerdir. Optimizasyon işleminin satı ı ı ı ı ı ı
nedeni vardı ı ı ı ı ı ı ı ı ı ı
denilen olumsuz durum için bir önlem oluşturması ı ı ı ı ı
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ı ı ı ı
epochs sayı ı ı ı ı ı ı ı
belirler. Az sayı ı ı
denilen olumsuz duruma zemin hazı ı ı ı ı ı
sı ı ı ı ı ı ı ı
fonksiyonları ı ı ı ı
duruma geldiğinde eğitim işlemini kesebilir. Ya da uygulamacı
yapabilir. İşlemler bitince epoch'lardaki performansa bakabilir. Olması
yeniden bu sayı ı ı ı ı
karı ı ı ı ı ı ı
veri kümesi karı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı ı ı
kümeyi karı ı ı ı ı ı ı ı ı ı ı ı
bir de validation_data isimli bir parametre vardı ı ı ı ı
sı ı ı ı ı
parametresi girildiyse artı ı ı ı
dikkate alı
model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
validation_split parametresinin default değerinin 0 olduğuna dikkat ediniz. validation_split değerinin 0 olması ı
sı ı ı ı
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ı ı ı ı ı
etmektedir. Örneğin ikili sı ı ı
ancak val_binary_accuracy değerinin %65 olduğunu düşünelim. Bunun anlamı ı ı ı
modelin bir şeyler öğrendiği ama bizim istediğimiz şeyleri öğrenemediği anlamı
epoch'larla sürekli bir biçimde gözden geçiren model artı ı ı ı ı
kümesinde gösterememektedir. İşte bu olguya "overfitting" denilmektedir. Yanlı
kadar kötü bir durumdur. Overfitting oluşumunun çeşitli nedenleri vardı ı ı
epoch'ları
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
6) fit işleminden sonra artı ı ı ı ı
evaluate isimli metodu ile yapı ı
almaktadı ı ı
kullanı ı ı ı
batch yapı ı ı ı ı ı ı
ağ parametrelerinin ayarlandı ı ı ı ı ı ı ı ı ı
işlemlerin hı ı ı ı ı ı ı
metodu bir liste geri döndürmektedir. Listenin ilk elemanı
elemanları ı ı ı
eval_result = model.evaluate(test_dataset_x, test_dataset_y)
Aslı ı ı ı ı ı
metrics_names isimli bir örnek öznietliği (instance attribute) bulundurulmuştur. Bu metrics_names listesindeki isimler bire bir
evalute metodunun geri döndürdüğü liste elemanları
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}')
#----------------------------------------------------------------------------------------------------------------------------
<BURADA KALDIK>
#----------------------------------------------------------------------------------------------------------------------------
7) Artı ı
sı ı ı ı ı ı ı
bize çı ı ı ı
Çünkü predict metodu tek hamlede birden çok satı ı
bile onu iki boyutlu bir matris biçiminde vermeliyiz. Örneğin:
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
predict_result = model.predict(predict_data)
print(predict_result)
predict metodu bize tahmin edilen değerleri iki boyutlu bir NumPy dizisi biçiminde vermektedir. Bunun nedeni aslı ı
çı ı ı ı ı ı ı ı ı
matris verir. O halde örneğin çı ı ı
for i in range(len(predict_result)):
print(predict_result[i, 0])
Tabii iki boyutlu diziyi Numpy'ı ı
yapabilirdik:
for val in predict_result.flatten():
print(val)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Sample')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
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]}')
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
predict_result = model.predict(predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Şimdi yukarı ı ı ı ı ı ı ı ı ı
sayı ı ı ı ı
biçimde çözülebilmektedir. Dolayı ı ı ı ı ı
(şekil tanı ı ı ı ı ı ı
Bu durumda ikiden fazla saklı ı ı
Girdi katmanı ı ı ı ı ı ı ı ı
hot encoding" işlemine sokulmalı ı ı ı ı ı ı ı ı ı ı ı
tarzı ı ı ı ı ı ı ı ı ı
regresyon problemlerinde ise çı ı ı ı ı
Saklı ı ı ı ı ı ı
de bağlı ı ı ı ı ı ı
saklı ı ı ı ı ı
- Problem karmaşı ı ı ı ı ı ı
- Saklı
- Saklı ı
durumuna yol açabilir.
- Eğitim veri kümesi azsa katmanlardaki nöron sayı ı
- Pek çok problemde katmanlardaki nöron sayı ı ı
- Saklı ı ı ı ı ı ı ı
Çeşitli kaynaklar saklı ı ı ı ı
- Saklı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
kadar olabilir. Örneğin girdi katmanı ı ı ı ı ı ı ı ı
5 olabilir.
- Saklı ı ı ı ı ı ı ı ı ı ı
Biz genellikle genel problemlerde iki saklı ı ı
Ancak ileride özel mimarilerde bu durumu farklı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yapay sinir ağı ı ı ı ı
değişebilir. Her eğitimde ağı ı ı ı ı ı ı
1) train_test_split fonksiyonu her çalı ı ı ı ı ı
karı ı
2) Katmanlardaki "w" değerleri programı ı ı ı ı ı
3) fit işleminde her epoch sonrası ı ı ı ı
Bir rastgele sayı ı ı ı ı ı
rassal sayı ı ı
çalı ı ı ı ı ı ı
O halde eğitimden hep aynı ı
unsurları ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Sample')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(32, 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
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]}')
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
predict_result = model.predict(predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Katmanlardaki aktivasyon fonksiyonları ı ı ı ı ı
fonksiyonu yoktur. Saklı ı ı ı
pek çok problemde en çok kullanı ı ı
fonksiyondur. Relu fonksiyonu şöyledir:
x >= 0 ise y = x
x < 0 ise 0
Relu fonksiyonun grafiği aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 1000)
y = np.maximum(x, 0)
plt.title('RELU 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(-10, 10)
plt.plot(x, y)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aktivasyon fonksiyonları
girilebilir. Örneğin:
from tensorflow.keras.activations import relu
...
model.add(Dense(16, activation=relu, name='Hidden'))
Bu modüldeki fonksiyonlar keras Tensorflow kullanı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
İkili sı ı ı ı ı ı ı
Yukarı ı ı ı ı ı ı ı ı
ağı ı ı ı
Pekiyi sigmoid nası
şöyledir:
y = e ** x / (1 + e ** x)
Burada e 2.71828... biçiminde irrasyonel e sayı ı ı ı ı ı ı ı
gibi de ifade edilebilir:
y = 1 / (1 + e ** -x)
Sigmoid eğrisi x = 0 için 0.5 değerini veren x pozitif yönde arttı ı
değerine yaklaşan S şeklinde bir eğridir. Sigmoid fonksiyonu (0, 1) arası ı ı ı
nöronun aktivasyon fonksiyonu sigmoid ise ağdan sonuç olarak 0 ile 1 arası ı ı ı
0.5 ten büyükse onu 1 olarak, 0.5'ten küçükse 0 olarak değerlendiririz. Tabii aslı ı ı ı ı
Yani ağı ı ı ı ı ı ı ı ı ı ı ı ı
o kestirimin 0 olma olası ı ı
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()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import sympy
x = sympy.Symbol('x')
fx = sympy.E ** x / (1 + sympy.E ** x)
dx = sympy.diff(fx, x)
from sympy import init_printing
init_printing()
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()
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok kullanı
kullanı
f(x) = (e ** (2 * x) - 1) / (e ** (2 * x) + 1)
Tanh fonksiyonu adeta sigmoid fonksiyonunun (-1, 1) arası
Tanh fonksiyonu saklı ı ı ı ı
kullanı ı ı ı
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şı ı ı ı ı ı ı ı
problemlerinde çı ı ı ı ı ı ı
Örneğin bir resmin "elma", "armut", "kayı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı
logictic regression)" da denilmektedir. Bu tür problemlerd sinir ağı ı ı ı ı ı
resim sı ı ı ı ı ı ı ı ı
Ağı ı ı ı ı ı ı ı ı ı ı ı ı ı
toplamı ı ı ı ı ı ı ı ı ı ı ı ı ı
toplamı ı ı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
sonucu elde edilmiş olsum:
Elma Nöronunun Çı ı ı
Armut Nöronunun Çı ı ı
Kayı ı ı ı ı
Şeftali Nöronunun Çı ı ı
karpuz Nöronunun Çı ı ı
Burada en büyük çı ı ı ı ı ı
Softmax fonksiyonu şöyle hesaplanmaktadı ı
>>> import numpy as np
>>> x = np.array([3, 6, 4, 1, 7])
>>> x
array([3, 6, 4, 1, 7])
Bu değerlerin soft max değerleri np.e ** x / np.sum(e ** x) biçimindedir.
>> 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
Keras aslı ı ı ı ı ı
ağı ı ı ı ı
uygular. Başka bir deyişle çı ı ı
değerlendirilmektedir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok kullanı ı ı
Yani girdi ile aynı
ne anlamı ı ı ı ı ı
Lojistik olmayan regresyon problemleri çı ı ı ı ı ı ı
bir otomobilin mil başı ı ı ı ı
Keras'ta "linear" ismiyle kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı
algoritması ı ı ı ı
"w" ve "bias" değerlerinin güncellenmesi için bir amaç fonksiyonu görevini görmektedir. Değişik problemler için değişik loss fonksiyonları ı
Programcı ı ı ı ı
modülündeki sı ı
loss fonksiyonları ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Yani bir batch işleminin gerçek sonucu ile ağdan o batch için elde edilecek kestirimö sonuçları ı
hesaplanmaktadı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
- Lojistik olmayan regresyon problemleri için en yaygı ı
Bu fonksiyona Türkçe "Ortalama Karesel Hata" diyebiliriz. Bu fonksiyon gerçek değerlerden kestirilen değerlerin farkı ı
toplamı ı ı ı
mse = np.mean((yi - yi_hat) ** 2)
Burada yi gerçek değerleri, yi_hat ise kestirilen değerleri belirtmektedir.
- Yine lojistik olmayan 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ı ı
ortalaması ı
mae = np.mean(np.abs(yi - yi_hat))
Loss fonksiyonu olarak çoğu kez MSE tercih edilmektedir. Kare işlemi algoritmalar için daha uygun bir işlemdir. Aynı
daha fazla farklı ı ı
- Lojistik olmayan regresyon problemleri için diğer bir loss fonksiyonu da "Mean Absolute Percentage Error (MAPE)" isimli fonksiyondur.
Fonkisyonun sembolikl ifadesi şöyledir:
mape = 100 * np.mean((yi - yi_hat) / yi_hat)
- Lojistik olmayan regresyon problemleri için yine "Mean Squared Logaritmic Error (MSLE)" isimli diğer bir loss fonksiyonu da vardı
Bu fonksiyon gerçek değerlerle kestirilen değerlerin logaritmaları ı ı ı ı ı
Sembolik ifadesi şöyledir:
msle = np.mean((np.log(yi) - np.log(yi_hat) ** 2)
- İkili sı ı ı ı ı
gösterinmi şöyledir:
bce = -np.mean(yi * np.log(yi_hat) + (1 - yi) * np.log(1 - yi_hat))
- Cok sı ı ı ı ı ı ı ı
CCE fonksiyonu aslı ı ı ı ı ı
sahip olması ı ı ı ı ı ı ı ı ı ı ı ı
"softmax" olmalı ı ı ı ı ı ı ı ı ı ı
M tane sı ı ı ı ı ı ı
söz konusu olmalı ı
cce = -np.sum(yk * log(yk_hat))
Tabii bu hesap tek bir satı ı ı ı ı ı ı ı
Anı ı ı ı ı ı
olarak belirtebiliriz. Bazı ı ı ı ı ı ı
'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'
'binary_crossentropy'
'categorical_crossentropy'
Aslı ı ı ı
from tensorflow.keras.losses import binary_crossentropy
model.compile(optimizer='rmsprop', loss=binary_crossentropy, metrics=['binary_accuracy])
Örneğin:
from tensorflow.keras.losses import BinaryCrossentropy
model.compile(optimizer='rmsprop', loss=BinaryCrossentropy(), metrics=['binary_accuracy])
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı
almak için kullanı ı ı
Birden fazla metirk fonksiyon kullanı
biçiminde girilmektedir. Metrik fonksiyonlar yazı ı ı
biçiminde de girilebilmektedir.
- "binary_accuracy" ikili sı ı ı ı ı
kaç gözlemin değerinin kestirilen değerle aynı
değerinin 0.70 olması
- Çok sı ı ı ı ı ı ı
Bu fonksiyon da yine gözlemlerin yüzde kaçı ı ı ı ı
iyi bir değer değildir. Çünkü zaten rastgele seçim yapı ı ı ı ı
0.50 başarı ı
- Aslı ı ı ı ı
her epoch'ta eğitim ve sı ı ı ı ı ı
olarak "binary_crossentropy" girmişsek ayrı ı ı
fonksiyon gibi de kullanı ı
- Lojistik olmayan regresyon problemleri için pek çok loss fonksiyonu aslı ı
bir problemde loss fonksiyonu olarak "mean_squared_error" seçmişsek metrik sonksiyon 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 lojistik olmayan regresyon problemlerinde "mean_asbolute_percentage_error", "mean_squared_logarithmic_error"
fonksiyonları ı
Metrik fonksiyonlar yazı ı ı
'binary_accuracy'
'categorical_accuracy'
'mean_absolute_error' ya da 'mae'
'mean_absolute_percentage_error' ya da 'mape'
'mean_squared_error' ya da 'mse'
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Bir sinir ağı ı ı ı ı ı
ağı ı ı ı ı ı
eğitim yapı ı
Keras'ta yepı ı
kastedilmektedir. Ayrı ı ı
Tüm model katmanları ı
Modeli saklamak için hangi dosya formatı ı ı ı
Örneğin bu işlem için "CSV" dosyaları
formattı ı ı
Modeli bir bütün olarak saklamak için Sequential sı ı ı ı ı ı
dosyanı ı ı ı ı
kütüphanesinin kullandı ı ı ı ı
model.save('diabetes.h5', save_format='h5')
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(32, 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
model.save('diabetes.h5', save_format='h5')
#----------------------------------------------------------------------------------------------------------------------------
HDF5 formatı ı ı ı
load_model fonksiyonu bizden yüklenecek dosyanı ı
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
predict_result = model.predict(predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı
kullanı ı
model.save_weights('diabetes-weights', save_format='h5')
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(32, 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
model.save_weights('diabetes-weights.h5', save_format='h5')
#----------------------------------------------------------------------------------------------------------------------------
save_weights metodu yalnı
aynı ı ı ı ı ı ı ı
Aşağı ı
saklamadı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
model.add(Dense(32, activation='relu', input_dim=8, name='Hidden-1'))
model.add(Dense(32, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.load_weights('diabetes-weights.h5')
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
predict_result = model.predict(predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı ı ı
program içerisinde kullanmak istesek ne yapmalı ı
isimli metotlar bulundurmaktadı
geri yükleyebiliriz. Tabii bu işlemi yapabilmek için katman nesnelerine erişmemiz gerekir. Bunun bir yolu katman nesnelerini
yaratı
model = Sequential(name='Sample')
hidden1 = Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1')
model.add(hidden1)
hidden2 = Dense(32, activation='relu', name='Hidden-2')
model.add(hidden2)
output = Dense(1, activation='sigmoid', name='Output')
model.add(output)
Biz artı ı ı ı ı ı
aklenen tüm katman nesnelerini bize layers isimli örnek özniteliği yoluyla bir liste biçiminde vermektedir. Yani örneğin
model.layers[0] zaten ilk saklı ı ı ı
Dense sı ı ı ı ı ı
Listenin ilk elemanı ı ı ı
"w" değerleri iki boyutlu bir NumPy dizisi biçimindedir. Burada satı ı ı
Bu durumda o katmandaki i'inci nöronun önceki katmandaki k'ı ı
Yani "w" değerlerine ilişkin NumPy dizisinin her sütunu o katmandaki belli bir nöronun "w" değerlerini belirtmektedir. Tabii
nöronları
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(32, 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
hidden1 = model.layers[0]
hidden1_weights = hidden1.get_weights()
print(type(hidden1_weights)) # <class 'list'>
print(len(hidden1_weights)) # 2
print(type(hidden1_weights[0]), type(hidden1_weights[1])) # <class 'numpy.ndarray'> <class 'numpy.ndarray'>
print(hidden1_weights[0].shape) # (8, 32)
print(hidden1_weights[1].shape) # (32,)
w = hidden1_weights[0][5, 17]
print(w) # -0.31158817
#----------------------------------------------------------------------------------------------------------------------------
Bir katmandaki "w" ve "bias" değerlerini Dense sı ı ı ı ı
katmandaki "w" değerlerine 0.1 toplanarak değerler geri yüknemiştir. (Bu işlemde bir anlam aramayı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
model.add(Dense(32, activation='relu', input_dim=dataset_x.shape[1], name='Hidden-1'))
model.add(Dense(32, 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(training_dataset_x, training_dataset_y, batch_size=32, epochs=200, validation_split=0.2)
hidden1 = model.layers[0]
hidden1_weights = hidden1.get_weights()
hidden1_weights[0] = hidden1_weights[0] + 0.1
hidden1.set_weights(hidden1_weights)
#----------------------------------------------------------------------------------------------------------------------------
Yapay sinir ağları ı
1) Hedefin Belirlenmesi: Öncelikle uygulamacı ı ı ı
istediği problem nedir? Bir sı ı ı ı
2) Kestirimle İlgili Olacak Özellerin (Sütunları
duyulmaktadı
Burada ilk gelecek özellikler şunla rolabilir:
- Eczanenin konumu
- Ecnanenin önünden geçen günlük insan sayı ı
- Eczannein destek ürünleri satı ı ı
- Eczanenin kozmetik ürünler satı ı ı
- Eczanenin anlaşmalı
- Eczanein büyüklüğü
- Eczanenin yakı ı ı ı ı ı ı
- Eczacı ı ı ı ı ı ı
3) Eğitim İçin Verilerin Toplanması ı
söz konusu olabilir:
- Anketler (Surveys)
- Daha önce elde edilmiş veriler
- Çeşitli kurumlar tarafı
- Sensörler yoluyla elde edilen veriler
- Sosyal ğalardan elde edilen veriler
- Birtakı ı
4) Verilerin Kullanı ı ı ı ı ı ı
Örneğin gereksiz sütunlar atı ı ı ı ı ı ı ı ı ı ı
kullanı ı
işlemleri yapı ı ı
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ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Callback sözcüğü belli bir olay devam ederken programcı ı ı ı
anlamı ı ı ı ı ı ı
sağlayan metotları ı ı ı ı
o işlemleri izleyebilir duruma göre gerekli işlemleri yapabiliriz.
Sequential sı ı ı ı ı ı
kendi callback fonksiyonları ı ı ı ı ı ı
nesneleri çağı ı
Aslı ı ı ı ı ı ı ı ı ı ı ı ı
aslı ı ı ı ı ı ı ı ı ı ı ı ı
callback sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
En sı ı ı ı ı ı ı ı ı ı ı ı ı ı
Sequential sı ı ı ı ı ı
hist = model.fit(....)
fit metodunun bize verdiği History nesnesi eğitim sı ı ı ı ı ı ı
fit metodu zaten eğitim sı ı ı ı
nesnesi aslı ı ı ı ı ı ı ı ı
Ancak nesnenin en önemli elemanı ı ı
yazı ı ı ı ı
türünden nesnelerdir. History nesnesinin history sözlüğü her zaman "loss" ve "val_loss" anahtarları ı ı ı ı ı ı
metriklere ilişkin eğitim ve sı ı ı ı ı ı ı
bu durumda "binary_accuracy" ve "val_binary_accuracy" isimli iki anahtara da sahip olacaktı
anahtarlar sı
belirtir. "loss" değeri ve diğer metrik değerler epoch'un tamamı ı ı ı
Epoch'lar sonrası ı ı ı
fikir edinebilmek için genellikle epoch grafiğini çizerler. Epoch sayı ı ı ı ı ı ı
belli bir epoch'tan sonra "overfitting" denilen olgu kendini göstermekte model gitgide yanlı
İşte uygulamacı ı ı
bunları ı ı
kötü bir gidişata işaret etmektedir. Uygulamacı ı ı ı
Aşağı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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(training_dataset_x, training_dataset_y, batch_size=32, 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.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()
#----------------------------------------------------------------------------------------------------------------------------
CSVLogger isimli callback sı ı ı ı ı ı
CSVLogger nesnesi yaratı ı ı ı ı
doldurulmuş olacaktı
from tensorflow.keras.callbacks import CSVLogger
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[CSVLogger('diabtes-epoch.csv')])
Burada fit metodunun callbacks parametresinin bir liste aldı ı
Aşağı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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'])
from tensorflow.keras.callbacks import CSVLogger
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[CSVLogger('diabtes-epoch.csv')])
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()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
fit bu nesnenin içini dolduracaktı
from tensorflow.keras.callbacks import History
hcb = History()
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[hcb])
Tabii böyle bir işleme gerek yoktur. Çünkü zaten fit metodu bize tamamen yukarı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
LambdaCallback isimli callback sı ı ı ı ı
çağı ı ı
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ı
Bu fonksiyonları ı ı
Fonksiyon Parametreler
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ı ı ı ı
Bu sözlüğün içerisinde loss değeri gibi metrik değerler gibi önemli bilgiler vardı
anahtarları
Aşağı ı ı ı ı
yazdı ı ı ı ı ı ı ı
onun ekranabir şey yazması ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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'])
from tensorflow.keras.callbacks import LambdaCallback
def on_epoch_end(epoch, logs):
diff = logs['loss'] - logs['val_loss']
print(f' Epoch: {epoch}, Diff: {diff}')
lcb = LambdaCallback(on_epoch_end=on_epoch_end)
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[lcb], 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-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()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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'])
from tensorflow.keras.callbacks import LambdaCallback
def on_epoch_begin(epoch, logs):
print(f'Epoch {epoch} begins...', end='\n\n')
def on_epoch_end(epoch, logs):
print(f'\nEpoch {epoch} ends...', end='\n\n')
def on_batch_end(batch, logs):
print(f' Batch: {batch}: Loss: {logs["loss"]}')
lcb = LambdaCallback(on_epoch_begin=on_epoch_begin, on_epoch_end=on_epoch_end, on_batch_end=on_batch_end)
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[lcb], 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-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()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı ı ı ı ı ı
tensorflow.keras.callbacks modülündeki Callback sı ı ı
from tensorflow.keras.callbacks import Callback
class MyCallback(Callback):
pass
İşte eğitim sı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
yazmazsak taban Callback sı ı ı ı ı ı ı ı
Bu metotları
on_epoch_begin
on_epoch_end
on_batch_begin
on_batch_end
on_train_begin
on_train_end
Tabii bir sı ı ı ı ı
LambdaCallback sı ı ı ı ı ı ı
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
Örneğin:
from tensorflow.keras.callbacks import Callback
class MyCallback(Callback):
def on_epoch_end(self, epoch, logs):
print(f'Epoch: {epoch}, Loss: {logs["loss"]}')
mcb = MyCallback()
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[mcb], verbose=0)
Pekiyi zaten LambdaCallback çeşitli durumlarda bizim verdiğimiz fonksiyonları ı ı ı ı ı
yazmamı ı ı ı ı
tutabildikleri için karmaşı ı
Aşağı ı ı ı ı ı ı ı ı ı
ortalaması ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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'])
from tensorflow.keras.callbacks import Callback
class MyCallback(Callback):
def __init__(self):
self.total_loss = 0
self.epochs = 0
def on_epoch_end(self, epoch, logs):
print(f'Epoch: {epoch}, Loss: {logs["loss"]}')
self.total_loss += logs['loss']
self.epochs += 1
def on_train_end(self, logs):
ratio = self.total_loss / self.epochs
print(ratio)
mcb = MyCallback()
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[mcb], 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-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()
#----------------------------------------------------------------------------------------------------------------------------
Tabii aslı ı ı ı ı ı ı ı ı ı ı ı
Örneğin aşağı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('diabetes.csv')
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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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'])
from tensorflow.keras.callbacks import Callback
class MyLambdaCallback(Callback):
def __init__(self, on_epoch_begin=None, on_epoch_end=None, on_batch_begin=None, on_batch_end=None,
on_train_begin=None, on_train_end=None):
super().__init__()
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
self._on_train_begin = on_train_begin
self._on_train_end = on_train_end
def on_epoch_begin(self, epoch, logs):
if self._on_epoch_begin:
self._on_epoch_begin(epoch, logs)
def on_epoch_end(self, epoch, logs):
if self._on_epoch_end:
self._on_epoch_end(epoch, logs)
def on_batch_begin(self, batch, logs):
if self._on_batch_begin:
self._on_batch_begin(batch, logs)
def on_batch_end(self, batch, logs):
if self._on_batch_end:
self._on_batch_end(batch, logs)
def on_train_begin(self, logs):
if self._on_train_begin:
self._on_train_begin(logs)
def on_train_end(self, logs):
if self._on_train_end:
self._on_train_end(logs)
def on_epoch_begin(epoch, logs):
print(f'Epoch {epoch} begins...', end='\n\n')
def on_epoch_end(epoch, logs):
print(f'\nEpoch {epoch} ends...', end='\n\n')
def on_batch_end(batch, logs):
print(f' Batch: {batch}: Loss: {logs["loss"]}')
mlcb = MyLambdaCallback(on_epoch_begin=on_epoch_begin, on_epoch_end=on_epoch_end, on_batch_end=on_batch_end)
hist = model.fit(training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[mlcb], 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-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()
#----------------------------------------------------------------------------------------------------------------------------
Bir nörona giren değerlerin "w" değerleriyle çarpı ı ı ı ı
fonksiyonuna sokulduğunu biliyoruz. Örneğin modelde girdi katmanı
Bu girdiler ilk saklı
aktivasyon fonksiyonuna sokulacaktı ı ı ı
mertebesi yüksek olan sütunun dot-product etkisi yüksek olacaktı
yol açacaktı ı ı ı ı ı ı ı
sütunları ı
denilmektedir. Yapay sinir ağları ı ı ı ı ı ı ı
Özellik ölçeklemesi makine öğrenmesinde başka konularda da gerekebilmektedir. Ancak bazı
her konuda özellik ölçeklemesinin gerekli olup olmadı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Çeşitli özellik ölçeklemesi yöntemleri vardı ı
"minmax ölçeklemesi (minmax scaling)" dir. Özellik ölçeklemesi konusunda aşağı ı ı
Soru: Yapay sinir ağları
Cavap: eğer sütunlar metrebe olarak birbirlerine zaten yakı ı
Soru: Özellik ölçeklemesi gerektiği halde yapmazsak ne olur?
Cevap: Modelin kestirim gücü azalı
Soru: Özellik ölçeklemesi gerekmediği halde özellik ölçeklemesi yaparsak bunun bir zararı ı
Cevap: Hayı
Soru: Kategorik sütunlara (0 ve 1'lerden oluşan ya da one hot encoding yapı ı
Cevap: Bu sütunlara özellik ölçeklemesi uygulanmayabilir. Ancak uygulamanı ı ı
tüm sütunlara özllik ölçeklemesi uyguladı ı ı
Özellik ölçeklemesi x verilerine uygulanmalı ı ı ı
Ayrı ı ı ı ı ı ı ı
yapmı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
En çok kullanı
sütunlar diğerlerden bağı ı ı ı ı ı ı ı
(x - mean(x)) / std(x)
Tabii burada biz formülü pseudo kod olarak verdik. Burdaki mümean sütunun ortalaması ı ı ı
Sütunu bu biçimde ölçeklendirdiğimizde değerler büyük ölçüde 0'ı ı ı
Standart ölçekleme eğer veri kümesindeki sütunlar kendi araları ı ı ı ı
kusursuz bir normal dağı ı ı ı ı ı
dağı ı ı ı ı ı ı
kar-zarar ilişkisi ile veri bilmcisi vermelidir. Sütunları ı ı ı ı ı ı ı ı ı ı
çizerek anlayabiliriz. Dağı ı ı ı ı ı
Standart ölçekleme yapan bir fonksiyonu aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def standard_scaler(dataset):
result = np.zeros(dataset.shape)
for col in range(dataset.shape[1]):
result[:, col] = (dataset[:, col] - np.mean(dataset[:, col])) / np.std(dataset[:, col])
return result
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
result = standard_scaler(a)
print(a, end='\n\n')
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def standard_scaler(dataset):
return (dataset - np.mean(dataset, axis=0)) / np.std(dataset, axis=0)
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
result = standard_scaler(a)
print(a, end='\n\n')
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Ası
bir sı ı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(a)
result = ss.transform(a)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Ö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 ayı ı ı
Ondan sonra eğitim veri kümesi üzerinde özellik ölçeklemesi yapı
train_test_split işleminden sonra yapı ı
veri kümesine de, kestirim işlemi öncesinde kestirim veri kümesine de uygulanması
Aşağı ı ı ı
Burada dikkat edilmesi gereken önemli noktalar şunlardı
- fit işlemi yaknı ı ı ı
- Test işleminde training_dataset_x üzerinde yapı ı ı ı ı
- Kestirimn işlemi yapı ı ı ı ı
- Ölçekleme yapı ı ı ı ı ı
konusudur.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv('diabetes.csv')
dataset_x = df.iloc[:, :-1].to_numpy(dtype=np.float32)
dataset_y = df.iloc[:, -1].to_numpy(dtype=np.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)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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=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.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()
scaled_test_dataset_x = ss.transform(test_dataset_x)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
for i in range(len(model.metrics_names)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
scaled_predict_data = ss.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Diğer çok kullanı
arası ı ı ı ı
(a - min(a)) / (max(a) - min(a))
Bunu bir "pseudo code" olarak ele alı ı ı ı
Min-maz ölçeklemesi yapan bir fonksiyonu aşağı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
def minmax_scaler(dataset):
return (dataset - np.min(dataset, axis=0)) / (np.max(dataset, axis=0) - np.min(dataset, axis=0))
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
result = minmax_scaler(a)
print(a, end='\n\n')
print(result
#----------------------------------------------------------------------------------------------------------------------------
scikit-learn kütüphanesi içerisinde min-max ölçeklemesi yapam MinMaxScaler isimli bir sı ı ı ı ı ı ı ı
diğer scikit-learn sı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
mms.fit(a)
result = mms.transform(a)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de "dibates" veri kümesinde min-max ölçeklemesini kullanalı ı ı ı ı ı ı ı
standart ölçeklemeden bu veri kümesi için daha iyi sonuçlar verdiğini görmekteyiz.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
import pandas as pd
df = pd.read_csv('diabetes.csv')
dataset_x = df.iloc[:, :-1].to_numpy(dtype=np.float32)
dataset_y = df.iloc[:, -1].to_numpy(dtype=np.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 MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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=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.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()
scaled_test_dataset_x = mms.transform(test_dataset_x)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
for i in range(len(model.metrics_names)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
scaled_predict_data = mms.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Diğer kullanı
değerler sütunları
a / abs(max(a))
Mutlak max ölçeklemesi scikit-learn kütüphanesindeki MaxAbsScaler sı ı ı ı ı ı ı ı
benzerdir.
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
a = np.array([[12, 20, 9], [2, 5, 6], [4, 8, 9]])
from sklearn.preprocessing import MaxAbsScaler
mas = MaxAbsScaler()
mas.fit(a)
result = mas.transform(a)
print(result)
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi özellik ölçeklemesi yaptı ı ı ı ı ı
ölçeklemesini scikit-learn kullnarak yaptı ı ı ı ı
bir parçası ı ı ı
özellik ölçeklendirmeleri bir katman nesnesi olarak da bulundurulmuştur. Eğer özellik ölçeklemeleri bir katman ile yapı ı
bu durumda modeli zaten save ettiğimizde bu bilgiler de save edilmiş olacaktı
nası ı ı
Programalamada bir sı ı ı ı ı
scikit-learn içerisinde "object serialiazation" işlemine yönelik özel sı ı ı
standart kütüphanesindeki pickle modülü ile yapı
Aşağı ı ı
saklanmı ı
#----------------------------------------------------------------------------------------------------------------------------
# scaled-model-save.py
import numpy as np
import pandas as pd
df = pd.read_csv('diabetes.csv')
dataset_x = df.iloc[:, :-1].to_numpy(dtype=np.float32)
dataset_y = df.iloc[:, -1].to_numpy(dtype=np.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 MinMaxScaler
mms = MinMaxScaler()
mms.fit(training_dataset_x)
scaled_training_dataset_x = mms.transform(training_dataset_x)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Diabetes')
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=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.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()
scaled_test_dataset_x = mms.transform(test_dataset_x)
eval_result = model.evaluate(scaled_test_dataset_x, test_dataset_y)
model.save('diabetes.h5')
import pickle
with open('diabetes.pickle', 'wb') as f:
pickle.dump(mms, f)
# scaled-model-load.py
from tensorflow.keras.models import load_model
model = load_model('diabetes.h5')
import pickle
with open('diabetes.pickle', 'rb') as f:
mms = pickle.load(f)
import numpy as np
predict_data = np.array([[2,148,58,37,128,25.4,0.699,24], [7,114,67,0,0,32.8,0.258,42],
[5,99,79,27,0,29,0.203,32], [0,110,85,30,0,39.5,0.855,39]])
scaled_predict_data = mms.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for i in range(len(predict_result)):
print(predict_result[i, 0])
for i in range(len(predict_result)):
print("Şeker Hastası ı
#----------------------------------------------------------------------------------------------------------------------------
Auto-MPG isimli veri kümesi otomobillerin mil başı ı ı ı ı ı
Lojistik olmayan regresyon problemleri için sı ı ı ı ı
toplanmı ı ı ı ı ı
https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/
Verti 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 Amerina, 2 ise Avrupa ve 3 ise Japon'dur.
Aşağı ı ı
- Veriler Pandas'ı ı ı ı
- Veri kümesinin 3'üncü indeksli sütununda '?' biçiminde eksik veriler vardı ı ı ı
- Modelde iki saklı ı ı ı ı ı
- Veri kümesinde sütunları ı ı ı ı
- Model "lojistik olmayan regresyon" modelidir. Dolayı ı ı ı ı ı
aktivasyon fonksiyonu 'linear' alı ı ı
- Modelin 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)
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='Auto-MPG')
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)
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]}')
import numpy as np
predict_data = np.array([[4, 91, 81, 2230, 17.5, 71, 1, 0, 0], [4, 150, 92, 2164, 16.5, 70, 0, 1, 0],
[3, 111, 90, 2428, 15, 78, 0, 0, 1]])
scaled_predict_data = mms.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for val in predict_result[:, 0]:
print(val)
model.save('auto-mpg.h5')
import pickle
with open('auto-mpg.pickle', 'wb') as f:
pickle.dump(mms, f)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
kestirilecek değerler de bir CSV dosyası ı
ve özellik ölçeklemesi yapı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.models import load_model
model = load_model('auto-mpg.h5')
import pickle
with open('auto-mpg.pickle', 'rb') as f:
mms = pickle.load(f)
import pandas as pd
df = pd.read_csv('predict-data.csv', header=None)
predict_data = pd.get_dummies(df, columns=[6]).to_numpy()
scaled_predict_data = mms.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for val in predict_result[:, 0]:
print(val)
#----------------------------------------------------------------------------------------------------------------------------
One hot encoding yaparken Pandas'ı ı ı
sütundaki kategorileri kendisi belirlemektedir. Eğer predict yapacağı ı ı ı
bu durum bir sorun yaratı
OneHotEncoder sı ı ı ı ı ı
yoktur.
OneHotEncoder sı ı ı ı
Ancak biz mevcut kategorilerden daha fazla kategori oluşturmak istiyorsak bu parametredeki listeye eklemeler yapabiliriz. categories
parametresi iki boyutlu bir liste olarak girilmelidir. Çünkü birden fazla sütun one hot encoding işlemine sokulabilmektedir. Bu durumda
bu iki boyutlu lsitenin her elemanı ı ı ı
ohe = OneHotEncoder(sparse=False, categories=[[0, 1, 2], [0, 1, 2, 3, 4]])
Burada biz iki sütunlu bir veri tablosunun 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 0, 1, 2, 3, 4 biçimindedir. Eğer bu sütunlarda daha az kategori varsa
burada belirtilen sayı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.models import load_model
model = load_model('auto-mpg.h5')
import pickle
with open('auto-mpg.pickle', 'rb') as f:
mms = pickle.load(f)
import pandas as pd
df = pd.read_csv('predict-data.csv', header=None)
predict_data = pd.get_dummies(df, columns=[6]).to_numpy()
scaled_predict_data = mms.transform(predict_data)
predict_result = model.predict(scaled_predict_data)
for val in predict_result[:, 0]:
print(val)
#----------------------------------------------------------------------------------------------------------------------------
Tabii yukarı ı
elde ettiğimiz DataFrame nesnesine içi sı ı ı
içi 0'larla dolu n tane sütun eklemek için kullanı
df_result = pd.concat([df, pd.DataFrame(np.zeros((n, k)))], axis=1)
Burada n satı ı
aşağı ı
df[['a', 'b', 'c']] = 0
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Lojistik olmayan regresyon problemlerinde kullanı ı
veri kümesidir. Bu veri kümesinde evin çeşitli bilgileri sütunlar haline kodlanmı ı ı ı
Veriler 1070 yı ı ı ı ı ı
https://www.kaggle.com/datasets/vikrishnan/boston-house-prices
Veri kümesinin son sütunu evin fiyatı ı ı ı ı
göre çok daha değerliydi). Veri kümesinde bir tane kategorik alan vardı
yapı ı
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')
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()
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)
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]}')
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 = mms.transform(predict_data)
predict_result = model.predict(scaled_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(mms, f)
#----------------------------------------------------------------------------------------------------------------------------
Girdiyle çı ı ı
gerçekleştirilebilmektedir. Aslı ı ı
biçiminde uygun bir fonksiyonun bulunması
y değerini elde edebiliriz. Tabi y = f(x) fonklsiyonunda x birden fazla değişkeni temsil ediyor olabilir. Benzer biçimde bu
eşitlikte f fonksiyonu birden fazla değer de veriyor olabilir.
İstatistikte regresyon işlemleri tipik olarak aşağı ı ı ı ı ı
- Eğer bağı ı
- Eğer x birden fazla ise buna da genellikle "çoklu regresyon (mulptiple regression)" denilmektedir.
- İstatistikte regresyonun çı ı ı
regresyon (logictics regression)" ya da "logit regresyonu" denilmektedir. Lojistk regresyonda çı ı ı ı
(hasta-sağlı ı ı ı ı ı
(binary logistic regression)" denilmektedir. Eğer çı ı ı ı
sı ı ı
- Eğer girdiyle çı ı ı
isteniyorsa) bu tür regresyonlara "doğrusal regresyon (linear regression)" denilmektedir. Doğrusal regresyon da bağı ı
bir tane ise "basit doğrusal regresyon (simple linear regression)", bağı ı
(multiple linear regression)" biçiminde ikiye ayrı
- Bağı ı ı ı ı ı ı
edilmeye çalı ı
çoklu olabilir. Aslı ı
dönüştürülebilmektedir. Dolayı ı ı ı ı ı
fark yoktur.
- Girdiyle çı ı ı
istenebilir). Bu tür regresyonlara "doğrusal olmayan regresyon (nonlinear regression)" denilmektedir. Her ne kadar polinomlar
da doğrusal değilse de bunlar transformasyonla doğrulsal hale getirilebildikleri için doğrusal olmayan regresyon demekle genel
olarak polinomsal regreson kastedilmemektedir. Örneğin logatirmik, üstel regresyonlar doğrusal olmayan regresyonlara örnektir.
- Bir regresyonda çı ı
regresyonlar denilmektedir. Örneğin:
y1, y2 = f(x1, x2, x3, x4, x5)
Çok değişkenli sözcüğü genellikle bağı ı ı ı ı ı
birden fazla olması ı ı
- Lojistik regresyon problemlerinde bir de "etiket (label)" kavramı ı ı ı ı ı ı
değişkenli sı ı ı ı ı ı ı ı
kullanı ı ı ı
"kişinin şişma olup olmadı ı ı ı ı ı ı ı
kategorileri belirtmek için kullanı ı
logistic regression)" gibi, "tek etiketli çok sı ı ı
gibi terimleri de duyabiliriz.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
çok kullanı ı
x verileri ise çanak yaprakları ı ı
kümesi içerisinde "id" isimli ilk sütun sı ı ı ı ı
aşağı ı
https://www.kaggle.com/datasets/uciml/iris?resource=download
Çok sı ı ı ı ı ı ı ı ı
sokulması ı ı ı ı ı ı ı ı ı ı
gety_dummies fonksiyonu aslı ı ı
ise bir sı ı ı ı ı ı
temsil etmektedir. SciPy'daki OneHotEncoder sı ı ı ı
olduğunu sı ı
Çok sı ı ı ı ı ı ı ı ı ı ı ı ı ı
fonksiyonu olarak softmax alı ı ı ı ı ı
çı ı ı ı ı ı
ziyade onun çı ı ı ı
argmax fonksiyonu ile yapı ı ı ı
Bu 2 numaralı ı ı ı ı ı
encoding sonucundaki 2 numaralı
sütunun hangi sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('iris.csv')
dataset_x = df.iloc[:, 1:-1].to_numpy(dtype='float32')
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse=False)
dataset_y = ohe.fit_transform(df.iloc[:, -1].to_numpy().reshape(-1, 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 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, 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-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(scaled_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('iris-predict.csv', header=None)
predict_data = predict_df.to_numpy(dtype='float32')
scaled_predict_data = ss.transform(predict_data )
predict_result = model.predict(scaled_predict_data)
import numpy as np
result_index = np.argmax(predict_result, axis=1)
predict_names = ohe.categories_[0][result_index]
print(predict_names)
model.save('iris.h5')
import pickle
with open('iris.pickle', 'wb') as f:
pickle.dump(ss, f)
#----------------------------------------------------------------------------------------------------------------------------
Sı ı ı ı ı ı
problemlerde kişiler bir olgu hakkı ı ı ı ı ı ı ı ı
olmadı ı ı ı ı ı ı ı ı ı ı
analiz için oluşturulmuş örnek veri kümeleri vardı ı ı ı
veri kümesidir. Bu veri kümesinde kişiler bir film hakkı ı ı ı ı ı ı
"negative" olarak sı ı ı ı ı ı ı ı ı ı
tespit edilebilmektedir.
Bu problemde girdiler yani dataset_x yazı ı ı ı ı ı ı
birer yazı ı ı
İşte yazı ı ı ı ı ı ı ı
kütüphanesi kullanı ı
İşte uygulamacı ı
vermelidir. Tabii bunı ı ı ı
karşı ı ı ı ı
her sözcüğe unique bir numara karşı ı ı ı ı ı ı
çı ı ı ı ı
1) Sözcüklerin belirttiği sayı ı ı ı ı ı ı ı ı
sözcükler kategorik bir bilgi gibi sayı ı ı ı ı
2) Her yorumda eşit sayı ı ı ı ı ı
gerekmektedir.
İşte bu tür uygulamalarda temelde iki yöntem kullanı ı
1) Vektörüzasyon (vectorization) yöntemi
2) Word embedding yöntemi
Biz burada öncelikle "vektörizasyon" yöntemi üzerinde duracağı
- Her yorum için toplam vocabulary'deki sözcük sayı ı
genişliğinin 100000 olduğunu düşünelim. Bu durumda her yorum 100000'lik bir dizi ile temsil edilecektir. Yani sinir ağı ı
girdi katmanı ı
- Sayı ı ı ı ı ı ı ı
için oluştutulmuş olan dizinin ilgili inmdeksli elemanı ı ı
16, 73452, 9371. Burada biz 100000'lik dizinin 101'inci, 8452'inci, 16'ı ı ı ı ı
Böylece büyük miktarda elemanı ı ı ı ı ı
Artı ı ı
Bu vektörizasyon yöntemi fazlaca bellek kullanma eğilimindedir. Veri yapı ı ı ı ı ı ı
farklı ı
Eğer vocabulary çok büyükse gerçekten de tüm girdilerin yukarı ı
hatta imkansı
Aşağı ı ı ı ı ı ı ı ı ı ı
olabilir:
- Bütün vocabulary word_dict isimli bir sözlükte bulundurulmuştur. Sözlüğün anahtarları
olan numaralardı
- dataset_x dixzisi toplam yorum sayı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
word_set = set()
import regex
for text in df['review']:
words = regex.findall("[A-Za-z-0-9'-]+", text.lower())
word_set.update(words)
"""
word_dict = {}
for index, word in enumerate(word_set):
word_dict[word] = index
"""
import numpy as np
word_dict = {word: index for index, word in enumerate(word_set)}
dataset_x = np.zeros((df.shape[0], len(word_dict)), dtype='int8')
for row, text in enumerate(df['review']):
words = regex.findall("[A-Za-z-0-9'-]+", text.lower())
word_indices = [word_dict[word] for word in words]
dataset_x[row, word_indices] = 1
dataset_y = np.zeros(len(df), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
"""
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
dataset_y = le.fit_transform(df['sentiment'])
"""
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 Dense
model = Sequential(name='IMDB')
model.add(Dense(128, activation='relu', input_dim=dataset_x.shape[1], 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=(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]}')
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:
words = regex.findall("[A-Za-z-0-9'-]+", predict_text.lower())
predict_vect = np.zeros(len(word_dict), dtype='int8')
word_indices = [word_dict[word] for word in words]
predict_vect[word_indices] = 1
predict_result = model.predict(predict_vect.reshape(1, -1))
if predict_result[0, 0] > 0.5:
print('Positive')
else:
print('Negative')
model.save('imdb.h5')
# Reverse operation (exposition only), not correct
rev_word_dict = {value: key for key, value in word_dict.items()}
indices = np.argwhere(dataset_x[0] == 1).flatten()
result_text = ' '.join([rev_word_dict[index] for index in indices])
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
şunlardı
- Aynı ı ı ı ı ı
yazı ı ı ı ı ı ı ı
- Vektörizasyon işlemi bir bağlam oluşturamamaktadı ı ı
nitelemektedir. Ancak bunu bizim ağı ı ı ı ı
ettiğimiz vektör değişmeyecektir.
- Vektörizasyon işlemi çok yer kaplama potansiyelinde olan bir işlemdir. Bu durumda ağı ı
Parçalı ı ı
- Biz işlemden önce tüm sözcükleri küçük harfe dönüştürdük. Bazı ı ı ı
bu gibi bazı ı ı ı ı ı ı ı ı
da eğitimin zorlaşması ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
Sı ı ı ı ı
- Önce CountVectorizer sı ı ı ı ı ı ı ı ı ı ı
belirlemeler yapı ı ı
parametreyi 'int8' gibi küçük bir tür olarak geçmek gerekebilir. Çünkü default durum 'float64' biçimindedir. Sı ı
default durumda tüm sözcükleri küçük harfe dönüştürmektedir. Metodun lowercase parametresi False geçilirse bu dönüştürme
yapı ı ı
cv = CountVectorizer(dtype='uint8')
Bundan sonra scikit-learn kütüphanesinin diğer sı ı ı ı ı
fit metoduna yazı ı ı
oluşturur. Biz de bu sözlük haznesini bir sözlük nesnesi biçiminde nesnenin vocabulary_ özniteliğinden elde edebiliriz. Örneğin:
texts = ['Film güzeldi ama oyuncular kötü oynamı ı ı
gibi bitti.']
cv = CountVectorizer(dtype='uint8')
cv.fit(texts)
print(cv.vocabulary_)
Ası ı ı ı
vektörel hale getirilmiş olan yazı ı
sparse_result = cv.transform(texts)
Seyrek matrisleri normal matrise dönüştürmek için seyrek matris sı ı ı ı ı ı ı
dense_result = sparse_result.todense()
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.feature_extraction.text import CountVectorizer
texts = ['Film güzeldi ama oyuncular kötü oynamı ı ı
zgibi bitti.']
cv = CountVectorizer(dtype='uint8')
cv.fit(texts)
print(cv.vocabulary_)
sparse_result = cv.transform(texts)
dense_result = sparse_result.todense()
print(dense_result)
Şöyle bir çı ı
{'film': 7, 'güzeldi': 9, 'ama': 0, 'oyuncular': 12, 'kötü': 10, 'oynamı ı ı
'eğlendim': 6, 'beklenedildiği': 1, 'gibi': 8, 'bitti': 4}
[[1 0 0 0 0 1 0 1 0 2 1 1 1 1]
[1 1 1 1 1 0 1 2 1 0 0 0 0 0]]
#----------------------------------------------------------------------------------------------------------------------------
CountVectorizer sı ı ı ı ı ı
yazı ı ı ı
True yapı ı ı ı
yapmalı ı ı ı
kazanç sağlanmaya çalı ı
CountVectorizer sı ı ı ı ı
haznesi oluşturulmadan önce tüm yazı ı
durumda tüm yazı ı ı ı
Ancak bazen büyük harfli yorrumlar vurgusal br anlam taşı ı
kaybı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
tensorflow.keras.datasets paketinin içersinde çok kullanı ı ı
boston_housing module
cifar10
cifar100
fashion_mnist
imdb module
mnist module
reuters module
Bu modüllerin load_data isimleri fonksiyonları ı
((training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y)) biçimindedir. Örneğin "Boston Housing Prices" veri kümesini hazı
bir biçimde şöyle yükleyebiliriz:
from tensorflow.keras.datasets import boston_housing
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = boston_housing.load_data()
IMDB verileri de benzer biçimde yüklenebilmektedir:
from tensorflow.keras.datasets import imdb
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data()
Burada load_data fonksiyonunun num_words isimli parametresine eğer bir değer girilirse bu değer toplam kelime haznesinin sayı ı ı
Örneğin:
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data(num_words=1000)
Burada artı ı ı ı ı
sütun uzunlukları ı ı ı ı
imdb modülündeki get_word_index fonksiyonu bize sözcük haznesini bir sözlük olarak vermektedir. num_words ne olurs aolsun bu sözlük her zaman
tüm kelmie haznesini içermektedir.
vocab_dict = imdb.get_word_index()
load_data fonksiyonunun bize verdiği veri kümeleri Numpy dizisi biçimindedir. Ancak bu Numpy dizisinin her elemanı ı
de o yorumda geçen sözcüklerin numaraları ı ı
hazı
rev_vocab_dict = {value: key for key, value in vocab_dict.items()}
Ancak burada önemli bir nokta vardı ı
Bu nedenle veri kümesinden elde ettiğimiz sayı ı ı ı ı ı ı
sonra rev_vocab_dict sözlüüne sokmamı
def get_text(text_numbers):
return ' '.join ([rev_vocab_dict[number - 3] for number in text_numbers if number > 2])
text = get_text(training_dataset_x[0])
print(text)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yazı ı ı ı ı ı ı ı
80'lerin başları ı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı
Haberler toplam 46 farklı
Reuters veri kümesinin orijinali .SGM uzantı ı ı ı ı ı ı ı
getirilmesi biraz yorucudur. Ancak tensorflow.keras.datasets paketi içerisinde reuters isimli modül tı ı
bu veri kümesini hazı ı ı ı ı ı
olarak bulunmaktadı
https://www.kaggle.com/datasets/nltkdata/reuters
Buradaki dosya indirilip açı ı ı ı ı ı ı
training <DIR>
test <DIR>
cats.txt
Buradaki "cats.text" dosyası ı ı ı ı
birtext dosya biçiminde oluşturulmuştur. Buradaki text dosyaları ı ı ı
Aşağı ı ı ı ı ı
- Önce cats.txt dosyası ı ı ı
elde edimiştir.
- Sonra training ve test dizinlerindeki dosyalar tek tek okunarak birer listede toplanmı ı ı ı
bir listede toplanmı ı ı ı ı ı ı ı ı ı
de one hot encoding yapı ı ı
- Eğitimde iki saklı ı ı ı ı ı ı ı ı ı
- Modele önce 100 epoch uygulanmı
- Kestirim için yine kestirilecek yazı
#----------------------------------------------------------------------------------------------------------------------------
import os
training_label_dict = {}
test_label_dict = {}
with open('ReutersData/cats.txt', encoding='latin-1') as f:
for line in f:
a = line.split()
label_type, pos = a[0].split('/')
pos = int(pos[pos.find('/') + 1:])
if label_type == 'training':
training_label_dict[pos] = a[1]
elif label_type == 'test':
test_label_dict[pos] = a[1]
all_labels_set = set(training_label_dict.values())
all_labels_set.update(test_label_dict.values())
all_labels_list = list(all_labels_set)
training_dataset_ylist = []
reuters_training_text = []
for fname in os.listdir('ReutersData/training'):
with open('ReutersData/training/' + fname) as f:
reuters_training_text.append(f.read())
val = training_label_dict[int(fname)]
index = all_labels_list.index(val)
training_dataset_ylist.append(index)
test_dataset_ylist = []
reuters_test_text = []
for fname in os.listdir('ReutersData/test'):
with open('ReutersData/test/'+ fname, encoding='latin-1') as f:
reuters_test_text.append(f.read())
val = test_label_dict[int(fname)]
index = all_labels_list.index(val)
test_dataset_ylist.append(index)
import numpy as np
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse=False, categories=[range(len(all_labels_list))])
training_dataset_y = ohe.fit_transform(np.array(training_dataset_ylist).reshape(-1, 1))
test_dataset_y = ohe.fit_transform(np.array(test_dataset_ylist).reshape(-1, 1))
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
cv.fit(reuters_training_text + reuters_test_text)
training_dataset_x = cv.transform(reuters_training_text).todense()
test_dataset_x = cv.transform(reuters_test_text).todense()
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Reuters')
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(len(all_labels_list), 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=5, 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.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()
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]}')
texts = ['countries trade volume is expanding. Trade is very important for countries.', 'It is known that drinking a lot of coffee is harmful to health. However, according to some, a little coffee is beneficial.']
predict_data = cv.transform(texts).todense()
predict_result = model.predict(predict_data)
predict_result = np.argmax(predict_result, axis=1)
for pr in predict_result:
print(all_labels_list[pr])
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
yüklenmesi yine load_data fonksiyonuyla yapı ı
için kullanı ı ı ı
farklı ı
category_list = ['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']
Tı ı ı ı
x veri kümeleri de yine listelerden oluşmaktadı ı ı ı ı ı
verilerindeki sayı ı ı
Biz bu örnekte CountVectorizer sı ı ı ı ı ı ı ı ı ı
bizim elimizde yazı ı ı ı ı ı ı ı ı ı ı ı ı
Ancak bu işlem yavaş olur. Şimdi sayı ı ı ı ı
convert_text = lambda text_numbers: ' '.join([rev_word_dict[tn - 3] for tn in text_numbers if tn > 2])
print(convert_text(training_dataset_x[0]))
Şimdi vektörizasyon işlemini yapan bir fonksiyon yazalı
def vectorize(sequence, colsize):
dataset_x = np.zeros((len(sequence), colsize), dtype='int8')
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
Aslı
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
from tensorflow.keras.datasets import reuters
(training_dataset_x, training_dataset_y), (test_dataset_x, test_dataset_y) = reuters.load_data()
word_dict = reuters.get_word_index()
rev_word_dict = {value: key for key, value in word_dict.items()}
convert_text = lambda text_numbers: ' '.join([rev_word_dict[tn - 3] for tn in text_numbers if tn > 2])
print(convert_text(training_dataset_x[0]))
import numpy as np
def vectorize(sequence, colsize):
dataset_x = np.zeros((len(sequence), colsize), dtype='int8')
for index, vals in enumerate(sequence):
dataset_x[index, vals] = 1
return dataset_x
training_dataset_x = vectorize(training_dataset_x, len(word_dict) + 3)
test_dataset_x = vectorize(test_dataset_x, len(word_dict) + 3)
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse=False)
ohe_training_dataset_y = vectorize(training_dataset_y, 46)
ohe_test_dataset_y = vectorize(test_dataset_y, 46)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='Reuters')
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(46, 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, batch_size=32, epochs=5, 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.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()
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]}')
texts = ['countries trade volume is expanding. Trade is very important for countries.', 'It is known that drinking a lot of coffee is harmful to health. However, according to some, a little coffee is beneficial.']
import regex
predict_data_list = []
for text in texts:
predict_data_list.append([word_dict[word] + 3 for word in regex.findall("[a-zA-Z!0-9']+", text.lower())])
predict_data = vectorize(predict_data_list, len(word_dict) + 3)
predict_result = model.predict(predict_data)
predict_result = np.argmax(predict_result, axis=1)
category_list = ['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']
for pr in predict_result:
print(category_list[pr])
#----------------------------------------------------------------------------------------------------------------------------
Çok büyük verilerle eğitim ve test işlemi sorunlu bir kondur. Çünkü örneğin fit işleminde büyük miktarda bir veri ile eğitim ve
test yapı ı ı
matrisler oluşmaktadı ı ı ı
denilmektedir. Ancak fit metodu evaluate metodu ve predict metodu seyrek matrislerle çalı ı ı
parçalı ı ı ı
evaluate metotları ı
Parçalı ı ı
Sequence sı ı ı ı ı ı ı ı
sı ı ı ı
metot kullanı ı ı ı ı ı ı
kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Üretici fonksiyon yoluyla parçalı ı
fit metodunun batch_size ve validation_split parametrelerinin bir önemi kalmaz. Çünkü batch miktarı
edilen verilerle yapı ı ı ı ı ı ı
Yine bu biçimde eğitim yapı ı ı ı ı
yapı ı ı ı ı
bir epoch işleminin kaç batch işleminden oluşacağı ı ı ı ı
(Bu parametrenin default değeri 1'dir.) Bu durumda programcı ı
uygulaması ı ı ı ı
nect işlemi yapmaktadı
Aşağı ı ı ı ı
Ancak bu örnekte x ve y verileri üretici fonksiyonlardan elde edilmiştir. Üretici fonksiyon içerisinde toplam "epochs * steps_per_epoch"
kadar yield işlemi yapı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 100
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, (BATCH_SIZE, 1), dtype='int8')
yield x, y
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='PartialDataTraining')
model.add(Dense(64, activation='relu', input_dim=10, name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH)
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı
yine bir üretici fonksiyon yazı ı
yield işlemi yaparak bizden sı ı ı
parça parça alı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 10
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
VALIDATION_STEPS = 5
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE, dtype='int8')
yield x, y
def validation_generator():
for _ in range(EPOCHS):
for _ in range(VALIDATION_STEPS + 1):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE, dtype='int8')
yield x, y
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='PartialDataTraining')
model.add(Dense(64, activation='relu', input_dim=10, name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_data=validation_generator(), validation_steps=VALIDATION_STEPS)
#----------------------------------------------------------------------------------------------------------------------------
Parçalı ı ı ı ı
yine bir üretici fonksiyon girilir. evaluate metodunun steps parametresi bizden test verilerinin kaç parça olarak isteneceğini belirtir.
Yani programcı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 10
STEPS_PER_EPOCH = 20
BATCH_SIZE = 32
VALIDATION_STEPS = 5
TEST_STEPS = 10
def data_generator():
for _ in range(EPOCHS):
for _ in range(STEPS_PER_EPOCH):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE, dtype='int8')
yield x, y
def validation_generator():
for _ in range(EPOCHS):
for _ in range(VALIDATION_STEPS + 1):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE, dtype='int8')
yield x, y
def test_generator():
for _ in range(TEST_STEPS):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE, dtype='int8')
yield x, y
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='PartialDataTraining')
model.add(Dense(64, activation='relu', input_dim=10, name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(data_generator(), epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_data=validation_generator(), validation_steps=VALIDATION_STEPS)
eval_result = model.evaluate(test_generator(), steps=TEST_STEPS)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de gerçekten bellekte büyük bir yer kaplayan vektörizasyon işlemi gerektiren bir örneği parçalı
edelim. Aşağı ı ı ı ı
Hem eğitim, hem sı ı ı ı ı
Anı ı ı ı ı
fit metodu böyle bir karı ı ı ı ı ı ı ı ı ı
Büyük bir veri yapı ı ı ı ı ı ı ı ı
Bu tür durumlarda ası ı ı ı ı ı ı ı
bu index dizisiyle erişmek daha uygun bir yöntemdir. Aşağı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
EPOCHS = 5
BATCH_SIZE = 32
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='int8')
cv.fit(df['review'])
df_x = df['review']
df_y = df['sentiment']
import numpy as np
dataset_y = np.zeros(len(df_y), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
from sklearn.model_selection import train_test_split
temp_df_x, test_df_x, temp_y, test_y = train_test_split(df_x, dataset_y, test_size=0.20)
training_df_x, validation_df_x, training_y, validation_y = train_test_split(temp_df_x, temp_y, test_size=0.20)
def data_generator(data_df_x, data_y, steps, shuffle=True):
indexes = list(range(steps))
for _ in range(EPOCHS):
if shuffle:
np.random.shuffle(indexes)
for i in range(steps):
start_index = indexes[i] * BATCH_SIZE;
stop_index = (indexes[i] + 1) * BATCH_SIZE
x = cv.transform(data_df_x.iloc[start_index:stop_index]).todense()
y = data_y[start_index:stop_index]
yield x, y
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='IMDB')
model.add(Dense(64, activation='relu', input_dim=len(cv.vocabulary_), 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'])
steps_per_epoch = len(training_df_x) // BATCH_SIZE;
steps_per_validation = len(validation_df_x) // BATCH_SIZE;
steps_per_test = len(test_df_x) // BATCH_SIZE;
hist = model.fit(data_generator(training_df_x, training_y, steps_per_epoch), steps_per_epoch=steps_per_epoch, validation_data=data_generator(validation_df_x, validation_y, steps_per_validation + 1, False), validation_steps=steps_per_validation, epochs=EPOCHS)
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(data_generator(test_df_x, test_y, steps_per_test), steps=steps_per_test)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Parçalı ı
sı ı ı ı ı ı ı ı ı
bir epoch'un kaç tane batch içerdiğini tespit etmek için sı ı ı ı ı ı ı
her batch bilgiyi elde etmek için sı ı ı ı ı ı ı ı ı
parametresine geçirir. Bu metottan programcı
Sonra programcı ı ı ı
Sı ı ı ı ı ı ı ı ı
metotları ı ı ı
Ayrı ı ı ı ı ı ı ı ı
bu metot çağrı ı ı ı ı ı ı ı
steps_per_epoch gibi bir parametresi kullanı ı ı ı
Benzer biçimde evaluate işleminde de yine Sequence sı ı ı ı ı ı
verilebilmektedir. Tabii bu metotta on_epoch_end metodunun bir anlamı
duyulmamaktadı
Uygulamada parçalı ı ı ı
Bu yöntemi uygulamak daha kolaydı ı ı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
EPOCHS = 10
BATCH_SIZE = 32
from tensorflow.keras.utils import Sequence
class DataGenerator(Sequence):
def __init__(self, number_of_batches):
super().__init__()
self.number_of_batches = number_of_batches
def __len__(self):
return self.number_of_batches
def __getitem__(self, index):
x = np.random.random((BATCH_SIZE, 10))
y = np.random.randint(0, 2, BATCH_SIZE)
return x, y
def on_epoch_end(self):
print('on_epoch_end')
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential(name='PartialDataTraining')
model.add(Dense(64, activation='relu', input_dim=10, name='Hidden-1'))
model.add(Dense(64, activation='relu', name='Hidden-2'))
model.add(Dense(1, activation='sigmoid', name='Output'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit(DataGenerator(5), epochs=EPOCHS, validation_data=DataGenerator(2))
eval_result = model.evaluate(DataGenerator(20))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi gerçekten parçalı
Aşağı
- DataGenerator isimli sı ı ı ı ı ı
kullanı ı ı
- Bir epoch2un kaç tane batch işleminden oluşacağı ı ı ı
eğitim için gereken parça sayı ı ı ı
- __getitem__ metodu her defası ı ı ı
geçirilmiştir. Dolayı ı
gerekir.
- Her epoch'tan sonra karı ı ı ı ı ı
Karı ı ı ı
- Sı ı ı ı ı ı ı ı ı
sı
- Test işlemi de benzer biçimde yapı ı
#----------------------------------------------------------------------------------------------------------------------------
EPOCHS = 5
BATCH_SIZE = 32
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='int8')
cv.fit(df['review'])
df_x = df['review']
df_y = df['sentiment']
import numpy as np
dataset_y = np.zeros(len(df_y), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
from sklearn.model_selection import train_test_split
temp_df_x, test_df_x, temp_y, test_y = train_test_split(df_x, dataset_y, test_size=0.20)
training_df_x, validation_df_x, training_y, validation_y = train_test_split(temp_df_x, temp_y, test_size=0.20)
from tensorflow.keras.utils import Sequence
class DataGenerator(Sequence):
def __init__(self, x_df, y, batch_size, shuffle=True):
super().__init__()
self.x_df = x_df
self.y = y
self.batch_size = batch_size
self.shuffle = shuffle
self.indexes = list(range(len(self.x_df) // self.batch_size))
def __len__(self):
return len(self.x_df) // self.batch_size
def __getitem__(self, index):
start_index = self.indexes[index] * self.batch_size;
stop_index = (self.indexes[index] + 1) * self.batch_size
x = cv.transform(self.x_df.iloc[start_index:stop_index]).todense()
y = self.y[start_index:stop_index]
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 Dense
model = Sequential(name='IMDB')
model.add(Dense(64, activation='relu', input_dim=len(cv.vocabulary_), 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(DataGenerator(training_df_x, training_y, BATCH_SIZE), validation_data=DataGenerator(validation_df_x, validation_y, BATCH_SIZE, False), epochs= EPOCHS)
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(DataGenerator(test_df_x, test_y, BATCH_SIZE, False))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
Elemanları ı ı ı
için alternatif birkaç veri yapı ı ı ı ı ı ı
Burada yalnı ı ı
matrix = {(34674,17000): 1, (542001, 170): 4, ...}
Burada anahtar satı ı ı
Böyle bir sı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import numpy as np
class DokMatrix:
def __init__(self, shape):
self.shape = shape
self.matrix = {}
def __setitem__(self, index, value):
if not isinstance(index, tuple) or len(index) != 2:
raise IndexError('Invalid index')
if index[0] >= self.shape[0] or index[1] >= self.shape[1]:
raise IndexError('inde out of range')
self.matrix[index] = value
def __getitem__(self, index):
if not isinstance(index, tuple) or len(index) != 2:
raise IndexError('Iinvalid index')
if index[0] >= self.shape[0] or index[1] >= self.shape[1]:
raise IndexError('index out of range')
return self.matrix.get(index, 0)
def __repr__(self):
s = ''
for key, value in self.matrix.items():
if s != '':
s += '\n'
s += f'({key[0]},{key[1]}): {value}'
return s;
def todense(self):
result = np.zeros(self.shape)
for key, value in self.matrix.items():
result[key] = value
return result
dok = DokMatrix((10, 10))
dok[3, 5] = 10
dok[4, 6] = 20
print(dok[3, 5])
print(dok[4, 6])
print(dok[7, 7])
a = dok.todense()
print(a)
#----------------------------------------------------------------------------------------------------------------------------
DOK biçimindeki seyrek matrisler SciPy kütüphanesinde scipy.sparse modülü içerisinde dok_matrix sı ı ı
Biz bir dok_marix sı ı ı ı
onu kullanabiliriz. Seyrek matrisi normal bir Numpy Dizisine dönüştürmek için sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
#----------------------------------------------------------------------------------------------------------------------------
Bir seyrek matris nesnesi ile biz NumPy dizileri üzerinde yaptı ı ı
dilimleyebiliriz. Bu durumda yine bir seyrek matris elde ederiz. dok_matrix sı ı ı ı ı ı
yalnı
Biz seyrek matrislerin karşı ı ı ı ı ı
seyrek matrislerde aynı ı ı
Ancak bu işlemler yavaş olma eğilimindedir.
#----------------------------------------------------------------------------------------------------------------------------
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)
#----------------------------------------------------------------------------------------------------------------------------
Diğer bir seyrek matris veri yapı ı ı ı ı ı ı ı ı
0 olmayan elemanları ı ı ı ı ı ı ı
LIL matrisler SciPy kütüphanesinde scipy.sparse modülünde lil_matrix sı ı ı ı ı ı ı ı ı ı
olduğu gibidir.
#----------------------------------------------------------------------------------------------------------------------------
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)
#----------------------------------------------------------------------------------------------------------------------------
lil_matrix sı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from scipy.sparse import lil_matrix
a = [[0, 0, 10, 0, 5], [12, 0, 11, 0, 7], [0, 0, 0, 0, 0], [0, 0, 5, 0, 9], [0, 0, 0, 0, 0]]
lil = lil_matrix(a)
print(a)
print(f'data={lil.data}') # data=[list([10, 5]) list([12, 11, 7]) list([]) list([5, 9]) list([])]
print(f'rows={lil.rows}') # rows=[list([2, 4]) list([0, 2, 4]) list([]) list([2, 4]) list([])]
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
CSR (Compressed Sparse Row), ve CSC (Compress Sparse Column) matrisleri genel veri yapı ı
Bu ver yapı ı ı ı ı ı ı ı ı ı ı ı
CSR fotmatı ı ı ı ı
CSR matrislerde sı ı ı ı ı ı ı ı
tutulduğu tek boyutlu dizidir. indices dizisi data dizisindeki, elemanları
sı ı ı ı ı
Bu veri yapı ı ı ı ı
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]
csr_matrix sı ı ı ı ı ı ı ı ı ı ı
atama yapmak yavaş bir işlemdir. Çünkü bu işlemler yukarı ı ı
matrisler daha hı ı ı ı ı ı ı ı ı ı ı
mesajı ı ı ı ı ı
CSR matrislerinde satı ı ı ı ı ı ı ı ı ı ı
yapı
#----------------------------------------------------------------------------------------------------------------------------
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)
#----------------------------------------------------------------------------------------------------------------------------
csr matrislerin data, indices ve indptr örnek öznitelikleri yukarı ı
#----------------------------------------------------------------------------------------------------------------------------
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]
#----------------------------------------------------------------------------------------------------------------------------
CSC formatı ı ı ı ı ı
CSC formatı ı ı ı ı
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]
#----------------------------------------------------------------------------------------------------------------------------
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]
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı
Yani örneğin elimizde bir csr_matrix nesnesi varsa biz bu sı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
lil = csc.tolil()
print(lil)
#----------------------------------------------------------------------------------------------------------------------------
Seyrek bir matris train_test_split fonksiyonuyla ayrı ı ı
işlemlerini yapmaktadı ı
örnek çzniteliği ile elde edilebilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Seyrek matrislerin birbirlerine göre avantaj ve dezavantajları
- DOK matriste elemanlara okuma ya da yazma amaçlı ı ı
- LIL matrisler de okuma amaçlı ı ı ı ı ı ı ı ı ı ı ı ı
- CSR matrisler satı ı ı ı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı
sı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
print(result.todense())
#----------------------------------------------------------------------------------------------------------------------------
Benzer biçimde scikit-learn içerisindeki CountVectorizer sı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
from sklearn.feature_extraction.text import CountVectorizer
text = ['this is a test', 'this is a book', 'yes it is', 'it is a book']
cv = CountVectorizer()
result = cv.fit_transform(text)
print(result)
print(result.todense())
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de seyrek matrisler için gerçek bir uygulama yapalı ı
parça parça yapmı ı ı ı ı ı ı ı ı ı ı
todense metodu ile dense matris hale getirelim. Yani biz örneğimizde IMDB verilerini bütünsel olarak vektörize edeceğiz. Ancak parçalı
eğitim sı ı ı ı
transform yapmamı ı ı ı ı ı ı ı ı ı
parçalı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
EPOCHS = 5
BATCH_SIZE = 32
import pandas as pd
df = pd.read_csv('IMDB Dataset.csv')
from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer(dtype='int8')
vectorized_dataset_x = cv.fit_transform(df['review'])
df_y = df['sentiment']
import numpy as np
dataset_y = np.zeros(len(df_y), dtype='int8')
dataset_y[df['sentiment'] == 'positive'] = 1
from sklearn.model_selection import train_test_split
temp_vectorized_x, test_x, temp_y, test_y = train_test_split(vectorized_dataset_x, dataset_y, test_size=0.20)
training_x, validation_x, training_y, validation_y = train_test_split(temp_vectorized_x, temp_y, test_size=0.20)
from tensorflow.keras.utils import Sequence
class DataGenerator(Sequence):
def __init__(self, vectorized_x, y, batch_size, shuffle=True):
super().__init__()
self.vectorized_x = vectorized_x
self.y = y
self.batch_size = batch_size
self.shuffle = shuffle
self.indexes = list(range(vectorized_x.shape[0] // self.batch_size))
def __len__(self):
return self.vectorized_x.shape[0] // self.batch_size
def __getitem__(self, index):
start_index = self.indexes[index] * self.batch_size;
stop_index = (self.indexes[index] + 1) * self.batch_size
x = self.vectorized_x[start_index:stop_index].todense()
y = self.y[start_index:stop_index]
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 Dense
model = Sequential(name='IMDB')
model.add(Dense(64, activation='relu', input_dim=len(cv.vocabulary_), 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(DataGenerator(training_x, training_y, BATCH_SIZE), validation_data=DataGenerator(validation_x, validation_y, BATCH_SIZE, False), epochs= EPOCHS)
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(DataGenerator(test_x, test_y, BATCH_SIZE, False))
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Resimlerle ilgili işlemler yapmaan önce resimler hakkı ı ı ı
tüm görüntü aslı ı
Yani ekrandaki her şey aslı ı ı
Tabii her pixel'in bir rengi de vardı ı ı ı ı ı ı ı
tonal birleşimleriyle ifade edilmektedir. Dolayı ı ı ı ı ı ı ı
o pixel siyah görünüt, hepsi 255 olursa o pixel beyaz görünür. Tüm renkler bu üç rengin girişimi ile elde edilebilmektedir.
Bilgisayar ortamı ı ı
formatlardı ı ı ı
tek yapacağı
bir resim kabaca 100 * 100 * 3 byte yer kaplar. Bu yüzden resimler üzerinde kayı ı ı ı ı ı
aslı ı ı ı ı ı ı ı ı ı ı
bozulur. Sonra onu yeniden BMP'ye dönüştürdüğümüzde aynı ı ı ı ı ı
O halde aslı ı ı ı ı ı ı ı
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 tül perdeden görünüyormuş
etkisi yaratı
ifade edilir. Örneğin PNG dosya formatı ı ı ı ı ı ı ı
Siyah-Beyaz resim demek pixel'leri tam siyah ya da tam beyaz resim demektir. Siyah-Beyaz resimlerde her pixel 1 bit ile tutulabildiğinden dolayı ı
Ancak siyah-beyaz resimler algı ı ı ı ı
Gri tonlamalı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Matplotlib kütüphanesinde bir resmi resim dosyası
dizisi biçiminde veren imread isimli bir fonksiyon vardı ı ı ı
elde ederiz. Örneğin:
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
Bu örnekte biz bir NumPy dizisi elde etmiş olduk. Bu dizinin shape demeti (300, 300, 3) biçiminde elde edilmiştir. Yani söz konusu resim
300x300 pixel'lik bir resimdir. Ancak her pixel'i RGB olan 3 bileşenden oluşmaktadı
Matplotlib kütüphanesinin imshow isimli fonksiyonu pixel bilgilerini alarak resmi görüntüler. Tabii imshow resmi orijinal boyutuyla görüntülememektedir.
imshow resmi ölçeklendirip figür büyüklüğünde görüntülemektedir.
Matplotlib bir resim üzerinde ondan parça almak, onu büyütmrk, küçültmek gibi işlemler için uygun değildir. Bu tür işlemler için
Python programcı ı ı ı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
plt.imshow(image_data)
plt.show()
print(image_data.shape)
#----------------------------------------------------------------------------------------------------------------------------
Örneğin biz bir resmi ters çevirmek için resmin tüm satı ı ı ı ı
pratik bir biçimde yapmaktadı ı ı
iyi araçlardı
#----------------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
image_data = plt.imread('AbbeyRoad.jpg')
plt.imshow(image_data)
plt.show()
import numpy as np
flipped_image_data = np.flip(image_data, 0)
plt.imshow(flipped_image_data)
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Renkli resimler imread fonksiyonu ile okunduğunda row x col x 3 boyutunda olurlar. Gri tonlamalı
boyutunda olurlar. Tabii rol x col ile row x col x 1 arası ı ı ı ı
boyut olarak karşı ı ı ı ı ı
row x col x 3 boyutları ı ı ı
saklanması
Pekiyi renkli bir resmi gri tonlamalı ı
ortalaması ı ı
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)
#----------------------------------------------------------------------------------------------------------------------------
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ı ı ı
ağı ı ı ı ı ı ı ı ı ı
res,m gri tonlamalı ı ı ı ı ı ı ı
için kullanı ı
#----------------------------------------------------------------------------------------------------------------------------
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()
#----------------------------------------------------------------------------------------------------------------------------
Resim tanı ı ı
denilen veri kümesidir. Bu veri kümesinde her biri 28x28 pixel'den oluşan gri tonlamalı ı
0 ile 9 arası ı ı ı ı ı ı
kullanı ı ı ı ı ı
https://www.kaggle.com/oddrationale/mnist-in-csv
Buradan minist_train.csv ve mnist_test.csv dosyaları
Aşağı ı ı ı
Model test edildiğinde %97 civarı ı
yapı ı ı ı ı ı ı
kullanı ı ı ı
Pixel verileri üzerinde eğitime sokulmadan önce Min-Max ölçeklemesi yapı ı ı ı ı
bu pixel verilerinin 255'e bölümüyle oluşturulabilmektedir. Modele çok fazla epoch uygulandı ı ı ı
Bu nedenle epoch sayı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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()
import matplotlib.pyplot as plt
plt.figure(figsize=(20, 40))
for i in range(50):
plt.subplot(10, 5, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=14)
plt.imshow(training_dataset_x[i].reshape(28, 28), 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)
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, 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 numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
gray_scaled_image_data = np.average(image_data, axis=2, weights=[0.3, 0.59, 0.11])
gray_scaled_image_data = gray_scaled_image_data / 255
predict_result = model.predict(gray_scaled_image_data.reshape(1, 784))
result = np.argmax(predict_result)
print(f'{path}: {result}')
"""
import itertools
for x in itertools.islice(training_dataset_x[training_dataset_y == 6], 10):
plt.imshow(x.reshape(28, 28), cmap='gray')
plt.show()
"""
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı
bize pixel verilerini üç boyutlu bir NumPy dizisi olarak vermektedir. Bizim bu verileri reshape ile 784'lük iki boyutlu matrise
dönüştürmemiz gerekir.
#----------------------------------------------------------------------------------------------------------------------------
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=(20, 40))
for i in range(50):
plt.subplot(10, 5, 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)
training_dataset_x = training_dataset_x.reshape(-1, 784) / 255
test_dataset_x = test_dataset_x.reshape(-1, 784) / 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, 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 numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
gray_scaled_image_data = np.average(image_data, axis=2, weights=[0.3, 0.59, 0.11])
gray_scaled_image_data = gray_scaled_image_data / 255
predict_result = model.predict(gray_scaled_image_data.reshape(1, 784))
result = np.argmax(predict_result)
print(f'{path}: {result}')
"""
import itertools
for x in itertools.islice(training_dataset_x[training_dataset_y == 6], 10):
plt.imshow(x.reshape(28, 28), cmap='gray')
plt.show()
"""
#----------------------------------------------------------------------------------------------------------------------------
Evrişim (convolution) genel olarak "sayı ı
Bir verinin başka bir veriyle girişime sokulması ı ı ı
dı ı ı ı ı ı ı
"Evrişimsel Sinir Ağları ı ı ı
Bir resmim evrişim işlemine sokulması ı
ya da "kernel" denilmektedir. Kernel herhangi bir boyutta olabilir. Kare bir matris biçiminde olması
kare matrisler kullanı ı ı ı ı ı
Kernel resmin sol üst köşesi ile çakı ı ı ı ı ı
Sonra kernel resim üzerinde kaydı ı ı ı ı ı ı ı ı ı
Böylece evrişim işlemi sonucunda başka bir resim elde edilmiştir. Örneğin 5x5'lik bir resim olsun:
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
Kullandı ı ı
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
İşte bu biçimde işlemlere devam edersek aşağı
c11 c12 c13
c21 c22 c23
c31 c32 c33
Eğer işlemle ryukarı ı ı
Hedef Resmin Genişliği = Ası
Hedef Resmin Yüksekliği = Ası
Görüldüğü gibi hedef resim ası ı ı ı ı ı
ası ı ı ı ı ı ı ı ı
Tabii ki (kernel genişliği ya da yükseliği - 1) kadar:
Padding Genişliği = Kernel Genişliği - 1
Padding Yüksekliği = Kernel Yüksekliği - 1
Örneğin 5x5'lik resme 3x3'lük kernel uygulamak isteyelim:
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
Padding şu biçimde görünecektir:
a11 a12 a13 a14 a15 p16 p17
a21 a22 a23 a24 a25 p26 p27
a31 a32 a33 a34 a35 p36 p37
a41 a42 a43 a44 a45 p46 p47
a51 a52 a53 a54 a55 p56 p57
p61 p62 p63 p64 p65 p66 p67
p71 p72 p73 p74 p75 p76 p77
Pekiyi padding resme dahil olmadı ı ı ı ı
0 almak ikincisi son n tane satı
Evrişim işleminde kaydı ı ı ı
stride değeri artı ı ı ı ı ı ı
Evrişim işlemi ile ne elde edilmek istenmektedir? Resimlerde evrişim işlemi resmi filtrelemek için kullanı ı
farklı
resmi bulanı ı ı
Bu konu "sayı ı
Aşağı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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()
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi evrişim işleminin yapay sinir ağları ı ı ı ı
Yani bir resmin sı ı ı ı ı ı ı ı ı ı
O halde evrişimsel ağlarda biz uygulayacağı ı ı ı ı
bulmaya çalı ı ı ı ı ı
Resim filtreden geçirildikten sonra yine dense katmanlara sokulur. Yani filtreleme ön katmanlarda yapı ı ı ı
Tabii resmi filtrelerden geçirmek ve bu filtreleri ağı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
ağı ı ı ı ı ı ı
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
Burada aşağı ı ı
b11 b12 b13
b21 b22 b23
b31 b32 b33
Bu kernel'ı ı ı ı ı ı ı
kernel'ı ı ı ı ı ı
katmanmı ı ı ı ı ı
Tabii ki hedef resmin büyüklüğü kadar. Yani 3x3 = 9 tane. Bu katmandaki nöronları ı ı ı ı
değeri anlamı ı ı ı ı ı ı ı ı
buradaki nöronları ı ı ı ı ı ı
oluşturulacak bu evrişim katmanı ı ı ı ı
Aşağı ı
a11 a12 a13
a21 a22 a23
a31 a32 a33
Biz de 2x2'lik aşağı ı ı
b11 b12
b21 b22
Bu işlemin sonucu olarak padding yapı ı ı ı ı ı ı ı
activation(a11 * b11 + a12 * b12 + a21 * b21 + a22 * b22 + b) --->
activation(a12 * b11 + a13 * b12 + a22 * b21 + a23 * b22 + b) --->
activation(a21 * b11 + a22 * b12 + a31 * b21 + a32 * b22 + b) --->
activation(a22 * b11 + a23 * b12 + a32 * b21 + a33 * b22 + b) --->
Burada toplam 4 nöron çı ı ı ı ı ı ı
Aslı ı ı ı ı
filtre kullanabiliriz. Ağı ı ı ı ı ı
resmin anlaşı ı ı ı ı ı ı ı
4x4'lük resimlerden toplam 32 tane elde edilir. Yani toplam nöronları ı ı ı ı ı
kanallı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi evrişim işlemi RGB resimlerde nası ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı
ayrı ı ı ı
else edilen değerler toplanarak teke düşürülür. Yani adeta biz evrişimsel ağlarda renkli resimleri evrişim işlemine soktuktan sonra
onlardan gri tonlamalı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Pekiyi evrişimsel sinir ağları ı ı ı ı
ilişkilendirmektedir. Yani onlara bir bağlam kazandı ı ı ı
komşu pixel'lerle bağı ı ı ı ı ı ı
ilişkilendirilmesi anlamı ı
Bu ağı ı ı ı ı ı ı
denilmektedir. Pek çok uygulamacı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Keras'ta evrişimsel ağları ı ı ı ı ı ı ı
iki boyutla bizden ister. Aslı ı ı ı ı ı ı ı
Conv2D sı ı ı ı ı ı ı ı ı ı
stride miktarı ı ı ı ı ı ı
conv2 = Conv2D(32, (3, 3), padding='same', activation='linear')
Burada toplam 32 filtre uygulanmı ı ı ı ı ı
padding yapı ı ı ı ı ı
Bu katman padding satı ı ı ı ı ı
(1, 1) biçimindedir. Yani kaydı ı ı ı ı
alı ı
Evrişim katmanları ı ı ı ı
tek boyuta indirgemen gerekir. Bu tek boyuta indirgeme işlemi Keras'taki Flatten isimli katmanla yapı ı
model = Sequential(name='MNIST')
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1), name='Conv2D-1', activation='relu'))
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()
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı
eğitilebilir parametrelerin sayı ı ı ı ı
model = Sequential(name='MNIST')
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1), name='Conv2D-1', activation='relu'))
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()
Bu modelden şöyle bir özet elde edilmiştir:
Model: "MNIST"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
Conv2D-1 (Conv2D) (None, 26, 26, 32) 320
Conv2D-2 (Conv2D) (None, 24, 24, 64) 18496
Flatten (Flatten) (None, 36864) 0
Hidden-1 (Dense) (None, 256) 9437440
Hidden-2 (Dense) (None, 128) 32896
Output (Dense) (None, 10) 1290
=================================================================
Total params: 9,490,442
Trainable params: 9,490,442
Non-trainable params: 0
_________________________________________________________________
Burada birinci evrişim katmanı ı ı ı ı ı ı ı
26x26'lı ı ı ı ı ı ı ı ı
sanki diğer evrişim katmanı ı ı
sayı ı ı ı ı ı ı ı
ilişkin nöronları ı ı ı ı ı ı
Yukarı ı ı ı ı
her kanal için ayrı ı ı ı
işleme girecektir. O halde tek bir filtre için eğitilebilir parametrelerin sayı ı ı
olduğuna göre bu değeri 64 ile çarparsak 289 * 64 = 18496 elde edilir. Burada ikinci evrişim katmanı ı ı ı ı ı ı
24 * 24 * 64 = 36864 tanedir. Bu nöronlar Flatten katmanı ı ı ı
O halde bu Dense katmandaki eğitilebilir parametrelerin sayı ı ı ı ı ı
roplam 256 nöron vardı ı ı ı
eğitilebilir parametrelerin sayı ı ı ı ı ı ı ı ı ı ı
nöron bu katmana girdi yapı ı ı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
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()
import matplotlib.pyplot as plt
plt.figure(figsize=(20, 40))
for i in range(50):
plt.subplot(10, 5, i + 1)
plt.title(str(training_dataset_y[i]), fontsize=14)
plt.imshow(training_dataset_x[i].reshape(28, 28), 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)
training_dataset_x = training_dataset_x / 255
test_dataset_x = test_dataset_x / 255
training_dataset_x = training_dataset_x.reshape(-1, 28, 28, 1)
test_dataset_x = test_dataset_x.reshape(-1, 28, 28, 1)
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, Dense, Flatten
model = Sequential(name='MNIST')
model.add(Conv2D(32, (3, 3), input_shape=(3, 3, 1), name='Conv2D-1', activation='relu'))
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()
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 numpy as np
import glob
for path in glob.glob('test-images/*.jpg'):
image_data = plt.imread(path)
gray_scaled_image_data = np.average(image_data, axis=2, weights=[0.3, 0.59, 0.11])
gray_scaled_image_data = gray_scaled_image_data / 255
predict_result = model.predict(gray_scaled_image_data.reshape(1, 28, 28))
result = np.argmax(predict_result)
print(f'{path}: {result}')
#----------------------------------------------------------------------------------------------------------------------------
Evrişimsel ağlarda evrişim katmanları ı ı
parametrelerin sayı ı ı ı ı ı
Ayrı ı ı ı ı ı ı ı ı ı
- Eğitim için gereken zaman fazlalaşı
- Çok nöron olması ı
- Eğitim sonucunda eitim bilgilerinin saklanması ı
İşte bu tür resim tanı ı ı ı ı ı
Bunun için akla gelecek yöntem evrişim katmanları ı ı ı ı ı ı ı
resmin tanı ı ı ı ı ı
Genellikle pooling yöntemi tercih edilmektedir.
Pooling bir grup dikdörtgensel bölgedeki pixel'ler yerine onları
versiyonu vardı ı ı
yönteminde ise dikdörtgensel bölgedeki elemanları ı ı ı
aşağı ı
112 62 41 52
200 15 217 21
58 92 81 117
0 21 45 89
Çerçevimiz 2x2'lik olsun. Bu 2x2'lik çerçeve resim üzerinde sağdan iki aşağı ı ı ı
112 62
200 15
41 52
217 21
58 92
0 21
81 117
45 89
İşte Max Pooling yönteminde bu çerçevelerin en büyük elemanları ı ı ı
200 217
92 117
Bu işlemin sonucunda elde edilen matris ilkinin karekökü kadardı
gibi sı ı ı ı ı ı ı ı ı
tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs)
tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs)
Metotları ı ı
parametreleri yine kaydı ı ı ı ı
"valid" ya da "same" olabilir. "valid" padding yapı ı ı ı ı
Tipik olarak Pooling katmanları ı ı
model = Sequential(name='MNIST')
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1), 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(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()
Burada aşağı
Model: "MNIST"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
Conv2D-1 (Conv2D) (None, 26, 26, 32) 320
Pooling-1 (MaxPooling2D) (None, 13, 13, 32) 0
Conv2D-2 (Conv2D) (None, 11, 11, 64) 18496
Pooling-2 (MaxPooling2D) (None, 5, 5, 64) 0
Flatten (Flatten) (None, 1600) 0
Hidden-1 (Dense) (None, 256) 409856
Hidden-2 (Dense) (None, 128) 32896
Output (Dense) (None, 10) 1290
=================================================================
Total params: 462,858
Trainable params: 462,858
Non-trainable params: 0
Görüldüğü gibi eğitilabilir parametrelerin sayı ı ı ı ı ı ı ı ı ı ı
artacaktı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Renkli resimlerin sı ı ı ı ı ı ı
tensorflow.keras.datasets paketi içerisinde de cifar10 modülünde bulunmaktadı
olan 3 kanallı ı ı ı ı ı ı ı ı ı
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
Veri kümesinin orijinal https://www.cs.toronto.edu/~kriz/cifar.html adresinden indirilebilir. Veri kümesinin CSV biçimi de
https://www.kaggle.com/datasets/fedesoriano/cifar10-python-in-csv adresinden indirilebilir. Veri kümesinin orijinali 5 tane eğitim dosyası
bir tane de test dosyası ı
sözlük bçimine dönüştümemiz gerekir. Bu işlemi yaptı ı
b'labels' anahtarı ı ı ı ı ı ı ı
bir dizinde olduğunu varsayı
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']
Aşağı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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)
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 = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
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-10')
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(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, 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]}')
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
Kers'taki hazı ı ı
hazı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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']
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, 0]], 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-10')
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(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=2 , 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 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]}')
#----------------------------------------------------------------------------------------------------------------------------
CIFAR-100 veri kümesi tamamen CIFAR-10 veri kümesi gibidir. Ancak resimler 10 tane sı ı ı ı ı ı ı
Yani biz CIFAR-100 veri kümesinde resimlerin 10 tane sı ı ı ı ı ı ı
Bu veri kümesi de yine aşağı ı
https://www.cs.toronto.edu/~kriz/cifar.html
Buradaki dosya indirilip açı ı ı ı
Python'ı ı ı ı ı ı ı
edilir. y verilerini temsil eden "fine_labels" "coarse_labels" anahtarları ı ı ı
20 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'
]
Aşağı
#----------------------------------------------------------------------------------------------------------------------------
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()
#----------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
aynı ı
#----------------------------------------------------------------------------------------------------------------------------
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()
#----------------------------------------------------------------------------------------------------------------------------
Keras'taki önemli bir callback sı ı ı ı ı ı ı ı ı ı ı ı ı
değerleri önceki epoch'lardaki sı ı ı ı ı ı
epoch'lar sı ı ı ı
Çünkü bu tür durumlarda eğitim verilerinden elde edilen metrik değerler gitgide iyileşir ancak sı
Bu durum da eğitimin olumsuz bir yöne gittiğini gösterir. EarlyStopping callback sı ı ı ı ı ı
tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=0,
patience=0,
verbose=0,
mode='auto',
baseline=None,
restore_best_weights=False
)
Burada monitor parametresi izlenecek metrik değeri belirtir. Metrik değerin başı ı
değer anlamı ı ı
fazla bir düşüş iyileşme kabul edilir.) patience parametresi üst üste kaç kez iyileşme olmazsa eğitimin sonlandı ı ı ı
3, 5 gibi değerler girilebilir. verbose parametresi 1 girilirse ekrana bilgi yazı ı ı ı
girilebilir. "min" iyileşmenin düşüşle sağlandı ı ı ı ı ı
kendisi belirler. restore_best_weights parametresi True geçilirse eğitim sonlandı ı
nöron ağı ı
Aşağı ı ı ı ı
restore_best_weights=True 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.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()
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'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping('val_loss', patience=5, verbose=1, restore_best_weights=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=500, 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]}')
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 = mms.transform(predict_data)
predict_result = model.predict(scaled_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(mms, f)
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
Bu örnekte de restore_best_weigts=True yapı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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']
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, 0]], 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-10')
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(10, activation='softmax', name='Output'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['categorical_accuracy'])
from tensorflow.keras.callbacks import EarlyStopping
esc = EarlyStopping(monitor='val_categorical_accuracy', patience=5, verbose=1, restore_best_weights=True)
hist = model.fit(training_dataset_x, ohe_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-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]}')
#----------------------------------------------------------------------------------------------------------------------------
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',
save_freq = 'epoch',
options=None,
initial_value_threshold=None,
**kwargs
)
Metodun birinci parametresi modelin save edileceği dosyanı ı ı
Metot bi,rden fazla save işlemi yapacaksa buradaki kalı ı ı
save_best_only parametresi True girilirse yalnı ı ı ı
save_weights_only parametresi default durumda False biçimdedir. Bu parametre True geçilirse tüm model değil yalnı ı ı
edilir. Yine verbose parametresi 1 girilirse ekrana bazı ı ı ı ı
modeli save etmekse ModelCheckpoint nesnesini aşağı
mcp = ModelCheckpoint('boston-checkpoint.h5', monitor='val_loss', save_best_only=True)
Burada save_best_only parametresi True girildiği için yalnı ı ı ı ı ı ı
Tüm epoch'ları ı ı ı ı
formatlama bilgisi kullanı ı ı ı
dosya isimleri ile save edilir. Eğer save_best_only parametresi True geçilirse bu durumda yalnı
formatlama bilgisine uygun dosya isimleriyle save edilir. Eğer dosya isminde formatlama kullanı
son epoch'taki değerler save edilir. Eğer dosya isminde formatlama kullanı
edilmiş olacaktı ı ı
Formatlama bilgisinde "{epoch}" o andaki epoch değerini temsil eder. "{epoch:02d}" gibi bir format epoch değerini iki basamak olarak (tek basamaksa 0 ile doldurarak)"
oluşturma anlamı
mcp = ModelCheckpoint('boston-checkpoint-{epoch:02d}.h5', monitor='val_loss', save_best_only=True)
Burada val_loss metrik değeri daha öncekilere göre iyi olan epoch ile karşı ı ı ı ı ı
bir dosyaya save işlemi yapı ı
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')
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()
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'])
from tensorflow.keras.callbacks import ModelCheckpoint
mcp = ModelCheckpoint('boston-checkpoint-{epoch:02d}.h5', monitor='val_loss', save_best_only=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[mcp])
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, len(hist.epoch), 20))
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, len(hist.epoch), 20))
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]}')
#----------------------------------------------------------------------------------------------------------------------------
Tabii aslı ı ı ı ı ı ı ı ı
örnek verilmiş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.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()
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'])
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
esc = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
mcp = ModelCheckpoint('boston-checkpoint-{epoch:02d}.h5', monitor='val_loss', save_best_only=True)
hist = model.fit(scaled_training_dataset_x, training_dataset_y, batch_size=32, epochs=100, validation_split=0.2, callbacks=[esc, mcp])
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, len(hist.epoch), 20))
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, len(hist.epoch), 20))
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]}')
#----------------------------------------------------------------------------------------------------------------------------
Yazı ı ı ı ı ı ı ı ı ı ı
Biz şimdiye kadar IMDB ve Retures gibi örneklerde yazı ı ı ı
Bu yöntemin en önemli dezavantajları ı ı ı ı ı
Biz bu tekniğe "vektörizasyon yöntemi" demiştik. İşte "word embedding" denilen teknik bu teknikten daha ileri bir tekniktir.
Word embedding yukarı ı ı
Word embedding yönteminde yazı
Örneğin yazı ı ı ı
boyutunda bir matrisle temsil edilecektir. Pekiyi her sözcüğün bir vektörle ifade edilmesinin anlamı ı ı
Bu vektörler oluşturulduktan sonra bunları ı ı ı ı ı ı
biribirine uzak sözcüklerin daha fazla olacağı ı ı
(iki boyutlu uzayda) bir nokta belirtirler. Bu durumda birbirlerine yakı ı
daha uzak olacaktı ı ı ı
Pekiyi bu vektörler nası ı ı ı ı
algoritması ı ı ı ı ı ı
Bu algoritmalar biraz karmaşı ı ı ı ı ı
bu vektörleri oluşturan algoritmalardı
Word embedding işlemleri aslı ı ı ı ı
işlemlerinin uygulanması ı ı ı ı
Keras'ta word embedding işlemleri katmanlarla yapı ı ı ı
ağı ı ı ı ı ı ı ı ı ı ı ı
zorunlu parametrelerdir. Birinci parametre tüm yazı ı ı ı ı ı ı ı
Burada tüm yazı ı ı ı ı ı ı ı ı ı ı ı ı
her yazı ı
kullanı ı ı ı ı ı ı
pad_sequences fonksiyonu kullanı ı ı ı ı
model.add(Embedding(30000, 32, input_length=100))
Burada tüm yazı ı ı ı
oluşacaktı
Embedding katmanı ı ı ı ı ı ı ı ı
önce yine vocabulary'deki her sözcüğe birer numara vermesi sonra da yazı ı
Embedding katmanı ı ı ı ı ı ı ı
parametre sayı ı ı
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şı ı ı
elemanları ı ı ı ı ı ı
Burada 'pre' baş tarafı ı ı
from tensorflow.keras.utils import pad_sequences
a = [[1, 2, 3], [3, 4, 5, 6, 7], [10], [11, 12]]
result = pad_sequences(a, 20, padding='post')
print(result)
Embedding katmanı ı ı ı ı ı ı ı ı ı ı ı ı
Embedding katmanı ı
çı ı ı ı ı
Girdi Katmanı
Aşağı ı ı ı ı
Sonra bu katmanı ı ı ı ı ı
oluşması ı ı ı ı ı ı ı
sözcük uzunluğu olarak alı
vektör uzunluğu ikinin kuvvetleri olacak biçimde (bunun çok özel bir anlamı ı
#----------------------------------------------------------------------------------------------------------------------------
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, Flatten, Dense
model = Sequential(name='IMDBEmbedding')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
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')
#----------------------------------------------------------------------------------------------------------------------------
Şimdi de word embedding işlemleri için görsel bir açı ı ı
birbirine yakı ı ı ı ı ı ı ı
uzak olacak biçimde ayarlama yapmaktadı ı
Biz burada Embedding katmanı
hangi sözcüklere ilişkin noktaları ı ı
Keras'ta biz daha önce belli bir katmanı ı ı ı ı ı ı ı ı
Keras bize belli bir katmanı ı ı ı ı ı
çı ı ı ı ı ı
Biz bu fonksiyona katmanı ı ı ı
katmanı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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, Flatten, Dense
model = Sequential(name='IMDBEmbedding')
model.add(Embedding(len(cv.vocabulary_), 2, input_length=TExT_SIZE, name='Embedding'))
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.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])
from tensorflow.keras.backend import function
embedding_func = function(model.layers[0].input, model.layers[0].output)
text = 'good bad awful perfect extraordinary well impressive average magnificent disgusting best poor ok terrible cool worst'
words = re.findall(r'(?u)\b\w\w+\b', text)
word_indexes = [cv.vocabulary_[word] for word in words]
input_vect = pad_sequences([word_indexes], TExT_SIZE, padding='post', truncating='post')
output_vect = embedding_func(input_vect)
word_values = output_vect[0, :len(word_indexes), :]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.title('Word Embedding Visual Representation')
plt.scatter(word_values[:, 0], word_values[:, 1])
for i, name in enumerate(words):
plt.annotate(name, (word_values[i, 0] + 0.005, word_values[i, 1] + 0.005))
plt.show()
#----------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Keras'taki bu hazı ı ı ı
bize vocabulary sözlüğü vermektedir. load_data fonksiyonunda istenirse num_words parametresi ile yorum yazı ı ı ı
n tane sözcükten oluşması
sözlükteki eleman sayı ı ı
#----------------------------------------------------------------------------------------------------------------------------
TExT_SIZE = 250
from tensorflow.keras.datasets import imdb
(training_dataset_x , training_dataset_y), (test_dataset_x, test_dataset_y) = imdb.load_data()
from tensorflow.keras.utils import pad_sequences
training_dataset_x = pad_sequences(training_dataset_x, TExT_SIZE, padding='post', truncating='post')
test_dataset_x = pad_sequences(test_dataset_x, TExT_SIZE, padding='post', truncating='post')
vocabulary = imdb.get_word_index()
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Embedding, Flatten, Dense
model = Sequential(name='IMDBEmbedding')
model.add(Embedding(len(vocabulary) + 1, 64, input_length=TExT_SIZE, name='Embedding'))
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']
import re
predict_vectors = [[vocabulary[word] for word in re.findall(r'(?u)\b\w\w+\b', text.lower())] for text in predict_texts]
predict_data = pad_sequences(predict_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')
#----------------------------------------------------------------------------------------------------------------------------
Birbirini izleyen ve araları ı ı
Örneğin yağmurun yağı ı ı ı ı ı ı
zamansal verilerdir. Çünkü birbirinden kopuk değil bir sı ı
yağmaktadı ı ı ı
gidişat hakkı ı ı ı
içerisinde değerlendirilmesi önemli olmaktadı ı
Zamansal veriler yukarı ı ı ı ı
yazı ı ı
daha iyi anlaşı ı ı ı ı ı
evrişim uygulamı ı ı
iki yönlü (sağa ve aşağı ı ı ı ı
boyutta kaydı ı ı ı ı
Tek boyutlu evrişim işleminde filtre büyüklüğü tek boyutludur (yani tek bir sayı ı ı ı
sayı ı ı ı ı ı
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
...................
Bunlar evrişime sokulacak verileri temsil ediyor olsun. Filteyi (kernel) 3 olarak olarak almı ı
aşağı ı ı
F F F F F F 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ı ı ı ı ı ı ı ı ı ı ı ı
Eğer padding uygulanı ı ı ı ı ı
Keras'ta tek boyutlu evirişim işlemi için Conv1D katman sı ı ı ı ı ı ı
filtre sayı ı ı ı ı ı
Yine metodun strides ve padding parametreleri vardı ı
Aşağı ı ı ı ı ı
Embedding --> Conv1D --> Flatten --> Dense --> Dense --> Dense (Output)
#----------------------------------------------------------------------------------------------------------------------------
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, Conv1D, Flatten, Dense
model = Sequential(name='IMDBEmbedding')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(Conv1D(64, 3, padding='same', activation='relu', name='Conv1D'))
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=10, 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ı ı ı ı ı
Yine evrişimler arası ı ı ı ı
Pooling işleminin de tek boyutlu olması ı ı ı
Tek boyutlu pooling işlemlerinde pool_szie için tek bir sayı ı ı ı ı ı
burada belirtilen satı ı ı ı ı ı ı ı
veriler şöyle olsun:
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
...................
Burada MaxPooling1D sı ı ı ı ı ı ı ı ı ı ı
en büyük elemanları ı ı ı ı ı ı ı
Bu işlemin sonucunda aynı ı ı ı ı ı
Aşağı ı ı ı
Embedding --> Conv1D --> MaxPooling1D --> Conv1D --> MaxPooling1D --> Flatten --> Dense --> Dense --> Dense (Output)
#----------------------------------------------------------------------------------------------------------------------------
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, Conv1D, MaxPooling1D, Flatten, Dense
model = Sequential(name='IMDBEmbedding')
model.add(Embedding(len(cv.vocabulary_), 64, input_length=TExT_SIZE, name='Embedding'))
model.add(Conv1D(64, 3, padding='same', activation='relu', name='Conv1D-1'))
model.add(MaxPooling1D(2, name='MaxPooling1D-1'))
model.add(Conv1D(64, 3, padding='same', activation='relu', name='Conv1D-2'))
model.add(MaxPooling1D(2, name='MaxPooling1D-2'))
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=10, 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ı ı
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ğı ı ı ı
Dropout düzenlemesi 2014 yı ı ı ı ı ı ı
katmandan atı ı ı ı ı ı ı ı
Bu olası ı ı ı ı ı ı ı ı ı ı
Bazı ı ı ı ı ı ı ı ı ı ı
Buradaki olası ı ı ı ı ı ı ı ı ı ı ı ı ı ı
katmanda 10 böron varsa bu durum bu 10 nöronun kesinlikle bir tanesinin atı ı ı ı ı ı ı ı
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ı ı ı ı ı ı ı ı
ortadan kaldı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Yani örneğin bir katmandaki dropout olası ı ı ı ı ı ı ı ı ı ı
Matematiksel olarak bu işlem 1 / (1 - rate) olarak yapı ı ı ı ı
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ı ı ı ı ı ı ı ı ı ı
Belli veriler eşliğinde o andaki ya da belli zaman sonrası ı ı
alı ı ı ı ı ı ı ı ı ı
birtakı ı ı ı ı ı ı ı
değişmektedir.
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ı ı ı ı ı
Örneğin tipik olarak "gelecek kestirimi" yani şimdiki değerlerden hareketle belli bir zaman sonraki hava sı ı ı ı
bu veri kümesinden deneme amaçlı ı ı
Jena Climate örneğinde bizim amacı ı ı ı ı ı
Böyle bir modelin eğitimi için bizim bazı ı ı ı ı ı ı ı
bir gün sonraki değerler olmalı ı
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ı
Ayrı ı ı ı ı ı ı ı
önemli bir özellik olabilir. Bundan faydalanmamı
uygulamaya göre aralı
ele alı ı ı ı ı ı ı
bir değer kullanı ı ı
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]}')
#----------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
sembolik sabitimiz son kaç ölçümün değerinin geri beslemeye sokulacağı ı ı ı ı ı
tahmin edileceğini belirtmektedir. Biz bu örnekte ardı ı ı
belleğin harcanması ı ı ı
sı ı ı ı ı ı ı ı ı ı ı ı ı
bir batch kadar bilgiyi verceğiz. 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ı
Buradaki örnekte örneğin biz saat 10:00'dan itibaren 10'ar dakika aralı ı ı ı ı ı
istemekteyiz. Yukarı ı ı ı ı
veriyi kullanarak tahmin yapmak istemekteyiz.
#----------------------------------------------------------------------------------------------------------------------------
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
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)
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)
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)
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)
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])
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)
#----------------------------------------------------------------------------------------------------------------------------
Geri beslemeli ağlarda (RNN) çı ı ı ı ı ı ı
"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'])
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, 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()
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ğı ı
#----------------------------------------------------------------------------------------------------------------------------
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, Bidirectional, GRU, Dropout, Flatten, Dense
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'))
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')
#----------------------------------------------------------------------------------------------------------------------------
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ı ı
Pekiyi yukarı ı
lojistik regresyondaki sı ı ı ı ı ı ı ı ı
ayrı ı ı ı ı ı
bu uygulama sözcük temelinde de yürütülebilir.
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Keras'ı ı ı ı ı
modelin sonuna ekleniyordu. Ayrı ı ı ı ı ı ı
bulunabiliyordu. Oysa bazı ı ı ı
hem de bir yazı ı ı
Bir resim ve bir yazı ı ı ı ı
aynı ı ı ı
kullanmadı ı ı ı
tek bir girdi katmanı ı ı ı ı ı ı
belirleyebilir hem de yazı ı ı ı ı ı ı
Sequential sı ı ı ı
İşte bu tür gereksinimlerden dolayı
Fonksiyonel model daha esnektir.
Fonksiyonel modelde katman nesneleri ayrı ı ı ı ı ı ı ı ı ı ı
operatör metotları ı ı ı ı ı ı
Input fonksiyonu aslı
Örneğin:
inp = Input(...)
d1 = Dense(...)
result = d1(inp)
d2 = Dense(...)
result = d2(result)
d3 = Dense(...)
result = d3(result)
d4 = Dense(...)
out = d4(result)
Burada önce Input fonksiyonu ile girdi tensörü oluşturulmuştur. Sonra bu girdi tensörü Dense sı ı ı ı ı
Buradan da bir tensör nesnesi elde edilmiştir. Bu nesne de sonraki Dense nesnesinin fonksiyon çağı ı ı ı
Tabii yukarı ı ı ı
inp = Input(...)
result = Dense(...)(inp)
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(result)
Burada bir girdi bir de çı ı
tensorflow.keras modülündeki Model sı ı ı ı ı ı ı ı ı ı
inputs ve outputs. inputs girdi tensörünü, outputs ise çı ı ı ı ı ı ı ı
şöyle getirebiliriz:
model = Model(inputs=inp, outputs=out, name='MyModel')
Burada oluşturmaya çalı ı ı ı
model = Sequential('MyModel')
model.add(Dense(..., input_dim=N))
model.add(Dense(...))
model.add(Dense(...))
model.add(Dense(...))
Aslı ı ı ı ı ı ı ı ı ı ı ı ı
Görüldüğü gibi fonksiyonel modelde önce Input sı ı ı
bir tensör elde eidlmiştir. İşlemler bu biçimde devam ettrilimiştir.
Tensör kavramı ı ı ı ı ı
Aşağı ı
kodları
from tensorflow.keras import Model
from tensorflow.keras.layers import Input, Dense
inp = Input(shape=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)
model.summary()
#----------------------------------------------------------------------------------------------------------------------------
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 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 Model
from tensorflow.keras.layers import Input, Dense
inp = Input(shape=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)
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)
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]}')
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 = mms.transform(predict_data)
predict_result = model.predict(scaled_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(mms, f)
#----------------------------------------------------------------------------------------------------------------------------
Tabii yukarı ı ı
yukarı ı ı ı ı ı ı
gerektiren en önemli nedenler biri çok girişle ve/veya çok çı ı ı ı ı
oluşturulur. Sonra bunlar Model sı ı ı ı
girilir.
Çok girdili fonksiyonel model oluştururken girdi katmanları ı
modülündeki concatenate fonksiyonu ile yapı ı
bir liste ya da demet olarak almaktadı ı ı ı
inp1 = Input(...)
inp2 = Input(...)
result = concatenate([inp1, inp2])
result = Dense(...)(result)
result = Dense(...)(result)
out = Dense(...)(result)
model = Model(inputs=[inp1, inp2], outputs=out)
Burada şöyle bir model oluşturulmuştur:
inp1 ---->
Dense ---> Dense ----> Dense (output)
inp2 ---->
Pekiyi yukarı ı ı ı
eğitim için gereken training_dataset_x ve training_dataset_y verilerini metodu veriyorduk. Ancak yukarı
İşte bu tür durumlarda fit metodunda girdiler bir liste ya da demet biçiminde girilmektedir. Örneğin:
model.fit([training_dataset_x1, training_dataset_x2], training_dataset_y, ...)
Benzer biçimde modelin test edilemsi sı ı
Örneğin:
eval_ result = model.evaluate([test_dataset_x1, test_dataset_x2], test_dataset_y)
Benzer biçimde kestirim işleminde de predict metodunda x verileri bir liste ya da demet biçiminde girilir. Örneğin:
predict_result = model.predict([predict_data_image_x, predict_data_text_x])
print(predict_result[0])
Aşağı ı ı ı
Biz bu örnekte modeli rastgele verilerle eğttik. Çünkü amacı ı ı
#----------------------------------------------------------------------------------------------------------------------------
IMAGE_SHAPE = (32, 32, 3)
TExT_LENGTH = 40
VOCAB_SIZE = 30000
TOTAL_ITEM = 1000
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Embedding, Conv1D, MaxPooling1D, concatenate, Dense
input_image = Input(shape=IMAGE_SHAPE, name='Image-Input')
result = Conv2D(32, (3, 3), input_shape=(32, 32, 3), name='Conv2D-1', activation='relu')(input_image)
result = MaxPooling2D(name='Pooling-1')(result)
result = Conv2D(64, (3, 3), name='Conv2D-2', activation='relu')(result)
result = MaxPooling2D(name='Pooling-2')(result)
result = Conv2D(128, (3, 3), name='Conv3D-3', activation='relu')(result)
result = MaxPooling2D(name='Pooling-3')(result)
image_output = Flatten(name='Flatten-1')(result)
input_text = Input(shape=(TExT_LENGTH, ), name='Text-Input')
result = Embedding(VOCAB_SIZE, 64, name='Embedding')(input_text)
result = Conv1D(64, 3, padding='same', activation='relu', name='Conv1D-1')(result)
result = MaxPooling1D(2, name='MaxPooling1D-1')(result)
result = Conv1D(64, 3, padding='same', activation='relu', name='Conv1D-2')(result)
result = MaxPooling1D(2, name='MaxPooling1D-2')(result)
text_output = Flatten(name='Flatten-2')(result)
concatenated_output = concatenate([image_output, text_output])
result = Dense(512, activation='relu', name='Hidden-1')(concatenated_output)
result = Dense(256, activation='relu', name='Hidden-2')(result)
out = Dense(1, activation='sigmoid', name='Output')(result)
from tensorflow.keras import Model
model = Model(inputs=[input_image, input_text], outputs=out)
model.summary()
# generate random data
import numpy as np
dataset_image_x = np.random.randint(0, 256, (TOTAL_ITEM, ) + IMAGE_SHAPE)
dataset_text_x = np.random.randint(0, VOCAB_SIZE, (TOTAL_ITEM, TExT_LENGTH))
dataset_y = np.random.randint(0, 2, TOTAL_ITEM)
"""
manuel separation
test_zone = int(TOTAL_ITEM * 0.80)
training_dataset_image_x = dataset_image_x[:test_zone]
training_dataset_text_x = dataset_text_x[:test_zone]
training_dataset_y = dataset_y[:test_zone]
test_dataset_image_x = dataset_image_x[test_zone:]
test_dataset_text_x = dataset_text_x[test_zone:]
test_dataset_y = dataset_y[:test_zone]
"""
from sklearn.model_selection import train_test_split
training_dataset_image_x, test_dataset_image_x, training_dataset_text_x, test_dataset_text_x, training_dataset_y, test_dataset_y = train_test_split(dataset_image_x, dataset_text_x, dataset_y, test_size=0.2)
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy'])
hist = model.fit([training_dataset_image_x, training_dataset_text_x], training_dataset_y, batch_size=32, epochs=100, validation_split=0.2)
eval_result = model.evaluate([test_dataset_image_x, test_dataset_text_x], test_dataset_y)
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
predict_data_image_x = np.random.randint(0, 256, (1, 32, 32, 3))
predict_data_text_x = np.random.randint(0, VOCAB_SIZE, (1, TExT_LENGTH))
predict_result = model.predict([predict_data_image_x, predict_data_text_x])
print(predict_result[0])
#----------------------------------------------------------------------------------------------------------------------------
Çok çı ı ı ı ı ı ı ı ı
"olumlu", "olumsuz" biçiminde iki sı ı ı ı ı ı ı ı ı
bir model oluşturacak olalı
Dense (sigmoid activation)
Input --> Dense ---> Dense
Dense (linear activation)
Bu modelin oluşturulması ı ı
inp = Input(...)
result = Dense(...)(inp)
result = Dense(...)(result)
out1 = Dense(...)(result)
out2 = Dense(...)(result)
model = Model(inputs=inp, outputs=[out1, out2])
model.compile(...)
model.fit(training_dataset_x, [trainingdataset_y1, training_dataset_y2], ...)
eval_result = model.evaluate(test_dataset_x, [test_dataset_y1, test_dataset_y2])
predict_result = model.predict(predict_data) # çı ı
Çok çı ı ı ı ı ı ı
Örneğin problemde çı ı ı ı ı ı ı ı ı
lojistik olmayan regresyona ilişkinse bu çı ı
bir tane fonksiyon verdik. Ancak aslı ı ı ı ı ı ı
Bunun için loss parametresinde bir liste ya da sözlük girilebilir. Liste girilecekse buradaki sı ı
parametresindeki sı ı ı ı ı ı
katman nesnelerinin isimlerinden 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ı ı ı
ortalaması ı ı ı ı ı ı ı
çı ı ı ı ı ı ı ı ı
belirtmektedir. Örneğin:
model.compile(optimizer='rmsprop', loss={'Output-1': 'binary_corssentropy, 'Output-2': 'mse'}, loss_weights={'Output-1': 1, 'Output-2': 0.1}, ...)
Çok çı ı ı ı ı ı ı ı ı
İşte her çı ı ı
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 çı ı ı ı
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 biz bir liste vermektedir. Listenin elemanları ı ı ı ı ı ı ı
aslı
predict_result = model.predict(predict_data.reshape(1, -1))
print(predict_result[0][0, 0], predict_result[1][0, 0])
Aşağı ı ı ı ı ı
#----------------------------------------------------------------------------------------------------------------------------
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, 'Output-2': 1}, 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)
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])
for i in range(len(eval_result)):
print(f'{model.metrics_names[i]}: {eval_result[i]}')
# 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])
#----------------------------------------------------------------------------------------------------------------------------
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)
- Kategorik verilerin sayı ı ı ı
- 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ı ı ı ı ı ı
Bu sı ı ı ı ı ı
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ı ı ı ı ı ı ı ı ı ı
oluşturulmaya çalı ı ı ı ı ı ı ı
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çı ı
uygun yöntem olmaktan çı ı ı ı
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ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kümeleme işlemleri aslı
denilmektedir. Ancak son yirmi yı ı ı ı
eskisinden çok daha fazla yöntemler ve teknikler geliştirildi. Bu nedenle kümeleme kavramı ı ı
makine öğrenmesi bağlamı ı ı
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
Kümeleme benzer olanları ı ı
Yani bir veri kümesinde satı ı ı ı ı
bir kavramdı ı
İşte bir veri tablosundaki satı ı ı ı
Eğer n boyutlu uzayda iki nokta arası ı ı
Ancak uzaklı ı ı ı ı ı ı ı
denilen ölçüttür. Öklit uzaklı ı ı ı ı ı ı
gibi "Manhattan uzaklı ı ı
İki boyutlu kartezyen koordinat sistemni aslı ı ı
aslı ı ı ı
biçimindedir. N boyutlu uzaydaki iki nokta arası ı ı ı ı ı ı ı
karelerinin toplamı ı ı ı ı ı ı ı
şöyle yazı
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
kategorili sütunlardı
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ı ı
doğru elde edilmektedir. Lojistik regresyon uygularken Y verileri üzerinde "one hot encoding" uygulanmaz. Y verileri LabelEncoding
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()
#----------------------------------------------------------------------------------------------------------------------------
Graf dünyası ı
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ı ı ı
uzunluğu olduğunu belirlemekte kullanı ı ı ı ı
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ı ı ı
Gerçek hayatta bu problem bütün noktaları ı ı ı ı ı
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.
Aşağı ı ı ı
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ı ı ı ı
"dot" verilmektedir. Bu dosyayı ı ı ı ı ı ı ı ı ı
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ğı ı ı ı ı ı ı
Nesne yaratı ı ı
bir graphviz dosyası ı ı ı
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
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]])
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ı ı ı ı
sütununu "one hot encoding" işlemine sokmak isteyelim. Bir sütununu da eksik veriler nedeniyle impute etmek isteyelim. Bu işlemi
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
Burada bizim amacı ı ı
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')
Buarada önce 0 ve 2 numaralı ı
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ı ı ı ı ı
sonucunu "one hot encoding" işlemine sokmak isteyebiliriz. Ancak ColumnTransformer sı ı ı ı
Ö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
Burada bizim 0'ı ı
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
Burada sex, smoker sütunları ı ı ı
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.
Psikolojide organizmanı ı
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
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
