TensorFlow Mechanics 101

Code: tensorflow/examples/tutorials/mnist/


본 자습서의 목적은 TensorFlow를 사용하여(고전적인)MNIST데이터 세트를 사용하여 손으로 작성된 손가락을 사용하여 간단한 피드 포워드 신경 네트워크를 훈련하고 평가하는 방법입니다. 본 자습서의 대상은 TensorFlow를 사용하는 데 관심이 있는 숙련된 사용자를 위한 것입니다.

이러한 자습서는 일반적으로 기계 학습을 가르치기 위한 것이 아닙니다.

TensorFlow를 설치하기 위한 지침을 준수했는지 확인하십시오.


튜토리얼 파일

이 자습서는 다음 파일을 참조합니다.

파일 목적

mnist.py : 완전히 연결된 MNIST 모델을 빌드하는 코드.

fully_connected_feed.py : 피드 사전을 사용하여 다운로드 된 데이터 세트에 대해 빌드 된 MNIST 모델을 학습하는 기본 코드.

교육을 시작하려면 직접 fully_connected_feed.py 파일을 실행하기 만하면됩니다.

python fully_connected_feed.py

데이터 준비

MNIST는 기계 학습의 전형적인 문제입니다. 문제는 회색으로 된 숫자 280x28픽셀 이미지를 보고이미지가 0에서 9까지의 숫자에 대해 나타내는 숫자를 판별하는 것입니다.

MNIST Digits

자세한 내용은 YanLecun의 MNIST페이지 또는 NBIST의 시각화를 참조하십시오.

(Yann LeCun's MNIST page or Chris Olah's visualizations of MNIST.)

다운로드.

런타임_데이터 처리()방법의 맨 위에 있는 경우 Input_data.reads_data_sets()함수가 로컬 교육 폴더로 다운로드된 데이터를 다운로드하여 DataSet인스턴스를 반환합니다.

data_sets = input_data.read_data_sets(FLAGS.train_dir, FLAGS.fake_data)

참고 : fake_data 플래그는 단위 테스트 목적으로 사용되며 판독기에서 무시할 수 있습니다.


데이터 집합             목적

data_sets.train                 55000 이미지 및 레이블, 기본 교육용.

data_sets.validation          5000 개의 이미지 및 레이블, 교육 정확도의 반복 검증.

data_sets.test                 훈련 된 정확도의 최종 테스트를 위해 10000 개의 이미지 및 레이블.


입력 및 자리 표시 자

placeholder_inputs () 함수는 입력의 모양을 정의하는 두 개의 tf.placeholder 연산을 생성합니다.이 연산은 batch_size를 포함하여 나머지 그래프와 실제 훈련 예제가 입력됩니다.

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,
                                                       mnist
.IMAGE_PIXELS))
labels_placeholder
= tf.placeholder(tf.int32, shape=(batch_size))

또한 트레이닝 루프에서 전체 이미지 및 레이블 데이터 세트가 각 단계의 batch_size에 맞게 슬라이스되고 이러한 자리 표시 자 연산과 일치 한 다음 feed_dict 매개 변수를 사용하여 sess.run () 함수로 전달됩니다.


그래프 작성

데이터의 자리 표시자를 만든 후 그래프는 3 단계 패턴 인 추론 (), 손실 () 및 학습 ()에 따라 mnist.py 파일에서 작성됩니다.

inference () - 예측을하기 위해 네트워크를 앞으로 돌리는 데 필요한만큼 그래프를 만듭니다.

loss () - 손실을 생성하는 데 필요한 연산을 추론 그래프에 추가합니다.

training () - 그라디언트를 계산하고 적용하는 데 필요한 연산을 손실 그래프에 추가합니다.


추론

inference () 함수는 출력 예측을 포함하는 텐서를 반환하는 데 필요한만큼 그래프를 작성합니다.

이미지 자리 표시자를 입력으로 사용하고 ReLU 활성화가있는 완전히 연결된 레이어와 출력 로짓을 지정하는 10 개의 노드 선형 레이어가 그 위에 빌드됩니다.

각 계층은 해당 범위 내에서 작성된 항목의 접두사로 사용되는 고유 한 tf.name_scope 아래에 작성됩니다.

with tf.name_scope('hidden1'):

정의 된 범위 내에서 각 레이어에서 사용되는 가중치와 바이어스는 원하는 모양으로 tf.Variable 인스턴스에 생성됩니다.

