[M.L] AICE Associate 연습문제 및 키워드 정리

EDA & PREPROCESSING

1. 데이터타입 선택/변환하기 pd.numeric(arg, errors=’coerce’)

# 방법1 : pd.numeric(arg, errors='coerce') => 'ignore'로 하면 그냥 넘어간다.
df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], errors='coerce')
df.loc[df['TotalCharges'].isnull(), 'TotalCharges'] = 0

# 방법2 : 오류 발생부분 직접 수정하기
df['TotalCharges'].astype(float) # => 오류발생 원인 확인하기
df.loc[df['TotalCharges'] == " ", 'TotalCharges'] = '0' # => 문제발생부분 0으로 수정
df['TotalCharges'] = df['TotalCharges'].astype(float) # => 변환하기

2. 학습에 사용할 데이터 선택하기 df.select_dtypes(include='number')

col_nums = df.select_dtypes(include='number').columns

3. 데이터 정규화/표준화

• Log Scaler : np.log1p(), np.expm1()

# 편향된(skewed) 데이터를 보정할 때 사용 : np.log1p(X_train) == np.log(X_train + 1)
X_train_scaled = np.log1p(X_train)
X_test_scaled = np.log1p(X_test)

# 다시 되돌링려면 np.expm1() : np.expm1(X_train_scaled) == np.exp(X_train_scaled) - 1
X_train == np.expm1(X_train_scaled)

• Standar Scaler: sklearn.preprocessing.StandardScaler

from sklearn.preprocessing import StandardScaler
std_sc = StandardScaler()
X_train_scaled = std_sc.fit_transform(X_train)
X_test_scaled = std_sc.transform(X_test)

• Min-Max Scaler : sklearn.preprocessing.MinMaxScaler

from sklearn.preprocessing import MinMaxScaler
mm_sc = MinMaxScaler()
X_train_scaled = mm_sc.fit_transform(X_train)
X_test_scaled = mm_sc.transform(X_test)

4. One-Hot Encoding pd.get_dummies()

# 문자형(Object)데이터타입 컬럼의 nunique값 확인
df.select_dtypes(include='O').nunique()

# One-Hot Encoder : pd.get_dummies() 이용하기
X = pd.get_dummies(df.drop(columns=label_name))
y = df[label_name]

# shape 확인 : X(2차원,행렬), y(1차원,벡터)
X.shape, y.shape

5. X, y > 학습/테스트 데이터 분리하기

# X, y 만들기
label_name = 'Target_col_name'
feature_names = df.drop(columns=label_name).columns

y = df[label_name]
X - df[feature_names]
print(f"X.shape: {X.shape}, y.shape: {y.shape}")


# train_test_split
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
		X, y, test_size=0.2, stratify=y, random_state=42)

6. 오버샘플링 imblearn.over_sampling.SMOTE()

!pip install -U imbalanced-learn
from imblearn.over_sampling import SMOTE
smote = SMOTE(random_state=42)
X_train_over, y_train_over = smote.fit_resample(X_train, y_train)

# SMOTE 적용된 데이터셋 shape 확인하기
print('SMOTE 적용 전 학습용 피처/레이블 데이터 세트: ', X_train.shape, y_train.shape)
print('SMOTE 적용 후 학습용 피처/레이블 데이터 세트: ', X_train_over.shape, y_train_over.shape)

# SMOTE 적용된 레이블 값 분포 확인하기 : 0, 1의 갯수 동일
print(pd.Series(y_train_over).value_counts())

7. 데이터 시각화 (Data Visualization)

User guide and tutorial — seaborn 0.12.2 documentation

https://seaborn.pydata.org/tutorial.html#

Quick start guide — Matplotlib 3.7.2 documentation

https://matplotlib.org/stable/tutorials/introductory/quick_start.html#sphx-glr-tutorials-introductory-quick-start-py

M.L (Machine Learning)

8. 모델 생성

# from sklearn.linear_model import LogisticRegression

# !pip install xgboost
# from xgboost import XGBClassifier

# !pip install lightgbm
from lightgbm import LGBMClassifier
lgbm = LGBMClassifier(n_estimators=3, random_state=42)
lgbm.fit(X_train, y_train)

lgbm_pred = lgbm.predict(X_test)

9. cross_val_predict

from sklearn.model_selection import cross_val_predict

y_valid_predict = cross_val_predict(model, X_train, y_train, 
                                    cv=5, n_jobs=-1, verbose=1)
y_valid_predict[:2]

10. Feature_Importance : 변수 중요도 시각화

# feature_names_in_ : 모델에 사용된 컬럼(feature)의 이름
# feature_importances : 모델에서 predict하는데 사용되는 중요도
f_i = pd.DataFrame(data=model.feature_importances_, 
                   index=model.feature_names_in_)

# 중요도 순으로 정렬 > 상위 N개 선택 > 수평바(barh)로 시각화
f_i.sort_values(by=0).head(10).plot().barh()

11. Confusion Matrix

• 정밀도 precision_score = TP / (FP + TP)

• 재현율 recall_score = TP / (FN + FP)

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report

• 재현율이 너무 나오지 않을 경우?
⇒ predict_proba의 threshold 값을 조정한다.
03-03. 정밀도와 재현율
위키북스의 파이썬 머신러닝 완벽 가이드 책을 토대로 공부한 내용입니다.

https://velog.io/@sset2323/03-03.-정밀도와-재현율#2-정밀도재현율-trade-off


