단계 및 예제를 통한 TensorFlow의 CNN 이미지 분류

컨볼루션 신경망이란 무엇입니까?

컨볼 루션 신경망, convnets 또는 CNN이라고도 알려진, 컴퓨터 비전 애플리케이션에서 잘 알려진 방법입니다. 시각적 이미지를 분석하는 데 사용되는 딥 신경망의 한 종류입니다. 이러한 유형의 아키텍처는 사진이나 비디오에서 객체를 인식하는 데 지배적입니다. 이미지 또는 비디오 인식, 신경 언어 처리 등과 같은 애플리케이션에 사용됩니다.

Archi컨볼루셔널 신경망의 구조

몇 년 전 Facebook을 생각해 보세요. 프로필에 사진을 업로드한 후 사진의 얼굴에 수동으로 이름을 추가하라는 요청을 받았습니다. 요즘 Facebook은 Convnet을 사용하여 사진에 친구를 자동으로 태그합니다.

이미지 분류를 위한 합성 신경망은 이해하기 어렵지 않습니다. 입력 이미지는 합성 단계에서 처리되고 나중에 레이블이 지정됩니다.

일반적인 컨브넷 아키텍처는 아래 그림에 요약되어 있습니다. 우선, 이미지가 네트워크에 푸시됩니다. 이를 입력 이미지라고 합니다. 그런 다음 입력 이미지는 무한한 수의 단계를 거칩니다. 이는 네트워크의 합성곱 부분입니다. 마지막으로 신경망은 이미지의 숫자를 예측할 수 있습니다.

이미지는 높이와 너비를 갖는 픽셀 배열로 구성됩니다. 회색조 이미지에는 채널이 하나만 있는 반면, 컬러 이미지에는 채널이 세 개(빨간색, 녹색, 파란색 각각 하나씩) 있습니다. 채널은 서로 겹쳐져 있습니다. 이 튜토리얼에서는 채널이 하나만 있는 회색조 이미지를 사용합니다. 각 픽셀은 색상의 강도를 반영하기 위해 0에서 255 사이의 값을 갖습니다. 예를 들어, 0에 해당하는 픽셀은 흰색으로 표시되고 값이 255에 가까운 픽셀은 더 어두워집니다.

저장된 이미지를 살펴보겠습니다. MNIST 데이터세트. 아래 그림은 왼쪽의 그림을 행렬 형식으로 표현하는 방법을 보여줍니다. 원래 행렬은 0과 1 사이로 표준화되었습니다. 더 어두운 색상의 경우 행렬의 값은 약 0.9이고 흰색 픽셀의 값은 0입니다.

합성 연산

모델에서 가장 중요한 구성 요소는 컨볼루셔널 레이어입니다. 이 부분은 더 빠른 가중치 계산을 위해 이미지 크기를 줄이고 일반화를 개선하는 것을 목표로 합니다.

컨벌루션 부분 동안 네트워크는 이미지의 필수 특징을 유지하고 관련 없는 노이즈를 제외합니다. 예를 들어 모델은 산을 배경으로 한 사진에서 코끼리를 인식하는 방법을 학습합니다. 기존 신경망을 사용하는 경우 모델은 산의 픽셀을 포함하여 모든 픽셀에 중요하지 않고 네트워크를 오도할 수 있는 가중치를 할당합니다.

대신 케 라스 합성곱 신경망은 수학적 기법을 사용하여 가장 관련성 있는 픽셀만 추출합니다. 이 수학적 연산을 합성곱이라고 합니다. 이 기법을 사용하면 네트워크가 각 계층에서 점점 더 복잡한 기능을 학습할 수 있습니다. 합성곱은 행렬을 작은 조각으로 나누어 각 조각 내의 가장 필수적인 요소를 학습합니다.

컨볼루셔널 신경망(ConvNet 또는 CNN)의 구성 요소

Convnet에는 네 가지 구성 요소가 있습니다.

1. 회선
2. 비선형성(ReLU)
3. Pooling 또는 서브 샘플링
4. 분류(완전 연결 계층)

회선

컨볼루션의 목적은 이미지에서 객체의 특징을 국부적으로 추출하는 것입니다. 이는 네트워크가 그림 내의 특정 패턴을 학습하고 그림의 모든 곳에서 이를 인식할 수 있음을 의미합니다.

