Building Input Functions with tf.estimator

이 튜토리얼에서는 tf.estimator에서 입력 함수를 만드는 방법을 소개합니다. input_fn을 사전 처리하고 모델에 데이터를 입력하는 방법을 개략적으로 살펴 보겠습니다. 그런 다음 median house 값을 예측하기 위해 신경망 회귀 분석기에 교육, 평가 및 예측 데이터를 제공하는 input_fn을 구현합니다.


input_fn이있는 사용자 입력 파이프 라인 input_fn은 피쳐 및 타겟 데이터를 트레인에 전달하고 평가자의 방법을 예측 및 예측하는 데 사용됩니다. 사용자는 input_fn 내부에서 기능 엔지니어링 또는 사전 처리를 수행 할 수 있습니다. 다음은 tf.estimator 빠른 시작 자습서에서 가져온 예제입니다.
import numpy as np

training_set
= tf.contrib.learn.datasets.base.load_csv_with_header(
    filename
=IRIS_TRAINING, target_dtype=np.int, features_dtype=np.float32)

train_input_fn
= tf.estimator.inputs.numpy_input_fn(
    x
={"x": np.array(training_set.data)},
    y
=np.array(training_set.target),
    num_epochs
=None,
    shuffle
=True)

classifier
.train(input_fn=train_input_fn, steps=2000)


input_fn의 해부 다음 코드는 입력 함수의 기본 골격을 보여줍니다.

def my_input_fn():

   
# Preprocess your data here...

   
# ...then return 1) a mapping of feature columns to Tensors with
   
# the corresponding feature data, and 2) a Tensor containing labels
   
return feature_cols, labels

입력 함수의 본문에는 잘못된 예제를 스크러빙하거나 피쳐 스케일링과 같이 입력 데이터를 사전 처리하는 특정 논리가 포함되어 있습니다.


입력 함수는 위의 코드 스켈레톤에서와 같이 모델에 공급할 최종 피처 및 레이블 데이터가 포함 된 다음 두 값을 반환해야합니다.


feature_cols

피쳐 열 이름을 해당 피처 데이터가 들어있는 Tensors (또는 SparseTensors)에 매핑하는 키 / 값 쌍을 포함하는 사전입니다.

labels

라벨 (목표) 값을 포함하는 Tensor : 모델이 예측하고자하는 값.

피쳐 데이터를 텐서 (tensors)로 변환


feature / label 데이터가 python 배열이거나 pandas 데이터 프레임 또는 numpy 배열에 저장되어있는 경우 다음 메소드를 사용하여 input_fn을 생성 할 수 있습니다.

import numpy as np
# numpy input_fn.
my_input_fn
= tf.estimator.inputs.numpy_input_fn(
    x
={"x": np.array(x_data)},
    y
=np.array(y_data),
   
...)
import pandas as pd
# pandas input_fn.
my_input_fn
= tf.estimator.inputs.pandas_input_fn(
    x
=pd.DataFrame({"x": x_data}),
    y
=pd.Series(y_data),
   
...)

스파스 데이터(대부분의 값이 0인 데이터)의 경우, 세개의 인수로 인스턴스화된 SparseTensor를 채우는 대신 SparseTensor를 채웁니다.

dense_shape

텐서의 모양. 각 차원의 요소 수를 나타내는 목록을 가져옵니다. 예를 들어 dense_shape = [3,6]은 2 차원 3x6 텐서를 지정하고 dense_shape = [2,3,4]는 3 차원 2x3x4 텐서를 지정하고 dense_shape = [9]는 9 개 요소가있는 1 차원 텐서를 지정합니다. .

indices

0이 아닌 값을 포함하는 텐서 요소의 인덱스입니다. 용어 목록을 취합니다. 여기서 각 용어는 자체가 0이 아닌 요소의 색인을 포함하는 목록입니다. 요소는 0으로 인덱싱됩니다. 즉, [0,0]은 2 차원 텐서에서 첫 번째 행의 첫 번째 열에있는 요소의 인덱스 값입니다. 예 : indices = [[1,3], [ 2,4]]는 [1,3]과 [2,4]의 인덱스가 0이 아닌 값을 갖도록 지정합니다.

values

1 차원 값의 텐서. 값의 항 i은 인덱스의 항 i에 해당하며 해당 값을 지정합니다. 예를 들어, 주어진 indices = [[1,3], [2,4]]에서, 매개 변수 값 = [18, 3.6]은 텐서의 원소 [1,3]가 18의 값을 갖고, [2 , 4]의 값은 3.6입니다.

