[Machine Learning] - Tips
2021. 2. 14. 13:20ㆍ[TIPs]/Machine Learning
[Pip-Installation (Google Colab)]
%%capture
import sys
if 'google.colab' in sys.modules:
# Install packages in Colab
!pip install category_encoders==2.*
!pip install pandas-profiling==2.*
!pip install -U scikit-learn==2.*
# 필요한 pacakge이 있으면 이런 형태로 추가를 시켜주면 개별적으로 pip install 안해줘도 됨
# download 과정도 출력으로 안 뜸
[Machine Learning]
A. Regression Models
1. Simple Regression
# train_data, test_data 라는 dataframe이 있다고 가정
from sklearn.linear_model import LinearRegression
# 모델 학습시킬 데이터 구분하기
model = LinearRegression()
feature = ['a'] # 'a' feature 라고 가정
target = ['b'] # 'b' target 이라고 가정
X_train = train_data[feature]
y_train = train_data[target]
# 모델 학습시키기
model.fit(X_train, y_train)
# 모델의 slope & y_intercept 구하기
model_slope = model.coef_ # array 형태로 반환
model_y_intercept = model.intercept_ # array 형태로 반환
# 학습한 모델을 바탕으로 예측하기
X_test = [[x] for x in test_data['a']] # list 형태
y_pred = model.predict(X_test) # array 형태
2. Multiple Regression
# train_data, test_data 라는 dataframe이 있다고 가정
# train_data : 학습할 데이터
# test_data : 예측용 데이터
from sklearn.linear_model import LinearRegression
# 데이터 구분하기 (X_train, X_test, y_train, y_test)
model = LinearRegression()
features = ['a','b'] # 'a','b' feature 라고 가정
target = ['c'] # 'c' target 이라고 가정
X_train = train_data_df[features]
X_test = test_data_df[features]
y_train = train_data_df[target]
y_test = test_data_df[target]
# 모델 학습시키기
model.fit(X_train, y_train)
# 모델의 slope & y_intercept 구하기
model_slope = model.coef_ # array 형태로 반환 / slope 2 개 반환
model_y_intercept = model.intercept_ # array 형태로 반환
# 학습한 모델을 바탕으로 예측하기
y_pred = model.predict(X_test) # array 형태
3. Ridge Regression
3.A) Ridge
from sklearn.linear_model import Ridge
# X_train / y_train / X_test / y_test 라는 dataframe 이 있다고 가정
ridge = Ridge(alpha=, normalize=)
# alpha : lambda 값을 의미 (0 ~ 무한대에 사이에서 설정)
# normalize : ridge regression model을 만들기 전 data를 normalize 할 건지 설정
ridge.fit(X_train,y_train)
ridge.coef_ # coefficients (feature 별 기울기) 반환
ridge.intercept_ # model 의 y-intercept (y 절편) 반환
ridge.predict(X_test) # test data에 대한 예측값 반환
3.B) Ridge CV
pip install -U scikit-learnfrom sklearn.linear_model import RidgeCV
# X_train / y_train / X_test / y_test 라는 dataframe 이 있다고 가정
alpha_list = np.arange(0,1,0.01)
ridgeCV = RidgeCV(alphas=alpha_list, normalize=, cv=)
# alpha : lambda 값을 의미 (0 ~ 무한대에 사이에서 설정)
# normalize : ridge regression model을 만들기 전 data를 normalize 할 건지 설정
# cv : 몇개의 fold 로 cross validation을 진행할 건지 설정
ridgeCV.fit(X_train,y_train)
ridgeCV.coef_ # coefficients (feature 별 기울기) 반환
ridgeCV.intercept_ # model 의 y-intercept (y 절편) 반환
ridgeCV.alpha_ # Cost Function을 가장 낮게 만드는 lambda 값 반환 (alpha_list 중에 선택)
ridgeCV.best_score_ # best lambda 값으로 만들어진 train data 의 score 반환
ridgeCV.predict(X_test) # test data에 대한 예측값 반환
4. Logistic Regression
from sklearn.linear_model import LogisticRegression
# X_train / y_train / X_test / y_test 라는 DataFrame이 있다고 가정
logistic = LogisticRegression()
logistic.fit(X_train,y_train)
logistic.score(X_test,y_train) # test data에 대한 accuracy 반환
B. Classification Models
1. Decision Tree
from category_encoders import OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.tree import DecisionTreeClassifier
# X_train / y_train / X_validation / y_validation 이라는 dataframe이 있다고 가정
pipe = make_pipeline(
OneHotEncoder(use_cat_names=True),
SimpleImputer(),
DecisionTreeClassifier(random_state=, criterion=, min_samples_split=, min_samples_leaf=, max_depth=)
)
# random_state : randomness 지정
# criterion : 'gini' or 'entropy' (default='gini')
# min_samples_split : split하기 위한 최소로 있어야 되는 sample 수 지정 (default = 2)
# min_samples_leaf : leaf node에 최소로 있어야 되는 sample 수 지정 (default = 1)
# max_depth : maximum depth 지정 (default = None)
pipe.fit(X_train, y_train) # model fit 시키기
pipe.score(X_validation, y_validation)) # accuracy score 반환
# attributes
.get_depth() # depth 수 반환
.get_n_leaves() # leaf nodes 수 반환
2. Random Forest
from category_encoders import OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
# X_train / y_train / X_validation / y_validation data 가 있다고 가정
pipe = make_pipeline(
OneHotEncoder(), # encoding 수행
SimpleImputer(), # nan값 처리하기 (default : 각 column의 mean으로 처리)
RandomForestClassifier(
n_jobs=-1,
random_state=,
oob_score=True,
n_estimators=,
criterion=,
max_depth=,
min_samples_split=,
min_samples_leaf=,
max_features=
)
)
# n_jobs : -1 로 설정해주면 모든 processers 가동한다는 의미 (좀 더 빠르게 model 학습시킬 수 있음)
# random_state : int 형 / seed값 설정해주면 sample bootstrapping 를 control할 수 있음
# oob_score : True 로 설정해주면 OOB sample을 써서 검증을 진행하겠다는 의미
# n_estimators : # of trees 지정
# criterion : 'gini' or 'entropy'
# max_depth : maximum depth 설정
# min_samples_split : node를 split (가지치기) 하는 최소한의 sample 수 지정
# min_samples_leaf : leaf node 가 되기 위한 최소한의 sample 수 지정
# max_features : 'auto' or 'sqrt' or 'log2' or int형 or float형 (default : auoto) tree에 담을 최대한의 feature의 수 지정
# ex) sqrt로 설정해주면 총 data feature 수에 루트를 씌어준 값을 tree에 담을 최대한의 feature수로 본다는 의미
pipe.fit(X_train, y_train) # train data에 학습시키기
# Attributes
pipe.score(X_validation, y_validation) # validation data의 accuracy 반환
pipe.named_steps['randomforestclassifier'].oob_score_ # OOB sample에 대한 accuracy 반환
pipe.predict(X_test) # test data에 대한 예측값 반환
[Encoders]
pip install category_encoders
1. One-Hot Encoder
from category_encoders import OneHotEncoder
# X_train / X_test 라는 dataframe 이 있다고 가정
# use_cat_name = True 를 설정하면 encoded 된 column의 이름 앞에 categorical data의 이름이 prefix로 붙는다
encoder = OneHotEncoder(use_cat_names = True)
X_train = encoder.fit_transform(X_train)
X_test = encoder.transform(X_test)
2. Ordinal Encoder
from category_encoders import OrdinalEncoder
# X_train / X_validation 이라는 data가 있다고 가정
# ord_enc 에 OrdinalEncoder() 담기
ord_enc = OrdinalEncoder()
ord_enc.fit_transform(X_train) # train data 에 의해 fit 하고 변환시켜줌
ord_enc.transform(X_validation) # validation data 변환
3. Target Encoder
from category_encoders import TargetEncoder
# X_train / y_train / X_validation 이라는 data가 있다고 가정
# targ_enc 에 TargetEncoder() 담기
targ_enc = TargetEncoder()
targ_enc.fit_transform(X_train,y_train) # train data 에 의해 fit 하고 변환시켜줌
targ_enc.transform(X_validation) # validation data 변환
[Imputers]
1. Simple Imputer
- nan 값 처리하는 가장 기본적인 method
from sklearn.impute import SimpleImputer
# X_train / X_validation 이라는 data가 있다고 가정
simp_imp = SimpleImputer(strategy=) # mean / most_frequent / median
# X_train imputing 적용 (fit & transform)
imputed_X_train = simp_imp.fit_transform(X_train)
# X_validation imputing 적용 (transform)
imputed_X_validation = simp_imp.transform(X_validation)
2. Iterative Imputer
- 다른 feature 와의 관계를 바탕으로 imputing 하는 method
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
# X_train / X_validation 이라는 data가 있다고 가정
simp_imp = IterativeImputer(initial_strategy=) # mean / most_frequent / median
# X_train imputing 적용 (fit & transform)
imputed_X_train = simp_imp.fit_transform(X_train)
# X_validation imputing 적용 (transform)
imputed_X_validation = simp_imp.transform(X_validation)
[Feature Selection]
from sklearn.feature_selection import SelectKBest
# X_train / X_test 라는 dataframe 이 있다고 가정
selector = SelectKBest(score_func=, k=)
# score_func : feature & target 간의 관계를 알아보는 함수
# k : 원하는 feature 의 갯수
X_train_selected = selector.fit_transform(X_train, y_train)
X_test_selected = selector.transform(X_test)
-
score_func types (필요한 function은 import를 따로 해야함)
-
f_classif : ANOVA F-value 를 가지고 관계를 알아본다
-
chi2 : $\chi^2$ value 를 가지고 관계를 알아본다
-
f_regression : F-value를 가지고 관계를 알아본다
-
[Evaluation Metrics]
1. Simple Method
# y : 실제 label 값들 (array 형태)
# y_pred : 예측 label 값들 (array 형태)
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, accuracy_score
mse = mean_squared_error(y, y_pred) # mse (float)
mae = mean_absolute_error(y, y_pred) # mae (float)
rmse = mse ** 0.5 # rmse (float)
r2 = r2_score(y, y_pred) # r_squared (float)
accracy = accuracy_score(y, y_pred) # accuracy
2. Confusion Matrix Visualization
from sklearn.metrics import plot_confusion_matrix
# pipeline으로 만든 'model' 이 있다고 가정
# X_validation을 model에 돌린 예측값 & y_validation의 실제값과 비교
fig, ax = plt.subplots()
pcm = plot_confusion_matrix(model, X_validation, y_validation,
cmap=plt.cm.Blues,
ax=ax,
values_format='d');
plt.title(f'Confusion matrix, n = {len(y_validation)}', fontsize=13);
3. Classification Report
from sklearn.metrics import classification_report
# y_validation(실제값) / model로 도출해낸 y_validation_predicted(예측값)이 있다고 가정
print(classification_report(y_validation, y_validation_predicted))
4. ROC Curve & AUC Score
from sklearn.metrics import roc_curve
from sklearn.metrics import roc_auc_score
# best model 은 pipeline을 통해 만든 fit한 model
# X_validation data / y_validation data 가 있다고 가정
# fpr / tpr / threshold 담기
# class 1 에 대한 확률 예측값 담기
y_validation_proba = best_model.predict_proba(X_validation)[:,1]
fpr, tpr, thresholds = roc_curve(y_true = y_validation, y_score = y_validation_proba)
# auc score 값 반환 (1에 가까울수록 분류가 잘 된 model)
roc_auc_score(y_true = y_validation,y_score = y_validation_proba)
# optimal threshold 찾기
# tpr - fpr 중 가장 큰 값의 index 반환
optimal_idx = np.argmax(tpr - fpr)
# 최적 threshold 반환
optimal_threshold = thresholds[optimal_idx]
# optimum threshold을 반영한 validation data의 predicted array 구하기
# optimal_threshold 보다 높으면 True / 낲으면 False
y_validation_optimal_T_or_F = y_validation_proba >= optimal_threshold
# True면 1 / False면 0 반환
y_validation_pred = np.array(y_validation_optimal_T_or_F).astype(int)
# 위 prediction을 가지고 y_validation(실제값) 과 비교해보고 성능의 개선이 있다면 test data 에도 optimal_threshold 적용
[Split Data]
# train / validation / test data를 6:2:2 비율로 나누기
from sklearn.model_selection import train_test_split
# df 라는 DataFrame이 있다고 가정
# train / test data를 8:2 비율로 나눈다
train_df,test_df = train_test_split(df,test_size = 0.2,train_size=0.8,random_state = 42)
# test_size : test data 비율
# train_size : train data 비율
# random_state : 임의로 지정
# train / validation data를 6:2 비율로 나눈다
train_df,validation_df = train_test_split(train_df,test_size=0.25,random_state = 42)
# test_size 을 지정해주면 train_size 는 알아서 계산이 된다
[Pipeline Model]
from category_encoders import OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
# X_train / y_train / X_validation / y_validation / X_test data가 있다고 가정
pipe = make_pipeline(
OneHotEncoder(),
SimpleImputer(),
StandardScaler(),
LogisticRegression()
) # hyper parameter값으로 조정 가능
pipe.fit(X_train, y_train) # model fit 시키기
pipe.score(X_validation, y_validation)) # accuracy 반환
pipe.predict(X_test) # test data에 대한 예측값 반환
pipe.named_steps # 각 속성이 나타난다
# ex)
enc = pipe.named_steps['onehotencoder'] # pipeline에 담긴 onehotencoder를 빼온다는 개념
enc.fit(X_validation) # validation data에 one-hot encoding을 진행
[Feature Importance Visualization]
from category_encoders import OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.tree import DecisionTreeClassifier
# X_train / y_train 이라는 dataframe이 있다고 가정
pipe = make_pipeline(
OneHotEncoder(use_cat_names=True),
SimpleImputer(),
DecisionTreeClassifier(random_state=, criterion=, min_samples_split=, min_samples_leaf=, max_depth=)
)
pipe.fit(X_train, y_train) # model fit 시키기
# decision tree classifier 추출
decision_tree_classifier = pipe.named_steps['decisiontreeclassifier']
# feature importance coefficients 담기
feature_importance = importances = pd.Series(decision_tree_classifier.feature_importances_, X_train.columns)
# barplot 시각화
importances.sort_values().plot.barh();
[Model Optimzation]
1. Randomized Search CV
from sklearn.pipeline import make_pipeline
from category_encoders import OneHotEncoder
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform
from sklearn.ensemble import RandomForestClassifier
# X_train / y_train / X_validation / y_validation / X_test 의 data가 있다고 가정
# pipeline 활용한 model 만들기
ranfor_model = make_pipeline(
OneHotEncoder(use_cat_names=True),
SimpleImputer(),
RandomForestClassifier(random_state=42)
)
# hyperparamter 범위 담기
dists = {
'simpleimputer__strategy': ['mean', 'median','most_frequent'],
'randomforestclassifier__n_estimators': randint(50, 500),
'randomforestclassifier__max_depth': [5, 10, 15, 20, None],
'randomforestclassifier__max_features': uniform(0, 1),
'randomforestclassifier__min_samples_leaf': randint(10,50),
'randomforestclassifier__min_samples_split': randint(10,50)
}
# Randomize Search CV 적용
clf = RandomizedSearchCV(
ranfor_model,
param_distributions=dists,
n_iter=10,
cv=10,
scoring='f1',
verbose=10,
n_jobs=-1,
refit=True
)
# param_distribution : parameter 범위 지정
# n_iter : 몇번의 iteration을 진행할 건지 지정
# cv : 몇 개의 fold로 cross validation 진행할 건지 지정
# scoring : scoring method 지정
# verbose : 최적화 과정이 잘 진행되고 있는지 확인하는 용도 (클수록 message가 많이 뜸)
# n_jobs : -1 로 설정해주면 가장 빠르게 진행됨
# refit : True로 설정해주면 최적 hyperparameter로 tuning된 model이 clf에 담겨져 있다는 의미# train data에 fit 하기
clf.fit(X_train, y_train)
# Attributes
# 최적 hyperparameter 값 반환
clf.best_params_
# 최적 hyperparameter로 구한 score 반환 (scoring method에 따라서 다름)
clf.best_score_
# score 순위를 dataframe 형식으로 보기
pd.DataFrame(clf.cv_results_).sort_values(by='rank_test_score').T
# refit = False로 설정해주었다면 최적화 model을 아래와 같이 담을 수 있음
best_model = clf.best_estimator_
# test data 에 대한 예측값 반환
clf.predict(X_test)
2. Grid Search CV
- Attributes 는 Randomized Search CV 와 동일
from sklearn.pipeline import make_pipeline
from category_encoders import OneHotEncoder
from sklearn.model_selection import GridSearchCV
from scipy.stats import randint, uniform
from sklearn.ensemble import RandomForestClassifier
ranfor_model = make_pipeline(
OneHotEncoder(use_cat_names=True),
SimpleImputer(),
RandomForestClassifier(random_state=42)
)
dists = {'simpleimputer__strategy': ['mean'],
'randomforestclassifier__n_estimators': np.arange(317,322,1),
'randomforestclassifier__max_depth': [5, 10, 15, None],
'randomforestclassifier__max_features': [np.random.uniform(0,1)],
'randomforestclassifier__min_samples_leaf': np.arange(23,26,1),
'randomforestclassifier__min_samples_split': np.arange(40,45,1)}
grd = GridSearchCV(
estimator = ranfor_model,
param_grid=dists,
cv=2,
scoring='f1',
verbose=10,
n_jobs=-1
)
# train data에 fit 하기
grd.fit(X_train,y_train)728x90