합성곱은 요소별 곱셈입니다. 개념은 이해하기 쉽습니다. 컴퓨터는 일반적으로 3×3 차원의 이미지 일부를 스캔하여 필터에 곱합니다. 요소별 곱셈의 출력을 피처 맵이라고 합니다. 이 단계는 모든 이미지가 스캔될 때까지 반복됩니다. 합성곱 후에는 이미지 크기가 줄어든다는 점에 유의하세요.

아래에는 컨볼루션 작동 방식을 실제로 확인할 수 있는 URL이 있습니다.

수많은 채널을 이용할 수 있습니다. 아래에는 일부 채널이 나열되어 있습니다. 각 필터에는 특정 목적이 있음을 알 수 있습니다. 아래 그림을 참고하세요. 커널은 필터와 동의어입니다.

컨볼루션 뒤의 산술

합성 단계는 그림 내의 작은 픽셀 배열에 필터를 적용합니다. 필터는 3×3 또는 5×5의 일반적인 모양으로 입력 이미지를 따라 이동합니다. 즉, 네트워크가 이러한 창을 모든 입력 이미지에 걸쳐 슬라이드하고 합성을 계산합니다. 아래 이미지는 합성이 작동하는 방식을 보여줍니다. 패치의 크기는 3×3이고 출력 행렬은 이미지 행렬과 필터 간의 요소별 연산의 결과입니다.

출력의 너비와 높이는 입력의 너비와 높이와 다를 수 있습니다. 경계 효과 때문에 발생합니다.

테두리 효과

이미지에는 5×5 기능 맵과 3×3 필터가 있습니다. 필터가 3×3 그리드를 차단할 수 있는 창은 중앙에 단 하나뿐입니다. 출력 기능 맵은 3×3 차원과 함께 타일 XNUMX개만큼 축소됩니다.

입력 차원과 동일한 출력 차원을 얻으려면 패딩을 추가해야 합니다. 패딩은 행렬의 각 측면에 올바른 수의 행과 열을 추가하는 것으로 구성됩니다. 그러면 컨볼루션이 모든 입력 타일의 중앙에 맞춰질 수 있습니다. 아래 이미지에서 입력/출력 행렬은 5×5의 동일한 차원을 갖습니다.

네트워크를 정의할 때 컨벌루션된 기능은 세 가지 매개변수로 제어됩니다.

1. 깊이: 컨볼루션 중에 적용할 필터 수를 정의합니다. 이전 예에서 깊이가 1인 것을 보았는데, 이는 필터가 하나만 사용된다는 것을 의미합니다. 대부분의 경우 필터가 두 개 이상 있습니다. 아래 그림은 필터가 세 개 있는 상황에서 수행되는 작업을 보여줍니다.

2. 보폭: 두 슬라이스 사이의 "픽셀 점프" 수를 정의합니다. 스트라이드가 1이면 윈도우는 픽셀의 스프레드 2로 이동합니다. 스트라이드가 XNUMX이면 윈도우는 XNUMX픽셀 점프합니다. 스트라이드를 늘리면 더 작은 피처 맵이 생깁니다.

예제 보폭 1

보폭 2

3. 제로 패딩: 패딩은 입력 피처 맵의 각 측면에 해당하는 수의 행과 열을 추가하는 작업입니다. 이 경우 출력은 입력과 동일한 차원을 갖습니다.

비선형성(ReLU)

합성 연산이 끝나면 출력은 비선형성을 허용하기 위해 활성화 함수의 적용을 받습니다. convnet의 일반적인 활성화 함수는 Relu입니다. 음수 값을 가진 모든 픽셀은 0으로 대체됩니다.

Pooling Opera기

이 단계는 이해하기 쉽습니다. 풀링의 목적은 입력 이미지의 차원을 줄이는 것입니다. 이 단계는 연산의 계산적 복잡성을 줄이기 위해 수행됩니다. 차원을 줄임으로써 네트워크는 계산할 가중치가 낮아지므로 과적합을 방지합니다.

이 단계에서는 크기와 보폭을 정의해야 합니다. 입력 이미지를 풀링하는 표준적인 방법은 피처 맵의 최대값을 사용하는 것입니다. 아래 그림을 살펴보세요. "풀링"은 4×4 피처 맵의 2개 하위 행렬을 스크린하여 최대값을 반환합니다. 풀링은 2×3,1,3,2 배열의 최대값을 가져온 다음 이 창을 3픽셀 이동합니다. 예를 들어, 첫 번째 하위 행렬이 [XNUMX]이면 풀링은 최대값인 XNUMX을 반환합니다.

평균과 같은 또 다른 풀링 연산이 있습니다.