다음 코드는 3 행 5 열의 2 차원 SparseTensor를 정의합니다. 인덱스가 [0,1] 인 요소의 값은 6이고 인덱스 [2,4]가있는 요소의 값은 0.5입니다 (다른 모든 값은 0입니다).

sparse_tensor = tf.SparseTensor(indices=[[0,1], [2,4]],
                                values
=[6, 0.5],
                                dense_shape
=[3, 5])

이것은 다음과 같은 밀도가 높은 텐서에 해당합니다.

[[0, 6, 0, 0, 0]
 
[0, 0, 0, 0, 0]
 
[0, 0, 0, 0, 0.5]]

SparseTensor에 대한 자세한 내용은 tf.SparseTensor를 참조하십시오.


모델에 input_fn 데이터 전달


훈련을 위해 모델에 데이터를 공급하려면 입력 작업 기능에 입력 기능을 input_fn 매개 변수의 값으로 전달하기 만하면됩니다.

classifier.train(input_fn=my_input_fn, steps=2000)

input_fn 매개 변수는 함수 호출 (input_fn = my_input_fn ())의 반환 값이 아닌 함수 객체 (예 : input_fn = my_input_fn)를 수신해야합니다. 즉, 기차 코드에서 input_fn에 매개 변수를 전달하려고하면 다음 코드와 같이 TypeError가 발생합니다.

classifier.train(input_fn=my_input_fn(training_set), steps=2000)

그러나 입력 함수를 매개 변수화 할 수 있기를 원하면 다른 방법이 있습니다. 인수를 취하지 않고 input_fn과 같은 래퍼 함수를 ​​사용하여 원하는 매개 변수로 입력 함수를 호출 할 수 있습니다. 예제소스:

def my_input_fn(data_set):
 
...

def my_input_fn_training_set():
 
return my_input_fn(training_set)

classifier
.train(input_fn=my_input_fn_training_set, steps=2000)

또는 파이썬의 functools.partial 함수를 사용하여 모든 매개 변수 값이 고정 된 새 함수 객체를 생성 할 수 있습니다.

classifier.train(
    input_fn
=functools.partial(my_input_fn, data_set=training_set),
    steps
=2000)

세 번째 옵션은 input_fn 호출을 람다에 랩핑하여 input_fn 매개 변수에 전달하는 것입니다.

classifier.train(input_fn=lambda: my_input_fn(training_set), steps=2000)

