Yapay Sinir Ağlarına Giriş

Eğim Inis

Gerçek değer \(y\) ile tahminimiz \(h_\theta(x)\) arasındaki hatayı minimuma indirecek \(\theta^*\) değerini arıyoruz. Yapay öğrenme, en iyi \(\theta^*\) değerini öğrenmekten ibarettir. Hata fonksiyonu \[ Hata(\theta) = \frac{1}{2} (y - h_\theta(x))^2 \]

Hatayi minimuma indirecek parametre değerlerini, eğim iniş yöntemi ile bulacağız. \(Hata(\theta)\) fonksiyonun minimum noktasini

\[ \theta_i = \theta_i - \alpha \frac{d Hata(\theta)}{d\theta_i} \]

Bu \(\theta\) değerlerini nasıl güncelleyeceğimizi söyler. Türevin aksi yönde \(\alpha\) adım büyüklüğü ile orantılı olarak yol al. Basitten başlamak için, hata fonksiyonumuzun

\[ Hata(\theta) = \theta^2 + 5 \] olduğunu düşünelim. Bakalım eğim iniş yöntemi bu hata fonksiyonun minimum noktasını bula bilecek mi?

##########################################################
# Basit bir f fonksiyonun minimum noktasini bulalim
# f fonksiyonunu hata fonksiyonu gibi dusunelim
theta = -100:100
f <- function(theta){theta^2 + 5}
f.turev <- function(theta){2*theta}
guncelleme = 20 # guncelleme sayisi
basla = 94
##########################################################
dereceli.inis <- function(theta = basla, alpha = 0.025, dongu = guncelleme){
  th = rep(theta, dongu)
  for(i in 2:dongu){
    theta <- theta - alpha * f.turev(theta)
    th[i] = theta
  }
  return(th)
}
##########################################################
inis = dereceli.inis()
plot(theta,f(theta), type = 'l')
lines(inis, f(inis), type = 'o', col = "blue")

grid()

20 guncelleme sayisi ve \(\alpha = 0.025\) adım büyüklüğü ile hedefe ulaşamadık. Adım büyüklüğümüzü arttıralım.

##########################################################
inis = dereceli.inis(alpha = 0.05)
plot(theta,f(theta), type = 'l')
lines(inis, f(inis), type = 'o', col = "orange")

grid()

Az kaldı, biraz daha arttıtralım.

##########################################################
inis = dereceli.inis(alpha = 0.1)
plot(theta,f(theta), type = 'l')
lines(inis, f(inis), type = 'o', col = "red")

grid()

Şimdi oldu. Peki neden daha büyük adımlarla gitmeyelim? \(alpha = 1\) olursa ne olur mesela?

Iris Verisi

Şimdi çiçeklere ait bir veriyi inceleyeceğiz. Botanik bilmesek de yapay zeka tekniklerini biliyoruz.

################################################
# Veri hazirligi : Uc tur Cicek verisi yerine 2 tip cicek verisi ile calısacagiz
# Siniflandirma: 
#         Cicek "virginica" mi "setosa" mi?
#         x1 : 1
#         x2 : sepal-length (canak yaprak uzunlugu),
#         x3 : petal-length (tac yaprak uzunlugu), 
#         ozelliklerine bakarak  karar verecegiz
################################################
data_df <- as.data.frame(iris)
# iki tur cicekle ilgilenelim
tur <- data_df$Species %in% c("virginica", "setosa")
data_df <- data_df[tur,]
# 1: "virginica" ve 0: "setosa" olsun
y <- ifelse(data_df$Species=="virginica", 1, 0)
# 4 boyut (ozellik) yerine 2 boyut ozellik ile ilgilenelim => cizim kolayligi 
X <- data_df[c(1,3)]
X <- as.matrix(X/max(X))
# theta0 icin ilk kolon 1 yapildi
X = cbind(rep(1, length(y)), X)
# Verimizin ilk 6 degerlerine goz atalim
head(X)

    Sepal.Length Petal.Length
1 1    0.6455696    0.1772152
2 1    0.6202532    0.1772152
3 1    0.5949367    0.1645570
4 1    0.5822785    0.1898734
5 1    0.6329114    0.1772152
6 1    0.6835443    0.2151899

plot(X[,2], X[,3],col = y + 1,
     xlab = "Canak (sepal) yaprak uzunlugu",
     ylab = "Tac (petal) yaprak uzunlugu")
grid()

Modelimizi Oluşturalım

