Bir önceki bölümde Makine Öğrenmesinde hipotez, parametreler, öğrenme algoritması, maliyet fonksiyonu ve amaç kavramlarından bahsetmiştik. Kare hata fonksiyonunu maliyet fonksiyonumuzda kullanarak, lineer regresyon problemimizin hipotezini hesaplamıştık. Hatırlamak isterseniz:

Kaldığımız yerden devam edelim.  Hipotezimizin basitleştirmeden önceki haline bir bakalım.

sss

Hatırlarsanız, Makine Öğrenmesinde asıl yapmak istediğimiz, amacımız, verilere en uygun eğriyi bulmaktır. Verilerin bir dağılım grafiğini çizdiğimizde, veriler eğer düz bir çizgiye düşüyorsa, yukarıdaki hipotezi kullanabiliriz, çünkü hipotez fonksiyonumuz düz bir çizgiyi tanımlar, doğru denklemidir. Bunu biraz daha net anlayalım. tetas.png değerlerini değiştirerek düzlem üzerine çizebileceğimiz sonsuz sayıda düz çizgi vardır. Ancak, dağılım grafiğimizde verilerin konumuna baktığımızda, verilerimize en iyi uyabilecek yalnızca bir düz çizgi vardır ve şimdi yapmak istediğimiz bu en iyi uyan çizgiyi çizebilmektir.

Maliyet fonksiyonu (J) bizim istediğimiz bu amaca algoritmik olarak hizmet eder. Eğer tetas.png parametrelerinin doğru hipotezden çok uzakta olduğunu bulursak bize çok büyük bir maliyet verir. Ancak, doğru bir hipotezin maliyeti çok düşüktür. Bunu genelde, tetas.png ‘ların maliyet fonksiyonunu en aza indirgeyerek yaparız.

Şimdi konuyu biraz daha rahat anlayabilmek için elimizdeki veri setine bir göz atalım.

Evin Büyüklüğü (metrekare)

Evin Fiyatı (TL)

100

150000

130

155000

170

200000

200

206000

235

340000

245

225000

280

250000

300

350000

345

250000

350

370000

400

450000

420

380000

450

560000

460

500000

500

550000

540

580000

540

660000

600

650000

Dağılım grafiğinde verilerimizi incelersek:veriler.png

dogru1.png Eğer tetaları 800, 6000 olarak seçseydik, hipotezimiz şöyle olacaktı, hipotez_yanlis.png

Bu hipotezin doğrusu da yandaki gibi olacaktı. Rastgele seçtiğimiz teta değerlerinin verilerimize mükemmel uymadığını görüyoruz.

Bunları zaten biliyoruz ancak sık sık tekrar etmenin bir sakıncası yok, tekrar hatırlamak gerekirse, hipotez (h) öğrenmeye çalıştığımız modeldir. Hipotez fonksiyonunu “öğrenmek” için θ’ları bulmamız gerekir.

Hatırlarsanız tek bir teta ile gerçekleştirdiğimiz bir önceki örnekte maliyet fonksiyonu ile teta arasında şöyle bir ilişki olduğunu görmüştük:iliski_grap2

Ancak şu an elimizde iki tane parametre var, tetas.png ve tahmin edersiniz ki bunların maliyet fonksiyonu ile aralarındaki ilişki tek bir parametreye sahip hipotezdeki gibi basit olmayacaktır. Burada daha rahat görselleştirebilmemiz için devreye kontur grafikleri giriyor. Kontur grafiğini bir önceki grafiğin üç boyutlu hali gibi düşünebilirsiniz. Tabi bu grafiği isterseniz iki boyutlu uzayda da temsil edebilirsiniz.Aşağıda bu grafiğe ait örnekler yer alıyor.

Bundan sonra yapacaklarımızı daha iyi anlamak için aşağıdaki görseli dikkatlice inceleyin.

stochastic gradient descent vs batch ile ilgili görsel sonucu

