Lineer Regresyon

Lineer regresyon, makine öğrenmesinin en eski yöntemlerinden olup, bir bağımlı değişken ile bir veya birden çok bağımsız değişken arasında ki ilişkiyi formülize etmek için kullanılan bir yöntemdir. Burada ki amacımız, minimum hataya sahip, bağımsız değişkenlerin bağımlı değişkenler üzerinde ki etkisini bulmaktır. Gerçek verilerden oluşan eğitim verisi kullanılarak, her bir değişkenin sonuç üzerindeki ağırlığı belirlenir ve daha sonra yeni gelen verilerle bir sonraki durum tahmin edilebilir. Örneğin, marketler zincirinizin olduğunu ve birçok şehirde şubelerinizin olduğunu düşünün. Yeni bir şube açacaksınız ama hangi şehirde? Karınızın o şehrin nüfusu ile bağlantılı olduğunu varsayarsak, elinizdeki eğitim verisini (şubelerinizin olduğu şehirlerin nüfusu ve kar oranlarının olduğu bir liste) regresyon metodundan geçirerek nüfusun kar üzerindeki ağırlığını bulabilirsiniz. Daha sonra şube açmak istediğiniz şehrin nüfusuna bağlı olarak o şehirde kar mı, yoksa zarar mı edeceğinizi kestirebilirsiniz.

Şimdi bu eğitim verisini Python da nasıl göstereceğimize bakalım. Bunun için Python da numpy ve matplotlib kütüphanesini kullanacağız. Eğer gerekli kütüphaneleri indirmediyseniz aşağı linklerden indirip kurabilirsiniz. Kurulum ile ilgili kütüphanelerin kendi dökümantasyonu içerisinde anlatımları mevcuttur.

Numpy : http://www.scipy.org/scipylib/download.html

Matplotlib: http://matplotlib.org/downloads.html

Yukarıdaki kütüphaneleri kurduysanız Python ile veri kümesini aşağıdaki gibi görselleştirebilirsiniz:

1:  import numpy as np  
2:  import matplotlib.pyplot as plt  
3:  import random  
4:  def f(x): return 2*x + 4  
5:  trainX=[]  
6:  trainY=[]  
7:  for i in range(0, 50):  
8:    y = f(i)  
9:    x = random.choice([i+2, i+1, i, i-0, i-2])  
10:    trainX.append(x)  
11:    trainY.append(y)  
12:    print str(x) + " " + str(y)  
13:  fig, ax = plt.subplots()  
14:  ax.plot(trainX, trainY, "r*")  
15:  plt.show()

Lineer regresyona iki çeşit yaklaşım vardır: Tek Değişkenli Lineer Regresyon ve Çok Değişkenli Lineer Regresyon. Biz burada tek değişkenli lineer regresyondan bahsedeceğiz. Tek değişkenli lineer regresyon aşağıdaki gibi ifade edebiliriz:

$y = \theta_{0} + x_{1}\theta_{1}$

Çok değişkenli lineer bir denklemi aşağıdaki gibi ifade edebiliriz:

$y = \theta_{0} + x_{1}\theta_{1} + x_{2}\theta_{2} + x_{3}\theta_{3} ... + x_{n}\theta_{n}$

Burada:

$y$ : Bağımlı değişken
$x_{i}$ : Bağımsız değişken
$\theta _{0}$ : Sabit

$\theta _{i}$ : $x_{i}$ ’nin $y$ üzerindeki ağırlığı

$n$ : Değişken sayısı

$x_{i} = 1$ Olmak şartı ile yukarıdaki denklemi kısaca:

$h(x)= \sum_{i}^{n} \theta_{i} x_{i} = \theta x$

Lineer regresyonda ki amacımız, $\theta$ değerlerini hesaplamak. $\theta$ Değerleri öyle bir seçilmeli ki $h(x)$ fonksiyonun da hesaplanan tahmin ile gerçek değer olan $y$ arasında ki fark(hata) minimum olmalı. Daha teknik bir deyim ile $h(x)$ ve $y$ rasındaki farkı gösterecek maliyet fonksiyonunu(cost function) minimum olmalıdır. Maliyet fonksiyonu, şu şekilde ifade edilebilir:

$J(\theta) = \frac{1}{2} \sum_{i}^{n} (y^{i} - h(x^{i}))^{2}$

Burada:
$x^{i}$ : $i$ ’inci satırdaki özellik listesi. Yani, $x^{i} = [x_{0}^{i}, x_{1}^{i},x_{2}^{i} .. x_{n}^{i}]$
$y^{i}$ : $i$ ’inci satırdaki gerçek değer.
$h(x^{i})$ : $i$ ’inci satırdaki tahmin edilen değer.

Yukarıdaki maliyet fonksiyonunu kodlayacak olursak şu şekilde olacaktır:

1:  def compute_cost(X, y, theta):  
2:        m = y.size  
3:        hx = (X.dot(theta).flatten() - y)**2  
4:        J = ( 1.0 / (2*m)) * hx.sum()  
5:        return J

Maliyet fonksiyonu ile seçtiğimiz $\theta$ değerinin sonuç üzerindeki hatasını bulduk. Ancak amacımız minimum hataya sahip $\theta$ değerlerini belirlemek. Bunun için Gradient Descent metodunu kullanarak fonksiyondaki minimum değeri bulabiliriz. GradientDescent, belirlenen oransal adım büyüklüğü (biz buna öğrenme oranı diyeceğiz.) ile yerel minimum ya da maksimum noktayı hızlı bir şekilde elde etmeye yarayan bir yöntemdir. Genel olarak gradient descent fonksiyonu aşağıdaki gibidir:

$x_{yeni} = x_{eski} - \alpha \frac{\partial J(\theta)}{\partial \theta_{i}}$

Gradient descent metodunu maliyet fonksiyonuna uyarladığımızda aşağıdaki fonksiyonu elde ederiz:

$\frac{\partial J(\theta)}{\partial \theta_{i}} = \frac{1}{2} \sum_{i}^{n} 2(y^{i} - h(x^{i})(-x^{i}))$

$\theta_{i} = \theta_{i} - \alpha \frac{\partial J(\theta)}{\partial \theta_{i}}$

$\theta_{i} = \theta_{i} - \alpha \sum_{j}^{n} (h(x^{i}) - y^{i})x_{j}^{i}$

Gradient Descent algoritmasını python ile kodladığımızda aşağıdaki sonucu elde edeceğiz:

1:  def gradient_descent(X, y, alpha, theta, iter):  
2:        m = y.size  
3:        J_history = np.zeros(shape= (iter, 1))  
4:        for i in range(iter):  
5:              hx0 = (X.dot(theta).flatten() - y)  
6:              hx1 = (X.dot(theta).flatten() - y) * X[:, 1]  
7:              theta[0,0] = theta[0,0] - alpha * (1.0 / m) * hx0.sum()  
8:              theta[1,0] = theta[1,0] - alpha * (1.0 / m) * hx1.sum()  
9:              J_history[i, 0] = compute_cost(X, y, theta)  
10:        return theta, J_history

$\alpha$ Çok küçük belirlendiğinde Gradient Descent algoritması yavaş çalışacaktır.

Eğer ki $\alpha$ değerini çok büyük belirlersek, algoritma hedeflenen minimum değeri atlayabilir. Bu sebepten minimum noktaya yakınsamak yerine uzaklaşabilir.

Eğitim verisinin okunması ve başlangıç parametreleri verilerek Regresyonun çalışması aşağıda verilmiştir:

1:  data_set = np.loadtxt('x01.txt')  
2:  X = data_set[:, 0]  
3:  y = data_set[:, 1]  
4:  m = y.size  
5:  XX = np.ones(shape=(m,2))  
6:  XX[:, 1] = X  
7:  alpha = 0.01  
8:  theta = np.zeros(shape = (2,1))  
9:  iter = 2000  
10:  theta, J = gradient_descent(XX, y, alpha, theta, iter)  
11:  result = XX.dot(theta).flatten()  
12:  py.scatter(X, y, marker= 'x', c='r')  
13:  py.plot(X, result)  
14:  py.show()

Kodu çalıştırdığımızda minimum hataya sahip denklemimiz aşağıda ki gibi olacak: