[AICE] 딥러닝

딥러닝

데이터를 통해 패턴을 배움

딥러닝 모델의 매개변수(weight, bias)를 무작위로 부여한 후,

반복학습을 통해 모델의 출력값을 정답과 일치하도록 매개변수를 조금씩 조정

 

DNN (Deep Neural Network)

입력층과 출력층 사이에 여러 개의 은닉층(hidden layer)으로 이루어진 인공신경망

신경망 출력에 비선형 활성화 함수를 추가하여 복잡한 비선형 관계 모델링 가능

 

※ dropout : 과적합 방지, train 학습 시에만 사용

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

model = Sequential()

# hidden layer 1
model.add(Dense(4, input_shape=(3,), activation='relu'))
model.add(Dropout(0.2))

# hidden layer 2
model.add(Dense(4, activation='relu'))

# output layer
model.add(Dense(1, activation='sigmoid'))   # output 하나

# 하나로 분류 binary_crossentropy
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])

history = model.fit(x_train, y_train, calidation_data=(x_test, y_test), epochs=40, batch_size=10)

 

CNN (Convolutional Neural Network)

이미지 처리에 자주 사용 (이미지 특징 추출 및 클래스 분류)

특징 추출 영역: Convolution layer와 Pooling layer를 여러 겹 쌓는 형태로 구성

클래스 분류 영역: Fully Connected layer 구성하여 사용

 

Convolutional Filer : 가중치 필터로 학습되며, 이미지 특징/패턴 찾아내어 이미지 분류가 가능하도록 함

Padding : Convolutional layer의 출력 데이터가 줄어드는 것을 방지하는 방법

Pooling layer : 계산량, 메모리량, 파라미터 수를 줄이기 위해 입력 이미지의 sub sample(축소본) 생성

(출력 데이터 크기 축소 & 특정 데이터 강조시 사용)

 

RNN (Recurrent Neural Network / 순환신경망)

입려과 출력을 시퀀스 단위로 처리하는 모델

음성인식, 언어 모델링, 번역, 이미지 주석 생성에 활용

 

vanishing gradient problem 발생 : 역전파시 기울기가 줄어들어 학습능력이 크게 저하

=> LSTM(Long Short-Term Memory) : RNN의 히든 state에 cell-state를 추가하여 보완, 순서&시계열 데이터에 효과적

# many to one - 감성분석
tf.keras.layers.LSTM(64)

# many to many - 번역
tf.keras.laters.LSTM(64, return_sequences=True)

 

Activation function

binary step

logistic, sigmoid, soft step

hyperbolic tangent(tanh)

rectified linear unit(ReLU)

 

loss function

회귀(Regression) : MSE, MAE

분류(Classification)

- 이진분류(Binary cross-entropy)

- 다중분류(Categorical cross-entropy)

 

gradient descent

뉴럴넷이 가중치 파라미터들을 최적화하는 방법

손실함수의 현 가중치에서 기울기를 구해 loss를 줄이는 방향으로 업데이트

 

back propagation(역전파)

실제값과 모델 결과값에서 오차를 구해서 오차를 output에서 input 방향으로 보내

가중치를 재업데이트하면서 학습

 

optimization algorithm(최적화 알고리즘)

Adam을 주로 사용

 

 

1 Epoch: 모든 데이터 셋을 한 번 학습
1 iteration: 1회 학습
Minibatch: 데이터 셋을 batch size 크기로 쪼개서 학습

 

---

① 라이브러리 임포트(import)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

② 데이터 가져오기(Loading the data)

df = pd.read_csv("csv_name")

③ 탐색적 데이터 분석(Exploratory Data Analysis)

df.info()
df.tail()
df["imbalance_col"].value_counts().pyplot(kind="bar")

④ 데이터 전처리(Data PreProcessing) : 데이터타입 변환, Null 데이터 처리, 누락데이터 처리, 더미특성 생성, 특성 추출 (feature engineering) 등

# one hot encoding
one_hot_cols = ["class", "sex"]
df1 = pd.get_dummies(data=df, columns=one_hot_cols, drop_first=True)
df1.info()

⑤ Train, Test 데이터셋 분할

from sklearn.model_selection import train_test_split

x = df1.drop("sex_M", axis=1).values
y = df1["sex_M"].values