위에 표시된 입력 파이프 라인을 설계하여 데이터 세트에 대한 매개 변수를 허용하는 한 가지 큰 장점은 데이터 세트 인수 만 변경하여 동일한 input_fn을 전달하여 연산을 평가하고 예측할 수 있다는 것입니다 (예 :

classifier.evaluate(input_fn=lambda: my_input_fn(test_set), steps=2000)

이 접근법은 코드 유지 보수성을 향상시킵니다. 각 유형의 작업에 대해 여러 input_fn (예 : input_fn_train, input_fn_test, input_fn_predict)을 정의 할 필요가 없습니다.


마지막으로, tf.estimator.inputs의 메소드를 사용하여 numpy 또는 pandas 데이터 세트에서 input_fn을 작성할 수 있습니다. 추가적인 이점은 num_epochs 및 shuffle과 같은 인수를 사용하여 input_fn이 데이터를 반복하는 방식을 제어 할 수 있다는 것입니다.

import pandas as pd

def get_input_fn_from_pandas(data_set, num_epochs=None, shuffle=True):
 
return tf.estimator.inputs.pandas_input_fn(
      x
=pdDataFrame(...),
      y
=pd.Series(...),
      num_epochs
=num_epochs,
      shuffle
=shuffle)
import numpy as np

def get_input_fn_from_numpy(data_set, num_epochs=None, shuffle=True):
 
return tf.estimator.inputs.numpy_input_fn(
      x
={...},
      y
=np.array(...),
      num_epochs
=num_epochs,
      shuffle
=shuffle)

보스턴 하우스 가치를위한 신경망 모델


이 튜토리얼의 나머지 부분에서는 UCI 주택 데이터 세트에서 가져온 Boston 주택 데이터의 하위 집합을 사전 처리하기위한 입력 함수를 작성하고 중앙 집 값을 예측하기 위해 신경 네트워크 회귀 분석기로 데이터를 공급하는 데이 함수를 사용합니다.


신경망을 훈련하는 데 사용할 보스턴 CSV 데이터 세트(Boston CSV data sets)는 Boston 교외 지역에 대한 다음과 같은 기능 데이터를 포함합니다.

FeatureDescription
CRIMCrime rate per capita / 1 인당 범죄율
ZNFraction of residential land zoned to permit 25,000+ sq ft lots /
 25,000+ 평방 피트를 허용하도록 구역화 된 주거용 토지의 분수
INDUSFraction of land that is non-retail business / 비 소매업 부문 토지의 비율
NOXConcentration of nitric oxides in parts per 10 million / 질소 산화물의 농도를 천만 배럴로
RMAverage Rooms per dwelling / 주거 당 RM 평균 객실
AGEFraction of owner-occupied residences built before 1940 / 1940 년 이전에 건축 된 주거지의 일부
DISDistance to Boston-area employment centers / 보스턴 지역 고용 센터까지의 거리
TAXProperty tax rate per $10,000 / 10,000 달러 당 세율
PTRATIOStudent-teacher ratio / 교사 비율

그리고 모델에서 예측할 수있는 레이블은 수천 달러의 소유자가 거주하는 주택의 중간 값 인 MEDV입니다.


설정


boston_train.csv, boston_test.csv 및 boston_predict.csv 데이터 세트를 다운로드하십시오.( boston_train.csvboston_test.csv, and boston_predict.csv.)


다음 섹션에서는 입력 함수를 작성하고 이러한 데이터 세트를 신경망 회귀 분석기에 공급하고 모델을 학습 및 평가하며 주택 가치 예측을 수행하는 방법을 단계별로 설명합니다. 완전한 최종 코드가 여기(available here)에 있습니다.


주택 데이터 가져 오기


시작하려면 가져 오기 (팬더 ​​및 텐서 흐름 포함)를 설정하고 자세한 로그 출력을 위해 자세한 정보 표시를 INFO로 설정하십시오.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import itertools

import pandas as pd
import tensorflow as tf

tf
.logging.set_verbosity(tf.logging.INFO)

COLUMNS에있는 데이터 세트의 열 이름을 정의하십시오. 레이블과 기능을 구별하려면 FEATURES 및 LABEL도 정의하십시오. 그런 다음 3 개의 CSV (tf.train, tf.test 및 예측)를 판다 데이터 프레임으로 읽습니다.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
           
"dis", "tax", "ptratio", "medv"]
FEATURES
= ["crim", "zn", "indus", "nox", "rm",
           
"age", "dis", "tax", "ptratio"]
LABEL
= "medv"

training_set
= pd.read_csv("boston_train.csv", skipinitialspace=True,
                           skiprows
=1, names=COLUMNS)
test_set
= pd.read_csv("boston_test.csv", skipinitialspace=True,
                       skiprows
=1, names=COLUMNS)
prediction_set
= pd.read_csv("boston_predict.csv", skipinitialspace=True,
                             skiprows
=1, names=COLUMNS)


FeatureColumns 정의 및 회귀 변수 만들기


그런 다음 입력 데이터에 대한 FeatureColumns 목록을 작성하십시오.이 목록은 공식적으로 교육에 사용할 피처 세트를 지정합니다. 주택 데이터 세트의 모든 피쳐에는 연속 값이 포함되어 있으므로 tf.contrib.layers.real_valued_column () 함수를 사용하여 FeatureColumns를 작성할 수 있습니다.

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]


참고 : 기능 열에 대한 자세한 내용은이 소개를 참조하고 범주 데이터에 대한 FeatureColumns 정의 방법을 보여주는 예제는 선형 모델 자습서를 참조하십시오.


이제 신경망 회귀 모델에 대한 DNNRegressor를 인스턴스화합니다. hidden_units, 각 숨겨진 레이어의 노드 수를 지정하는 하이퍼 매개 변수 (여기서 10 개의 노드가있는 두 개의 숨겨진 레이어) 및 방금 정의한 FeatureColumns 목록이 포함 된 feature_columns를 두 가지 인수로 제공해야합니다.

regressor = tf.estimator.DNNRegressor(feature_columns=feature_cols,
                                      hidden_units
=[10, 10],
                                      model_dir
="/tmp/boston_model")

input_fn 빌드하기


회귀 변수에 입력 데이터를 전달하려면 pandas Dataframe을 허용하고 input_fn을 반환하는 팩터 리 메서드를 작성합니다.

def get_input_fn(data_set, num_epochs=None, shuffle=True):
 
return tf.estimator.inputs.pandas_input_fn(
      x
=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
      y
= pd.Series(data_set[LABEL].values),
      num_epochs
=num_epochs,
      shuffle
=shuffle)

입력 데이터는 data_set 인수에서 input_fn으로 전달됩니다. 즉, 함수는 training_set, test_set 및 prediction_set과 같이 가져온 DataFrames를 처리 할 수 ​​있습니다.