from sklearn.preprocessing import Binarizer

# Binarizer의 threshold 값을 0.5로 설정
custom_threshold = 0.5

# Positive 클래스의 컬럼 하나만 추출하여 Binarizer를 적용
proba_1 = model.predict_proba(X_test)[:,1].reshape(-1,1)

# 조정된 custom_threshold를 기준으로 다시 예측
binarizer=Binarizer(threshold=custom_threshold).fit(proba_1)
custom_pred = binarizer.transform(proba_1)

# custom_pred의 정확도 및 재현율 확인
print(f"정확도 : {accuracy_score(y_test, custom_pred)}")
print(f"재현율 : {recall_score(y_test, custom_pred)}")

D.L (Deep Learning)

12. 모델 생성하기

• 라이브러리 임포트

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

tf.random.set_seed(100)

batch_size = 16
epochs = 20

• Sequential 모델 layer 쌓기

# Sequential() 모델 정의 하고 model로 저장
# input layer는 input_shape=() 옵션을 사용한다.
# 39개 input layer
# unit 4개 hidden layer
# unit 3개 hidden layer
# 1개 output layser : 이진분류


model = Sequential()
model.add(Dense(4, activation='relu', input_shape=(39,)))
model.add(Dropout(0.3))
model.add(Dense(3, activation='relu'))
model.add(Dropout(0.3)) # 과적합 방지
model.add(Dense(1, activation='sigmoid'))

• 출력층

# 이진분류
model.add(Dense(1, activation='sigmoid'))

# 다중분류
model.add(Dense(2, activation='softmax'))

• model.summary

# 만들어진 모델 확인
model.summary()

13. 모델 컴파일

• 다중 분류 모델 (Y값을 One-Hot-Encoding 한경우)model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

• 다중 분류 모델 (Y값을 One-Hot-Encoding 하지 않은 경우)model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

• 예측 모델 model.compile(optimizer='adam', loss='mse')

# 모델 컴파일
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

14. 모델 학습

model.fit(X_train, y_train,
          validation_data=(X_test, y_test),
          epochs=10,
          batch_size=10)

15. Callback : 조기 종료

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# val_loss 모니터링해서 성능이 5번 지나도록 좋아지지 않으면 조기 종료
early_stop = EarlyStopping(monitor='val_loss', mode='min',
                           verbose=1, patience=5)

# val_loss 가장 낮은 값을 가질때마다 모델저장
check_point = ModelCheckpoint('best_model.h5', verbose=1,
                              monitor='val_loss', mode='min', save_best_only=True)

# 모델학습 : history에 저장하기
history = model.fit(x=X_train, y=y_train,
          epochs=50 , batch_size=20,
          validation_data=(X_test, y_test), verbose=1,
          callbacks=[early_stop, check_point])

16. 모델 성능 평가

• history.history 시각화하기

# history에서 history.history를 해야 가져올 수 있다. 
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Acc')
plt.legend(['acc', 'val_acc'])
plt.show()

• 성능 평가하기

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report

pred = model.predict(X_test)
# 66/66 [==============================] - 0s 1ms/step

pred.shape
# (2109, 2)

y_pred = np.argmax(pred, axis=1)

print(accuracy_score(y_test, y_pred))
print(recall_score(y_test, y_pred))
print(classification_report(y_test, y_pred))

# recall 성능을 올리면, 반대로 precision 성능은 떨어진다.

# 모델별로 Recall 점수 저장
# 모델 Recall 점수 순서대로 바차트를 그려 모델별로 성능 확인 가능

from sklearn.metrics import accuracy_score

my_predictions = {}

colors = ['r', 'c', 'm', 'y', 'k', 'khaki', 'teal', 'orchid', 'sandybrown',
          'greenyellow', 'dodgerblue', 'deepskyblue', 'rosybrown', 'firebrick',
          'deeppink', 'crimson', 'salmon', 'darkred', 'olivedrab', 'olive',
          'forestgreen', 'royalblue', 'indigo', 'navy', 'mediumpurple', 'chocolate',
          'gold', 'darkorange', 'seagreen', 'turquoise', 'steelblue', 'slategray',
          'peru', 'midnightblue', 'slateblue', 'dimgray', 'cadetblue', 'tomato'
         ]

# 모델명, 예측값, 실제값을 주면 위의 plot_predictions 함수 호출하여 Scatter 그래프 그리며
# 모델별 MSE값을 Bar chart로 그려줌
def recall_eval(name_, pred, actual):
    global predictions
    global colors

    plt.figure(figsize=(12, 9))

    #acc = accuracy_score(actual, pred)
    acc = recall_score(actual, pred)
    my_predictions[name_] = acc * 100

    y_value = sorted(my_predictions.items(), key=lambda x: x[1], reverse=True)

    df = pd.DataFrame(y_value, columns=['model', 'recall'])
    print(df)

    length = len(df)

    plt.figure(figsize=(10, length))
    ax = plt.subplot()
    ax.set_yticks(np.arange(len(df)))
    ax.set_yticklabels(df['model'], fontsize=15)
    bars = ax.barh(np.arange(len(df)), df['recall'])

    for i, v in enumerate(df['recall']):
        idx = np.random.choice(len(colors))
        bars[i].set_color(colors[idx])
        ax.text(v + 2, i, str(round(v, 3)), color='k', fontsize=15, fontweight='bold')

    plt.title('recall', fontsize=18)
    plt.xlim(0, 100)

    plt.show()