머신러닝 심화과정(데이터분석 프로세스) - 실습하기, 교차검증, GridSearch

# titanic 데이터를 이용한 데이터분석 프로세스

1. 데이터 로드 & 분리

  ● train / test 데이터 분리

2. 탐색적 데이터 분석(EDA)

  ● 분포확인 & 이상치 확인

3. 데이터 전처리

  ●  결측치 처리

     - 수치형: Age

     - 범주형: Embarked

     - 삭제 : Cabin, Name

  ●  전처리

     - 수치형: Age, Fare, Sibsp+Parch

     - 범주형

        ▶ 레이블 인코딩: Pclass, Sex

        ▶ 원- 핫 인코딩: Embarked

4. 모델 수립

5. 평가

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

# 데이터가 원래 나뉘어져 있어서 각각 데이터를 불러온다.
train_df = pd.read_csv('C:/Users/user/Documents/ML/titanic/train.csv')
test_df = pd.read_csv('C:/Users/user/Documents/ML/titanic/test.csv')

test_df.head(3) # test 데이터는 원래 모르는 상태라는 점 참고하기

# 전처리할 데이터 정보 확인
train_df.info()
train_df.describe(include='all')

# 기초가공 : family 변수생성
train_df_2 = train_df.copy()
def get_family(df):
    df['Family'] = df['SibSp'] + df['Parch'] + 1
    return df
get_family(train_df_2).head(3)

# 숫자형 변수들의 이상치를 확인하기 위하여 pairplot
sns.pairplot(train_df_2[['Age', 'Fare', 'Family']])

train_df_2 = train_df_2[train_df_2['Fare'] < 512] # Fare 이상치 처리
train_df_2.shape
train_df_2[['Fare']].describe()


# 결측치 처리
def get_non_missing(df):
    Age_mean = train_df_2['Age'].mean()
    Fare_mean = train_df_2['Fare'].mean()  # test 데이터 결측치 처리

    df['Age'] = df['Age'].fillna(Age_mean)
    df['Fare'] = df['Fare'].fillna(Age_mean)  # test 데이터 결측치 처리
    df['Embarked'] = df['Embarked'].fillna('S')
    return df
get_non_missing(train_df_2).info() # 결측치 처리됐는지 확인

# 범주형 데이터 변환
def get_numeric_sc(df):
    # sd_sc : Fare, mm_sc : Age, Family
    from sklearn.preprocessing import StandardScaler, MinMaxScaler
    sd_sc = StandardScaler()
    mm_sc = MinMaxScaler()

    sd_sc.fit(train_df_2[['Fare']])
    df['Fare_sd_sc'] = sd_sc.transform(df[['Fare']])

    mm_sc.fit(train_df_2[['Age', 'Family']])
    df[['Age_mm_sc', 'Family_mm_sc']] = mm_sc.transform(df[['Age', 'Family']])

    return df
get_numeric_sc(train_df_2).describe()

# 인코딩 작업
def get_category(df):
    from sklearn.preprocessing import LabelEncoder, OneHotEncoder
    le = LabelEncoder()
    le2 = LabelEncoder()
    oe = OneHotEncoder()

    le.fit(train_df_2[['Pclass']])
    df['Pclass_le'] = le.transform(df['Pclass'])

    le2.fit(train_df_2[['Sex']])
    df['Sex_le'] = le2.transform(df['Sex'])

    # index reset을 하기 위한 구문
    df = df.reset_index()

    oe.fit(train_df_2[['Embarked']])
    embarked_csr = oe.transform(df[['Embarked']])
    embarked_csr_df = pd.DataFrame(embarked_csr.toarray(), columns=oe.get_feature_names_out())
    df = pd.concat([df, embarked_csr_df], axis=1)
    return df
train_df_2 = get_category(train_df_2)

train_df_2.info() # 데이터 확인

# 평가
def get_model(df):
    from sklearn.linear_model import LogisticRegression
    model_lor = LogisticRegression()
    X = df[['Age_mm_sc', 'Fare_sd_sc', 'Family_mm_sc', 'Pclass_le', 'Sex_le', 'Embarked_C', 'Embarked_Q', 'Embarked_S']]
    y = df[['Survived']]
    model_lor.fit(X,y)
    return model_lor

model_output = get_model(train_df_2)
model_output

X = train_df_2[['Age_mm_sc', 'Fare_sd_sc', 'Family_mm_sc', 'Pclass_le', 'Sex_le', 'Embarked_C', 'Embarked_Q', 'Embarked_S']]
y_pred = model_output.predict(X)

