์ค์ ๋ก ์์ธก์ ํ๊ณ ์ ํ ๋ ๋ณดํต ํ๋ ์ด์์ ๋ณ์๋ค์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค. multiple linear regression์ ๋ค์ํ ์ ๋ ฅ ๋ณ์๋ค์ ์ฌ์ฉํ๋ ์์ธก๋ชจ๋ธ์ ๋๋ค.
์ ์ด๋ฏธ์ง๋ฅผ ์๋ก ์ค๋ช ํ๋ฉด,
์ง๊ฐ๊ฒฉ(y)๋ฅผ ์์ธกํ๋ค๊ณ ํ ๋, x1(์นจ์ค์), x2=์ธต ์, x3=์ง์ด์ง์ฐ์, x4=ํฌ๊ธฐ 4๊ฐ์ง feature(n=4)๊ฐ ์์ต๋๋ค .
feature= dimension=attribute
x(2)๋ =[3 2 40 127](์ด๋ฒกํฐ๋ก)๊ฐ ๋๊ณ , x3(2)๋ 30 ์ ๋๋ค
default๋ ํ์ ์ด๋ฒกํฐ์ด๊ณ , row vector ์ฆ [3 2 40 127]๋ก ํํํ๊ณ ์ถ๋คํ๋ฉด, transpose๋ฅผ ์ฌ์ฉํ์ฌ ํํํฉ๋๋ค.
์์ธก ๋ชจ๋ธ ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ธํ0,1,2,3์ ๊ฐ ๋ณ์์ ๊ฐ์ค์น์ด๊ณ , x1,2,3๋ ๊ฐ feature์ ๋๋ค.
๊ฐ feature์ ๊ฐ ํฌ๊ธฐ๊ฐ ์ ๊ฐ๊ฐ์ ๋๋ค. ์๋ฅผ๋ค์ด ์ง ํฌ๊ธฐ๋1-2000๊น์ง ์ด๊ณ , ์นจ์ค ์๋ 1-5๋ฒ์์ ๋๋ค.
์ด๋ฌํ ์ฐจ์ด๋ ์ค์ผ์ผ๋ฌ(min-max ๋ฑ)๋ฅผ ํตํด 0~1์ฌ์ด์ ๊ฐ์ผ๋ก ์ค์ผ์ผ๋งํ์ฌ ๊ณ์ฐํฉ๋๋ค.
๊ฒฝ์ฌํ๊ฐ๋ฒ(gradient descent)์ผ๋ก ๋ฏธ๋ถ ๊ฐ(๊ธฐ์ธ๊ธฐ)์ด ์ต์๊ฐ ๋๋ ์ ์ ์ฐพ์ ์๋ง์ weight(๊ฐ์ค์น ๋งค๊ฐ๋ณ์)๋ฅผ ์ฐพ์ต๋๋ค. ์ฆ, ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ํด๋น ํจ์์ ์ต์๊ฐ ์์น๋ฅผ ์ฐพ๊ธฐ ์ํด Cost Function์ ๊ฒฝ์ฌ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์ ์ํ step size๋ฅผ ๊ฐ์ง๊ณ ์กฐ๊ธ์ฉ ์์ง์ฌ ๊ฐ๋ฉด์ ์ต์ ์ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐพ์ผ๋ ค๋ ๋ฐฉ๋ฒ์ผ๋ก, ํ๋ผ๋ฏธํฐ(ํธ๋ฏธ๋ถํ ๋ฒกํฐ)๋ฅผ ์กฐ๊ธ์ฉ ์์ง์ฌ๊ฐ๋ฉฐ ๊ณ์ฐํฉ๋๋ค.
์์ ๋ฅผ ํตํด ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์๋์ฐจ์ ์ฌ๋ฌ ๊ธฐ์ ์ ์ธ ์ฌ์๋ค์ ๊ณ ๋ คํ์ฌ ์ฐ๋น๋ฅผ ์์ธกํ๋ auto miles per gallon(MPG) dataset์ ์์ ๋ฐ์ดํฐ ์ ์ผ๋ก ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
1.1 Dataset
1. ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๊ธฐ
import pandas
import seaborn
seaborn.set()
from urllib.request import urlretrieve
URL = 'https://go.gwu.edu/engcomp6data3'
urlretrieve(URL, 'auto_mpg.csv')
mpg_data = pandas.read_csv('/content/auto_mpg.csv')
mpg_data.head()
mpg_data.info()๋ฅผ ํตํด์ Data์ ๋ํ ์ ๋ณด๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค
์ด 392๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์๊ณ 9๊ฐ์ ์ ๋ณด๋ค์ด ์์ต๋๋ค.
์ฌ๊ธฐ์ car name ์ object๋ก ์๋์ฐจ์ ์ด๋ฆ์ ๋ด๊ณ ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ origin์ int๋ก ์ ์ ํํ์ด์ง๋ง ์ด๊ฒ์ด ๋ง๋ค์ด์ง ๋์๋ก categorical ํ ๊ฐ์ ๋๋ค(ex. ์์ธ : 1, ๊ฒฝ๊ธฐ : 2, ... ).
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ด๋ฒ์ linear regression์ ํ ๋๋ car name, origin ๊ฐ์ ์ ์ธํ๊ณ ์๊ฐํ๋๋ก ํ๊ฒ ์ต๋๋ค.
y_col = 'mpg'
x_cols = mpg_data.columns.drop(['car name', 'origin', 'mpg']) # also drop mpg column
print(x_cols)
1.2 Data exploration
๋จผ์ linear regression์ ์งํํ๊ธฐ ์ ์ ์๋์ฐจ์ ์ ๋ณด๋ค๊ณผ ์ฐ๋น์์ 1๋1 ์๊ด๊ด๊ณ๋ฅผ ์์๋ณด๊ฒ ์ต๋๋ค.
์๊ฐํํด์ ๋ณด๋ ๊ฒ์ด ๊ฐ์ฅ ์ง๊ด์ ์ผ๋ก ์ดํดํ๊ธฐ ์ฝ์ต๋๋ค.
seaborn.pairplot(data=mpg_data, height=5, aspect=1,
x_vars=x_cols,
y_vars=y_col);
Accerlation๊ณผ model_year ์ ์ ๋ณด๋ ์์ ์๊ด๊ด๊ณ์ ์๊ณ ๋๋จธ์ง๋ ์์ ์๊ด๊ด๊ณ์ ์์ต๋๋ค.
์ด๋ฌํ ์๊ด๊ด๊ณ๋ฅผ ํตํด์ linear model ์ด ์ฐ๋น๋ฅผ ์์ธกํ๋๋ฐ ์ถฉ๋ถํ๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
1.3 Linear model in matrix form
from autograd import numpy
from autograd import grad
X = mpg_data[x_cols].values
X = numpy.hstack((numpy.ones((X.shape[0], 1)), X)) # pad 1s to the left of input matrix
y = mpg_data[y_col].values
print("X.shape = {}, y.shape = {}".format(X.shape, y.shape))
#X.shape = (392, 7), y.shape = (392,)
mean squared error๋ก cost function์ ์ ์ํ๊ฒ ์ต๋๋ค.
def linear_regression(params, X):
'''
The linear regression model in matrix form.
Arguments:
params: 1D array of weights for the linear model
X : 2D array of input values
Returns:
1D array of predicted values
'''
return numpy.dot(X, params)
def cost_function(params, model, X, y):
'''
The mean squared error loss function.
Arguments:
params: 1D array of weights for the linear model
model : function for the linear regression model
X : 2D array of input values
y : 1D array of predicted values
Returns:
float, mean squared error
'''
y_pred = model(params, X)
return numpy.mean( numpy.sum((y-y_pred)**2) )
1.4 Find the weights using gradient descent
์ด์ Gradient descent๋ก cost function์ ์ต์๋ก ํด์ฃผ๋ ๊ณ์๋ฅผ ์ฐพ์๋ณด๊ฒ ์ต๋๋ค. autograd.grad()ํจ์๋ก ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํด์ ์ฌ์ฉํ๊ฒ ์ต๋๋ค.
gradient = grad(cost_function)
๊ธฐ์ธ๊ธฐ๊ฐ์ด ์ ๊ตฌํด์ง๋์ง ๋๋คํ ๊ฐ์ ํตํด ์์๋ณด๊ฒ ์ต๋๋ค.
gradient(numpy.random.rand(X.shape[1]), linear_regression, X, y)
1.5 Feature scaling
Gradient descent๋ฅผ ์งํํ๋๋ loss๊ฐ ๋ฌดํ๋๋ก ๋ฐ์ฐํ์ต๋๋ค. ์ด๊ฒ์ ์ ๋ ฅ ๋ณ์๋ค ์ค์ ํน์ ๊ฐ๋ค์ด ๋๋ฌด ์ปค์ ์ผ์ด๋ ์ผ์ ๋๋ค. ์ ๋ ฅ ๋ฐ์ดํฐ๋ค์ max ์ min ๊ฐ์ ํ๋ฒ ์ถ๋ ฅํด๋ณด๋ฉด,
from sklearn.preprocessing import MinMaxScaler
min_max_scaler = MinMaxScaler()
X_scaled = min_max_scaler.fit_transform(mpg_data[x_cols])
X_scaled = numpy.hstack((numpy.ones((X_scaled.shape[0], 1)), X_scaled))
pandas.DataFrame(X_scaled).describe().loc[['max', 'min']]
0๋ฒ์งธ ํ์ ์ฒ์์ 1์ ์ถ๊ฐํด์ค ํ์ด๋ฏ๋ก 1๋ก ์ ์ง๋๋๊ฒ ๋ง์ต๋๋ค. ์ด์ ๋ณํ๋ ๋ฐ์ดํฐ๋ก ๋ค์ gradient descent๋ฅผ ์งํํด ๋ณด๊ฒ ์ต๋๋ค.
max_iter = 1000
alpha = 0.001
params = numpy.zeros(X.shape[1])
for i in range(max_iter):
descent = gradient(params, linear_regression, X_scaled, y)
params = params - descent * alpha
loss = cost_function(params, linear_regression, X_scaled, y)
if i%100 == 0:
print("iteration {}, loss = {}".format(i, loss))
1.6 How accurate is the model?
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ๋ชจ๋ธ์ด ์ผ๋ง๋ ์ ํํ์ง ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค. Regression ๋ฌธ์ ์์๋ ์ฃผ๋ก ๋๊ฐ์ ๊ธฐ๋ณธ ์งํ๊ฐ ์์ต๋๋ค. Mean absolute error(MAE)์ root mean squared error(RMSE)์ ๋๋ค. ๋๊ฐ์ ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
from sklearn.metrics import mean_absolute_error, mean_squared_error
mae = mean_absolute_error(y, y_pred_gd)
rmse = mean_squared_error(y, y_pred_gd, squared=False)
print("mae = {}".format(mae))
print("rmse = {}".format(rmse))
mae = 2.613991601156043
rmse = 3.40552056741184
'๋จธ์ ๋ฌ๋' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ค์ค ๋ก์ง์คํฑ ํ๊ท (์ํํธ๋งฅ์ค ํ๊ท) (0) | 2022.12.05 |
---|---|
๋ก์ง์คํฑ ํ๊ท sklearn logistic regression iris python (0) | 2022.12.04 |
[๋จธ์ ๋ฌ๋4] Logistic Regression ๋ก์ง์คํฑ ํ๊ท pyhton (0) | 2022.11.30 |
[๋จธ์ ๋ฌ๋2] Polynomial Regression python (0) | 2022.11.30 |
[๋จธ์ ๋ฌ๋1] ์ ํํ๊ท Linear Regression , gradient descent pyhton (0) | 2022.11.28 |