weights = tf.Variable(
    tf
.truncated_normal([IMAGE_PIXELS, hidden1_units],
                        stddev
=1.0 / math.sqrt(float(IMAGE_PIXELS))),
    name
='weights')
biases
= tf.Variable(tf.zeros([hidden1_units]),
                     name
='biases')

예를 들어, hidden1 범위에서 생성 된 경우 weights 변수에 고유 한 이름이 "hidden1 / weights"가됩니다.

각 변수에는 초기화 작업이 주어진다.

이 가장 일반적인 경우, 가중치는 tf.truncated_normal로 초기화되고 2 차원 텐서의 모양이 주어지면 가중치가 연결되는 레이어의 단위 수를 나타내는 첫 번째 흐림과 수를 나타내는 두 번째 흐림이 표시됩니다 가중치가 연결되는 계층의 단위. hidden1이라는 첫 번째 레이어의 경우, 가중치가 이미지 입력을 hidden1 레이어에 연결하기 때문에 크기는 [IMAGE_PIXELS, hidden1_units]입니다. tf.truncated_normal 초기화 프로그램은 주어진 평균 및 표준 편차로 임의의 분포를 생성합니다.

그런 다음 바이어스를 tf.zeros로 초기화하여 모든 0 값으로 시작하도록하고 그 모양은 연결되는 레이어의 단위 수입니다.

그래프의 세 가지 주요 작업 - 숨겨진 레이어에 대해 tf.matmul 및 로그에 대해 하나의 추가 tf.matmul을 포함하는 두 개의 tf.nn.relu ops가 차례로 생성되고 각 인스턴스에는 각각 별도의 tf.Variable 인스턴스가 생성됩니다 입력 자리 표시 자의 이전 텐서 또는 이전 레이어의 출력 텐서.

hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
logits = tf.matmul(hidden2, weights) + biases

마지막으로 출력을 포함하는 로그 텐서가 반환됩니다.


손실

loss () 함수는 필요한 손실 작업을 추가하여 그래프를 작성합니다.

먼저 labels_placeholder의 값이 64 비트 정수로 변환됩니다. 그런 다음 tf.nn.sparse_softmax_cross_entropy_with_logits op가 추가되어 labels_placeholder에서 1- 핫 레이블을 자동으로 생성하고 inference () 함수의 출력 로그를 1- 핫 레이블과 비교합니다.

labels = tf.to_int64(labels)
cross_entropy
= tf.nn.sparse_softmax_cross_entropy_with_logits(
    labels
=labels, logits=logits, name='xentropy')

그런 다음 tf.reduce_mean을 사용하여 일괄 처리 차원 (첫 번째 차원)에서 교차 엔트로피 값을 전체 손실로 평균화합니다.

loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')

그리고 나서 손실 값을 포함 할 텐서가 반환됩니다.

