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

Bir önceki bölümde Çok Değişkenli Lineer Regresyon probleminde Toplu Dereceli Azalma kullanmıştık. Şimdi ise dereceli azalmayı kullanırken bütün örnekler yerine daha küçük paketler seçerek kullanalım. Buna hatırlarsanız Mini Paket Dereceli Azalma deniyordu.

Mini Batch Gradient Descent

calistir_mini_batch_gradient_descent.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
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.005

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

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
Mini Paket 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 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(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))

 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)

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

mini_paket_maliyet_1.pngmini_paket_maliyet.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.005)
5.2- Mini Paket Dereceli Azalma Hesaplaniyor …
6- Maliyet Fonksiyonu – Devir Sayisi Grafigi Kaydediliyor …
(‘Hesaplanan Beta (MSE) ‘, array([[ 320785.09930926],
[ 107849.55509481],
[ 33309.82981735]]))
(‘Hesaplanan Beta (MAE) ‘, array([[ 320785.09930926],
[ 107849.55509481],
[ 33309.82981735]]))
(‘Hesaplanan Beta (SQRT ERR) ‘, array([[ 320785.09930926],
[ 107849.55509481],
[ 33309.82981735]]))
(‘Hesaplanan Beta (RMSE) ‘, array([[ 320785.09930926],
[ 107849.55509481],
[ 33309.82981735]]))
7- Hipotez (SQRT ERR’e gore)
J(theta) = 320785.099309 + 107849.555095 x0 + 33309.8298174 x1
8- Ev Fiyati Tahmini Yapalim … (SQRT ERR’e gore)
(‘Ev Buyuklugu 1650, 3 yatak odali ise Fiyati : ‘, 265148.33582330809)
(‘Ev Buyuklugu 1604, 3 yatak odali ise Fiyati : ‘, 258838.15646738984)
(‘Ev Buyuklugu 1000, 2 yatak odali ise Fiyati : ‘, 131737.35983648058)

 

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

Designed by Freepik