Bir yapay sinir hücresi, kendisine gelen uyarıları (\(x_1, x_2, x_3\)) önem dereceleri (\(\theta_1, \theta_2, \theta_3\)) ile çarpararak ağırlıklı bir toplam oluşturur.

\[z = \theta \cdot x = \theta_1 x_1 + \theta_2 x_2 + \theta_3 x_3\]

Şimdi bu toplam girdiden sigmoid fonksiyonunu kullanarak tahminimizi oluşturacağız.

\[h_\theta(x) = \sigma (z) = \frac{1}{1 + e^{-z}}\]

Amacımız hipotezimiz \(h_\theta\) ile gerçek çıktı olan \(y\) arasındaki farkı en az indirecek \(\theta_0\), \(\theta_1\), \(\theta_2\) değerlerini bulmaktır. Şimdi tek bir örnek üzerinden yapılan hataya bir göz atalım

\[ Hata(\theta) = \frac{1}{2}(y - h_\theta(x))^2 \]

Hatayı minimize etmek için eğim iniş yöntemini kullanacağız. Hatanın türevini hesaplamamız gerekiyor. \[ \frac{d Hata(\theta)}{d\theta_i} = \frac{d Hata(\theta)}{dh_\theta(x)} \times \frac{d h_\theta(x)}{d\theta_i} = - (y - h_\theta(x)) \frac{d h_\theta(x)}{d\theta_i} \]

Demek ki, zincir kuralı gereği hipotezimin türevini hesaplamamız gerekiyor.

\[\begin{equation} \begin{split} \frac{d h_\theta(x)}{d\theta_i} &=& \frac{d \sigma (z)}{d\theta_i} \\ &=& \frac{d \sigma (z)}{dz} \frac{d z}{d\theta_i}\\ &=& \sigma (z) (1 - \sigma (z)) \frac{d z}{d\theta_i}\\ &=& \sigma (z) (1 - \sigma (z)) \frac{d (\theta_1 x_1 + \theta_2 x_2 + \theta_3 x_3)}{d\theta_i}\\ &=& \sigma (z) (1 - \sigma (z)) x_i\\ &=& h_\theta(x) (1 - h_\theta(x)) x_i\\ \end{split} \end{equation}\]

Tüm bu matematiksel denklemleri bir araya getirip, hatamızın türevini hesaplayalım

\[ \frac{d Hata(\theta)}{d\theta_i} = (h_\theta(x) - y) h_\theta(x) (1 - h_\theta(x)) x_i \] Dereceli İniş

Hata fonksiyonun minimum noktasını elde etmek için adım adım aşağıdaki gibi ilerleyeceğiz.

\[ \theta_i = \theta_i - \alpha \frac{d Hata(\theta)}{d\theta_i} \] Sigmoid fonksiyonun dünya gözüyle bir görelim.

sigmoid <- function(z){
  return (1 / (1 + exp(-z)))
}
z = -10:10
plot(z, sigmoid(z), type="b")

Aşağıda i.inci gözlem için hatanın nasıl elde edildiğini matris ve vektör bakışıyla inceleyelim.

############################################################
# X gozlem verilerini tutan matristir
egim.inis <- function(X = X, y = y, th, adim = 0.5){
  z = X %*% th                          # gozlem verisini theta ile carpıyoruz 
  h = sigmoid(z)                        # sigmoid ile tahmın yapıyoruz
  hata = 0.5 * sum((y - h) *  (y - h))  # Toplam Hata: Tahmin ve gercek y arasındaki fark
  
  # Tum thetalar sadece BIR KEZ guncelleniyor
  for(i in 1:length(th)){
    gradyan = sum((h-y) * h * (1-h) * X[,i]) # Butun hatalarin toplami, Dikkat: h, y ve X[,i] ler ayni boyda
    th[i] = th[i] - adim * gradyan
  }
  # Thetalar ve tehmın hatasi geri donuyor
  return(list(th = th , hata = hata))
}

# ilk theta degerlerı 0 olsun
th <- rep(0,ncol(X))
# 
simulasyon = egim.inis(X, y , th)
th = simulasyon$th
print(simulasyon)

$th
[1] 0.0000000 0.6257911 1.6178797

$hata
[1] 12.5

Büyük bir hata var. Ama parametrelerimizi güncellemeyi sürdürürsek eğimli iniş bizi en iyi parametrelere götürecektir.

simulasyon = egim.inis(X, y , th)
th = simulasyon$th
print(simulasyon)

