합성곱 신경망(CNN) - CNN 구현하기

단순한 CNN 네트워크 구성

[그림1] 단순한 CNN 네트워크 구성

 

초기화 때 받는 인수

• input_dim - 입력 데이터(채널 수, 높이, 너비)의 차원
• conv_param - 합성곱 하이퍼파라미터(딕셔너리), 딕셔너리의 키는 아래
  • fiter_num - 필터의 수
  • filter_size - 필터의 크기
  • stride - 스트라이드
  • pad - 패딩
  • hidden_size - 은닉층(완전연결)의 뉴런 수
  • output_size - 출력층(완전연결)의 뉴런 수
  • weight_init_std - 초기화 때의 가중치 표준편차

# 5. CNN 구현

class SimpleConvNet:
    def __init__(self, input_dim=(1,28,28),
                 conv_param={'filter_num':30, 'filter_size':5, 'pad':0,'stride':1},
                hidden_size=100, output_size = 10, weight_init_std=0.01):
        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']
        input_size = input_dim[1]
        conv_output_size = (input_size - filter_size + 2*filter_pad)/\
                filter_stride +1
        pool_output_size = int(filter_num * (conv_output_size/2)*(conv_output_size/2))
        
        # 가중치 매개변수 초기화
        self.params ={}
        self.params['W1'] = weight_init_std * \
                        np.random.rand(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)
        self.params['W2'] = weight_init_std * \
                        np.random.rand(pool_output_size, hidden_size)
        
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = weight_init_std * \
                        np.random.rand(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)
        
        # CNN 구성 계층 생성
        self.layers = OrderedDict()
        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
                                          conv_param['stride'],conv_param['pad'])
        
        self.layers['Relu1'] = Relu()
        self.layers['Pool1'] = Pooling(pool_h = 2, pool_w = 2, stride=2)
        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['Relu2'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W3'].self.params['b3'])
        
        self.last_layer = SoftmaxWithLoss()
        
    # 추론을 수행하는 predit 메서드
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        return x
    
    # 손실 함수를 구하는 loss
    def loss(self, x, t):
        y = self.predict(x)
        return self.last_layer.forward(y, t)
    # x는 입력 데이터 t는 정답 레이블
    
    
    # 오차역전파법 기울기 구하는 메서드
    def gradient(self, x, t):
        # 순전파
        self.loss(x, t)
        
        # 역전파
        dout = 1
        dout = self.last_layer.backward(dout)
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
            
        # 결과 저장
        grads = {}
        grads['W1'] = self.layers['Conv1'].dW
        grads['b1'] = self.layers['Conv1'].db
        grads['W2'] = self.layers['Affine1'].dW
        grads['b2'] = self.layers['Affine1'].db
        grads['W3'] = self.layers['Affine2'].dW
        grads['b3'] = self.layers['Affine2'].db
        
        return grads

 

 

출처 : 밑바닥부터 시작하는 딥러닝

https://www.hanbit.co.kr/store/books/look.php?p_code=B8475831198

밑바닥부터 시작하는 딥러닝