object 타입은 범주형. 머신러닝에선 숫자형으로 바꾸어줘야 한다.

number 타입은 숫자형. 숫자형은 스케일링 해줘야 한다.

##################################전처리#################################

import pandas as pd

pd.read_csv(' 파일명 ')

df.columns 기억 #컬럼명 확인, s붙는거 기억

df.values 기억 #values 확인, s붙는거 기억

df.isnull().sum() 기억 #null 값 확인 ------------ () 괄호 위치 기억

df.shape #행 수, 열 수 확인할 수 있음

df.info() #df.info 말고 df.info()가 편리하다.

df.info #괄호가 없으면 ------------ 숫자형 데이터 가능성 있는 것들을 용이하게 확인할 수 있다.

df.describe() 기억 #"숫자형" 정보들의 통계정보를 보여준다.

df.boxplot() 기억 #숫자형 정보들의 boxplot을 볼 수 있다

df[' 해당컬럼 '].astype(float) 기억 #float type으로 컬럼들을 변경하여 보여줌(값이 바뀌지는 않음)

df[' 컬럼 '].replace( [' 값 '], [' 바꾼결과값 '], inplace=True) 기억 #replace로 값 바꾸기

                                                                       #boolean으로 공백찾기 - 예시는 밑에서 확인

(df[' 컬럼명' ] == > <등 조건식)

                                                                       #(예시) null이 아니지만 공란이거나 스페이스인 경우 확인

                                                                       #결과는=>    해당컬럼인덱스  탭  False나 True

cond = (df[' 조사대상컬럼명 '] == '') | (df[' 조사대상컬럼명 '] == ' ') #cond에 필터링 해서 True, False로 집어넣기

df[cond] #로 확인할 수 있음

df[' 컬럼 '].value_counts() 기억 #범주 별 건수 확인. 스펠, 언더바, 괄호 확인, value에 s 안 붙음

df[' 컬럼 '].replace(['Yes', 'No'], [1, 0], inplace = True) #replace에 여러 값을 한 번에 넣을 수도 있음

df.drop(' 컬럼명 ', axis = 1, inplace = True) #컬럼 제거, dropna 하기 전에 한 번 무조건 확인

df_BacDropna=df.copy() #drop하기 전에 백업해두는 것도 좋은방법일듯

df.dropna(inplace = True)

df.reset_index(drop = True) 기억 #인덱스 reorg

import matplotlib.pyplot as plt 기억 #시각화 임포트

df.value_counts().plot(kind = 'bar') 기억 #시각화는 value_counts와 짝꿍이다

       #한꺼번에 Object type 시각화하기, 그리고 불균형 심한거 제거하기

.select_dtypes('O') 기억 #Object type만 보기. O (대문자)대신 object(소문자)라고 해도 될 거다

.columns.values 기억 3columns.values

df.select_dtypes('O').columns.values 기억 #select_dtypes()와 columns.values 조합

변수명=df.select_dtypes('O').columns.values 로 담기 기억

for col in 변수명

       df[col].value_counts().plot(kind = 'bar')

       plt.title(col)

       plt.show()

#연속형 자료는 value_counts().plot으로 보는거 아니다

!pip install seaborn

import seaborn as sns

sns.histplot(data=df, x=' 컬럼명 ') 기억 histogram로 보기

sns.histplot(data=df, x=' 컬럼명 ', hue(' 컬럼명2 ')) 기억 컬럼명2로 비교

kdeplot #곡선

countplot #

df[[' 컬럼1 ', ... ' 컬럼n']].corr() 기억 여러 컬럼들의 상관관계분석 가능

sns.heatmap( ~~ .corr(), annot=True) 기억 히트맵으로 상관관계 볼 수 있음

sns.boxplot(data=df, x=' 컬럼명 ', y= ' 컬럼명2 ') 기억 boxplot으로 이상치 등을 볼 수 있음

df.to_csv(' 저장할파일명 ', index = False) 기억 csv파일로 저장하기. index=false를 줘야 index 없이 저장할 수 있음

###############################머신러닝################################

1) get_dummies

2) train_test_split

3) MinMaxScaler

df = pd.read_csv(' 파일 명 ', sep= " ~ ") 기억 csv 가져올 때

pd.get_dummies(data=df, columns=[' 컬럼명 ']) 기억 인코딩! 그리고 columns=[ ] 대괄호니까 안에 값이 여러개 들어갈 수도 있겠지

