AICE ASSOCIATE_정리

1. 데이터 불러오기 

- 라이브러리 임포트 및 설치 

# 라이브러리 불러오기
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

 

!pip install seaborn

- 데이터 로드 및 저장 

data = pd.read_csv('data.csv')

- 데이터 구성확인 및 다루기 

# 상위 데이터 확인 
data.head() 

# 하위 데이터 확인 
data.tail() 

# 데이터 정보 
data.info() 

# 데이터프레임 인덱스
data.index

# 데이터프레임 컬럼 
data.columns 

# 데이터프레임 값 
data.values 

# 데이터 크기 확인 
data.shape

# 특정 컬럼 데이터 확인 
data['_']

# 특정 컬럼 데이터별 개수 
data['_'].value_counts() 

# 데이터프레임 통계 
data.describe()

2. 데이터 전처리 

- 결측치 처리 

# Null(NaN) 값 확인 
data.isnull().sum() 

# 컬럼 삭제 
data.drop(columns=['_']) # data.drop(['_'], axis=1)

# 여러 컬럼 동시 제거
drop_cols = ['__', '__', '__', '__']
data.drop(drop_cols, axis=1, inplace=True)
#inplace반영 안했을 경우: data= data.drop(drop_cols, axis =1) 

# NaN이 포함된 모든 행(axis=0) 제거   
# 열 제거 drop/ 행 제거 dropna/ 행 채우기 fillna 
data.dropna(axis=0, inplace=True)

# 특정 변수에 NaN이 포함된 행 제거
# subset 기억! 
data.dropna(subset=['__'], axis=0, inplace=True)

# NaN 열이 포함된 모든 변수(axis=1) 제거
data.dropna(axis=1, inplace=True)

# __별 __ 평균 구하기 
data.groupby(by='__', as_index=False)[['__']].mean()

# 최빈값으로 채우기 
# NaN 값을 가장 빈도가 높은 값으로 채우기
# data['Embarked'].fillna('S', inplace=True)
data['Embarked'].fillna(data['Embarked'].mode()[0], inplace=True)

# 최빈값으로 채우기
data['__'].replace(np.nan, data['__'].mode(), inplace=True)

# 중앙값으로 채우기
data['__'].replace(np.nan, data['__'].median(), inplace=True)

# 앞/뒤 값으로 채우기 
# method='ffill': 바로 앞의 값으로 채우기 
# method='bfill': 바로 뒤의 값으로 채우기 

# Ozone 변수 NaN 값을 바로 앞의 값으로 채우기
air['Ozone'].fillna(method='ffill', inplace=True)
# Solar.R 변수 NaN 값을 바로 뒤의 값으로 채우기
air['Solar.R'].fillna(method='bfill', inplace=True)

# 선형 보간법으로 채우기 
# 선형 보간법으로 채우기
# air['Ozone'].interpolate(method='linear', inplace=True)
# air['Solar.R'].interpolate(method='linear', inplace=True)
air.interpolate(method='linear', inplace=True)

- 데이터인코딩 (라벨인코딩, 원핫인코딩) 

# 가변수화 
# 범주형 값을 갖는 변수(object형) 제거 
# 라벨 인코딩 -> 문자 형태의 feature 이름을 숫자로 
from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
data['__'] = le.fit_transform(data['__'])

# 원핫인코딩 
# 원핫 인코딩 -> 모든 feature를 0,1로 
pd.get_dummies(data=data, columns=['__'], drop_first=True)

3. 데이터셋 분리 

-X,y 분리 
-Train, Test 데이터셋 분리 

from sklearn.model_selection import train_test_split

X = data.drop(columns=['__'])
y = data['__']

# strarify: 비율에 맞게 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

 

4. 데이터 스케일링 

- 데이터 정규분포화, 표준화 

# 정규분포화(StandardScaler) 
from sklearn.preprocessing import StandardScaler

# StandardScaler 적용
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

5. 머신러닝 학습 

- 사이킷런으로 머신러닝 모델학습 및 성능평가 

# 로지스틱 회귀 (LogisticRegression) 
from sklearn.linear_model import LogisticRegression 
LR = LogisticRegression()
LR.fit(X_train, y_train)

#성능평가 및 시각화 
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

y_pred = LR.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot = True)

print(classification_report(y_test, y_pred))

# Decision Tree 
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)
clf.score(X_test, y_test)

# RandomForest 
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
rfc.fit(X_train, y_train)
rfc.score(X_test, y_test)

# XGBoost 
!pip install xgboost
import xgboost as xgb

xgb_model = xgb.XGBClassifier()
xgb_model.fit(X_train, y_train)
xgb_model.score(X_test, y_test)

y_pred = xgb_model.predict(X_test)
print(confusion_matrix(y_test, y_pred))

#Light GBM 
!pip install lightgbm
from lightgbm import LGBMClassifier

lgbm_model = LGBMClassifier()
lgbm_model.fit(X_train, y_train)
lgbm_model.score(X_test, y_test)

y_pred = lgbm_model.predict(X_test)
print(confusion_matrix(y_test, y_pred))

6. 딥러닝 학습 

- 텐서플로우로 딥러닝 모델 학습 

1_모델생성(Sequential): relu 함수, Dense 레이어 

2_모델컴파일: Adam, MSE, MAE 사용 

3_콜백함수 설정: EarlyStopping, ModelCheckpoint 

-주의: early stopping할 때 Val_loss 모니터링 꼭 할 것!

4_모델학습: x_train, y_train 사용, 모델 n epochs 학습 

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

try:
    model = Sequential()

    model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))
    model.add(Dropout(0.2))
    model.add(Dense(32, activation='relu'))
    model.add(Dropout(0.2))
    model.add(Dense(16, activation='relu'))
    model.add(Dropout(0.2))
    model.add(Dense(1, activation='sigmoid'))

    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
# 다중분류의 경우 손실함수 -> categorical_crossentropy 
# to_categorical 안하면 sparse_categorical_crossentropy 사용 
    es = EarlyStopping(monitor='val_loss', patience=4, mode='min', verbose=1)
    mc = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True, verbose=1)


    history = model.fit(X_train, y_train, 
                        batch_size=10, 
                        epochs=10, 
                        callbacks=[es, mc],
                        validation_data=(X_test, y_test), 
                        verbose=1)

- 성능평가 및 그래픽 출력 

# 학습정확도와 검증정확도 그래프 
plt.figure(figsize=(10,5))
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(['Train','Validation'], loc='lower right')

# 정확도 
y_test_pred = model.predict(X_test, batch_size=10, verbose=1)

y_test = np.argmax(y_test_ohe, axis=1)
y_test_pred = np.argmax(y_test_pred, axis=1)

from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_test_pred)

 

요약

1. 60분 내 완료할 수 있도록 연습! 

2. 가이드를 벗어나는 행동 하지 않기!

3. 프로세스는 동일하기 때문에 새로운 데이터가 나와도 당황 No! 

4. 모르는 내용이 나오면 구글링으로 적극 활용!

5. 가이드에 제시된 내용을 정확하게 수행! 

6. 답안 cell에만 작성하기! 

7. 데이터 불러오기: 반드시 파일명 정확히 기재! 

8. 시각화: 시각화 내용에 대한 해석과 데이터 처리 연습!

9. 전처리: 전처리 후에는 제시된 명칭의 새로운 데이터 프레임에 꼭 저장!