Şimdi yukarıdaki görseli birlikte yorumlayalım.

  • Sağ tarafta kontur grafiğinin iki boyutlu düzlemde temsili verilmiş. Ortaya doğru giderek küçülen halkaya doğru baktığımızda tetas.png değerleri ile hesaplanan maliyet fonksiyonunun değerinin 0’a doğru yaklaştığını görüyoruz.
  • Maliyet fonksiyonunun sıfıra yaklaşması bize en iyi hipotezi verecektir. En iyi hipotez ise veri setimize uyan en iyi eğriyi verir.
  • Sağ tarafta tetas.png değerlerini kırmızı ile seçiyor ve sıfıra doğru yaklaştırıyor.
  • Bu sırada sol tarafta verilen verilerimizin dağılım grafiğine baktığımızda,
  • Seçilen tetalara göre hesaplanan hipotezin, maliyet fonksiyonunu minimize ettiğimiz anda verilere en iyi uyum sağladığını görebiliyoruz.

Bundan sonra ne yapacağımızı kısaca anlamışsınızdır. Amaç bir önceki örnekte olduğu gibi ve az önceki görselde gözüktüğü gibi maliyet fonksiyonumuzu minimize eden en iyi tetas.png değerlerini seçerek hipotezimizi oluşturacağız.

Burada Dereceli Azalma’yı kullanacağız. Dereceli azalmanın o meşhur karışık tanımlamalarından önce basitçe anlamaya çalışalım.

Gradient Descent ya da türkçe olarak Dereceli Azalma aslında bir algoritmadır. Sadece makine öğrenmesi problemlerinde değil, bir çok optimizasyon probleminde de kullanılır. Bizim makine öğrenmesinde kullanmamızın da aslında en temel sebebi optimizasyondur. Sanırım artık ezberlediniz ancak maliyet fonksiyonunu en aza indirmek de bir optimizasyon problemidir.

  • Dereceli Azalma Algoritması : Bir fonksiyonun minimumunu bulmamızı sağlar. Fonksiyonun minimumunu bulmak için birinci dereceden yinelemeli bir optimizasyon algoritmasıdır.

Biz dereceli azalmayı maliyet fonksiyonunu en aza indirgemek için bize gereken  tetas.pngdeğerlerini bulmak için kullanacağız.

  • Dereceli azalmada kullanacağımız fonksiyon : jteta.png
  • Amacımız : minjteta.png

Dereceli Azalma Algoritmasının Basitçe Çalışma Şekli:

  1. tetas.png‘lara Herhangi Bir Değer Verin ( teta değerlerine başlangıç değeri olarak 0 verebiliriz. )
  2. jteta.png değerini minimuma indirgeyene kadar tetas.pngdeğerlerini değiştirin.

Aşağıda maliyet fonksiyonunun kontur grafiğine baktığımızda iki ayrı minimum noktası görüyoruz. Başlangıç noktası seçtiğimiz yere göre farklı minimumlara gittiğine dikkat edin.

gradyan2li.png

Dereceli Azalmanın algoritmasına bakalım.

yakinsayanakadar.png

Bildiklerimizden başlayalım. jteta.png fonksiyonunun maliyet fonksiyonu olduğunu biliyoruz.tetaj.pngnin de sırayla j=0 ve j=1 için tetas.png değerlerini bize vereceğini biliyoruz.

  • alfa.png : Öğrenme Oranı ( bir katsayı )
  • turev.png : Maliyet Fonksiyonunun türevi
  • tetaj.png = tetas.png :  Parametreler (tetalar)
  • simulupdate :  eşzamanlı olarak güncellemek (tetas.png‘ları)

Eşzamanlı Olarak Tetaları güncellemek şu demek:

dogru_atama.png

Yani, önce tetaları bulacağız, sonra teta değişkenine atayacağız. Fark ettiyseniz, maliyet fonksiyonunun türevini aldığımız kısımda her iki tetayı da kullanıyoruz. Önceteta0‘ı bulupteta0‘a atarsak bir sonraki adımda teta1.png‘i hesaplarken kullanacağımızteta0 değerini değiştirmiş olduğumuz halde görürüz.

Yanlış Şekilde Tetaları Güncellemek de aşağıdaki şekilde olur:

yanlis_atama.png

