Bu yazı Makine Öğrenmesi Matematiği yazı dizisinin 7. bölümüdür. Hatırlamak isterseniz:

Çok değişkenli lineer regresyon örneğimiz ile devam edelim. Veri Setimiz AndrewNG’nin hazırladığı Coursera’daki Machine Learning dersinden alınmıştır. ex1data2.txt

2104,3,399900
1600,3,329900
2400,3,369000
1416,2,232000
3000,4,539900
1985,4,299900
1534,3,314900
1427,3,198999
1380,3,212000
1494,3,242500
1940,4,239999
2000,3,347000
1890,3,329999
4478,5,699900
1268,3,259900
2300,4,449900
1320,2,299900
1236,3,199900
2609,4,499998
3031,4,599000
1767,3,252900
1888,2,255000
1604,3,242900
1962,4,259900
3890,3,573900
1100,3,249900
1458,3,464500
2526,3,469000
2200,3,475000
2637,3,299900
1839,2,349900
1000,1,169900
2040,4,314900
3137,3,579900
1811,4,285900
1437,3,249900
1239,3,229900
2132,4,345000
4215,4,549000
2162,4,287000
1664,2,368500
2238,3,329900
2567,4,314000
1200,3,299000
852,2,179900
1852,4,299900
1203,3,239500

Hatırlarsanız ilk kolon evin büyüklüğünü, ikinci kolon evdeki yatak odası sayısını ve son kolon ise evin fiyatını göstermektedir. İlk iki kolondaki verileri kullanarak son kolondaki verilere en iyi uyacak doğruyu çizeceğiz. Bunun için hipotez fonksiyonuna ihtiyacımız var.

İki değişkenimiz olduğu için Hipotezimiz:

yeni_hipo1

Amaç: Hipotezi Bulmak

  1. Hipotezi Bulmak İçin Tetaları(parametreleri) Bulmamız Gerekiyor.
  2. Tetaları Bulmak için Maliyet Fonksiyonunu Kullanacağız.
  3. Maliyeti En Aza indirgemek için Dereceli Azalmayı Kullacağız.
    • Özellikleri Ölçeklendirmeliyiz.
      • Dereceli Azalmanın Bazı Ağırlıkları Daha Önce Güncellemesini Önlemek için.
    • Dereceli Azalmayı Üç Ayrı Şekilde Gerçekleştireceğiz:
      1. Batch-Gradient Descent
      2. Mini-Batch Gradient Descent
      3. Mini-Batch Gradient Descent with Momentum Optimization

Batch-Gradient Descent

calistir_batch_gradient_descent.py

# coding=utf-8
""" Batch Gradient Descent
Toplu Dereceli Azalma"""

import pandas as pd
import numpy as np

from termcolor import colored
from dereceli_azalma import dereceli_azalma
from ozellik_normalizasyonu import ozellik_normalizasyonu
from grafik_ciz import maliyet_devir_grafigi_ciz

u""" 1- Veri Setinin Yuklenmesi """
print colored('1- Veri Seti Yukleniyor ...', 'blue')
# Veri Setini Csv Dosyasindan Okuma
veri_seti = pd.read_csv('ex1data2.txt', delimiter=',', header=None, names=['Buyukluk', 'Oda', 'Fiyat'])

# Tahmin Etmeye Calisacagimiz Verileri Okuma
y = veri_seti['Fiyat'].as_matrix()
del veri_seti['Fiyat']

# Toplam Girdi Sayisi
m = len(y)

# Ongorucu Veriler, ilk iki degisken: buyukluk ve oda sayisi
X_veri = veri_seti.as_matrix()

u""" 2- Ozellik Normalizasyonu """
print colored('2- Ozellik Normalizasyonu Yapiliyor ...', 'blue')
x, ortalama, standart_sapma = ozellik_normalizasyonu(X_veri)

u""" 3- Kesme Degerinin Eklenmesi"""
print colored('3- Kesme Degeri Ekleniyor ...', 'blue')
X = np.ones(shape=(m, (len(X_veri[0]) + 1)))
X[:, 1:(len(X_veri[0]) + 1)] = x

# Tahmin Edilecek Hedef Degiskeni Atama ve Boyutunu Ayarlama, yani vektor haline donusturme
y.shape = (m, 1)

u""" 4- Ogrenme Orani ve Devir Sayisinin Ayarlanmasi"""
print colored('4- Ogrenme Orani ve Devir Sayisi Ayarlaniyor ...', 'blue')
toplam_devir = 1000
alfa = 0.01

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

beta_mse = np.zeros((len(X[0]), 1))
beta_mae = np.zeros((len(X[0]), 1))
beta_sqrt_err = np.zeros((len(X[0]), 1))
beta_rmse = np.zeros((len(X[0]), 1))