노트 : 교차 엔트로피는 정보 이론의 아이디어로, 실제로 사실 인 것을 감안할 때 신경망의 예측을 얼마나 나쁘게 생각하는지 설명 할 수 있습니다. 자세한 내용은 블로그 게시물 Visual Information Theory (http://colah.github.io/posts/2015-09-Visual-Information/)를 참조하십시오.

훈련

training () 함수는 Gradient Descent를 통해 손실을 최소화하는 데 필요한 연산을 추가합니다.

먼저 loss () 함수에서 손실 텐서를 취하여 tf.summary.FileWriter (아래 참조)와 함께 사용할 때 이벤트 파일에 요약 값을 생성하는 연산 인 tf.summary.scalar로 전달합니다. 이 경우 요약이 기록 될 때마다 손실의 스냅 샷 값을 방출합니다.

tf.summary.scalar('loss', loss)

다음으로, 요청 된 학습 속도로 그라데이션을 적용하는 tf.train.GradientDescentOptimizer를 인스턴스화합니다.

optimizer = tf.train.GradientDescentOptimizer(learning_rate)

그런 다음 글로벌 교육 단계에 대한 카운터를 포함하는 단일 변수를 생성하고 tf.train.Optimizer.minimize op는 시스템의 학습 가능한 가중치를 업데이트하고 전역 단계를 증가시키는 데 사용됩니다. 이 작업은 관습에 따라 train_op이라고하며, 한 단계의 교육 (아래 참조)을 유도하기 위해 TensorFlow 세션에서 실행해야하는 작업입니다.

global_step = tf.Variable(0, name='global_step', trainable=False)
train_op
= optimizer.minimize(loss, global_step=global_step)

모델 교육

일단 그래프가 작성되면 fully_connected_feed.py의 사용자 코드에 의해 제어되는 루프에서 반복적으로 트레이닝되고 평가 될 수 있습니다.

그래프

run_training () 함수의 맨 위에는 내장 된 모든 op가 기본 전역 tf.Graph 인스턴스와 연관되어 있음을 나타내는 명령과 함께 python이 있습니다.

with tf.Graph().as_default():

tf.Graph는 그룹으로 함께 실행될 수있는 작업 모음입니다. 대부분의 TensorFlow 사용은 단일 기본 그래프에만 의존해야합니다.

여러 그래프를 사용하는보다 복잡한 용도는 가능하지만이 간단한 자습서의 범위를 벗어납니다.

세션

모든 빌드 준비가 완료되고 필요한 모든 작업이 생성되면 그래프 실행을위한 세션이 만들어집니다.

sess = tf.Session()

또는 세션을 범위 지정을 위해 with 블록으로 생성 할 수 있습니다.

with tf.Session() as sess:

세션에 대한 빈 매개 변수는이 코드가 기본 로컬 세션에 연결 (또는 아직 생성되지 않은 경우 생성)한다는 것을 나타냅니다.

세션을 생성 한 직후, 모든 tf.Variable 인스턴스는 초기화 op에서 tf.Session.run을 호출하여 초기화됩니다.

init = tf.global_variables_initializer()
sess
.run(init)

tf.Session.run 메서드는 매개 변수로 전달 된 op (s)에 해당하는 그래프의 전체 하위 집합을 실행합니다. 이 첫 번째 호출에서 init op는 변수의 초기화 코드 만 포함하는 tf.group입니다. 나머지 그래프는 여기에서 실행되지 않습니다. 그것은 아래의 교육 과정에서 발생합니다.

학습 루프

세션으로 변수를 초기화 한 후 교육이 시작될 수 있습니다.

사용자 코드는 단계별 교육을 제어하며 유용한 교육을 수행 할 수있는 가장 단순한 루프는 다음과 같습니다.

for step in xrange(FLAGS.max_steps):
    sess
.run(train_op)

그러나이 자습서는 이전 단계에서 생성 된 자리 표시 자와 일치시키기 위해 각 단계의 입력 데이터를 슬라이스해야한다는 점에서 약간 더 복잡합니다.

그래프 피드

각 단계에서 코드는 단계에 대한 교육을위한 예제 세트를 포함하는 피드 사전을 생성하며,이 단계는 해당 인스턴스가 나타내는 자리 표시 자 연산에 의해 입력됩니다.

fill_feed_dict () 함수에서 주어진 DataSet은 이미지와 레이블의 다음 batch_size 세트에 대해 쿼리되고 자리 표시 자와 일치하는 tensors는 다음 이미지와 레이블을 포함하여 채워집니다.

images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size,
                                               FLAGS
.fake_data)

그런 다음 키와 자리 표시자를 나타내는 파이썬 사전 객체가 생성되고 대표적인 피드 텐서가 값으로 제공됩니다.

feed_dict = {
    images_placeholder
: images_feed,
    labels_placeholder
: labels_feed,
}

이것은 sess.run () 함수의 feed_dict 매개 변수로 전달되어이 단계의 학습에 대한 입력 예제를 제공합니다.

상태 확인

이 코드는 실행 호출에서 가져올 두 값을 지정합니다 : [train_op, loss].

for step in xrange(FLAGS.max_steps):
    feed_dict
= fill_feed_dict(data_sets.train,
                               images_placeholder
,
                               labels_placeholder
)
    _
, loss_value = sess.run([train_op, loss],
                             feed_dict
=feed_dict)

가져올 값은 두 가지이므로 sess.run ()은 두 항목이 포함 된 튜플을 반환합니다. 가져올 값 목록에있는 각 Tensor는 반환 된 튜플의 numpy 배열에 해당하며이 단계에서이 텐서 값이 채워집니다. train_op은 출력 값이없는 Operation이기 때문에 반환 된 튜플의 해당 요소는 None이므로 버려집니다. 그러나 모델이 훈련 중에 분기되면 손실 텐서의 값은 NaN이 될 수 있으므로이 값을 로깅에 사용합니다.

NaN 없이도 교육이 잘 진행된다고 가정하면 교육 과정에서 100 단계마다 간단한 상태 텍스트를 인쇄하여 사용자에게 교육 상태를 알릴 수 있습니다.

if step % 100 == 0:
   
