Bu yazı Makine Öğrenmesi Matematiği 2‘nin devamıdır. Hemen hatırlayalım, elimizde bir veri seti vardı, iki kolondan oluşuyor, kısaca ilk değişkeni kullanarak ikinci değişkeni tahmin edeceğiz. Verilerin Dağılım grafiği aşağıdaki gibidir:

dagilim_grafigi.png

Problemimizi şöyle tanımlamıştık: Bu verilere en iyi uyan doğru nasıl olmalıdır? 

Elimizdeki çıktıyı(ikinci kolonu) tahmin etmemizi sağlayacak tek bir değişken yani öngürücü değişken var, ilk kolondaki veriler(girdi). Yani problemimize makine öğrenmesi alanındaki ismine tek değişkenli lineer regresyon denir. Verilere uygun bir doğru çizeceğiz, yani bir doğru denklemine ihtiyacımız var. Buna da Hipotez  deniyorduHipotezimizde iki tane parametre var, bunlar theta’lar. Bu verilere en iyi uyan doğruyu bulabilmek için de hipotezimizde kullanacağımız en uygun parametreleri bulmalıyız. En uygun parametrelerin ise maliyetinin çok az olması gerektiğini biliyoruz. Şöyle bir bakalım:

sss

Maliyet fonksiyonu olarak squared error, kare ortalama hatayı kullanıyoruz. Burada aslında bir kural yok. Maliyet fonksiyonu olarak istediğiniz hata fonksiyonunu, metriği kullanabilirsiniz. Yani şimdi bu ne demek diyorsanız, şunlara bir göz atabilirsiniz.

Göz atmayacaklar için bir özet geçelim. Kısaca bu hata fonksiyonların temeli bize bulduğumuz değer ile gerçekte olması gereken değer arasındaki uzaklığı veriyor. Bunu her bir örnek için yapıyor. Tüm uzaklıkların toplamını bize dönüyor. Yani her tahmini hedef değişkeni değeri için gerçek değerleri arasındaki ilişkiyi bize gösteriyor. Tahminlerimizin doğruluğunu ölçmemize yarıyor. Tahminler ne kadar doğru o kadar az maliyet. En az maliyet en iyi hipotez. 

yakinsayanakadar
Dereceli Azalma Algoritması

Bir önceki bölüm Makine Öğrenmesi Matematiği 2’de , Tek değişkenli lineer regresyonda ve aslında regresyon problemlerinin çoğunda sıklıkla kullanılan popüler bir algoritma olan Dereceli Azalma‘yı kullanarak verilerimize uyan en iyi doğruyu çizmiştik. Bunun için bir kod yazmıştık. Bu programın nasıl çalıştığına şimdi adım adım bakalım, tabi önce doğrumuza:

hipotez egrisi.png

Başlamadan Önce:

Makine Öğrenmesi Matematiği 2‘de verilen her kod parçasını ayrı bir python file olarak aynı python package altında kaydediyoruz.

Main, Çalıştır Programımız ile başlayalım. Çalıştıracağımız Ana Program sadece bu.

  • Önce gerekli paketleri içe aktaralım.

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

  • Şimdi veri setini yükleyelim.
u""" 1- Veri Setinin Yuklenmesi """
print colored('1. Veri Seti Yukleniyor...', 'blue')
veri_seti = pd.read_csv('ex1data1.txt', header=None, names=['X', 'Y'])
  • Veri Setimizin Dağılım Grafiğine bir Bakalım.
dagilim_grafigi(veri_seti)
  • dagilim_grafigi(veri_seti) metoduna bakalım. Burada parametre olarak gelen veri setinden x ve y’e ekseni için gerekli bilgileri okuduktan sonra bir dağılım grafiği olarak gösteriyoruz.
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()
  • Şimdi öngürücü verimize kesme değeri ekliyoruz. Verilerimizi öngörücü veri seti yani X, ve hedef veri seti yani y olarak ikiye ayırıyoruz. Nedir bu Kesme Değeri?