두 개의 추가 인수가 제공됩니다. num_epochs : 데이터를 반복 할 에포크 수를 제어합니다. 교육의 경우이 값을 없음으로 설정하면

input_fn은 필요한 수의 열차 단계에 도달 할 때까지 데이터를 반환합니다. 평가하고 예측하려면 1로 설정하면 input_fn이 데이터를 한 번 반복 한 다음 OutOfRangeError를 발생시킵니다. 이 오류는 평가자가 평가 또는 예측을 중지하도록 신호를 보냅니다. shuffle : 데이터 셔플 여부. 평가하고 예측하기 위해 이것을 false로 설정하면 input_fn이 데이터를 순차적으로 반복합니다. 열차의 경우이 값을 True로 설정하십시오.


회귀 자 훈련


뉴럴 네트워크 회귀 분석기를 훈련 시키려면 다음과 같이 input_fn에 전달 된 training_set을 사용하여 train을 실행하십시오.

regressor.train(input_fn=get_input_fn(training_set), steps=5000)

You should see log output similar to the following, which reports training loss for every 100 steps:

INFO:tensorflow:Step 1: loss = 483.179
INFO
:tensorflow:Step 101: loss = 81.2072
INFO
:tensorflow:Step 201: loss = 72.4354
...
INFO
:tensorflow:Step 1801: loss = 33.4454
INFO
:tensorflow:Step 1901: loss = 32.3397
INFO
:tensorflow:Step 2001: loss = 32.0053
INFO
:tensorflow:Step 4801: loss = 27.2791
INFO
:tensorflow:Step 4901: loss = 27.2251
INFO
:tensorflow:Saving checkpoints for 5000 into /tmp/boston_model/model.ckpt.
INFO
:tensorflow:Loss for final step: 27.1674.

모델 평가


다음으로, 훈련 된 모델이 테스트 데이터 세트에 대해 어떻게 수행되는지보십시오. evaluate을 실행하고, 이번에는 test_set을 input_fn으로 전달합니다.

ev = regressor.evaluate(
    input_fn
=get_input_fn(test_set, num_epochs=1, shuffle=False))

결과를 가져온 결과에서 손실을 검색하고 출력을 출력합니다.

loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))

결과는 다음과 유사해야합니다.

INFO:tensorflow:Eval steps [0,1) for training step 5000.
INFO
:tensorflow:Saving evaluation summary for 5000 step: loss = 11.9221
Loss: 11.922098

예측하기

마지막으로이 모델을 사용하여 feature_data를 포함하고 있지만 6 개의 예제에 대한 레이블이없는 prediction_set의 집값 중앙값을 예측할 수 있습니다.

y = regressor.predict(
    input_fn
=get_input_fn(prediction_set, num_epochs=1, shuffle=False))
# .predict() returns an iterator of dicts; convert to a list and print
# predictions
predictions
= list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

결과에는 6 가지 주택 가치 예측치가 수천 달러로 포함되어야합니다. 예 :

Predictions: [ 33.30348587  17.04452896  22.56370163  34.74345398  14.55953979
 
19.58005714]


Deep MNIST for Experts (전문가를위한 딥 MNIST)

TensorFlow는 대규모 수치 계산을 수행하는 강력한 라이브러리입니다. 탁월한 과제 중 하나는 심 신경 네트워크를 구현하고 교육하는 것입니다. 이 튜토리얼에서 우리는 TensorFlow 모델의 기본 빌딩 블록을 배우면서 깊은 컨볼 루션 MNIST 분류자를 생성합니다.

이 소개는 신경망과 MNIST 데이터 세트에 익숙하다고 가정합니다. 그들과 배경이 없다면, 초보자를위한 소개를 확인하십시오. 시작하기 전에 반드시 TensorFlow를 설치하십시오.


About this tutorial


이 튜토리얼의 첫 번째 부분에서는 Tensorflow 모델의 기본 구현 인  mnist_softmax.py코드에서 어떤 일이 일어나는지 설명합니다. 두 번째 부분에서는 정확성을 높이는 몇 가지 방법을 보여줍니다.


이 튜토리얼의 각 코드 스 니펫을 복사하여 Python 환경에 붙여 넣거나, 완전히 구현 된 깊은 네트를 mnist_deep.py 에서 다운로드 할 수 있습니다.


이 튜토리얼에서 우리가 달성 할 수있는 것 :

-이미지의 모든 픽셀을 관찰하여 MNIST 숫자를 인식하는 모델 인 softmax 회귀 함수를 만듭니다.