$th
[1] -3.151160 -1.270309  1.310737

$hata
[1] 11.79086

for(i in 1:10000){
  simulasyon = egim.inis(X, y , th, adim = 0.5)
  th = simulasyon$th
}
print(simulasyon)

$th
[1] -10.1470785   0.5655115  23.4601114

$hata
[1] 0.001531893

\(\theta_1 x_1 + \theta_2 x_2 + \theta_3 x_3 = 0\) ve \(x_1 = 1\) olduğuna göre

\[ x_3 = - \frac{\theta_2}{\theta_3}x_2 - \frac{\theta_1}{\theta_3} \]

model = (-th[2] * X[,2]) / th[3] - th[1] / th[3]
plot(X[,2], X[,3],col = y + 1,
     xlab = "Canak (sepal) yaprak uzunlugu",
     ylab = "Tac (petal) yaprak uzunlugu")
lines(X[,2],model)

grid()

Sentetik Veri

Dogrusal Sınıflandırma yöntemini kullanarak, sentetik bir veriyi iki sınıfa ayıralım.

n = 50
merkez1 = 5
kume1.x1 = rnorm(n, mean = merkez1, sd=3)
kume1.x2  = rnorm(n, mean = merkez1, sd=3)
kume1.y = rep(0,n)
merkez2 = 20
kume2.x1 = rnorm(n, mean = merkez2, sd=3)
kume2.x2  = rnorm(n, mean = merkez2, sd=3)
kume2.y = rep(0,n)
plot(kume1.x1,kume1.x2,col= "red", type = "p", xlim = c(0,30), ylim = c(0,30))
lines(kume2.x1,kume2.x2,col= "green", type = "p")

grid()

VX = cbind(rep(1,2*n),
          c(kume1.x1, kume2.x1),
          c(kume1.x2, kume2.x2))
Vy = c(rep(0,n),rep(1,n))
  
th = c(0,0,0)
for(i in 1:10000){
  simulasyon = egim.inis(VX, Vy , th, adim = 0.005)
  th = simulasyon$th
}
print(simulasyon)

$th
[1] -8.2541734  0.1781334  0.4628224

$hata
[1] 0.06215666

plot(VX[,2], VX[,3], col = Vy + 2, xlim = c(0,30), ylim = c(0,30))
model = (-th[2] * VX[,2]) / th[3] - th[1] / th[3]
lines(VX[,2],model)

grid()

Dikkat ederseniz yeni hiç bir kod yazmadık, önce bir botanikçi gibi çiçekleri birbirinden ayırdık sonra rastgele üretilmiş iki sınıf verisini birbirinden ayırdık. Gene hiçbir kod yazmadan eğer bize gerekli gözlem verisi verilirse, bir doktor gibi hasta-hasta değil ya da bir güvenlik uzmanı gibi spam-spam değil, ya da bir ekonomist gibi krediye uygun-krediye uygun değil, hatta bir siyasetçi gibi oy verir-oy vermez gibi ayrımları yapabiliriz.

Buradaki muhteşem gücün farkında mısınız?

Sadece basit bir yapay öğrenme aracını öğrendik ve bir doktor, bir ekonomist ya da bir siyasetçi gibi çalışma yapabilir hale geldik.

İşte bu yüzden gelecekte yapay zekayı kullanma dışında bir mesleğe hiç gerek kalmayabilir.

YSA Baslangıç

# Yeni bir veri kumesi ekleyelim
merkez3 = 35
kume3.x1 = rnorm(n, mean = merkez3, sd=3)
kume3.x2  = rnorm(n, mean = merkez3, sd=3)
kume3.y = rep(0,n)
VX = rbind(VX, cbind(rep(1,n),
          c(kume3.x1, kume3.x1),
          c(kume3.x2, kume3.x2)))
Vy = c(Vy, rep(0,n))
plot(VX[,2], VX[,3], col = Vy + 2, xlim = c(0,50), ylim = c(0,50))
grid()

Buradaki yeşil tip veriyi, kırmızı tip veriden ayırmak tek bir doğru ile mümkün değil.

Netlogo ile Oyun Programlama

extensions [sound]
breed [oyuncular oyuncu]          ;; iki oyuncu
breed [toplar top]                ;; bir top
toplar-own[hiz carpma-mesafesi]   ;; topun hizi ve carpma-mesafesi gibi ozellikleri var


