Keras와 TPU를 사용한 컨볼루셔널 신경망

1. 개요

이 실습에서는 컨볼루셔널 레이어를 꽃을 인식할 수 있는 신경망 모델로 조합하는 방법을 알아봅니다. 이번에는 모델을 처음부터 직접 빌드하고 TPU의 성능을 활용하여 몇 초 만에 모델을 학습시키고 설계를 반복합니다.

이 실습에는 컨볼루셔널 신경망에 관한 필요한 이론적 설명이 포함되어 있으며, 딥 러닝을 배우는 개발자가 이 실습을 시작하기에 좋은 출발점이 될 것입니다.

이 실습은 'TPU 기반 Keras'의 3부입니다. Google Cloud 시리즈를 확인해 보세요 다음 순서대로 또는 개별적으로 수행할 수 있습니다.

• TPU 속도의 데이터 파이프라인: tf.data.Dataset 및 TFRecords
• 전이 학습을 사용한 첫 번째 Keras 모델
• [이 실험실] Keras와 TPU를 사용한 컨볼루셔널 신경망
• Keras 및 TPU를 사용한 최신 Convnet, Squeezenet, Xception

학습할 내용

• Keras Sequential 모델을 사용하여 컨볼루셔널 이미지 분류기 빌드
• TPU에서 Keras 모델 학습시키기
• 적절한 컨볼루셔널 레이어를 선택하여 모델을 미세 조정하는 것

의견

이 Codelab에서 잘못된 부분을 발견하면 알려주세요. 의견은 GitHub 문제[의견 링크]를 통해 제공할 수 있습니다.

2. Google Colaboratory 빠른 시작

이 실습에서는 Google Collaboratory를 사용하므로 사용자가 별도로 설정할 필요가 없습니다. Colaboratory는 교육용 온라인 노트북 플랫폼입니다. 무료 CPU, GPU, TPU 학습을 제공합니다.

이 샘플 노트북을 열고 몇 개의 셀을 실행하여 Colaboratory에 익숙해지세요.

Welcome to Colab.ipynb

TPU 백엔드 선택

Colab 메뉴에서 런타임 > 런타임 유형 변경을 선택한 다음 TPU를 선택합니다. 이 Codelab에서는 하드웨어 가속 학습에 지원되는 강력한 TPU (Tensor Processing Unit)를 사용합니다. 처음 실행 시 런타임에 자동으로 연결이 이루어집니다. 또는 '연결' 버튼을 클릭합니다.

노트북 실행

셀을 클릭하고 Shift-Enter를 사용하여 셀을 한 번에 하나씩 실행합니다. 런타임 > 모두 실행

목차

모든 노트북에는 목차가 있습니다. 왼쪽에 있는 검은색 화살표를 사용해 파일을 열 수 있습니다.

숨겨진 셀

일부 셀에는 제목만 표시됩니다. Colab 전용 노트북 기능입니다. 두 번 클릭하면 안의 코드를 볼 수 있지만 보통은 그다지 흥미롭지 않습니다. 일반적으로 지원 또는 시각화 함수입니다. 내부의 함수를 정의하려면 이러한 셀을 실행해야 합니다.

인증

승인된 계정으로 인증하면 Colab에서 비공개 Google Cloud Storage 버킷에 액세스할 수 있습니다. 위의 코드 스니펫은 인증 프로세스를 트리거합니다.

3. [정보] Tensor Processing Unit (TPU)이란 무엇인가요?

요약

TPU는 딥 러닝 작업에 특화된 하드웨어 가속기입니다. 이 Codelab에서는 Keras와 Tensorflow 2에서 이를 사용하는 방법을 알아봅니다. Cloud TPU는 8개의 코어가 포함된 기본 구성과 'TPU 포드'라는 더 큰 구성으로 제공됩니다. 최대 2048개의 코어를 실행할 수 있습니다 추가 하드웨어는 학습 배치 크기를 늘려 학습을 가속화하는 데 사용할 수 있습니다.

Keras의 TPU에서 모델을 학습시키기 위한 코드 (TPU를 사용할 수 없는 경우 GPU 또는 CPU로 대체)

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

오늘은 TPU를 사용하여 상호작용 속도 (학습 실행당 분)의 꽃 분류기를 빌드하고 최적화해 보겠습니다.

TPU를 사용해야 하는 이유

최신 GPU는 프로그래밍 가능한 '코어'를 중심으로 구성됩니다. 코어는 3D 렌더링, 딥 러닝, 물리적 시뮬레이션 등과 같은 다양한 작업을 처리할 수 있는 매우 유연한 아키텍처입니다. 반면 TPU는 기본 벡터 프로세서에 전용 행렬 곱셈 유닛을 결합하고 신경망과 같이 큰 행렬 곱셈이 중요한 모든 작업에서 탁월한 성능을 발휘합니다.