print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration))

상태 시각화

TensorBoard에서 사용되는 이벤트 파일을 내보내려면 그래프 작성 단계에서 모든 요약 (이 경우 하나만 포함)이 단일 텐서로 수집됩니다.

summary = tf.summary.merge_all()

그리고 나서 세션이 생성 된 후 tf.summary.FileWriter가 인스턴스화되어 그래프 자체와 요약 값을 모두 포함하는 이벤트 파일을 작성할 수 있습니다.

summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)

마지막으로, 이벤트 파일은 요약이 평가 될 때마다 새 요약 값으로 업데이트되고 출력이 작성자의 add_summary () 함수에 전달됩니다.

summary_str = sess.run(summary, feed_dict=feed_dict)
summary_writer
.add_summary(summary_str, step)

이벤트 파일을 작성하면 Training 폴더에 대해 TensorBoard를 실행하여 요약의 값을 표시 할 수 있습니다.

MNIST TensorBoard

참고 : Tensorboard를 작성하고 실행하는 방법에 대한 자세한 내용은 함께 제공되는 Tensorboard : Visualizing Learning을 참조하십시오. Tensorboard: Visualizing Learning.

검사 점 저장(체크포인트 저장)

추후 교육이나 평가를 위해 모델을 나중에 복원하는 데 사용할 수있는 검사 점 파일을 내보내려면 tf.train.Saver를 인스턴스화합니다.

saver = tf.train.Saver()

트레이닝 루프에서는 tf.train.Saver.save 메소드가 정기적으로 호출되어 모든 트레이닝 가능한 변수의 현재 값을 사용하여 검사 점 파일을 트레이닝 디렉토리에 씁니다.

saver.save(sess, FLAGS.train_dir, global_step=step)

나중에 추후에 thetf.train.Saver.restore 메소드를 사용하여 모델 매개 변수를 다시로드하여 교육을 재개 할 수 있습니다.

saver.restore(sess, FLAGS.train_dir)


모델 평가

천 단계마다이 코드는 교육 및 테스트 데이터 세트 모두에 대해 모델을 평가하려고 시도합니다. do_eval () 함수는 교육, 유효성 검사 및 테스트 데이터 집합에 대해 세 번 호출됩니다.

print('Training Data Eval:')
do_eval
(sess,
        eval_correct
,
        images_placeholder
,
        labels_placeholder
,
        data_sets
.train)
print('Validation Data Eval:')
do_eval
(sess,
        eval_correct
,
        images_placeholder
,
        labels_placeholder
,
        data_sets
.validation)
print('Test Data Eval:')
do_eval
(sess,
        eval_correct
,
        images_placeholder
,
        labels_placeholder
,
        data_sets
.test)

더 복잡한 사용법은 대개 상당한 양의 하이퍼 매개 변수 튜닝 후에 만 ​​확인되도록 data_sets.test를 격리합니다. 그러나 간단한 MNIST 문제 때문에 모든 데이터에 대해 평가합니다.

평가 그래프 작성

교육 루프를 시작하기 전에 평가 () 함수는 mnist.py에서 loss () 함수와 동일한 logits / labels 매개 변수를 사용하여 evaluation () 함수를 호출하여 작성해야합니다.

eval_correct = mnist.evaluation(logits, labels_placeholder)

evaluation () 함수는 단순히 true 레이블이 K 가장 가능성있는 예측에서 발견 될 수있는 경우 각 모델 출력을 자동으로 득점 할 수있는 tf.nn.in_top_k op를 생성합니다. 이 경우 K의 값을 1로 설정하여 실제 레이블 인 경우 올바른 예측 만 고려합니다.

eval_correct = tf.nn.in_top_k(logits, labels, 1)

평가 출력

그런 다음 feed_dict를 채우고 eval_correct op에 대해 sess.run ()을 호출하여 지정된 데이터 집합에서 모델을 평가하는 루프를 만들 수 있습니다.

for step in xrange(steps_per_epoch):
    feed_dict
= fill_feed_dict(data_set,
                               images_placeholder
,
                               labels_placeholder
)
    true_count
+= sess.run(eval_correct, feed_dict=feed_dict)

true_count 변수는 in_top_k op가 올바른 것으로 판단한 모든 예측을 누적합니다. 거기에서 정밀도는 총 사례 수로 단순히 나누어 계산할 수 있습니다.

precision = true_count / num_examples
print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
     
(num_examples, true_count, precision))



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