Lineer Regresyonda, kesme değeri yani önyargı terimi olmadan çözümümüz origin noktasından geçmek zorundadır. Yani, tüm özellikler sıfır olduğunda tahmin edilen değerimizin de sıfır olması gerekir. Bununla birlikte, eğitim verilerimizin öne sürdüğü cevap bu olmayabilir. Herhangi bir özellikten bağımsız olarak bir önyargı ağırlığı eklenmesi, öğrendiğimiz ağırlıklarla açıklanan aşırı düzlemin (hiper düzlemin), başlangıç ​​noktasından geçmeyen verilere daha kolay uymasını sağlar.

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)
  • Theta Değerini Ayarlıyoruz. Evet, hatırlarsanız bir önceki bölümden, dereceli azalma ile teta değerlerini bulurken, teta değerlerine önceden ilk değerlerini atayacağımızı söylemiştik. Parametrelerin ilk değerlerini sıfır olarak ayarlıyoruz.
teta = np.matrix(np.array([0, 0]))
  •  Öğrenme Oranı ve Devir Sayısını ayarlayacağız şimdi. Öğrenme oranını,alfa.png tekrar hatırlayalım.

Öğ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.

  • Öğrenme Oranını ve Devir Sayısını Dereceli Azalmayı çalıştırdığımızda kullanacağız. Devir sayısı kaç iterasyon (döngü) yapacağımızı belirtirken, öğrenme oranı da ne kadar bir hızla hareket etmemiz gerektiğini belirtiyor.

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

print colored(('Devir Sayisi ', toplam_devir), 'green')
print colored(('Alfa ', alpha), 'green') 
  • Şimdi Dereceli Azalmayı çalıştıralım ve dereceli_azalma(X, y, theta, alpha, devir)  fonksiyonunun nasıl çalıştığına bakalım.
u""" 4- Dereceli Azalmanin Hesaplanmasi"""
print colored('4- Dereceli Azalma Hesaplaniyor ...', 'blue')
teta, maliyet = dereceli_azalma(X, y, teta, alpha, toplam_devir)
  • Dereceli Azalmanın denklemini inceleyelim. Özetle ne yapıyoruz? Maliyet fonksiyonunu daha önceden belirlediğimiz hata fonksiyonuna göre hesaplıyoruz. Sonra türevini alıyoruz. Hesaplanan teta değerinden farkını alıp, yeni tetalara atıyoruz.

yakinsayanakadar

dogru_atama

  • Şimdi Dereceli Azalma fonksiyonunu inceleyelim. Her şeyden önce yukarıdaki denklemin başında Yakınsayana Kadar Devam yazmışız. Bunu devir sayısı ile ayarlıyoruz, yani Dereceli Azalma Algoritmasını çalıştırmayı ne kadar sürdüreceğimizi.

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
def maliyet_hesapla(x, y, theta):
    """

    :param x: Ongorucu Degisken, Ev Buyuklukleri
    :param y: Hedef Degisken, Ev Fiyatlari
    :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
  • term dediğimiz terim, maliyet fonksiyonunda toplamın içinin diferansiyalini bize veriyor. ara_islem ise öğrenme oranı alpha ile diferansiyalin bölümünü bize veriyor. yeni_theta da bir önceki hesaplanan teta’dan bulduğumuz ara_islemin farkını, yani yeni teta değerimizi bize dönüyor. Bulunan yeni teta değerlerine göre de yeni maliyetimizi böylece hesaplayabiliyoruz. Görünüşte çok karmaşık gelse de üzerinde çalışmaya devam ettikçe her şey  kolaylaşacaktır.
  • Son adımda Bulunan yeni teta değerlerimizle hipotezimizi oluşturarak grafiğimize bakalım.
    u""" 5- Sonuc"""
    print colored('5- [Sonuc]: Grafikler ...', 'blue')
    print colored(('Hesaplanan Teta ', teta), 'green')
    
    hipotez_grafigi(veri_seti['X'], veri_seti['Y'], teta)
    
    def hipotez_grafigi(x, y, theta):
        """
    
        :param x: Ongorucu Degisken, Ev Buyuklukleri
        :param y: Hedef Degisken, Ev Fiyatlari
        :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.xlabel('X')
        plt.ylabel('Y')
        plt.title('Hipotez Egrisi')
        plt.show()

    hipotez egrisi.png

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

Designed by Freepik