to setup
  ca
  create-oyuncular 2 [
    set shape "face happy"        ;; baslangicta herkes mutlu
    set size 3
    set color blue
    ses
  ]
  create-toplar 1 [
    set shape "dot"
    set color red
    set size 2
    set heading (- 135)           ;; topun yonu
    set hiz 0.00005               ;; topun hizi
    set carpma-mesafesi 2         ;; topun mesafesi
  ]
  ask oyuncu 0 [setxy -20 0]      ;; oyuncu 0in konumu
  ask oyuncu 1 [setxy 20 0]       ;; oyuncu 1in konumu
  ask patches with [pxcor = [xcor] of oyuncu 0 or pxcor = [xcor] of oyuncu 1] [set pcolor white]
  ;; oyuncularin oldugu yerde dikey beyaz cizgi
end


to go
  oyna                           ;; top hareket ediyor
  carpma-kontrol                 ;; top bir yere carpti mi? kontrol et.
  if (kazan = true) [            ;; Oyunculardan biri kazandiysa ses cikar
    ses                              ;; ses cikar
    wait 2
    ses
    reset-oyuncular
    ask top 2 [
      setxy 0 0                      ;; topu ortaya al
      set heading random 360         ;; rtestgele yon ata
    ]
  ]
end



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Kim kazandi
to-report kazan
  if( [xcor] of top 2 < [xcor] of oyuncu 0)[
    ;;ask top 2 [set hiz 0]
    ask oyuncu 0 [
      set shape "face sad"
      set label "kaybettin"
      set color violet
    ]
    report true
  ]
  if( [xcor] of top 2 > [xcor] of oyuncu 1)[
    ;;ask top 2 [set hiz 0]
    ask oyuncu 1 [
      set shape "face sad"
      set label "kaybettin"
      set color violet
    ]
    report true
  ]
  report false
end


to reset-oyuncular
  ask oyuncular [
    set shape "face happy"        ;; baslangicta herkes mutlu
    set label ""
    set color blue
  ]
end


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Top Hareketi
to oyna
  ask top 2 [fd hiz]
end

to carpma-kontrol
  carpma-oyuncu0
  carpma-yatay-duvar
  carpma-dikey-duvar
end

to carpma-oyuncu0
  ask top 2 [
    if (distance oyuncu 0 < carpma-mesafesi) [     ;; topun oyuncu 0a mesafesi 2den az ise,
      show "oyuncu0a fazla yakin"
      set heading ( 360 - heading)   ;; topun geri yansir

      while [distance oyuncu 0 < carpma-mesafesi][fd hiz]
    ]
  ]
end

to carpma-yatay-duvar
  let y [ycor] of top 2
  ask top 2 [
    if (abs(y) > (abs(min-pycor) - 0.1)) [     ;; topun oyuncu 0a mesafesi 2den az ise,
      show "yatay duvara fazla yakin"
      set heading ( 180 - heading)   ;; topun geri yansir
    ]
  ]
end

to carpma-dikey-duvar
  let x [xcor] of top 2
  ask top 2 [
    if (abs(x) > (abs(min-pxcor) - 0.1)) [     ;; topun oyuncu 0a mesafesi 2den az ise,
      show "dikey duvara fazla yakin"
      set heading ( 360 - heading)   ;; topun geri yansir
    ]
  ]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Oyuncu Kontrol
to yukari
  let y [ycor] of oyuncu 0
  let x [xcor] of oyuncu 0
  ask oyuncu 0 [
    if(abs(y + 1) < abs(min-pycor)) [setxy x (y + 1)]
  ]
end

to asagi
  let y [ycor] of oyuncu 0
  let x [xcor] of oyuncu 0
  ask oyuncu 0 [
    if(abs(y - 1) < abs(min-pycor)) [setxy x (y - 1)]
  ]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Top Hareketi
to ses
  sound:play-drum "ACOUSTIC SNARE" 64
end

Python ile Programlamaya Giris

Netlogo ve R dillerinde daha önce gördüğümüz, veri tipleri, fonksiyonlar, kontrol yapıları ve döndüler pythın dilinin de temellerini oluşturur.

# Liste
L = [1, [1,2], 3]
print(L)
print(L[0])
print(L[1])
# Listenin uzunlugu
print(len(L))

[1, [1, 2], 3]
1
[1, 2]
3

a, b = 1, 8
a, b = b, a
print(a," ",b)

(8, ' ', 1)

# Fonksiyon
def degis(a,b):
    a, b = b, a
    return a, b