그림: 행렬 곱셈이 적용된 밀집 신경망 레이어로, 신경망을 통해 한 번에 처리된 8개의 이미지 배치가 포함됩니다. 한 줄 x 열 곱셈을 실행하여 이미지의 모든 픽셀 값에 대한 가중치가 적용된 합계를 실제로 수행하고 있는지 확인하세요. 컨볼루셔널 레이어는 조금 더 복잡하지만 ( 이 섹션 1의 설명)도 행렬 곱셈으로 표현할 수 있습니다.

하드웨어

MXU 및 VPU

TPU v2 코어는 행렬 곱셈과 VPU(벡터 처리 장치)를 실행하는 MXU(Matrix Multiply Unit)로 구성되며, 활성화, softmax 등의 기타 모든 작업을 위한 VPU(벡터 처리 장치)가 실행됩니다. VPU는 float32 및 int32 계산을 처리합니다. 반면에 MXU는 혼합 정밀도 16~32비트 부동 소수점 형식으로 작동합니다.

정밀도 부동 소수점과 bfloat16이 혼합됨

MXU는 bfloat16 입력 및 float32 출력을 사용하여 행렬 곱셈을 계산합니다. 중간 누적은 float32 정밀도로 실행됩니다.

신경망 학습은 일반적으로 부동 소수점 정밀도 감소로 인해 발생하는 노이즈에 강합니다. 노이즈가 옵티마이저가 수렴하는 데까지 도움이 되는 경우도 있습니다. 전통적으로 16비트 부동 소수점 정밀도는 계산을 가속화하는 데 사용되었지만 float16 및 float32 형식은 범위가 매우 다릅니다. 정밀도를 float32에서 float16으로 줄이면 일반적으로 오버 및 언더플로가 발생합니다. 솔루션이 있지만 float16이 작동하려면 일반적으로 추가 작업이 필요합니다.

이러한 이유로 Google은 TPU에 bfloat16 형식을 도입했습니다. bfloat16은 float32와 정확히 동일한 지수 비트와 범위를 가진 잘린 float32입니다. 이는 TPU가 bfloat16 입력과 float32 출력의 혼합 정밀도로 행렬 곱셈을 계산한다는 사실에 더해, 일반적으로 낮은 정밀도의 성능 향상 이점을 누리기 위해 코드를 변경할 필요가 없다는 뜻입니다.

TPU에서는 bfloat16/float32 혼합 정밀도를 사용하는 것이 기본값입니다. TensorFlow 코드를 변경하기 위해 코드를 변경하지 않아도 됩니다. 코드 전체에서 float32로 계속 작업합니다. 행렬 곱셈을 실행할 때 TPU는 자동으로 bfloat16 입력을 자릅니다. 결과 행렬은 float32입니다.

수축 배열

MXU는 이른바 '시스톨릭 배열'을 사용하여 하드웨어에서 행렬 곱셈을 구현합니다. 데이터 요소가 하드웨어 계산 장치의 배열을 통해 흐르는 아키텍처. (의학에서 '수축기'는 심장 수축과 혈류, 여기서는 데이터의 흐름을 의미합니다.)

행렬 곱셈의 기본 요소는 한 행렬의 선과 다른 행렬의 열 사이의 내적입니다 (이 섹션 상단의 그림 참조). 행렬 곱셈 Y=X*W의 경우 결과의 한 요소는 다음과 같습니다.

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

GPU에서는 이 제품을 GPU '코어'로 프로그래밍합니다. 최대한 많은 '코어'에서 결과 행렬의 모든 값을 한 번에 계산하려고 시도합니다. 결과 행렬이 128x128 큰 경우 128x128=16K '코어'가 필요합니다. 일반적으로는 불가능한 상태입니다 가장 큰 GPU에는 약 4000개의 코어가 있습니다. 반면 TPU는 MXU의 컴퓨팅 단위에 최소한의 하드웨어만 사용합니다. 즉, bfloat16 x bfloat16 => float32 곱셈-누산기만 사용합니다. 이러한 연산은 매우 작아서 TPU에서 128x128 MXU로 16K를 구현하고 한 번에 행렬 곱셈을 처리할 수 있습니다.

그림: MXU 수축기 배열 컴퓨팅 요소는 곱셈-누산기입니다. 한 행렬의 값이 배열 (빨간색 점)에 로드됩니다. 다른 행렬의 값은 배열 (회색 점)을 통과합니다. 수직선은 값을 위로 전파합니다. 가로선은 부분 합계를 전파합니다. 데이터가 배열을 통과할 때 오른쪽에서 행렬 곱셈의 결과가 나오는지 확인하는 작업은 사용자의 연습으로 남겨 둡니다.

그 밖에도, 내적이 MXU에서 계산되는 동안 중간 합계는 단순히 인접한 컴퓨팅 단위 간에 흐릅니다. 메모리 또는 레지스터 파일에서도 저장하고 검색할 필요가 없습니다. 결과적으로 TPU 시스톨릭 배열 아키텍처는 밀도와 전력 측면에서 상당한 이점을 얻을 뿐만 아니라 행렬 곱셈을 계산할 때 GPU에 비해 무시할 수 없는 속도상의 이점을 얻게 됩니다.

