pdf_path
stringclasses 2
values | page_num
int64 0
127
| marker
stringclasses 35
values |
|---|---|---|
/content/drive/MyDrive/pdf_folder/511459.pdf
| 0
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 1
|
_page_1_Picture_0.jpeg)
| JÜRİ ÜYESİ | IMZA | KANAATİ<br>(KABUL / RED / DÜZELTME) |
|---------------------------------------------|---------|-------------------------------------|
| PROF DR.ERGÜN EROĞLU | | a 4 U |
| DOC.DR.NIHAT TAŞ | | nabu |
| DOÇ.DR.ERSOY ÖZ | | rabil |
| DOÇ.DR.EMRAH ÖNDER | | Plabu |
| DOKTOR ÖĞRETİM ÜYESİ SERPİL<br>KILIÇ DEPREN | 1 . 180 | Kabul |
| yedek jüri üyesi | IMZA | KANAATI<br>(KABUL / RED / DÜZELTME) |
|------------------------------------------|------|-------------------------------------|
| DOKTOR ÖĞRETİM ÜYESİ MUSTAFA<br>CAN | | |
| DOKTOR ÖĞRETİM ÜYESİ ÖYKÜM<br>ESRA ASKIN | | |
# **GRADYAN VE ÖZEL BİR HİPER DÜZLEM TEMELLİ YENİ BİR OPTİMİZASYON ALGORİTMASI: EVRİŞTİRİLMİŞ GRADYAN YÖNÜ İLE OPTİMİZASYON**
**ÖZ**
### **İBRAHİM KARABAYIR**
Bu çalışmada çok boyutlu problemleri çözmek için birinci dereceden gradyan ve özel bir hiper düzlem ailesine dayalı yeni ve etkili bir algoritma sunulmaktadır. Bu amaçla hiper düzlem ailesi üretilmiştir. Yaklaşım keyfi olarak seçilen bireysel çözüm popülasyonunu, hiper düzlem ailesine ait hiper düzleminin gradyan vektörü ve birinci dereceden gradyan vektörü yardımıyla dinamik olarak evriştirerek çok boyutlu problemi optimize etmeyi amaçlamaktadır.
Özellikle örüntü tanıma uygulamalarında hata fonksiyonunun hayli lineer olmayan yapıya sahip olduğu düşünüldüğünde keyfi olarak seçilen başlangıç çözümünün yerel minimum çözümüne yaklaşması bilinen bir problemdir. Kurulan algoritma yardımıyla, fonksiyon optimizasyonunda çözümün, gradyan iniş yönteminin en büyük handikabı olan lokal minimum tuzağına düşmesinden kaçınılması hedeflenmiştir.
Ayrıca bu tezde, hiper düzleminin ve önerilen optimizasyon algoritmasının geometrik anlamı sunulmuştur. Bunun yanı sıra, önerilen algoritmanın performansı bazı uygulamalar yapılarak incelenmiştir. Bu uygulamalar genel olarak bazı klasik matematiksel fonksiyon uygulamaları ve makine öğrenmesi uygulamaları olarak verilmiştir. Makine öğrenmesi uygulamalarında yapay olarak üretilen veri setlerinin yanı sıra literatürde sıklıkla kullanılan rakamların el yazısı olarak yazılmasıyla oluşturulan MNIST veri seti kullanılmıştır. Makine öğrenmesi uygulamaları için öğrenme algoritmaları olarak lojistik regresyon, softmax regresyon ve derin evrişimli sinir ağı (DESA) kullanılmıştır. Özellikle derin evrişimli sinir ağlarının örüntü tanıma uygulamalarındaki başarısı bilinmektedir. Bu amaçla üretilen optimizasyon algoritmasının performansı derin evrişimli sinir ağı ile de test edilmiştir. MNIST veri seti işlenirken tensör büyüklüğü düşünüldüğünde grafik işleme birimi (GPU) kullanılarak öğrenme hızlandırılmıştır.
Önerilen yöntemle elde edilen sonuçlar, özellikle örüntü tanıma problemlerinde sıklıkla kullanılan gradyan iniş algoritmasıyla elde edilen sonuçlar ile birlikte verilmiştir. Böylelikle önerilen yöntem ile gradyan iniş yöntemi karşılaştırılmıştır ve önerilen yöntemin görece olarak daha iyi sonuçlar verdiği gözlemlenmiştir.
**Anahtar Kelimeler:** Gradyan Temelli Öğrenme, Derin Öğrenme, Derin Evrişimli Sinir Ağları, Örüntü Tanıma, El Yazısı Rakam Tanıma
### **ABSTRACT**
## <span id="page-4-0"></span>**A NOVEL OPTIMIZATION ALGORITHM BASED ON GRADIENT AND SPECIFIC HYPERPLANE: EVOLVED GRADIENT DIRECTION OPTIMIZER**
### **İBRAHİM KARABAYIR**
We introduce a novel algorithm for optimization of multidimensional objective functions based on their first-order gradient and specific hyperplane family. For this purpose, we produce hyperplane family. The proposed approach is aimed at optimizing multidimensional functions by evolving the arbitrary initial individual solution with the help of both the gradient vector of hyperplane belonging to the hyperplane family and first-order gradient.
Especially in the pattern recognition applications, it is well known that the arbitrary initial solution can approximate to the local minimum solution when considered rather nonlinear structure of the error function. The aim of the proposed algorithm is to strip away local minimum trap which is a handicap for the gradient descent algorithm.
Moreover, we also analyse the geometrical meaning of both hyperplane family and the proposed optimization algorithm. Besides, the computational performance of the proposed algorithm has been examined by some applications. These applications are generally presented as some classical mathematical function applications and machine learning applications. In machine learning applications, both artificially generated datasets and MNIST handwritten digit dataset which is commonly used in the literature have been processed. Logistic regression, softmax regression and deep convolutional neural network have been used as learning algorithms. Especially, it is well known that the deep convolutional neural networks are very successful in pattern recognition. For this purpose, the performance of the proposed optimization algorithm has also been tested with deep convolutional neural network. Taken into account of tensor size when processing MNIST dataset, the learning is accelerated using the graphics processing unit (GPU).
The results of the proposed method have been given together with the results of the gradient descent algorithm which is commonly used in pattern recognition. Thus, the proposed method has compared with the gradient descent approach and it has been observed that the proposed method has achieved relatively better results.
**Keywords:** Gradient-Based Learning, Deep Learning, Deep Convolutional Neural Networks, Pattern Recognition, Handwritten Digit Recognition.
### **ÖNSÖZ**
<span id="page-6-0"></span>Öncelikle bu tezin hazırlanmasındaki desteği, anlayışı ve bana olan güveni dolayısıyla danışman hocam Doç. Dr. Nihat TAŞ' a teşekkür ederim. Ayrıca önceki danışman hocam Prof. Dr. Erhan ÖZDEMİR' e kendi fikirlerimin peşinden koşmam konusunda verdiği cesaret ve tanıdığı özgürlük, aynı zamanda kariyerimi oluşturma konusunda verdiği destekler dolayısıyla çok teşekkür ederim.
Dünyanın diğer ucunda olmasına rağmen tez dönemim boyunca her zaman fikirlerini benimle paylaşan, derin öğrenme konusunda beni cesaretlendiren, ihtiyacım olduğu her zaman bana yardımcı olan ve çalışmalarımı adım adım takip eden hocam Dr. Oğuz AKBİLGİÇ' e teşekkürü bir borç bilirim.
Doç. Dr. Ersoy ÖZ' e destekleri ve değerli yönlendirmeleri dolayısıyla çok teşekkür ederim. Ayrıca tezimi bitirmem konusunda bana sağladığı yüksek motivasyon nedeniyle Yrd. Doç. Dr. Nihat TAK' a, yapay zeka üzerinde yaptığımız fikir alış verişleri için ise arkadaşım Erol SELİTEKTAY' a teşekkür ederim.
Vardığım her noktada üzerimde emekleri olan anneme, babama ve kardeşlerime yürekten teşekkür ederim. Desteğini her zaman yanımda gördüğüm değerli abilerim Yaşar ve İsmail' e özel olarak teşekkür etmek isterim.
Son olarak tüm çalışmalarımda verdiği koşulsuz destek ve sabır ile üzerimdeki yükü hafifleten değerli eşim Havvagül' e ve her zaman neşe kaynağım olan canım oğlum Eymen' e teşekkürlerimi sunarım.
İyi ki varsınız…
İbrahim KARABAYIR
İSTANBUL, 2018
<span id="page-7-0"></span>
| ÖZiii | |
|-----------------------|-----|
| ABSTRACT | v |
| ÖNSÖZvii | |
| İÇİNDEKİLER<br>viii | |
| ŞEKİLLER LİSTESİ | x |
| TABLOLAR LİSTESİxii | |
| GRAFİKLER LİSTESİxiii | |
| KISALTMALAR LİSTESİ | xiv |
| GİRİŞ<br> | 1 |
| | |
| 1.1. Bazı Matematiksel Tanımlamalar ve Notasyonlar<br>3 |
|-------------------------------------------------------------------------------|
| −Boyutlu Öklidyen Uzayı<br>3 |
| 1.1.2. Konvekslik<br>4 |
| 1.1.3. Gradyan Vektör, Hessian Matrisi ve Kuadratik Form<br>4 |
| <br>6 |
| <br>6 |
| 1.2. Derin Öğrenme (Deep Learning)<br>7 |
| <br>8 |
| 1.2.2 Gradyan İniş Algoritması<br>11 |
| 1.2.3 Geri Yayılım Algoritması (Backpropagation)<br>12 |
| 1.2.4 Aktivasyon Fonksiyonları<br>14 |
| 1.2.5 Derin Evrişimli Sinir Ağları (Deep Convolutional Neural Networks)<br>15 |
| 1.2.5.1 Evrişim Katmanı (Convolutional Layer)<br>15 |
| <br>19 |
| 1.2.5.3 Tam Bağlı Katman (Fully Connected Layer)<br>20 |
| |
### **İKİNCİ BÖLÜM**
### −**BOYUTLU UZAYDA SPESİFİK BİR HİPER DÜZLEM: HİPER DÜZLEMİ**
| 2.1. 𝑀𝑝<br>Hiper Düzlemi ve Bazı Önemli Özellikleri | 21 |
|---------------------------------------------------------|----|
| 3 de<br>2.2 𝑅<br>𝑀3<br>Düzleminin Geometrik Analizi<br> | 31 |
#### **ÜÇÜNCÜ BÖLÜM**
### **HİPER DÜZLEMİ YARDIMIYLA OPTİMİZASYON: EVRİŞTİRİLMİŞ GRADYAN YÖNÜ İLE OPTİMİZASYON ALGORİTMASI (EVGO)**
| 3.1. Giriş | 35 |
|------------------------------------------------------|----|
| 3.2. Algoritma | 36 |
| 2 de Geometrik Analizi<br>3.3. EVGO Algoritmasının 𝑅 | 42 |
### **DÖRDÜNCÜ BÖLÜM DEĞERLENDİRME VE TARTIŞMA**
| 4.1. Bazı Klasik Fonksiyonlar Üzerinde Analizler | 44 |
|--------------------------------------------------------------|-----|
| 4.2. Sentetik Veriler İçin Lojistik Regresyon İle Analiz<br> | 57 |
| 4.2.1. Sentetik verilerin yapısı<br> | 57 |
| 4.2.2. Lojistik Regresyon Yapısı ve Analiz Sonuçları | 58 |
| 4.3. El Yazısı Rakam Dizisi Üzerinde Analiz<br> | 60 |
| 4.3.1. MNIST Veri Seti | 60 |
| 4.3.2. Softmax Regresyon Analizi | 61 |
| 4.3.3. Derin Evrişimli Sinir Ağı (DESA) Analizi | 65 |
| SONUÇ | 70 |
| KAYNAKÇA<br> | 72 |
| EKLER | 77 |
| ÖZGEÇMİŞ | 100 |
### **ŞEKİLLER LİSTESİ**
<span id="page-9-0"></span>
| Şekil 1.1.<br>3 katmanlı (girdi, bir gizli ve çıktı) ve her bir katmanda 3 nöronlu ileri |
|-----------------------------------------------------------------------------------------------------------------|
| beslemeli sinir ağı<br><br>10 |
| Şekil 1.2.<br>(a) Katman 𝑚<br>deki her nöron katman 𝑚<br>deki 3 komşu nörona bağlı ve<br>−<br>1 |
| katman 𝑚<br>deki nöron katman 𝑚<br>deki 3 komşu nörona aynı şekilde bağlıdır.<br>+<br>1 |
| (b) Aynı renkteki bağlantılar aynı ağırlıkta olacak şekilde kısıtlanmıştır<br>16 |
| Şekil 2.1.<br>Örnek 2.7 için 𝑀1, 𝑀2<br>ve 𝑀3<br>düzlemleri<br>31 |
| 3 de gösterimi<br>Şekil 2.2.<br>Vektör 𝑑<br>ve Vektör 𝑒<br>nin 𝑅<br><br>32 |
| Şekil 3.1. Temsili 𝑛𝑜𝑡𝑏𝑒𝑠𝑡<br>değeri güncelleşirken EVGO algoritması ve gradyan iniş |
| algoritması için izlediği yol<br>42 |
| Şekil 4.1.<br>𝐹(𝑥,<br>𝑦)<br>fonksiyonunun geometrik gösterimi ve seviye eğrileri<br><br>48 |
| Şekil 4.2.𝑓1<br>(𝑥)<br>fonksiyonunun geometrik gösterimi<br><br>49 |
| Şekil 4.3. 𝑓1<br>(𝑥)<br>fonksiyonunun türevinin geometrik gösterimi<br>50 |
| 3 de gösterimi<br>Şekil 4.4.<br>Sırasıyla 𝑓2,<br>ve 𝑓8<br>fonksiyonlarının 𝑅<br>51<br>𝑓4,<br>𝑓5,<br>𝑓6,<br>𝑓7 |
| 3<br>Şekil 4.5.<br>𝑓2<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅 |
| de gösterimi<br>52 |
| 3<br>Şekil 4.6.<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅<br>𝑓4 |
| de gösterimi<br>52 |
| 3<br>Şekil 4.7.<br>𝑓5<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅 |
| de gösterimi<br>52 |
| 3<br>Şekil 4.8.<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅<br>𝑓6 |
| de gösterimi<br>53 |
| 3<br>Şekil 4.9.<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅<br>𝑓7 |
| de gösterimi<br>53 |
| 3<br>Şekil 4.10.<br>fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin 𝑅<br>𝑓8 |
| de gösterimi<br>53 |
| Şekil 4.11.<br>Sırasıyla 𝑓2,<br>fonksiyonları için seviye eğrileri<br>54<br>𝑓4,<br>𝑓5,<br>𝑓6,<br>𝑓7<br>ve<br>𝑓8 |
| Şekil 4.12.<br>Sırasıyla 𝑓3<br>ve 𝑓9<br>fonksiyonları için EVGO algoritmasının döngü boyunca |
| 3 de gösterimi<br>ürettiği noktaların 𝑅<br>55 |
| 2 de gösterimi<br>Şekil 4.13.<br>Veri 1 in girdi kümesinin 𝑅<br><br>58 |
| Şekil 4.14.<br>MNIST veri setinden örnekler. (Hedef değerleri soldan sağa sırasıyla |
|--------------------------------------------------------------------------------------------------------------------|
| 5,<br>0,<br>4,<br>1,<br>9,<br>2,<br>1,<br>3,<br>1,<br>4,<br>3,<br>5,<br>3,<br>6,<br>1,<br>7<br>şeklindedir.)<br>61 |
| Şekil 4.15.<br>Softmax Regresyon Analizi<br>63 |
| Şekil 4.16.<br>DESA<br>yapısı<br><br>66 |
| Şekil 4.17.<br>Sırasıyla EVGO ve gradyan iniş yöntemlerinin eğitim, doğrulama ve test |
| seti için iterasyon boyunca aldıkları hata değerleri (DESA<br>analizi)<br>68 |
| Şekil 4.18.<br>Sırasıyla doğrulama ve test seti için EVGO ve gradyan iniş yöntemleri ile |
| iterasyonlar boyunca elde edilen hata değerleri (DESA<br>analizi)<br><br>68 |
### **TABLOLAR LİSTESİ**
<span id="page-11-0"></span>
| Tablo 3.1.<br>EVGO algoritmasına ait sözde kod<br>40 |
|-------------------------------------------------------------------------------------------------|
| Tablo 4.1.<br>Fonksiyonlar ve tipleri<br><br>45 |
| Tablo 4.2.<br>Fonksiyonlar için problem değerleri<br><br>46 |
| Tablo 4.3.<br>Problemler için sırasıyla başlangıç değerleri, iterasyon sayısı ve hiper |
| parametre değerleri<br>46 |
| Tablo 4.4.<br>Problemler için sırasıyla gradyan iniş yöntemi ile elde edilen çözüm |
| parametresi, EVGO algoritması ile elde edilen çözüm parametresi. gradyan iniş |
| yöntemi ile elde edilen çözüm değeri ve EVGO algoritması ile elde edilen çözüm |
| değeri<br>47 |
| Tablo 4.5.<br>Üretilen sentetik verilerin bazı özellikleri<br>57 |
| Tablo 4.6.<br>Veri 1 ve Veri 2 için kullanılan hiper parametreler ve analiz sonuçları<br><br>59 |
| Tablo 4.7.<br>Softmax regresyon analizi ile ilgili bazı bilgiler<br>63 |
| Tablo 4.8.<br>Softmax regresyon analizi sonuçları<br><br>64 |
| Tablo 4.9.<br>DESA<br>analizi ile ilgili bazı bilgiler<br>66 |
| Tablo 4.10.<br>DESA<br>için ağırlık tensörü boyutları<br>67 |
| Tablo 4.11.<br>DESA<br>analizinde yer alan katmanların girdi ve çıktıların tensör boyutları |
| <br>67 |
| Tablo 4.12.<br>DESA<br>analizi sonuçları<br>68 |
### **GRAFİKLER LİSTESİ**
<span id="page-12-0"></span>**Grafik 4.1.** Sırasıyla 1, 2, 3, 4, 5, 6, 7, <sup>8</sup> ve <sup>9</sup> [fonksiyonları için gradyan iniş ve](#page-68-0) [EVGO algoritmalarının iterasyonlar boyunca aldıkları değerleri gösteren grafikler.](#page-68-0) 55 **Grafik 4.2.** [Sırasıyla Veri 1 ve Veri 2 için gradyan iniş ve EVGO algoritmasıyla elde](#page-72-1) [edilen iterasyona bağlı hata fonksiyonu değerleri......................................................](#page-72-1) 59 **Grafik 4.3.** [Sırasıyla EVGO ve gradyan iniş yöntemlerinin eğitim, doğrulama ve test](#page-77-1) [seti için iterasyon boyunca aldıkları hata değerleri \(Softmax regresyon analizi\)......](#page-77-1) 64 **Grafik 4.4.** [Sırasıyla doğrulama ve test seti için EVGO ve gradyan iniş yöntemleri](#page-77-2) [ile iterasyonlar boyunca elde edilen hata değerleri \(Softmax regresyon analizi\)](#page-77-2) ...... 65
### **KISALTMALAR LİSTESİ**
<span id="page-13-0"></span>
| AF | : Aktivasyon Fonksiyonu |
|-------|-----------------------------------------------------------|
| Bkz. | : Bakınız |
| DESA | : Derin Evrişimli Sinir Ağı |
| DÖ | : Derin Öğrenme |
| EVGO | : Evriştirilmiş Gradyan Yönü İle Optimizasyon |
| GYA | : Geri Yayılım Algoritması |
| GPU | : Graphics Processing Unit |
| İBYSA | : İleri Beslemeli Yapay Sinir Ağı |
| LR | : Lojistik Regresyon |
| MNIST | : Mixed<br>National Institute of Standards and Technology |
| SR | : Softmax Regresyon |
| YSA | : Yapay Sinir Ağı |
### **GİRİŞ**
<span id="page-14-0"></span>Matematik, bilgisayar bilimleri ve yöneylem araştırmasında matematiksel programlama veya optimizasyon, çözüm uzayı içerisinde belli kritere (kriterlere) göre en iyileyen çözüm değerlerini bulmaktır. Optimizasyon problemi maksimizasyon veya minimizasyon problemi olabilir. Genellikle optimizasyonu üzerinde çalışılan fonksiyon multimodal yapıya sahiptir. Eğer üzerinde çalışılan fonksiyon diferansiyellenebilir bir fonksiyon ise algoritmada bu bilgiyi kullanmak oldukça işe yarar. Global optimum değerine yaklaşmak için çeşitli algoritmalar geliştirilmiştir. Bu bağlamda gradyan temelli en basit ve kullanışlı algoritma gradyan iniş algoritmasıdır. Ancak gradyan iniş algoritması için yerel minimuma yaklaşarak optimal değerden uzaklaşma bilinen bir problemdir. Bunun yanında gradyan iniş algoritması özellikle örüntü tanıma problemlerinde sıklıkla kullanılan bir algoritmadır.
Örüntü tanıma problemlerinde son zamanlarda derin öğrenme olarak ifade edilen devasa bir yapay sinir ağı oldukça başarılı sonuçlar vermektedir. Bu sinir ağı insan sinir sistemini taklit ederek tıpkı insan gibi öğrenen ve karar veren yapay zeka (YZ) türüdür. İleri beslemeli yapay siniri ağı ile öğretilecek olan veri ve keyfi olarak seçilen çözüm parametresi () yardımıyla bir hata fonksiyonu üretilir. Söylemek gerekir ki derin öğrenme gibi büyük sistemlerde parametre boyutu çok büyüktür. Sonrasında programlanan problem için hata fonksiyonunu minimize edecek şekilde çözüm parametresi aranır. Böylece, keyfi olarak seçilen çözüm parametresi sürekli güncelleşir ve önceden belirlenen bir durdurma kriteri uygulanarak optimum çözüm parametresine (<sup>∗</sup> ) ulaşılır. Derin öğrenmede hata fonksiyonu esasen iç içe geçmiş diferansiyellenebilir fonksiyonlardan oluşur.
Bu çalışmada yerel minimum probleminden sıyrılmak amacıyla yeni bir algoritma geliştirilmiştir. Sunulan algoritma keyfi olarak seçilen tane parametre değerinden oluşur. bu parametrelerden oluşan aileyi temsil etmek üzere bireysel çözüm popülasyonu olarak adlandırılmıştır:
$$\mathcal{S} = \{ \mathcal{W}^l \colon i = 1, 2, \dots, k \}$$
bireysel çözüm popülasyonunda en küçük hata değerini veren parametre (yerel en iyi parametre) gradyan iniş yöntemi ile güncelleşirken, bu hata terimi dışında kalan parametreler (yerel en iyi olmayan parametreler) ile yerel en iyi parametre arasında özel bir hiper düzlem kurulur. Yerel en iyi olmayan parametreler güncelleşirken kurulan hiper düzlemin gradyanı ve hata fonksiyonunun gradyanı kullanılır. Kurulan hiper düzlem yardımıyla parametrelerin de dolaşması sağlanmıştır.
Çalışmanın ilk bölümünde derin öğrenme ağı olan derin evrişimli sinir ağları ve bazı matematiksel tanımlamalar üzerinde durularak çalışma için bir temel oluşturulmuştur. İkinci bölümde ise de herhangi iki nokta için özel bir hiper düzlem oluşturulmuştur. Bu hiper düzlem üretilen optimizasyon algoritmasının temelini oluşturmaktadır. Bu bölümde oluşturulan özel hiper düzlem için bazı teoremler verilmiş ve geometrik anlamı incelenmiştir.
Bölüm 3 ile üretilen hiper düzlem ve optimize edilecek fonksiyonun gradyanı yardımıyla evriştirilmiş gradyan algoritması (EVGO) sunulmuştur. Yine bu bölümde EVGO algoritmasının <sup>2</sup> de nasıl çalıştığı detaylı bir şekilde anlatılmış ve algoritma ile ilgili bazı teoremler verilmiştir.
Dördüncü bölümde ise EVGO algoritmasının bazı deneyler ile değerlendirmesi yapılmıştır. Bu deneyler birçok araştırmacı tarafından da kullanılmış olan bazı klasik fonksiyonların optimizasyonu ve örüntü tanıma uygulamalarıdır. Tüm deneyler aynı keyfi başlangıç noktaları ile gradyan iniş yöntemi kullanılarak da yapılmıştır. Böylece EVGO algoritmasının gradyan iniş yöntemine göre göreli olarak ne düzeyde bir iyileştirme yaptığı belirlenmiştir. Sonuç bölümünde ise EVGO algoritması ile ortaya konan bulgular irdelenmiştir.
## **1 BİRİNCİ BÖLÜM MATEMATİKSEL ÖN HAZIRLIK VE DERİN ÖĞRENMENİN TEORİK ÇERÇEVESİ**
### <span id="page-16-0"></span>**1.1. Bazı Matematiksel Tanımlamalar ve Notasyonlar**
Bu alt bölümde üretilen çalışmada sıklıkla kullanılan bazı matematiksel tanımlamalar ve notasyonlar verilmiştir. Tüm tez boyunca girdi elemanı vektör değişkeni olan diferansiyellenebilir fonksiyonlar üzerinde çalışılmıştır. Aksi belirtilmedikçe () ifadesinde, reel değerli diferansiyellenebilir fonksiyonu ve −boyutlu vektörü temsil eder. Burada,
$$\mathbf{x} = \begin{bmatrix} \mathbf{x\_1} \\ \mathbf{x\_2} \\ \vdots \\ \mathbf{x\_n} \end{bmatrix}$$
<span id="page-16-1"></span>şeklindedir.
### **1.1.1.** −**Boyutlu Öklidyen Uzayı**
−boyutlu Öklidyen Uzayı, reel sayıların −boyutlu vektörlerinin (x1, x2, … , x ) uzayıdır ve ile gösterilir<sup>1</sup> . de ve vektörleri arasındaki uzaklık veya − nin normu
$$\|\mathbf{x} - \mathbf{y}\|\| = \sqrt{(\mathbf{x}\_1 - \mathbf{y}\_1)^2 + (\mathbf{x}\_2 - \mathbf{y}\_2)^2 + \dots + (\mathbf{x}\_n - \mathbf{y}\_n)^2}$$
olarak verilmiştir<sup>2</sup> .
<sup>1</sup> Barret O'Neill, **Elementary Differential Geometry**, San Diego CA, Academic Press, 1966, p. 5. <sup>2</sup> **A.e**., p. 44.
### **1.1.2. Konvekslik**
<span id="page-17-0"></span>Birbirinden farklı 1, <sup>2</sup> ∈ için, eğer {: = <sup>2</sup> + (1 − )1, 0 ≤ ≤ 1} kümesinin tüm elemanları kümesinde ise kümesine konvekstir denir<sup>3</sup> .
de bir hiper düzlem,
$$X = \{ \mathbf{x} \colon \mathbf{c}^T \mathbf{x} = \mathbf{z} \}$$
şeklindedir. Burada ≠ 0, −boyutlu bir vektör ve z skalerdir. Burada vektörü hiper düzlemin normal vektörüdür. Yani, vektörü hiper düzlem üzerinde kalan herhangi bir vektöre ortogonaldir.
de konveks kümesi ele alınsın. 1, <sup>2</sup> ∈ ve 0 ≤ ≤ 1 olmak üzere
$$f(\lambda \mathbf{x}\_2 + (1 - \lambda)\mathbf{x}\_1) \le \lambda f(\mathbf{x}\_2) + (1 - \lambda)f(\mathbf{x}\_1)$$
ise fonksiyonuna konveks fonksiyon denir. Bu eşitsizlik <sup>1</sup> ≠ <sup>2</sup> ve 0 < < 1 için kesin ise bu durumda fonksiyonuna kesin konvekstir denir. Aynı şekilde eşitsizlik yön değiştirdiğinde konkav fonksiyon ve kesin konkav fonksiyon tanımları elde edilir<sup>4</sup> . Konveks ve konkav fonksiyonlara tek bir optimum noktaya (veya bölgeye) sahip oldukları için unimodal fonksiyonlar denir. Unimodal yapıda olmayan fonksiyonlara ise multimodal fonksiyonlar denir<sup>5</sup> .
### <span id="page-17-1"></span>**1.1.3. Gradyan Vektör, Hessian Matrisi ve Kuadratik Form**
Diferansiyellenebilir () fonksiyonu için gradyan
$$\nabla f(\mathbf{x}) = \left[ \frac{\partial f}{\partial \mathbf{x}\_1}(\mathbf{x}), \frac{\partial f}{\partial \mathbf{x}\_2}(\mathbf{x}), \dots, \frac{\partial f}{\partial \mathbf{x}\_n}(\mathbf{x}) \right]^T$$
−boyutlu kısmi türevler vektörüdür.
<sup>4</sup> **A.e**., pp. 5-7.
<sup>5</sup> **A.e**., p. 37.
<sup>3</sup> David A. Wismer, R. Chattergy, **Introduction to Nonlinear Optimization: a problem solving approach**, Amsterdam, North-Holland Publishing Company, 1978, p. 4.
Eğer () fonksiyonu için ikinci kısmi türevlere sahipse, Hessian matrisi
$$H(\mathbf{x}) = \begin{bmatrix} \frac{\partial^2 f}{\partial \mathbf{x}\_1^2}(\mathbf{x}) & \frac{\partial^2 f}{\partial \mathbf{x}\_1 \partial \mathbf{x}\_2}(\mathbf{x}) & \dots & \frac{\partial^2 f}{\partial \mathbf{x}\_1 \partial \mathbf{x}\_n}(\mathbf{x}) \\ \frac{\partial^2 f}{\partial \mathbf{x}\_2 \partial \mathbf{x}\_1}(\mathbf{x}) & \frac{\partial^2 f}{\partial \mathbf{x}\_2}(\mathbf{x}) & \dots & \frac{\partial^2 f}{\partial \mathbf{x}\_2 \partial \mathbf{x}\_n}(\mathbf{x}) \\ \frac{\partial^2 f}{\partial \mathbf{x}\_n \partial \mathbf{x}\_1}(\mathbf{x}) & \frac{\partial^2 f}{\partial \mathbf{x}\_n \partial \mathbf{x}\_2}(\mathbf{x}) & \dots & \frac{\partial^2 f}{\partial \mathbf{x}\_n^2}(\mathbf{x}) \end{bmatrix}$$
ikinci kısmi türevlerden oluşan × boyutlu simetrik matristir.
Optimizasyon problemleri için fonksiyonların önemli bir sınıfı kuadratik formdur. Eğer () fonksiyonu aşağıdaki gibi xx bileşenlerinin doğrusal kombinasyonu olan bir fonksiyon ise bir kuadratik formdur. Şöyle ki:
$$f(\mathbf{x}) = \sum\_{i=1}^{n} \sum\_{j=1}^{n} a\_{ij} \mathbf{x}\_i \mathbf{x}\_j.$$
Burada değerleri sabitlerdir. Aynı zamanda kuadratik form matris-vektör notasyonu ile aşağıdaki gibi yazılır:
$$\mathbf{x}^T \mathbf{A} \mathbf{x}.$$
Burada = [], × boyutlu simetrik matristir. Kuadratik forma sahip () fonksiyonun görüntü uzayının olduğu aşikardır.
≠ 0 olmak üzere her için > 0 ise, kuadratik formu pozitif tanımlıdır. Ayrıca, her için ≥ 0 ve en az bir ≠ 0 için = 0 ise kuadratik formu pozitif yarı tanımlıdır. Aynı şekilde eşitsizlikler yön değiştirdiğinde negatif tanımlılık ve negatif yarı tanımlılık tanımları elde edilir. Bir fonksiyonun pozitif tanımlılığı için aşağıdaki teorem kullanılabilir.
**Teorem 1.1.** (Sylvester Teoremi) kuadratik formunun pozitif tanımlı olması için ancak ve ancak matrisinin tüm asal minörlerinin pozitif olmalıdır<sup>6</sup> .
<sup>6</sup> **A.e**., pp. 8-13.
### **1.1.4. Kritik Noktalar ve Singülerlik**
<span id="page-19-0"></span> fonksiyonu ⊂ açık kümesi üzerinde diferansiyellenebilir olsun. ∈ için ∇() = 0 ise noktasına kritik nokta denir. noktasının komşuluğundaki tüm ler için eğer () ≤ () (veya () ≥ ()) ise fonksiyonu noktasında yerel maksimuma (veya yerel minimuma) sahiptir denir<sup>7</sup> .
<sup>2</sup> de fonksiyonunu ele alalım. Eğer ‖x − x0‖ < ve ‖y − y0‖ < olacak şekilde her x,y için
$$f(\mathbf{x}, \mathbf{y}\_0) \le f(\mathbf{x}\_0, \mathbf{y}\_0) \le f(\mathbf{x}\_0, \mathbf{y})$$
şartını sağlayan > 0 varsa fonksiyonu (x0, y<sup>0</sup> ) noktasında bir semer noktasına sahiptir denir. Bu nokta x değişkenine göre maksimum, y değişkenine göre ise minimum noktadır<sup>8</sup> .
: → diferansiyellenebilir fonksiyonu için <sup>0</sup> kritik noktası ele alınsın. Eğer <sup>0</sup> noktası için hessian matrisinin determinantı sıfır ise, bu kritik noktaya dejeneredir denir<sup>9</sup> .
Son olarak singülerlik ile ilgili bazı tanımlardan bahsedelim. () fonksiyonu = <sup>0</sup> da analitik olmayıp tüm komşu noktalarında analitik ise <sup>0</sup> noktasına ayrık singüler nokta, tüm komşu noktalarında analitik değilse ayrık olmayan singüler nokta denir<sup>10</sup> .
### <span id="page-19-1"></span>**1.1.5. Lineer Sistemler ve Hadamard Çarpımı**
× (), elemanları reel sayılar kümesinde olan × tipindeki matrisleri temsil etsin. ∈ × (), ∈ ×1 () ve ∈ ×1 () olsun. = lineer sistemi ele alınsın. Farz edilsin ki () = ve ([: ]) = olsun.
<sup>7</sup> Gerald B. Folland, **Advanced Calculus**, Upper Saddle River, NJ, PrenticeHall, Inc., 2002, pp. 95.
<sup>8</sup> David A. Wismer, R. Chattergy, **a.g.e**., p. 38.
<sup>9</sup> Gerald B. Folland, **a.g.e**., p. 98.
<sup>10</sup> George B. Arfken, Hans J. Weber, **Mathematical Methods for Physicists,** Boston, Elsevier Acad. Press, 2005, p. 438.
- i. Eğer = < ise lineer sistemin − parametreye bağlı sonsuz çözümü vardır.
- ii. Eğer = = ise lineer sistem tek bir çözüme sahiptir.
- iii. Eğer < ise lineer sistemin çözümü yoktur.
= [] ve = [] aynı boyuta sahip iki matris olsun. Bu iki matrisin hadamard çarpımı eleman yollu çarpımıdır (element-wise product). Yani bu iki matrisin hadamard çarpımı
$$A \ast B = \left[a\_{ij}b\_{lj}\right]$$
<span id="page-20-0"></span>şeklindedir. Dolayısıyla ∗ matrisinin boyutu ve matrisleri ile aynıdır.<sup>11</sup>
### **1.2. Derin Öğrenme (Deep Learning)**
İnsanın görme duyusu inanılmaz bir şekilde gelişmiştir, saliseler içerisinde görüş alanı içerisindeki nesneleri tereddütsüz bir şekilde tanıyabilir. Ancak insan sadece bu nesneleri tanıyıp onları adlandırmak ile kalmaz aynı zamanda bu nesnelerin derinliklerini de anlayabilir, siluetleri mükemmel bir şekilde ayırt edebilir ve bu nesneleri ardındaki nesnelerden ayırabilir. Gördüğümüz bu nesnelerin (veri) ham voksellerini beynimiz çizgi, eğri ve şekil gibi daha anlamlı ilkellere dönüştürür. İnsan beyni çizgileri, siluetleri, nesneleri otomatik olarak görürken bilgisayarlar sadece sayılardan oluşan devasa matrisler görürler. Bu bağlamda bilim insanları, aktif olarak, insandaki görme duyusunu taklit eden makina algoritmaları üzerinde çalışmaktadırlar. Bunun ile ilgili çalışmalar arasında hali hazırda kullanılan Facebook'un yüz tanıma algoritmaları, Google'ın sürücüsüz araçları, modern biyomedikal tanı araçları gibi çalışmalar bulunmaktadır<sup>12</sup> .
<sup>11</sup> Roger A. Horn, Charles R. Johnson**, Matrix Analysis,** New York, Cambridge University Press, 2013, pp. 12-371.
<sup>12</sup> Nikhil Buduma, Nicholas Locascio, **Fundamentals of Deep Learning: Designing Next-generation Machine Intelligence Algorithms,** O'Reilly Media, Inc, 2017, pp. 7-8.
İnsandaki görme duyusunu taklit eden böyle bir karmaşık sistemi kompleks özniteliklerin ham piksel değerleri yardımıyla işlemek için, son yıllarda derin evrişimli sinir ağı (DESA) adı verilen oldukça başarılı özel bir tür sinir ağı kullanılmaktadır<sup>13</sup> .
Esasen, DESA' yı da kapsayan derin öğrenmenin temelleri McCulloch-Pitts tarafından yapılan çalışmayla atılmıştır<sup>14</sup>. Bu çalışma insan sinir sisteminde ortaya çıkan düşüncelerin oluşumundan esinlenmiştir. Böylece yapay sinir ağlarının (YSA) temelleri de atılmıştır. Sonrasında ise Perceptron ve Neocognitron gibi modeller ortaya konmuştur<sup>15</sup>. Yapay sinir ağları gibi sığ öğrenme algoritmalarının aksine insan sinir sistemine daha çok benzeyen ağlar (derin sinir ağları) gelişen bilgisayar teknolojisi ile büyük verileri işleme konusunda oldukça iyi performans sergilemişlerdir. Derin öğrenme (DÖ) modelleri veri yapısındaki çok seviyeli soyutluğu öğrenen çok sayıdaki katmanlardan oluşur<sup>16</sup>. Derin öğrenme modelleri ses, video, görüntü (imge), doğal dil işleme, medikal, robotik gibi alanlarda veri işlemede hatırı sayılır başarı elde etmiştir<sup>17</sup> .
### <span id="page-21-0"></span>**1.2.1 İleri Beslemeli Yapay Sinir Ağları**
İleri beslemeli sinir ağlarında (İBYSA) sinyal akışı, . katmanda yer alan nöronlardan ( + 1). katmanda yer alan nöronlara doğru tek yönde olur. Aşağıda [Şekil](#page-23-0)
<sup>13</sup> Y. LeCun, L. Bottou, Y. Bengio and P. Haffner, "Gradient-Based Learning Applied to Document Recognition", **Proceedings of the IEEE**, Vol. 86, No: 11, 1998, pp. 2278-2324.
<sup>14</sup> W. McCulloch and W. Pitts, "A logical calculus of the ideas immanent in nervous activity", **Bulletin of Mathematical Biophysics**, Vol. 5, No: 4, 1943, pp. 115–133.
<sup>15</sup> F. Rosenblatt, "The Perceptron: A Probabilistic Model for Information Storage and Organization in The Brain", **Psychological Review**, Vol. 65, No: 6, 1958, pp. 386–408.; D. H. Wiesel and T. N. Hubel," Receptive fields of single neurones in the cat's striate cortex", **The Journal of Physiology**, Vol. 148, No: 3, 1959, pp. 574–591.
<sup>16</sup> Y. LeCun, Y. Bengio and G. Hinton, "Deep learning", **Nature**, Vol. 521, No: 7553, 2015, pp. 436- 444.
<sup>17</sup> Abdel-rahman Mohamed, George E. Dahl, and Geoffrey Hinton. "Acoustic modeling using deep belief networks", **IEEE Transactions on Audio, Speech, and Language Processing**, Vol. 20, No: 1, 2012, pp. 14-22.; Andrej Karpathy, George Toderici, Sanketh Shetty, Thomas Leung, Rahul Sukthankar, and Li Fei-Fei, "Large-scale video classification with convolutional neural networks", **In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition**, 2014, pp. 1725- 1732.; Feng Ning, Damien Delhomme, Yann LeCun, Fabio Piano, Léon Bottou, and Paolo Emilio Barbano, "Toward automatic phenotyping of developing embryos from videos", **IEEE Transactions on Image Processing**, Vol. 14, No: 9, 2005, pp. 1360-1371.; Hermann Mayer, Faustino Gomez, Daan Wierstra, Istvan Nagy, Alois Knoll, and Jürgen Schmidhuber, "A system for robotic heart surgery that learns to tie knots using recurrent neural networks", **Advanced Robotics**, Vol. 22, No: 13-14, 2008, pp. 1521-1537.
[1.1](#page-23-0) ile basit bir ileri beslemeli sinir ağı verilmektedir. Verilen şekilde en altta yer alan katman girdi verisini, en üstte yer alan katman hesaplanan çıktı değerlerini, arada yer alan katman ise gizli katmanı temsil etmektedir. , () değeri ise . katmandaki . nöron ile ( + 1). katmandaki . nöron arasındaki bağlantının ağırlığını temsil etmektedir. Gizli katmanda yer alan her bir nöron kendisine ait girdi değerleri ve ağırlıklar yardımıyla bazı değerleri üretir. Aşağıda . katmanda yer alan . nöron için bu değerlerin nasıl üretildiği verilmiştir. , girdi değerlerinin sayısı olmak üzere, . katman . nöron için çıktı değeri:
$$f\left(\sum\_{i=1}^d \mathbf{x}\_i \mathbf{w}\_{ij}^{(k)}\right) = f\left(\left(\mathbf{w}\_j^{(k)}\right)^T \mathbf{x}\right),$$
şeklinde hesaplanır. Burada fonksiyonuna transfer veya aktivasyon fonksiyonu denir. Bu bölümde bazı aktivasyon fonksiyonlarından bahsedilecektir. . katmandaki tüm nöronlar için üretilen bu çıktı değerleri ( + 1). katmanın girdi değerleri olacaktır. Aynı yolla çıktı katmanına kadar tüm katmanlarda gerekli hesaplamalar yapılır. Çıktı katmanında üretilen çıktı değerleri ile istenen hedef değerleri arasında bir hata fonksiyonu yardımıyla (ağdaki tüm hataları temsilen parametrelerine bağlı) hata değeri elde edilir.
#### <span id="page-23-0"></span>**Şekil 1.1** 3 katmanlı (girdi, bir gizli ve çıktı) ve her bir katmanda 3 nöronlu ileri beslemeli sinir ağı
**Kaynak:** Buduma, **a.g.e**, p.15.
Temsili olarak, girdi verisi , hedef değerleri , parametre değerleri vektörleri ve kullanılan tüm aktivasyon fonksiyonları ile temsil edilsin. Hata fonksiyonu;
#### (; ; )
şeklindedir. Hata fonksiyonu kareli hata, negatif olabilirlik fonksiyonu vb. olabilir. Çalışmanın dördüncü bölümünde bazı hata fonksiyonlarının detaylarından bahsedilmiştir.
Sinir ağlarında amaç hatayı minimize edecek optimum değerlerine yaklaşmaktır. Bunun için belli bir durdurma kriteri ile başlangıçta keyfi olarak seçilen parametreleri, seçilen optimizasyon algoritması yardımıyla her bir iterasyonda güncellenir. Bu bölümde optimizasyon algoritması olarak derin öğrenmede sıklıkla kullanılan gradyan iniş yönteminden bahsedilecektir. Daha önceden de bahsedildiği gibi bu tezde derin öğrenme ağları ve matematiksel fonksiyonlar için yeni bir optimizasyon algoritması sunulmuştur. Sunulan bu yönteme ait uygulama detayları dördüncü bölümde yer almaktadır<sup>18</sup> .
### <span id="page-24-0"></span>**1.2.2 Gradyan İniş Algoritması**
Bahsedildiği gibi örüntü tanıma ve makine öğrenmesi problemlerinde amaç hatayı minimize edecek parametre değerlerine yaklaşmaktır. Eğer hata fonksiyonu (; ; ), parametrelerine göre diferansiyellenebilir ise gradyan bilgisini kullanarak parametrelerini güncelleyecek en basit yaklaşım gradyan iniş algoritmasıdır. Hata fonksiyonunu diferansiyellenebilir kılmak için aktivasyon fonksiyonlarının diferansiyellenebilir olması aşikardır.
Gradyan iniş yönteminin üç farklı formu bulunmaktadır. Bunlar; parti (batch), küçük-parti (mini-batch) ve stokastik gradyan inişdir. Bu formlar hata fonksiyonuna giren eğitim verisi büyüklüğü temelinde farklılık gösterirler.
Tüm girdi verisini ve karşılık gelen hedef değerleri , parametre değerleri vektörleri olmak üzere, parti gradyan iniş ile için güncelleme
$$W - \alpha \nabla\_W Hata(x; y; W)$$
şeklindedir. Burada > 0 öğrenme oranı (learning rate) olarak bilinir. Stokastik gradyan iniş ile için güncelleme ise
$$W -
α
∇\_W
Hata
{(x^{(l)}; y^{(l)}; W)}$$
şeklindedir. Burada () ve () sırasıyla . eğitim verisi için girdi ve çıktı değerler vektörleridir. Stokastik gradyan iniş yöntemi kullanılırken hata fonksiyonu sadece tek bir veriden oluştuğundan parametre güncelleme parti gradyan iniş yöntemine göre daha hızlı olacaktır.
<sup>18</sup> Buduma, **a.g.e**, pp. 14-15.; Richard O. Duda, Peter E. Hart, and David G. Stork. **Pattern classification**. John Wiley & Sons, 2012, pp. 284-285.
Küçük-parti gradyan iniş yönteminde ise hata fonksiyonu eğitim verisinin belli bir partisinden oluşur. Dolayısıyla eğitim verisinden oluşan bir parti için mini-parti gradyan iniş ile için güncelleme
$$\mathcal{W} - \alpha \nabla\_{\mathcal{W}} Hata \{ \boldsymbol{x}^{(l:l+n)}; \boldsymbol{\mathcal{Y}}^{(l:l+n)}; \boldsymbol{W} \}$$
şeklindedir. Dördüncü bölümde yer alan MNIST veri seti üzerindeki softmax ve DESA analizleri için küçük-parti yaklaşımı benimsenmiştir. Tüm bu güncellemelerde , hata fonksiyonunu azaltan en büyük oran yönünde hareket eder <sup>19</sup> .
### <span id="page-25-0"></span>**1.2.3 Geri Yayılım Algoritması (Backpropagation)**
Gradyan iniş algoritmasını uygulayabilmek için etkili bir şekilde kısmi türev almak gerekir. Bu amaç için matematikte zincir kuralı olarak bilinen geri yayılım algoritması (GYA) kullanılır.
() ve () sırasıyla . eğitim verisi için girdi ve çıktı değerleri, = 2, … , olmak üzere ağdaki katman indislerini, , değeri ise . katmandaki . nöron ile ( + 1). katmandaki . nöron arasındaki bağlantının ağırlığı, . katman için net vektörü, . katmandaki . nöron için net değeri, . katman için aktivasyon vektörü, . katmandaki . nöron için aktivasyon değeri ve aktivasyon fonksiyonu olsun. = 2, … , olmak üzere . katman için ve ile ilgili aşağıdaki ifadeler verilsin.
$$\begin{aligned} z^l &= w^l \ast a^{l-1} \\\\ a^l &= \sigma(z^l) \end{aligned}$$
Yukarıda ∗ operatörü hadamard çarpımını temsil etmektedir. Ayrıca hata fonksiyonu olarak aşağıda ile gösterilen kuadratik fonksiyon kullanılsın.
<sup>19</sup> Christopher, M. Bishop., **Pattern Recognition and Machine Learning (Information Science and Statistics)**, Springer-Verlag New York, 2006, pp. 240-241.; Sergey Ioffe & Christian Szegedy, "Batch normalization: Accelerating deep network training by reducing internal covariate shift", **International Conference on Machine Learning**, June 2015, pp. 448-456.
$$\mathcal{L}(\boldsymbol{x}; \boldsymbol{y}; \boldsymbol{W}) = \frac{1}{2} \|\boldsymbol{y} - \boldsymbol{a}^{L}\|^{2} = \frac{1}{2} \sum\_{j} \left(\boldsymbol{y}\_{j} - \boldsymbol{a}\_{j}^{L}\right)^{2}$$
Hata fonksiyonunun gradyan vektörünü hesaplayabilmek için öncelikle ileri besleme aşaması yapılır ve her bir katman için ve değerleri elde edilir. <sup>0</sup> vektörü eğitim verisini girdi vektörünü temsil etmektedir.
Daha sonrasında çıktı katmanı için (. katman için) hata vektörü hesaplanır. , çıktı katmanı için hata vektörü olmak üzere, . katmandaki nöronu için hata değeri
$$\boldsymbol{\delta}\_{l}^{L} = \nabla\_{\mathbf{z}\_{l}^{L}} \mathcal{C} = -(\mathbf{y}\_{l} - a\_{l}^{L}) \boldsymbol{\sigma}'(\mathbf{z}\_{l}^{L})$$
şeklinde hesaplanır. Sonraki aşama olarak = − 1, − 2, − 3, … ,2 olmak üzere . katmandaki nöronu için hata değeri
$$\delta\_i^l = \left(\sum\_j \omega\_{j\_l}^l \delta\_i^{l+1}\right) \sigma'(\mathbf{z}\_i^l)$$
hesaplanır. Son olarak istenen kısmi türevler,
$$\frac{\partial}{\partial \boldsymbol{w}\_{ij}^{l}} \boldsymbol{C}(\boldsymbol{x}; \boldsymbol{y}; \boldsymbol{W}) = a\_{j}^{l} \boldsymbol{\delta}\_{i}^{l+1}$$
şeklinde hesaplanır. Bu hesaplamalar yapılırken aktivasyon fonksiyonunun türevine ihtiyaç duyulur. Not olarak söylemek gerekir ki eğer aktivasyon fonksiyonunun türevi fonksiyonun kendisi biçiminden ifade edilebilirse hesaplamalar çok daha hızlı bir şekilde yapılır. Sigmoid fonksiyonu tam da bu şekilde bir fonksiyondur. Aşağıda bazı aktivasyon fonksiyonları ve bu fonksiyonların türevleri verilmiştir<sup>20</sup> .
<sup>20</sup> Bishop**, a.g.e**, pp. 241-249.
### <span id="page-27-0"></span>**1.2.4 Aktivasyon Fonksiyonları**
Aşağıda yer alan fonksiyonu sigmoid fonksiyonudur. Sigmoid fonksiyonu <sup>2</sup> de geometrik olarak 'S' şekline benzemektedir.
$$\mathcal{S}(t) = \frac{1}{1 + e^{-t}}$$
Sigmoid fonksiyonunun önemli bir özelliği türevinin fonksiyonun kendisiyle gösterilebiliyor olmasıdır. Sigmoid fonksiyonunun türevi ise
$$\mathcal{S}'(t) = \mathcal{S}(t)(1 - \mathcal{S}(t))$$
şeklindedir<sup>21</sup> .
Diğer sık kullanılan bir aktivasyon fonksiyonu (AF) olarak softmax fonksiyonundan bahsedilebilir. Softmax fonksiyonu ile > 2 sınıf sayısı olmak üzere üstel normalizasyon yapılır.
$$\text{Softmax(net}\_k) = \frac{e^{net\_k}}{\sum\_{m=1}^{K} e^{net\_m}}.$$
Softmax fonksiyonunun görüntü uzayında tane fonksiyon olduğundan türevi için Jacobian matrisi kullanılır.
Son olarak tanjant hiperbolik fonksiyonu ise,
$$
tanh(t) = \frac{e^t - e^{-t}}{e^t + e^{-t}}
$$
şeklindedir.
Bu fonksiyonun türevi ise yine fonksiyonun cinsinden yazılabilir<sup>22</sup>:
$$tanh'(t) = 1 - tanh^2(t).$$
<sup>22</sup> Bishop**, a.g.e**, pp. 197-245.
<sup>21</sup> Jun Han, Claudio Morag, "The influence of the sigmoid function parameters on the speed of backpropagation learning", **In: Mira José, Sandoval F. (eds) From Natural to Artificial Neural Computation**, 1995, pp. 195–201.
### <span id="page-28-0"></span>**1.2.5 Derin Evrişimli Sinir Ağları (Deep Convolutional Neural Networks)**
Derin evrişimli sinir ağları (DESA) bünyesinde genellikle evrişim katmanı (convolutional layer), havuzlama katmanı (pooling layer) ve tam bağlı katmanı (fully connected layer) bulundurur. Bu alt bölümde bu katmanlardan bahsedilecektir.
### <span id="page-28-1"></span>**1.2.5.1 Evrişim Katmanı (Convolutional Layer)**
İmge verisinde, ham verideki x ve y noktaları arasındaki uzaklık arttıkça bu x ve y noktaları arasındaki korelasyonun azalması çok önemli bir varsayımdır. Bu durum, tamamen birbirine bağlı nöronların (her bir nöron, alt katmanda yer alan tüm nöronlara bağlı) kullanımı yerine lokal olarak birbirine bağlı nöronların (her bir nöron, alt katmanda birbirine komşu olan nöronlar kümesine bağlı) kullanımının daha doğru olacağını gösterir. İmge verileri için diğer önemli husus ise, imgenin her bölgesinde aranan özniteliklerin aynı olması gerektiğidir. Örneğin imgedeki herhangi bir konumda yatay kenarın önemli olduğu bulunmuş ise, bu bilgi imgedeki diğer konumlar içinde kullanılabilir. Böylece evrişim katmanındaki tüm farklı konumlar için yatay kenarı bulmayı tekrar öğrenmeye gerek kalmamış olur. Bu iki önemli varsayım birleştirilirse, ağdaki ağırlıklar lokal olarak birbirine bağlı her bir nöron için paylaşılır denebilir<sup>23</sup> .
Esasen evrişim katmanı bir operatördür. Evrişim katmanından geçen girdi tensörü ağırlık (kernel veya filter) tensörü ile evrişir. Bu evrişme gerçekleşirken bazı hiper parametreler tanımlanmıştır. Bunlar stride, zero padding, boyutsal uzanım (spatial extent) ve ağırlık sayısı değerleridir. Stride değeri evrişim işlemi gerçekleşirken ağırlık tensörünün girdi tensörü üzerinde hangi aralıklar ile adım atılacağı bilgisini verir. Zero padding değeri ise girdi tensörünün boyutunu büyütür ve büyütülen yerlere sıfır değerleri atar. Boyutsal uzanım ağırlık tensöründe yer alan
<sup>23</sup> Emrecan Batı, "Deep convolutional neural networks with an application towards geospatial object recognition", **Middle East Technical University**, Master's thesis, Ankara, 2016, p. 33.
matrislerin satır ve sütun sayısı değerleridir, ağırlık sayısı ise ağırlık tensöründeki kanal sayısıdır. Burada tensör kavramı ile matris ailesi kastedilmektedir. Örneğin tane ( kanallı) × matrisi yerine × × tipinde tensör ifadesi kullanılmaktadır (3 boyutlu tensör).
<span id="page-29-0"></span>**Şekil 1.2.** (a) Katman deki her nöron katman − 1 deki 3 komşu nörona bağlı ve katman + 1 deki nöron katman deki 3 komşu nörona aynı şekilde bağlıdır.
(b) Aynı renkteki bağlantılar aynı ağırlıkta olacak şekilde kısıtlanmıştır.
**Kaynak:** The Theano Development Team: Theano, " Convolutional Neural Networks (LeNet) -- DeepLearning 0.1 documentation", (Çevrimiçi) [http://deeplearning.net/tutorial/lenet.html,](http://deeplearning.net/tutorial/lenet.html) 25.2.2016.
Şimdi matematiksel olarak tüm bu söylenenlerin ne anlama geldiğini açıklayalım. Girdi tensörü <sup>1</sup> × <sup>1</sup> × <sup>1</sup> tipinde olsun. Burada 1; girdi kanal sayısı, 1; girdi matrislerinin (imgenin) sütun sayısı, 1; girdi matrislerinin (imgenin) satır sayısıdır. Hiper parametre değerleri; , , , ise sırasıyla ağırlık sayısını, boyutsal uzanım değerini, stride değerini ve zero padding değerini temsil etsin. Evrişim katmanı için operatör olarak sembolü kullanılsın. katmanının çıktı tensörü <sup>2</sup> × <sup>2</sup> × <sup>2</sup> tipinde olur. Burada,
$$E\_2 = \frac{(E\_1 - F + 2P)}{S} + 1,$$
$$B\_2 = \frac{(B\_1 - F + 2P)}{S} + 1$$
$$D\_2 = K$$
şeklindedir. Burada 2; çıktı kanal sayısı, 2; çıktı matrislerinin (imgenin) sütun sayısı, 2; çıktı matrislerinin (imgenin) satır sayısıdır.
Örnek üzerinde katmanını açıklayalım. Girdi tensörü <sup>1</sup> × <sup>1</sup> × <sup>1</sup> = 3 × 5 × 5 tipinde olsun: 1, 2, 3. Ayrıca = 2 tane, boyutsal uzanım (spatial extent) değeri = 3 olan ağırlık matrislerini ele alalım: 1, 2. Stride değeri olarak = 2 ve zero padding değeri olarak = 1 alalım. Girdi matrisleri ve ağırlık matrisleri aşağıdaki biçimde verilsin.
$$\mathbf{x}\_1 = \begin{bmatrix} 1 & 0 & 1 & 0 & 1 \\ 2 & 2 & 2 & 1 & 1 \\ 2 & 1 & 1 & 2 & 2 \\ 1 & 2 & 2 & 1 & 0 \\ 0 & 2 & 1 & 0 & 1 \end{bmatrix}, \mathbf{x}\_2 = \begin{bmatrix} 1 & 0 & 2 & 2 & 0 \\ 1 & 1 & 0 & 1 & 2 \\ 0 & 0 & 2 & 2 & 2 \\ 0 & 2 & 2 & 1 & 0 \\ 2 & 1 & 0 & 0 & 2 \end{bmatrix}, \mathbf{x}\_3 = \begin{bmatrix} 1 & 1 & 2 & 1 & 1 \\ 1 & 1 & 0 & 2 & 1 \\ 2 & 1 & 0 & 1 & 0 \\ 0 & 0 & 1 & 0 & 0 \end{bmatrix},$$
$$\mathbf{w}\_1 = \begin{bmatrix} 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 0 & 0 \end{bmatrix}, \begin{bmatrix} -1 & -1 & 0 \\ 0 & 1 & -1 \\ 0 & 0 & 0 \end{bmatrix}, \begin{bmatrix} -1 & 0 & 0 \\ 1 & -1 & 0 \\ 0 & 0 & 0 \end{bmatrix},$$
$$\mathbf{w}\_2 = \begin{bmatrix} -1 & -1 & 1 \\ -1 & -1 & 1 \\ 1 & -1 & -1 \end{bmatrix}, \begin{bmatrix} 0 & 0 & 0 \\ -1 & 1 & 1 \\ -1 & 1 & 1 \end{bmatrix}, \begin{bmatrix} -1 & 0 & -1 \\ -1 & 0 & 0 \\ 0 & 1 & 0 \end{bmatrix}.$$
Verilen bu değerler ışığında (1, 2, 3; 1, 2; ; ) hesaplanacaktır. Öncelikle çıktı matrisinin boyutu hesaplanmalıdır. Yukarıda verilenler ışığında çıktı tensörü <sup>2</sup> × <sup>2</sup> × <sup>2</sup> = 2 × 3 × 3 tipinde olur. Bu çıktı matrisleri <sup>1</sup> = [ 1 ], <sup>2</sup> = [ 2 ] şeklinde sembolize edilsin. Zero padding değeri = 1 olduğundan 1, 2, <sup>3</sup> matrisleri 7 × 7 tipine dönüşücektir. Dolayısıyla 1, 2, <sup>3</sup> matrisleri
$$\mathbf{x}\_1^\* = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 1 & 0 & 1 & 0 \\ 0 & 2 & 2 & 2 & 1 & 1 & 0 \\ 0 & 2 & 1 & 1 & 2 & 2 & 0 \\ 0 & 1 & 2 & 2 & 1 & 0 & 0 \\ 0 & 0 & 2 & 1 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix}$$
$$\begin{aligned} \mathbf{x}\_2^\* &= \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 2 & 2 & 0 & 0 \\ 0 & 1 & 1 & 0 & 1 & 2 & 0 \\ 0 & 0 & 0 & 2 & 2 & 2 & 0 \\ 0 & 0 & 2 & 2 & 1 & 0 & 0 \\ 0 & 2 & 1 & 0 & 0 & 2 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} \\\\ \mathbf{x}\_3^\* &= \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 1 & 2 & 1 & 1 & 0 \\ 0 & 1 & 1 & 0 & 2 & 1 & 0 \\ 0 & 2 & 1 & 0 & 1 & 0 & 0 \\ 0 & 2 & 2 & 2 & 0 & 2 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} \end{aligned}$$
şeklinde dönüşecektir. katmanı <sup>1</sup> ∗ , <sup>2</sup> ∗ , <sup>3</sup> <sup>∗</sup> matrislerinin alt matrisleri ile 1, <sup>2</sup> matrislerinin elemanları çarpımının toplamı ile ve matrislerini elde eder. Bu işlemi ⊙ ile gösterelim. Örneğin <sup>11</sup> değeri aşağıdaki gibi bulunur:
$$
\begin{bmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 2 & 2 \end{bmatrix} \odot \begin{bmatrix} 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 0 & 0 \end{bmatrix} + \begin{bmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 1 & 1 \end{bmatrix} \odot \begin{bmatrix} -1 & -1 & 0 \\ 0 & 1 & -1 \\ 0 & 0 & 0 \end{bmatrix} + \begin{bmatrix} 0 & 0 & 0 \\ 0 & 1 & 1 \\ 0 & 1 & 1 \end{bmatrix} \odot \begin{bmatrix} -1 & 0 & 0 \\ 1 & -1 & 0 \\ 0 & 0 & 0 \end{bmatrix}
$$
$$
\boldsymbol{o}\_{11}^1 = \boldsymbol{0} + \boldsymbol{1} + \{-1\} = \boldsymbol{0}
$$
değeri ise
$$
\begin{bmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 2 & 2 & 1 \end{bmatrix} \odot \begin{bmatrix} 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 0 & 0 \end{bmatrix} + \begin{bmatrix} 0 & 0 & 0 \\ 0 & 2 & 2 \\ 1 & 0 & 1 \end{bmatrix} \odot \begin{bmatrix} -1 & -1 & 0 \\ 0 & 1 & -1 \\ 0 & 0 & 0 \end{bmatrix} + \begin{bmatrix} 0 & 0 & 0 \\ 1 & 2 & 1 \\ 1 & 0 & 2 \end{bmatrix} \odot \begin{bmatrix} -1 & 0 & 0 \\ 1 & -1 & 0 \\ 0 & 0 & 0 \end{bmatrix}
$$
$$o\_{12}^1 = 0 + 0 + (-1) = -1$$
şeklinde bulunur. Tüm bu işlemler neticesinde ve matrisleri
$$o^1 = \begin{bmatrix} 0 & -1 & 0 \\ 2 & 7 & 2 \\ 6 & 0 & 2 \end{bmatrix}$$
$$o^2 = \begin{bmatrix} -1 & 1 & -2 \\ -1 & -1 & -7 \\ 4 & -9 & 0 \end{bmatrix}$$
<span id="page-32-0"></span>şeklinde elde edilir<sup>24</sup> .
### **1.2.5.2 Havuzlama Katmanı (Pooling Layer)**
DESA yapılarında havuzlama katmanı sık kullanılmaktadır. Girdi tensörüne havuzlama katmanı işlemi uygulandığında tensörün boyutsal uzanım büyüklüğü küçülür ve böylece ağdaki parametre sayısı azalır. Havuzlama katmanı için iki hiper parametre vardır: boyutsal uzanım () ve stride () değerleri.
Girdi tensörü <sup>1</sup> × <sup>1</sup> × <sup>1</sup> tipinde olsun. Havuzlama katmanı için operatör olarak sembolü kullanılsın. Havuzlama katmanının çıktı tensörü <sup>2</sup> × <sup>2</sup> × <sup>2</sup> tipinde olur. Burada,
$$E\_2 = \frac{(E\_1 - F)}{S} + 1,$$
$$B\_2 = \frac{(B\_1 - F)}{S} + 1$$
$$D\_2 = D\_1$$
Örnek üzerinde katmanını açıklayalım. Girdi tensörü <sup>1</sup> × <sup>1</sup> × <sup>1</sup> = 1 × 4 × 4 tipinde olsun: 1. Hiper parametre değerleri olarak = 2 ve = 2 olsun. <sup>1</sup> aşağıdaki gibi verilsin.
$$\mathbf{x}\_1 = \begin{bmatrix} 1 & 5 & 2 & 9 \\ 2 & 3 & 4 & 2 \\ 1 & 7 & 3 & 2 \\ 0 & 8 & 0 & 6 \end{bmatrix}$$
katmanı <sup>1</sup> matrisini ve hiper parametre değerleri kullanarak alt matrislere böler ve bazı işlemler ile çıktı tensörünü elde eder. alt matrisin büyüklüğünü belirler. ise adım sayısını belirtir. Bu işlemler alt matriste yer alan değerlerin ortalaması veya bu değerlerin maksimum değeri vb. olabilir. Eğer işlem olarak maksimum seçilirse bu
<sup>24</sup> Andrej Karpathy, "Course materials and notes for Stanford class CS231n: Convolutional Neural Networks for Visual Recognition", (Çevrimiçi) [http://cs231n.github.io/convolutional-networks/,](http://cs231n.github.io/convolutional-networks/) 8.2.2018.
katmana max-pool katmanı denir. Yukarıda verilenler ışığında çıktı tensörü <sup>2</sup> × <sup>2</sup> × <sup>2</sup> = 1 × 2 × 2 tipinde olur. Çıktı tensöründe yer alan matrisi <sup>1</sup> = [ 1 ] ile gösterelim. Ayrıca işlem olarak pratikte yaygın olarak da kullanılan maksimum seçilsin. max-pool katmanı ile
$$o\_{11}^1 = \max\{1, 5, 2, 3\} = 5$$
$$o\_{12}^1 = \max\{2, 9, 4, 2\} = 9$$
$$o\_{12}^1 = \max\{1, 7, 0, 8\} = 8$$
$$o\_{12}^1 = \max\{3, 2\} 0, 6$$
olur. Dolayısıyla <sup>1</sup> matrisi ise
.
$$o^1 = \begin{bmatrix} 5 & 9 \\ 8 & 6 \end{bmatrix}$$
<span id="page-33-0"></span>şeklinde olur<sup>25</sup>
### **1.2.5.3 Tam Bağlı Katman (Fully Connected Layer)**
Tam bağlı katmandaki her nöron tıpkı klasik sinir ağlarında olduğu gibi kendisinden önceki tüm nöronlara tam olarak bağlıdır<sup>26</sup> .
<sup>26</sup> **A.e.**
<sup>25</sup> **A.e.**
# **2 İKİNCİ BÖLÜM** −**BOYUTLU UZAYDA SPESİFİK BİR HİPER DÜZLEM: HİPER DÜZLEMİ**
### <span id="page-34-0"></span>**2.1. Hiper Düzlemi ve Bazı Önemli Özellikleri**
Çalışmanın bu bölümünde boyutlu uzay için yeni bir hiper düzlem ailesi sunulacaktır ve sunulacak olan bu hiper düzlemlerin geometrik anlamı irdelenecektir.
**Tanım 2.1.** boyutlu uzayda a ≠ b<sup>p</sup> olmak üzere birbirinden ve sıfır vektöründen farklı olan = (a1, a2, … , a<sup>n</sup> ) ve = (b1, b2, … , b<sup>n</sup> ) noktaları verilsin. de p. bileşen için (p = 1,2, … , n) hiper düzlemi
$$X = \{ \mathbf{x} = (\mathbf{x}\_1, \mathbf{x}\_2, \dots, \mathbf{x}\_n) : \ \mathbf{c}\_\*^T \mathbf{x} = \mathbf{z}\_\* \}$$
noktalar kümesi olarak tanımlansın. Burada <sup>∗</sup> ≠ 0 bileşenli bir vektör ve z<sup>∗</sup> skaler olmak üzere aşağıdaki gibi tanımlanmıştır:
$$c\_\* = \left\lfloor \frac{\underbrace{\left(\mathbf{a}\_{\mathrm{p}-1} - \mathbf{b}\_{\mathrm{p}-1}\right)}\_{\mathbf{m}\_\*}}{\mathbf{m}\_\*} \right\rfloor$$
$$c\_\* = \left\lfloor \frac{\left(\mathbf{a}\_{\mathrm{p}+1} - \mathbf{b}\_{\mathrm{p}+1}\right)}{\mathbf{m}\_\*} \right\rfloor$$
$$= \left\lfloor \frac{\left(\mathbf{a}\_{\mathrm{p}+1} - \mathbf{b}\_{\mathrm{p}+1}\right)}{\mathbf{m}\_\*} \right\rfloor$$
$$= \left\lfloor \frac{\left(\mathbf{a}\_{\mathrm{n}} - \mathbf{b}\_{\mathrm{n}}\right)}{\mathbf{m}\_\*} \right\rfloor$$
$$\mathbf{z}\_{\*} = \frac{1}{\mathbf{m}\_{\*}} \sum\_{\mathbf{i}=\mathbf{l}}^{\mathbf{p}-1} \mathbf{a}\_{\mathbf{i}} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}}) + \frac{1}{\mathbf{m}\_{\*}} \sum\_{\mathbf{i}=\mathbf{p}+\mathbf{1}}^{\mathbf{n}} \mathbf{a}\_{\mathbf{i}} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}}) + \mathbf{a}\_{\mathbf{p}} \dots$$
Ayrıca m<sup>∗</sup> skaleri aşağıdaki gibi tanımlanmıştır:
$$\mathbf{m}\_{\*} = \frac{1}{\mathbf{b}\_{\mathbf{p}} - \mathbf{a}\_{\mathbf{p}}} \left( \sum\_{\mathbf{i}=\mathbf{1}}^{\mathbf{p}-1} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}})^2 + \sum\_{\mathbf{i}=\mathbf{p}+\mathbf{1}}^{\mathbf{n}} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}})^2 \right).$$
Burada <sup>∗</sup> vektörünün hiper düzleminin normal vektörü olduğu açıktır.
de verilen iki nokta için tüm hiper düzlemlerinin ailesi Tanım 2.2 de verilmiştir.
**Tanım 2.2.** boyutlu uzayda birbirinden ve sıfır vektöründen farklı olan = (a1, a2, … , a<sup>n</sup> ) ve = (b1, b2, … , b<sup>n</sup> ) noktaları verilsin. de verilen bu iki nokta için hiper düzlem ailesi
$$M = \{M\_p \colon p = 1, 2, \ldots, n\}.$$
şeklindedir. Burada her bir hiper düzlemi için ve noktalarının . bileşenlerinin birbirinden farklı olduğu varsayılmıştır.
Bölüm 3 te sunulan algoritmanın temel dayanağı olan hiper düzleminin ne ifade ettiğini açıklayalım. Tanım 2.1 den boyutlu uzayda a ≠ b<sup>n</sup> olmak üzere birbirinden ve sıfır vektöründen farklı olan = (a1, a2, … , a<sup>n</sup> ) ve = (b1, b2, … , b<sup>n</sup> ) noktaları için hiper düzlemi
$$X = \{ \mathbf{x} = (\mathbf{x}\_1, \mathbf{x}\_2, \dots, \mathbf{x}\_n) : \mathbf{c}^T \mathbf{x} = \mathbf{z} \} \tag{2.1}$$
,
noktalar kümesidir. Burada ≠ 0 bileşenli bir vektör ve z skaler olmak üzere aşağıdaki gibi verilmiştir:
$$c = \begin{bmatrix} \frac{(\mathbf{a}\_1 - \mathbf{b}\_1)}{\mathbf{m}}\\\frac{(\mathbf{a}\_2 - \mathbf{b}\_2)}{\mathbf{m}}\\\cdots\\\frac{(\mathbf{a}\_{\mathbf{n}-1} - \mathbf{b}\_{\mathbf{n}-1})}{\mathbf{m}}\\\mathbf{1} \end{bmatrix}$$
$$\begin{aligned} \mathbf{z} &= \frac{1}{\mathbf{m}} \sum\_{\mathbf{i}=\mathbf{1}}^{\mathbf{n}-1} \mathbf{a}\_{\mathbf{i}} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}}) + \mathbf{a}\_{\mathbf{n}} \ , \\\\ \mathbf{m} &= \frac{1}{\mathbf{b}\_{\mathbf{n}} - \mathbf{a}\_{\mathbf{n}}} \sum\_{\mathbf{i}=\mathbf{1}}^{\mathbf{n}-1} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}})^2 \ . \end{aligned}$$
Denklem (2.1) aşağıdaki şekilde de yazılabilir:
$$X = \left\{ \mathbf{x} \colon \mathbf{x}\_{\mathbf{n}} = \sum\_{\mathbf{i}=1}^{\mathbf{n}-1} \frac{(\mathbf{b}\_{\mathbf{i}} - \mathbf{a}\_{\mathbf{i}})}{\mathbf{m}} \mathbf{x}\_{\mathbf{i}} + \frac{1}{\mathbf{m}} \sum\_{\mathbf{i}=1}^{\mathbf{n}-1} \mathbf{a}\_{\mathbf{i}} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}}) + \mathbf{a}\_{\mathbf{n}} \right\}. \tag{2.2}$$
Denklem (2.2) de hiper düzlemi . koordinat düzlemi baz alınarak ifade edilmiştir. Denklem (2.2) den faydalanarak hiper düzlemine ait gradyan (x<sup>n</sup> bileşeninin gradyanı) :
$$\nabla \mathbf{x}\_n = \left[ \frac{\mathbf{b}\_1 - \mathbf{a}\_1}{\mathbf{m}}, \frac{\mathbf{b}\_2 - \mathbf{a}\_2}{\mathbf{m}}, \dots, \frac{\mathbf{b}\_{\mathbf{n}-1} - \mathbf{a}\_{\mathbf{n}-1}}{\mathbf{m}} \right]^T \tag{2.3}$$
şeklindedir. Burada m aşağıdaki gibidir:
$$\mathbf{m} = \frac{1}{\mathbf{b}\_{\mathbf{n}} - \mathbf{a}\_{\mathbf{n}}} \sum\_{\mathbf{i}=\mathbf{l}}^{\mathbf{n}-1} (\mathbf{a}\_{\mathbf{i}} - \mathbf{b}\_{\mathbf{i}})^2.$$
**Örnek 2.3.** <sup>2</sup> de = (a1, a<sup>2</sup> ) = (1,2) and = (b1, b<sup>2</sup> ) = (3,4) nokta çifti için 1doğrusu elde edecek olursak,
$$\begin{aligned} \mathbf{c}\_\* &= \begin{bmatrix} 1 \\ (\mathbf{a}\_2 - \mathbf{b}\_2) \\ \hline \mathbf{m}\_\* \end{bmatrix} = \begin{bmatrix} 1 \\ (-2) \\ \hline \mathbf{m}\_\* \end{bmatrix} \\\\ \mathbf{z}\_\* &= \frac{1}{\mathbf{m}\_\*} \mathbf{a}\_2 (\mathbf{a}\_2 - \mathbf{b}\_2) + \mathbf{a}\_1 = \frac{1}{\mathbf{m}\_\*} (-4) + 1 \\\\ \mathbf{m}\_\* &= \frac{1}{\mathbf{b}\_1 - \mathbf{a}\_1} (\mathbf{a}\_2 - \mathbf{b}\_2)^2 = 2 \end{aligned}$$
bulunur. Dolayısıyla
$$\mathbf{c}\_\*^T \mathbf{x} - \mathbf{z}\_\* = \begin{bmatrix} 1 & -1 \end{bmatrix} \begin{bmatrix} \mathbf{x}\_1 \\\\ \mathbf{x}\_2 \end{bmatrix} + \mathbf{1} = \mathbf{0}$$
olacağından x<sup>1</sup> − x<sup>2</sup> + 1 = 0 doğrusu istenen <sup>1</sup> doğrusudur. ve nokta çifti için <sup>2</sup> doğrusunu elde edecek olursak ise,
$$\mathbf{c} = \left[\frac{(\mathbf{a}\_1 - \mathbf{b}\_1)}{\mathbf{m}}\right] = \left[\frac{(-2)}{\mathbf{m}}\right]$$
$$\mathbf{z} = \frac{1}{\mathbf{m}} \mathbf{a}\_1 (\mathbf{a}\_1 - \mathbf{b}\_1) + \mathbf{a}\_2 = \frac{1}{\mathbf{m}}(-2) + 2$$
$$\mathbf{m} = \frac{1}{\mathbf{b}\_2 - \mathbf{a}\_2} (\mathbf{a}\_1 - \mathbf{b}\_1)^2 = 2$$
bulunur. Dolayısıyla
$$\mathbf{c}^T \mathbf{x} - \mathbf{z} = \begin{bmatrix} -1 & 1 \end{bmatrix} \begin{bmatrix} \mathbf{x}\_1 \\\\ \mathbf{x}\_2 \end{bmatrix} - \mathbf{1} = \mathbf{0}$$
olacağından −x<sup>1</sup> + x<sup>2</sup> − 1 = 0 doğrusu istenen <sup>2</sup> doğrusudur.
**Teorem 2.4.** <sup>2</sup> de = (a1, a<sup>2</sup> ) ve = (b1, b<sup>2</sup> ) noktasından geçen doğru aynı zamanda <sup>2</sup> doğrusudur.
İspat. ve noktası için <sup>2</sup> doğrusunu elde edecek olursak,
$$
\left[\frac{\mathbf{(}\mathbf{a\_1} - \mathbf{b\_1})}{\mathbf{m}}\right]^T \begin{bmatrix} \mathbf{x\_1} \\ \mathbf{x\_2} \end{bmatrix} - \frac{1}{\mathbf{m}} \mathbf{a\_1(a\_1 - b\_1) - a\_2 = 0}
$$
$$
\mathbf{m} = \frac{1}{\mathbf{b\_2} - \mathbf{a\_2}} (\mathbf{a\_1} - \mathbf{b\_1})^2
$$
bulunur. Gerekli işlemler yapılırsa <sup>2</sup> doğrusu
$$\mathbf{x}\_{2} = \frac{\mathbf{b}\_{2} - \mathbf{a}\_{2}}{\mathbf{b}\_{1} - \mathbf{a}\_{1}}\mathbf{x}\_{1} + \mathbf{a}\_{1} \left(\frac{\mathbf{b}\_{2} - \mathbf{a}\_{2}}{\mathbf{a}\_{1} - \mathbf{b}\_{1}}\right) + \mathbf{a}\_{2}$$
elde edilir. <sup>2</sup> doğrusunun ve noktasından geçtiği açıktır.
**Teorem 2.5.** <sup>2</sup> de = (a1, a<sup>2</sup> ) ve = (b1, b<sup>2</sup> ) noktası için elde edilen <sup>1</sup> ve <sup>2</sup> doğruları birbirinin aynısıdır.
İspat. ve noktası için <sup>1</sup> doğrusunu elde edecek olursak,
$$
\left[\frac{\mathbf{1}}{\mathbf{(a\_2 - b\_2)}}\right]^T \begin{bmatrix} \mathbf{x\_1} \\ \mathbf{x\_2} \end{bmatrix} - \frac{1}{\mathbf{m}} \mathbf{a\_2(a\_2 - b\_2) - a\_1 = 0}
$$
$$
\mathbf{m} = \frac{1}{\mathbf{b\_1 - a\_1}(\mathbf{a\_2 - b\_2})^2}
$$
bulunur. Gerekli işlemler yapılırsa 1ve <sup>2</sup> doğrusuna ait denklemler sırasıyla,
$$\begin{aligned} \mathbf{x}\_2 &= \frac{\mathbf{b}\_2 - \mathbf{a}\_2}{\mathbf{b}\_1 - \mathbf{a}\_1} \mathbf{x}\_1 + \mathbf{a}\_1 \left( \frac{\mathbf{a}\_2 - \mathbf{b}\_2}{\mathbf{b}\_1 - \mathbf{a}\_1} \right) + \mathbf{a}\_2 \\\\ \mathbf{x}\_2 &= \frac{\mathbf{b}\_2 - \mathbf{a}\_2}{\mathbf{b}\_1 - \mathbf{a}\_1} \mathbf{x}\_1 + \mathbf{a}\_1 \left( \frac{\mathbf{b}\_2 - \mathbf{a}\_2}{\mathbf{a}\_1 - \mathbf{b}\_1} \right) + \mathbf{a}\_2 \end{aligned} \tag{2.4}$$
olduğundan bu iki doğru birbirinin aynısıdır.
**Teorem 2.6.** <sup>3</sup> de = (a1, a2, a<sup>3</sup> ) ve = (b1, b2, b<sup>3</sup> ) noktası için elde edilen 1, <sup>2</sup> ve <sup>3</sup> doğruları sonsuz noktada kesişirler.
İspat. ve noktası için 1, <sup>2</sup> ve <sup>3</sup> düzlemleri sırasıyla,
$$M\_1 \colon \quad \begin{bmatrix} \mathbf{1} \\ \hline \mathbf{m\_1} \\ \mathbf{(a\_3 - b\_3)} \\ \hline \mathbf{m\_1} \end{bmatrix}^T \begin{bmatrix} \mathbf{x\_1} \\ \mathbf{x\_2} \\ \mathbf{x\_3} \end{bmatrix} = \mathbf{z\_1}$$
$$M\_2 \colon \begin{bmatrix} \frac{\{\mathbf{(a\_1} - \mathbf{b\_1}\}}{\mathbf{m\_2}} \\ 1 \\ \frac{\{\mathbf{(a\_3} - \mathbf{b\_3})\}}{\mathbf{m\_2}} \end{bmatrix}^T \begin{bmatrix} \mathbf{x\_1} \\ \mathbf{x\_2} \\ \mathbf{x\_3} \end{bmatrix} = \mathbf{z\_2} \tag{2.5}$$
$$M\_3 \colon \begin{bmatrix} \frac{(\mathbf{a}\_1 - \mathbf{b}\_1)}{\mathbf{m}\_3} \\ \frac{(\mathbf{a}\_2 - \mathbf{b}\_2)}{\mathbf{m}\_3} \\ 1 \end{bmatrix}^T \begin{bmatrix} \mathbf{x}\_1 \\ \mathbf{x}\_2 \\ \mathbf{x}\_3 \end{bmatrix} = \mathbf{z}\_3$$
Burada yer alan z1, m1, z2, m2, z3, m<sup>3</sup> değerleri aşağıdaki gibidir:
$$\begin{aligned} \mathbf{m}\_1 &= \frac{1}{\mathbf{b}\_1 - \mathbf{a}\_1} \left[ (\mathbf{a}\_2 - \mathbf{b}\_2)^2 + (\mathbf{a}\_3 - \mathbf{b}\_3)^2 \right] \\\\ \mathbf{m}\_2 &= \frac{1}{\mathbf{b}\_2 - \mathbf{a}\_2} \left[ (\mathbf{a}\_1 - \mathbf{b}\_1)^2 + (\mathbf{a}\_3 - \mathbf{b}\_3)^2 \right] \\\\ \mathbf{m}\_3 &= \frac{1}{\mathbf{b}\_3 - \mathbf{a}\_3} \left[ (\mathbf{a}\_1 - \mathbf{b}\_1)^2 + (\mathbf{a}\_2 - \mathbf{b}\_2)^2 \right] \\\\ \mathbf{z}\_1 &= \frac{1}{\mathbf{m}\_1} \left[ \mathbf{a}\_2 (\mathbf{a}\_2 - \mathbf{b}\_2) + \mathbf{a}\_3 (\mathbf{a}\_3 - \mathbf{b}\_3) \right] + \mathbf{a}\_1 \\\\ \mathbf{z}\_2 &= \frac{1}{\mathbf{m}\_2} \left[ \mathbf{a}\_1 (\mathbf{a}\_1 - \mathbf{b}\_1) + \mathbf{a}\_3 (\mathbf{a}\_3 - \mathbf{b}\_3) \right] + \mathbf{a}\_2 \\\\ \mathbf{z}\_3 &= \frac{1}{\mathbf{m}\_3} \left[ \mathbf{a}\_1 (\mathbf{a}\_1 - \mathbf{b}\_1) + \mathbf{a}\_2 (\mathbf{a}\_2 - \mathbf{b}\_2) \right] + \mathbf{a}\_3 \end{aligned}$$
1, <sup>2</sup> ve <sup>3</sup> düzlem denklemlerini katsayılarından oluşan genişletilmiş matris olarak yazacak olursak,
$$\begin{aligned} \begin{bmatrix} F & \mid & g \end{bmatrix} \\ = \begin{bmatrix} 1 & \langle \mathbf{a}\_2 - \mathbf{b}\_2 \rangle / \mathbf{m}\_1 & \langle \mathbf{a}\_3 - \mathbf{b}\_3 \rangle / \mathbf{m}\_1 \\ \langle \mathbf{a}\_1 - \mathbf{b}\_1 \rangle & \mathbf{m}\_2 & \langle \mathbf{a}\_3 - \mathbf{b}\_3 \rangle \\ \langle \mathbf{a}\_1 - \mathbf{b}\_1 \rangle & \langle \mathbf{a}\_2 - \mathbf{b}\_2 \rangle & \mathbf{m}\_3 \end{bmatrix} \begin{bmatrix} \mathbf{z}\_1 \\ \mathbf{m}\_2 \mathbf{z}\_2 \\ \mathbf{m}\_3 \mathbf{z}\_3 \end{bmatrix} \end{aligned} \tag{2.6}$$
olur. Eğer () = ([ | ] < 3 olursa yukarıda verilen lineer sistemin sonsuz çözümünün olduğu söylenir. İşlem kolaylığı açısından a<sup>1</sup> − b<sup>1</sup> = x, a<sup>2</sup> − b<sup>2</sup> = y, a<sup>3</sup> − b<sup>3</sup> = z denilsin. Öncelikle (2.6) da verilen matrise elementer satır işlemleri yaparak eşolon forma getirilmelidir. <sup>2</sup> → <sup>2</sup> + (b<sup>1</sup> − a<sup>1</sup> )<sup>1</sup> ve <sup>3</sup> → <sup>3</sup> + (b<sup>1</sup> − a<sup>1</sup> )<sup>1</sup> elementer satır işlemleri yapılırsa,
$$\begin{bmatrix} 1 & \mathbf{y}/\mathbf{m}\_1 & \mathbf{z}/\mathbf{m}\_1\\ 0 & \mathbf{m}\_2 - \mathbf{x}\mathbf{y}/\mathbf{m}\_1 & \mathbf{z}(1 - \mathbf{x}/\mathbf{m}\_1)\\ 0 & \mathbf{y}(1 - \mathbf{x}/\mathbf{m}\_1) & \mathbf{m}\_3 - \mathbf{x}\mathbf{z}/\mathbf{m}\_1 \end{bmatrix} \begin{bmatrix} \mathbf{z}\_1\\ \mathbf{m}\_2\mathbf{z}\_2 - \mathbf{x}\mathbf{z}\_1\\ \mathbf{m}\_3\mathbf{z}\_3 - \mathbf{x}\mathbf{z}\_1 \end{bmatrix} \tag{2.7}$$
matrisi elde edilir. (2.7) de verilen matriste işlem kolaylığı açısından bazı değerler sembolize edilirse aşağıdaki matris elde edilir;
$$
\begin{bmatrix}
\mathbf{1} & \mathbf{y}/\mathbf{m}\_1 & \mathbf{z}/\mathbf{m}\_1 \\
\mathbf{0} & \mathbf{A} & \mathbf{B} \\
\mathbf{0} & \mathbf{C} & \mathbf{D}
\end{bmatrix}
\begin{bmatrix}
\mathbf{z}\_1 \\
\mathbf{K}\_1 \\
\mathbf{K}\_2
\end{bmatrix}
\tag{2.8}
$$
Burada,
$$\begin{aligned} \mathbf{A} &= \mathbf{m}\_2 - \mathbf{x} \mathbf{y} / \mathbf{m}\_1 = -\frac{\mathbf{z}^2 (\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2)}{\mathbf{y} (\mathbf{y}^2 + \mathbf{z}^2)} \\\\ \mathbf{B} &= \mathbf{z} (\mathbf{1} - \mathbf{x} / \mathbf{m}\_1) = \mathbf{z} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \\\\ \mathbf{C} &= \mathbf{y} (\mathbf{1} - \mathbf{x} / \mathbf{m}\_1) = \mathbf{y} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \end{aligned}$$
$$\begin{aligned} \mathbf{D} &= \mathbf{m}\_3 - \mathbf{x} \mathbf{z} / \mathbf{m}\_1 = -\frac{\mathbf{y}^2 (\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2)}{\mathbf{z} (\mathbf{y}^2 + \mathbf{z}^2)} \\\\ \mathbf{K}\_1 &= \mathbf{m}\_2 \mathbf{z}\_2 - \mathbf{x} \mathbf{z}\_1 \\\\ \mathbf{K}\_2 &= \mathbf{m}\_3 \mathbf{z}\_3 - \mathbf{x} \mathbf{z}\_1 \end{aligned}$$
şeklindedir. Burada x, y, z ≠ 0 olduğundan A, B, C,D ≠ 0 olduğu açıktır. (2.8) de yer alan matris için <sup>2</sup> → 2/A işlemi yapılırsa
$$
\begin{bmatrix}
\mathbf{1} & \mathbf{y}/\mathbf{m}\_1 & \mathbf{z}/\mathbf{m}\_1 \\
\mathbf{0} & \mathbf{1} & \mathbf{B}/\mathbf{A} \\
\mathbf{0} & \mathbf{C} & \mathbf{D}
\end{bmatrix}
\begin{array}{c}
\mathbf{z}\_1 \\
\mathbf{K}\_1/\mathbf{A} \\
\mathbf{K}\_2
\end{array}
$$
matrisi elde edilir. <sup>3</sup> → <sup>3</sup> − C<sup>2</sup> elementer satır işlemi yapılırsa (2.6) da verilen matrisin eşolon formu aşağıdaki gibi elde edilir:
$$
\begin{bmatrix}
\mathbf{1} & \mathbf{y}/\mathbf{m}\_1 & \mathbf{z}/\mathbf{m}\_1 \\
\mathbf{0} & \mathbf{1} & \mathbf{B}/\mathbf{A} \\
\mathbf{0} & \mathbf{0} & \mathbf{D} - \mathbf{C}\mathbf{B}/\mathbf{A} \\
\end{bmatrix}
\quad \begin{array}{c}
\mathbf{z}\_1 \\
\mathbf{K}\_1/\mathbf{A} \\
\mathbf{K}\_2 - \mathbf{C}\mathbf{K}\_1/\mathbf{A} \\
\end{array}
\tag{2.9}
$$
(2.9) de elde edilen D − CB/A değeri sıfıra eşit olursa () = 2 olur. Aynı zamanda K<sup>2</sup> − CK1/A değeri sıfıra eşit olursa ([ | ] = 2 olur. Öncelikle D − CB A değerinin sıfıra eşit olması için AD = CB olmalıdır. Gerekli işlemler yapıldığı takdirde
$$\text{AD} = -\frac{\mathbf{z}^2(\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2)}{\mathbf{y}(\mathbf{y}^2 + \mathbf{z}^2)} \left( -\frac{\mathbf{y}^2(\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2)}{\mathbf{z}(\mathbf{y}^2 + \mathbf{z}^2)} \right) = \text{yz} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right)^2$$
$$\text{CB} = \text{y} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \text{z} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) = \text{yz} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right)^2$$
elde edilir. Dolayısıyla AD = CB elde edilir. Böylece () = 2 denir.
Son olarak K<sup>2</sup> − CK1/A değerinin sıfıra eşit olması için AK<sup>2</sup> = CK<sup>1</sup> olmalıdır. Yani,
$$\mathbf{A(m\_3z\_3 - xz\_1) = C(m\_2z\_2 - xz\_1)}$$
olmalıdır. Buradan
$$\mathbf{A}\mathbf{m}\_3\mathbf{z}\_3 - \mathbf{C}\mathbf{m}\_2\mathbf{z}\_2 = -\mathbf{x}\mathbf{z}\_1(\mathbf{C} - \mathbf{A})\tag{2.10}$$
eşitliği elde edilir. Yapılacak olan (2.10) eşitliğinin doğru olup olmadığını göstermektir. Öncelikle C − A değerinin ne ifade ettiği gösterilecek olursa,
$$\mathbf{C} - \mathbf{A} = \mathbf{y} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) + \frac{\mathbf{z}^2(\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2)}{\mathbf{y}(\mathbf{y}^2 + \mathbf{z}^2)} = \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}}$$
elde edilir. Bunun yanında
$$-\mathbf{x}\mathbf{z}\_1 = \frac{\mathbf{x}^2}{\mathbf{y}^2 + \mathbf{z}^2} (\mathbf{a}\_2\mathbf{y} + \mathbf{a}\_3\mathbf{z}) - \mathbf{x}\mathbf{a}\_1$$
şeklindedir. Dolayısıyla,
$$\begin{aligned} -\mathbf{x} \mathbf{z}\_1 (\mathbf{C} - \mathbf{A}) &= \mathbf{a}\_1 \left[ -\mathbf{x} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}} \right) \right] \\ &+ \mathbf{a}\_2 \left[ \mathbf{x}^2 \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \right] \\ &+ \mathbf{a}\_3 \left[ \frac{\mathbf{z} \mathbf{x}^2}{\mathbf{y}} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \right] \end{aligned} \tag{2.11}$$
elde edilir. Devam edilecek olunursa,
$$\mathbf{A}\mathbf{m}\_3\mathbf{z}\_3 = \mathbf{A}(\mathbf{a}\_1\mathbf{x} + \mathbf{a}\_2\mathbf{y} + \mathbf{a}\_3\mathbf{m}\_3)$$
ve
$$\mathbf{C} \mathbf{m}\_2 \mathbf{z}\_2 = \mathbf{C} (\mathbf{a}\_1 \mathbf{x} + \mathbf{a}\_3 \mathbf{z} + \mathbf{a}\_2 \mathbf{m}\_2)$$
olduğundan
$$\begin{aligned} \mathbf{A} \mathbf{m}\_3 \mathbf{z}\_3 - \mathbf{C} \mathbf{m}\_2 \mathbf{z}\_2 \\ &= \mathbf{a}\_1 [\mathbf{x}(\mathbf{A} - \mathbf{C})] + \mathbf{a}\_2 [\mathbf{A} \mathbf{y} - \mathbf{C} \mathbf{z}] \\ &+ \mathbf{a}\_3 [\mathbf{A} \mathbf{m}\_3 - \mathbf{C} \mathbf{m}\_2] \end{aligned} \tag{2.12}$$
olur. Gerekli işlemler yapıldığı takdirde
$$\begin{aligned} \mathbf{x}(\mathbf{A} - \mathbf{C}) &= -\mathbf{x} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}} \right) \\\\ \mathbf{A}\mathbf{y} - \mathbf{C}\mathbf{z} &= \mathbf{x}^2 \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \\\\ \mathbf{A}\mathbf{m}\_3 - \mathbf{C}\mathbf{m}\_2 &= \frac{\mathbf{z}\mathbf{x}^2}{\mathbf{y}} \left( \frac{\mathbf{x}^2 + \mathbf{y}^2 + \mathbf{z}^2}{\mathbf{y}^2 + \mathbf{z}^2} \right) \end{aligned}$$
bulunur. (2.11) ve (2.12) yardımıyla
$$\mathbf{A}(\mathbf{m}\_3 \mathbf{z}\_3 - \mathbf{x} \mathbf{z}\_1) = \mathbf{C}(\mathbf{m}\_2 \mathbf{z}\_2 - \mathbf{x} \mathbf{z}\_1)$$
elde edilir. O halde [ | ] genişletilmiş matrisinin rankı 2 bulunmuş olur.
Dolayısıyla () = ([ | ] = 2 < 3 elde edilir. O halde (2.5) de verilen lineer denklem sisteminin bir parametreye bağlı sonsuz çözüme sahip olduğu söylenir.
**Örnek 2.7.** <sup>3</sup> de = (1,2,3) and = (3,4,0) nokta çifti için (2.5) yardımıyla, sırasıyla 1, <sup>2</sup> ve <sup>3</sup> düzlemleri
$$\begin{array}{l} \mathbf{13x} - \mathbf{4y} + \mathbf{6z} = \mathbf{23} \\ -\mathbf{4x} + \mathbf{13y} + \mathbf{6z} = \mathbf{40} \\ \mathbf{3x} + \mathbf{3y} + \mathbf{4z} = \mathbf{21} \end{array}$$
şeklinde elde edilir. Bu düzlemlerin <sup>3</sup> deki geometrik gösterimi [Şekil 2.1](#page-44-1) de yer almaktadır.
**Şekil 2.1***.* Örnek 2.7 için 1, <sup>2</sup> ve <sup>3</sup> düzlemleri
<span id="page-44-1"></span>
<span id="page-44-0"></span>**2.2 de Düzleminin Geometrik Analizi**
Bu bölümde üretilen spesifik hiper düzlemin 3 te ne anlam ifade ettiği gösterilecektir.
<sup>3</sup> de a<sup>3</sup> ≠ b<sup>3</sup> olmak üzere birbirinden ve sıfır noktasından farklı olan = (a1, a2, a<sup>3</sup> ) ve = (b1, b2, b<sup>3</sup> ) verilsin. Bu iki nokta arasındaki fark vektörüne vektörü diyelim. Yani,
$$d = (\mathbf{b}\_1 - \mathbf{a}\_1)\boldsymbol{\ell} + (\mathbf{b}\_2 - \mathbf{a}\_2)\boldsymbol{\ell} + (\mathbf{b}\_3 - \mathbf{a}\_3)\boldsymbol{\hat{k}}$$
olacaktır. vektörünün düzlemiyle yaptığı açıya ise denilsin [\(Şekil 2.2](#page-45-0) de verilen OMN üçgeninde MON ̂ açısı). Buradan Pisagor teoremi yardımıyla açısının tanjantı
$$\tan\alpha = \frac{|MN|}{|OM|} = \frac{\mathbf{b}\_3 - \mathbf{a}\_3}{\sqrt{(\mathbf{b}\_1 - \mathbf{a}\_1)^2 + (\mathbf{b}\_2 - \mathbf{a}\_2)^2}}$$
şeklinde bulunur.
**Şekil 2.2.** Vektör ve Vektör nin <sup>3</sup> de gösterimi
<span id="page-45-0"></span>
vektörünün düzlemine göre izdüşümü ise = (b<sup>1</sup> − a<sup>1</sup> )̂+ (b<sup>2</sup> − a<sup>2</sup> )̂ şeklindedir. Bu aşamadan sonra yapılacak olan oluşturulacak ve noktalarından geçen düzlem için bir normal elde etmektir. Ancak bu noktalardan sonsuz sayıda düzlem geçer. Dolayısıyla bu sonsuz düzlem için sonsuz tane normal opsiyonu vardır. Ancak istenen özel bir normaldir. Bu özel normal yardımıyla <sup>3</sup> düzlemini elde edeceğiz. Bu özel normal vektörü [Şekil 2.2](#page-45-0) de vektörü olarak gösterilmiştir.
Bu özel normal vektörünün özelliği şu şekilde belirlenmiştir: vektörü vektörü ile diktir ve vektörünün birinci ve ikinci bileşeni olarak − vektörünün birinci ve ikinci bileşenleri belirlenmiştir. Üçüncü bileşeni ise r olsun. Dolayısıyla vektörü
$$e = (\mathbf{a}\_1 - \mathbf{b}\_1)\mathbf{\hat{t}} + (\mathbf{a}\_2 - \mathbf{b}\_2)\mathbf{\hat{y}} + \mathbf{r}\mathbf{\hat{k}}$$
şeklinde tanımlansın. vektörünün düzlemiyle yaptığı açı 2 − dır[\(Şekil 2.2](#page-45-0) de verilen OAC üçgenindêAOC açısı). Buradan Pisagor teoremi yardımıyla 2 − açısının tanjantı,
$$\tan\left(\frac{\pi}{2} - \alpha\right) = \frac{|AC|}{|OA|} = \frac{\mathbf{r}}{\sqrt{(\mathbf{a}\_1 - \mathbf{b}\_1)^2 + (\mathbf{a}\_2 - \mathbf{b}\_2)^2}}$$
şeklindedir. Ayrıca
$$\tan\left(\frac{\pi}{2} - \alpha\right) = \cot\alpha = \frac{\sqrt{(\mathbf{b}\_1 - \mathbf{a}\_1)^2 + (\mathbf{b}\_2 - \mathbf{a}\_2)^2}}{\mathbf{b}\_3 - \mathbf{a}\_3}$$
olduğundan, buradan r değeri
$$r = \frac{(\mathbf{b}\_1 - \mathbf{a}\_1)^2 + (\mathbf{b}\_2 - \mathbf{a}\_2)^2}{\mathbf{b}\_3 - \mathbf{a}\_3}$$
bulunur.
Dolayısıyla özelleştirdiğimiz vektörü
$$e = (\mathbf{a}\_1 - \mathbf{b}\_1)\hat{\imath} + (\mathbf{a}\_2 - \mathbf{b}\_2)\hat{\jmath} + \left(\frac{(\mathbf{b}\_1 - \mathbf{a}\_1)^2 + (\mathbf{b}\_2 - \mathbf{a}\_2)^2}{\mathbf{b}\_3 - \mathbf{a}\_3}\right)\hat{k}$$
şeklinde elde edilmiş olur.
Şimdi normali vektörü olan, noktasından geçen düzlemi elde edelim. Bu düzlem vektörü ve noktası için
$$
\begin{bmatrix}
\mathbf{(a\_1 - b\_1)} \\
\mathbf{(a\_2 - b\_2)} \\
\mathbf{(b\_1 - a\_1)^2 + (b\_2 - a\_2)^2} \\
\hline
\mathbf{b\_3 - a\_3}
\end{bmatrix}^T \begin{bmatrix}
\mathbf{x - a\_1} \\
\mathbf{y - a\_2} \\
\mathbf{z - a\_3}
\end{bmatrix} = \mathbf{0}
$$
eşitliğini sağlar. Dikkat edilirse bu eşitlik noktası için de sağlanır. Dolayısıyla elde edilen <sup>3</sup> düzlemi ve noktalarından geçer ve vektörü gibi bir normale sahiptir.
Buradan gerekli düzenlemeler yapıldığında <sup>3</sup> de ve noktaları için <sup>3</sup> düzleminin denklemi;
$$z = \left(\frac{\mathbf{b\_1} - \mathbf{a\_1}}{\mathbf{m}}\right)x + \left(\frac{\mathbf{b\_2} - \mathbf{a\_2}}{\mathbf{m}}\right)y + \frac{\mathbf{a\_1}(\mathbf{a\_1} - \mathbf{b\_1}) + \mathbf{a\_2}(\mathbf{a\_2} - \mathbf{b\_2})}{\mathbf{m}} \quad (2.13)$$
$$+ \mathbf{a\_3}$$
şeklinde bulunur. Burada
$$\mathbf{m} = \frac{(\mathbf{b}\_1 - \mathbf{a}\_1)^2 + (\mathbf{b}\_2 - \mathbf{a}\_2)^2}{\mathbf{b}\_3 - \mathbf{a}\_3}$$
dir. (2.5) de <sup>3</sup> düzlemi için verilen denklemin (2.13) ile aynı denklem olduğu açıktır. <sup>1</sup> ve <sup>2</sup> düzlemleri de benzer şekilde üretilebilir.
# **3 ÜÇÜNCÜ BÖLÜM HİPER DÜZLEMİ YARDIMIYLA OPTİMİZASYON: EVRİŞTİRİLMİŞ GRADYAN YÖNÜ İLE OPTİMİZASYON ALGORİTMASI (EVGO)**
### <span id="page-48-0"></span>**3.1. Giriş**
Çalışmanın bu bölümünde, girdi elemanlarının uzayı olan bir fonksiyonun (örüntü tanıma ve makine öğrenme için bu fonksiyon hata fonksiyonudur), Bölüm 2 de açıklanan hiper düzlemi yardımıyla optimizasyonuna yönelik bir algoritma sunulmuştur. Bahsedilen kısıtsız optimizasyon problemi aşağıdaki gibi tanımlansın:
$$\text{minimize } f(x) \tag{3.1}$$
Burada = (x1, x2, … , x<sup>n</sup> ) vektörü ve : → diferansiyellenebilir bir fonksiyon olsun.
Genel anlamda önerilen algoritma keyfi olarak seçilen sayıda başlangıç çözümünü evriştirirken öncelikle seçilen sayıda başlangıç çözümünün arasında "en iyisini" belirler. En iyi çözüm değerinin nasıl elde edileceği bölümün devamında yer almaktadır. Ancak eğer hata fonksiyonunun minimizasyonu ile ilgileniliyorsa bu en iyi başlangıç çözümü, hata fonksiyonu altındaki değeri en küçük olan çözümdür. Döngünün birinci adımını temsil edecek şekilde birinci adım için bu çözüm değerine <sup>1</sup> denilsin. <sup>1</sup> değeri Bölüm 1 de detayları verilen gradyan iniş yöntemi ile güncellenir. Yani <sup>1</sup> çözümünün güncellenmiş yeni değeri
$$(best\_1 - a\nabla f(best\_1))\tag{3.2}$$
şeklindedir. Geriye kalan − 1 sayıda başlangıç çözümü güncelleştirilirken ise hiper düzleminden faydalanılır. − 1 sayıda başlangıç çözümünden temsili olarak <sup>1</sup> ℎ elemanını göz önüne alalım. +1 de ilk elemanı <sup>1</sup> ile aynı ( + 1). elemanı ise (<sup>1</sup> ) olan vektöre \_<sup>1</sup> adı verilsin. Aynı şekilde, +1 de ilk elemanı <sup>1</sup> ℎ ile aynı ( + 1). elemanı ise (<sup>1</sup> ℎ ) olan vektöre \_<sup>1</sup> ℎ adı verilsin. +1 de \_<sup>1</sup> ile \_<sup>1</sup> ℎ için +1 hiper düzlemi elde edilsin. +1 hiper düzleminin ( + 1). elemanı için gradyan vektörü (2.3) yardımıyla elde edilir. Böylece <sup>1</sup> ℎ elemanını <sup>1</sup> elemanına yaklaştıracak vektör elde edilmiş olur. Bu vektöre bu aşamada adı verilsin. <sup>1</sup> ℎ elemanının güncellenmiş yeni terimi;
$$nombest\_1^h - \alpha \ast R \ast \nabla f\{nombest\_1^h\} - \beta \ast L \tag{3.3}$$
Burada vektörü vektörünün yönünü temsil eden yön vektörü, ve öğrenme oranlarını temsil eder. İlk terim ∗ ∗ (<sup>1</sup> ℎ ), gradyan vektörü için yeni bir momentum sağlarken, ikinci terim ∗ ise daha önceden de bahsedildiği gibi doğrudan doğruya yeni değeri <sup>1</sup> vektörüne yaklaştırmayı hedefler.
Algoritma, fonksiyonunu her bir adımda bir yandan gradyan iniş yöntemini kullanarak analitik olarak optimize eder iken, diğer yandan +1 hiper düzlemini kullanarak çözüm uzayı üzerinde gezinir. Uygun ve öğrenme oranları ile genellikle her bir adımda en iyi değer () değişir. Böylelikle gradyan iniş yönteminde karşımıza çıkan yerel minimum problemi gezinen çözüm değerleri ile tatmin edici bir şekilde aşılmış olur.
Üretilen algoritmadan genel olarak bahsedilmiştir. Algoritmanın detayları ise bir sonraki alt bölümde yer almaktadır.
### <span id="page-49-0"></span>**3.2. Algoritma**
(3.1) de verilen kısıtsız matematiksel optimizasyon problemi göz önüne alınsın. Klasik gradyan iniş yönteminde gradyan yönü optimizasyon problemini çözmek için iyi bir adaydır. Yapılan çalışmada, bu gradyan yönünü daha sonra bahsedilecek başka bir vektör ile etkileşime sokarak yeni bir yön elde edilecektir. Bu yeni yön parametre değerlerinin güncellemesinde kullanılacaktır.
Önerilen algoritma, keyfi olarak seçilen başlangıç bireysel çözüm popülasyonunu sürekli olarak modifiye ederek fonksiyonunu global minimuma yaklaştırır. Bu modifiye işlemi adım adım aşağıdaki gibi gerçekleşir.
**Aşama 1 (Başlangıç)**. Keyfi olarak bir bireysel çözüm popülasyonu seçilir. Başlangıç aşamasında seçilecek bireysel çözüm popülasyonu <sup>1</sup> olsun. , döngüdeki her bir iterasyon için bireysel çözüm popülasyonlarını içeren aile olmak üzere,
> = { : = 1,2, … , : }
şeklinde gösterilsin.
Burada her bir bireysel çözüm popülasyonu, sayıda parametre değerini içeren kümedir. , . iterasyonda elde edilen bireysel çözüm popülasyonunu göstermek üzere;
$$S\_p = \{x\_p^j; j = 1, 2, \dots, k \text{ ve } k \text{: toplam parametre sayus}\}$$
şeklindedir. Döngüdeki her bir iterasyonda başlangıç bireysel çözüm popülasyonu <sup>1</sup> önerilen yaklaşıma göre evrişecek ve önceden belirlenecek bir durdurma kriterine göre veya yine önceden belirlenecek toplam iterasyon sayısı sonunda optimum noktaya tatmin edici bir şekilde yakın bir nokta elde edilecektir.
**Aşama 2 (Yerel en iyi parametre değerini belirleme ve güncelleme).** Bu aşamada, verilen bir bireysel çözüm popülasyonu için yerel en iyi parametre değeri belirlenecek ve güncellemesi yapılacaktır. kümesi için uygunluk fonksiyonları \_, \_ ve fonksiyonları aşağıdaki gibi verilsin<sup>27</sup> .
\_, \_, : → ve = 1,2, … , olmak üzere
$$Linear\\_Uygunku k\_p(\boldsymbol{\chi}\_p^j) = \frac{1}{\sum\_{l=1}^k \frac{1}{1 + f(\boldsymbol{\chi}\_p^l)}}\tag{3.4}$$
<sup>27</sup> J.A. Lima, N. Gracias, H. Pereira, A.C. Rosa, "Fitness Function Design for Genetic Algorithms in Cost Evaluation Based Problems", **Proceedings of IEEE International Conference on Evolutionary Computation**, Nagoya, 1996, pp. 207-212.
$$Statis\\_Uygunkuk\_p\{\chi\_p^j\} = \frac{e^{-\sigma \chi\_p^j}}{\sum\_{i=1}^k e^{-\sigma \chi\_p^i}}\tag{3.5}$$
$$Hata\_p(\mathbf{x}\_p^j) = f(\mathbf{x}\_p^j) \tag{3.6}$$
şeklinde verilsin. Burada verilen bu üç fonksiyonu tanımsız yapmayan ( ) değerlerinin var olduğu varsayılmıştır. Ayrıca > 0 değerinden seçme parametresi olarak bahsedilecektir.
kümesi için yerel en iyi parametre değeri , \_ ve \_ fonksiyonlarında maksimum değeri veren, fonksiyonunda ise minimum değeri veren kümesi elemanını temsil etsin.
Elde edilen yerel en iyi parametre değeri için güncelleme için bizzat gradyan iniş yöntemini kullanarak yapılacak olan güncelleme
$$(best\_p - a\nabla f(best\_p))\tag{3.7}$$
şeklinde olacaktır. Şüphesiz bu yeni değer artık +1 kümesinin elemanıdır. Burada > 0 hiper parametresi öğrenme oranıdır.
Not olarak belirtmek gerekir ki, girdi elemanlarının uzayı için büyüdükçe bireysel çözüm popülasyonları için yerel en iyi parametre değerinin birden çok olması zorlaşacaktır. Nitekim yerel en iyi parametre değeri birden çok dahi olsa her biri için (3.7) güncellemesi yapılacaktır. Bir sonraki aşamada sunulan algoritmanın tanıtımına gösterim karmaşasının önüne geçmek adına en iyi parametre değerinin bir tane olduğu kabul edilerek devam edilmiştir.
**Aşama 3 (Yerel en iyi olmayan parametre değerlerini güncelleme).** Bu aşamada kümesinde dışında kalan parametre değerlerine yönelik güncelleme elde edilecektir. Bu parametre değerlerini = 1,2, … , − 1 olmak üzere ile gösterelim. Yerel en iyi olmayan parametre değeri için güncelleme
$$\begin{aligned} & \textit{notbest}\_{p}^{j} \\ & -a \textit{Reflect} \Big[ \textit{L}\_{f} \{ \textit{best}\_{p}, \textit{notbest}\_{p}^{j} \}, \nabla f \{ \textit{notbest}\_{p}^{j} \} \Big] \\ & -\beta \textit{L}\_{f} \{ \textit{best}\_{p}, \textit{notbest}\_{p}^{j} \} \end{aligned} \tag{3.8}$$
şeklindedir. Burada minimizasyon problemi ile çalışıldığından , > 0 (maksimizasyon durumunda ise , < 0) şeklindedir.
(3.8) de yer alan ve katsayıları öğrenme oranlarıdır. Bu katsayılar algoritmamız için birer hiper parametredir.
Bu güncellemede yer alan bazı yardımcı fonksiyonlar aşağıda yer almaktadır. Burada : × → , : → {1, −1}, : → , : × → olmak üzere;
$$Reflect(\mathbf{x}, \mathbf{y}) = \xi(\mathbf{x}) \* \xi(\mathbf{y}) \* \mathbf{y}$$
$$\xi(\mathbf{x}) = [sgn(\mathbf{x}\_1), sgn(\mathbf{x}\_2), \dots, sgn(\mathbf{x}\_n)]$$
$$sgn(\mathbf{x}) = \begin{cases} -1, & \mathbf{x} < \mathbf{0} \\ 1, & \mathbf{x} \ge \mathbf{0} \end{cases}$$
$$L\_f(\mathbf{x}, \mathbf{y}) = \begin{bmatrix} \frac{\mathbf{y}\_1 - \mathbf{x}\_1}{\mathbf{m}}, \frac{\mathbf{y}\_2 - \mathbf{x}\_2}{\mathbf{m}}, \dots, \frac{\mathbf{y}\_n - \mathbf{x}\_n}{\mathbf{m}} \end{bmatrix}^T$$
şeklinde tanımlanmıştır. Burada
$$\text{Im} = \frac{1}{f(\mathbf{y}) - f(\mathbf{x})} \sum\_{\mathbf{i}=\mathbf{l}}^{\mathbf{n}} (\mathbf{y}\_{\mathbf{i}} - \mathbf{x}\_{\mathbf{i}})^2$$
dir. Burada ∗ operatörü Hadamard çarpımını temsil etmektedir.
Verilen fonksiyonu +1 de <sup>∗</sup> = (x1, x2, … , xn, ()) ve <sup>∗</sup> = (y1, y2, … , yn, ()) noktaları için elde edilen +1 hiper düzlem denkleminin ( + 1). bileşenine ait gradyan vektörünü temsil etmektedir (Bkz. (2.3) eşitliği).
Son olarak, algoritma durdurma kriteri uygulandığında son bireysel çözüm popülasyonu için aşama 2 uygulanır ve bu popülasyon için yerel en iyi parametre değeri çözüm parametre değeri olarak elde edilir. Algoritmaya ait sözde kod [Tablo 3.1](#page-53-0) de yer almaktadır.
Not olarak söylemek gerekir ki aksi söylenmedikçe aşama 3 ve aşama 4 de yer alan parametrelerinin aynı değeri aldığı düşünülmelidir.
| Tablo 3.1 | | EVGO algoritmasına ait sözde kod | | |
|-----------|--|----------------------------------|--|--|
|-----------|--|----------------------------------|--|--|
<span id="page-53-0"></span>
| | Algoritma | | |
|--|-----------|--|--|
|--|-----------|--|--|
**Girdi:** *Keyfi* <sup>1</sup> = {<sup>1</sup> : = 1,2, … , : } *başlangıç çözüm popülasyonu ve , öğrenme oranları belirlenir.* **for** = 1,2, … , (: ) **do** = min{( )} **for** = 1,2, … , **do if** <sup>=</sup> **do** +1 <sup>=</sup> <sup>−</sup> ( ) **else do** +1 <sup>=</sup> <sup>−</sup> [ ( , ), ( )] − ( , ) **end for end for find** \_\_ =
**Teorem 3.1.** Tek değişkenli fonksiyonu için (3.1) de yer alan kısıtsız matematiksel optimizasyon problemi göz önüne alınsın. Bu problem için, <sup>1</sup> = {x<sup>1</sup> 1 , x<sup>1</sup> 2 } başlangıç bireysel çözüm popülasyonu, x<sup>1</sup> 1 , x<sup>1</sup> <sup>2</sup> ∈ , x<sup>1</sup> <sup>1</sup> < x<sup>1</sup> 2 ve , . iterasyonda yer alan parametre değerleri tarafından oluşturulmuş kapalı aralık olsun. <sup>1</sup> başlangıç aralığı global minimum değerini içeriyor ve her inci iterasyon için aşağıdaki şartların hepsi birden sağlanıyor ise önerilen EVGO algoritması ile yeterli adım sonra öyle bir bireysel çözüm popülasyonu elde edilir ki bu popülasyon global minimuma oldukça yakın bir değeri içerir.
$$\begin{array}{ll} \text{i.} & \begin{cases} \nabla f(\mathbf{x}\_{l}^{1}) < 0 \quad ,best\_{l} = \mathbf{x}\_{l}^{1} \text{ is} \\ \nabla f(\mathbf{x}\_{l}^{2}) > 0 \quad ,best\_{l} = \mathbf{x}\_{l}^{2} \text{ is} \end{cases} \end{array}$$
ii. Her bir bireysel çözüm popülasyonu için x <sup>1</sup> < x 2 olacak şekilde yeterli ve değerleri seçilmesi
İspat. <sup>1</sup> = {x<sup>1</sup> 1 , x<sup>1</sup> 2 } başlangıç bireysel çözüm popülasyonu, <sup>1</sup> = [x<sup>1</sup> 1 , x<sup>1</sup> 2 ] aralığını göz önüne alalım.
i. <sup>1</sup> = x<sup>1</sup> 1 olsun. O halde x<sup>1</sup> 1 değeri için (3.7) ile yapılacak güncelleme ile
$$\mathbf{x}\_2^1 = \mathbf{x}\_1^1 - \alpha \nabla f(\mathbf{x}\_1^1)$$
değeri elde edilir. (<sup>1</sup> 1 ) < 0 olduğundan x<sup>2</sup> <sup>1</sup> > x<sup>1</sup> 1 olur. x<sup>1</sup> 2 değeri için (3.8) ile yapılacak güncelleme ile
$$\mathbf{x}\_2^2 = \mathbf{x}\_1^2 - aReflect \left[ L\_f(\mathbf{x}\_1^1, \mathbf{x}\_1^2), \nabla f(\mathbf{x}\_1^2) \right] - \beta L\_f(\mathbf{x}\_1^1, \mathbf{x}\_1^2)$$
değeri elde edilir. Burada
$$L\_f(\mathbf{x}\_1^1, \mathbf{x}\_1^2) = \frac{f(\mathbf{x}\_1^2) - f(\mathbf{x}\_1^1)}{\mathbf{x}\_1^2 - \mathbf{x}\_1^1}$$
dir. x<sup>1</sup> <sup>1</sup> < x<sup>1</sup> 2 ve (x<sup>1</sup> 1 ) < (x<sup>1</sup> 2 ) olduğundan (x<sup>1</sup> 1 , x<sup>1</sup> 2 ) > 0 ve [ (x<sup>1</sup> 1 , x<sup>1</sup> 2 ), (x<sup>1</sup> 2 )] > 0 olur. Dolayısıyla x<sup>2</sup> <sup>2</sup> < x<sup>1</sup> 2 olur. Yeterli ve değerleri seçilmesi x<sup>2</sup> <sup>1</sup> < x<sup>2</sup> 2 olacağından <sup>2</sup> = [x<sup>2</sup> 1 , x<sup>2</sup> 2 ] aralığı <sup>1</sup> aralığının bir alt aralığı olur. Yani <sup>2</sup> ⊂ <sup>1</sup> dir.
ii. <sup>1</sup> = x<sup>1</sup> 2 olsun. O halde x<sup>1</sup> 2 değeri için (3.7) ile yapılacak güncelleme ile
$$\mathbf{x}\_2^2 = \mathbf{x}\_1^2 - \alpha \nabla f(\mathbf{x}\_1^2)$$
değeri elde edilir. (<sup>1</sup> 2 ) > 0 olduğundan x<sup>2</sup> <sup>2</sup> < x<sup>1</sup> 2 olur. x<sup>1</sup> 1 değeri için (3.8) ile yapılacak güncelleme ile
$$\mathbf{x}\_2^1 = \mathbf{x}\_1^1 - aReflect \left[ L\_f(\mathbf{x}\_1^2, \mathbf{x}\_1^1), \nabla f(\mathbf{x}\_1^1) \right] - \beta L\_f(\mathbf{x}\_1^2, \mathbf{x}\_1^1) $$
değeri elde edilir. Burada
$$L\_f(\mathbf{x}\_1^2, \mathbf{x}\_1^1) = \frac{f(\mathbf{x}\_1^1) - f(\mathbf{x}\_1^2)}{\mathbf{x}\_1^1 - \mathbf{x}\_1^2}$$
dir. x<sup>1</sup> <sup>1</sup> < x<sup>1</sup> 2 ve (x<sup>1</sup> 2 ) < (x<sup>1</sup> 1 ) olduğundan (x<sup>1</sup> 2 , x<sup>1</sup> 1 ) < 0 ve [ (x<sup>1</sup> 2 , x<sup>1</sup> 1 ), (x<sup>1</sup> 1 )] < 0 olur. Dolayısıyla x<sup>2</sup> <sup>1</sup> > x<sup>1</sup> 1 olur. Yeterli ve değerleri seçilmesi x<sup>2</sup> <sup>1</sup> < x<sup>2</sup> 2 olacağından <sup>2</sup> = [x<sup>2</sup> 1 , x<sup>2</sup> 2 ] aralığı <sup>1</sup> aralığının bir alt aralığı olur. Yani <sup>2</sup> ⊂ <sup>1</sup> dir.
Görüldüğü üzere, her iki durumda da <sup>2</sup> ⊂ <sup>1</sup> elde edilir. iterasyon sayısı yeterli iterasyon sayısı olarak düşünülürse aynı yolla sonraki iterasyonlardan
$$I\_\mathbf{p} \subset I\_{\mathbf{p}-1} \dots \subset I\_3 \subset I\_2 \subset I\_1$$
elde edilir. Ve böylelikle inci bireysel çözüm popülasyonu <sup>p</sup> = {x<sup>P</sup> 1 , x<sup>P</sup> 2 } kümesini elemanları fonksiyonunu minimize eden global minimum değerine yaklaşır.
#### <span id="page-55-0"></span>**3.3. EVGO Algoritmasının de Geometrik Analizi**
Aşağıda [Şekil 3.1](#page-55-1) de <sup>2</sup> de temsili değeri güncelleşirken EVGO algoritması ve gradyan iniş algoritması için nasıl bir yol izlendiğine dair açıklayıcı bir gösterim yer almaktadır.
<span id="page-55-1"></span>
[Şekil 3.1](#page-55-1) de grafiği verilen fonksiyon () = 6 − ( −5 2+4 + sin 2) 2 fonksiyonudur. Burada ∈ [−5, 5] şeklindedir. Şekilde yer alan ⃗⃗ , , , vektörlerinin eğimleri sırasıyla , , , olarak verilsin.
Bu fonksiyonun minimizasyonu ile uğraşırken başlangıç değeri ile işe başlanıldığı düşünülsün. [Şekil 3.1](#page-55-1) de gradyan iniş yöntemiyle değeri için en dik iniş vektörünün belirttiği yöndür. Burada vektörünün eğiminin = ′ () < 0 olduğu aşikardır. Gradyan iniş yöntemiyle bir iterasyon sonra değerinin 2 olarak güncellendiği düşünülsün.
Verilen fonksiyonun minimizasyonu için EVGO algoritmasının nasıl çalıştığını gösterecek olursak; başlangıç bireysel çözüm popülasyonu olarak {, } alınsın. EVGO algoritmasına göre değeri gradyan iniş yöntemiyle hareket edecektir. değerini güncellerken ise (3.8) kullanılacaktır. Bunun için ile noktaları arasında <sup>2</sup> doğrusu elde edilmelidir. [Şekil](#page-55-1) [3.1](#page-55-1) de <sup>2</sup> doğrusu gösterilmiştir. Teorem 2.4 yardımıyla <sup>2</sup> doğrusunun esasen ve noktalarından geçen doğru olduğu bilinmektedir. [Şekil 3.1](#page-55-1) de yer alan ⃗⃗ vektörünü ele alalım. Bu vektörün eğimi <sup>2</sup> hiper düzlem denkleminin ikinci bileşenine göre türevidir. Yine şekilde yer alan vektörü ise ⃗⃗ ve vektörlerinden elde edilen bir vektördür. (3.8) güncellemesinde yer alan fonksiyonu ⃗⃗ vektörünün eğiminin işaretini vektörüne yükler ve yeni bir değer elde eder. İşte bu yeni değer şekildeki vektörünün eğimine karşılık gelir. > 0 ve = ′ () < 0 olduğundan fonksiyonu yardımıyla vektörünün eğimi,
$$n\_r = -f'(notbest) > 0$$
olacaktır. Son olarak vektörünün eğimi ise
$$n\_e = an\_r + \beta n\_m > 0$$
olarak elde edilecektir.
EVGO algoritmasının bir iterasyon sonra yardımıyla değerini 3 değeri olarak güncellediğini düşünülsün ( > 0 olduğundan). Sonuç olarak ilk iterasyon sonunda (2) < (3) elde edilecektir. Bu durum gradyan iniş yöntemi adına olumlu olarak gözükse de belli bir iterasyon sonunda değeri yerel minimuma yaklaşırken, EVGO algoritmasıyla değeri global minimum yaklaşacaktır. EVGO algoritması aynı zamanda değerini de global minimuma yaklaştıracaktır. Hatırlatmak gerekir ki, bu alt bölümde değeri sadece ilk iterasyon için yerel en iyi parameter değeridir.
### **4 DÖRDÜNCÜ BÖLÜM DEĞERLENDİRME VE TARTIŞMA**
Çalışmanın bu bölümünde, EVGO algoritmasının bazı deneyler ışığında değerlendirmesi yapılmıştır. Bu deneyler genel olarak üç kısma ayrılarak sunulmuştur. İlk kısımda, birçok araştırmacı tarafından da kullanılmış olan bazı klasik fonksiyonların minimizasyonu için EVGO algoritması ile nasıl sonuçlar elde edildiği tartışılmıştır. 28,29,30 İkinci ve üçüncü kısımda ise, makine öğrenmesi uygulamaları üzerinde EVGO algoritması değerlendirilmiştir. Makine öğrenmesi deneylerinde öğrenme algoritması olarak lojistik regresyonun yanı sıra, örüntü tanıma problemlerinde oldukça başarılı sonuçlar veren derin öğrenme yöntemi kullanılmıştır.<sup>31</sup> Aynı zamanda tüm bu deneyler, özellikle örüntü tanıma problemlerinde literatürde sıklıkla kullanılan gradyan iniş yöntemi için de uygulanmıştır.<sup>32</sup> Bu kapsamda EVGO algoritması, gradyan iniş yöntemi ile hesaplama performansı açısından karşılaştırılmıştır.
### <span id="page-57-0"></span>**4.1. Bazı Klasik Fonksiyonlar Üzerinde Analizler**
Bu alt bölümde unimodal ve multimodal fonksiyonlar üzerinde EVGO algoritmasının performansı değerlendirilmiştir. [Tablo 4.1](#page-58-0) de bu fonksiyonların neler olduğu ve hangi tip fonksiyonlar olduğu (unimodal veya multimodal) belirtilmiştir. Bu fonksiyonlara ait girdi uzayı boyutu, arama uzayı, global minimum değerleri ve global minimumu veren girdileri [Tablo 4.2](#page-59-1) de verilmiştir. Problemler için başlangıç değerleri, iterasyon sayısı, hiper parametre değerleri [Tablo 4.3](#page-59-0) de verilmiştir. Son
<sup>28</sup> J.G. Digalakis, K.G Margaritis, "On benchmarking functions for genetic algorithms", **International Journal of Computer Mathematics**, Vol. 77, Issue: 4, 2001, pp. 481–506.
<sup>29</sup> S. Mirjalili, S.M. Mirjalili, X. Yang, "Binary bat algorithm", **Neural Computing and Applications**, Vol. 25, Issue: 3-4, 2014, pp. 663-681.
<sup>30</sup> D. Karaboga, B. Basturk, "A powerful and efficient algorithm for numerical function optimization: artificial bee colony (ABC) algorithm", **Journal of Global Optimization**, Vol. 39, Issue: 3, 2007, pp. 459-471.
<sup>31</sup> Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton, "Imagenet classification with deep convolutional neural networks", **Advances in neural information processing systems**, 2012, pp. 1097–1105.
<sup>32</sup> Y. LeCun, L. Bottou, Y. Bengio and P. Haffner, **a. y.**
olarak [Tablo 4.4](#page-60-0) de ise problemler için gradyan iniş yöntemi ile elde edilen çözüm parametresi, EVGO algoritması ile elde edilen çözüm parametresi. gradyan iniş yöntemi ile elde edilen çözüm değeri ve EVGO algoritması ile elde edilen çözüm değeri verilmiştir.
| Tablo 4.1. Fonksiyonlar ve tipleri | |
|------------------------------------|--|
|------------------------------------|--|
<span id="page-58-1"></span><span id="page-58-0"></span>
| Fonksiyonlar | | |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|--|
| 2<br>𝑥 − 5<br>(𝑥) =<br>𝑓1<br>− (<br>+ sin 2𝑥)<br>+ 6<br>2 +<br>𝑥<br>4 | Multimodal | |
| 2<br>2<br>1<br>1<br>−0.2√<br>−<br>2<br>(𝑥) =<br>∑cos(2𝜋𝑥𝑖<br>)<br>) + 20 + exp(1)<br>𝑓2<br>−20 exp<br>∑𝑥𝑖<br>exp (<br>2<br>2<br>𝑖=1<br>𝑖=1<br>(<br>)<br>{Ackley Fonksiyonu} | Multimodal | |
| 3 | | |
| 2<br>(𝑥) =<br>𝑓3<br>∑𝑥𝑖<br>𝑖=1 | Unimodal | |
| {Küre Fonksiyonu} | | |
| 2<br>2 −<br>(𝑥) =<br>20 +∑[𝑥𝑖<br>10 cos(2𝜋𝑥𝑖<br>)]<br>𝑓4<br>𝑖=1 | Multimodal | |
| {Rastgrin Fonksiyonu} | | |
| 2<br>2<br>2<br>(𝑥) =<br>(1<br>) +<br>2(x2<br>)<br>𝑓5<br>− x1<br>− x1 | Unimodal | |
| {Rosenbrock Fonksiyonu} | | |
| 2 +<br>2<br>2 +<br>3<br>2<br>(𝑥) =<br>(1.5<br>)<br>(2.25<br>)<br>(2.625<br>)<br>𝑓6<br>− x1<br>+ x1x2<br>− x1<br>+ x1x2<br>− x1<br>+ x1x2<br>{Beale Fonksiyonu} | Multimodal | |
| sin2<br>2 −<br>2<br>(x1<br>) −<br>x2<br>0.5<br>(𝑥) =<br>𝑓7<br>0.5 +<br>2 +<br>2)]<br>2<br>[1<br>+ 0.001(x1<br>x2<br>{Schaffer Fonksiyonu N.2} | Multimodal | |
| 2 | | |
| (𝑥) =<br>sin (√ 𝑥𝑖<br> )]<br>𝑓8<br>837.9658 −∑[𝑥𝑖<br>𝑖=1 | Multimodal | |
| {Schwefel Fonksiyonu } | | |
| 3<br>2 −<br>30 +∑[𝑥𝑖<br>)]<br>𝑓9<br>(𝑥) =<br>10 cos(2𝜋𝑥𝑖<br>𝑖=1 | Multimodal | |
| {Rastgrin Fonksiyonu} | | |
<span id="page-59-1"></span>
| Fonksiyonlar | Girdi | Arama uzayı (∀<br>𝑥𝑖 | Global minimumu veren | Global |
|--------------|--------|----------------------|-----------------------|----------|
| | Uzayı | için) | parametre değeri | minimum |
| | Boyutu | | | |
| (𝑥)<br>𝑓1 | 1 | [−10,<br>10] | −0.737839 | 0.901005 |
| 𝑓2<br>(𝑥) | 2 | [−32.768,<br>32.768] | (0,0) | 0 |
| (𝑥)<br>𝑓3 | 3 | [−5.12,<br>5.12] | (0,0,0) | 0 |
| 𝑓4<br>(𝑥) | 2 | [−5.12,<br>5.12] | (0,0) | 0 |
| 𝑓5<br>(𝑥) | 2 | [−5,<br>10] | (1,1) | 0 |
| 𝑓6<br>(𝑥) | 2 | [−4.5,<br>4.5] | (3,0.5) | 0 |
| 𝑓7<br>(𝑥) | 2 | [−100,<br>100] | (0,0) | 0 |
| (𝑥)<br>𝑓8 | 2 | [−500,<br>500] | (420.9687,420.9687) | 0 |
| (𝑥)<br>𝑓9 | 3 | [−5.12,<br>5.12] | (0,0,0) | 0 |
**Tablo 4.2.** Fonksiyonlar için problem değerleri
<span id="page-59-0"></span>**Tablo 4.3.** Problemler için sırasıyla başlangıç değerleri, iterasyon sayısı ve hiper parametre değerleri
| 𝑓𝑖 | Başlangıç | İterasyon | Hiper parametre | |
|-----------|---------------------------------------------------------------------------------------------|-----------|-----------------|-------------------|
| | Değerleri | | Gradyan İniş | EVGO |
| | | | Yöntemi | (sırasıyla |
| | | | (𝛼) | 𝛼 ve 𝛽) |
| (𝑥)<br>𝑓1 | {−6,<br>−5, −3, 2, 4} | 500 | 0.1 | ve 1<br>0.1 |
| (𝑥)<br>𝑓2 | {(1,2),<br>(3,4)} | 500 | 0.001 | ve 0.022<br>0.001 |
| 𝑓3<br>(𝑥) | {(1,2,2),<br>(3,4,−1)} | 100 | 0.01 | ve 0.08<br>0.01 |
| (𝑥)<br>𝑓4 | {(−1,<br>−2),<br>(3,4)} | 500 | 0.001 | ve 0.01<br>0.001 |
| (𝑥)<br>𝑓5 | {(1,2),<br>(3,4)} | 500 | 0.001 | ve 0.022<br>0.001 |
| (𝑥)<br>𝑓6 | {(4,1),<br>(2,0)} | 500 | 0.001 | ve 0.1<br>0.001 |
| 𝑓7<br>(𝑥) | {(1,2),<br>(−10,10)} | 500 | 0.1 | 0.1<br>ve 0.4 |
| (𝑥)<br>𝑓8 | (300,<br>−250),<br>(480,40)<br>(40,400),<br>(−400,225)<br>{<br>}<br>(470,400),<br>(−170,26) | 500 | 0.01 | ve 0.9<br>0.01 |
| (𝑥)<br>𝑓9 | {(1,2,2),<br>(3,4,0)} | 50 | 0.01 | ve 0.022<br>0.01 |
<span id="page-60-0"></span>**Tablo 4.4.** Problemler için sırasıyla gradyan iniş yöntemi ile elde edilen çözüm parametresi, EVGO algoritması ile elde edilen çözüm parametresi. gradyan iniş yöntemi ile elde edilen çözüm değeri ve EVGO algoritması ile elde edilen çözüm değeri.
| 𝑓𝑖 | Gradyan İniş | EVGO | Gradyan İniş | EVGO |
|-----------|--------------------------------------|----------------------------------------------------------------|-----------------|-------------------|
| | ile elde edilen | ile elde edilen | ile elde edilen | ile elde edilen |
| | parametre | parametre | çözüm | çözüm |
| (𝑥)<br>𝑓1 | −3.892837 | −0.737952 | 3.862718 | 0.901005 |
| (𝑥)<br>𝑓2 | (0.138960,<br>0.600455) | −6.705249𝑒 − 04,<br>(<br>1.146085𝑒 − 03 ) | 3.468322 | 0.003802 |
| (𝑥)<br>𝑓3 | (0.132619,<br>0.265239,<br>0.265239) | 1.316811𝑒 − 06,<br>(<br>)<br>3.273024𝑒 − 06,<br>3.693848𝑒 − 06 | 0.158291 | 0 |
| (𝑥)<br>𝑓4 | −0.99495864,<br>(<br>−1.98991223) | 5.414625𝑒 − 100,<br>(<br>1.476639𝑒 − 099 ) | 4.974790 | 0 |
| (𝑥)<br>𝑓5 | (1.178052,<br>1.420142) | (1.000002,<br>1.000004) | 0.016896 | 2.416617𝑒<br>− 12 |
| (𝑥)<br>𝑓6 | 4.010336,<br>(<br>0.678986) | (2.854053,<br>0.461339) | 0.069943 | 0.004027 |
| (𝑥)<br>𝑓7 | (−10.698190,<br>10.698190) | (−0.014442,<br>0.014455) | 0.008461 | 5.918698𝑒<br>− 07 |
| 𝑓8<br>(𝑥) | (436.195162,<br>414.861337) | (420.968746,<br>420.968746) | 33.776062 | 2.545513𝑒<br>− 05 |
| (𝑥)<br>𝑓9 | (1,2,2) | 0.94555464,<br>(<br>)<br>0.05070923,<br>−0.01364392 | 9 | 2.016298 |
Üzerinde çalışılan tüm fonksiyonlar için, keyfi olarak seçilen başlangıç değerlerinin EVGO algoritması ile optimum değere oldukça yakın değerlere yaklaştığı [Tablo 4.4](#page-60-0) incelendiğinde net bir şekilde görülmektedir. Bunun aksine birçok fonksiyon için gradyan iniş yönteminin optimum değerden uzak kaldığı görülmektedir. Bunun nedeni gradyan iniş yönteminin yerel minimum ve semer noktalarına yakınsayabilmesindendir. Semer noktası için durumu açıklayıcı bir örnek ile ele alalım.
(x,y) = 1 2 x <sup>2</sup> + 1 4 y <sup>4</sup> − 1 2 y 2 fonksiyonu için öğrenme oranıyla gradyan iniş yöntemini veren güncelleme fonksiyonu genelleştirilmiş biçimde aşağıdaki gibi verilsin.
$$G(\mathbf{x}) = \begin{bmatrix} (1-\alpha)\mathbf{x} \\ (1+\alpha)\mathbf{y} - \alpha \mathbf{y}^3 \end{bmatrix}$$
Kritik noktalar ise,
$$\begin{bmatrix} \mathbf{z}\_1 = \begin{bmatrix} 0 \\ 0 \end{bmatrix} & \mathbf{z}\_2 = \begin{bmatrix} 0 \\ -1 \end{bmatrix} & \mathbf{z}\_3 = \begin{bmatrix} 0 \\ 1 \end{bmatrix} \end{bmatrix}$$
şeklindedir. (x,y) fonksiyonunun Hessian matrisi ise aşağıdaki verilmiştir.
$$\mathbf{H} = \begin{bmatrix} \mathbf{1} & \mathbf{0} \\ \mathbf{0} & \mathbf{3}\mathbf{y}^2 - \mathbf{1} \end{bmatrix}$$
Buradan <sup>2</sup> ve <sup>3</sup> için ℎ<sup>11</sup> = 1 > 0 ve |H| > 0 olduğundan H pozitif tanımlı olur ve böylece <sup>2</sup> ve <sup>3</sup> noktaları yerel minimumdur. <sup>1</sup> için ise ℎ<sup>11</sup> = 1 > 0 ve |H| < 0 olduğundan H tanımsızdır. Dolayısıyla <sup>1</sup> semer noktasıdır.
Dolayısıyla keyfi başlangıç noktası [ x 0 ] şeklinde olan herhangi bir nokta <sup>1</sup> semer noktasına yakınsar denir. Diğer tüm keyfi başlangıçlar ise ya ıraksar veya lokal minimuma yakınsar. Söylemek gerekir ki, (x,y) fonksiyonu için keyfi başlangıç noktası [ x 0 ] olma olasılığının çok düşük olduğu aşikardır.<sup>33</sup> Ancak daha karmaşık fonksiyonlar için bu durum değişebilir. (x,y) fonksiyonu ve fonksiyona ait seviye eğrileri [Şekil 4.1](#page-61-0) de geometrik olarak sunulmuştur.
<span id="page-61-0"></span>**Şekil 4.1.** (x,y) fonksiyonunun geometrik gösterimi ve seviye eğrileri
<sup>33</sup> Jason D. Lee, Max Simchowitz, Michael I. Jordan, and Benjamin Recht, "Gradient Descent Converges to Minimizers", **arXiv preprint**, arXiv:1602.04915v2, 2016.
Gradyan iniş yönteminin yerel minimuma yakınsaması durumu ise <sup>1</sup> () test fonksiyonu ile kolaylıkla görülebilir. <sup>1</sup> () fonksiyonunun geometrik gösterimi [Şekil](#page-62-0) [4.2](#page-62-0) de, [Şekil 4.3](#page-63-0) de ise <sup>1</sup> (x) fonksiyonunun türevinin geometrik gösterimi verilmiştir. Her iki şekilde de siyah ile gösterilen noktalar <sup>1</sup> (x) fonksiyonu için [Tablo 4.3](#page-59-0) de verilen keyfi başlangıç noktalarıdır. Yeşil ile gösterilen noktalar ve kırmızı ile gösterilen noktalar ise sırasıyla gradyan iniş ve EVGO algoritmaları ile elde edilen noktalardır. Yüksek derecede multimodal özelliğe sahip olan bu fonksiyon için gradyan iniş yöntemi ile keyfi başlangıç noktalarının yerel minimum değerlerine yakınsadığı görülmektedir. Bunun aksine EVGO algoritması ile keyfi başlangıç noktaları, optimize edilen fonksiyondan neredeyse tamamen bağımsız olarak arama uzayında <sup>2</sup> doğrusu yardımıyla gezinerek global minimuma yakınsamıştır.
Aşağıd[a Şekil 4.3](#page-63-0) ile siyah, yeşil ve kırmızı ile belirtilen ve yukarıda ne anlama geldiği ifade edilen noktaların türev fonksiyonundaki yerleri kritik noktalar açısından incelenmiştir.
**Şekil 4.3.** <sup>1</sup> (x) fonksiyonunun türevinin geometrik gösterimi
<span id="page-63-0"></span>
Girdi uzayları iki olan fonksiyonların <sup>3</sup> de gösterimi aşağıda [Şekil](#page-64-0) 4.4 ile verilmiştir. Bu fonksiyonlara ait türev fonksiyonlarının geometrik gösterimi ise [Şekil](#page-65-0) [4.5-](#page-65-0)[Şekil 4.10](#page-66-2) arasında verilmiştir. Aynı fonksiyonlara ait seviye eğrileri [Şekil 4.11](#page-67-0) de verilmiştir. Bu seviye eğrilerinde siyah ile gösterilen noktalar EVGO algoritması ile elde edilen parametre değerleri, kırmızı ile gösterilen nokta ise ilgili fonksiyona ait global minimumu veren parametre değerini göstermektedir.
Aşağıd[a Şekil 4.12](#page-68-1) de ise girdi uzayı üç olan <sup>3</sup> ve <sup>9</sup> fonksiyonları için EVGO algoritmasının döngü boyunca ürettiği noktalar (mavi ile gösterilen noktalar) ve bu fonksiyonlara ait global minimum (kırmızı ile gösterilen noktalar) noktaları belirtilmiştir.
Son olarak [Grafik 4.1](#page-68-0) de ise tüm test fonksiyonları için gradyan iniş ve EVGO algoritmalarının iterasyonlar boyunca aldıkları değerleri gösteren grafik verilmiştir. Böylece iki algoritmanın hesaplama performansı karşılaştırması yapılabilir.
<span id="page-64-0"></span>
#### **Şekil 4.4.** Sırasıyla 2, 4, 5, 6, <sup>7</sup> ve <sup>8</sup> fonksiyonlarının de gösterimi
<span id="page-65-0"></span>**Şekil 4.5.** fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin de gösterimi
<span id="page-66-0"></span>**Şekil 4.8.** fonksiyonunun sırasıyla birinci ve ikinci bileşene göre türevlerinin de gösterimi
<span id="page-67-1"></span>
<span id="page-67-0"></span>**Şekil 4.11.** Sırasıyla , , , , ve fonksiyonları için seviye eğrileri
<span id="page-68-1"></span>**Şekil 4.12.** Sırasıyla ve fonksiyonları için EVGO algoritmasının döngü boyunca ürettiği noktaların de gösterimi
Unimodal fonksiyonların aksine, multimodal fonksiyonlar girdi boyutu ile birlikte üstel olarak sürekli artan sayıda yerel optimuma sahiplerdir. Bu durum algoritmaları karşılaştırma açısından multimodal fonksiyonları uygun yapar. EVGO algoritmasının gradyan iniş yöntemiyle hesaplama performansı açısından rekabet edici nitelikte olduğu [Tablo 4.4](#page-60-0) deki sonuçlar ve [Grafik 4.1](#page-68-0) de yer alan grafikler ile açıkça görülmektedir. Kuşkusuz bu durumun oluşmasında, EVGO algoritmasının parametre değerlerini arama uzayında hiper düzlemine bağlı olarak dolaştırarak yerel minimum ve semer noktalarından sıyırması yatmaktadır.
### **4.2. Sentetik Veriler İçin Lojistik Regresyon İle Analiz**
<span id="page-70-0"></span>Çalışmanın bu bölümünde iki farklı sentetik veri için lojistik regresyon ile EVGO ve gradyan iniş algoritmaları kullanılarak bu iki optimizasyon algoritmasının karşılaştırılmasına gidilmiştir. Lojistik regresyon için aktivasyon fonksiyonu sigmoid fonksiyonu olarak seçilmiştir.
Ayrıca her iki lojistik regresyon için hata fonksiyonu olarak kareli hata kullanılmıştır:
$$J = \sum\_{l} (\mathfrak{y}\_{l} - \mathfrak{f}\_{l})^{2}$$
Burada ; . girdi değeri için istenen hedef değeri, ̂ ; . girdi değeri için elde edilen tahmin değerini göstermektedir.
### <span id="page-70-1"></span>**4.2.1. Sentetik verilerin yapısı**
Üretilen iki sentetik veri Veri 1, Veri 2 olarak ifade edilsin. Bu iki sentetik verinin bazı özellikleri aşağıda [Tablo 4.5](#page-70-3) ile özetlenmiştir.
<span id="page-70-3"></span>
| Veriler | Girdi elemanları | Hedef değerleri | Veri Büyüklüğü |
|---------|--------------------|-----------------|----------------|
| | ve keyfi başlangıç | | (𝑁) |
| | ağırlıkları boyutu | | |
| | (𝑀) | | |
| Veri 1 | 2 | {0,1} | 250 |
| Veri 2 | 784 | {0,1} | 400 |
**Tablo 4.5.** Üretilen sentetik verilerin bazı özellikleri
<span id="page-70-2"></span>Veri 1, aşağıda [Şekil 4.13](#page-71-1) ile resmedilmiştir. Burada sarı ile gösterilen noktaların hedef değeri "1", mavi ile gösterilen noktaların hedef değeri ise "0" dır. Ek 1 de her iki verinin Python programlama dili kullanılarak nasıl oluşturulduğu belirtilmiştir.
<span id="page-71-1"></span>**Şekil 4.13.** Veri 1 in girdi kümesinin de gösterimi
### <span id="page-71-0"></span>**4.2.2. Lojistik Regresyon Yapısı ve Analiz Sonuçları**
Her iki veri için girdi kümesinin . elemanının . değeri ile gösterilecek olunursa kurulan regresyon için hata fonksiyonu,
$$f(\mathbf{x}, \mathbf{y}, \mathbf{w}) = \sum\_{l=1}^{N} \left[ \left( \mathbf{y}\_{l} - \sum\_{j=1}^{M} \frac{1}{1 + e^{-\mathbf{x}\_{lj}\mathbf{w}\_{j}}} \right)^{2} \right]$$
şeklindedir. Burada ; . girdi değeri için istenen hedef değeri, ; başlangıçta keyfi olarak seçilen optimize edilecek ağırlığın . değerini göstermektedir.
Aşağıda [Tablo 4.6](#page-72-0) de Veri 1 ve Veri 2 için kullanılan hiper parametreler ve analiz sonuçları yer almaktadır. Bu tabloda yer alan "hata" ile kastedilen, iterasyonlar boyunca hata fonksiyonunun aldığı minimum değerdir. Analiz sonuçlarına göre, Veri 1 için EVGO algoritmasıyla gradyan iniş yöntemine göre % 99 'luk bir göreli iyileşme mevcutken, Veri 2 için EVGO algoritmasıyla göreli iyileşme % 95 tir.
| Veriler | İterasyon | Keyfi | Gradyan İniş | | EVGO | |
|---------|-----------|-------------|--------------|--------|---------------|--------|
| | sayısı | başlangıç | Hiper | Hata | Hiper | Hata |
| | | ağırlıkları | parametre | | parametre | |
| | | sayısı | (𝛼) | | (sırasıyla | |
| | | | | | 𝛼 ve 𝛽) | |
| Veri 1 | 100 | 2 | 0.01 | 3.8687 | 0.01<br>ve | 0.0042 |
| | | | | | 0.088 | |
| Veri 2 | 500 | 3 | 0.1 | 1.3236 | 0.1<br>ve 0.8 | 0.0577 |
<span id="page-72-0"></span>**Tablo 4.6.** Veri 1 ve Veri 2 için kullanılan hiper parametreler ve analiz sonuçları
Yukarıda detayları verilen lojistik regresyon (LR) ve veriler için, gradyan iniş ve EVGO algoritması kullanılarak elde edilen iterasyona bağlı hata fonksiyonu değerleri [Grafik 4.2](#page-72-1) ile verilmiştir. EVGO yönteminin kurulan basit regresyon için hata fonksiyonu değerini minimize etme açısından gradyan iniş yöntemi ile rekabet edici nitelikte olduğu aşikardır.
<span id="page-72-1"></span>**Grafik 4.2.** Sırasıyla Veri 1 ve Veri 2 için gradyan iniş ve EVGO algoritmasıyla elde edilen iterasyona bağlı hata fonksiyonu değerleri
Ek 1 de yapılan her iki analize ait Python programlama diline ait kodlar verilmiştir. Ek 1 de Veri 2 için yapılan analizin kodu Python programlama dilinde bir kütüphane olan theano kullanılarak yazılmıştır<sup>34</sup> .
<sup>34</sup> The Theano Development Team: Theano, "A Python framework for fast computation of mathematical expressions", **arXiv preprint**, arXiv:1605.02688v1, 2016.
### <span id="page-73-0"></span>**4.3. El Yazısı Rakam Dizisi Üzerinde Analiz**
Bu bölümde literatürde sıklıkla yer alan MNIST (Mixed National Institute of Standards and Technology) veri seti kullanılacaktır<sup>35</sup>. Öncelikle MNIST veri seti tanıtılacak, sonrasında ise MNIST veri seti üzerinde yapılan analizlerden bahsedilecektir. Bu analizlerden ilki lojistik regresyonun çok kategorili olarak genelleştirilmiş biçimi olan softmax regresyon olacaktır. İkinci analiz olarak ise imge tanıma sistemlerinde sıklıkla kullanılan ve mükemmel performansa sahip derin evrişimli sinir ağları olacaktır<sup>36</sup> .
### <span id="page-73-1"></span>**4.3.1. MNIST Veri Seti**
MNIST veri seti makine öğrenmesi alanında yoğun olarak kullanılmaktadır<sup>37</sup> . Orijinal MNIST veri seti, eğitim seti olarak 60,000 veri ve test seti olarak 10,000 veriden oluşmaktadır. Çalışmada orijinal eğitim setinin 50,000 verilik kısmı eğitim seti olarak 10,000 verilik kısmı ise doğrulama seti olarak ikiye ayrılmıştır. Tüm veriler 28 × 28 piksellik sabit imge boyutuna sahiptir. Orijinal veri setinde yer alan imgelerdeki her bir piksel değeri [0,255] aralığında yer almaktadır. Burada, 0 siyah pikseli, 255 beyaz pikseli, aralıkta yer alan değerler ise grinin diğer tonlarını temsil etmektedir. Çalışmada piksel değerleri [0,1] aralığında yer alacak şekilde normalize edilmiştir. Yine burada, 0 siyah pikseli, 1 beyaz pikseli, aralıkta yer alan değerler ise grinin diğer tonlarını temsil etmektedir. Ayrıca her bir verinin hedef değeri imge verilerindeki rakamları temsilen 0 ila 9 arasındaki rakamlardır. Aşağıda [Şekil 4.14](#page-74-1) de MNIST veri setinden bazı örnekler verilmiştir.
<sup>35</sup> Y. LeCun, L. Bottou, Y. Bengio and P. Haffner, **a. y.**
<sup>36</sup> Steven J. Nowlan, John C. Platt, "A convolutional neural network hand tracker", **Advances in Neural Information Processing Systems**, 1995, pp. 901–908.
<sup>37</sup> Jürgen Schmidhuber, "Deep learning in neural networks: An overview", **Neural Networks**, Vol.61, 2015, pp. 85–117.
<span id="page-74-1"></span>**Şekil 4.14.** MNIST veri setinden örnekler. (Hedef değerleri soldan sağa sırasıyla , , , , , , , , , , , , , , , şeklindedir.)
### <span id="page-74-0"></span>**4.3.2. Softmax Regresyon Analizi**
Çalışmanın bu kısmında, veriyi işlemek amacıyla küçük-parti (mini-batch) yaklaşımı ele alınmıştır. Hata fonksiyonunu tanımlarken, sadece bir örneği kullanmak yerine eğitim setinin küçük-partisi kullanılmıştır. Böylelikle gradyan vektörünün kalitesi artmış olur<sup>38</sup>. Bu durumda neden tüm eğitim verisinin bir kerede hata
<sup>38</sup>Sergey Ioffe & Christian Szegedy, **a. y.**
fonksiyonunun üretilmesinde kullanılmadığı sorusu akla gelebilir. MNIST gibi büyük eğitim verilerinin bir defada hata fonksiyonuna dahil olması, hata fonksiyonunu devasa hale getirecek ve böylece algoritmalarda kullanılacak gradyan alma işleminin hayli zaman almasına neden olacaktır. Bu nedenle MNIST verisi işlenirken eğitim verisi küçük partilere ayrılmıştır. Dolayısıyla her bir partiden sonra ağırlık güncelleştirmeleri yapılmıştır. Softmax regresyon (SR) analizi için küçük-parti değeri 600 olarak belirlenmiştir.
Softmax regresyonun matematiksel olarak genel formunu verecek olursak; {( (1) , (1) ), … , ( () , () )} kümesi tane hedef değeri ile veriyi temsil etsin. Burada () ∈ dir. Hata fonksiyonu ise negatif olabilirlik fonksiyonu olarak:
$$J(\mathcal{W}) = -\left[\sum\_{l=1}^{m} \sum\_{k=1}^{K} \mathbf{1}\{\mathbf{y}^{(l)} = k\} \log \frac{e^{\mathcal{W}^{(k)T}\mathbf{x}^{(l)}}}{\sum\_{j=1}^{K} e^{\mathcal{W}^{(j)T}\mathbf{x}^{(l)}}}\right]$$
şeklindedir<sup>39</sup>. Burada logaritmanın içindeki ifade softmax fonksiyonunu ifade etmektedir. Ayrıca hata fonksiyonunda yer alan 1{∙} fonksiyonu gösterge fonksiyonudur. Şöyle ki 1{∙} fonksiyonu için, 1{ğ } = 1 ve 1{ş } = 0 ifadeleri geçerlidir. Yine hata fonksiyonunda yer alan değeri kategori sayısını (hedef değeri sayısı) ifade etmektedir. Üzerinde çalıştığımız MNIST veri seti için = 10 ve = 600 şeklindedir.
<span id="page-75-0"></span>Aşağıda [Şekil 4.15](#page-76-1) ile softmax regresyon analizi diyagram olarak verilmiştir.
<sup>39</sup> Bishop**, a.g.e**, pp. 197-245.
Uygulanan analiz için keyfi başlangıç parametreleri ve hiper parametreler için bazı bilgiler [Tablo 4.7](#page-76-0) ile sunulmuştur. Burada ile gösterilen hiper parametrelerin iki algoritma için birbirinden farklı olduğuna dikkat edilmelidir.
<span id="page-76-0"></span>
| İterasyon Sayısı | | 500 | |
|------------------------------------|-----------------------|------------------|--|
| Keyfi başlangıç ağırlıkları sayısı | | 3 | |
| Keyfi başlangıç ağırlıkları boyutu | | 7840 | |
| | | (784<br>10)<br>× | |
| | Gradyan İniş (𝛼) | 0.13 | |
| Hiper parametreler | EVGO | ve 0.14<br>0.001 | |
| | (sırasıyla 𝛼<br>ve 𝛽) | | |
**Tablo 4.7.** Softmax regresyon analizi ile ilgili bazı bilgiler
Softmax regresyon kullanılarak EVGO ve gradyan iniş optimizasyon yöntemleri ile elde edilen sonuçlara ilişkin bazı bilgiler [Tablo 4.8](#page-77-0) ile sunulmuştur. Bu tabloda yer alan "hata" ile iterasyonlar boyunca yanlış olarak sınıflandırılmış verilerin oranı kastedilmiştir. Doğrulama setinde en düşük hatayı veren ağırlık değerlerinin test seti üzerindeki performansı [Tablo 4.8](#page-77-0) de Test Seti\* ile verilmiştir.
<span id="page-77-0"></span>
| | Gradyan iniş ile<br>elde edilen hata | EVGO ile elde<br>edilen hata | Göreli İyileşme |
|----------------|--------------------------------------|------------------------------|-----------------|
| Eğitim Seti | % | % | % |
| | 6.5 | 6.38 | 1.84 |
| Doğrulama Seti | % | % | 2.55 |
| | 7.04 | 6.86 | % |
| Test Seti | % | % | % |
| | 7.2 | 6.94 | 3.61 |
| Test Seti* | % | % | % |
| | 7.28 | 7.11 | 2.33 |
**Tablo 4.8.** Softmax regresyon analizi sonuçları
Yapılan softmax regresyon analizinin eğitim, doğrulama ve test seti için iterasyon boyunca aldıkları hata değerleri, EVGO ve gradyan iniş optimizasyon yöntemleri için grafiksel olarak [Grafik 4.3](#page-77-1) ile verilmiştir. Sırasıyla doğrulama ve test seti için EVGO ve gradyan iniş yöntemleri ile iterasyonlar boyunca elde edilen hata değerleri [Grafik 4.4](#page-78-1) ile verilmiştir.
EVGO yönteminin softmax regresyon analizi için hata değerini minimize etme açısından gradyan iniş yöntemi ile rekabet edici nitelikte olduğu aşikardır.
<span id="page-77-1"></span>**Grafik 4.3.** Sırasıyla EVGO ve gradyan iniş yöntemlerinin eğitim, doğrulama ve test seti için iterasyon boyunca aldıkları hata değerleri (Softmax regresyon analizi)
<span id="page-77-2"></span>
<span id="page-78-1"></span>
### <span id="page-78-0"></span>**4.3.3. Derin Evrişimli Sinir Ağı (DESA) Analizi**
Çalışmanın bu bölümünde derin evrişimli sinir ağları (convolutional neural network - CNN) kullanılarak MNIST veri seti üzerinde bir analiz gerçekleştirilecektir. DESA nın özellikle imge verisini işleme konusunda ne kadar başarılı olduğundan birinci bölümde bahsedilmiştir. DESA lar özellikle büyük ve derin bir yapıya sahip olduklarında potansiyellerini daha fazla ortaya çıkartırlar<sup>40</sup>. Fakat CPU'lar kullanılarak bu yapıları eğitmek günler, haftalar ve hatta yıllar alabilir. Ancak son yıllarda, grafik kartları (GPUs) için hızlı paralel sinir ağı kodları bu problemin üstesinden gelmiştir<sup>41</sup>. Bu nedenle DESA analizi için yazılan kod GPU desteklidir.
Analiz için kullanılan DESA yapısı aşağıda [Şekil 4.16](#page-79-0) ile verilmiştir. Kullanılan DESA yapısı için LeNet-5 ağından faydalanılmıştır<sup>42</sup> .
<sup>40</sup> D. C. Ciresan, U. Meier, J. Masci, L. M. Gambardella, and J. Schmidhuber, " Flexible, high performance convolutional neural networks for image classification", **International Joint Conference on Artificial Intelligence,** 2011, pp. 1237–1242.
<sup>41</sup> Dan Ciregan, Ueli Meier, and Jürgen Schmidhuber. "Multi-column deep neural networks for image classification", **2012 IEEE Conference on Computer Vision and Pattern Recognition (CVPR),** Providence, RI, 2012, pp. 3642-3649.
<sup>42</sup> Y. LeCun, L. Bottou, Y. Bengio and P. Haffner, **a. y.**
#### **Şekil 4.16.** DESA yapısı
<span id="page-79-0"></span>
Uygulanan analiz için keyfi başlangıç parametreleri ve hiper parametreler için bazı bilgiler [Tablo 4.9](#page-79-1) ile sunulmuştur. Uygulanan analizde her katmanda yer alan ağırlıkların boyutları ise [Tablo 4.10](#page-80-0) de yer almaktadır. Analiz için eğitilebilir ağırlık değeri sayısı 430500 dür. Keyfi başlangıç ağırlık sayısı olarak 3 belirlenmiştir. Dolayısıyla EVGO algoritması için her bir iterasyonda 1291500 ağırlık değeri eğitilmiştir. Ayrıca uygulanan analiz için küçük-parti değeri 500 olarak belirlenmiştir.
<span id="page-79-1"></span>
| İterasyon Sayısı | | 100 | |
|------------------------------------|-----------------------|----------------|--|
| Keyfi başlangıç ağırlıkları sayısı | | 3 | |
| | Gradyan İniş (𝛼) | 0.1 | |
| Hiper parametreler | EVGO | 0.1<br>ve 0.05 | |
| | (sırasıyla 𝛼<br>ve 𝛽) | | |
#### **Tablo 4.9.** DESA analizi ile ilgili bazı bilgiler
Ayrıca katman 2, katman 4 ve katman 5 den sonra tanjant hiperbolik aktivasyon fonksiyonu, katman 6 dan sonra ise softmax aktivasyon fonksiyonu kullanılmıştır. Ayrıca havuzlama katmanlarında maksimum havuzlama (max-pooling) yöntemi benimsenmiştir. Analizde yer alan katmanların girdi ve çıktı boyutları [Tablo 4.11](#page-80-1) de yer almaktadır.
<span id="page-80-0"></span>
| | Katmanlar | Ağırlık Tensör<br>Boyutu |
|----|-----------------------------|-----------------------------------|
| L1 | Evrişim (Convolution) | 20<br>×<br>1<br>×<br>5<br>×<br>5 |
| L2 | Havuzlama (Pooling) | 0 |
| L3 | Evrişim (Convolution) | 50<br>×<br>20<br>×<br>5<br>×<br>5 |
| L4 | Havuzlama (Pooling) | 0 |
| L5 | Tam Bağlı (Fully Connected) | 800<br>×<br>500 |
| L6 | Tam Bağlı (Fully Connected) | 500<br>×<br>10 |
**Tablo 4.10.** DESA için ağırlık tensör boyutları
DESA analizinde hata fonksiyonu negatif olabilirlik fonksiyonu olarak belirlenmiştir. Ayrıca evrişim katmanlarında boyutsal uzanım değeri () 5, stride değeri () 1, zero padding değeri () 0 olarak, havuzlama katmanlarında ise boyutsal uzanım değeri ve stride değeri 2 olarak belirlenmiştir.
DESA kullanılarak EVGO ve gradyan iniş optimizasyon yöntemleri ile elde edilen sonuçlara ilişkin bazı bilgiler [Tablo 4.12](#page-81-2) ile sunulmuştur. Bu tablo da yer alan "hata" ile kastedilen, iterasyonlar boyunca yanlış olarak sınıflandırılmış verilerin oranlarının minumum değeridir. Doğrulama setinde en düşük hatayı veren ağırlık değerlerinin test seti üzerindeki performansı [Tablo 4.12](#page-81-2) de Test Seti\* ile verilmiştir.
<span id="page-80-2"></span>
| | Katmanlar | Girdi Boyutu | Çıktı Boyutu | |
|----|-----------------------------|--------------------------|--------------------------|--|
| L1 | Evrişim (Convolution) | 1<br>×<br>28<br>×<br>28 | 20<br>×<br>24<br>×<br>24 | |
| L2 | Havuzlama (Pooling) | 20<br>×<br>24<br>×<br>24 | 20<br>×<br>12<br>×<br>12 | |
| L3 | Evrişim (Convolution) | 20<br>×<br>12<br>×<br>12 | 50<br>×<br>8<br>×<br>8 | |
| L4 | Havuzlama (Pooling) | 50<br>×<br>8<br>×<br>8 | 50<br>×<br>4<br>×<br>4 | |
| L5 | Tam Bağlı (Fully Connected) | 50<br>×<br>4<br>×<br>4 | 500<br>×<br>1<br>×<br>1 | |
| L6 | Tam Bağlı (Fully Connected) | 500<br>×<br>1<br>×<br>1 | 10<br>×<br>1<br>×<br>1 | |
<span id="page-80-1"></span>**Tablo 4.11.** DESA analizinde yer alan katmanların girdi ve çıktıların tensör boyutları
**Tablo 4.12.** DESA analizi sonuçları
<span id="page-81-2"></span>
| | Gradyan iniş ile | EVGO ile elde | | |
|----------------|------------------|---------------|-----------------|--|
| | elde edilen hata | edilen hata | Göreli İyileşme | |
| Doğrulama Seti | % | % | % | |
| | 0.96 | 0.91 | 5.20 | |
| Test Seti | % | % | % | |
| | 0.97 | 0.87 | 10.30 | |
| Test Seti* | % | % | % | |
| | 1.00 | 0.90 | 10 | |
<span id="page-81-0"></span>**Şekil 4.17.** Sırasıyla EVGO ve gradyan iniş yöntemlerinin eğitim, doğrulama ve test seti için iterasyon boyunca aldıkları hata değerleri (DESA analizi)
Yapılan DESA analizinin eğitim, doğrulama ve test seti için iterasyon boyunca aldıkları hata değerleri, EVGO ve gradyan iniş optimizasyon yöntemleri için grafiksel olarak [Şekil 4.17](#page-81-0) ile verilmiştir. Sırasıyla doğrulama ve test seti için EVGO ve gradyan iniş yöntemleri ile iterasyonlar boyunca elde edilen hata değerleri [Şekil 4.18](#page-81-1) de verilmiştir.
Ek 2 ile DESA analizine ait Python programlama dilinde theano kütüphanesi kullanılarak yazılmış GPU destekli kod verilmiştir.
DESA analizi için EVGO yönteminin hata değerini minimize etme açısından gradyan iniş yöntemi ile rekabet edici nitelikte olduğu aşikardır. EVGO optimizasyon algoritmasıyla oldukça yüksek düzeyde bir göreli iyileşme elde edildiği [Tablo 4.12](#page-81-2) ile görülebilir.
### **SONUÇ**
<span id="page-83-0"></span>Bu doktora tezi çalışmasında, EVGO adı verilen gradyan temelli yeni bir optimizasyon yöntemi ortaya konmuştur. EVGO algoritmasını temellendiren öge ise özel bir hiper düzlemdir. Bu hiper düzlem × 1 boyutlu iki vektör için kurulan özel bir hiper düzlemdir: hiper düzlemi. Ayrıca çalışmada <sup>2</sup> ve <sup>3</sup> hiper düzlemleri için bazı ilgi çekici özelliklerden bahsedilmiştir. Bu özellikler hiper düzleminin estetik değerini de ortaya çıkarmıştır.
EVGO algoritması ile parametre güncellemesi hiper düzlemi ve optimizasyonu üzerinde çalışılan fonksiyonun gradyanı ile gerçekleştirilir. hiper düzleminin gradyanı ile çözüm uzayında gezinilebilecek analitik bir yöntem elde edilmiştir. Dolayısıyla EVGO algoritmasıyla parametre güncellemesinde yeni bir momentum elde edilmiş olunur.
EVGO algoritmasının hata fonksiyonunu minimize etme üzerindeki başarısı bazı matematiksel fonksiyonlar ve makine öğrenmesi problemleriyle test edilmiştir. EVGO algoritması için keyfi başlangıç ağırlık sayısını ve () gradyan iniş algoritmasının karmaşıklığını göstermek üzere EVGO algoritmasının karmaşıklığı ( + 1) dir. değeri büyüdüğünde hesaplama maliyeti artacağından bu çalışmada özellikle örüntü tanıma uygulamalarında küçük değerleri ile çalışılmıştır.
EVGO algoritmasının hesaplama performansı çalışmada verilen tüm uygulamalar açısından gradyan iniş yöntemine göre daha iyi düzeydedir. Tüm uygulamalar için gradyan iniş ve EVGO algoritmalarıyla elde edilen sonuçlar çalışmada detayları ile verilmiştir. Özellikle DESA yapısıyla MNIST veri setinde elde edilen % 10 düzeyindeki göreli iyileşme dikkat çekicidir.
EVGO algoritmasının karmaşıklığını gradyan iniş algoritmasının karmaşıklığı seviyesine çekecek yine hiper düzlemi temelli yeni algoritmaların üretilebileceği düşünülmektedir. Böylelikle düşen hesaplama maliyeti ile EVGO algoritması ağırlık güncelleme konusunda daha kullanışlı hale gelecektir. Çalışmada optimizasyon için diferansiyellenebilir fonksiyonlar kullanılmıştır. Ancak diferansiyellenemez fonskiyonlar için kullanılan optimizasyon yöntemleri için de hiper düzlemi temelli bir momentum sağlayacak yeni algoritmaların üretilebileceği kanısındayız.
### **KAYNAKÇA**
<span id="page-85-0"></span>
| Arfken, | George, | B., | Mathematical | Methods | for | Physicists, | Boston, |
|-----------------|---------|-------------------------------------|--------------|---------|-----|-------------|---------|
| Hans J. Weber.: | | Elsevier Acad. Press, 2005, p. 438. | | | | | |
Batı, Emrecan.: "Deep convolutional neural networks with an application towards geospatial object recognition", **Middle East Technical University**, Master's thesis, Ankara, 2016, p. 33.
Bishop, Christopher, M.: **Pattern Recognition and Machine Learning (Information Science and Statistics)**, Springer-Verlag New York, 2006.
Buduma, Nikhil, Nicholas Locascio.: **Fundamentals of Deep Learning: Designing Nextgeneration Machine Intelligence Algorithms,** O'Reilly Media, Inc, 2017.
Ciregan, Dan, Ueli Meier, and Jürgen Schmidhuber.: "Multi-column deep neural networks for image classification", **2012 IEEE Conference on Computer Vision and Pattern Recognition (CVPR),** Providence, RI, 2012, pp. 3642-3649.
Ciresan, D. C., U. Meier, J. Masci, L. M. Gambardella, and J. Schmidhuber.: "Flexible, high performance convolutional neural networks for image classification", **International Joint Conference on Artificial Intelligence,** 2011, pp. 1237– 1242.
Digalakis, J.G., K.G Margaritis.: "On benchmarking functions for genetic algorithms", **International Journal of Computer Mathematics**, Vol. 77, Issue: 4, 2001, pp. 481–506.
Duda, Richard, O., Peter E. Hart, and David G. Stork.: **Pattern classification**. John Wiley & Sons, 2012.
Folland, Gerald, B.: **Advanced Calculus**, Upper Saddle River, NJ, PrenticeHall, Inc., 2002.
Han, Jun, Claudio Morag.: "The influence of the sigmoid function parameters on the speed of backpropagation learning", **In: Mira José, Sandoval F. (eds) From Natural to Artificial Neural Computation**, 1995, pp. 195–201.
Horn, Roger, A., Charles R. Johnson.: **Matrix Analysis,** New York, Cambridge University Press, 2013, pp. 12-371.
Ioffe, Sergey, Christian Szegedy.: "Batch normalization: Accelerating deep network training by reducing internal covariate shift", **International Conference on Machine Learning**, June 2015, pp. 448-456.
Karaboga, D., B. Basturk.: "A powerful and efficient algorithm for numerical function optimization: artificial bee colony (ABC) algorithm", **Journal of Global Optimization**, Vol. 39, Issue: 3, 2007, pp. 459-471.
Karpathy, Andrej, George Toderici, Sanketh Shetty, Thomas Leung, Rahul Sukthankar, Li Fei-Fei.: "Large-scale video classification with convolutional neural networks", **In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition**, 2014, pp. 1725-1732.
Karpathy, Andrej.: "Course materials and notes for Stanford class CS231n: Convolutional Neural Networks for Visual Recognition", (Çevrimiçi) [http://cs231n.github.io/convolutional](http://cs231n.github.io/convolutional-networks/)[networks/,](http://cs231n.github.io/convolutional-networks/) 8.2.2018.
Krizhevsky, Alex, Ilya Sutskever, and Geoffrey E. Hinton.: "Imagenet classification with deep convolutional neural networks", **Advances in neural information processing systems**, 2012, pp. 1097–1105.
Lecun, Y., L. Bottou, Y. Bengio and P. Haffner.: "Gradient-Based Learning Applied to Document Recognition", **Proceedings of the IEEE**, Vol. 86, No: 11, 1998, pp. 2278-2324.
LeCun, Y., Y. Bengio, G. Hinton.: "Deep learning", **Nature**, Vol. 521, No: 7553, 2015, pp. 436-444.
Lee, Jason D., Max Simchowitz, Michael I. Jordan, and Benjamin Recht.: "Gradient Descent Converges to Minimizers", **arXiv preprint**, arXiv:1602.04915v2, 2016.
Lima, J.A., N. Gracias, H. Pereira, A.C. Rosa.: "Fitness Function Design for Genetic Algorithms in Cost Evaluation Based Problems", **Proceedings of IEEE International Conference on Evolutionary Computation**, Nagoya, 1996, pp. 207-212.
Mayer, Hermann, Faustino Gomez, Daan Wierstra, Istvan Nagy, Alois Knoll, and Jürgen Schmidhuber.: "A system for robotic heart surgery that learns to tie knots using recurrent neural networks", **Advanced Robotics**, Vol. 22, No: 13-14, 2008, pp. 1521-1537.
McCulloch, W., W. Pitts.: "A logical calculus of the ideas immanent in nervous activity", **Bulletin of Mathematical Biophysics**, Vol. 5, No: 4, 1943, pp. 115–133.
Mirjalili, S., S.M. Mirjalili, X. Yang.: "Binary bat algorithm", **Neural Computing and Applications**, Vol. 25, Issue: 3-4, 2014, pp. 663-681.
Mohamed, Abdelrahman, George E. Dahl, Geoffrey Hinton.: "Acoustic modeling using deep belief networks", **IEEE Transactions on Audio, Speech, and Language Processing**, Vol. 20, No: 1, 2012, pp. 14-22.
Ning, Feng, Damien Delhomme, Yann LeCun, Fabio Piano, Léon Bottou, Paolo Emilio Barbano.: "Toward automatic phenotyping of developing embryos from videos", **IEEE Transactions on Image Processing**, Vol. 14, No: 9, 2005, pp. 1360-1371.
Nowlan, Steven J., John C. Platt.: "A convolutional neural network hand tracker", **Advances in Neural Information Processing Systems**, 1995, pp. 901–908.
O'Neill, Barret.: **Elementary Differential Geometry**, San Diego CA, Academic Press, 1966.
PaddlePaddle developers.: "Recognize Digits" , (Çevrimiçi), [http://paddlepaddle.org/docs/develop/](http://paddlepaddle.org/docs/develop/book/02.recognize_digits) [book/02.recognize\\_digits/](http://paddlepaddle.org/docs/develop/book/02.recognize_digits)index.html, 16 Ocak 2018.
Rosenblatt, F.: "The Perceptron: A Probabilistic Model for Information Storage and Organization in The Brain", **Psychological Review**, Vol. 65, No: 6, 1958, pp. 386–408
Schmidhuber, Jürgen.: "Deep learning in neural networks: An overview", **Neural Networks**, Vol.61, 2015, pp. 85–117.
The Theano Development Team: Theano.: "A Python framework for fast computation of mathematical expressions", **arXiv preprint**, arXiv:1605.02688v1, 2016.
The Theano Development Team: Theano.: " Convolutional Neural Networks (LeNet) -- DeepLearning 0.1 documentation", (Çevrimiçi) [http://deeplearning.net/tutorial/lenet.html,](http://deeplearning.net/tutorial/lenet.html) 25.2.2016.
Wiesel, D. H., T. N. Hubel.: " Receptive fields of single neurones in the cat's striate cortex", **The Journal of Physiology**, Vol. 148, No: 3, 1959, pp. 574–591.
Wismer, David, A., R. Chattergy.: **Introduction to Nonlinear Optimization: a problem solving approach**, Amsterdam, North-Holland Publishing Company, 1978.
### **EKLER**
### <span id="page-90-0"></span>**EK 1: Sentetik Verilere ait Python Kodu**
### **Veri 1 için GPU Destekli Python Kodu**
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
from \_\_future\_\_ import division
from sklearn.datasets.samples\_generator import make\_blobs
import numpy as np
import argparse
import math
from numpy import vectorize
(X, y) = make\_blobs(n\_samples=250, n\_features=2, centers=2, cluster\_std=1.05, random\_state=20)
X = np.c\_[np.ones((X.shape[0])), X]
def sigmoid(gamma):
if gamma < 0:
return 1 - 1/(1 + math.exp(gamma))
else:
return 1/(1 + math.exp(-gamma))
sigmoid\_activation = vectorize(sigmoid)
def isaret2(x,y):
return np.multiply(np.multiply(sgn(x),sgn(y)),y)
def sgn(x):
return (np.sign(x[0]),np.sign(x[1]),np.sign(x[2]))
def total(a,b):
sum=0
d=[(x-y)\*\*2 for x, y in zip(a[:-1], b[:-1])]
for i in range(0,len(d)):
sum=sum+d[i]
return sum
def grad\_mn(a,b):
c=[(x-y)\*(a[-1]-b[-1])/total(a, b) for x, y in zip(a[:-1], b[:-1])]
return np.asarray(c)
def L(loss1,a,b,X,y):
a=np.append(a,loss1((X,a,y)))
b=np.append(b,loss1((X,b,y)))
return grad\_mn(a,b)
def fitness(x):
return 1/(1+x) # buraya tekrar bak negatif x durumunda işler karışıyor
def fit2(ck,X,y):
results = []
for i in ck:
results.append(fitness(loss1((X,i,y))))
return results
```
def pos(ck,X,y):
sum=0
for s in range(0,len(fit2(ck,X,y))):
sum = sum +fit2(ck,X,y)[s]
results = []
for i in range(0,len(fit2(ck,X,y))):
results.append((fit2(ck,X,y)[i])/sum)
return results
```
```
def best2(ck,X,y):
```
```
for i in range(0,len(ck)):
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
return (ck[i],loss1((X,ck[i],y)))
```
```
def best3(ck,X,y):
```
```
for i in range(0,len(ck)):
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
return loss1((X,ck[i],y))
def best4(ck,X,y):
```
```
for i in range(0,len(ck)):
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
return ck[i]
```
```
def best5(ck,X,y):
```
```
for i in range(0,len(ck)):
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
return i
```
def loss1(args):
return np.sum((sigmoid\_activation(args[0].dot(args[1]))-args[2]) \*\* 2)
def gradient(args):
return X.T.dot(sigmoid\_activation(args[0].dot(args[1]))-args[2]) / args[0].shape[0]
print("[INFO] gradyan inis...")
W1=np.array([ 0.28847315, 0.0581705 , 0.92380737]) W2=np.array([ 0.01979629, 0.80299375, 0.46981295])
ck=[W1,W2] lossHistory = [] alfa=0.01
print ck
for epoch in np.arange(0, 100):
loss = min([loss1((X,i,y)) for i in ck])
print (np.argmin([loss1((X,i,y)) for i in ck]))
lossHistory.append(loss)
print ("[INFO] epoch #{}, loss={:.7f}".format(epoch + 1, loss))
for i in range(0,len(pos(ck,X,y))):
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
ck[i] += np.multiply(-alfa,gradient((X,ck[i],y)))
else:
ck[i] += np.multiply(-alfa,gradient((X,ck[i],y)))
print (best5(ck,X,y))
print("[INFO] EVGO...")
W1=np.array([ 0.28847315, 0.0581705 , 0.92380737]) W2=np.array([ 0.01979629, 0.80299375, 0.46981295])
ck=[W1,W2]
lossHistory1 = []
alfa=0.01
beta=0.088
print ck
for epoch in np.arange(0, 100):
loss = min([loss1((X,i,y)) for i in ck])
print (np.argmin([loss1((X,i,y)) for i in ck]))
lossHistory1.append(loss)
print ("[INFO] epoch #{}, loss={:.7f}".format(epoch + 1, loss))
```
for i in range(0,len(pos(ck,X,y))):
```
if pos(ck,X,y)[i] == max(pos(ck,X,y)):
ck[i] += np.multiply(-alfa,gradient((X,ck[i],y)))
else:
ck[i] += np.multiply(-alfa,isaret2(L(loss1, best4(ck,X,y), ck[i] , X, y), gradient((X,ck[i],y))))-np.multiply(beta,L(loss1, best4(ck,X,y), ck[i] , X, y)) print (best5(ck,X,y))
### **Veri 2 için GPU Destekli Python Kodu**
import numpy
import theano
import theano.tensor as T from theano.ifelse import ifelse
rng= numpy.random.RandomState(25) rng2= numpy.random.RandomState(24) rng3= numpy.random.RandomState(23)
N = 400 feats = 784 feats = 784
feats = 784
# generate a dataset: D = (input\_values, target\_class) D = (rng.randn(N, feats), rng.randint(size=N, low=0, high=2)) training\_steps = 10
x = T.dmatrix("x") y = T.dvector("y")
w1 = theano.shared(rng.randn(feats), name="w1") w2 = theano.shared(rng2.randn(feats), name="w2") w3 = theano.shared(rng3.randn(feats), name="w3")
ck = [w1,w2,w3]
p=[] prediction = [] xent = [] cost = []
for w in ck:
p\_1 = 1 / (1 + T.exp(-T.dot(x, w))) p.append(p\_1) predictionx = p\_1 > 0.5 prediction.append(predictionx) xentx = (y-p\_1)\*\* 2 xent.append(xentx)
```
for w,xentx in zip(ck,xent):
costx = xentx.mean() + 0.01 * (w ** 2).sum()
cost.append(costx)
```
```
enk= T.argmin(cost)
```
```
cknew=T.concatenate([w1,w2,w3])
```
```
cknew2=T.reshape(cknew,(3,feats))
```
```
best = cknew2[enk]
```
```
non=cknew2[0:enk]
```
```
non2=cknew2[enk+1:]
```
```
xx = T.concatenate([non,non2])
```
```
nonbest2=xx.reshape((-1,))
```
nonbest=T.reshape(nonbest2,(2,feats))
nonbest3=[nonbest[0], nonbest[1]]
best\_ck\_index = theano.function([x,y], T.argmin(cost))
cost\_f = theano.function([x,y], cost)
predict = theano.function(inputs=[x], outputs=prediction)
```
def composition(x,y):
```
input = best
best\_p\_1 = 1 / (1 + T.exp(-T.dot(x, input))) best\_prediction = best\_p\_1 > 0.5 best\_xent = (y-best\_p\_1)\*\* 2 best\_cost = best\_xent.mean() + 0.01 \* (input \*\* 2).sum() best\_gw = T.grad(best\_cost, [input])[0]
p2=[] prediction2 = [] xent2 = [] cost2 = []
for i in range(len(nonbest3)):
p\_12 = 1 / (1 + T.exp(-T.dot(x, nonbest3[i]))) p2.append(p\_12) predictionx = p\_12 > 0.5 prediction2.append(predictionx) xentx = (y-p\_12)\*\* 2 xent2.append(xentx)
```
for i,xentx in zip(range(len(nonbest3)),xent2):
costx = xentx.mean() + 0.01 * (nonbest3[i] ** 2).sum()
cost2.append(costx)
```
yComp = input- 0.1\* best\_gw #update best
gw2 = []
for i in range(len(nonbest3)):
gwx = T.grad(cost2[i], [nonbest3[i]])
gw2.append(gwx[0])
mn=[]
for i in range(len(nonbest3)):
mnx= ((input-nonbest3[i])\*(best\_cost-cost2[i]))/T.sum(T.sqr(input-nonbest3[i])) mn.append(mnx)
nCom=[]
for i in range(len(nonbest3)):
nComp = nonbest3[i] -0.8 \* T.sgn(mn[i])\* T.sgn(gw2[i]) \* gw2[i] - 0.1\* mn[i] nCom.append(nComp)
return yComp, nCom[0], nCom[1]
funComp = theano.function([x,y], composition(x,y), on\_unused\_input='ignore')
lossHistory1 = []
for i in range(500):
aa = ck[best\_ck\_index(D[0],D[1])] bb = [x for x in ck if x!=ck[best\_ck\_index(D[0],D[1])]] print (aa)
print (cost\_f(D[0],D[1])) lossHistory1.append(min(cost\_f(D[0],D[1]))) aa.set\_value(funComp(D[0],D[1])[0]) bb[0].set\_value(funComp(D[0],D[1])[1]) bb[1].set\_value(funComp(D[0],D[1])[2])
### **EK 2: DESA için Python Kodu (GPU destekli)**
from \_\_future\_\_ import print\_function
import os
import sys
import timeit
import numpy
import theano
import theano.tensor as T
from theano.tensor.signal import pool
from theano.tensor.nnet import conv2d
from logistic\_sgd import LogisticRegression, load\_data # url:http://deeplearning.net/tutorial/code/logistic\_sgd.py (Çevrimiçi), 15.2.2018
from mlp import HiddenLayer # url:http://deeplearning.net/tutorial/code/mlp.py (Çevrimiçi), 15.2.2018
dataset='mnist.pkl.gz'
batch\_size=500
datasets = load\_data(dataset)
```
train_set_x, train_set_y = datasets[0]
```
valid\_set\_x, valid\_set\_y = datasets[1]
test\_set\_x, test\_set\_y = datasets[2]
n\_train\_batches = train\_set\_x.get\_value(borrow=True).shape[0]
n\_valid\_batches = valid\_set\_x.get\_value(borrow=True).shape[0]
n\_test\_batches = test\_set\_x.get\_value(borrow=True).shape[0]
n\_train\_batches //= batch\_size
n\_valid\_batches //= batch\_size
n\_test\_batches //= batch\_size
index = T.lscalar()
def conv\_pool(input, filter\_shape, image\_shape, poolsize=(2, 2)):
assert image\_shape[1] == filter\_shape[1]
fan\_in = numpy.prod(filter\_shape[1:])
fan\_out = (filter\_shape[0] \* numpy.prod(filter\_shape[2:]) // numpy.prod(poolsize))
rng= numpy.random.RandomState(25)
rng2= numpy.random.RandomState(24)
rng3= numpy.random.RandomState(23)
enk = theano.shared(numpy.int64(0 ,dtype='float64'),name='w1')
W\_bound = numpy.sqrt(6. / (fan\_in + fan\_out))
w1 = theano.shared(numpy.asarray(rng.uniform(low=-W\_bound, high=W\_bound, size=filter\_shape),dtype=theano.config.floatX), borrow=True, name='w1')
w2 = theano.shared(numpy.asarray(rng2.uniform(low=-W\_bound, high=W\_bound, size=filter\_shape),dtype=theano.config.floatX), borrow=True, name='w2')
w3 = theano.shared(numpy.asarray(rng3.uniform(low=-W\_bound, high=W\_bound, size=filter\_shape),dtype=theano.config.floatX), borrow=True, name='w3')
ck = [w1,w2,w3]
conv\_pool = []
for w in ck:
conv\_out = conv2d(input=input, filters=w, filter\_shape=filter\_shape, input\_shape=image\_shape)
pooled\_out = pool.pool\_2d(input=conv\_out, ws=poolsize, ignore\_border=True)
output = T.tanh(pooled\_out)
conv\_pool.append(output)
return (conv\_pool, ck)
x = T.matrix('x')
y = T.ivector('y')
nkerns=[20, 50]
rng= numpy.random.RandomState(25)
rng2= numpy.random.RandomState(24)
rng3= numpy.random.RandomState(23)
rn = [rng, rng2, rng3]
layer0\_input = x.reshape((batch\_size, 1, 28, 28))
layer0 = conv\_pool(
input=layer0\_input,
image\_shape=(batch\_size, 1, 28, 28),
filter\_shape=(nkerns[0], 1, 5, 5),
poolsize=(2, 2))
layer1\_w1 = conv\_pool(input=layer0[0][0], filter\_shape=(nkerns[1], nkerns[0], 5, 5), image\_shape=(batch\_size, nkerns[0], 12, 12), poolsize=(2, 2))
layer1\_w2 = conv\_pool(input=layer0[0][1], filter\_shape=(nkerns[1], nkerns[0], 5, 5), image\_shape=(batch\_size, nkerns[0], 12, 12), poolsize=(2, 2))
layer1\_w3 = conv\_pool(input=layer0[0][2], filter\_shape=(nkerns[1], nkerns[0], 5, 5), image\_shape=(batch\_size, nkerns[0], 12, 12), poolsize=(2, 2))
layer1 = [layer1\_w1, layer1\_w2, layer1\_w3]
layer2\_input=[]
for i in range(len(layer1)):
aa = layer1[i][0][i].flatten(2)
layer2\_input.append(aa)
```
layer2_1 = HiddenLayer(
```
rng,
```
input=layer2_input[0],
```
n\_in=nkerns[1] \* 4 \* 4,
n\_out=500,
activation=T.tanh
)
```
layer2_2 = HiddenLayer(
rng2,
input=layer2_input[1],
n_in=nkerns[1] * 4 * 4,
n_out=500,
activation=T.tanh
)
```
```
layer2_3 = HiddenLayer(
```
rng3,
```
input=layer2_input[2],
n_in=nkerns[1] * 4 * 4,
```
n\_out=500,
```
activation=T.tanh
```
```
)
```
```
layer2 = [layer2_1, layer2_2, layer2_3]
```
layer3= []
```
layer3_params =
[theano.shared(value=numpy.zeros((500,10)),name='W',borrow=True),
```
```
theano.shared(rng2.standard_normal(size=(500, 10))),
```
```
theano.shared(rng3.standard_normal(size=(500, 10)))]
```
for lay, wi in zip(layer2, layer3\_params):
```
x_layer3 = T.nnet.softmax(T.dot(lay.output, wi))
```
```
layer3.append(x_layer3)
```
cost=[]
for i in range(3):
```
costs = -T.mean(T.log(layer3[i])[T.arange(y.shape[0]), y])
```
cost.append(costs)
enk = T.argmin(cost)
par0 = [layer0[1][0], layer0[1][1], layer0[1][2]]
```
par1 = [layer1[0][1][0], layer1[1][1][1], layer1[2][1][2]]
```
```
par2 = [layer2[0].params[0], layer2[1].params[0], layer2[2].params[0]]
```
```
par3 = [layer3_params[0], layer3_params[1], layer3_params[2]]
```
```
par0_ck=T.concatenate(par0)
```
```
par0_ck2=T.reshape(par0_ck,(3, 20, 1, 5, 5))
```
```
best0 = par0_ck2[enk]
```
non0=par0\_ck2[0:enk]
```
non02=par0_ck2[enk+1:]
```
```
xx0 = T.concatenate([non0,non02])
```
```
nonbest00 = xx0.reshape((-1,))
```
```
nonbest0 = T.reshape(nonbest00,(2, 20, 1, 5, 5))
```
```
last_nonbest0 = [nonbest0[0], nonbest0[1]]
```
```
par1_ck=T.concatenate(par1)
par1_ck2=T.reshape(par1_ck,(3, 50, 20, 5, 5))
best1 = par1_ck2[enk]
non1=par1_ck2[0:enk]
non12=par1_ck2[enk+1:]
xx1 = T.concatenate([non1,non12])
nonbest11 = xx1.reshape((-1,))
nonbest1 = T.reshape(nonbest11,(2, 50, 20, 5, 5))
last_nonbest1 = [nonbest1[0], nonbest1[1]]
```
```
par2_ck=T.concatenate(par2)
par2_ck2=T.reshape(par2_ck,(3, 800, 500))
best2 = par2_ck2[enk]
non2=par2_ck2[0:enk]
```
non22=par2\_ck2[enk+1:]
xx2 = T.concatenate([non2,non22])
nonbest22 = xx2.reshape((-1,))
nonbest2 = T.reshape(nonbest22,(2, 800, 500))
last\_nonbest2 = [nonbest2[0], nonbest2[1]]
par3\_ck=T.concatenate(par3)
par3\_ck2=T.reshape(par3\_ck,(3, 500, 10))
best3 = par3\_ck2[enk]
non3=par3\_ck2[0:enk]
non32=par3\_ck2[enk+1:]
xx3 = T.concatenate([non3,non32])
nonbest33 = xx3.reshape((-1,))
nonbest3 = T.reshape(nonbest33,(2, 500, 10))
```
last_nonbest3 = [nonbest3[0], nonbest3[1]]
```
```
bestall = [best3] + [best2] + [best1] + [best0]
nonbestall0 = [last_nonbest3[0]] + [last_nonbest2[0]] + [last_nonbest1[0]] +
[last_nonbest0[0]]
nonbestall1 = [last_nonbest3[1]] + [last_nonbest2[1]] + [last_nonbest1[1]] +
[last_nonbest0[1]]
params = [layer3_params[0]] + [layer2[0].params[0]] + [layer1[0][1][0]] +
[layer0[1][0]]
```
params1 = [layer3\_params[1]] + [layer2[1].params[0]] + [layer1[1][1][1]] + [layer0[1][1]]
params2 = [layer3\_params[2]] + [layer2[2].params[0]] + [layer1[2][1][2]] + [layer0[1][2]]
best\_layer0\_input = x.reshape((batch\_size, 1, 28, 28))
```
best_conv_out = conv2d(input= best_layer0_input, filters= best0, filter_shape=
(nkerns[0], 1, 5, 5) ,input_shape=(batch_size, 1, 28, 28))
```
```
best_pooled_out = pool.pool_2d(input=best_conv_out,ws=(2,2),ignore_border=True)
```
```
best_output = T.tanh(best_pooled_out)
```
```
best_conv_out2 = conv2d(input= best_output, filters= best1, filter_shape= (nkerns[1],
nkerns[0], 5, 5) ,input_shape=(batch_size, nkerns[0], 12, 12))
```
best\_pooled\_out2 =
```
pool.pool_2d(input=best_conv_out2,ws=(2,2),ignore_border=True)
```
```
best_output2 = T.tanh(best_pooled_out2)
```
best\_layer2\_input = best\_output2.flatten(2) best\_layer2 = T.tanh(T.dot(best\_layer2\_input, best2)) best\_layer3 = T.nnet.softmax(T.dot(best\_layer2, best3))
```
cost_best = -T.mean(T.log(best_layer3)[T.arange(y.shape[0]), y])
```
y\_pred = T.argmax(best\_layer3, axis=1)
errors = T.mean(T.neq(y\_pred, y))
```
test_model = theano.function(
[index],
errors,
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size],
y: test_set_y[index * batch_size: (index + 1) * batch_size]
}
)
```
```
validate_model = theano.function(
[index],
errors,
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
}
)
```
```
train_model_error = theano.function(
```
```
inputs=[index],
outputs=errors,
givens={
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
},
on_unused_input='ignore'
```
```
bestall = [best3] + [best2] + [best1] + [best0]
```
best\_grad = T.grad(cost\_best, bestall)
```
nonbest_layer0_input = x.reshape((batch_size, 1, 28, 28))
```
```
nonbest_layer0 = []
```
)
for i in range(2):
```
nonbest_conv_out = conv2d(input= nonbest_layer0_input, filters= last_nonbest0[i],
filter_shape= (nkerns[0], 1, 5, 5) ,input_shape=(batch_size, 1, 28, 28))
```
nonbest\_pooled\_out =
```
pool.pool_2d(input=nonbest_conv_out,ws=(2,2),ignore_border=True)
```
```
nonbest_output = T.tanh(nonbest_pooled_out)
```
```
nonbest_layer0.append(nonbest_output)
```
nonbest\_layer1 = []
for i in range(2):
nonbest\_conv\_out2 = conv2d(input= nonbest\_layer0[i], filters= last\_nonbest1[i], filter\_shape= (nkerns[1], nkerns[0], 5, 5) ,input\_shape=(batch\_size, nkerns[0], 12, 12))
```
nonbest_pooled_out2 =
pool.pool_2d(input=nonbest_conv_out2,ws=(2,2),ignore_border=True)
```
nonbest\_output2 = T.tanh(nonbest\_pooled\_out2)
```
nonbest_layer1.append(nonbest_output2)
```
```
nonbest_layer2_3 = []
```
for i in range(2):
nonbest\_layer2\_input = nonbest\_layer1[i].flatten(2) nonbest\_layer2 = T.tanh(T.dot(nonbest\_layer2\_input, last\_nonbest2[i])) nonbest\_layer3 = T.nnet.softmax(T.dot(nonbest\_layer2, last\_nonbest3[i])) nonbest\_layer2\_3.append(nonbest\_layer3)
cost\_nonbest = []
for i in range(2):
costs = -T.mean(T.log(nonbest\_layer2\_3[i])[T.arange(y.shape[0]), y])
cost\_nonbest.append(costs)
nonbestall0 = [last\_nonbest3[0]] + [last\_nonbest2[0]] + [last\_nonbest1[0]] + [last\_nonbest0[0]]
```
nonbestall1 = [last_nonbest3[1]] + [last_nonbest2[1]] + [last_nonbest1[1]] +
[last_nonbest0[1]]
```
nonbest\_all = [nonbestall0, nonbestall1]
cost\_all = [cost\_best, cost\_nonbest[0], cost\_nonbest[1]]
nonbest\_grad0 = T.grad(cost\_nonbest[0], nonbestall0)
nonbest\_grad1 = T.grad(cost\_nonbest[1], nonbestall1)
nonbest\_grad = [nonbest\_grad0, nonbest\_grad1]
mn0 = [(best-nonbest)\*(cost\_best-cost\_nonbest[0])/ T.sum(T.sqr(best-nonbest)) for best, nonbest in zip(bestall, nonbestall0)]
mn1 = [(best-nonbest)\*(cost\_best-cost\_nonbest[1])/ T.sum(T.sqr(best-nonbest)) for best, nonbest in zip(bestall, nonbestall1)]
nCom0 = [non- 0.1 \* T.sgn(mn) \* T.sgn(grad) \* grad - 0.05 \* mn for mn, grad, non in zip(mn0,nonbest\_grad0, nonbestall0 )]
nCom1 = [non- 0.1 \* T.sgn(mn) \* T.sgn(grad) \* grad - 0.05 \* mn for mn, grad, non in zip(mn1,nonbest\_grad1, nonbestall1 )]
cast\_nCom0 = [T.cast(ncom, 'float32') for ncom in nCom0] cast\_nCom1 = [T.cast(ncom, 'float32') for ncom in nCom1]
xbest = [ -0.1 \* nc + non for nc, non in zip(best\_grad, bestall)]
```
updates = [
```
```
(param_i, param_i - param_i + best_i)
for param_i, best_i in zip(params, xbest)
```
```
]
```
updates.extend(
[(param\_i, param\_i - param\_i + ncom\_i)
for param\_i, ncom\_i in zip(params1, cast\_nCom0)]
```
)
```
updates.extend(
[(param\_i, param\_i - param\_i + ncom\_i)
for param\_i, ncom\_i in zip(params2, cast\_nCom1)]
```
)
```
shape\_f = theano.function(
[index],
[nonbestall0[3].shape, nonbestall1[3].shape, bestall[3].shape,nonbestall0[2].shape, nonbestall1[2].shape, bestall[2].shape, nonbestall0[1].shape, nonbestall1[1].shape, bestall[1].shape, nonbestall0[0].shape, nonbestall1[0].shape, bestall[0].shape, params[0].shape, params[1].shape, params[2].shape, params[3].shape ],
givens={
```
x: train_set_x[index * batch_size: (index + 1) * batch_size],
```
```
y: train_set_y[index * batch_size: (index + 1) * batch_size]
```
}, on\_unused\_input='ignore')
```
train_f = theano.function(
```
[index],
[cost\_best, cost\_nonbest[0], cost\_nonbest[1], enk],
updates = updates,
givens={
```
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
```
}, on\_unused\_input='ignore')
```
print('... training')
n_epochs = 100
patience = 10000
patience_increase = 2
improvement_threshold = 0.995
validation_frequency = min(n_train_batches, patience // 2)
best_validation_loss = numpy.inf
best_iter = 0
test_score = 0.
start_time = timeit.default_timer()
epoch = 0
done_looping = False
evgo_train_cost=[]
skipHistory1 = []
val_lossHistory1 = []
test_lossHistory1 = []
train_lossHistory1= []
test_lossHistory2=[]
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in range(n_train_batches):
```
iter = (epoch - 1) \* n\_train\_batches + minibatch\_index
if iter % 100 == 0:
print('training @ iter = ', iter) train\_modelx = train\_f(minibatch\_index) cost\_ij = min(train\_modelx[0], train\_modelx[1], train\_modelx[2]) evgo\_train\_cost.append(cost\_ij) skipHistory1.append(train\_modelx[3])
if (iter + 1) % validation\_frequency == 0:
```
# compute zero-one loss on validation set
validation_losses = [validate_model(i) for i
in range(n_valid_batches)]
train_losses = [train_model_error(i)
```
for i in range(n\_train\_batches)]
test\_losses = [test\_model(i)
for i in range(n\_test\_batches)]
this\_validation\_loss = numpy.mean(validation\_losses) this\_validation\_loss2 = numpy.mean(train\_losses) this\_validation\_loss3 = numpy.mean(test\_losses)
val\_lossHistory1.append(this\_validation\_loss) train\_lossHistory1.append(this\_validation\_loss2 \* 100.) test\_lossHistory2.append(this\_validation\_loss3\* 100.)
print('epoch %i, minibatch %i/%i, validation error %f %%' % (epoch, minibatch\_index + 1, n\_train\_batches, this\_validation\_loss \* 100.))
if this\_validation\_loss < best\_validation\_loss:
if this\_validation\_loss < best\_validation\_loss \* \ improvement\_threshold: patience = max(patience, iter \* patience\_increase)
best\_validation\_loss = this\_validation\_loss best\_iter = iter
test\_losses = [ test\_model(i) for i in range(n\_test\_batches) ] test\_score = numpy.mean(test\_losses) test\_lossHistory1.append(test\_score) print((' epoch %i, minibatch %i/%i, test error of ' 'best model %f %%') % (epoch, minibatch\_index + 1, n\_train\_batches, test\_score \* 100.))
if patience <= iter: done\_looping = True break
end\_time = timeit.default\_timer()
### **ÖZGEÇMİŞ**
<span id="page-113-0"></span>Temmuz 1987' de İstanbul' da doğan yazar ilk ve orta öğretimini İstanbul' da tamamlamıştır. 2008 yılında Atatürk Üniversitesi, Fen Fakültesi, Matematik Bölümü'nü bitirmiştir. 2012 yılında Gaziantep-Kilis 7 Aralık Üniversitesi, Fen Bilimleri Enstitüsü, ortak dereceli Matematik programına başlamış ve 2014 yılında mezun olmuştur. Aynı sene İstanbul Üniversitesi, Sosyal Bilimler Enstitüsü, İşletme Anabilim Dalı, Sayısal Yöntemler Bilim Dalı' nda doktora eğitimine başlamıştır.
2011 – 2014 yılları arasında Kilis 7 Aralık Üniversitesi, Fen-Edebiyat Fakültesi, Matematik Bölümü' nde araştırma görevlisi olarak çalışmıştır. 2014 yılından beri, Kırklareli Üniversitesi, İktisadi ve İdari Bilimler Fakültesi, Ekonometri Bölümü' nde araştırma görevlisi olarak çalışmaktadır. Çeşitli uluslararası dergilerde yayınlanmış makaleleri bulunan yazar evli ve bir çocuk babasıdır.
|
/content/drive/MyDrive/pdf_folder/511459.pdf
| 85
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 86
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 87
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 88
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 89
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 90
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 91
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 92
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 93
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 94
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 95
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 96
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 97
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 98
| null |
/content/drive/MyDrive/pdf_folder/511459.pdf
| 99
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.