Codelog
[AIB] Logistic Regression ๋ณธ๋ฌธ
๐ก Classification ๋ฌธ์
ํ๊ท ๋ฌธ์ ์์๋ ๋ณดํต ํ๊ฒ ๋ณ์์ ํ๊ท ๊ฐ์ ๊ธฐ์ค๋ชจ๋ธ๋ก ์ฌ์ฉํ๋ค.
๋ถ๋ฅ ๋ฌธ์ ์์๋ ๋ณดํต ํ๊ฒ ๋ณ์์์ ๊ฐ์ฅ ๋น๋ฒํ๊ฒ ๋ํ๋๋ ๋ฒ์ฃผ๋ฅผ ๊ธฐ์ค๋ชจ๋ธ๋ก ์ค์ ํ๋ค.
์๊ณ์ด ๋ฐ์ดํฐ๋ ๋ณดํต ์ด๋ค ์์ ์ ๊ธฐ์ค์ผ๋ก ์ด์ ์๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๊ธฐ์ค๋ชจ๋ธ์ด ๋๋ค.
๋ถ๋ฅ ๋ฌธ์ ์๋ ํ๊ฒ ๋ณ์๊ฐ ํธ์ค๋ ๋ฒ์ฃผ ๋น์จ์ ๊ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ ํญ์ ๋จผ์ ํ๊ฒ ๋ฒ์ฃผ์ ๋น์จ์ ํ์ธํด์ผ ํ๋ค.
๋ํ ๋ถ๋ฅ์์๋ ํ๊ท์ ๋ค๋ฅธ ํ๊ฐ์งํ๋ฅผ ์ฌ์ฉํ๋ค.
์ ํ๋(Accuracy)๋ ๋ถ๋ฅ ๋ฌธ์ ์์ ์ฌ์ฉํ๋ ํ๊ฐ์งํ์ด๋ค.
๐ก Logistic Regression
๋ก์ง์คํฑ ํ๊ท๋ ํน์ฑ๋ณ์๋ฅผ ๋ก์ง์คํฑ ํจ์ ํํ๋ก ํํํ๋ค.
๋ฐ๋ผ์ ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ด์ธก์น๊ฐ ํน์ ํด๋์ค์ ์ํ ํ๋ฅ ๊ฐ์ผ๋ก ๊ณ์ฐ๋๋ค.
๋ถ๋ฅ ๋ฌธ์ ์์๋ ํ๋ฅ ๊ฐ์ ์ฌ์ฉํ์ฌ ๋ถ๋ฅ๋ฅผ ํ๋๋ฐ, ํ๋ฅ ๊ฐ์ด ์ ํด์ง ๊ธฐ์ค๊ฐ๋ณด๋ค ํฌ๋ฉด 1 ์๋๋ฉด 0์ด๋ผ๊ณ ์์ธกํ๋ค.
Logit Transformation
๋ก์ง์คํฑ ํ๊ท์ ๊ณ์๋ ๋น์ ํ ํจ์ ๋ด์ ์์ด ์ง๊ด์ ์ผ๋ก ํด์ํ๊ธฐ๊ฐ ์ด๋ ต๋ค.
ํ์ง๋ง ์ค์ฆ(Odds)๋ฅผ ์ฌ์ฉํ๋ฉด ์ ํ๊ฒฐํฉ ํํ๋ก ๋ณํ์ด ๊ฐ๋ฅํ์ฌ ์ฝ๊ฒ ํด์์ด ๊ฐ๋ฅํด์ง๋ค.
์ค์ฆ๋ ์คํจํ๋ฅ ์ ๋ํ ์ฑ๊ณตํ๋ฅ ์ ๋น์ธ๋ฐ ์ค์ฆ๊ฐ 4 ์ด๋ฉด ์ฑ๊ณตํ๋ฅ ์ด ์คํจํ๋ฅ ์ 4๋ฐฐ๋ผ๋ ๋ป์ด๋ค.
์ด๋, ์๋ ์์ฒ๋ผ ์ค์ฆ์ ๋ก๊ทธ๋ฅผ ์ทจํด ๋ณํํ๋ ๊ฒ์ ๋ก์ง๋ณํ(Logit Transformation) ์ด๋ผ๊ณ ํ๋ค.
๋ก์ง๋ณํ์ ํตํด ๋น์ ํํํ์ธ ๋ก์ง์คํฑ ํจ์๋ฅผ ์ ํํํ๋ก ๋ง๋ค์ด ํ๊ท๊ณ์์ ์๋ฏธ๋ฅผ ํด์ํ๊ธฐ ์ฝ๊ฒ ํ๋ค.
ํน์ ํน์ฑ(feature)์ ์ฆ๊ฐ์ ๋ฐ๋ผ ๋ก์ง(ln(odds))์ด ์ผ๋ง๋ ์ฆ๊ฐ ํน์ ๊ฐ์ํ๋ค๊ณ ํด์ํ ์ ์๋ค.
โจ Logistic Regression ์์
Kaggle์ Titanic: Machine Learning from Disaster ๋ฐ์ดํฐ ์ฌ์ฉ
import pandas as pd
train = pd.read_csv('titanic_train.csv')
test = pd.read_csv('titanic_test.csv')
# ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ํ๋ จ/๊ฒ์ฆ ์ธํธ๋ก ๋ถ๋ฆฌ
from sklearn.model_selection import train_test_split
train, val = train_test_split(train, random_state=2)
๋ถ๋ฅ ๋ฌธ์ ์ ๊ธฐ์ค๋ชจ๋ธ (major class)๋ก ์์ธก ์ํ
# ํ๊ฒ ์ค์
target = 'Survived'
y_train = train[target]
# mode() : Return the highest frequency value in a Series
major = y_train.mode()[0]
# ํ๊ฒ ์ํ ์ ๋งํผ 0์ด ๋ด๊ธด ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ๊ธฐ์ค๋ชจ๋ธ๋ก ์์ธก
y_pred = [major] * len(y_train)
from sklearn.metrics import accuracy_score
# ํ๋ จ ๋ฐ์ดํฐ์์์ ๊ธฐ์ค๋ชจ๋ธ ์ ํ๋
print("training accuracy: ", accuracy_score(y_train, y_pred))
>>> training accuracy: 0.625748502994012
# ๊ฒ์ฆ ๋ฐ์ดํฐ์์์ ๊ธฐ์ค๋ชจ๋ธ ์ ํ๋
y_val = val[target]
y_pred = [major] * len(y_val)
print("validation accuracy: ", accuracy_score(y_val, y_pred))
>>> validation accuracy: 0.5874439461883408
์ ํํ๊ท๋ชจ๋ธ๋ก ํ์ตํ ๊ฒฐ๊ณผ
from sklearn.linear_model import LinearRegression
linear_model = LinearRegression()
# ์ซ์ํ ํน์ฑ๋ง ์ฌ์ฉ
features = ['Pclass', 'Age', 'Fare']
X_train = train[features]
X_val = val[features]
# Age, Cabin์ ๊ฒฐ์ธก์น๋ฅผ ํ๊ท ๊ฐ์ผ๋ก ๋์ฒดํ๊ธฐ ์ํด์ SimpleImputer ๋ชจ๋ธ ์ฌ์ฉ
from sklearn.impute import SimpleImputer
# default, imputing 'mean' value
imputer = SimpleImputer()
X_train_imputed = imputer.fit_transform(X_train)
X_val_imputed = imputer.transform(X_val)
# ํ์ต
linear_model.fit(X_train_imputed, y_train)
# ์์ธก
pred = linear_model.predict(X_val_imputed)
# ํ๊ท๊ณ์ ํ์ธ
pd.Series(linear_model.coef_, features)
output :
- Pclass ๊ฐ์ด ๋์์๋ก(2,3๋ฑ์) ์์กด์จ์ด ๋จ์ด์ง
- Age ๊ฐ์ด ๋ง์์๋ก ์์กด์จ์ด ๋จ์ด์ง
- Fare ๊ฐ์ด ๋์์๋ก ์์น๊ฐ ์์ง๋ง ์์กด์จ์ด ์ฌ๋ผ๊ฐ
๋ก์ง์คํฑ ํ๊ท๋ชจ๋ธ๋ก ํ์ตํ ๊ฒฐ๊ณผ
from sklearn.linear_model import LogisticRegression
logistic = LogisticRegression()
# ํ์ต
logistic.fit(X_train_imputed, y_train)
# ์์ธก
pred = logistic.predict(X_val_imputed)
print('๊ฒ์ฆ์ธํธ ์ ํ๋', logistic.score(X_val_imputed, y_val))
>>> ๊ฒ์ฆ์ธํธ ์ ํ๋ 0.7130044843049327
print(features)
print(logistic.coef_)
output :
ํ์ดํ๋ ๋ฐ์ดํฐ์ ๋ชจ๋ ํน์ฑ์ ์ฌ์ฉํ ๋ชจ๋ธ ํ์ต ๊ฒฐ๊ณผ
['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
- ์นดํ ๊ณ ๋ฆฌ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํ OneHotEncoder
- ๊ฒฐ์ธก์น ์ฒ๋ฆฌ๋ฅผ ์ํ SimpleImputer
- ํน์ฑ๋ค์ ์ฒ๋๋ฅผ ๋ง์ถ๊ธฐ๋ฅผ ์ํด ํ์ค์ ๊ท๋ถํฌ๋ก ํ์คํํ๋ StandardScaler
from category_encoders import OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
target = 'Survived'
X_train = train[features]
y_train = train[target]
X_val = val[features]
y_val = val[target]
# ๋ฒ์ฃผํ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
encoder = OneHotEncoder(use_cat_names=True)
X_train_encoded = encoder.fit_transform(X_train)
X_val_encoded = encoder.transform(X_val)
# ๊ฒฐ์ธก์น ์ฒ๋ฆฌ
imputer = SimpleImputer(strategy='mean')
X_train_imputed = imputer.fit_transform(X_train_encoded)
X_val_imputed = imputer.transform(X_val_encoded)
# ํ์คํ
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_imputed)
X_val_scaled = scaler.transform(X_val_imputed)
model = LogisticRegression(random_state=1)
# ํ์ต
model.fit(X_train_scaled, y_train)
# ์์ธก
y_pred = model.predict(X_val_scaled)
accuracy_score(y_val, y_pred)
>>> 0.7892376681614349
coefficients = pd.Series(model.coef_[0], X_train_encoded.columns)
coefficients
output :
- ์ข์ ๋ฑ๊ธ์ด ๋์์๋ก, ๋์ด๊ฐ ์ด๋ฆด์๋ก, ๋จ์ฑ๋ณด๋ค๋ ์ฌ์ฑ์ ์์กด์จ์ด ๋ ๋๋ค.
coefficients.sort_values().plot.barh()
output :
'Boot Camp > section2' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[AIB] One Hot Encoding, Feature Selection, Ridge Regression (0) | 2022.03.30 |
---|---|
[AIB] Bias, Variance, R-Square, Multiple Regression, Evaluation Metrics (0) | 2022.03.25 |
[AIB] OLS, MAE, RSS, Simple Regression (0) | 2022.01.07 |