# 평가
from sklearn.metrics import accuracy_score, f1_score
print(accuracy_score(train_df_2['Survived'], y_pred))
print(f1_score(train_df_2['Survived'], y_pred))


# 테스트 데이터로 테트스 작업
test_df.info()

# 각 함수 적용
test_df_2 = get_family(test_df)
test_df_2 = get_non_missing(test_df_2)
test_df_2 = get_numeric_sc(test_df_2)
test_df_2 = get_category(test_df_2)

# 학습은 이미 되어있음
type(model_output)
# 내장 되어있는 것들
print(model_output.classes_)
print(model_output.coef_)
print(model_output.intercept_)

# 오류나면 컬럼 개수 및 종류 비교
train_df_2.columns
test_df_2.columns

test_X = test_df_2[['Age_mm_sc', 'Fare_sd_sc', 'Family_mm_sc', 'Pclass_le', 'Sex_le', 'Embarked_C', 'Embarked_Q', 'Embarked_S']]
# test_X.info() # null 값이 있음을 확인 -> 함수 정정하기 get_non_missing에 추가
y_test_pred = model_output.predict(test_X)

# 파일 저장 및 제출
sub_df = pd.read_csv('C:/Users/user/Documents/ML/titanic/gender_submission.csv')
sub_df['Survived'] = y_test_pred
sub_df.head(10) # 값이 바뀐 것 확인
sub_df.to_csv('./result.csv', index = False)

 

교차검증

데이터셋을 여러 개의 하위 집합으로 나누어 돌아가면서 검증 데이터로 사용하는 방법

 

● K-Fold Validation

 - 정의: Train Data를 K개의 하위 집합으로 나누어 모델을 학습시키고 모델을 최적화 하는 방법

 - 이때 K는 분할의 갯수

   Split 1: 학습용(Fold 2~5), 검증용(Fold1)

   Split 2: 학습용(Fold1, 3~5), 검증용(Fold2)

   Split 5까지 반복 후 최종 평가

▶ 데이터가 부족할 경우 유용하다. (반복 학습)

함수
skelarn.model_selection.KFold
sklearn.model_selection.StrifiedKFold # 불균형한 레이블(Y)를 가지고 있을 때 사용

 

# 실습

from sklearn.model_selection import KFold
import numpy as np

kfold = KFold(n_splits=5) # 사전에 5개의 폴더를 만든다.
scores = [] # split 마다의 각 평가 값을 넣는 빈 리스트

# X, y 변수 지정
X = train_df_2[
    ['Age_mm_sc', 'Fare_sd_sc', 'Family_mm_sc', 'Pclass_le', 'Sex_le', 'Embarked_C', 'Embarked_Q', 'Embarked_S']]
y = train_df_2['Survived']

# 5개의 split을 반복하니 5개의 값을 scores 빈 리스트에 저장하기
for i, (train_index, test_index) in enumerate(kfold.split(X)):  # enumerate 인덱스, 값을 동시에 전달하는 반복자
    X_train, X_test = X.values[train_index], X.values[test_index]
    y_train, y_test = y.values[train_index], y.values[test_index]

    from sklearn.linear_model import LogisticRegression
    from sklearn.metrics import accuracy_score

    model_lor2 = LogisticRegression()
    model_lor2.fit(X_train, y_train)
    y_pred2 = model_lor2.predict(X_test)
    accuracy = round(accuracy_score(y_test, y_pred2), 3)
    print(i, '번째 교차검증 정확도는', accuracy)
    scores.append(accuracy)

print('평균 정확도', np.mean(scores))

0 번째 교차검증 정확도는 0.792

1 번째 교차검증 정확도는 0.803

2 번째 교차검증 정확도는 0.775

3 번째 교차검증 정확도는 0.774

4 번째 교차검증 정확도는 0.836

평균 정확도 0.796

 

GridSearch

하이퍼 파라미터(Hyper Parameter)  : 모델을 구성하는 입력 값 중 사람이 임의적으로 바꿀 수 있는 입력 값

- 다양한 값을 넣고 실험할 수 있기 때문에 이를 자동화해주는 Grid Search를 적용해볼 수 있다.

from sklearn.model_selection import GridSearchCV

params = {'solver' : ['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'],
           'max_iter' : [100,200]}
grid_lor = GridSearchCV(model_lor2, param_grid = params, scoring='accuracy', cv = 5)
grid_lor.fit(X_train, y_train)

print('최고의 하이퍼 파라미터', grid_lor.best_params_)
print('최고의 정확도', grid_lor.best_score_.round(3))

최고의 하이퍼 파라미터 {'max_iter': 100, 'solver': 'newton-cg'}

최고의 정확도 0.785