00_기본 설정

파이썬: 3.9.19
케라스: 2.10.0
출처: 딩셰프의 3분 딥러닝 케라스맛, 김성진 지음, 한빛미디어

01_케라스 시작하기

• 완전 연결 계층(fully connected or dense layer): 입력 벡터에서 가중치 벡터를 내적하고 편향값을 빼줌

import keras

model = keras.models.Sequential()	# 기보적인 모델 선언
model.add(keras.layers.Dense(1, input_shape=(1, )))	# 노드 1개인 레이어 생성
model.compile(optimizer='SGD', loss='mse')	모델 생성

02_ANN

인공신경망(Artificiail Neural network): 입력, 은닉, 출력 계층으로 구성. 가장 기본적인 산경망

• 모델 구현 방식:
  • 연쇄 방식
  • 분산 방식

from keras import layers, models
# layers: 각 계층을 만드는 모듈
# models: 모델 생성 및 학습

# 분산 방식 모델링, 함수형 구현
x = layers.Input(shape=(input_num, ))
h = layers.Activation('relu')(layers.Dense(hidden_num)(x))
y = layers.Activation('softmax')(layers.Dense(output_num)(h))

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

# 연쇄 방식 모델링, 함수형 구현
model = models.Sequential() # 모델 구조 정의 전 Sequential로 초기화
model.add(layers.Dense(hidden_num, activation='relu', input_shape=(input_num, )))
model.add(layers.Dense(output_num, activation='softmax'))

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

# 분산 방식 모델링, 객체지향형 구현
class ANN(models.Model):
    def __init__(self, input_num, hidden_num, output_num, **kwargs):
        hidden = layers.Dense(hidden_num)
        output = layers.Dense(output_num)
        relu = layers.Activation('relu')
        softmax = layers.Activation('softmax')

        x = layers.Input(shape=input_num)
        h = relu(hidden(x))
        y = softmax(output(h))

        super().__init__(**kwargs)
        self.compile(loss='categorical_crossentropu', optimizer='adam', metrics=['accuracy'])

# 연쇄 방식 모델링, 객체지향형 구현
class ANN(models.Sequential):
    def __init__(self, input_num, hidden_num, output_num):
        super().__init__()
        self.add(layers.Dense(hidden_num, activation='relu', input_shape=(input_num, )))
        self.add(layers.Dense(output_num, activation='softmax'))
        self.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

03_DNN

심층신경망(Deep Neral network): 은닉층을 많이 쌓아서 만든 인공지능 기술. 과적합 방지가 중요.
relu: 경사도 소실 문제 해결하기 위한 활성화 함수
Dropout: 일정 확률로 출력 노드의 신호를 보냄. (tensorflow 함수 설명:훈련 시간 동안 각 단계의 비율 빈도에 따라 입력 단위를 무작위로 0으로 설정하여 과적합을 방지합니다.)

from keras import layers, models

class DNN(models.Sequental):
    def __init__(self, Nin, Nh_1, Nout):
        super().__init()

        self.add(layers.Dense(Nh_1[0], activation='relu', input_shape=(Nin, )), name='Hidden-1')
        self.add(layers.Dropout(0.2))
        self.add(layers.Dense(Nh_1[1], activation='relu', input_shape=(Nin, )), name='Hidden-2')
        self.add(layers.Dropout(0.2))
        self.add(layers.Dense(Nout, activation='softmax'))

        self.compile(loss='categorical_crossentropy', optimizer='adam', metrics='accuracy')

04_CNN

합성곱신경망(convolutional neural network): 합성곱을 이용해 가중치 수를 줄여 연산량을 감소. 합성곱 필터(convolution filter)를 이용하여 신경망 독작 수행.
Conv2D: 2차원 합성곱을 계산하는 클래스
MaxPooling2D: 2차원 맥스풀링을 계산하는 클래스
Flaten: 다차원 입력을 1차원 입력으로 변환하는 클래스

from keras.models import Model
from keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout

class CNN(Model):
    def __init__(model, nb_classes, in_shape=None):
        model.nb_classes = nb_classes
        model.in_shape = in_shape
        model.build_model()
        super().__init__(model.x, model.y)
        model.cl_part = Model(model.x, model.z_cl)
        model.fl_part = Model(model.x, model.z_fl)
        model.compile()
    
    def build_model(model):
        nb_classes = model.nb_classes
        in_shape = model.in_shape

        x = Input(in_shape)
        h = Conv2D(32, kernel_size=(3,3), activation='relu', input_shape=in_shape)(x)
        h = Conv2D(64, (3,3), activation='relu')(h)
        h = MaxPooling2D(pool_size=(2,2))(h)
        h = Dropout(0.25)(h)
        h = Flatten()(h)
        z_cl = h

        h = Dense(128, activation='relu')(h)
        h = Dropout(0.5)(h)
        z_fl = h

        y = Dense(nb_classes, activation='softmax', name='preds')(h)
        model.z_cl = z_cl
        model.z_fl = z_fl
        model.x, model.y = x, y

    def compile(model):
        Model.compile(model, loss='categorical_crossentropy', optimizer='adadelta', metrics=['acc'])