dum_list

df1=pd.get_dummies(data=df, columns=dum_list) 기억 columns=변수명 으로 해버려도 됨 (Q. columns=[dum_list]로 왜 안 하지?)

X=df1.drop(' 컬럼명 ', axis = 1).values 기억 뒤에 .values를 붙여야하는 걸 잊지마. 데이터프레임으로 저장이 아니라 값들만으로 저장해야해

X.shape, y.shape 기억 shape로 행 개수, 컬럼개수 확인 가능

from sklearn.model_selection import train_test_split

=train_test_split(X, y, test_size=0.3, stratify = y, random_state = 42) #트레인 세트 분리

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify = y, random_state = 42)

from sklearn.preprocessing import MinMaxScaler 기억 scaler 임포트

scaler = MinMaxScaler() 기억 scaler에 MinMaxScaler() 함수를 담는다.

X_train = scaler.fit_transform(X_train) 기억 X_train으로 scale을 fit함과 동시에 다시 그대로 담는다

X_test = scaler.transform(X_test) 기억 X_test를 위에서 fit 된걸 기반으로 담는다.

X_train[:2], y_train[:2] 기억 담긴거 확인(2개 컬럼만 확인한다)

==================================================함수

모델별로 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 recalleval(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()

===========================================함수 끝

X_train, X_test, y_train, y_test = train_test_split(X=X_train, stratify=y, random_state = 42)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state = 42)

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)

#===============================로지스틱

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix

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

from sklearn.metrics import classification_report

lg = LogisticRegression()

lg.fit(X_train, y_train)

lg.score(X_test, y_test)

lg_pred = lg.predict(X_test) #pred

confusion_matrix(y_test, lg_pred) #혼돈행렬

accuracy_score(y_test, lg_pred) #정확도

precision_score(y_test, lg_pred) #정밀도

recall_score(y_test, lg_pred) #재현율

f1_score(y_test, lg_pred) #정밀도 + 재현율

print(classification_report(y_test, lg_pred)) #한눈에 보기

recall_eval('LogisticRegression', lg_pred, y_test) #함수 불러와서 확인

#===============================KNN

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)

knn.fit(X_train, y_train)

knn.score(X_test, y_test)

knn_pred = knn.predict(X_test)

recall_eval('K-Nearest Neighbor', knn_pred, y_test)

#===============================Decision Tree

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(max_depth=10, random_state=42)

dt.fit(X_train, y_train)

dt_pred = dt.predict(X_test)

recall_eval('DecisionTree', dt_pred, y_test)

#===============================Random Forest

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, random_state=42)

rfc.fit(X_train, y_train)

rfc_pred = rfc.predict(X_test)

recall_eval('RandomForest Ensemble', rfc_pred, y_test)

#===============================XGBoost

!pip install xgboost

from xgboost import XGBClassifier

xgb = XGBClassifier(n_estimators=3, random_state=42)

xgb.fit(X_train, y_train)

xgb_pred=xgb.predict(X_test)

recall_eval('XGBoost', xgb_pred, y_test)

#==============================Light GBM

!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)

recall_eval('LGBM', lgbm_pred, y_test)

lgbm.score(X_test, y_test)

recall_score(y_test, lgbm_pred) #별도 재현율

#====================================================딥러닝

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

X_train.shape

y_train.shape

Sequential() 모델 정의 하고 model로 저장

input layer는 input_shape=() 옵션을 사용한다.

39개 input layer

unit 4개 hidden layer

unit 3개 hidden layer

1개 output layser : 이진분류

#Sequential 모델 만들기

model = Sequential()

model.add(Dense(4, activation='relu', input_shape=(39,)))