x, y = 3, 4
print("x, y = ", degis(x,y))

('x, y = ', (4, 3))

x, y = 3, 4
# Kontol
if(x > y):
    print(x, ",", y, "den buyuk")
else:
    print(y, ",", x, "den buyuk")

(4, ',', 3, 'den buyuk')

def kategori(yas):
    if yas<=18:
        durum="cocuk"
    elif yas>65:
        durum="emekli"
    else:
        durum="normal"
    return durum

print(kategori(15))

cocuk

Say = [1,2,3,4,5,6,7]
for i in Say:  
    print(i**2)   

1
4
9
16
25
36
49

# range([bas,] son [,adim]) : bas varsayilan degeri 0, adim varsayilan degeri 1
for i in range(4,10,2):
    print(i)

4
6
8

# Sozlukler
DB = {
    "uzay" : {"Star Wars": 4.5, "Superman": 3.5,"Batman": 4,},
    "selin" : {"Venedik": 4.5, "Paris": 3.5,"Batman": 4,},
    "fatih" : {"Superman": 4,"Batman": 4},
}
print("\nUzay Begenileri: ", DB['uzay'])
print("Uzayin Star Wars filmine verdigi puan: ", DB['uzay']['Star Wars'])

('\nUzay Begenileri: ', {'Star Wars': 4.5, 'Batman': 4, 'Superman': 3.5})
('Uzayin Star Wars filmine verdigi puan: ', 4.5)

# Sozlukler
DB = {
    "uzay" : {"Star Wars": 4.5, "Superman": 3.5,"Batman": 4,},
    "selin" : {"Venedik": 4.5, "Paris": 3.5,"Batman": 4,},
    "fatih" : {"Superman": 4,"Batman": 4},
}
# Yeni deger ekleme
DB.setdefault("Umut", {"Maymunlar Cehennemi": 4, "Babam ve Oglum": 3})
print(DB)
print("\n\n")
for k in DB.keys():  
    print(k)  

{'selin': {'Paris': 3.5, 'Batman': 4, 'Venedik': 4.5}, 'Umut': {'Maymunlar Cehennemi': 4, 'Babam ve Oglum': 3}, 'fatih': {'Batman': 4, 'Superman': 4}, 'uzay': {'Star Wars': 4.5, 'Batman': 4, 'Superman': 3.5}}



selin
Umut
fatih
uzay

# Sozlukler
DB = {
    "uzay" : {"Star Wars": 4.5, "Superman": 3.5,"Batman": 4,},
    "selin" : {"Venedik": 4.5, "Paris": 3.5,"Batman": 4,},
    "fatih" : {"Superman": 4,"Batman": 4},
}
# Yeni deger ekleme
DB.setdefault("Umut", {"Maymunlar Cehennemi": 4, "Babam ve Oglum": 3})

for deger in DB.values():  
    print(deger)

{'Paris': 3.5, 'Batman': 4, 'Venedik': 4.5}
{'Maymunlar Cehennemi': 4, 'Babam ve Oglum': 3}
{'Batman': 4, 'Superman': 4}
{'Star Wars': 4.5, 'Batman': 4, 'Superman': 3.5}

# Ileri Liste Islemler
print([x*5 for x in range(5)])
print([x for x in range(5) if x%2 == 0])

[0, 5, 10, 15, 20]
[0, 2, 4]

import numpy as np
liste = np.array(range(5))
print(liste)

[0 1 2 3 4]

import numpy as np
liste = np.array(range(5))
liste = liste * liste
print(liste)

import math
for i in liste:
    print(math.sqrt(i))

[ 0  1  4  9 16]
0.0
1.0
2.0
3.0
4.0

import numpy as np
liste = np.array([0, 1,  4,  9, 16])
print(len(liste))
print("liste[liste > 5]: ", liste[liste > 5])

liste = np.append(liste, [25,36,49])
print(liste)

liste = liste - 16
liste[liste>0] = 1
liste[liste<0] = -1
print(liste)

liste2 = np.zeros(8)
liste2[5:] = -1
print(liste2)
print(liste + liste2)

5
('liste[liste > 5]: ', array([ 9, 16]))
[ 0  1  4  9 16 25 36 49]
[-1 -1 -1 -1  0  1  1  1]
[ 0.  0.  0.  0.  0. -1. -1. -1.]
[-1. -1. -1. -1.  0.  0.  0.  0.]

Daha fazlasi icin python ve numpy kodlari: https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf