Algorytmy regresji - regresja liniowa

Wprowadzenie do regresji liniowej

Regresję liniową można zdefiniować jako model statystyczny, który analizuje liniową zależność między zmienną zależną a danym zestawem zmiennych niezależnych. Liniowa zależność między zmiennymi oznacza, że gdy zmieni się (wzrośnie lub zmniejszy) wartość jednej lub więcej zmiennych niezależnych, odpowiednio zmieni się również wartość zmiennej zależnej (wzrośnie lub zmniejszy).

Matematycznie zależność można przedstawić za pomocą następującego równania -

Y = mX + b

Tutaj Y jest zmienną zależną, którą próbujemy przewidzieć

X to zmienna zależna, której używamy do prognozowania.

m jest nachyleniem linii regresji, która reprezentuje wpływ X na Y

b jest stałą, znaną jako punkt przecięcia z osią Y. Jeśli X = 0, Y byłoby równe b.

Ponadto zależność liniowa może mieć charakter pozytywny lub negatywny, jak wyjaśniono poniżej -

Pozytywna relacja liniowa

Zależność liniowa będzie nazywana dodatnią, jeśli wzrośnie zarówno zmienna niezależna, jak i zależna. Można to zrozumieć za pomocą poniższego wykresu -

Negatywna relacja liniowa

Zależność liniowa będzie nazywana dodatnią, jeśli niezależne wzrosty i zależna zmienna spadną. Można to zrozumieć za pomocą poniższego wykresu -

Rodzaje regresji liniowej

Regresja liniowa ma dwa typy:

Prosta regresja liniowa
Wielokrotna regresja liniowa

Prosta regresja liniowa (SLR)

Jest to najbardziej podstawowa wersja regresji liniowej, która przewiduje odpowiedź przy użyciu pojedynczej cechy. W lustrzankach jednoobiektywowych założenie jest takie, że dwie zmienne są liniowo powiązane.

Implementacja Pythona

Możemy zaimplementować SLR w Pythonie na dwa sposoby, jeden to dostarczenie własnego zestawu danych, a drugi to użycie zestawu danych z biblioteki scikit-learn python.

Example 1 - W poniższym przykładzie implementacji Pythona używamy naszego własnego zestawu danych.

Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

Następnie zdefiniuj funkcję, która obliczy ważne wartości dla lustrzanek jednoobiektywowych -

def coef_estimation(x, y):

Poniższy wiersz skryptu poda liczbę obserwacji n -

n = np.size(x)

Średnią z wektorów xiy można obliczyć w następujący sposób -

m_x, m_y = np.mean(x), np.mean(y)

Odchylenie krzyżowe i odchylenie o x możemy znaleźć w następujący sposób -

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x

Następnie współczynniki regresji, czyli b, można obliczyć w następujący sposób -

b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

Następnie musimy zdefiniować funkcję, która wykreśli linię regresji, a także będzie przewidywać wektor odpowiedzi -

def plot_regression_line(x, y, b):

Poniższa linia skryptu przedstawia rzeczywiste punkty jako wykres punktowy -

plt.scatter(x, y, color = "m", marker = "o", s = 30)

Następująca linia skryptu przewiduje wektor odpowiedzi -

y_pred = b[0] + b[1]*x

Następujące linie skryptu wykreślą linię regresji i umieszczą na nich etykiety -

plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Na koniec musimy zdefiniować funkcję main () do dostarczania zestawu danych i wywoływania funkcji, którą zdefiniowaliśmy powyżej -

def main():
   x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
   y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
   b = coef_estimation(x, y)
   print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
   plot_regression_line(x, y, b)
   
if __name__ == "__main__":
main()

Wynik

Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788

Example 2 - W poniższym przykładzie implementacji Pythona korzystamy z zestawu danych dotyczących cukrzycy ze scikit-learn.

Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

Następnie załadujemy zbiór danych dotyczących cukrzycy i utworzymy jego obiekt -

diabetes = datasets.load_diabetes()

Ponieważ wdrażamy lustrzankę, będziemy używać tylko jednej funkcji:

X = diabetes.data[:, np.newaxis, 2]

Następnie musimy podzielić dane na zestawy uczące i testowe w następujący sposób -

X_train = X[:-30]
X_test = X[-30:]

Następnie musimy podzielić cel na zestawy treningowe i testowe w następujący sposób -

y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]

Teraz, aby wytrenować model, musimy utworzyć obiekt regresji liniowej w następujący sposób -

regr = linear_model.LinearRegression()

Następnie wytrenuj model za pomocą zestawów uczących w następujący sposób -

regr.fit(X_train, y_train)

Następnie wykonaj prognozy za pomocą zestawu testowego w następujący sposób -

y_pred = regr.predict(X_test)

Następnie wydrukujemy współczynnik, taki jak MSE, wynik wariancji itp. W następujący sposób -

print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))

Teraz wykreśl wyniki w następujący sposób -

plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

Wynik

Coefficients:
   [941.43097333]
Mean squared error: 3035.06
Variance score: 0.41

Wielokrotna regresja liniowa (MLR)

Jest to rozszerzenie prostej regresji liniowej, która przewiduje odpowiedź przy użyciu dwóch lub więcej cech. Matematycznie możemy to wyjaśnić następująco -

Rozważmy zbiór danych zawierający n obserwacji, p cechy, tj. Zmienne niezależne i y jako jedną odpowiedź, tj. Zmienną zależną, linię regresji dla cech p można obliczyć w następujący sposób -

$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} $$

Tutaj h (x _i ) to przewidywana wartość odpowiedzi, a b ₀ , b ₁ , b ₂ …, b _p to współczynniki regresji.

Wiele modeli regresji liniowej zawsze zawiera błędy w danych znane jako błąd resztkowy, który zmienia obliczenia w następujący sposób -

$$ h (x_ {i}) = b_ {0} + b_ {1} x_ {i1} + b_ {2} x_ {i2} + ... + b_ {p} x_ {ip} + e_ {i} $$

Możemy również zapisać powyższe równanie w następujący sposób -

$$ y_ {i} = h (x_ {i}) + e_ {i} \: lub \: e_ {i} = y_ {i} - h (x_ {i}) $$

Implementacja Pythona

w tym przykładzie będziemy używać zbioru danych mieszkaniowych w Bostonie ze scikit Learn -

Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

Następnie załaduj zestaw danych w następujący sposób -

boston = datasets.load_boston(return_X_y=False)

Poniższe wiersze skryptu definiują macierz cech, X i wektor odpowiedzi, Y -

X = boston.data
y = boston.target

Następnie podziel zbiór danych na zestawy uczące i testowe w następujący sposób -

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)

Przykład

Teraz utwórz obiekt regresji liniowej i wytrenuj model w następujący sposób -

reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
   color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
   color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()

Wynik

Coefficients:
[
   -1.16358797e-01  6.44549228e-02  1.65416147e-01  1.45101654e+00
   -1.77862563e+01  2.80392779e+00  4.61905315e-02 -1.13518865e+00
    3.31725870e-01 -1.01196059e-02 -9.94812678e-01  9.18522056e-03
   -7.92395217e-01
]
Variance score: 0.709454060230326

Założenia

Poniżej przedstawiono niektóre założenia dotyczące zbioru danych utworzonego przez model regresji liniowej -

Multi-collinearity- Model regresji liniowej zakłada, że w danych występuje bardzo mała lub żadna współliniowość. Zasadniczo multi-kolinearność występuje, gdy niezależne zmienne lub cechy mają w sobie zależność.

Auto-correlation- Kolejnym założeniem, w którym przyjęto model regresji liniowej, jest to, że w danych występuje bardzo mała autokorelacja lub jej brak. Zasadniczo autokorelacja występuje, gdy istnieje zależność między błędami resztowymi.

Relationship between variables - Model regresji liniowej zakłada, że związek między odpowiedzią a zmiennymi cech musi być liniowy.