Şimdi öğrenme oranından,alfa.png biraz bahsedelim.

  • Öğrenme oranı, zamanın azalan bir fonksiyonudur. Bu parametre, optimum ağırlığa doğru ne kadar hızlı veya yavaş hareket edeceğimizi belirler. 
  • alfa.png çok büyükse optimal çözümü atlayacağız. Çok küçükse, en iyi değerleri birleştirmek için çok fazla yinelemeye ihtiyacımız olacaktır. Bu yüzden iyi biralfa.png kullanmak çok önemlidir.

Görerek daha iyi anlarız. O yüzden dereceli azalma ile öğrenme oranı arasındaki ilişkiye bakalım. Sol tarafta alfayı çok küçük seçersek, sağ tarafta da alfayı çok büyük seçersek maliyeti nasıl minimize ettiğimize bakın.

Dereceli azalma(Gradyan inişi), öğrenme oranı α sabit olsa bile, yerel bir minimuma yaklaşabilir.  Yerel bir minimuma yaklaştığımızda dereceli azalma otomatik olarak daha küçük adımlar atacaktır. Yani, zamanla α’nın azaltılmasına gerek yoktur. Yerel minimuma yaklaştıkça aslında grafiğimiz şöyle olacaktır:gercek_dereceli_azalma.png

Lineer Regresyonun amacı maliyet fonksiyonunu en aza indirmektir.

j_teta

Hipotezi şöyle yazabiliriz:

h_x.png

Buradan sonra matematik işlemlerini yazdığımız program ile gerçekleştireceğiz.

Programımızda AndrewNG’nin hazırladığı Coursera’daki Machine Learning dersindeki  ex1data1.txt veri setini kullanarak yararlanacağız.

veriseti, ex1data1.txt

6.1101,17.592
5.5277,9.1302
8.5186,13.662
7.0032,11.854
5.8598,6.8233
8.3829,11.886
7.4764,4.3483
8.5781,12
6.4862,6.5987
5.0546,3.8166
5.7107,3.2522
14.164,15.505
5.734,3.1551
8.4084,7.2258
5.6407,0.71618
5.3794,3.5129
6.3654,5.3048
5.1301,0.56077
6.4296,3.6518
7.0708,5.3893
6.1891,3.1386
20.27,21.767
5.4901,4.263
6.3261,5.1875
5.5649,3.0825
18.945,22.638
12.828,13.501
10.957,7.0467
13.176,14.692
22.203,24.147
5.2524,-1.22
6.5894,5.9966
9.2482,12.134
5.8918,1.8495
8.2111,6.5426
7.9334,4.5623
8.0959,4.1164
5.6063,3.3928
12.836,10.117
6.3534,5.4974
5.4069,0.55657
6.8825,3.9115
11.708,5.3854
5.7737,2.4406
7.8247,6.7318
7.0931,1.0463
5.0702,5.1337
5.8014,1.844
11.7,8.0043
5.5416,1.0179
7.5402,6.7504
5.3077,1.8396
7.4239,4.2885
7.6031,4.9981
6.3328,1.4233
6.3589,-1.4211
6.2742,2.4756
5.6397,4.6042
9.3102,3.9624
9.4536,5.4141
8.8254,5.1694
5.1793,-0.74279
21.279,17.929
14.908,12.054
18.959,17.054
7.2182,4.8852
8.2951,5.7442
10.236,7.7754
5.4994,1.0173
20.341,20.992
10.136,6.6799
7.3345,4.0259
6.0062,1.2784
7.2259,3.3411
5.0269,-2.6807
6.5479,0.29678
7.5386,3.8845
5.0365,5.7014
10.274,6.7526
5.1077,2.0576
5.7292,0.47953
5.1884,0.20421
6.3557,0.67861
9.7687,7.5435
6.5159,5.3436
8.5172,4.2415
9.1802,6.7981
6.002,0.92695
5.5204,0.152
5.0594,2.8214
5.7077,1.8451
7.6366,4.2959
5.8707,7.2029
5.3054,1.9869
8.2934,0.14454
13.394,9.0551
5.4369,0.61705

Programı Bana Hemen Ver !

calistir.py

# coding=utf-8
""" Main
Calistir """

from termcolor import colored
from grafik_ciz import dagilim_grafigi, hipotez_grafigi, maliyet_devir_grafigi, maliyet_fonksiyonu_grafikleri
from dereceli_azalma import dereceli_azalma
import pandas as pd
import numpy as np

u""" 1- Veri Setinin Yuklenmesi """
print colored('1. Veri Seti Yukleniyor...', 'blue')
veri_seti = pd.read_csv('ex1data1.txt', header=None, names=['X', 'Y'])
dagilim_grafigi(veri_seti)

u""" 2- Kesme Degerinin Eklenmesi"""
print colored('2. Kesme Degeri Ekleniyor...', 'blue')
veri_seti.insert(0, 'Kesme Degeri', 1)
kesme_degeri_kolonu = veri_seti.shape[1]
X = veri_seti.iloc[:, 0:kesme_degeri_kolonu - 1]
y = veri_seti.iloc[:, kesme_degeri_kolonu - 1:kesme_degeri_kolonu]

X = np.matrix(X.values)
y = np.matrix(y.values)

u""" 3- Ogrenme Orani ve Devir Sayisinin Ayarlanmasi"""
print colored('3- Ogrenme Orani ve Devir Sayisi Ayarlaniyor ...', 'blue')
alpha = 0.0001
toplam_devir = 1000

teta = np.matrix(np.array([0, 0]))

print colored(('Devir Sayisi ', toplam_devir), 'green')
print colored(('Alfa  ', alpha), 'green')

u""" 4- Dereceli Azalmanin Hesaplanmasi"""
print colored('4- Dereceli Azalma Hesaplaniyor ...', 'blue')
teta, maliyet = dereceli_azalma(X, y, teta, alpha, toplam_devir)

u""" 5- Sonuc"""
print colored('5- [Sonuc]: Grafikler ...', 'blue')
print colored(('Hesaplanan Teta ', teta), 'green')

maliyet_devir_grafigi(toplam_devir, maliyet)
hipotez_grafigi(veri_seti['X'], veri_seti['Y'], teta)
maliyet_fonksiyonu_grafikleri(X, y, teta)

print colored('[BILGI] : Program Basari ile Sonlandi.', 'blue')

dereceli_azalma.py

# coding=utf-8
""" Gradient Descent
Dereceli Azalma """
import numpy as np
from maliyeti_hesapla import maliyet_hesapla

def dereceli_azalma(x, y, theta, alpha, devir_sayisi):
  """

  :param x: Ongorucu Degisken
  :param y: Hedef Degisken
  :param theta: Parametreler
  :param alpha: Ogrenme Orani
  :param devir_sayisi: Iterasyon Sayisi
  :return: theta: bulunan parametreler ve maliyet
  """
  yeni_theta = np.matrix(np.zeros(theta.shape))
  parametreler = int(theta.ravel().shape[1])

  maliyet_J = np.zeros(shape=(devir_sayisi, 1))

  for i in range(devir_sayisi):
    hata = (x * theta.T) - y

    for j in range(parametreler):
      term = np.multiply(hata, x[:, j])
      ara_islem = (np.divide(alpha, len(x)) * np.sum(term))
      yeni_theta[0, j] = np.subtract(theta[0, j], ara_islem)

      theta = yeni_theta
      maliyet_J[i, 0] = maliyet_hesapla(x, y, theta)

  return theta, maliyet_J

maliyeti_hesapla.py

# coding=utf-8
""" Compute Cost Function
Maliyet Fonksiyonunu Hesapla """
import numpy as np

def maliyet_hesapla(x, y, theta):
  """

  :param x: Ongorucu Degisken
  :param y: Hedef Degisken
  :param theta: parametre
  :return: maliyet
  """
  m = len(x)
  toplamin_acilimi = np.power(((x * theta.T) - y), 2)
  maliyet = np.sum(toplamin_acilimi) / (2 * m)
  return maliyet

ozellik_normalizasyonu.py

# coding=utf-8
""" Feature Normalization
Ozellik Normalizasyonu """
import numpy as np

