💠 AIchemist 1주차 💠

 

 

⏰ 진행 타임라인 ⏰

19:00 ~ 19:15       근황 토크 및 과제 확인
19:20 ~ 20:00      강의 세션
20:00 ~ 20:05     쉬는 시간
20:05 ~ 20:25     Q&A
20:25 ~ 21:00      실습 

 

 

1.  개념 정리

https://sosoeunii.tistory.com/91

💠 Python 기반 머신러닝 - NumPy, Pandas 💠

https://sosoeunii.tistory.com/92

💠 사이킷런 ( scikit-learn )💠

 

 

2.  Q&A

1. Ndarray vs DataFrame

    구조적 차이 / 데이터 셀렉션 방법 - [ ] 연산자

2.  DataFrame vs Series

3.  groupby란?

4.  교차 검증이 필요한 이유

5.  머신러닝 프로세스 정리

 

 

3.  실습

 

<붓꽃 품종 예측하기>

 

필요한 모듈 import

from sklearn.datasets import load_iris        # 내장 데이터set
from sklearn.tree import DecisionTreeClassifier      # 트리 기반 ML 알고리즘
from sklearn.model_selection import train_test_split      # 학습/테스트 데이터 분리

 

import pandas as pd

iris = load_iris()     # 붓꽃 데이터set 로딩하기
iris_data = iris.data     # iris.data : Iris 데이터set에서 피처 데이터를 numpy로 가짐
iris_label = iris.target     # iris.target : Iris 데이터set에서 레이블(결정값) 데이터를 numpy로 가짐

print('iris target 값: ', iris_label)
print('iris target 명: ', iris.target_names)

# 붓꽃 데이터set DataFrame 형식으로 변환
iris_df = pd.DataFrame(data = iris_data, columns = iris.feature_names)
iris_df['label'] = iris.target
iris_df.head(3)

 

# 학습/테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(iris_data, iris_label, test_size = 0.2, random_state=11)


dt_clf = DecisionTreeClassifier(random_state = 11)	# 결정 트리 객체 생성

dt_clf.fit(X_train, y_train)	# fit()함수 : 학습 데이터로 모델 학습시키기
pred = dt_clf.predict(X_test)	# predict()함수 : 테스트 데이터로 모델 예측

# 평가 - 정확도
from sklearn.metrics import accuracy_score
print('예측 정확도: {0:.4f}'.format(accuracy_score(y_test, pred)))

 

 

< 타이타닉 생존자 예측 >

 

import 해야 되는 거

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

 

데이터 세팅

titanic_df = pd.read_csv('/Users/jeongsoeun/Downloads/titanic_train.csv')
print('\n ### 학습 데이터 정보 ### \n')
print(titanic_df.info())

 

데이터 전처리 - Null값 처리

titanic_df['Age'].fillna(titanic_df['Age'].mean(), inplace = True)
titanic_df['Cabin'].fillna('N', inplace = True)
titanic_df['Embarked'].fillna('N', inplace = True)
print('데이터 세트 Null 값 개수 ', titanic_df.isnull().sum().sum())

 

Cabin 칼럼 - 가장 앞글자 기준으로 초기화

print(' Sex 값 분포 : \n', titanic_df['Sex'].value_counts())
print('\n Cabin 값 분포 :\n', titanic_df['Cabin'].value_counts())
print('\n Embarked 값 분포 :\n', titanic_df['Embarked'].value_counts()

titanic_df['Cabin'] = titanic_df['Cabin'].str[:1]
print(titanic_df['Cabin'].head(3))

 

성별 기준으로 생존 여부 카운트 -> 시각화

#'Sex', 'Survived' 칼럼 groupby 후 'Sex'를 기준으로 'Survived' 개체 count
titanic_df.groupby(['Sex','Survived'])['Survived'].count()

# 데이터 시각화 - Seaborn 패키지 이용
sns.barplot(x='Sex', y = 'Survived', data = titanic_df)
sns.barplot(x='Pclass', y = 'Survived', hue = 'Sex', data = titanic_df)

# 나이별로 카테고리 구분하는 함수
def get_category(age):
    cat=''
    if age <= -1: cat='Unknown'
    elif age <= 5: cat = 'Baby'
    elif age <= 12: cat = 'Child'
    elif age <= 18: cat = 'Teenager'
    elif age <= 25: cat = 'Student'
    elif age <= 35: cat = 'Young Adult'
    elif age <= 60: cat = 'Adult'
    else: cat = 'Elderly'
    
    return cat

# 막대 그래프의 크기 figure를 더 크게 설정
plt.figure(figsize=(10, 6))

# 카테고리 이름
group_names=['Unknown', 'Baby', 'Child', 'Teenager', 'Student', 'Young Adult', 'Adult', 'Elderly']

# 'Age_cat' 칼럼 초기화 -> lambda식으로( x: 'Age' 칼럼 요소, get_category 함수에 x 대입 )
titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x : get_category(x))

# 데이터 시각화
sns.barplot(x = 'Age_cat', y = 'Survived', hue = 'Sex', data = titanic_df, order = group_names)

# 'Age_cat' 칼럼 삭제, 원본 삭제
titanic_df.drop('Age_cat', axis = 1, inplace = True)

 

데이터 전처리 - 레이블 인코딩

from sklearn.preprocessing import LabelEncoder