Cloud TPU

" Cloud TPU v2인치 PCI 연결 TPU 보드가 포함된 가상 머신 (VM)을 얻을 수 있습니다. TPU 보드에는 4개의 듀얼 코어 TPU 칩이 있습니다. 각 TPU 코어에는 VPU (벡터 처리 장치)와 128x128 MXU (MatriX 곱하기 단위)가 있습니다. 이 'Cloud TPU'는 일반적으로 네트워크를 통해 이를 요청한 VM에 연결됩니다. 전체 그림은 다음과 같습니다.

그림: 네트워크에 연결된 'Cloud TPU'가 있는 VM 액셀러레이터를 생성합니다 'Cloud TPU' 듀얼 코어 TPU 칩이 4개 있는 PCI 연결 TPU 보드가 탑재된 VM으로 구성됩니다.

TPU 포드

Google의 데이터 센터에서 TPU는 고성능 컴퓨팅 (HPC) 상호 연결에 연결되어 하나의 거대한 가속기처럼 보일 수 있습니다. Google은 이를 포드라고 부르며 최대 512개의 TPU v2 코어 또는 2,048개의 TPU v3 코어를 포함할 수 있습니다.

그림: TPU v3 포드 HPC Interconnect를 통해 연결된 TPU 보드 및 랙

학습 중에는 AllReduce 알고리즘을 사용하여 TPU 코어 간에 경사가 교환됩니다 ( 여기에 all-Reduce에 대한 자세한 설명). 학습 중인 모델은 큰 배치 크기로 학습시켜 하드웨어를 활용할 수 있습니다.

그림: Google TPU의 2D 원환형 메시 HPC 네트워크에서 AllReduce 알고리즘을 사용하여 학습 중 경사의 동기화

소프트웨어는

대형 배치 크기 학습

TPU에 이상적인 배치 크기는 TPU 코어당 128개의 데이터 항목이지만, 하드웨어는 이미 TPU 코어당 8개의 데이터 항목 중에서 적절한 사용률을 표시하고 있습니다. Cloud TPU 한 개에는 코어가 8개 있습니다.

이 Codelab에서는 Keras API를 사용합니다. Keras에서 지정하는 배치는 전체 TPU의 전역 배치 크기입니다. 배치가 자동으로 8개로 분할되어 TPU의 8개 코어에서 실행됩니다.

추가 성능 팁은 TPU 성능 가이드를 참조하세요. 매우 큰 배치 크기의 경우 일부 모델에서 특별한 주의가 필요할 수 있습니다. 자세한 내용은 LARSOptimizer를 참고하세요.

비하인드 스토리: XLA

TensorFlow 프로그램은 계산 그래프를 정의합니다. TPU는 Python 코드를 직접 실행하지 않고 TensorFlow 프로그램에서 정의한 계산 그래프를 실행합니다. 내부적으로 XLA (가속 선형 대수 컴파일러)라는 컴파일러는 계산 노드의 TensorFlow 그래프를 TPU 기계어 코드로 변환합니다. 이 컴파일러는 코드 및 메모리 레이아웃에 관해 다양한 고급 최적화도 실행합니다. 작업이 TPU로 전송될 때 컴파일이 자동으로 실행됩니다. 빌드 체인에 명시적으로 XLA를 포함하지 않아도 됩니다.

그림: TPU에서 실행하기 위해 TensorFlow 프로그램에서 정의한 계산 그래프는 먼저 XLA (가속 선형 대수학 컴파일러) 표현으로 변환된 다음 XLA를 통해 TPU 머신 코드로 컴파일됩니다.

Keras에서 TPU 사용

TPU는 Tensorflow 2.1부터 Keras API를 통해 지원됩니다. Keras 지원은 TPU 및 TPU 포드에서 작동합니다. 다음은 TPU, GPU, CPU에서 작동하는 예입니다.

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

이 코드 스니펫에서 각 항목의 의미는 다음과 같습니다.

• TPUClusterResolver().connect()는 네트워크에서 TPU를 찾습니다. 대부분의 Google Cloud 시스템 (AI Platform 작업, Colaboratory, Kubeflow, 'ctpu up' 유틸리티를 통해 생성된 딥 러닝 VM)에서 매개변수 없이 작동합니다. 이러한 시스템은 TPU_NAME 환경 변수 덕분에 TPU의 위치를 알고 있습니다. TPU를 직접 만드는 경우 TPU_NAME 환경을 설정하거나 var. 사용 중인 VM에서 또는 명시적 매개변수(TPUClusterResolver(tp_uname, zone, project))를 사용하여 TPUClusterResolver를 호출합니다.
• TPUStrategy는 분포와 'all-reduce'를 구현하는 부분입니다. 경사 동기화 알고리즘입니다.
• 전략이 범위를 통해 적용됩니다. 모델은 전략 scope() 내에 정의되어야 합니다.
• tpu_model.fit 함수에는 TPU 학습을 위한 입력으로 tf.data.Dataset 객체가 필요합니다.

일반적인 TPU 포팅 작업