이 작업은 피처 맵의 크기를 적극적으로 줄입니다.

완전히 연결된 레이어

마지막 단계는 전통적인 건물을 짓는 것입니다. 인공 신경망 이전 튜토리얼에서 했던 것처럼. 이전 레이어의 모든 뉴런을 다음 레이어에 연결합니다. 소프트맥스 활성화 함수를 사용하여 입력 이미지의 숫자를 분류합니다.

요약 :

TensorFlow 컨볼루셔널 신경망은 예측을 하기 전에 다양한 레이어를 컴파일합니다. 신경망에는 다음이 포함됩니다.

• 컨볼루셔널 레이어
• Relu 활성화 기능
• Pooling층
• 조밀하게 연결된 레이어

합성곱 계층은 그림의 하위 영역에 다른 필터를 적용합니다. Relu 활성화 함수는 비선형성을 추가하고 풀링 계층은 피처 맵의 차원을 줄입니다.

이 모든 레이어는 이미지에서 필수 정보를 추출합니다. 마지막으로 특징 맵은 예측을 위해 소프트맥스 함수를 사용하여 기본 완전 연결 레이어에 공급됩니다.

TensorFlow로 CNN 훈련하기

이제 컨브넷의 구성 요소에 익숙해졌으므로 다음을 사용하여 컨브넷을 구축할 준비가 되었습니다. TensorFlow. CNN 이미지 분류를 위해 MNIST 데이터세트를 사용하겠습니다.

데이터 준비는 이전 튜토리얼과 동일합니다. 코드를 실행하고 CNN 아키텍처로 바로 이동할 수 있습니다.

CNN을 사용한 이미지 분류를 위해 아래 단계를 따르세요.

1단계: 데이터 세트 업로드

2단계: 입력 레이어

3단계: 컨벌루션 레이어

4 단계 : Pooling층

5단계: 두 번째 컨벌루션 레이어 및 Pooling 레이어

6단계: 조밀층

7단계: 로짓 레이어

1단계: 데이터 세트 업로드

MNIST 데이터 세트는 scikit에서 학습할 수 있습니다. URL. 다운로드하여 다운로드에 저장하세요. fetch_mldata('MNIST 원본')로 업로드할 수 있습니다.

열차/테스트 세트 생성

train_test_split을 사용하여 데이터세트를 분할해야 합니다.

기능 확장

마지막으로 TensorFlow CNN 예제를 사용하여 아래 이미지 분류에 표시된 것처럼 MinMaxScaler로 기능을 확장할 수 있습니다.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

CNN 정의

CNN은 이미지의 원시 픽셀에 필터를 사용하여 기존 신경망의 글로벌 패턴과 비교되는 세부 패턴을 학습합니다. CNN을 구성하려면 다음을 정의해야 합니다.

1. 컨벌루션 레이어: 기능 맵에 n개의 필터를 적용합니다. 컨벌루션 후에는 Relu 활성화 함수를 사용하여 네트워크에 비선형성을 추가해야 합니다.
2. Pooling 레이어: 합성곱 후 다음 단계는 피처 맥스를 다운샘플링하는 것입니다. 목적은 피처 맵의 차원을 줄여 과적합을 방지하고 계산 속도를 개선하는 것입니다. 맥스 풀링은 피처 맵을 하위 영역(일반적으로 2×2 크기)으로 나누고 최대값만 유지하는 기존 기술입니다.
3. 완전 연결 레이어: 이전 레이어의 모든 뉴런은 다음 레이어에 연결됩니다. CNN은 컨볼루션 레이어의 특징에 따라 레이블을 분류하고 풀링 레이어로 축소합니다.

CNN 아키텍처

• 컨벌루션 레이어: ReLU 활성화 기능을 사용하여 14개의 5×5 필터 적용(5×5 픽셀 하위 영역 추출)
• Pooling 레이어: 2×2 필터와 스트라이드 2를 사용하여 최대 풀링을 수행합니다(풀링된 영역이 겹치지 않음을 지정함)
• 컨볼루셔널 레이어: ReLU 활성화 기능과 함께 36개의 5×5 필터 적용
• Pooling 레이어 #2: 다시 2×2 필터와 스트라이드 2를 사용하여 최대 풀링을 수행합니다.
• 1,764개의 뉴런, 드롭아웃 정규화 비율이 0.4(훈련 중에 특정 요소가 삭제될 확률 0.4)
• 밀도 계층(로지트 계층): 10개의 뉴런, 각 숫자 대상 클래스(0-9)에 대해 하나씩.

