로지스틱 회귀 분류기를 훈련하려면 새 파일을 열고 이름을 train_model.py로 지정하십시오.
2-8 행은 필수 Python 패키지를 가져옵니다. 그런 다음 명령 줄 인수를 구문 분석합니다.
여기에는 훈련이 완료된 후 출력 로지스틱 회귀 모델에 대한 경로와 함께 입력 HDF5 –db에 대한 경로 인 두 개의 스위치 만 필요합니다. 다음으로 읽기용 HDF5 데이터 세트를 열고 학습용 데이터의 75 %, 테스트 용 데이터의 25 % 인 학습 및 테스트 분할을 결정합니다.
이 기능 분할이 주어지면 LogisticRegression 분류기의 C 하이퍼 파라미터에 대한 그리드 서치를 수행합니다.
C의 최선의 선택을 찾으면 테스트 세트에 대한 분류 보고서를 생성 할 수 있습니다.
마지막으로, 훈련 된 모델은 나중에 사용할 수 있도록 디스크에 직렬화 할 수 있습니다.
ResNet50 기능에 대한 모델을 학습하려면 다음 명령을 실행하면됩니다.
결과에서 볼 수 있듯이 특징 추출을 통한 전이 학습을 사용하는 우리의 접근 방식은 98.69 %의 인상적인 정확도를 산출하여 Kaggle Dogs vs. Cats 순위표에서 2 위 자리를 차지하기에 충분합니다.
이 장에서 우리는 Kaggle Dogs vs. Cats 데이터 세트에 대해 자세히 살펴보고 다음과 같이 90 % 이상의 분류 정확도를 얻는 방법을 연구했습니다.
1. AlexNet을 처음부터 훈련합니다.
2. ResNet을 통한 전이 학습 적용.
AlexNet 아키텍처는 2012년 Krizhevsky 등이 처음 소개 한 작업입니다. AlexNet 구현을 사용하여 분류 정확도가 94 %에 도달했습니다. 이것은 특히 처음부터 훈련 된 네트워크의 경우 매우 존경할만한 정확성입니다. 추가 정확도는 다음을 통해 얻을 수 있습니다.
1. 더 많은 훈련 데이터 얻기.
2.보다 적극적인 데이터 증대를 적용합니다.
3. 네트워크 심화.
그러나 우리가 얻은 94 %는 상위 5 위는 말할 것도없고 상위 25 위 리더 보드에 진입하기에 충분하지 않습니다. 따라서 상위 5 위 위치를 얻기 위해 특성 추출을 통한 전이 학습, 특히 ImageNet 데이터 세트에서 훈련 된 ResNet50 아키텍처에 의존했습니다. ImageNet에는 개와 고양이 품종의 많은 예가 포함되어 있으므로 사전 훈련 된 네트워크를 이 작업에 적용하는 것은 더 적은 노력으로 더 높은 정확도를 얻을 수있는 자연스럽고 쉬운 방법입니다.
결과에서 알 수 있듯이 분류 정확도는 98.69 %로 Kaggle Dogs vs. Cats 순위표에서 2 위를 차지할 수있을만큼 높습니다.
물론 Kaggle Dogs vs. Cats 순위표를 살펴보면 상위 25 위 순위에 진입하려면 96.69 %의 정확도가 필요하지만 현재 방법으로는 도달 할 수 없습니다. 그렇다면 해결책은 무엇입니까?
대답은 전이 학습, 특히 특징 추출을 통한 전이 학습입니다. ImageNet 데이터 세트는 1,000 개의 개체 범주로 구성되어 있지만 그중 상당 부분에는 개 종과 고양이 종이 포함됩니다. 따라서 ImageNet에서 훈련 된 네트워크는 이미지가 개인 지 고양이인지뿐만 아니라 동물의 특정 품종도 알려줄 수 있습니다. ImageNet에서 훈련 된 네트워크가 이러한 세분화 된 동물을 구별 할 수 있어야한다는 점을 감안할 때, 사전 훈련 된 네트워크에서 추출한 기능이 Kaggle Dogs vs. Cats에서 최고의 자리를 차지할 가능성이 높다고 가정하는 것은 당연합니다.
이 가설을 테스트하기 위해 먼저 사전 훈련 된 ResNet 아키텍처에서 특성을 추출한 다음 이러한 특성 위에 로지스틱 회귀 분류기를 훈련시켜 보겠습니다.
30.6.1 ResNet을 이용한 피처 추출
이 섹션에서 사용할 특징 추출 기술을 통한 전이 학습은 30 장을 기반으로합니다. 전체적인 문제로 extract_features.py의 전체 내용을 검토하겠습니다. 그러나 CNN을 사용한 특징 추출에 대한 추가 지식이 필요한 경우 30 장을 참조하십시오. 시작하려면 새 파일을 열고 이름을 extract_features.py로 지정한 후 다음 코드를 삽입하십시오.
2 ~ 13 행은 필수 Python 패키지를 가져옵니다. 사전 학습 된 ResNet 아키텍처에 액세스 할 수 있도록 2 행에서 ResNet50 클래스를 가져옵니다. 또한 7 행에서 HDF5DatasetWriter를 사용하여 추출 된 기능을 효율적으로 HDF5 파일 형식으로 작성할 수 있습니다. 여기에서 명령 줄 인수를 구문 분석해 보겠습니다
여기에는 두 개의 필수 명령 줄 인수 인 –dataset 만 필요합니다.이 인수는 Dogs vs. Cats 이미지의 입력 데이터 세트 경로이고, –output은 ResNet을 통해 추출 된 기능을 포함하는 출력 HDF5 파일 경로입니다. 다음으로 디스크에있는 Dogs vs. Cats 이미지의 경로를 가져온 다음 파일 경로를 사용하여 레이블 이름을 추출해 보겠습니다.
이제 디스크에서 사전 훈련 된 ResNet50 가중치를 로드 할 수 있습니다 (FC 레이어 제외).#
ResNet50에서 추출한 기능을 디스크에 저장하려면 HDF5DatasetWriter 객체를 인스턴스화 해야합니다.
ResNet50의 최종 평균 풀링 레이어는 100352 (224 x 224 x 2 = 100352) 이므로 HDF5datasetWriter에 차원으로 100352 값을 제공합니다. 또한 기능 추출 프로세스를 추적 할 수 있도록 진행률 표시 줄을 초기화합니다.
CNN을 사용하여 데이터 세트에서 특징을 추출하는 것은 30 장에서와 동일합니다. 먼저, 일괄적으로 imagePath를 반복합니다
이어서 각 이미지를 사전 처리합니다.
그런 다음 네트워크 아키텍처를 통해 batchImage를 전달하여 ResNet50의 최종 POOL 계층에서 기능을 추출 할 수 있습니다.
이렇게 추출 된 피처는 데이터 세트에 추가 합니다.
ResNet을 활용하여 Dogs vs. Cats 데이터 세트에서 특징을 추출하려면 다음 명령을 실행하면됩니다.
명령 실행이 완료되면 이제 출력 디렉토리에 dogs_vs_cats_features.hdf5라는 파일이 있어야합니다.
이러한 기능이 주어지면 그 위에 로지스틱 회귀 분류기를 훈련하여 Kaggle Dogs vs. Cats 리더 보드에서 top-5위 자리를 얻을 수 있습니다.
이제 Krizhevsky et al.의 중요한 AlexNet 아키텍처를 구현해 보겠습니다. AlexNet 아키텍처를 요약 한 표는 아래 표에서 볼 수 있습니다.
AlexNet 아키텍처의 표 요약입니다. 출력 볼륨 크기는 관련되는 경우 컨볼 루션 필터 크기 / 풀 크기와 함께 각 레이어에 포함됩니다.
입력 이미지가 227 × 227 × 3 픽셀로 가정되는 방식에 주목하십시오. 이것은 실제로 AlexNet의 올바른 입력 크기입니다. 29 장에서 언급했듯이, 원래 출판물에서 Krizhevsky et al. 입력 공간 크기가 224x224x3이라고 보고했습니다. 그러나 11×1 커널로 타일링하면 224×224가 불가능하다는 것을 알기 때문에 출판물에 오타가있을 가능성이 있으며 224×224는 실제로 227×227이어야합니다.
AlexNet의 첫 번째 블록은 stride가 4×4 인 96, 11×11 커널을 적용한 다음 풀 크기가 3×3이고 stride가 2×2 인 RELU 활성화 및 최대 풀링을 적용하여 57 × 57 크기의 출력 볼륨을 생성합니다.
그런 다음 두 번째 CONV => RELU => POOL 레이어를 적용합니다. 이번에는 1×1 스트라이드의 256, 5×5 필터를 사용합니다. 풀 크기가 3×3이고 보폭이 2×2 인 최대 풀링을 다시 적용하면 13×13 볼륨이 남습니다.
다음으로 (CONV => RELU) * 3 => POOL을 적용합니다. 처음 두 개의 CONV 레이어는 384, 3×3 필터를 학습하고 최종 CONV는 256, 3×3 필터를 학습합니다.
또 다른 최대 풀링 작업 후에는 각각 4096 개의 노드와 RELU 활성화가있는 두 개의 FC 계층에 도달합니다. 네트워크의 마지막 계층은 소프트 맥스 분류기입니다. AlexNet이 처음 도입되었을 때 배치 정규화와 같은 기술이 없었습니다. 구현시 Convolutional Neural Networks를 사용하는 대부분의 이미지 분류 작업에 대한 표준과 같이 활성화 후 배치 정규화를 포함 할 것입니다. 또한 과적 합을 줄이기 위해 각 POOL 작업 후 매우 적은 양의 드롭 아웃을 포함 할 것입니다. AlexNet을 구현하기 위해 pyimagesearch에서 nn의 conv 하위 모듈에 alexnet.py라는 새 파일을 생성하겠습니다.
여기에서 alexnet.py를 열고 다음과 같은 중요한 아키텍처를 구현할 것입니다
2-11 행은 필수 Keras 클래스를 가져옵니다. 이전에 이 책의 이전 장에서 이러한 모든 레이어를 사용했으므로 각 레이어에 대해 명시 적으로 설명하지 않겠습니다. 제가 주목하고 싶은 유일한 import l2 함수를 가져 오는 10행 입니다.이 방법은 L2 가중치 감쇄를 네트워크의 가중치 레이어에 적용하는 역할을 합니다. import가 처리되었으므로 AlexNet의 정의를 시작하겠습니다.
15 행은 AlexNet의 빌드 방법을 정의합니다. 이 책의 모든 이전 예제와 마찬가지로 실제 네트워크 아키텍처를 구성하고이를 호출 함수로 반환하려면 build 메서드가 필요합니다. 이 메서드는 입력 이미지의 너비, 높이, 깊이와 데이터 세트의 총 클래스 레이블 수의 네 가지 인수를받습니다. 선택적 매개 변수 인 reg는 네트워크에 적용 할 L2 정규화의 양을 제어합니다. 더 크고 심층적 인 네트워크의 경우 정규화를 적용하는 것은 유효성 검사 및 테스트 세트의 정확도를 높이면서 과적합을 줄이는 데 중요합니다.
18 행은 “channels last”순서를 사용한다고 가정하고 inputShape 및 채널 차원과 함께 모델 자체를 초기화합니다. 대신 “channels first”순서를 사용하는 경우 inputShape 및 chanDim을 업데이트합니다 (24 ~ 26 행).
이제 네트워크에 설정된 첫 번째 CONV => RELU => POOL 레이어를 정의하겠습니다.
첫 번째 CONV 레이어는 4×4의 보폭을 사용하여 크기가 11×11 (28 및 29행) 인 96 개의 필터를 학습합니다. kernel_regularizer 매개 변수를 Conv2D 클래스에 적용하면 L2 가중치 정규화 매개 변수를 적용 할 수 있습니다. 이 정규화는 네트워크의 모든 CONV 및 FC 계층에 적용됩니다.
CONV 후에 ReLU 활성화가 적용되고 BatchNormalization (32 및 33 행)이 이어집니다. MaxPooling2D는 공간 차원을 줄이기 위해 적용됩니다 (34 행). 또한 과적 합을 줄이기 위해 작은 확률 (25 %)로 드롭 아웃을 적용 할 것입니다 (35 행). 다음 코드 블록은 또 다른 CONV => RELU => POOL 계층 집합을 정의하며 이번에는 크기가 각각 5×5 인 256 개의 필터를 학습합니다.
POOL 작업을 적용하기 전에 여러 CONV => RELU를 함께 스택하는 AlexNet의 세 번째 블록에서 더 깊고 풍부한 기능을 학습합니다.
처음 두 개의 CONV 필터는 384, 3×3 필터를 학습하고 세 번째 CONV는 256, 3×3 필터를 학습합니다. 다시 말하지만, 파괴적인 POOL 레이어를 적용하기 전에 여러 CONV => RELU 레이어를 쌓아두면 네트워크가 더 풍부하고 잠재적으로 더 차별적 인 기능을 배울 수 있습니다.
거기에서 우리는 완전히 연결된 2 개의 레이어 (각각 4096 노드)를 사용하여 다차원 표현을 표준 피드 포워드 네트워크로 축소합니다.
배치 정규화는 위의 CONV 계층에서와 같이 FC 계층 집합에서 각 활성화 후에 적용됩니다. 대부분의 CNN에서 표준처럼 모든 FC 레이어 세트 이후에 50 %의 더 큰 확률로 드롭 아웃이 적용됩니다. 마지막으로 원하는 클래스 수를 사용하여 소프트 맥스 분류기를 정의하고 결과 모델을 호출 함수로 반환합니다.
보시다시피 AlexNet 구현은 특히 위의 표에 제시된 아키텍처를 보면 매우 간단한 프로세스입니다. 간행물에서 아키텍처를 구현할 때마다 구현이 훨씬 쉬워지는 표를 확인하세요. 자체 네트워크 아키텍처의 경우 네트워크 아키텍처 시각화에 대한 20 장을 내용을 고려하여 입력 볼륨 및 출력 볼륨 크기가 예상 한대로 되도록 하십시오.
AlexNet 아키텍처를 구현하고 Kaggle Dogs vs. Cats 데이터 세트에서 훈련하기 전에 먼저 HDF5 데이터 세트에서 이미지 및 레이블 배치를 생성하는 클래스를 정의해야합니다. 29 장에서는 디스크에 있는 이미지 세트를 HDF5 데이터 세트로 변환하는 방법에 대해 논의했습니다. 그러나 이를 다시 가져 오려면 어떻게해야합니까? 대답은 io 하위 모듈에 HDF5DatasetGenerator 클래스를 정의하는 것입니다.
이전에는 모든 이미지 데이터 세트를 메모리에 로드 할 수 있었으므로 Keras 생성기 유틸리티를 사용하여 이미지 배치와 해당 레이블을 생성 할 수있었습니다. 그러나 이제 데이터 세트가 너무 커서 메모리에 맞지 않으므로 이 생성기를 직접 구현해야합니다. 계속해서 hdf5datasetgenerator.py 파일을 열면 작업이 시작됩니다.
7 행에서 생성자를 HDF5DatasetGenerator에 정의합니다. 이 클래스는 여러 인수를받습니다. 그 중 2 개는 필수이고 나머지는 선택 사항입니다. 아래에 각 인수에 대해 자세히 설명하겠습니다.
• dbPath : 이미지와 해당 클래스 레이블을 저장하는 HDF5 데이터 세트의 경로입니다.
• batchSize : 네트워크를 훈련 할 때 산출 할 미니 배치의 크기입니다.
• preprocessors : 적용 할 이미지 전 처리기 목록 (예 : MeanPreprocessor, ImageToArrayPreprocessor 등).
• aug : 기본값은 None입니다. 또한 Keras ImageDataGenerator를 제공하여 HDF5DatasetGenerator 내부에서 직접 데이터 증가를 적용 할 수 있습니다.
• binarize : 일반적으로 클래스 레이블을 HDF5 데이터 세트 내에 단일 정수로 저장합니다. 그러나 우리가 알고 있듯이, 손실 함수로 범주형 교차 엔트로피 또는 이진 교차 엔트로피를 적용하는 경우 먼저 레이블을 원-핫 인코딩 벡터로 이진화해야합니다.이 스위치는 이 이진화가 수행되어야하는지 여부를 나타냅니다. (기본값은 True).
• classes : 데이터 세트에 있는 고유한 클래스 레이블의 수입니다. 이 값은 이진화 단계에서 원-핫 인코딩 된 벡터를 정확하게 구성하는 데 필요합니다.
이 변수는 12-16 행에 저장되어 있으므로 나머지 클래스에서 액세스 할 수 있습니다. 20행은 HDF5 데이터 세트 파일에 대한 파일 포인터를 엽니 다. 21행은 데이터 세트의 총 데이터 포인트 수에 액세스하는 데 사용되는 편의 변수를 생성합니다.
다음으로, 이름에서 알 수 있듯이 네트워크를 훈련 할 때 Keras .fit_generator 함수에 이미지 및 클래스 레이블 배치를 생성하는 생성기 함수를 정의해야합니다.
23 행은 선택적 인수를 받을 수있는 생성기 함수를 정의합니다. passes 값을 총 Epoch 수로 생각하십시오. 대부분의 경우 생성기가 총 Epoch 수에 신경쓰기를 원하지 않습니다. 우리의 훈련 방법론 (고정 된 epoch 수, 조기 중지 등)이 이를 책임 져야합니다. 그러나 특정 상황에서는 생성자에게 이 정보를 제공하는 것이 도움이되는 경우가 있습니다.
29 행에서 원하는 epoch 수에 대해 반복을 시작합니다. 기본적으로이 루프는 다음 중 하나가 될 때까지 무기한 실행됩니다.
1. Keras가 학습 종료 기준에 도달합니다.
2. 훈련 과정을 명시적으로 중지합니다 (예 : ctrl + c).
31 행은 데이터 세트의 각 데이터 포인트 배치에 대해 반복을 시작합니다. 33 행과 34 행의 HDF5 데이터 세트에서 batchSize 크기의 이미지와 라벨을 추출합니다. 다음으로 라벨이 원-핫 인코딩되어야하는지 확인합니다.
# check to see
if the labels should be binarized if self.binarize:
전처리기가 None이 아닌 경우(42 행) 배치의 각 이미지를 반복하고 개별 이미지에 대해 preprocess 메서드를 호출하여 각 preprocessors를 적용합니다. 이렇게하면 여러 이미지 전처리기를 함께 연결할 수 있습니다.
예를 들어 첫 번째 전처리기는 SimplePreprocessor 클래스를 통해 이미지를 고정된 크기로 조정할 수 있습니다. 거기에서 우리는 MeanPreprocessor를 통해 평균 빼기를 수행 할 수 있습니다. 그런 다음 ImageToArrayPreprocessor를 사용하여 이미지를 Keras 호환 배열로 변환해야합니다.
이 시점에서 우리가 모든 전처리 클래스를 preprocess 방법으로 정의한 이유가 명확해야합니다. 이를 통해 데이터 생성기 내에서 전처리기를 함께 연결할 수 있습니다. 그런 다음 전처리 된 이미지는 58 행에서 NumPy 배열로 다시 변환됩니다.
데이터 확대에 사용되는 ImageDataGenerator 클래스 인 aug 인스턴스를 제공했다면 이미지에도 데이터 확대를 적용 할 수 있습니다.
69 행은 데이터 세트의 모든 미니 배치가 처리 된 후 총 epoch 수를 증가시킵니다. 71-73 행의 close 메소드는 단순히 HDF5 데이터 세트에 대한 포인터를 닫는 역할을 합니다.
물론 HDF5DatasetGenerator를 구현하는 것은 우리가 딥러닝을 수행하는 것처럼 “느낌”을 주지 못할 수도 있습니다. 결국 이것은 파일에서 데이터 일괄 처리를 담당하는 클래스가 아닌가? 기술적으로 맞습니다. 그러나 실용적인 딥러닝은 단순히 모델 아키텍처를 정의하고, 최적화 프로그램을 초기화하고,이를 데이터 세트에 적용하는 것 이상입니다.
실제로 데이터 세트, 특히 너무 커서 메모리에 맞지 않는 데이터 세트로 작업 할 수 있도록 도와주는 추가 도구가 필요합니다. 이 책의 나머지 부분에서 볼 수 있듯이 HDF5DatasetGenerator는 여러 번 유용하게 사용될 것입니다. 자신만의 딥 러닝 응용 프로그램 / 실험을 만들기 시작하면 레포지토리에 포함 시키는 것이 좋을 것입니다.
PatchPreprocessor는 훈련 과정에서 이미지의 M × N 영역을 무작위로 샘플링합니다. 입력 이미지의 공간 차원이 CNN이 예상하는 것보다 클 때 패치 전처리를 적용합니다. 이는 과적 합을 줄이는 데 도움이되는 일반적인 기술이므로 정규화의 한 형태입니다. 훈련 중에 전체 이미지를 사용하는 대신, 대신 무작위로 잘라내어 네트워크로 전달합니다 (크롭 전처리의 예는 아래 그림 참조).
이 자르기를 적용한다는 것은 데이터 증가와 유사하게 네트워크가 똑같은 이미지를 볼 수 없음을 의미합니다 (무작위로 발생하지 않는 한). 이전 장에서 알 수 있듯이 각 이미지가 256×256 픽셀 인 Kaggle Dogs vs. Cats 이미지의 HDF5 데이터 세트를 구성했습니다. 그러나 이 장의 뒷부분에서 구현할 AlexNet 아키텍처는 227×227 픽셀 크기의 이미지 만 허용 할 수 있습니다. 어떻게 해야 할까요?
SimplePreprocessor를 적용하여 256×256 픽셀 각각의 크기를 227×227로 축소 하시겠습니까? 아닙니다. 이것은 훈련 중에 256×256 이미지에서 227×227 영역을 무작위로 잘라 데이터 증가를 수행 할 수있는 좋은 기회입니다. 실제로 이 프로세스는 Krizhevsky et al. ImageNet 데이터 세트에서 AlexNet을 훈련시킵니다. 다른 모든 이미지 전처리 기와 마찬가지로 PatchPreprocessor는 pyimagesearch의 전처리 하위 모듈에서 정렬됩니다.
5 행은 PatchPreprocessor에 대한 구성을 정의합니다. 잘라낸 이미지의 대상 너비와 높이를 제공하기 만하면됩니다. 그런 다음 전처리 기능을 정의 할 수 있습니다.
scikit-learn 라이브러리의 extract_patches_2d 함수를 사용하면 self.width x self.height 크기의 임의 패치를 쉽게 추출 할 수 있습니다. 입력 이미지가 주어지면이 함수는 이미지에서 패치를 무작위로 추출합니다. 여기서 max_patches = 1을 제공하여 입력 이미지에서 하나의 임의 패치 만 필요함을 나타냅니다.
PatchPreprocessor 클래스는 실제 쓰이는 법은 별로 보이지 않지만 실제로는 또 다른 데이터 증가 계층을 적용하여 과적합을 방지하는 매우 효과적인 방법입니다. AlexNet을 교육 할 때 PatchPreprocessor를 사용합니다. 다음 전처리 기인 CropPreprocessor는 훈련 된 네트워크를 평가할 때 사용됩니다.
다음으로 오버 샘플링을 위해 10 개의 크롭을 계산하는 CropPreprocessor를 정의해야합니다. CNN의 평가 단계에서 입력 이미지의 네 모서리 + 중앙 영역을 잘라낸 다음 해당 수평 반전을 수행하여 입력 이미지 당 총 10 개의 샘플을 얻습니다 (아래 그림).
왼쪽 : 원본 256 × 256 입력 이미지.
오른쪽 : 10 자르기 전처리기를 적용하여 중앙, 네 모서리 및 해당 수평 거울을 포함하여 이미지의 227 × 227 자르기 10 개를 추출합니다.
이 10 개의 샘플은 CNN을 통과 한 다음 확률이 평균화됩니다. 이 오버 샘플링 방법을 적용하면 분류 정확도가 1-2 % 증가하는 경향이 있습니다 (경우에 따라 더 높음). CropPreprocessor 클래스는 전처리 하위 모듈에 있습니다.
# store the target image width, height, whether or not
# horizontal flips should be included, along with the
# interpolation method used when resizing
self.width = width
self.height = height
self.horiz = horiz
self.inter = inter
6 행은 생성자를 CropPreprocessor에 정의합니다. 유일한 필수 인수는 잘린 각 영역의 대상 너비와 높이입니다. 또한 OpenCV가 크기 조정에 사용할 보간 알고리즘과 함께 수평 뒤집기를 적용할지 (기본값은 True) 여부를 선택적으로 지정할 수도 있습니다. 이러한 인수는 모두 preprocess 메서드 내에서 사용하기 위해 클래스 내부에 저장됩니다. 이제 preprocess 메서드을 정의 해 보겠습니다.
ㅁ
전처리 방법은 오버 샘플링을 적용 할 이미지 인 단일 인수만 필요합니다. 21 행에서 입력 이미지의 너비와 높이를 가져와서 네 모서리 (각각 왼쪽 위, 오른쪽 위, 오른쪽 아래, 왼쪽 아래)의 (x, y) 좌표를 계산할 수 있습니다) 22-26 행.
그런 다음 이미지의 중앙 자르기는 29 행과 30 행에서 계산 된 다음 31 행의 좌표 목록에 추가됩니다.
이제 각 크롭을 추출 할 준비가 되었습니다.
35 행에서 직사각형 크롭의 시작 및 끝 (x, y) 좌표를 반복합니다. 36 행은 NumPy 배열 슬라이싱을 통해 크롭을 추출한 다음 37 행에서 크기를 조정하여 목표 너비와 높이 치수가 충족되도록합니다. 크롭은 크롭 리스트에 추가됩니다.
수평 뒤집기를 계산해야하는 경우 5 가지 원본 크롭을 각각 뒤집어 전체적으로 10 가지 크롭을 남길 수 있습니다. #
그런 다음 자르기 배열이 48 행의 호출 함수로 반환됩니다. 정규화를 위해 MeanPreprocessor를 사용하고 오버 샘플링을 위해 CropPreprocessor를 사용하면 가능한 것보다 더 높은 분류 정확도를 얻을 수 있습니다.
이전 장에서 HDF5 및 메모리에 맞지 않는 너무 큰 데이터 세트로 작업하는 방법을 배웠습니다. 이를 위해 이미지의 입력 데이터 세트를 가져 와서 고효율 HDF5 데이터 세트로 직렬화하는 데 사용할 수있는 Python 유틸리티 스크립트를 정의했습니다. HDF5 데이터 세트에서 이미지 데이터 세트를 표현하면 I/O 지연 문제를 피할 수 있으므로 훈련 프로세스의 속도를 높일 수 있습니다.
Bulldog and Cat Facing Off
예를 들어 디스크에서 이미지를 순차적으로 로드하는 데이터 집합 생성기를 정의한 경우 각 이미지에 대해 하나씩 N 개의 읽기 작업이 필요합니다. 그러나 이미지 데이터 세트를 HDF5 데이터 세트에 배치하면 단일 읽기를 사용하여 이미지 배치를로드 할 수 있습니다. 이 작업을 통해 I/O 호출 수를 크게 줄이고 매우 큰 이미지 데이터 세트로 작업 할 수 있습니다.
이 장에서는 작업을 확장하고 Keras로 Convolutional Neural Networks를 훈련하는 데 적합한 HDF5 데이터 세트용 이미지 생성기를 정의하는 방법을 배웁니다. 이 생성기는 HDF5 데이터 세트를 열고 학습 할 네트워크에 대한 이미지 배치 및 관련 학습 레이블을 생성하고 모델이 충분히 낮은 손실/높은 정확도에 도달 할 때까지 계속 진행합니다. 이 프로세스를 수행하기 위해 먼저 분류 정확도를 높이기 위해 설계된 세 가지 새로운 이미지 전 처리기 (평균 빼기, 패치 추출 및 자르기 (또는 오버 샘플링이라고도 함))를 살펴 보겠습니다. 새로운 전 처리기 세트를 정의한 후에는 실제 HDF5 데이터 세트 생성기 정의로 넘어갈 것입니다.
여기에서 Krizhevsky 등의 2012 년 논문 인 ImageNet Classification with Deep Convolutional Neural Networks의 AlexNet 아키텍처를 구현할 것입니다. AlexNet을 구현하여 Kaggle Dogs vs. Cats 챌린지에 대한 학습을 시작하게 됩니다. 학습 된 모델이 주어지면 테스트 세트에서 성능을 평가 한 다음 오버 샘플링 방법을 사용하여 분류 정확도를 더욱 높일 것입니다. 결과에서 알 수 있듯이, 네트워크 아키텍처 + 자르기 방법을 통해 Kaggle Dogs vs. Cats 챌린지에서 상위 25 위 순위에 진입 할 수 있습니다.
이 섹션에서는 두 개의 새로운 이미지 전처리기를 구현할 것입니다.
1. 입력 이미지 (데이터 정규화의 한 형태)에서 데이터 세트 전체의 평균 빨강, 녹색 및 파랑 픽셀 강도를 빼도록 설계된 평균 빼기 전 처리기 ).
2. 훈련 중 이미지에서 M × N 픽셀 영역을 무작위로 추출하는 데 사용되는 패치 전 처리기.
3. 입력 이미지의 5 개 영역 (네 모서리 + 중앙 영역)을 해당 수평 뒤집기와 함께 샘플링하기 위해 테스트 시간에 사용되는 오버 샘플링 전 처리기 (총 10 회 자르기). 오버 샘플링을 사용하면 CNN을 통해 10 가지 크롭을 전달한 다음 10 가지 예측을 평균하여 분류 정확도를 높일 수 있습니다.
30.1.1 평균값 전처리
평균 전 처리기부터 시작하겠습니다. 29 장에서 이미지 데이터 세트를 HDF5 형식으로 변환하는 방법을 배웠습니다. 이 변환의 일부는 전체 데이터 세트의 모든 이미지에서 평균 빨강, 녹색 및 파랑 픽셀 강도를 계산하는 것입니다. 이제 이러한 평균을 얻었으므로 데이터 정규화의 한 형태로 입력 이미지에서 이러한 값을 픽셀 단위로 뺄 것입니다. 입력 이미지 I와 R, G, B 채널이 주어지면 다음을 통해 평균 감산을 수행 할 수 있습니다.
• R = R− µR
• G = G− µG
• B = B− µB
여기서 µR, µG 및 µB는 이미지 데이터 셋은 HDF5 형식으로 변환됩니다. 아래 그림에는 입력 이미지에서 평균 RGB 값을 빼는 시각화가 포함되어 있습니다. 빼기가 픽셀 단위로 수행되는 방식을 확인하십시오.
R = 124.96, G = 115.97, B = 106.13 픽셀 단위를 빼서 입력 이미지 (왼쪽)에 평균 빼기를 적용하여 출력 이미지 (오른쪽)를 생성하는 예입니다. 평균 빼기는 분류 중 조명 변화의 영향을 줄이는 데 사용됩니다.
이 개념을 좀 더 구체적으로 만들기 위해 계속해서 MeanPreprocessor 클래스를 구현해 보겠습니다.
전처리 하위 모듈에 meanpreprocessor.py라는 새 파일을 배치 한 방법에 주목하십시오. 이 위치는 MeanPreprocessor 클래스가있는 곳입니다. 이제 이 클래스를 구현해 보겠습니다.
# import the necessary packages
import cv2
class MeanPreprocessor:
def __init__(self, rMean, gMean, bMean):
# store the Red, Green, and Blue channel averages across a
# training set
self.rMean = rMean
self.gMean = gMean
self.bMean = bMean
5 행은 MeanPreprocessor에 대한 생성자를 정의합니다. 여기에는 세 개의 인수 (전체 데이터 세트에서 계산 된 각각의 빨간색, 녹색 및 파란색 평균)가 필요합니다. 이 값은 8-10 행에 저장됩니다. 다음으로, 이미지 처리 파이프 라인에 적용하려는 모든 전처리기에 필요한 함수 인 전처리 방법을 정의 해 보겠습니다.
15 행은 cv2.split 함수를 사용하여 입력 이미지를 각각의 RGB 구성 요소로 분할합니다. OpenCV는 RGB 가 아닌 BGR 순서로 이미지를 나타내므로 반환 튜플에 (R, G가 아닌 (B, G, R) 서명이있는 이유는 , B). 또한 OpenCV 이미지는 일반적으로 부호없는 8 비트 정수로 표시되므로 이러한 채널이 부동 소수점 데이터 유형인지 확인합니다 (이 경우 음수 값을 가질 수 없으며 대신 모듈로 산술이 수행됨).
17-20 행은 입력 이미지의 RGB 채널에서 각각의 평균 RGB 값을 빼면서 평균 빼기를 수행합니다. 그런 다음 23 행은 정규화 된 채널을 다시 병합하고 결과 이미지를 호출 함수에 반환합니다.
오리지널 Inception 모듈은 GoogLeNet 용으로 설계되어 ImageNet 데이터 세트 (각 입력 이미지가 224 × 224 × 3 인 것으로 가정)에서 학습하고 최첨단 정확도를 얻을 수 있습니다. 그럼에도 더 적은 네트워크 매개 변수가 필요한 더 작은 데이터 세트 (더 작은 이미지 공간 차원 포함)의 경우 Inception 모듈을 단순화 할 수 있습니다. 아래 그림의 맨 위 행은 MiniGoogLeNet 구현에 사용 된 세 가지 모듈을 설명합니다.
Miniception 아키텍처는 convolution 모듈, Inception 모듈 및 다운 샘플 모듈을 포함한 빌딩 블록으로 구성됩니다. 이러한 모듈은 전체 아키텍처를 형성하기 위해 함께 결합됩니다.
• 왼쪽 : 컨볼루션, 배치 정규화 및 활성화를 수행하는 컨볼 루션 모듈입니다.
• 중간 : 1×1 필터 용과 3×3 필터 용으로 하나씩 두 세트의 컨볼 루션을 수행하는 미니 셉션 모듈이 결과를 연결합니다. (1) 입력 볼륨이 더 작아지고 (CIFAR-10 데이터 세트를 사용할 것이므로) (2) 네트워크의 매개 변수 수를 줄이기 위해 3×3 필터 전에 차원 축소가 수행되지 않습니다.
• 오른쪽 : 컨볼루션과 최대 풀링을 모두 적용하여 차원을 줄인 다음 필터 차원에서 연결하는 다운 샘플 모듈입니다.
그런 다음 이러한 빌딩 블록을 사용하여 맨 아래 줄에 MiniGoogLeNet 아키텍처를 구축합니다. 여기서는 CNN을 구현할 때 권장되는 것과 달리 작성자가 활성화 전에 배치 정규화를 배치했음을 알 수 있습니다 (아마도 Szegedy 등이 수행 한 작업이기 때문일 수 있음). 이 책에서는 결과를 복제하기 위해 활성화 전에 배치 정규화를 배치하여 원저자의 작업 구현을 고수했습니다. 자신의 실험에서는 이 순서를 바꾸는 것을 생각해 볼 수 있습니다. 다음 섹션에서는 MiniGoogLeNet 아키텍처를 구현하고이를 CIFAR-10 데이터 세트에 적용합니다. 여기에서 전체 Inception 모듈을 구현하고 cs231n Tiny ImageNet 과제를 해결할 준비가 될 것입니다.
먼저 nn의 conv 모듈 내에 minigooglenet.py라는 파일을 만듭니다. 여기에 MiniGoogLeNet 클래스 구현을 하겠습니다.
minigooglenet.py를 열고 다음 코드를 삽입하십시오.
2 ~ 13 행은 필수 Python 패키지를 가져옵니다. 한 레이어의 출력이 다음 레이어로 직접 공급되는 Sequential 클래스를 가져 오는 대신 Model 클래스 (11 행)를 사용해야합니다. Sequential이 아닌 Model을 사용하면 Inception 모듈 에서처럼 분할 및 분기가있는 네트워크 그래프를 만들 수 있습니다. 아직 보지 못한 또 다른 import는 12 행의 concatenate 함수입니다. 이름에서 알 수 있듯이이 함수는 입력 집합을 가져 와서 주어진 축을 따라 연결합니다. 이 경우에는 채널 차원이됩니다. 이전 그림에 설명 된대로 MiniGoogLeNet의 정확한 버전을 구현할 것이므로 conv_module부터 시작하겠습니다.
conv_module 함수는 컨볼 루션 적용, 배치 정규화, 마지막으로 활성화를 담당합니다. 메서드에 대한 매개 변수는 아래에 자세히 설명되어 있습니다.
19 행에서 우리는 conv 층을 생성합니다. Conv2D에 대한 실제 매개 변수는 AlexNet 및 VGGNet과 같은 이전 아키텍처의 예제와 동일하지만 여기서 변경된 사항은 주어진 계층에 입력을 제공하는 방법입니다.
네트워크 아키텍처를 정의하기 위해 Sequential이 아닌 Model을 사용하고 있기 때문에 model.add를 호출 할 수 없습니다. 이것은 한 레이어의 출력이 순차적으로 다음 레이어로 이어진다는 것을 의미하기 때문입니다. 대신 함수 호출이 끝날 때 괄호 안에 입력 레이어를 제공합니다.이를 Functional API라고합니다. 모델의 각 레이어 인스턴스는 텐서에서 호출 할 수 있으며 텐서를 반환합니다. 따라서 객체가 인스턴스화되면 함수로 호출하여 주어진 레이어에 입력을 제공 할 수 있습니다. 이러한 방식으로 레이어를 구성하기위한 템플릿은 아래에서 볼 수 있습니다.
비 순차적 네트워크를 정의 할 때마다 사용하게 되므로 네트워크에 레이어를 추가하는이 새로운 스타일에 익숙해 지시길 바랍니다. Conv2D 계층의 출력은 20 행의 BatchNormalization 계층으로 전달됩니다. 그런 다음 BatchNormalization의 출력은 ReLU 활성화 (21 행)를 거칩니다. conv_module을 시각화하는 데 도움이되는 그림을 구성한다면 아래 그림과 같을 것입니다.
MiniGoogLeNet 아키텍처의 conv_module. 이 모듈은 분기를 포함하지 않으며 간단한 CONV => BN => ACT입니다.
먼저 컨볼 루션이 적용된 다음 일괄 정규화가 적용된 다음 활성화됩니다. 이 모듈은 분기를 수행하지 않았습니다. 아래의 inception_module 정의로 변경 될 것입니다.
Mininception 모듈은 1×1 CONV와 3×3 CONV의 두 세트의 컨볼루션을 수행합니다. 이 두 컨볼루션은 병렬로 수행되고 결과 함수는 채널 차원에서 연결됩니다.
30 행과 31 행은 conv_module을 사용하여 numK1x1 필터 (1×1)를 학습합니다. 32 행과 33 행은 conv_module을 다시 적용하여 numK3x3 필터 (3 × 3)를 학습합니다. conv_module 함수를 사용하면 코드를 재사용 할 수 있고 CONV => BN => RELU 블록의 여러 블록을 삽입하여 MiniGoogLeNet 클래스를 부 풀릴 필요가 없습니다. 이 스택은 conv_module을 통해 간결하게 처리됩니다.
1×1 및 3×3 Conv2D 클래스에 대한 입력이 모두 레이어에 대한 입력 인 x 인 것을 확인하십시오. Sequential 클래스를 사용할 때 이러한 유형의 레이어 구조는 불가능했습니다. 그러나 Model 클래스를 사용하면 이제 여러 레이어가 동일한 입력을 받아들이도록 할 수 있습니다. conv_1x1과 conv_3x3이 모두 있으면 채널 차원에서 연결합니다.
(mini) -inception_module은 두 가지 분기로 구성됩니다. 첫 번째 분기는 1×1 필터를 학습하는 CONV 계층입니다. 두 번째 분기는 3×3 필터를 학습하는 또 다른 CONV 계층입니다. 그런 다음 필터 응답은 채널 차원을 따라 연결됩니다.
“Mini”-Inception 모듈을 시각화하려면 위 그림을 살펴보십시오. 1×1 및 3×3 CONV 레이어는 주어진 입력을 받아 각각의 컨볼루션을 적용합니다. 그런 다음 두 컨볼 루션의 출력이 연결됩니다 (33 행). padding = “same”으로 인해 두 컨볼루션의 출력 볼륨 크기가 동일하기 때문에 레이어 출력을 연결할 수 있습니다. 다음은 이름에서 알 수 있듯이 입력 볼륨의 공간 크기를 줄이는 역할을 하는 downsample_module입니다. @staticmethod def downsample_module(x, K, chanDim): # define the CONV module and POOL, then concatenate # across the channel dimensions conv_3x3 = MiniGoogLeNet.conv_module(x, K, 3, 3, (2, 2), chanDim, padding=”valid”) pool = MaxPooling2D((3, 3), strides=(2, 2))(x) x = concatenate([conv_3x3, pool], axis=chanDim) # return the block return x
이 메소드는 일괄 정규화 및 채널 연결을 위한 chanDim과 함께 컨벌루션 레이어가 학습 할 필터 수 K 인 입력 x를 전달해야합니다. downsample_module의 첫 번째 분기는 2×2의 스트라이드를 사용하여 K, 3×3 필터 세트를 학습하여 출력 볼륨 크기를 줄입니다 (라인 43 및 44). 우리는 볼륨 크기를 줄이기 위해 창 크기가 3×3이고 보폭이 2×2 인 라인 45 (두 번째 분기)에 최대 풀링을 적용합니다. conv_3x3 및 pool 출력은 연결되고 (46 행) 호출 함수로 반환됩니다.
downsample_module은 입력 볼륨의 공간 차원을 줄이는 역할을합니다. 첫 번째 분기는 출력 볼륨을 줄이기 위해 스트라이드가 2×2 인 필터 세트를 학습합니다. 두 번째 분기도 이번에는 최대 풀링을 적용하여 공간 차원을 줄입니다. downsample_module의 출력은 채널 차원을 따라 연결됩니다.
위 그림에서 downsample_module을 시각화 할 수 있습니다. 그림에서 알 수 있듯이 컨볼루션 및 최대 풀링 작업이 동일한 입력에 적용된 다음 연결됩니다.
이제 모든 조각을 모을 준비가되었습니다. @staticmethod def build(width, height, depth, classes): # initialize the input shape to be “channels last” and the # channels dimension itself inputShape = (height, width, depth) chanDim = -1 # if we are using “channels first”, update the input shape # and channels dimension if K.image_data_format() == “channels_first”: inputShape = (depth, height, width) chanDim = 1
52 행은 네트워크에 대한 빌드 방법을 정의합니다. 우리의 빌드 방법은 입력 너비, 높이, 깊이 및 학습 할 총 클래스 수를 허용합니다. 55 행과 56 행은 우리가 “channels last”순서를 사용한다고 가정하고 inputShape와 chanDim을 초기화합니다. 대신 “channels first”순서를 사용하는 경우 60-62 행은 이러한 변수를 각각 업데이트합니다. 첫 번째 conv_module과 함께 모델 입력을 정의 해 보겠습니다. # define the model input and first CONV module inputs = Input(shape=inputShape) x = MiniGoogLeNet.conv_module(inputs, 96, 3, 3, (1, 1), chanDim)
65 행의 입력에 대한 호출은 아키텍처를 초기화합니다. 네트워크에 대한 모든 입력은 단순히 입력 데이터를 “holds”하는 이 계층에서 시작됩니다 (모든 네트워크에 입력이 있어야 함). 첫 번째 CONV => BN => RELU는 66 번과 67 번 줄에 적용되어 96, 3×3 필터를 학습합니다. 여기에서 두 개의 Inception 모듈과 다운 샘플 모듈을 쌓습니다. # two Inception modules followed by a downsample module x = MiniGoogLeNet.inception_module(x, 32, 32, chanDim) x = MiniGoogLeNet.inception_module(x, 32, 48, chanDim) x = MiniGoogLeNet.downsample_module(x, 80, chanDim)
첫 번째 Inception 모듈 (70 행)은 1×1 및 3×3 CONV 레이어 모두에 대해 32 개의 필터를 학습합니다. 연결되면이 모듈은 K = 32 + 32 = 64 필터로 볼륨을 출력합니다. 두 번째 Inception 모듈 (71 행)은 32, 1 × 1 필터와 48, 3 × 3 필터를 학습합니다. 다시 연결하면 출력 볼륨 크기가 K = 32 + 48 = 80임을 알 수 있습니다. 다운 샘플 모듈은 입력 볼륨 크기를 줄이지 만 80에서 학습 한 필터 수는 동일하게 유지합니다. 다음으로 4 개의 Inception 모듈을 위에 쌓아 보겠습니다. 다운 샘플을 적용하기 전에 GoogLeNet이 더 깊고 풍부한 기능을 학습 할 수 있도록 합니다. # four Inception modules followed by a downsample module x = MiniGoogLeNet.inception_module(x, 112, 48, chanDim) x = MiniGoogLeNet.inception_module(x, 96, 64, chanDim) x = MiniGoogLeNet.inception_module(x, 80, 80, chanDim) x = MiniGoogLeNet.inception_module(x, 48, 96, chanDim) x = MiniGoogLeNet.downsample_module(x, 96, chanDim)
일부 레이어에서는 3×3 필터보다 1×1 필터를 더 많이 학습하는 반면 다른 Inception 모듈은 1×1보다 3×3 필터를 더 많이 학습합니다. 이러한 유형의 변형 패턴은 Szegedy et al. 이 많은 실험을 결과로 의도적으로 수행된 것입니다.. 이 장 뒷 부분에서 GoogLeNet의 더 깊은 변형을 구현할 때 이 패턴을 볼 수 있습니다. 구현을 계속하면서 이제 두 개의 시작 모듈을 더 적용한 다음 글로벌 풀 및 드롭 아웃을 적용 할 것입니다. # two Inception modules followed by global POOL and dropout x = MiniGoogLeNet.inception_module(x, 176, 160, chanDim) x = MiniGoogLeNet.inception_module(x, 176, 160, chanDim) x = AveragePooling2D((7, 7))(x) x = Dropout(0.5)(x)
83 행 이후의 출력 볼륨 크기는 7×7×336 입니다. 7×7의 평균 풀링을 적용하면 볼륨 크기가 1×1×336으로 줄어들 기 때문에 많은 완전 연결 레이어를 적용 할 필요성이 줄어 듭니다. 대신 간단히 컨볼루션의 공간 출력을 평균해 버립니다. 드롭 아웃은 과적 합을 줄이기 위해 85행에서 50 % 확률로 적용됩니다. 마지막으로 배우고 자하는 클래스 수에 따라 소프트맥스 분류기를 추가합니다. # softmax classifier x = Flatten()(x) x = Dense(classes)(x) x = Activation(“softmax”)(x) # create the model model = Model(inputs, x, name=”googlenet”) # return the constructed network architecture return model
그런 다음 실제 모델은 inputs, layer (내부 분기를 포함하는 x) 및 선택적으로 네트워크의 이름을 전달하는 93 행에서 인스턴스화됩니다. 구성된 아키텍처는 96 행의 호출 함수로 반환됩니다.
Inception 모듈의 동기에 대해 논의 했으므로 이제 그림에서 실제 모듈 자체를 살펴 보겠습니다.
GoogLeNet에서 사용 된 원래 Inception 모듈. Inception 모듈은 네트워크의 동일한 모듈 내에서 1 × 1, 3 × 3 및 5 × 5 컨볼 루션을 계산하여 “다단계 특징 추출기”역할을합니다.
Szegedy et al., 2014 논문 그림
활성화 함수 (ReLU)는 모든 CONV 계층 이후에 암시 적으로 적용됩니다. 공간을 절약하기 위해이 활성화 기능은 위의 네트워크 다이어그램에 포함되지 않았습니다. GoogLeNet을 구현할 때이 활성화가 Inception 모듈에서 어떻게 사용되는지 볼 수 있습니다.
특히 Inception 모듈이 입력 계층에서 4개의 개별 경로로 분기되는 방식을 주목하십시오. Inception 모듈의 첫 번째 분기는 입력에서 일련의 1×1 로컬피처를 학습합니다.
두 번째 배치는 먼저 1×1 컨볼루션을 로컬 피처 학습의 한 형태로 적용 할뿐만 아니라 차원 감소로 적용합니다. 더 큰 컨볼루션 (즉, 3×3 및 5×5)은 정의상 더 많은 계산을 수행해야합니다. 따라서 1×1 컨볼루션을 적용하여 이러한 더 큰 필터에 대한 입력의 차원을 줄일 수 있다면 네트워크에 필요한 계산량을 줄일 수 있습니다. 따라서 두 번째 분기의 1×1 CONV에서 학습 된 필터의 수는 항상 나중에 직접 학습 된 3×3 필터의 수보다 적습니다.
세 번째 분기는 두 번째 분기와 동일한 논리를 적용하지만 이번에는 5×5 필터 학습을 목표로 합니다. 다시 한 번 1×1 컨볼 루션을 통해 차원을 줄인 다음 출력을 5×5 필터에 공급합니다.
Inception 모듈의 네 번째이자 마지막 분기는 1 × 1의 stride로 3 × 3 max 풀링을 수행합니다. 이 분기를 일반적으로 풀 프로젝션 분기라고합니다. 역사적으로 풀링을 수행하는 모델은 더 높은 정확도를 얻을 수있는 능력을 보여 왔지만 2014 년 Springenberg et al 논문, Striving for Simplicity : The All Convolutional Net 에서는 이것이 반드시 사실은 아니며 볼륨 크기를 줄이기 위해 POOL 레이어를 CONV 레이어로 대체 할 수 있다고 설명했습니다.
Szegedy et al.의 경우 CNN이 합리적으로 수행되는 데 필요하다고 생각했기 때문에 이 POOL 레이어가 추가되었습니다. 그런 다음 POOL의 출력은 로컬 기능을 학습하기 위해 또 다른 일련의 1 x 1 컨볼 루션으로 공급됩니다.
마지막으로 Inception 모듈의 4 개 분기가 모두 수렴하여 채널 차원을 따라 함께 연결됩니다. 구현 중에 (제로 패딩을 통해) 각 분기의 출력이 동일한 볼륨 크기를 가지도록 특별히 주의하여 출력을 연결할 수 있도록 합니다. Inception 모듈의 출력은 네트워크의 다음 계층으로 공급됩니다. 실제로, 우리는 종종 볼륨 크기를 줄이기 위해 풀링 작업을 수행하기 전에 여러 Inception 모듈을 서로 겹쳐 쌓습니다.
첫째, 모델 아키텍처는 AlexNet 및 VGGNet에 비해 작습니다 (가중치 자체의 경우 ≈ 28MB). 작성자는 완전히 연결된 레이어를 제거하고 대신 글로벌 평균 풀링을 사용하여 네트워크 아키텍처 크기를 크게 줄일 수 있었습니다 (전체 네트워크의 깊이는 여전히 증가). CNN의 가중치 대부분은 고밀도 FC 레이어에서 찾을 수 있습니다. 이러한 레이어를 제거 할 수 있다면 메모리 절약이 엄청납니다.
둘째, Szegedy et al. 논문은 전체 매크로 아키텍처를 구성 할 때 네트워크 또는 마이크로 아키텍처에서 네트워크를 사용합니다.
지금까지 한 네트워크의 출력이 다음 네트워크로 직접 공급되는 순차 신경망 만 보았습니다. 이제 나머지 아키텍처 내부에서 사용되는 작은 빌딩 블록인 마이크로 아키텍처를 살펴 보겠습니다. 여기서 한 레이어의 출력은 여러 다양한 경로로 분할되고 나중에 다시 결합 될 수 있습니다.
특히, Szegedy et al 논문은 Convolutional Neural Network에 맞는 빌딩 블록 인 딥러닝 커뮤니티에 Inception 모듈을 제공하여 여러 필터 크기로 CONV 계층을 학습하여 모듈을 다단계 기능 추출기로 전환했습니다.
Inception과 같은 마이크로 아키텍처는 ResNet의 Residual 모듈과 SqueezeNet의 Fire 모듈을 포함한 다른 중요한 변형에 영감을 주었습니다. 이 장의 뒷부분에서 Inception 모듈 (및 그 변형)에 대해 설명합니다. Inception 모듈을 검사하고 작동 방식을 확인한 후 “MiniGoogLeNet”이라는 GoogLeNet의 더 작은 버전을 구현합니다. 이전 장의 CIFAR-10 데이터 세트에서이 아키텍처를 훈련하고 어떤 것보다 더 높은 정확도를 얻을 것입니다.
여기에서 더 어려운 cs231n Tiny ImageNet Challenge로 넘어갈 것입니다. 이 도전은 최종 프로젝트의 일부로 Stanford의 cs231n Convolutional Neural Networks for Visual Recognition 수업에 등록한 학생들에게 제공됩니다. 이는 전체 ImageNet 데이터 세트만큼 작업하는 데 시간이 많이 걸리거나 부담을주지 않으면서 현대 아키텍처에서 대규모 딥 러닝과 관련된 과제를 맛볼 수 있음을 의미합니다.
Tiny ImageNet에서 GoogLeNet을 처음부터 교육함으로써 Tiny ImageNet 리더 보드에서 상위 순위를 차지하는 방법을 보여 드리겠습니다. 다음 장에서는 ResNet을 활용하여 처음부터 훈련 된 모델에서 최고의 위치를 차지할 것입니다. Inception 모듈에 대해 논의하여 이 장을 시작하겠습니다.
최신 첨단 컨볼루션 신경망은 원래 Lin et al.이 제안한 네트워크 내 네트워크 모듈이라고도 하는 마이크로 아키텍처를 활용합니다. 저는 개인적으로 마이크로 아키텍처라는 용어를 선호합니다.이 모듈은 전체 매크로 아키텍처 (즉, 실제로 구축하고 훈련하는 것)의 맥락에서 이러한 모듈을 빌딩 블록으로 더 잘 설명하기 때문입니다.
마이크로 아키텍처는 네트워크 깊이를 증가시키면서 네트워크가 (1) 더 빠르게, (2) 더 효율적으로 학습 할 수 있도록 딥 러닝 실무자가 설계 한 작은 빌딩 블록입니다. 이러한 마이크로 아키텍처 빌딩 블록은 CONV, POOL 등과 같은 기존 레이어 유형과 함께 스택되어 전체 매크로 아키텍처를 형성합니다.
2014 년에 Szegedy et al 논문에서 Inception 모듈을 도입했습니다. Inception 모듈의 일반적인 개념은 두 가지입니다.
1. 주어진 CONV 레이어에서 학습해야하는 필터의 크기를 결정하는 것은 어려울 수 있습니다. 5 × 5 필터 여야합니까? 3 × 3 필터는 어떻습니까? 1 × 1 필터를 사용하여 로컬 피쳐를 학습해야 합니까? 대신 모든 것을 배우고 모델이 결정하도록 하는 것은 어떨까요? Inception 모듈 내에서 채널 차원을 따라 결과 피쳐 맵을 연결하는 3 개의 5×5, 3×3 및 1×1 필터 (병렬로 계산)를 모두 학습합니다. GoogLeNet 아키텍처의 다음 레이어 (다른 Inception 모듈 일 수 있음)는 이러한 연결되고 혼합된 필터를 수신하고 동일한 프로세스를 수행합니다. 전체적으로 볼 때 이 프로세스를 통해 GoogLeNet은 더 작은 컨볼 루션을 통해 로컬 기능과 더 큰 컨볼루션을 가진 추상화 된 기능을 모두 학습 할 수 있습니다. 더 작은 기능을 희생하여 추상화 수준을 희생 할 필요가 없습니다.
2. 여러 필터 크기를 학습하여 모듈을 다단계 피쳐 추출기로 전환 할 수 있습니다. 5 × 5 필터는 더 큰 수용 크기를 가지며 더 많은 추상 피쳐를 학습 할 수 있습니다. 1×1 필터는 로컬 제한적 입니다. 3×3 필터는 그 사이에 균형을 이루고 있습니다.