• TensorFlow 모델에서 데이터를 로드하는 방법에는 여러 가지가 있지만 TPU의 경우 tf.data.Dataset API를 사용해야 합니다.
• TPU는 매우 빠르기 때문에 데이터를 수집할 때 TPU 실행 시 병목 현상이 발생하는 경우가 많습니다. TPU 성능 가이드에는 데이터 병목 현상을 감지하는 데 사용할 수 있는 도구와 기타 성능 팁이 있습니다.
• int8 또는 int16 숫자는 int32로 취급됩니다. TPU에는 32비트 미만에서 작동하는 정수 하드웨어가 없습니다.
• 일부 TensorFlow 작업은 지원되지 않습니다. 목록은 여기에서 확인하세요. 좋은 소식은 이 제한이 모델을 정방향 및 역방향으로 전달하는 학습 코드에만 적용된다는 것입니다. 모든 TensorFlow 작업은 CPU에서 실행되므로 데이터 입력 파이프라인에서 계속 사용할 수 있습니다.
• tf.py_func는 TPU에서 지원되지 않습니다.

4. [정보] 신경망 분류 기준 101

요약

다음 단락에서 굵게 표시된 모든 용어를 이미 알고 있는 경우 다음 실습으로 이동할 수 있습니다. 딥 러닝을 이제 막 시작했다면 환영하며, 계속 읽어 보시기 바랍니다.

신경망 분류기는 뉴런의 여러 레이어로 구성됩니다. 이미지 분류의 경우 밀집 레이어 또는 컨볼루셔널 레이어일 수 있습니다. 일반적으로 relu 활성화 함수를 통해 활성화됩니다. 마지막 레이어는 클래스와 동일한 수의 뉴런을 사용하며 소프트맥스로 활성화됩니다. 분류의 경우 교차 엔트로피는 가장 일반적으로 사용되는 손실 함수로, 원-핫 인코딩된 라벨 (정답)을 신경망에서 예측한 확률과 비교합니다. 손실을 최소화하려면 운동량이 있는 옵티마이저(예: AdamOptimizer)를 선택하고 학습 이미지 및 라벨 배치로 학습하는 것이 가장 좋습니다.

레이어의 시퀀스로 빌드된 모델의 경우 Keras는 Sequential API를 제공합니다. 예를 들어 밀집 레이어 3개를 사용하는 이미지 분류기는 Keras로 다음과 같이 작성할 수 있습니다.

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

고밀도 신경망

이는 이미지 분류를 위한 가장 단순한 신경망입니다. 인코더-디코더는 '뉴런'으로 층으로 배열됩니다. 첫 번째 레이어는 입력 데이터를 처리하고 그 출력을 다른 레이어에 제공합니다. 이를 '밀도가 높은' 각 뉴런이 이전 레이어의 모든 뉴런과 연결되어 있기 때문입니다.

모든 픽셀의 RGB 값을 긴 벡터로 평면화하고 입력으로 사용하여 이미지를 이러한 네트워크에 피드할 수 있습니다. 이미지 인식에 가장 적합한 기술은 아니지만 나중에 개선하겠습니다.

뉴런, 활성화, RELU

'뉴런' 모든 입력의 가중 합계를 계산한 다음 '편향'이라는 값을 더합니다. 소위 '활성화 함수'를 통해 결과를 제공합니다. 가중치와 편향은 처음에는 알 수 없습니다. 무작위로 초기화되고 '학습'됩니다. 신경망을 학습시킬 수 있습니다.

가장 많이 사용되는 활성화 함수는 정류 선형 유닛의 RELU입니다. 위의 그래프에서 볼 수 있듯이 매우 간단한 함수입니다.

소프트맥스 활성화

꽃을 5가지 카테고리 (장미, 튤립, 민들레, 데이지, 해바라기)로 분류하기 때문에 위의 네트워크는 5개의 뉴런 레이어로 끝납니다. 중간 레이어의 뉴런은 클래식 RELU 활성화 함수를 사용하여 활성화됩니다. 하지만 마지막 레이어에서는 이 꽃이 장미나 튤립일 확률을 나타내는 0과 1 사이의 숫자를 계산하려고 합니다. 이를 위해 '소프트맥스'라는 활성화 함수를 사용하겠습니다.

벡터에 소프트맥스를 적용하려면 각 요소의 지수를 구한 다음, 일반적으로 L1 norm (절대값의 합)을 사용하여 값의 합이 최대 1이 되어 확률로 해석될 수 있도록 벡터를 정규화합니다.

'소프트맥스'가 어떻게 해야 할까요? 지수는 급격히 증가하는 함수입니다. 뉴런 출력 간의 차이가 증가합니다. 그런 다음 벡터를 정규화할 때 표준을 지배하는 가장 큰 요소가 1에 가까운 값으로 정규화되고 다른 모든 요소는 큰 값으로 나누어 0에 가까운 값으로 정규화됩니다. 결과 벡터는 가장 우수한 클래스인 'max'를 명확하게 보여주지만 값의 원래 상대적 순서를 유지하기 때문에 'soft'가 됩니다.

교차 엔트로피 손실

이제 신경망이 입력 이미지에서 예측을 생성하므로 얼마나 좋은지 측정해야 합니다. 즉, 네트워크가 알려준 내용과 종종 '라벨'이라고 하는 정답 사이의 거리를 측정해야 합니다. 데이터 세트의 모든 이미지에 올바른 라벨이 있다는 점을 기억하세요.

모든 거리가 작동하지만 분류 문제의 경우 '교차 엔트로피 거리'가 가장 효과적입니다. 이를 오류 또는 '손실'이라고 하겠습니다. 함수:

'원-핫' 인코딩은 '3) 민들레'라는 5개 값으로 구성된 벡터를 사용하여 세 번째 값인 1을 제외한 모든 0을 생성합니다. 이 벡터는 민들레가 될 확률을 100% 나타냅니다. 또한 신경망은 예측을 5개의 확률값이 있는 벡터로 출력합니다. 비교가 쉽습니다.

경사하강법

"학습" 신경망은 실제로 학습 이미지와 라벨을 사용하여 교차 엔트로피 손실 함수를 최소화하기 위해 가중치와 편향을 조정하는 것을 의미합니다. 작동 원리는 다음과 같습니다.

교차 엔트로피는 가중치, 편향, 학습 이미지의 픽셀 및 알려진 클래스의 함수입니다.

모든 가중치와 모든 편향에 상대적인 교차 엔트로피의 편미분을 계산하면 주어진 이미지, 라벨, 가중치와 편향의 현재 값에 대해 계산된 '경사'를 얻게 됩니다. 수백만 개의 가중치와 편향이 있을 수 있으므로 경사를 계산하는 것은 엄청난 노력으로 들립니다. 다행히 Tensorflow가 이를 자동으로 수행합니다. 그라데이션의 수학적 특성은 '위쪽'을 향한다는 것입니다. 교차 엔트로피가 낮은 곳으로 가려고 하므로 반대 방향으로 갑니다. 가중치와 편향은 경사의 비율로 업데이트합니다. 그런 다음 학습 루프에서 다음 학습 이미지 및 라벨 배치를 사용하여 동일한 작업을 반복해서 수행합니다. 이 경우 교차 엔트로피가 최소 수준인 지점으로 연결되길 바라지만 이 최솟값이 고유하다는 것을 보장하지는 않습니다.

'학습률': 각 반복에서 전체 경사 길이만큼 가중치와 편향을 업데이트할 수 없습니다. 7리그 부츠를 신은 채 골짜기 바닥에 내려가는 것과 같습니다. 골짜기의 한쪽에서 다른 쪽으로 점프해야 했습니다. 최저치로 이동하려면 더 작은 단계를 실행해야 합니다. 예를 들어 그라데이션의 일부만 사용합니다(일반적으로 1/1000 범위). 이 비율을 '학습률'이라고 합니다.

미니 배치 및 모멘텀

예시 이미지 한 개에 대해서만 경사를 계산하고 가중치와 편향을 즉시 업데이트할 수 있지만, 예를 들어 128개 이미지 배치에서는 그라데이션이 적용되어 서로 다른 예시 이미지가 주는 제약 조건을 더 잘 표현하는 그라데이션이 제공되므로 솔루션을 향해 더 빠르게 수렴할 수 있습니다. 미니 배치의 크기는 조정 가능한 매개변수입니다.

'확률적 경사하강법'이라고도 하는 이 기법 또 다른 실용적인 이점이 있습니다. 배치 작업은 더 큰 행렬로 작업하게 되어 일반적으로 GPU 및 TPU에서 더 쉽게 최적화할 수 있다는 것입니다.

하지만 수렴은 여전히 약간 혼란스러울 수 있으며 경사 벡터가 모두 0이면 멈출 수도 있습니다. 최솟값을 찾았다는 뜻일까요? 항상 그렇지는 않습니다. 그라데이션 구성요소는 최솟값이나 최댓값이 0일 수 있습니다. 수백만 개의 요소가 있는 경사 벡터에서 요소가 모두 0인 경우 모든 0이 최솟값에 해당하고 어느 것도 최댓값에 해당하지 않을 확률은 매우 작습니다. 여러 차원의 공간에서 안장점은 매우 일반적이며 여기서 멈추고 싶지 않습니다.

삽화: 새들 포인트 경사는 0이지만 모든 방향에서 최솟값은 아닙니다. (이미지 저작자 표시 Wikimedia: By Nicoguaro - own work, CC BY 3.0)

해결책은 최적화 알고리즘에 모멘텀을 더하여 멈추지 않고 안장 지점을 지나 항해할 수 있도록 하는 것입니다.

TensorFlow 라이브러리는 tf.train.GradientDescentOptimizer부터 시작하는 광범위한 옵티마이저를 제공합니다. 모멘텀이 기본으로 제공되는 고급 옵티마이저로는 tf.train.RMSPropOptimizer 또는 tf.train.AdamOptimizer이 있습니다.