model.add(Dense(3, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

#모델 확인

model.summary()

#모델 만들기 - 과적합방지

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.summary()

#모델 컴파일

model.compile(optimizer='adam',

          loss='binary_crossentropy',

          metrics=['accuracy'])

#==================================DNN

앞쪽에서 정의된 모델 이름 : model

Sequential 모델의 fit() 함수 사용

@인자

X, y : X_train, y_train

validation_data=(X_test, y_test)

epochs 10번

batch_size 10번

#모델 FIT

model.fit(X_train, y_train,

      validation_data=(X_test, y_test),

      epochs=10,

      batch_size=10)

#모델 만들기

39개 input layer

unit 5개 hidden layer

dropout

unit 4개 hidden layer

dropout

2개 output layser : 다중분류

model = Sequential()

model.add(Dense(5, activation='relu', input_shape=(39,)))

model.add(Dropout(0.3))

model.add(Dense(4, activation='relu'))

model.add(Dropout(0.3))

model.add(Dense(2, activation='softmax'))

#모델 확인

model.summary()

#모델 컴파일

model.compile(optimizer='adam',

          loss='sparse_categorical_crossentropy',

          metrics=['accuracy'])

#모델 학습

history = model.fit(X_train, y_train,

      validation_data=(X_test, y_test),

      epochs=20,

      batch_size=16)

#조기 종료 모델, 모델 저장

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 = 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])

#모델 성능 평가

losses = pd.DataFrame(model.history.history)

losses.head()

#성능 시각화

losses[['loss','val_loss']].plot()

여러개 시각화

losses[['loss','val_loss', 'accuracy','val_accuracy']].plot()

그래프...?

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)

pred.shape

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

정확도 80%

accuracy_score(y_test, y_pred)

재현율 성능이 좋지 않다

recall_score(y_test, y_pred)

accuracy, recall, precision 성능 한번에 보기

print(classification_report(y_test, y_pred))

#================================== 재현율 성능 높이기

!pip install -U imbalanced-learn

#SMOTE 함수 이용하여 Oversampling

from imblearn.over_sampling import SMOTE

SMOTE 함수 정의 및 Oversampling 수행

smote = SMOTE(random_state=0)

X_train_over, y_train_over = smote.fit_resample(X_train, y_train)

print('SMOTE 적용 전 학습용 피처/레이블 데이터 세트: ', X_train.shape, y_train.shape)

print('SMOTE 적용 후 학습용 피처/레이블 데이터 세트: ', X_train_over.shape, y_train_over.shape)

SMOTE 적용 후 레이블 값 분포 : 0과 1 갯수가 동일

pd.Series(y_train_over).value_counts()

#데이터 정규화

MinMaxScaler

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

scaler.fit(X_train)

X_train_over = scaler.transform(X_train_over)

X_test = scaler.transform(X_test)

X_train_over.shape, y_train_over.shape, X_test.shape, y_test.shape

#모델 개발

model = Sequential()

model.add(Dense(64, activation='relu', input_shape=(39,)))

model.add(Dropout(0.3))

model.add(Dense(32, activation='relu'))

model.add(Dropout(0.3))

model.add(Dense(16, activation='relu'))

model.add(Dropout(0.3))

model.add(Dense(2, activation='softmax'))

model.compile(optimizer='adam',

          loss='sparse_categorical_crossentropy',

          metrics=['accuracy'])

여기서는 val_accuracy 모니터링해서 성능이 좋아지지 않으면 조기 종료 하게 함.

early_stop = EarlyStopping(monitor='val_accuracy', mode='max',

                       verbose=1, patience=5)

check_point = ModelCheckpoint('best_model.h5', verbose=1,

                          monitor='val_loss', mode='min',

                          save_best_only=True)

history = model.fit(x=X_train_over, y=y_train_over,

      epochs=50 , batch_size=32,

      validation_data=(X_test, y_test), verbose=1,

      callbacks=[early_stop, check_point])

#모델 성능 평가

losses = pd.DataFrame(model.history.history)

#위에 이어서

losses.head()

#성능 시각화

losses[['loss','val_loss']].plot()

losses[['loss','val_loss', 'accuracy','val_accuracy']].plot()

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)

pred.shape

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

정확도 70~80%

accuracy_score(y_test, y_pred)

재현율 70% 정도로 이전보다 좋아졌다.

recall_score(y_test, y_pred)

recall 성능을 올렸지만, 반대급부로 precision 성능은 떨어진다.

accuracy, recall, precision 어떤것에 집중할지 선택하는것도 필요하다.

print(classification_report(y_test, y_pred))

딥러닝 심층신경망(DNN) 모델 프로세스

데이터 가져오기

데이터 전처리

Train, Test 데이터셋 분할

데이터 정규화

DNN 딥러닝 모델

재현율 성능이 좋지 않다. 어떻게 성능향상 방법은?

Feature Engineering : 성능 잘 나올수 있도록 데이터 가공

불균현 데이터 문제 해소 : under-sampling, over-sampling

Over-Sampling 기법 : SMOTE