이 게시글은 기계 학습과 기계 학습 모두에 새롭게 등장하는 독자를 위한 것입니다.


MNIST가 무엇인지 이미 알고 있다면 softmax( multinomial logistic)회귀이 무엇인지를 알 수 있으며, 이는 보다 빠른 속도의 자습서를 선호할 수 있습니다.


튜토리얼을 시작하기 전에 반드시 TensorFlow를 설치해야 합니다.


프로그래밍하는 법을 배울 때,"HelloWorld"는 "HelloWorld"를 인쇄하는 것과 같은 전통을 가지고 있습니다. 프로그래밍이 HelloWorld를 하는 것은 이번 튜토리얼과 같은 문맥입니다.


MNIST는 간단한 컴퓨터 비전 데이터 세트입니다. 이는 다음과 같이 손으로 작성한 숫자의 이미지로 구성됩니다.


또한 각 이미지에 대한 라벨이 포함되어 있으며, 각 이미지에 해당하는 숫자를 알려 줍니다.

 예를 들어 위 이미지의 레이블은 5,0,4,1입니다.


이 튜토리얼에서, 우리는 이미지를 관찰하고 그들이 어떤 숫자인지 예측할 수 있도록 모델을 훈련시킬 것입니다.

우리의 목표는 최첨단 성능을 발휘하는 정교한 모델을 훈련시키는 것이 아니라, 나중에 할 수 있도록 코드를 부여하는 것입니다!--하지만 발가락을 사용하여 발가락 부분을 찍는 것이 낫다. 

이와 같이 우리는 매우 단순한 모델로 시작할 것입니다. 바로 Softmax 회귀라는 회귀 모델입니다.


+ 즉, 나중에 훈련시킨 모델들을 가져오는 원리들을 파악 및 softmax 회귀 모델을 알아가는 부분인 것 같습니다.


이 튜토리얼의 실제 코드는 매우 짧으며, 모든 재미 있는 것들은 세줄로 되어 있습니다.하지만, 그것 이면의 아이디어들을 이해하는 것은 매우 중요하다.이것 때문에, 우리는 매우 신중하게 코드를 완성할 것입니다.


본 자습서는 mnist_softmax.py 라인 코드에서 발생하는 일련의 설명, 라인별로 설명합니다.


본 자습서는 다음을 비롯하여 몇가지 다른 방법으로 사용할 수 있습니다.

1) 각 줄의 설명을 통해 읽을 수 있는 대로 각 코드를 라인별로 구분하여 라인 업으로 복사하고 붙여 넣으십시오.

2) 설명서를 읽기 전에 전체 mnist_softmax.py Python 파일을 실행하고 이 자습서를 사용하여 명확하지 않은 코드를 이해할 수 있도록 합니다.


수행할 내용:

1)데이터 중복 제거 기술에 대한 자세한 내용 및 데이터 중복 제거 기술에 대해 알아보기.

2)이미지의 모든 픽셀을 보는 데 기반하여 자릿수를 인식하는 기능을 생성합니다.

3)TensorFlow를 사용하여 모델을 " 보기"로 인식하여 모델을 식별하고, 수천개의 예제를 실행할 수 있도록 합니다.

4)테스트 데이터를 통해 모델의 정확도를 점검하십시오.

The MNIST Data

MNIST 데이터는 Yann LeCun의 웹 사이트에서 호스팅 됩니다.

이 자습서에서 코드를 복사하고 붙여 넣는 경우, 여기서 데이터를 자동으로 다운로드하고 읽을 수 있는 코드 두줄로 시작하십시오.

from tensorflow.examples.tutorials.mnist import input_data
mnist
= input_data.read_data_sets("MNIST_data/", one_hot=True)

MNIST 데이터는 세 부분으로 나뉩니다. 즉, 교육 데이터의 55,000개의 데이터 포인트( mnist.train), 테스트 데이터의 10,000포인트( mnist.test), 검증 데이터의 5,000포인트( mnist.validation)등이 있습니다.

이 세분류는 매우 중요합니다. 우리가 배워야 할 것은 우리가 배우지 못한 것을 확실히 할 수 있는 별개의 데이터를 가지고 있다는 것입니다.


앞서 언급한 바와 같이, 모든 MNIST 데이터 포인트에는 두개의 파트가 있습니다. 즉, 손으로 작성한 숫자와 해당 라벨의 이미지입니다.