05_RNN

순환신경망(recurrent neural network): 계층의 출력이 순환(은닉 계층의 결과가 자기 계층으로 다시 들어옴)하는 인공신경망.
RNN은 활성화 함수를 곱셈보다는 덧셈을 사용(활성화 함수를 반복할수록 미분값이 0에 수렴하여 이를 해결하기 위함)

05-01_LSTM

• LSTM(long short-term Memory): RNN의 문제점을 개선한 RNN의 방법 중 하나
  입력 조절 벡터, 망각 벡터, 출력 조절 벡터를 통해 입출력 신호를 게이팅(gating: 신호의 양을 조정하는 기법)

from __future__ import print_function  # 파이썬 2와 3 간의 호환성 위한 패키지
# 파이썬 2에선 print를 괄호 없이 사용하지만 이 함수를 호출함으로써 함수로써(괄호와 함꼐) 사용하게 함
from keras.datasets import imdb
from keras import layers, models

class RNN_LSTM(models.Model):
    def __init__(self, max_features, maxlen):
        # model = models.Sequential()
        # model.add(layers.Embedding(max_features, 128))
        # model.add(layers.LSTM(128, dropout=0.2, recurrent_dropout=0.2))
        # model.add(layers.Dense(1, activation='sigmoid'))
        # model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])

        x = layers.Input((maxlen,))
        h = layers.Embedding(max_features, 128)(x)
        h = layers.LSTM(128, dropout=0.2, recurrent_dropout=0.2)(h)
        y = layers.Dense(1, activation='sigmoid')(h)
        super().__init__(x, y)
        self.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])

06_AE

오토인코더(autoencoder): 비지도학습으로 입력 데이터의 특징점을 효율적으로 찾는 것이 목표. 압축, 노이즈 제거 등에 사용. 입력 데이터를 부호화 후 복호화.

from keras import layers, models

class AE(models.Model):
    def __init__(self, x_nodes, z_dim):
        x_shape = (x_nodes, )
        x = layers.Input(shape=x_shape) # 입력 계층
        z = layers.Dense(z_dim, activation='relu')(x)   # 은닉 계층
        y = layers.Dense(x_nodes, activation='sigmoid')(z)  # 출력 계층
        super().__init__(x, y)
        self.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])

        self.x = x
        self.z = z
        self.z_dim = z_dim
    
    def Encoder(self):	# output을 z로 불러와서 encoder 부분만으로 만든 모델
        return models.Model(self.x, self.z)
    
    def Decoder(self):	# deoder부분인 y_layer를 가져온 후 input을 맞춘 새로운 z를 입력한 모델
        z_shape = (self.z_dim, )
        z = layers.Input(shape=z_shape)
        y_layer = self.layers[-1]
        y = y_layer(z)

        return models.Model(z, y)

# 합성곱 AE 모델링
from keras import layers, models

def Conv2D(filters, kernel_size, padding='same', activation='relu'):
    return layers.Conv2D(filters, kernel_size, padding, activation)

class AE(models.Model):
    def __init__(self, org_shape):
        # Input
        original = layers.Input(shape=org_shape)
        x = Conv2D(4, (3,3))(original)
        x = layers.MaxPooling2D((2,2), padding='same')(x)
        x = Conv2D(8, (3,3))(x)
        x = layers.MaxPooling2D((2,2), padding='same')(x)

        z = layers.Conv2D(1, (7,7))(x)  # encoding의 output이자 decoding의 input

        y = Conv2D(16, (3,3))(z)
        y = layers.UpSampling2D((2,2)(y))
        x = Conv2D(8, (3,3))(x)
        x = layers.UpSampling2D((2,2))(z)
        x = Conv2D(4, (3,3))(x)

        decoded = Conv2D(1, (3,3), activation='sigmoid')(y)

        super().__init__(original, decoded)
        self.compile(optimizer='adadelta', loss='binary_crossentropy', metrics=['acc'])

07_GAN

생성적 적대 신경망(generative adversarial network): 경쟁하여 최적화 수행하는 생성형 신경망. 생성망과 판별망으로 구성.
실제 데이터와 비슷한 확률분포를 가진 허구 데이터를 생성하여 이를 구분하며 학습.
모델 구현 코드는 교재 것이 복잡하여 미기재

08_UNET

오후에