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

Mini Batch Gradient Descent with Momentum

calistir_momentum_mini_batch.py

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

import pandas as pd
import numpy as np

from termcolor import colored
from dereceli_azalma import dereceli_azalma_mini_paket_momentum_ile
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.001

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))

paket = 50

u""" 5.3 - Momentum ile Mini Paket Dereceli Azalmanin Hesaplanmasi"""
print colored('5.3- Momentum Mini Paket Dereceli Azalma Hesaplaniyor ...', 'blue')
beta_mse, maliyet_mse = dereceli_azalma_mini_paket_momentum_ile(X, y, beta_mse, alfa, toplam_devir, paket, 'mse')
beta_mae, maliyet_mae = dereceli_azalma_mini_paket_momentum_ile(X, y, beta_mae, alfa, toplam_devir, paket, 'mae')
beta_sqrt_err, maliyet_sqrt_err = dereceli_azalma_mini_paket_momentum_ile(X, y, beta_sqrt_err, alfa, toplam_devir,
                                                                          paket,
                                                                          'squared_error')
beta_rmse, maliyet_rmse = dereceli_azalma_mini_paket_momentum_ile(X, y, beta_rmse, alfa, toplam_devir, paket, '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='Mini Paket Dereceli Azalma Momentum Optimizasyon ile')

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
""" Mini Batch Gradient Descent with Momentum
Mini Paket Dereceli Azalma Momentum ile """

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 mini_paket_al(x, y, mini_paket_buyuklugu):
  """

  :param x: ozellik degiskenleri
  :param y: hedef degisken
  :param mini_paket_buyuklugu:
  :return: veri setinden secilen paket(mini batch)
  """
  mini_paketler = []

  # X, y = np.random.shuffle(X,y)

  for i in range(0, x.shape[0], mini_paket_buyuklugu):
     x_mini = x[i:i + mini_paket_buyuklugu]
     y_mini = y[i:i + mini_paket_buyuklugu]

     mini_paketler.append((x_mini, y_mini))

  return mini_paketler

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

  :param x: ozellik degiskenleri
  :param y: hedef degisken
  :param beta: parametreler
  :param alfa: ogrenme orani
  :param devir_sayisi: devir sayisi
  :param paket_buyuklugu: secilen mini paketin buyuklugu
  :param maliyet_fonksiyonu: hesaplanacak maliyet fonksiyonu turu
  :return: beta ve maliyet fonksiyonu
  """
  maliyet_J = np.zeros(shape=(devir_sayisi, 1))
  momentum_sabiti = 0.9
  hiz = 1
  for devir in range(devir_sayisi):

    for paketler in mini_paket_al(x, y, paket_buyuklugu):

      x = paketler[0]
      y = paketler[1]
      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)

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

        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")

momentum_2.png

mom.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.001)
5.3- Momentum Mini Paket Dereceli Azalma Hesaplaniyor …
6- Maliyet Fonksiyonu – Devir Sayisi Grafigi Kaydediliyor …
(‘Hesaplanan Beta (MSE) ‘, array([[ 219286.32605301],
[ 168548.78480287],
[ 106600.78670958]]))
(‘Hesaplanan Beta (MAE) ‘, array([[ 219286.32605301],
[ 168548.78480287],
[ 106600.78670958]]))
(‘Hesaplanan Beta (SQRT ERR) ‘, array([[ 219286.32605301],
[ 168548.78480287],
[ 106600.78670958]]))
(‘Hesaplanan Beta (RMSE) ‘, array([[ 219286.32605301],
[ 168548.78480287],
[ 106600.78670958]]))
7- Hipotez (SQRT ERR’e gore)
J(theta) = 219286.326053 + 168548.784803 x0 + 106600.78671 x1
8- Ev Fiyati Tahmini Yapalim … (SQRT ERR’e gore)
(‘Ev Buyuklugu 1650, 3 yatak odali ise Fiyati : ‘, 120004.4445724087)
(‘Ev Buyuklugu 1604, 3 yatak odali ise Fiyati : ‘, 110142.80850545214)
(‘Ev Buyuklugu 1000, 2 yatak odali ise Fiyati : ‘, -160942.42948644597) 

 

Designed by Freepik