CNN을 생성하는 데 사용할 세 가지 중요한 모듈이 있습니다.

• 전환2d(). 필터 수, 필터 커널 크기, 패딩 및 활성화 함수를 인수로 사용하여 XNUMX차원 컨볼루셔널 레이어를 구성합니다.
• max_pooling2d(). 최대 풀링 알고리즘을 사용하여 XNUMX차원 풀링 계층을 구성합니다.
• 밀집한(). 은닉층과 단위로 조밀한 층을 구성합니다.

CNN을 구축하기 위한 함수를 정의합니다. 함수에서 모든 것을 함께 래핑하기 전에 각 빌딩 블록을 구성하는 방법을 자세히 살펴보겠습니다.

2단계: 입력 레이어

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

데이터의 모양에 따라 텐서를 정의해야 합니다. 이를 위해 tf.reshape 모듈을 사용할 수 있습니다. 이 모듈에서는 형태를 변경할 텐서와 텐서의 형태를 선언해야 합니다. 첫 번째 인수는 함수의 인수에 정의된 데이터의 기능입니다.

그림에는 높이, 너비 및 채널이 있습니다. MNIST 데이터세트는 28×28 크기의 단색 그림입니다. 형상 인수에서 배치 크기를 -1로 설정하여 형상[“x”]의 형상을 취합니다. 장점은 배치 크기 하이퍼파라미터를 조정하도록 만드는 것입니다. 배치 크기가 7로 설정된 경우 텐서는 5,488개의 값(28*28*7)을 제공합니다.

3단계: 컨벌루션 레이어

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

첫 번째 컨벌루션 레이어에는 동일한 패딩을 사용하는 커널 크기 14×5의 필터 5개가 있습니다. 동일한 패딩은 출력 텐서와 입력 텐서의 높이와 너비가 동일해야 함을 의미합니다. Tensorflow는 동일한 크기를 보장하기 위해 행과 열에 XNUMX을 추가합니다.

Relu 활성화 기능을 사용합니다. 출력 크기는 [28, 28, 14]입니다.

4 단계 : Pooling층

합성곱 후의 다음 단계는 풀링 계산입니다. 풀링 계산은 데이터의 차원을 줄입니다. 2×2 크기와 스트라이드 2로 max_pooling2d 모듈을 사용할 수 있습니다. 이전 레이어를 입력으로 사용합니다. 출력 크기는 [batch_size, 14, 14, 14]가 됩니다.

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

5단계: 두 번째 컨벌루션 레이어 및 Pooling 레이어

두 번째 합성곱 계층에는 32개의 필터가 있으며 출력 크기는 [batch_size, 14, 14, 32]입니다. 풀링 계층은 이전과 동일한 크기를 갖고 출력 모양은 [batch_size, 14, 14, 18]입니다.

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

6단계: 조밀층

그런 다음 완전 연결 계층을 정의해야 합니다. 피처 맵은 밀집 레이어와 연결되기 전에 평면화되어야 합니다. 7*7*36 크기의 모듈 reshape를 사용할 수 있습니다.

밀집층은 1764개의 뉴런을 연결합니다. Relu 활성화 함수를 추가합니다. 게다가 비율이 0.3인 드롭아웃 정규화 항을 추가합니다. 즉, 가중치의 30%가 0으로 설정됩니다. 드롭아웃은 훈련 단계에서만 발생한다는 점에 유의하세요. cnn_model_fn 함수에는 아래 CNN 이미지 분류 TensorFlow 예에 표시된 것처럼 모델을 훈련해야 하는지 또는 평가해야 하는지 선언하는 인수 모드가 있습니다.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

7단계: 로짓 레이어

마지막으로 TensorFlow 이미지 분류 예시에서는 모델 예측으로 마지막 레이어를 정의할 수 있습니다. 출력 형태는 배치 크기와 같고 총 이미지 수인 10입니다.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

클래스와 각 클래스의 확률을 포함하는 사전을 만들 수 있습니다. tf.argmax() 모듈은 로짓 레이어인 경우 가장 높은 값을 반환합니다. 소프트맥스 함수는 각 클래스의 확률을 반환합니다.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

모드가 예측으로 설정된 경우에만 사전 예측을 반환하려고 합니다. 예측을 표시하려면 이 코드를 추가하세요.

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

다음 단계는 모델의 손실을 계산하는 것입니다. 마지막 튜토리얼에서 다중 클래스 모델의 손실 함수가 교차 엔트로피라는 것을 배웠습니다. 손실은 다음 코드로 쉽게 계산할 수 있습니다.

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