x_train, y_train, x_test, y_test = train_test_split(x, y, test_size=0.3, stratify=y, random_state=42)

x_train.shape
y_train.shape

⑥ 데이터 정규화(Normalizing the Data)

# cols 값끼리 한자리, 네자리 범위가 달라 스케일링 진행

df1.tail()

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
y_train = scaler.transform(x_test)

x_train[:2]

# shape는 변화 없음
x_train.shape
y_train.shape

⑦ 모델 개발(Creating the Model)

 

DNN

- 이진분류용

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


# 15개 input layer
# unit 5개 hidden layer
# unit 3개 hidden layer
# 1개 output layer : 이진분류 - sigmoid

model = Sequential()
model.add(Dense(5, activation='relu', input_shape=(15,)))
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'])


# 모델 훈련
history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=20, batch_size=16)

 

- 다중분류용

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

# 12개 input layer
# unit 4개 hidden layer
# dropout
# unit 3개 hidden layer
# dropout
# 2개 output layer : 다중분류 - softmax

model = Sequential()
model.add(Dense(4, activation='relu', input_shape(12,)))
model.add(Dropout(0.3))
model.add(Dense(3, 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, vaildation_data(x_test, y_test), epochs=20, batch_size=16)

 

CNN

feature learning + classification

# 데이터 전처리
# tensorflow ImageDataGenerator : 이미지 데이터 스케일 및 트레인 데이터/ 테스트 데이트 나누기
# flow_from_directory : 나누어진 트레인 데이터와 테스트 데이터에 대해 배치 사이즈 나누고 , 셔플하고 labeling 수행

# Hyperparameter Tunning
num_epochs = 10
batch_size = 4
learning_rate = 0.001
input_shape = (384, 512, 3)

# 사이즈 확인
num_classes = 2 # clean, dirty


from tensorflow.keras.preprocessing.image import ImageDataGenerator

# ImageDataGenerator 이용하여 이미지 전처리하기

# train set : 435 * (1 - 0.2) = 348
training_datagen = ImageDataGenerator( rescale=1. / 255, validation_split=0.2)

# test set : 435 * 0.2 = 87
test_datagen = ImageDataGenerator( rescale=1./255, validation_split=0.2)


# 이미지 데이터 읽고 배치 , 셔플하고 labeling 수행
# IMAGE 포더 밑에 .ipynb_checkpoints 폴더 있을경우 폴데 삭제
!rm -rf ./IMAGE/dataset/.ipynb_checkpoints

training_generator = training_datagen.flow_from_directory( './IMAGE/dataset/', batch_size=batch_size, target_size=(384, 512), class_mode = 'categorical', shuffle = True, subset = 'training')

test_generator = test_datagen.flow_from_directory( './IMAGE/dataset/', batch_size=batch_size, target_size=(384, 512), class_mode = 'categorical', shuffle = True, subset = 'validation')

# class 이름 및 번호 매핑 확인
print(training_generator.class_indices)


batch_samples = next(iter(training_generator))

print('True Value : ',batch_samples[1][0])
plt.imshow(batch_samples[0][0])
plt.show()

#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

# Feature extraction
model = Sequential()
model.add(Conv2D(filters=32, kernel_size=3, activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(filters=16, kernel_size=3, activation='relu'))
model.add(MaxPooling2D(pool_size=2))

# Classification
model.add(Flatten())
model.add(Dense(50, activation='relu'))
model.add(Dense(2, activation='softmax'))

model.summary()

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

history = model.fit(training_generator, epochs=10 , steps_per_epoch = len(training_generator) / batch_size, validation_steps = len(test_generator) / batch_size, validation_data=test_generator, verbose=1 )

 

RNN

#RNN 라이브러리 임포트
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.layers import LSTM

# 3차원으로 만들기
X_train.shape, X_test.shape

X_train = X_train.reshape(-1,18,1)
X_test = X_test.reshape(-1,18,1)

X_train.shape, X_test.shape


# define model
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'))

model.summary()

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

history = model.fit(x=X_train, y=y_train, epochs=10 , batch_size=128, validation_data=(X_test, y_test), verbose=1 )

 

⑧ 모델 성능 평가

 

# 성능 시각화

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