용어집

배치 또는 미니 배치: 항상 학습 데이터 및 라벨 배치에 대해 학습이 수행됩니다. 이렇게 하면 알고리즘이 수렴되는 데 도움이 됩니다. '배치' 차원은 일반적으로 데이터 텐서의 첫 번째 차원입니다. 예를 들어 형태가 [100, 192, 192, 3] 인 텐서에는 픽셀당 3개의 값 (RGB)이 있는 192x192픽셀 이미지 100개가 포함됩니다.

교차 엔트로피 손실: 분류기에서 자주 사용되는 특수한 손실 함수입니다.

밀집 레이어: 각 뉴런이 이전 레이어의 모든 뉴런과 연결되는 뉴런 레이어입니다.

특성: 신경망의 입력을 '특성'이라고 부르기도 합니다. 좋은 예측을 하기 위해 데이터 세트의 어떤 부분 (또는 부분의 조합)을 신경망에 입력해야 하는지 알아내는 기술을 '특성 추출'이라고 합니다.

labels: '클래스'의 다른 이름 지도 분류 문제에서 정답과 같은

학습률: 학습 루프의 각 반복에서 가중치와 편향이 업데이트되는 경사의 비율입니다.

로지트: 활성화 함수가 적용되기 전의 뉴런 레이어의 출력을 '로지트'라고 합니다. 이 용어는 '로지스틱 함수'에서 유래했습니다. '시그모이드 함수'라고도 합니다. 이는 가장 인기 있는 활성화 함수였습니다. '로지스틱 함수 이전의 뉴런 출력' 'logits'로 단축되었습니다.

loss: 신경망 출력을 정답과 비교하는 오류 함수

뉴런: 입력의 가중 합계를 계산하고 편향을 더한 후 활성화 함수를 통해 결과를 제공합니다.

원-핫 인코딩: 클래스 5개 중 3개가 5개 요소로 구성된 벡터로 인코딩됩니다. 이때 세 번째 원-핫 인코딩은 1인 클래스만 제외하고 모두 0입니다.

relu: 정류 선형 유닛입니다. 뉴런에 널리 사용되는 활성화 함수입니다.

시그모이드: 예전에는 널리 사용되어 왔지만 특별한 경우에 여전히 유용한 또 다른 활성화 함수입니다.

소프트맥스: 벡터에서 작동하고, 가장 큰 구성요소와 다른 구성요소 간의 차이를 늘리고, 확률 벡터로 해석될 수 있도록 벡터를 합계가 1이 되도록 정규화합니다. 분류기의 마지막 단계로 사용됩니다.

tensor: '텐서' 는 행렬과 같지만, 임의의 차원 수를 사용합니다. 1차원 텐서는 벡터입니다. 2차원 텐서는 행렬입니다. 그런 다음 3차원, 4차원, 5차원 또는 그 이상의 차원을 가진 텐서를 사용할 수 있습니다.

5. [신규 정보] 컨볼루셔널 신경망

요약

다음 단락에서 굵게 표시된 모든 용어를 이미 알고 있는 경우 다음 실습으로 이동할 수 있습니다. 컨볼루셔널 신경망을 이제 막 배우셨다면 계속 읽어 보시기 바랍니다.

그림: 각각 4x4x3=48의 학습 가능 가중치로 구성된 2개의 연속된 필터로 이미지를 필터링하고 있습니다.

컨볼루셔널 신경망은 입력 이미지에 일련의 학습 가능한 필터를 적용합니다. 컨볼루셔널 레이어는 필터 (또는 커널) 크기, 적용된 필터의 수 및 스트라이드로 정의됩니다. 컨볼루셔널 레이어의 입력과 출력에는 입력 이미지 (너비, 높이, RGB 채널)부터 시작하여 3차원 (너비, 높이, 채널 수)이 있습니다. 컨볼루셔널 레이어를 쌓는 경우 1보다 큰 스트라이드 또는 max-pooling 연산을 사용하여 출력의 너비와 높이를 조정할 수 있습니다. 출력의 깊이 (채널의 nb)는 더 많이 또는 더 적은 필터를 사용하여 조정됩니다.

Keras에서 간단한 컨볼루셔널 신경망은 다음과 같습니다.

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

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

컨볼루셔널 신경망 기초

컨볼루셔널 신경망의 레이어에는 하나의 '뉴런'이 는 이미지의 작은 영역에 대해서만 바로 위에 있는 픽셀의 가중 합계를 수행합니다. 일반 밀집 레이어의 뉴런처럼 편향을 추가하고 활성화 함수를 통해 합계를 제공합니다. 그런 다음 동일한 가중치를 사용하여 전체 이미지에서 이 연산을 반복합니다. 밀집 레이어에서 각 뉴런에는 고유한 가중치가 있다는 점을 기억하세요. 여기에서는 단일 '패치'가 이미지에서 양방향으로 슬라이드되는 가중치의 비율('컨볼루션') 출력에는 이미지의 픽셀 수만큼의 값이 있습니다. 하지만 가장자리에는 일부 패딩이 필요합니다. 이는 4x4x3=48 가중치 필터를 사용하는 필터링 연산입니다.