-Tensorflow를 사용하여 수천 가지 사례를 "조사"하여 숫자를 인식하도록 모델을 교육합니다 (첫 번째 Tensorflow 세션을 실행하여 수행)

-테스트 데이터로 모델의 정확성을 확인하십시오.

-결과를 향상시키기 위해 다중 컨볼 루션 신경망을 구축, 훈련 및 테스트합니다.


Setup

모델을 만들기 전에 먼저 MNIST 데이터 세트를로드하고 TensorFlow 세션을 시작합니다.

MNIST 데이터로드

이 자습서의 코드를 복사하여 붙여 넣는 경우 다음 두 줄의 코드를 사용하여 데이터를 자동으로 다운로드하고 읽습니다.
from tensorflow.examples.tutorials.mnist import input_data
mnist
= input_data.read_data_sets('MNIST_data', one_hot=True)
여기서 mnist는 훈련, 검증 및 테스트 세트를 NumPy 배열로 저장하는 간단한 클래스입니다. 또한 아래에 사용할 데이터 minibatches를 반복하는 함수를 제공합니다.

TensorFlow InteractiveSession 시작

TensorFlow는 매우 효율적인 C ++ 백엔드를 사용하여 계산을 수행합니다. 이 백엔드에 대한 연결을 세션이라고합니다. TensorFlow 프로그램의 일반적인 사용법은 먼저 그래프를 만든 다음 세션에서 시작하는 것입니다.
여기서 우리는 편리한 InteractiveSession 클래스를 대신 사용합니다. TensorFlow는 코드 구조화 방법을보다 융통성있게 만듭니다. 그래프를 실행하는 계산 그래프를 작성하는 조작을 인터리브 할 수 있습니다. 이것은 IPython과 같은 대화식 환경에서 작업 할 때 특히 편리합니다. InteractiveSession을 사용하지 않는 경우, 세션을 시작하고 그래프를 시작하기 전에 전체 계산 그래프를 작성해야합니다.
import tensorflow as tf
sess
= tf.InteractiveSession()
계산 그래프

파이썬에서 효율적인 수치 계산을 수행하기 위해 일반적으로 다른 언어로 구현 된 매우 효율적인 코드를 사용하여 파이썬 외부의 행렬 곱셈과 같은 값 비싼 연산을 수행하는 NumPy와 같은 라이브러리를 사용합니다. 불행하게도, 모든 작업을 파이썬으로 다시 전환하면 많은 오버 헤드가 발생할 수 있습니다. 이 오버 헤드는 GPU에서 계산을 실행하거나 데이터를 전송하는 데 비용이 많이 드는 분산 된 방식으로 실행하려는 경우 특히 나쁩니다.

TensorFlow는 파이썬 밖에서도 힘든 작업을 수행하지만이 오버 헤드를 피하기 위해 한 걸음 더 나아갑니다. TensorFlow는 Python과 독립적으로 고가의 단일 연산을 실행하는 대신 Python 외부에서 실행되는 상호 작용하는 연산의 그래프를 설명합니다. 이 방법은 Theano 또는 Torch에서 사용되는 방법과 유사합니다.

따라서 파이썬 코드의 역할은이 외부 계산 그래프를 작성하고 계산 그래프의 어느 부분을 실행해야하는지 지시하는 것입니다. 자세한 내용은 TensorFlow 시작하기의 계산 그래프 섹션을 참조하십시오.

Softmax 회귀 모델 구축

이 섹션에서는 단일 선형 레이어가있는 softmax 회귀 모델을 작성합니다. 다음 섹션에서 우리는 이것을 다중 계층 콘볼 루션 네트워크가있는 softmax 회귀의 경우까지 확장 할 것입니다.

Placeholders
우리는 입력 이미지와 대상 출력 클래스에 대한 노드를 생성하여 계산 그래프를 작성하기 시작합니다.
+ 초급자 버전 및 기본 mnist 튜토리얼과 같은 방법으로 선언이 됩니다.
x = tf.placeholder(tf.float32, shape=[None, 784])
y_
= tf.placeholder(tf.float32, shape=[None, 10])
여기서 x와 y는 특정 값이 아닙니다. 오히려 각각은 자리 표시 자입니다. TensorFlow에 계산을 실행하도록 요청할 때 입력 할 값입니다.

입력 이미지 x는 2 차원 텐서 부동 소수점 수로 구성됩니다. 여기서 우리는 [없음, 784]의 모양을 할당합니다. 여기서 784는 단일 평평한 28x28 픽셀 MNIST 이미지의 차원이며, 없음은 배치 크기에 해당하는 첫 번째 차원이 모든 크기 일 수 있음을 나타냅니다. 목표 출력 클래스 y_는 또한 2d 텐서로 구성되며, 각 행은 해당 MNIST 이미지가 속하는 디지트 클래스 (0에서 9까지)를 나타내는 1 핫 10 차원 벡터입니다.