def encode_features(dataDF):
    features = ['Cabin', 'Sex', 'Embarked']
    for feature in features:
    	# LabelEncoder 객체 생성
        le = LabelEncoder()
        
        # features의 요소를 칼럼명으로 갖는 칼럼 -> fit()과 transform() 적용해서 칼럼 초기화
        le = le.fit(dataDF[feature])
        dataDF[feature] = le.transform(dataDF[feature])
    
    return dataDF

titanic_df = encode_features(titanic_df)
titanic_df.head()

 

데이터 전처리 과정 총정리

def fillna(df):
    df['Age'].fillna(df['Age'].mean(), inplace = True)
    df['Cabin'].fillna('N', inplace = True)
    df['Embarked'].fillna('N', inplace = True)
    df['Fare'].fillna('N', inplace = True)
    return df

def drop_features(df):
    df.drop(['PassengerId', 'Name', 'Ticket'], axis = 1, inplace = True)
    return df

def format_features(df):
    df['Cabin'] = df['Cabin'].str[:1]
    features = ['Cabin', 'Sex', 'Embarked']
    for feature in features:
        le = LabelEncoder()
        le = le.fit(df[feature])
        df[feature] = le.transform(df[feature])
    return df

def transform_features(df):
    df = fillna(df)
    df = drop_features(df)
    df = format_features(df)
    return df
    
  
titanic_df = pd.read_csv('/Users/jeongsoeun/Downloads/titanic_train.csv')
y_titanic_df = titanic_df['Survived']
X_titanic_df = titanic_df.drop('Survived', axis = 1)
X_titanic_df = transform_features(X_titanic_df)

 

학습 데이터, 테스트 데이터 분리

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_titanic_df, y_titanic_df, test_size = 0.2, random_state = 11)

 

ML 알고리즘 - 결정 트리, 랜덤 포레스트, 로지스틱 회귀

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

dt_clf = DecisionTreeClassifier(random_state = 11)
rf_clf = RandomForestClassifier(random_state = 11)
lr_clf = LogisticRegression(solver = 'liblinear')

# 결정 트리 - 학습/예측/평가
dt_clf.fit(X_train, y_train)
dt_pred = dt_clf.predict(X_test)
print('DecisionTreeClassifier 정확도: {0:.4f}'.format(accuracy_score(y_test, dt_pred)))

# 랜덤 포레스트 - 학습/예측/평가
rf_clf.fit(X_train, y_train)
rf_pred = rf_clf.predict(X_test)
print('RandomForestClassifier 정확도: {0: .4f}'.format(accuracy_score(y_test, rf_pred)))

# 로지스틱 회귀 - 학습/예측/평가
lr_clf.fit(X_train, y_train)
lr_pred = lr_clf.predict(X_test)
print('LogisticRegression 정확도: {0:.4f}'.format(accuracy_score(y_test, lr_pred)))

 

교차 검증 - KFold

from sklearn.model_selection import KFold

def exec_kfold(clf, folds = 5):
	# 폴드 세트가 5개인 KFold 객체 생성, 폴드 수만큼 예측 결과 저장을 위한 리스트 객체 생성
    kfold = KFold(n_splits = folds)
    scores=[]
    
    ### KFold 교차 검증 수행 ###
    
    # KFold 객체의 split()을 호출하면 폴드 별 학습, 테스트 데이터의 로우 인덱스를 array로 변환
    # (iter_count, (학습 데이터 인덱스, 테스트 데이터 인덱스)) 튜플 형태로 반복문 수행 - enumerate
    for iter_count, (train_index, test_index) in enumerate(kfold.split(X_titanic_df)):
        X_train, X_test = X_titanic_df.values[train_index], X_titanic_df.values[test_index]
        y_train, y_test = y_titanic_df.values[train_index], y_titanic_df.values[test_index]
        
        # Classifier 학습, 예측, 정확도 계산
        clf.fit(X_train, y_train)
        predictions = clf.predict(X_test)
        accuracy = accuracy_score(y_test, predictions)
        scores.append(accuracy)
        print("교차 검증 {0} 정확도: {1:.4f}".format(iter_count, accuracy))
    
    # 5개 폴드에서 평균 정확도 계산 - mean() : 평균 계산
    mean_score = np.mean(scores)
    print("평균 정확도: {0:.4f}".format(mean_score))

exec_kfold(dt_clf, folds = 5)

 

교차 검증 - cross_val_score() API 이용

from sklearn.model_selection import cross_val_score

scores = cross_val_score(dt_clf, X_titanic_df, y_titanic_df, cv = 5)

for iter_count, accuracy in enumerate(scores):
    print("교차 검증 {0} 정확도: {1:.4f}".format(iter_count, accuracy))

print("평균 정확도: {0:.4f}".format(np.mean(scores)))

 

결정트리의 최적 하이퍼 파라미터 찾고 예측 성능 측정 - GridSearchCV

from sklearn.model_selection import GridSearchCV

parameters = {'max_depth':[2,3,5,10],
             'min_samples_split':[2,3,5], 'min_samples_leaf':[1,5,8]}

grid_dclf = GridSearchCV(dt_clf, param_grid=parameters, scoring = 'accuracy', cv = 5)
grid_dclf.fit(X_train, y_train)

print('GridSearchCV 최적 하이퍼 파라미터 :', grid_dclf.best_params_)
print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dclf.best_score_))
best_dclf = grid_dclf.best_estimator_

dpredictions = best_dclf.predict(X_test)
accuracy = accuracy_score(y_test, dpredictions)
print('테스트 세트에서의 DecisionTreeClassifier 정확도: {0:.4f}'.format(accuracy))

 

 

---

 

히히