하지만 48개의 가중치로는 충분하지 않습니다. 자유도를 더 추가하려면 새로운 가중치 집합으로 동일한 연산을 반복합니다. 그러면 새로운 필터 출력 세트가 생성됩니다. 'channel'이라고 하겠습니다. 출력의 R,G,B 채널을 입력 이미지의 채널과 비유하면 됩니다

새 차원을 추가하여 두 개 이상의 가중치 집합을 하나의 텐서로 합산할 수 있습니다. 이렇게 하면 컨볼루셔널 레이어에 대한 가중치 텐서의 일반적인 형태를 얻을 수 있습니다. 입력 및 출력 채널의 수가 매개변수이므로 컨볼루셔널 레이어를 스택하고 체이닝할 수 있습니다.

삽화: 컨볼루셔널 신경망이 '정육면체'를 변환 데이터를 다른 '정육면체'로 확인할 수 있습니다

스트라이드 컨볼루션, 최대 풀링

2 또는 3의 스트라이드로 컨볼루션을 수행함으로써 결과로 생성되는 데이터 큐브를 수평 차원에서 축소할 수도 있습니다. 여기에는 두 가지 일반적인 방법이 있습니다.

• 스트라이드 컨볼루션: 위와 같지만 스트라이드가 1보다 큰 슬라이딩 필터
• 최대 풀링: MAX 연산을 적용하는 슬라이딩 윈도우 (일반적으로 2x2 패치에서 2픽셀마다 반복됨)

그림: 컴퓨팅 기간을 3픽셀 단위로 슬라이드하면 출력 값이 감소합니다. 스트라이드 컨볼루션 또는 최대 풀링 (2x2 윈도우에서 2의 스트라이드 슬라이딩의 최댓값)는 수평 차원에서 데이터 큐브를 축소하는 방법입니다.

'Max-pooling' 은 컨볼루셔널 신경망이 작동하는 방식을 직관적으로 이해하는 데 도움이 됩니다. 학습 중에 가중치 패치가 기본적인 모양 (수평선 및 수직선, 곡선 등)을 인식하는 필터로 발전한다고 가정한다면 유용한 정보를 압축하는 한 가지 방법은 도형이 최대 강도로 인식된 출력을 계층에 유지하는 것입니다. 실제로 max-pool 레이어에서는 뉴런 출력이 2x2 그룹으로 처리되고 최댓값만 유지됩니다.

온볼루셔널 분류기

마지막으로, 마지막 데이터 큐브를 평면화하고 밀집된 소프트맥스 활성화 레이어를 통해 피드하는 방식으로 분류 헤드를 연결합니다. 일반적인 컨볼루셔널 분류기는 다음과 같습니다.

삽화: 컨볼루셔널 및 소프트맥스 레이어를 사용하는 이미지 분류기 3x3 및 1x1 필터를 사용합니다. maxpool 레이어는 2x2 데이터 포인트 그룹의 최대 개수를 사용합니다. 분류 헤드는 소프트맥스 활성화를 통해 밀집 레이어로 구현됩니다.

Keras 사용 시

위에서 설명한 컨볼루셔널 스택은 다음과 같이 Keras로 작성할 수 있습니다.

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

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

컨볼루셔널 레이어의 패딩 매개변수에는 다음 두 가지 값이 있을 수 있습니다.

• "same": 입력과 동일한 너비/높이 출력을 생성하기 위해 0으로 패딩
• '유효': 패딩이 없습니다. 실제 픽셀만 사용하세요.

6. 맞춤 전환

실습

컨볼루셔널 신경망을 처음부터 빌드하고 학습시켜 보겠습니다. TPU를 사용하면 매우 빠르게 반복할 수 있습니다. 다음 노트북을 열고 셀을 실행 (Shift-ENTER)한 다음 '작업 필요'가 표시되면 안내를 따르세요. 라벨을 지정합니다.

Keras_Flowers_TPU (playground).ipynb

목표는 전이 학습 모델의 75% 정확성을 능가하는 것입니다. 이 모델은 3, 670개의 이미지만 있지만 수백만 개의 이미지 데이터 세트로 사전 학습을 진행했다는 장점이 있습니다. 적어도 맞출 수 있을까요?

추가 정보

레이어는 몇 개이고 얼마나 큰가요?

레이어 크기 선택은 과학이라기보다는 예술에 가깝습니다. 매개변수 (가중치 및 편향)가 너무 적거나 너무 많은 경우 간에 적절한 균형을 찾아야 합니다. 가중치가 너무 적으면 신경망이 꽃 모양의 복잡성을 나타낼 수 없습니다. 이미지가 너무 많으면 학습 이미지에 특화되어 일반화하지 못하는 등 '과적합'되기 쉽습니다. 매개변수가 많으면 모델의 학습 속도가 느려집니다. Keras에서 model.summary() 함수는 모델의 구조와 매개변수 수를 표시합니다.

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