TensorFlow CNN 예제의 마지막 단계는 모델을 최적화하는 것, 즉 가장 좋은 가중치 값을 찾는 것입니다. 이를 위해 학습률이 0.001인 Gradient descent 최적화 프로그램을 사용합니다. 손실을 최소화하는 것이 목표

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

CNN은 끝났습니다. 그러나 평가 모드 중에 성능 지표를 표시하려고 합니다. 다중클래스 모델의 성능 지표는 정확도 지표입니다. Tensorflow에는 레이블과 예측 값이라는 두 가지 인수가 포함된 정확도 모듈이 탑재되어 있습니다.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

그게 다야. 첫 번째 CNN을 만들었고 모델을 훈련하고 평가하는 데 사용하기 위해 모든 것을 함수로 래핑할 준비가 되었습니다.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

아래 단계는 이전 튜토리얼과 동일합니다.

먼저, 이미지 분류를 위해 CNN 모델을 사용하여 추정기를 정의합니다.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

CNN은 훈련하는 데 많은 시간이 걸리므로 50회 반복마다 소프트맥스 레이어의 값을 저장하는 로깅 후크를 생성합니다.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

모델을 추정할 준비가 되었습니다. 배치 크기를 100으로 설정하고 데이터를 섞습니다. 훈련 단계를 16.000으로 설정했기 때문에 훈련하는 데 많은 시간이 걸릴 수 있습니다. 인내심을 가지십시오.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

이제 모델이 학습되었으므로 모델을 평가하고 결과를 인쇄할 수 있습니다.

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

현재 아키텍처를 사용하면 정확도가 97%입니다. 아키텍처, 배치 크기 및 반복 횟수를 변경하여 정확도를 개선할 수 있습니다. CNN 신경망은 ANN 또는 로지스틱 회귀보다 훨씬 더 나은 성능을 보였습니다. 인공 신경망 튜토리얼에서 정확도가 96%였는데, 이는 CNN보다 낮습니다. CNN의 성능은 더 큰 이미지에서 인상적입니다. 세트, 속도 계산과 정확도 측면에서 모두 그렇습니다.

제품 개요

합성 신경망은 사진을 평가하는 데 매우 효과적입니다. 이러한 유형의 아키텍처는 사진이나 비디오에서 객체를 인식하는 데 지배적입니다.

TensorFlow CNN을 구축하려면 다음 XNUMX단계를 따라야 합니다.

1단계: 데이터세트 업로드:

MNIST 데이터 세트는 scikit과 함께 학습할 수 있습니다. 다운로드하여 다운로드에 저장하세요. fetch_mldata('MNIST 원본')로 업로드할 수 있습니다.

2단계: 입력 레이어:

이 단계는 데이터를 재구성합니다. 모양은 픽셀 수의 제곱근과 같습니다. 예를 들어, 그림에 156개의 픽셀이 있는 경우 모양은 26×26입니다. 그림에 색상이 있는지 여부를 지정해야 합니다. 그렇다면 모양에 3이 있습니다. RGB의 경우 3, 그렇지 않은 경우 1입니다.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

3단계: 컨벌루션 레이어

다음으로 컨볼루셔널 레이어를 생성해야 합니다. 네트워크가 중요한 기능을 학습할 수 있도록 다양한 필터를 적용합니다. 커널 크기와 필터 양을 지정합니다.

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

4단계: Pooling층

세 번째 단계에서는 풀링 레이어를 추가합니다. 이 레이어는 입력 크기를 줄입니다. 이는 하위 행렬의 최대값을 취함으로써 가능합니다. 예를 들어, 하위 행렬이 [3,1,3,2]인 경우 풀링은 최대값인 3을 반환합니다.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

5단계: 컨볼루셔널 레이어를 추가하고 Pooling 레이어

이 단계에서는 원하는 만큼 conv 레이어와 풀링 레이어를 추가할 수 있습니다. Google은 20개 이상의 conv 레이어가 있는 아키텍처를 사용합니다.

6단계: 치밀한 층

6단계에서는 이전 레이어를 평면화하여 완전히 연결된 레이어를 만듭니다. 이 단계에서는 다양한 활성화 기능을 사용하고 드롭아웃 효과를 추가할 수 있습니다.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

7단계: 로짓 레이어

마지막 단계는 예측이다.

logits = tf.layers.dense(inputs=dropout, units=10)