자리 표시 자에 대한 shape 인수는 선택 사항이지만 TensorFlow가 일치하지 않는 텐서 모양에서 발생하는 버그를 자동으로 잡을 수 있습니다.

Variables

이제 우리 모델에 대한 가중치 W와 편향치 b를 정의합니다. 우리는 이들을 추가 입력과 같이 취급한다고 상상할 수도 있지만 TensorFlow는이를 처리하는 더 좋은 방법을 가지고 있습니다 : 가변. 변수는 TensorFlow의 계산 그래프에있는 값입니다. 그것은 계산에 의해 사용되거나 심지어 수정 될 수 있습니다. 기계 학습 응용 프로그램에서 일반적으로 모델 매개 변수는 변수입니다.
W = tf.Variable(tf.zeros([784,10]))
b
= tf.Variable(tf.zeros([10]))
tf.Variable에 대한 호출에서 각 매개 변수의 초기 값을 전달합니다. 이 경우 W와 b를 0으로 채워진 텐서로 초기화합니다. W는 784x10 행렬 (784 개의 입력 피처와 10 개의 출력이 있기 때문에)이고 b는 10 개의 클래스가 있으므로 10 차원 벡터입니다.

변수는 세션 내에서 사용되기 전에 해당 세션을 사용하여 초기화되어야합니다. 이 단계는 이미 지정된 초기 값 (이 경우에는 0으로 가득 찬 텐서)을 취하여 각 변수에 할당합니다. 이 작업은 모든 변수에 대해 동시에 수행 할 수 있습니다.
sess.run(tf.global_variables_initializer())

Predicted Class and Loss Function

이제 회귀 모델을 구현할 수 있습니다. 한 줄만 필요합니다! 벡터화 된 입력 이미지 x에 가중치 행렬 W를 곱하고 바이어스 b를 더합니다.