u""" 5.1 - Dereceli Azalmanin Hesaplanmasi"""
print colored('5.1- Dereceli Azalma Hesaplaniyor ...', 'blue')
beta_mse, maliyet_mse = dereceli_azalma(X, y, beta_mse, alfa, toplam_devir, 'mse')
beta_mae, maliyet_mae = dereceli_azalma(X, y, beta_mae, alfa, toplam_devir, 'mae')
beta_sqrt_err, maliyet_sqrt_err = dereceli_azalma(X, y, beta_sqrt_err, alfa, toplam_devir, 'squared_error')
beta_rmse, maliyet_rmse = dereceli_azalma(X, y, beta_rmse, alfa, toplam_devir, 'rmse')

u""" 6- Dereceli Azalmanin Dogru Calisip Calismadiginin Kontrolu"""
print colored('6- Maliyet Fonksiyonu - Devir Sayisi Grafigi Kaydediliyor ...', 'blue')
maliyet_devir_grafigi_ciz(toplam_devir, maliyet_mse, maliyet_mae, maliyet_sqrt_err, maliyet_rmse,
baslik='Dereceli Azalma')

u""" 7- Sonuc"""
print colored(('Hesaplanan Beta (MSE) ', beta_mse), 'green')
print colored(('Hesaplanan Beta (MAE) ', beta_mae), 'green')
print colored(('Hesaplanan Beta (SQRT ERR) ', beta_sqrt_err), 'green')
print colored(('Hesaplanan Beta (RMSE) ', beta_rmse), 'green')

print colored('7- Hipotez (SQRT ERR\'e gore)', 'blue')
print colored( "J(theta) = " + str(beta_sqrt_err[0][0]) + " + " + str(beta_sqrt_err[1][0]) + " x0 + " + str(
beta_sqrt_err[2][0]) + " x1", 'green')

print colored('8- Ev Fiyati Tahmini Yapalim ... (SQRT ERR\'e gore)', 'blue')

# X Verilerinde Normalizasyon Yaptigimiz Icin Direkt Kullanamayiz.
# Tahmin etmek icin X ongorucu degiskenlerimizi buldugumuz
# ortalama ve standart sapmalara gore normalize edip kullaniyoruz
x0 = 1
x1 = (1650 - ortalama[0]) / standart_sapma[0]
x2 = (3 - ortalama[1]) / standart_sapma[1]
tahmin = np.dot([x0, x1, x2], beta_sqrt_err)

print colored(('Ev Buyuklugu 1650, 3 yatak odali ise Fiyati : ', tahmin[0]), 'green')

x0 = 1
x1 = (1604 - ortalama[0]) / standart_sapma[0]
x2 = (3 - ortalama[1]) / standart_sapma[1]
tahmin = np.dot([x0, x1, x2], beta_sqrt_err)

print colored(('Ev Buyuklugu 1604, 3 yatak odali ise Fiyati : ', tahmin[0]), 'green')

x0 = 1
x1 = (1000 - ortalama[0]) / standart_sapma[0]
x2 = (2 - ortalama[1]) / standart_sapma[1]
tahmin = np.dot([x0, x1, x2], beta_sqrt_err)

print colored(('Ev Buyuklugu 1000, 2 yatak odali ise Fiyati : ', tahmin[0]), 'green')

ozellik_normalizasyonu.py

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

def ozellik_normalizasyonu(x):
    """

    :param x: normallestirilecek ozellikler
    :return: normalize olmus X, ortalamasi ve sapmasi
    """
    butun_ortalamalar = []
    butun_standart_sapmalar = []
    X_normalize = x

    n_c = x.shape[1]
    for i in range(n_c):
        m = np.mean(x[:, i])
        s = np.std(x[:, i])

        butun_ortalamalar.append(m)
        butun_standart_sapmalar.append(s)
        X_normalize[:, i] = (X_normalize[:, i] - m) / s

    return X_normalize, butun_ortalamalar, butun_standart_sapmalar

dereceli_azalma.py

# coding=utf-8
""" Gradient Descent
 Dereceli Azalma """

import numpy as np
from maliyet_hesapla import squarred_error_maliyet_hesapla, mae_maliyet_fonksiyonu_hesapla, \
    mse_maliyet_fonksiyonu_hesapla, \
    rmse_maliyet_fonksiyonu_hesapla