우리는 이미지"x"와 라벨"y"를 부를 것입니다. 교육 세트 및 테스트 세트에는 이미지 및 해당 라벨이 모두 포함되어 있습니다. 예를 들어 교육용 이미지는 mnist.train.images이며, 교육용 레이블은 mnist.train.labels.입니다.


각 이미지는 28픽셀 x28픽셀입니다. NAT은 다음과 같은 다양한 수치로 해석할 수 있습니다.


우리는 이 배열을 28x28의 벡터의 벡터로 평평하게 만들 수 있다. 우리가 이미지들 사이에 일관성을 유지하는 한, 우리가 어떻게 배열할지는 중요하지 않습니다.

이러한 관점에서 볼 때, MNIST 이미지는 매우 풍부한 구조(경고:시각화 집약적 시각화)를 가진 벡터 기반 벡터 공간의 수많은 포인트일 뿐입니다.


평평한 데이터에서 이미지의 2D구조에 대한 정보가 삭제됩니다. 최고의 컴퓨터 비전 방법은 이 구조를 이용하는 거죠. 그리고 우리는 나중에 튜토리얼을 쓸 것입니다. 그러나 우리가 여기서 사용할 간단한 방법은 다음과 같습니다.


결과적으로 mnist.train.images는 55000( n-dimensional, 784, ])의 텐서이다. 첫번째 차원은 영상 목록에 있는 색인이며 두번째 차원은 각 영상의 각 픽셀에 대한 인덱스입니다.텐서( tensor)의 각 항목은 특정 영상의 특정 화소에 대해 0과 1사이의 화소 강도이다.

각 그림 MNIST의 각 이미지에는 해당 이미지에 그려진 숫자를 나타내는 0~9사이의 숫자가 있습니다.


본 자습서를 위해 저희는 라벨을 "one-hot 벡터"라고 부르고자 합니다. 벡터 기반 벡터는 대부분의 차원에서 0이며, 단일 차원의 1차원이다. 이 경우 n번째 숫자는 n번째 치수의 1개의 벡터로 표현됩니다.예를 들어, 3은[0,0,0,0,0,0,0,0,0,0]입니다. 결과적으로 mnist.train.labels는[ 55000,10]kg의 부동 소수 점 배열이다.

우리는 이제 실제로 모델을 만들 준비가 됐어요!


Softmax Regressions

파이썬을 사용하여 효율적인 숫자 계산을 하기 위해서, 우리는 보통 Python곱셈기와 같은 비싼 작업을 하는 NumPy 같은 라이버리을 사용한다. 다른 언어로 구현된 매우 효율적인 코드이다.

불행히도, 모든 운영 체제로 전환하는 데는 여전히 많은 오버 헤드가 존재할 수 있습니다.

이 오버 헤드는 특히 데이터 전송에 높은 비용이 들 수 있는 분산된 방식이나 분산된 방식으로 계산하려는 경우에 특히 나쁩니다.


TensorFlow는 또한 Python을 없애기 위해 많은 노력을 하지만, 이러한 오버 헤드를 피하기 위해 한 걸음 더 나아 간다.

Python은 파이썬을 사용하여 독립적으로 운영하는 것을 대신하는 대신에 파이선을 사용하여 운영되는 상호 작용 작업의 그래프에 대해 설명합니다.(이와 같은 접근 방식은 몇개의 기계 학습 라이브러리에서 볼 수 있습니다.)


TensorFlow를 사용하려면 먼저 가져와야 합니다.

import tensorflow as tf
import tensorflow as tf

우리는 상징적 변수를 조작하여 이러한 상호 작용 운영을 설명한다. 다음을 생성합니다.

x = tf.placeholder(tf.float32, [None, 784])

x는 특정한 가치가 아니다. 이것은 자리 표시자입니다. 우리가 계산대에서 계산할 때 우리가 입력할 가치가 있는 값입니다.

우리는 각각의 MNIST 이미지들을 784-dimensional 벡터로 바꿀 수 있는 숫자를 입력할 수 있기를 원합니다.

우리는 이것을 부동 소수 점 이하의 부동 소수 점 숫자의 2차원 텐서( 784)로 표현한다. (여기서는 치수가 어떤 길이라도 될 수 있음을 의미한다.)

우리는 또한 모델에 대한 체중(Weights)과 편견(Biases)이 필요합니다. 우리는 이것들을 추가 투입하는 것을 상상할 수 있지만, TensorFlow는 그것을 다루는 더 나은 방법을 가지고 있습니다. Variable