y = tf.matmul(x,W) + b
손실 기능을 쉽게 지정할 수 있습니다. 손실은 단일 예에서 모델의 예측이 얼마나 나쁜지를 나타냅니다. 우리는 모든 예제를 통해 교육하면서이를 최소화하려고 노력합니다. 여기서 우리의 손실 함수는 목표와 모델의 예측에 적용되는 softmax 활성화 함수 간의 교차 엔트로피입니다. 초보자 가이드 에서처럼 안정된 공식을 사용합니다.
cross_entropy = tf.reduce_mean(
    tf
.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
tf.nn.softmax_cross_entropy_with_logits는 모델의 비표준 모델 예측에 softmax를 내부적으로 적용하고 모든 클래스에서 합계를 계산하며, tf.reduce_mean은 이러한 합계에 대한 평균을 취합니다.

Train the Model

이제 모델 및 교육 손실 기능을 정의 했으므로 TensorFlow를 사용하여 교육하는 것이 간단합니다. TensorFlow는 전체 계산 그래프를 알고 있으므로 자동 차별화를 사용하여 각 변수에 대한 손실 그라디언트를 찾을 수 있습니다. TensorFlow에는 다양한 내장 최적화 알고리즘이 있습니다. 이 예에서는 교차 엔트로피를 내리기 위해 steepest gradient descent를 단계 길이 0.5로 사용합니다.
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
TensorFlow가 실제로 한 줄에서 계산 한 것은 새로운 연산을 계산 그래프에 추가하는 것이 었습니다. 이러한 작업에는 그라디언트를 계산하고, 매개 변수 업데이트 단계를 계산하고, 매개 변수에 업데이트 단계를 적용하는 작업이 포함되었습니다.

반환 된 작업 train_step을 실행하면 그라데이션 강하 업데이트가 매개 변수에 적용됩니다. 따라서 train_step을 반복적으로 실행하여 모델 교육을 수행 할 수 있습니다.
for _ in range(1000):
  batch
= mnist.train.next_batch(100)
  train_step
.run(feed_dict={x: batch[0], y_: batch[1]})
각 교육 반복마다 100 개의 교육 사례를로드합니다. 그런 다음 feed_dict를 사용하여 place_holder x 및 y_를 학습 예제로 대체하여 train_step 연산을 실행합니다. feed_dict를 사용하여 계산 그래프에서 임의의 텐서를 대체 할 수 있습니다. 단지 자리 표시 자에만 국한되지 않습니다.

Evaluate the Model (모델 평가)

우리 모델은 얼마나 잘 했습니까?

먼저 정확한 라벨 위치를 예측할 것입니다. tf.argmax는 어떤 축을 따라 텐서에서 가장 높은 엔트리의 인덱스를 제공하는 매우 유용한 함수입니다. 예를 들어, tf.argmax (y, 1)는 우리 모델이 각 입력에 대해 가장 가능성이 있다고 생각하는 레이블이고 tf.argmax (y_, 1)는 실제 레이블입니다. tf.equal을 사용하여 예측이 진실과 일치하는지 확인할 수 있습니다.
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
그건 우리에게 불공정 목록을 제공합니다. 어떤 부분이 올바른지 결정하기 위해 부동 소수점 수로 캐스팅 한 다음 평균을 취합니다. 예를 들어, [True, False, True, True]는 [1,0,1,1]이되어 0.75가됩니다.
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
마지막으로 테스트 데이터의 정확성을 평가할 수 있습니다. 이것은 약 92 % 정확해야합니다.
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

Build a Multilayer Convolutional Network

멀티 레이어 컨볼 루션 네트워크 구축


MNIST에서 92 % 정확도를 얻는 것은 좋지 않습니다. 그것은 거의 당황스럽게도 나빴습니다. 이 섹션에서는 아주 단순한 모델에서 중간 정도의 복잡한 것, 즉 작은 콘볼 루션 신경 네트워크로 점프 할 것입니다. 이것은 우리에게 99.2 %의 정확성을 줄 것입니다. 예술 수준은 아니지만 존경 할 만합니다.


무게 초기화


이 모델을 만들려면 많은 가중치와 편향을 만들어야합니다. 일반적으로 대칭 분리를 위해 소량의 잡음을 사용하여 가중치를 초기화하고 0 기울기를 방지해야합니다. 우리가 ReLU(ReLU) 뉴런을 사용하고 있기 때문에, "죽은 뉴런"을 피하기 위해 약간 긍정적 인 초기 바이어스로 초기화하는 것이 좋습니다. 모델을 빌드하는 동안이 작업을 반복적으로 수행하는 대신, 우리를 위해이 작업을 수행하는 두 가지 편리한 기능을 만들어 보겠습니다.

+여기서 ReLU가 나오는데 CNN 및 점점 들어갈 수록 많이 사용되는 용어입니다.

def weight_variable(shape):
  initial
= tf.truncated_normal(shape, stddev=0.1)
 
return tf.Variable(initial)

def bias_variable(shape):
  initial
= tf.constant(0.1, shape=shape)
 
return tf.Variable(initial)

회선 및 풀링


TensorFlow는 또한 컨볼 루션 및 풀링 작업에 많은 유연성을 제공합니다. 경계를 어떻게 처리할까요? 우리의 보폭은 무엇입니까? 이 예에서는 항상 바닐라 버전을 선택합니다. 우리의 컨볼 루션은 1의 보폭을 사용하며 출력이 입력과 동일한 크기가되도록 0으로 채워집니다. 우리의 풀링은 2x2 블록을 넘어서 평범한 오래된 최대 풀링입니다. 코드를보다 깨끗하게 유지하려면 이러한 연산을 함수로 추상화합시다.

def conv2d(x, W):
 
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
 
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides
=[1, 2, 2, 1], padding='SAME')

첫 번째 콘볼 루션 레이어


이제 첫 번째 레이어를 구현할 수 있습니다. 컨볼 루션 (convolution)과 최대 풀링 (max pooling)으로 구성됩니다. 컨볼 루션은 각 5x5 패치에 대해 32 개의 기능을 계산합니다. 그것의 체중 텐서는 [5, 5, 1, 32]의 모양을 가질 것입니다. 처음 두 차원은 패치 크기이고, 다음은 입력 채널 수이고, 마지막은 출력 채널 수입니다. 각 출력 채널에 대한 구성 요소가있는 바이어스 벡터도 갖게됩니다.

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1
= bias_variable([32])

레이어를 적용하기 위해 먼저 x와 4d 텐서의 형태를 바꾸고 두 번째 및 세 번째 차원은 이미지 너비와 높이에 해당하고 최종 차원은 색상 채널 수에 해당합니다.

x_image = tf.reshape(x, [-1, 28, 28, 1])

우리는 x_image와 체중 텐서를 곱하고, 바이어스를 추가하고, ReLU 함수를 적용하고, 마지막으로 최대 풀을 적용합니다. max_pool_2x2 메소드는 이미지 크기를 14x14로 줄입니다.

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1
= max_pool_2x2(h_conv1)