몇 가지 팁:

• 여러 레이어가 있는 것이 '심층'으로 살펴보겠습니다 이 간단한 꽃 인식 문제의 경우 5~10개의 레이어가 적합합니다.
• 작은 필터를 사용합니다. 일반적으로 3x3 필터는 모든 곳에 적합합니다.
• 1x1 필터도 사용할 수 있으며 가격이 저렴합니다. 실제로 '필터링'하지는 않지만 채널의 선형 조합을 계산하지 마세요. 실제 필터로 번갈아 보세요. (다음 섹션에서 '1x1 컨볼루션'에 관해 자세히 알아보세요.)
• 이와 같은 분류 문제의 경우 최대 풀링 레이어 (또는 스트라이드가 1보다 큰 컨볼루션)로 자주 다운샘플링합니다. 꽃이 어디에 있는지는 중요하지 않고 장미나 민들레일 뿐이므로 x와 y 정보를 잃는 것은 중요하지 않으며 작은 영역을 필터링하는 것이 더 저렴합니다.
• 일반적으로 필터의 수는 네트워크 끝에 있는 클래스 수와 비슷합니다 (이유는 아래의 '전역 평균 풀링' 트릭 참조). 수백 개의 클래스로 분류하는 경우 연속 레이어에서 필터 수를 점진적으로 늘립니다. 클래스가 5개인 꽃 데이터 세트의 경우 5개의 필터로만 필터링하는 것만으로는 충분하지 않습니다. 대부분의 레이어에서 동일한 필터 수(예: 32개)를 사용하고 끝으로 갈수록 필터 수를 줄일 수 있습니다.
• 최종 밀집 레이어는 비용이 많이 듭니다. 모든 컨볼루셔널 레이어를 합한 것보다 더 많은 가중치를 가질 수 있습니다. 예를 들어 24x24x10 데이터 포인트의 마지막 데이터 큐브에서 매우 합리적인 출력을 얻더라도 100개의 뉴런 밀집 레이어에는 24x24x10x100=576,000개의 가중치가 필요합니다. 신중을 기하거나 전 세계 평균 풀링을 사용해 보세요 (아래 참조).

전 세계 평균 풀링

컨볼루셔널 신경망 끝에 값비싼 밀집 레이어를 사용하는 대신 수신 데이터 '큐브'를 분할할 수 있습니다. 값의 평균을 내며 소프트맥스 활성화 함수를 통해 값을 입력합니다. 이 방식으로 분류 헤드를 빌드하는 방식에는 가중치가 없습니다. Keras에서 문법은 tf.keras.layers.GlobalAveragePooling2D().입니다.

컨볼루셔널 신경망은 사물의 위치를 감지합니다. 필터는 특정 기능에 강력하게 반응하는 경우 특정 x,y 위치에 반응합니다. 원하는 작업에 따라 신경망은 이 위치 데이터를 사용하거나 삭제하도록 학습시킬 수 있습니다. 전역 평균 풀링을 사용하면 모든 위치 데이터가 명시적으로 삭제됩니다. 꽃 분류기에는 괜찮을 수 있지만, 이미지에서 꽃 수를 세는 것과 같은 다른 작업에는 적합하지 않을 수 있습니다. 주의해서 사용하세요.

해결 방법

다음은 솔루션 노트북입니다. 문제가 있을 때 사용할 수 있습니다.

Keras_Flowers_TPU (solution).ipynb

학습한 내용

• 🤔 컨볼루셔널 레이어 사용
• 🤓 최대 풀링, 보폭, 전 세계 평균 풀링 등으로 실험했습니다.
• 😀 TPU의 실제 모델에 대해 빠르게 반복했습니다.

잠시 시간을 내어 이 체크리스트를 머릿속에 살펴보세요.

7. 축하합니다.

최초의 최신 컨볼루셔널 신경망을 빌드하고 80% 이상의 정확도로 학습시켰으며, TPU 덕분에 단 몇 분 만에 아키텍처를 반복했습니다. 최신 컨볼루셔널 아키텍처에 관해 알아보려면 다음 실습을 계속 진행하세요.

• TPU 속도의 데이터 파이프라인: tf.data.Dataset 및 TFRecords
• 전이 학습을 사용한 첫 번째 Keras 모델
• [이 실험실] Keras와 TPU를 사용한 컨볼루셔널 신경망
• Keras 및 TPU를 사용한 최신 Convnet, Squeezenet, Xception

TPU의 실제 사용 사례

TPU 및 GPU는 Cloud AI Platform에서 사용할 수 있습니다.

• Deep Learning VM에서
• AI Platform Notebooks에서
• AI Platform Training 작업

마지막으로, YouTube는 고객의 의견을 소중하게 생각합니다. 이 실습에서 부족한 부분이 있거나 개선이 필요하다고 생각되는 부분이 있으면 알려 주세요. 의견은 GitHub 문제[의견 링크]를 통해 제공할 수 있습니다.

작성자: 마틴 괴르너 트위터: @martin_gorner

www.tensorflow.org