def dereceli_azalma(x, y, beta, alfa, devir_sayisi, maliyet_fonksiyonu):
    """

    :param x: ozellik degiskenleri
    :param y: hedef degisken
    :param beta: parametreler
    :param alfa: ogrenme orani
    :param devir_sayisi: devir sayisi
    :param maliyet_fonksiyonu: hesaplanacak maliyet fonksiyonu turu
    :return: beta ve maliyet fonksiyonu
    """
    maliyet_J = np.zeros(shape=(devir_sayisi, 1))

    for devir in range(devir_sayisi):

        m = y.size

        tahminler = x.dot(beta)
        beta_size = beta.size

        for i in range(beta_size):
            X_i = x[:, i]
            X_i.shape = (m, 1)

            beta[i][0] = beta[i][0] - alfa * (1.0 / m) * ((tahminler - y) * X_i).sum()

        if maliyet_fonksiyonu == 'mse':
            maliyet_J[devir, 0] = mse_maliyet_fonksiyonu_hesapla(x, y, beta)
        if maliyet_fonksiyonu == 'mae':
            maliyet_J[devir, 0] = mae_maliyet_fonksiyonu_hesapla(x, y, beta)
        if maliyet_fonksiyonu == 'rmse':
            maliyet_J[devir, 0] = rmse_maliyet_fonksiyonu_hesapla(x, y, beta)
        if maliyet_fonksiyonu == 'squared_error':
            maliyet_J[devir, 0] = squarred_error_maliyet_hesapla(x, y, beta)
    return beta, maliyet_J

maliyet_hesapla.py

# coding=utf-8
""" Compute Cost Function
 Maliyet Fonksiyonunu Hesapla"""

import numpy as np

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

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

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

    :param x: Ongorucu Degisken, Ev Buyuklukleri
    :param y: Hedef Degisken, Ev Fiyatlari
    :param teta: parametre
    :return: maliyet
    """
    m = len(x)
    toplamin_acilimi = np.abs(((x * teta.T) - y))
    maliyet = np.sum(toplamin_acilimi) / m
    return maliyet

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

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

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

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

grafik_ciz.py

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

import matplotlib.pyplot as plt
import numpy as np

def maliyet_devir_grafigi_ciz(toplam_devir, mse, mae, squared_error, rmse, baslik):
  """

:param toplam_devir: Toplam Devir Sayisi
  :param mse: Mean Squared Error
  :param mae: Mean Absolute Error
  :param squared_error: Squared Error
  :param rmse: Root Mean Squared Error
  :param baslik: Grafigin Basligi
  """
  fig = plt.figure(1)
  fig.suptitle(baslik)

  ax1 = fig.add_subplot(221)
  ax1.set_title("Mean Squarred Error")
  ax1.set_xlabel("Devir")
  ax1.set_ylabel("Maliyet Fonksiyonu")
  ax1.plot(np.arange(toplam_devir), mse, 'blue')

  ax2 = fig.add_subplot(222)
  ax2.set_title("Mean Absolute Error")
  ax2.set_xlabel("Devir")
  ax2.set_ylabel("Maliyet Fonksiyonu")
  ax2.plot(np.arange(toplam_devir), mae, 'red')

  ax3 = fig.add_subplot(223)
  ax3.set_title("Squarred Error")
  ax3.set_xlabel("Devir")
  ax3.set_ylabel("Maliyet Fonksiyonu")
  ax3.plot(np.arange(toplam_devir), squared_error, 'green')
  plt.tight_layout()

  ax4 = fig.add_subplot(224)
  ax4.set_title("Root Mean Square Error")
  ax4.set_xlabel("Devir")
  ax4.set_ylabel("Maliyet Fonksiyonu")
  ax4.plot(np.arange(toplam_devir), rmse, 'magenta')
  plt.tight_layout()

  fig.savefig(str(baslik).strip() + ".png")

 

1- Veri Seti Yukleniyor …
2- Ozellik Normalizasyonu Yapiliyor …
3- Kesme Degeri Ekleniyor …
4- Ogrenme Orani ve Devir Sayisi Ayarlaniyor …
(‘Devir Sayisi ‘, 1000)
(‘Alfa ‘, 0.01)
5.1- Dereceli Azalma Hesaplaniyor …
6- Maliyet Fonksiyonu – Devir Sayisi Grafigi Kaydediliyor …
(‘Hesaplanan Beta (MSE) ‘, array([[ 324143.83342031],
[ 119602.41373489],
[ 20129.50216174]]))
(‘Hesaplanan Beta (MAE) ‘, array([[ 324143.83342031],
[ 119602.41373489],
[ 20129.50216174]]))
(‘Hesaplanan Beta (SQRT ERR) ‘, array([[ 324143.83342031],
[ 119602.41373489],
[ 20129.50216174]]))
(‘Hesaplanan Beta (RMSE) ‘, array([[ 324143.83342031],
[ 119602.41373489],
[ 20129.50216174]]))
7- Hipotez (SQRT ERR’e gore)
J(theta) = 324143.83342 + 119602.413735 x0 + 20129.5021617 x1
8- Ev Fiyati Tahmini Yapalim … (SQRT ERR’e gore)
(‘Ev Buyuklugu 1650, 3 yatak odali ise Fiyati : ‘, 266244.76416209328)
(‘Ev Buyuklugu 1604, 3 yatak odali ise Fiyati : ‘, 259246.93573893074)
(‘Ev Buyuklugu 1000, 2 yatak odali ise Fiyati : ‘, 140624.41778667527)

Dereceli Azalma.png

toplu_maliyet.png

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

Designed by Freepik