Variable는 상호 작용의 상호 작용에 대한 TensorFlow의 그래프에서 수정 가능한 수정 가능한 텐서이다.

그것은 계산에 의해 사용되고 심지어 수정될 수도 있다. 기계 학습 애플리케이션의 경우 일반적으로 모델 매개 변수는 변수 변수가 됩니다.

W = tf.Variable(tf.zeros([784, 10]))
b
= tf.Variable(tf.zeros([10]))

우리는 변수의 초기 값을 tf.Variable의 초기 값으로 줌으로써 이 변수를 생성합니다. 이 경우에는 W과 b을 tf.zeros 0으로 나눕니다.

우리는 W와 b를 배울 것이기 때문에, 그것들이 처음에는 그다지 중요하지 않다.


W는[ 784,10]의 형태를 가지고 있습니다. 왜냐하면 우리는 벡터의 벡터 벡터를 곱하기 위해 다른 등급의 벡터 벡터를 생성하기 위해 벡터 벡터를 곱하고 싶습니다.b는 출력에 추가할 수 있도록[10]의 모양을 가지고 있다.

이제 모델을 구현할 수 있습니다. 그것을 정의하는데 한줄만 걸려요!

y = tf.nn.softmax(tf.matmul(x, W) + b)

첫째로, 우리는 x, W, W의 표현으로 x를 곱합니다.

이것은 우리가 곱셈 부호를 가지고 있는 우리의 방정식으로, 우리가 여러개의 입력을 가진 2D텐서를 다루는 작은 속임수로 우리의 방정식에 넣은 것에서 힌트를 얻었다.

그리고 나서 우리는 b를 추가하고, 마침내 tf.nn.softmax.를 적용한다.

바로 그거에요. 몇번의 짧은 설치 후에 모델을 정의할 수 있는 선이 하나밖에 없었습니다.

그것은 TensorFlow가 특별히 쉽게 회귀할 수 있도록 설계되었기 때문이 아니다.

그것은 기계 학습 모델에서부터 물리학 시뮬레이션에 이르기까지 많은 숫자의 수치 연산을 묘사하는 매우 유연한 방법입니다.

그리고 일단 정의된 대로, 우리의 모델은 컴퓨터의 CPU, GPUs, 심지어는 심지어 전화기로도 작동할 수 있습니다!

Training

모델을 훈련시키기 위해서, 우리는 모델이 좋은 것이 무엇인지를 의미하는 것을 정의해야 합니다.

실제로, 기계 학습에서는 전형적으로 모델이 나쁘다는 것을 의미합니다.

우리는 이것을 원가 혹은 손실이라 부르며, 그것은 우리의 모델이 원하는 결과로부터 얼마나 멀리 떨어져 있는지를 나타냅니다.

우리는 에러를 최소화하려고 합니다. 에러 마진이 적을수록 우리의 모델은 더 좋습니다.

모델의 분실을 결정하기 위한 매우 일반적이고 매우 훌륭한 기능은 "cross-entropy"라고 불립니다.

정보 이론은 정보 이론에서 정보 압축 코드에 대해 생각하는 것에서 기인하지만, 도박에서부터 기계 학습에 이르기까지 많은 분야에서 중요한 아이디어가 된다. 다음과 같이 정의됩니다.


여기서 y는 예측 가능한 확률 분포이며 y ′는 실제 분포(자릿수 라벨을 사용한 one-hot 벡터)이다.

대략적으로, cross-entropy는 우리의 예측이 진실을 설명하는 데 얼마나 비효율적인지를 측정하고 있다.

cross-entropy에 대한 자세한 내용은 본 자습서의 범위를 벗어나지만 이해할 만한 가치가 충분히 있습니다.


cross-entropy를 구현하려면 먼저 새 자리 표시자를 추가하여 올바른 답을 입력해야 합니다.

y_ = tf.placeholder(tf.float32, [None, 10])

우리는 cross-entropy 기능을 구현할 수 있다. ylog(y):

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

첫째, tf.log는 y의 각 요소의 대수를 계산한다. 다음으로 y-y의 원소를 곱하고 y^y(y)와 같은 원소를 곱한다.