def normalize_et(x):
  """

  :param x: Normalizasyon Yapilacak Veriler, numpy matrisi olarak
  :return: x_normalize: X'in normalizasyon Sonucu, ortalama ve standart sapma
  """
  x_normalize = x

  ortalama = np.mean(x)
  standart_sapma = np.std(x)

  x_normalize = (x_normalize - ortalama) / standart_sapma

  return x_normalize, ortalama, standart_sapma

grafik_ciz.py

# coding=utf-8
""" Plotting Data
Veri Setinin Grafiginin Cizilmesi"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.colors import LogNorm

def dagilim_grafigi(veri_seti):
  """

  :param veri_seti: Dagilim Grafiginin Yapilacagi Veri Seti
  """
  x = np.asarray(veri_seti['X'])
  y = np.asarray(veri_seti['Y'])
  plt.figure()
  plt.scatter(x, y, c="magenta")
  plt.xlabel('X')
  plt.ylabel('Y')
  plt.title('Dagilim Grafigi')
  plt.show()

def hipotez_grafigi(x, y, theta):
  """

  :param x: Ongorucu Degisken
  :param y: Hedef Degisken
  :param theta: Parametreler
  """
  agirliklar = np.asarray(theta)
  hipotez = x * agirliklar[0][1] + agirliklar[0][0]
  plt.figure()
  plt.scatter(x, y, c="magenta")
  plt.plot(x, hipotez, c='blue')
  plt.title("Hipotez Egrisi")
  plt.xlabel('X')
  plt.ylabel('Y')
  plt.show()

def maliyet_devir_grafigi(toplam_devir, maliyet):
  """

  :param toplam_devir: Toplam Devir Sayisi
  :param maliyet: Maliyet
  """
  plt.xlabel("Devir")
  plt.ylabel("Maliyet Fonksiyonu")
  plt.plot(np.arange(toplam_devir), maliyet, 'blue')
  plt.show()

def maliyet_fonksiyonu_grafikleri(x, y, teta):
  """

  :param x:Ongorucu Degisken
  :param y:Hedef Degisken
  :param teta:
  """
  theta0_vals = np.linspace(-10, 10, 100)
  theta1_vals = np.linspace(-1, 4, 100)

  J_vals = np.zeros([len(theta0_vals), len(theta1_vals)])

  for i in range(1, len(theta0_vals)):
    for j in range(1, len(theta1_vals)):
      t = [theta0_vals[i], theta1_vals[j]]
      J_vals[i, j] = np.sum(np.power((np.dot(x, t) - y), 2)) / (2 * len(x))

  J_vals = J_vals.T
  teta = np.asarray(teta)

  fig = plt.figure(1)

  from mpl_toolkits.mplot3d import Axes3D

  ax1 = fig.add_subplot(1, 2, 1, projection='3d')
  ax1.plot_surface(theta1_vals, theta0_vals, J_vals, cmap=cm.jet)
  ax1.set_xlabel(r"$\theta_1$")
  ax1.set_ylabel(r"$\theta_0$")

  ax2 = fig.add_subplot(2, 2, 4)
  ax2.plot(teta[0][0], teta[0][1], 'rx', markersize=10)
  ax2.set_xlabel(r"$\theta_0$")
  ax2.set_ylabel(r"$\theta_1$")

  ax2.contour(theta0_vals, theta1_vals, J_vals,
  norm=LogNorm(),
  levels=np.logspace(-4, 6, 20))  # -4, 6, 20
  plt.tight_layout()

  fig.savefig("grafik.png")
  plt.show()

Tekrar etmeden önce programı çalıştırın ve ne yapıldığını anlamaya çalışın. Alpha değerini ve devir sayısını değiştirerek programı tekrar çalıştırarak deneyebilirsiniz.

Dereceli Azalmanın nasıl çalıştığını, nasıl tek değişkenli lineer regresyonda kullanıldığını anlamak istiyorsanız devam edelim. Programı Bana Hemen Ver Diyorsanız, kopyala yapıştır ile işiniz hallolduysa devam etmenize gerek yok.

Evet, şimdi daha derine inmeye devam edelim.

Devamı -> Makine Öğrenmesi Matematiği 3

Designed by Freepik