|
학습목차
1. 실습을 위한 KT AIDU 환경변수 설정
In [1]:
# 코드실행시 경고 메시지 무시
import warnings
warnings.filterwarnings(action='ignore')
AIDU 라이브러리 임포트
In [2]:
from aicentro.session import Session
from aicentro.framework.keras import Keras as AiduFrm
aidu_session = Session(verify=False)
aidu_framework = AiduFrm(session=aidu_session)
AIDU 디렉토리 환경변수
In [3]:
# aidu_framework.config.data_dir 내용 확인
aidu_framework.config.data_dir #나중에 여기에 + ‘\cust_data.csv’
Out[3]:
'/aihub/data'
2. 딥러닝 모델(DNN, CNN, RNN) 프로세스
① 라이브러리 임포트(import)
② 데이터 가져오기(Loading the data)
③ 탐색적 데이터 분석(Exploratory Data Analysis)
④ 데이터 전처리(Data PreProcessing) : 데이터타입 변환, Null 데이터 처리, 누락데이터 처리, 더미특성 생성, 특성 추출 (feature engineering) 등
⑤ Train, Test 데이터셋 분할
⑥ 데이터 정규화(Normalizing the Data)
⑦ 모델 개발(Creating the Model)
⑧ 모델 성능 평가
① 라이브러리 임포트
필요 라이브러리 임포트
In [4]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
② 데이터 로드
In [5]:
#고객등급(cust_class), 성별(sex_type), 나이(age), 사용서비스수(efct_svc_count), 서비스중지여부 (dt_stop_yn), 미납여부(npay_yn)
#3개월 평균 요금(r3m_avg_bill_amt), A서비스 3개월 평균요금(r3m_A_avg_arpu_amt), B서비스 3개월 평균요금(r3m_B_avg_arpu_amt), 해지여부(termination_yn)
df = pd.read_csv('cust_data.csv')
③ 데이터 분석
In [6]:
# 12컬럼, 7814 라인
df.info()
In [7]:
df.tail()
Out[7]:
In [8]:
# termination 레이블 불균형
df['termination'].value_counts().plot(kind='bar')
Out[8]:
<AxesSubplot:>
④ 데이터 전처리 문자->숫자로
In [9]: #여러 개 한꺼번에 one-hot encoding.
cal_cols = ['class', 'sex', 'stop', 'npay', 'termination', 'bill_rating']
In [10]: #one-hot encoding
df1 = pd.get_dummies(data=df, columns=cal_cols, drop_first=True) #drop_first를 쓰면 첫번째 레벨 뺴고 만들어짐. k개중 k-1개 만들어짐
참고,
print(tf.one_hot(temp_y[0], 10))
print(tf.one_hot(temp_y, 10))
In [11]:
# 19컬럼, 7814 라인
df1.info()
⑤ Train, Test 데이터셋 분할
In [12]:
from sklearn.model_selection import train_test_split
In [13]:
X = df1.drop('termination_Y', axis=1).values #termination 값 외 나머지 넣기
y = df1['termination_Y'].values #terminaction(해지여부) 값 넣기
In [14]:
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.3,
stratify=y,
random_state=42)
참고, train데이터와 test데이터가 따로 주어진 경우
df_feature = pd.read_csv("onenavi_train_feature.csv",sep="|")
df_target = pd.read_csv("onenavi_train_target.csv",sep="|")
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(df_feature, df_target, test_size=0.20, random_state=42)
In [15]:
X_train.shape
Out[15]:
(5469, 18)
In [16]:
y_train.shape
Out[16]:
(5469,)
⑥ 데이터 정규화/스케일링(Normalizing/Scaling)
In [17]:
# 숫자 분포 이루어진 컬럼 확인
df1.tail()
Out[17]:
In [18]: #정규화
from sklearn.preprocessing import MinMaxScaler
In [19]:
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
In [20]:
X_train[:2]
Out[20]:
#모델 입력갯수, 출력갯수 확인
In [21]:
X_train.shape
Out[21]:
(5469, 18)
In [22]:
y_train.shape
Out[22]:
(5469,)
⑦ 모델 개발
1) DNN
A. 이진 분류용 DNN layer
In [23]: 임포트 하기
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation, Dropout
In [24]:
# 18개 input layer
# unit 4개 hidden layer
# unit 3개 hidden layer
# 1개 output layser : 이진분류
model = Sequential()
model.add(Dense(4, activation='relu', input_shape=(18,))) #첫번째 히든레이어부터 생성. 거기에 input입력
model.add(Dense(3, activation='relu'))
model.add(Dense(1, activation='sigmoid')) #1개값에 분류 모델.
참고,
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_x.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
model.compile(loss='mse',
optimizer='adam',
metrics=['mae', 'mse'])
return model
모델 확인
In [25]:
model.summary()
모델 컴파일 – 이진 분류 모델 #빨리 처리하기 위해서 컴파일.
In [26]:
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
#최적화 adam사용, #y가 1개 값이 나오기 때문에 binary_crossentropy 써줘야 함.
Dropout : 과적합 방지
In [27]:
model = Sequential()
model.add(Dense(4, activation='relu', input_shape=(18,)))
model.add(Dropout(0.3)) #히든레이어 설정 후 과적합 코드 0.3=30%확률로 없어짐.
model.add(Dense(3, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(1, activation='sigmoid'))
In [28]:
model.summary()
모델 컴파일 – 이진 분류 모델
In [29]:
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
모델 훈련(학습) 하기 ##fitting!! test데이터로 학습
In [30]:
history = model.fit(X_train, y_train,
validation_data=(X_test, y_test),
epochs=20, #20번 학습
batch_size=16) #16사이즈 만큼 잘라서 학습
Loss가 점점 낮아지고 정확도 점점 올라감.
B. 다중 분류용 DNN layer #y가 2개인 경우
In [31]:
# 18개 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=(18,)))
model.add(Dropout(0.3))
model.add(Dense(4, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(2, activation='softmax')) #다중분류라 softmax y1, y2로 나오게 됨.
In [32]:
model.summary()
모델 컴파일 – 다중 분류 모델
In [33]:
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']) # 다중 모델이라서
모델 훈련(학습) 하기
In [34]:
history = model.fit(X_train, y_train,
validation_data=(X_test, y_test),
epochs=20,
batch_size=16)
#loss와 accuracy로 평가 할수 있지만 시각화 하기.
⑧ 모델 성능 평가
성능 시각화
In [35]:
losses = pd.DataFrame(model.history.history) #복붙
In [36]:
losses.head()
Out[36]:
In [37]:
losses[['loss','val_loss']].plot()
Out[37]:
<AxesSubplot:>
In [38]:
losses[['loss','val_loss', 'accuracy','val_accuracy']].plot()
Out[38]:
<AxesSubplot:>
In [39]: #matplotlib 사용
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()
2) CNN #이미지 처리시 좋음
KT AIDU 사이트에 업로드된 이미지 파일 가져오기
In [40]:
from glob import glob
import tensorflow as tf
In [41]:
# KT AIDU 사이트에 업로드한 dataset-clean,dirty.zip 파일 확인 #영상에서는 폴더가 다름.
glob('dataset-clean,dirty.zip') #glob(aidu_framework.config.data_dir + ‘\datase-clean,dirty.zip’)
Out[41]:
['dataset-clean,dirty.zip'] #’/aibub/data/dataset-clean,dirty.zip’
In [42]:
# dataset-clean,dirty.zip 파일을 현재 디렉토리로 복사 # ! 느낌표는 리눅스 영역
!mkdir IMAGE
!cp ./dataset-clean,dirty.zip ./IMAGE #!cp ’aibub/data/dataset-clean,dirty.zip ./IMAGE
In [43]:
# dataset-small-clean,dirty.zip 압축풀기
!cd IMAGE ; unzip -o dataset-clean,dirty.zip
Archive: dataset-clean,dirty.zip
creating: dataset-clean,dirty/
creating: dataset-clean,dirty/clean/
inflating: dataset-clean,dirty/clean/plastic1.jpg
….
inflating: dataset-clean,dirty/clean/plastic99.jpg
creating: dataset-clean,dirty/dirty/
inflating: dataset-clean,dirty/dirty/dirty_plastic1.jpg
….
inflating: dataset-clean,dirty/dirty/dirty_plastic99.jpg
In [44]:
# dataset-small-clean,dirty/0.clean 폴더 안의 이미지 갯수
!ls -l ./IMAGE/dataset-clean,dirty/clean | grep jpg | wc -l
435
In [45]:
# dataset-small-clean,dirty/1.drity 폴더 안의 이미지 갯수
!ls -l ./IMAGE/dataset-clean,dirty/dirty | grep jpg | wc -l
435
이미지 파일 하나 읽어 이미지 보기 #간단하게 보고 넘어가기
In [46]:
clean_img_path = './IMAGE/dataset-clean,dirty/clean/plastic1.jpg' #정의
In [47]:
gfile = tf.io.read_file(clean_img_path) #메모리에 올려서 읽어오기
image = tf.io.decode_image(gfile, dtype=tf.float32)
In [48]:
image.shape
Out[48]:
TensorShape([384, 512, 3]) #3은 RGB표현
In [49]:
plt.imshow(image)
plt.show()
In [50]:
dirty_img_path = './IMAGE/dataset-clean,dirty/dirty/dirty_plastic1.jpg'
In [51]:
gfile = tf.io.read_file(dirty_img_path)
image = tf.io.decode_image(gfile, dtype=tf.float32)
In [52]:
image.shape
Out[52]:
TensorShape([384, 512, 3])
In [53]:
plt.imshow(image)
plt.show()
전처리 . 이미지 전처리.
Data Preprocess
In [54]:
# Hyperparameter Tunning
num_epochs = 50 #몇번 돌릴것이냐
batch_size = 4 #이미지 묶음 사이즈
learning_rate = 0.001 #학습크기 작을수록 세부적으로 조금씩조금씩 학습
input_shape = (384, 512, 3) # 사이즈 확인
num_classes = 2 # clean, dirty 2가지
In [55]:
from tensorflow.keras.preprocessing.image import ImageDataGenerator #복붙 import
In [56]:
# ImageDataGenerator 이용하여 이미지 전처리하기
training_datagen = ImageDataGenerator(
rescale=1. / 255, #scale을 255로 나눠서 사용
validation_split=0.2 # train set : 435 * (1 - 0.2) = 348 #0.8만큼 트레이닝에 사용해라
)
test_datagen = ImageDataGenerator(
rescale=1./255, #scale을 255로 나눠서 사용
validation_split=0.2 # test set : 435 * 0.2 = 87
)
In [57]:
# training_datagen.flow_from_directory 이미지 데이터 읽고 배치 , 셔플하고 labeling 수행
# IMAGE 포더 밑에 .ipynb_checkpoints 폴더 있을경우 폴데 삭제
!rm -rf ./IMAGE/dataset-clean,dirty/.ipynb_checkpoints
training_generator = training_datagen.flow_from_directory(
'./IMAGE/dataset-clean,dirty/', # 이미지 데이터 읽고 배치 , 셔플하고 labeling 수행
batch_size=batch_size,
target_size=(384, 512), # 사이즈 확인
class_mode = 'categorical', # binary , categorical
shuffle = True,
subset = 'training' # training, validation. validation_split 사용하므로 subset 지정
)
test_generator = test_datagen.flow_from_directory(
'./IMAGE/dataset-clean,dirty/',
batch_size=batch_size,
target_size=(384, 512), # 사이즈 확인
class_mode = 'categorical', # binary , categorical
shuffle = True,
subset = 'validation' # training, validation. validation_split 사용하므로 subset 지정
)
Out[57]
Found 696 images belonging to 2 classes. #696이 트레이닝 데이터
Found 174 images belonging to 2 classes. #174가 테스트 데이터
In [58]:
# class 이름 및 번호 매핑 확인
print(training_generator.class_indices)
{'clean': 0, 'dirty': 1}
In [59]:
batch_samples = next(iter(training_generator))
print('True Value : ',batch_samples[1][0]) #샘플 보여주기
plt.imshow(batch_samples[0][0])
plt.show()
True Value : [0. 1.]
이때까지 이미지 전처리를 한거고, 이렇게 이미지가 만들어지면 CNN모델링으로 학습
CNN 모델링 #이미지 처리시 좋음
In [60]:
#CNN 라이브러리 임포트 #복붙
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras.layers import Conv2D, MaxPooling2D
In [61]:
# Feature extraction
model = Sequential()
model.add(Conv2D(filters=32, kernel_size=3, activation='relu', input_shape=input_shape))
#레이어추가, CNN은 Conv2D로 추가, filters 32개 통과, size 3*3 # 위에서 정의함 input_shape = (384, 512, 3)
model.add(MaxPooling2D(pool_size=2)) #축소본 만들기. 2*2사이즈로 반으로 줄어듬
model.add(Conv2D(filters=16, kernel_size=3, activation='relu'))
model.add(MaxPooling2D(pool_size=2))
# Classification
model.add(Flatten()) # 쭉펴서 확인 여기선 input안넣음, feature extraction에서 가져옴
model.add(Dense(50, activation='relu'))
model.add(Dense(2, activation='softmax')) #y값 2개
In [62]:
model.summary()
모델 컴파일 – 이진 분류 모델
In [63]:
#model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),
model.compile(optimizer='adam',
loss='categorical_crossentropy', #y가 2개이상이라서
metrics=['accuracy'])
모델 훈련(학습) 하기
In [64]:
history = model.fit(training_generator, #training_generator에 이미 y값과 이미지가 다 들어있음
epochs=20 ,
steps_per_epoch = len(training_generator) / batch_size,
validation_steps = len(test_generator) / batch_size,
validation_data=test_generator,
verbose=1
)
성능 시각화 - 성능평가
In [65]:
losses = pd.DataFrame(model.history.history)
In [66]:
losses.head()
Out[66]:
In [67]:
losses[['loss','val_loss']].plot()
Out[67]:
<AxesSubplot:>
In [68]:
losses[['loss','val_loss', 'accuracy','val_accuracy']].plot()
Out[68]:
<AxesSubplot:>
In [69]:
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()
예측하기
In [70]:
# test_generator 샘플 데이터 가져오기
# 배치 사이즈 32 확인
batch_img, batch_label = next(iter(test_generator))
print(batch_img.shape)
print(batch_label.shape)
(4, 384, 512, 3)
(4, 2)
In [71]:
# 4개 Test 샘플 이미지 그려보고 예측해 보기
i = 1
plt.figure(figsize=(16, 30))
for img, label in list(zip(batch_img, batch_label)):
pred = model.predict(img.reshape(-1,384, 512,3))
pred_t = np.argmax(pred)
plt.subplot(8, 4, i)
plt.title(f'True Value:{np.argmax(label)}, Pred Value: {pred_t}')
plt.imshow(img)
i = i + 1
#True Value:0 0 이 깨끗한 병
3) RNN
RNN 모델링
In [72]: 복붙!!
#RNN 라이브러리 임포트
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.layers import LSTM
In [73]:
X_train.shape, X_test.shape
Out[73]:
((5469, 18), (2345, 18))
In [74]:
X_train = X_train.reshape(-1,18,1) #1을 넣어서 2차원을 3차원 데이터로 바꿔줌.
X_test = X_test.reshape(-1,18,1)
In [75]:
X_train.shape, X_test.shape
Out[75]:
((5469, 18, 1), (2345, 18, 1))
In [76]:
# define model #RNN은 LSTM으로 레벨 추가
model = Sequential()
model.add(LSTM(32, activation='relu', return_sequences=True, input_shape=(18, 1)))
model.add(LSTM(16, activation='relu', return_sequences=True))
model.add(Flatten())
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
In [77]:
model.summary()
모델 컴파일 – 이진 분류 모델
In [78]:
model.compile(optimizer='adam',
loss='binary_crossentropy', # y가 1개라서
metrics=['accuracy'])
모델 학습
In [79]:
history = model.fit(x=X_train, y=y_train,
epochs=10 , batch_size=128,
validation_data=(X_test, y_test),
verbose=1
)
성능 시각화 - 성능평가
In [80]:
losses = pd.DataFrame(model.history.history)
In [81]:
losses.head()
Out[81]:
In [82]:
losses[['loss','val_loss']].plot()
Out[82]:
<AxesSubplot:>
In [83]:
losses[['loss','val_loss', 'accuracy','val_accuracy']].plot()
Out[83]:
<AxesSubplot:>
In [84]:
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()
# 최적 모델 불러오기 및 저장
model.load_weights(checkpoint_path)
model.save("DeeplearningModel.h5")
배운 내용 정리
① 라이브러리 임포트(import)
② 데이터 가져오기(Loading the data)
③ 탐색적 데이터 분석(Exploratory Data Analysis)
④ 데이터 전처리(Data PreProcessing) : 데이터타입 변환, Null 데이터 처리, 누락데이터 처리, 더미특성 생성, 특성 추출 (feature engineering) 등
⑤ Train, Test 데이터셋 분할
⑥ 데이터 정규화(Normalizing the Data)
⑦ 모델 개발(Creating the Model)
모델링 – 컴파일 - 모델학습
⑧ 모델 성능 평가
|