그런 다음 tf.reduce_sum는 reduction_indices=[1 매개 변수로 인해 y의 두번째 치수에 해당하는 요소를 추가합니다.

마지막으로, tf.reduce_mean는 배치의 모든 예제에 대한 평균을 계산합니다.


소스 코드에서는 이 공식을 사용하지 않습니다. 숫자가 불안정하기 때문입니다. 그 대신에 unnormalized(x, W)+b(x, W)에 softmax_cross_entropy_with_logits를 tf.nn.softmax_cross_entropy_with_logits에 적용한다.

이는 보다 수치적으로 안정적인 기능을 통해 내부적으로 softmax 활성화를 계산합니다. 코드를 사용하는 경우 대신 tf.nn.softmax_cross_entropy_with_logits를 사용하는 것을 고려해 보십시오.


이제 우리가 원하는 것이 무엇인지 알 수 있으므로, 우리가 그것을 하기 위해 TensorFlow를 훈련시키는 것은 매우 쉬워요.

왜냐하면 TensorFlow는 당신의 계산의 전체 그래프를 알고 있기 때문입니다. 자동화 알고리즘을 사용하여 변수가 손실되는 손실에 어떻게 영향을 미치는지 효율적으로 결정할 수 있습니다.

그런 다음 최적화 알고리즘을 적용하여 변수를 수정하고 손실을 줄일 수 있습니다.

train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

이 경우에, 우리는 TensorFlow에게 0.5의 학습 속도로 구배 하강 알고리즘을 사용하여 cross_entropy를 최소화할 것을 요청한다.경사 하강은 간단한 절차입니다. 여기서 TensorFlow는 단순히 각 변수를 비용을 감소시키는 방향으로 조금씩 돌립니다. 하지만 TensorFlow는 여러가지 다른 최적화 알고리즘을 제공합니다. 만약 한개만 한다면 하나의 선을 조정하는 것만큼 간단합니다.


TensorFlow가 실제로 여기서 수행하는 것은 backpropagation와 경사도 하강을 구현하는 그래프에 새로운 연산을 추가하는 것입니다. 그런 다음, 단일 작업을 수행합니다. 단, 작동 시 기울기 하강 훈련을 수행하여 변수를 약간 수정하고 손실을 줄입니다.


이제 InteractiveSession에서 모델을 시작할 수 있습니다.

sess = tf.InteractiveSession()

먼저 생성한 변수를 초기화하기 위한 작업을 생성해야 합니다.

tf.global_variables_initializer().run()

훈련을 시작합시다--훈련 스텝은 1000번입니다!

for _ in range(1000):
  batch_xs
, batch_ys = mnist.train.next_batch(100)
  sess
.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

각 단계마다 100개의 무작위 데이터 포인트가 배치되어 있습니다. 교육 세트에서 백개의 랜덤 데이터 포인트를 얻을 수 있습니다. 우리는 배치 데이터에서 자리 표시자를 대체하기 위해 train_step 데이터를 실행한다.


무작위 데이터의 소량 배치를 확률적 훈련이라 부르며 이 경우 확률적 경사 하강 하강이다. 이상적으로는, 우리는 모든 훈련 과정을 위해 모든 데이터를 사용하고 싶습니다. 왜냐하면 우리는 우리가 해야 할 일을 더 잘 이해할 수 있기 때문입니다. 하지만 그것은 비쌉니다. 따라서, 우리는 매번마다 다른 하위 집합을 사용합니다. 이것을 하는 것은 싸고 이로운 점도 많다.

Evaluating Our 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))

그것은 우리에게 booleans 리스트를 제공한다. 정확한 비율을 결정하기 위해, 우리는 부동 소수 점 숫자를 선택한 다음 평균을 취한다. 예를 들어,[True, False, True, True]는 0.75가 될[1,0,1,1]이 됩니다.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

마지막으로, 우리는 우리의 시험 데이타에 대한 정확성을 요구한다.

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

이는 약 92%여야 합니다.

good ? 어떤가요? 글쎄, 그렇진 않아. 사실, 그것은 꽤나 나빠요. 이것은 우리가 매우 단순한 모델을 사용하고 있기 때문입니다.

약간의 깊이를 가지고 있으면 97%까지 갈 수 있어요. 최고의 모델들은 99.7%이상의 정확도를 달성할 수 있습니다! ( 자세한 내용은 이 결과 목록을 참조하십시오.)


중요한 것은 우리가 이 모델에서 배운 것입니다. 그럼에도 불구하고, 만약 여러분이 이러한 결과에 대해 조금 더 우울하다면, 우리가 훨씬 더 잘하는 다음 튜토리얼을 통해 더 정교한 모델을 만드는 방법을 배워 보세요!



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


추후 다음 튜토리얼을 하기 전에 실제 돌린 장면을 포함해서 올리도록 하겠습니다.


+ Recent posts