두 번째 컨벌루션 레이어


깊은 네트워크를 구축하기 위해이 유형의 여러 레이어를 쌓습니다. 두 번째 레이어에는 각 5x5 패치에 대해 64 개의 기능이 있습니다.

W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2
= bias_variable([64])

h_conv2
= tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2
= max_pool_2x2(h_conv2)

조밀하게 연결된 레이어


이미지 크기가 7x7로 축소되었으므로 전체 이미지에서 처리 할 수 ​​있도록 1024 개의 뉴런이있는 완전히 연결된 레이어를 추가합니다. 우리는 풀링 레이어에서 텐서를 벡터 묶음으로 변형하고, 가중치 행렬을 곱하고, 바이어스를 추가하고, ReLU를 적용합니다.

W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1
= bias_variable([1024])

h_pool2_flat
= tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1
= tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

DropOut


초과 맞춤을 줄이기 위해 판독 레이어 앞에 드롭 아웃을 적용합니다. 우리는 드롭 아웃 중에 뉴런의 출력이 유지 될 확률에 대한 자리 표시자를 만듭니다. 이것은 우리가 훈련 중에 dropout을 켜고 시험하는 동안 turn off 할 수있게 해줍니다. TensorFlow의 tf.nn.dropout op는 마스킹 외에도 스케일링 뉴런 출력을 자동으로 처리하므로 드롭 아웃은 추가 스케일링 없이도 작동합니다 .

keep_prob = tf.placeholder(tf.float32)
h_fc1_drop
= tf.nn.dropout(h_fc1, keep_prob)

판독 레이어


마지막으로 위의 한 계층 softmax 회귀와 마찬가지로 계층을 추가합니다.


W_fc2 = weight_variable([1024, 10])
b_fc2
= bias_variable([10])

y_conv
= tf.matmul(h_fc1_drop, W_fc2) + b_fc2


차이점은 다음과 같습니다.


-가파른 그라데이션 하강 옵티 마이저를보다 정교한 ADAM 옵티 마이저로 대체 할 것입니다.

-feed_dict에 추가 매개 변수 keep_prob를 포함시켜 드롭 아웃 속도를 제어합니다.

-우리는 교육 과정에서 매 100 번째 반복에 로깅을 추가 할 것입니다.


또한 tf.InteractiveSession보다는 tf.Session을 사용할 것입니다. 이렇게하면 그래프를 만드는 과정 (모델 선택)과 그래프를 평가하는 과정 (모델 피팅)이 더 잘 분리됩니다. 일반적으로 더 깨끗한 코드를 만듭니다. tf.Session은 with 블록 내에서 만들어 지므로 블록이 종료되면 자동으로 삭제됩니다.


이 코드를 자유롭게 실행하십시오. 2 만 건의 교육 반복 작업을 수행하며 프로세서에 따라 다소 시간이 걸릴 수 있습니다 (최대 30 분 소요).

cross_entropy = tf.reduce_mean(
    tf
.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
train_step
= tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction
= tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy
= tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

with tf.Session() as sess:
  sess
.run(tf.global_variables_initializer())
 
for i in range(20000):
    batch
= mnist.train.next_batch(50)
   
if i % 100 == 0:
      train_accuracy
= accuracy.eval(feed_dict={
          x
: batch[0], y_: batch[1], keep_prob: 1.0})
     
print('step %d, training accuracy %g' % (i, train_accuracy))
    train_step
.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

 
print('test accuracy %g' % accuracy.eval(feed_dict={
      x
: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

이 코드를 실행 한 후 최종 테스트 세트 정확도는 약 99.2 % 여야합니다.


우리는 TensorFlow를 사용하여 매우 정교한 심층 학습 모델을 빠르고 쉽게 작성, 교육 및 평가하는 방법을 배웠습니다.


1 :이 작은 컨볼 루션 네트워크의 경우 성능은 실제로 드롭 아웃 유무와 거의 동일합니다. 드롭 아웃은 종종 과잉을 줄이는 데 효과적이지만 매우 큰 신경 네트워크를 학습 할 때 가장 유용합니다.




+ Relu와 Dropout을 활용하여 심층 신경망을 연결하는 방법 및 히든레이어를 활용하여 서로 연결된 네트워크망을  구성하는 방법을 간단하게 나왔습니다. 추후의 CNN 을 참고하게 된다면 더 많은 레이어 구성 및 복잡하지만 단순하게 구성하는 방법의 튜토리얼이 나옵니다.


출처 : https://www.tensorflow.org/get_started/mnist/pros







+ Recent posts