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

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 기능을 구현할 수 있다. $-\sum y^{\prime }\log (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

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

+ 지난 텐서플로우 게시글에 이어서 튜토리얼 2를 진행하겠습니다.

+ 적힌 부분이 추가설명 및 의견입니다.. ㅎㅎ

  기계 학습에 대한 자세한 내용은이 튜토리얼의 범위를 벗어난다. 

그러나 TensorFlow는 손실 함수를 최소화하기 위해 각 변수를 천천히 변경하는 옵티 마이저를 제공합니다.

 가장 간단한 옵티 마이저는 그래디언트 디센트입니다. 

해당 변수에 대한 손실 파생의 크기에 따라 각 변수를 수정합니다. 일반적으로 심볼릭 파생물을 수동으로 계산하는 것은 지루하고 오류가 발생하기 쉽습니다. 

결과적으로 TensorFlow는 tf.gradients 함수를 사용하여 모델 설명 만 제공된 파생물을 자동으로 생성 할 수 있습니다. 단순화를 위해 일반적으로 옵티마이 저가이를 수행합니다. 

+ 마땅한 번역할 단어가 안떠올라서 마지막 구글 번역을 돌렸더니 단어가 이상하네요 추가적으로 예제 코드를 보면서 설명하겠습니다.

예를 들어,

optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})

print(sess.run([W, b]))

이제 실제 기계 학습을했습니다!

+ 이번 코드는 GradientDescentOptimizer 0.01비율로 손실을 최소화 시키고 선형 모델인 

+ y = Wx+b 에서 x값과 y값을 주어졌을 때, W와, b의 값을 1000번의 학습된 결과를 통해 

+ 값을 표현한 것입니다.

 이 간단한 선형 회귀를 수행하더라도 TensorFlow 핵심 코드가 많이 필요하지는 않지만 모델에 데이터를 입력하는 더 복잡한 모델과 메서드는 더 많은 코드가 필요합니다.

 따라서 TensorFlow는 일반적인 패턴, 구조 및 기능에 대해 더 높은 수준의 추상화를 제공합니다. 

우리는 이어서 이러한 추상화를 사용하는 방법을 배웁니다.

완료된 프로그램 

완성 된 훈련 가능한 선형 회귀 모델은 다음과 같습니다.

import numpy as np
import tensorflow as tf

# Model parameters
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

# evaluate training accuracy
curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

+ 이 코드의 함수를 시각화 해서 본다면

tf.contrib.learn

tf.contrib.learn은 다음을 포함하여 기계 학습의 메커니즘을 단순화하는 상위 TensorFlow 라이브러리입니다.

-실행중인 학습 루프

-평가 루프 실행

-데이터 세트 관리

-수유 관리

tf.contrib.learn은 많은 공통 모델을 정의합니다.

기본 사용법

tf.contrib.learn을 사용하면 선형 회귀 프로그램이 얼마나 단순 해지는 지 주목하십시오

import tensorflow as tf
# NumPy is often used to load, manipulate and preprocess data.
import numpy as np

# Declare list of features. We only have one real-valued feature. There are many
# other types of columns that are more complicated and useful.
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

# An estimator is the front end to invoke training (fitting) and evaluation
# (inference). There are many predefined types like linear regression,
# logistic regression, linear classification, logistic classification, and
# many neural network classifiers and regressors. The following code
# provides an estimator that does linear regression.
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

# TensorFlow provides many helper methods to read and set up data sets.
# Here we use `numpy_input_fn`. We have to tell the function how many batches
# of data (num_epochs) we want and how big each batch should be.
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
                                              num_epochs=1000)

# We can invoke 1000 training steps by invoking the `fit` method and passing the
# training data set.
estimator.fit(input_fn=input_fn, steps=1000)

# Here we evaluate how well our model did. In a real example, we would want
# to use a separate validation and testing data set to avoid overfitting.
print(estimator.evaluate(input_fn=input_fn))

 {'global_step': 1000, 'loss': 1.9650059e-11}

+ 위 처럼 결과가 나올 것입니다.

커스텀 모델

tf.contrib.learn은 사용자를 미리 정의 된 모델로 잠그지 않습니다. 

TensorFlow에 내장되어 있지 않은 커스텀 모델을 만들고 싶다고 가정 해 보겠습니다. 

tf.contrib.learn의 데이터 세트, 수유, 교육 등의 높은 수준의 추상화는 여전히 유지할 수 있습니다. 

설명을 위해, 우리는보다 낮은 수준의 TensorFlow API에 대한 지식을 사용하여 LinearRegressor에 대한 자체 등가 모델을 구현하는 방법을 보여줍니다.

tf.contrib.learn과 작동하는 사용자 정의 모델을 정의하려면 tf.contrib.learn.Estimator를 사용해야합니다. tf.contrib.learn.LinearRegressor는 실제로 tf.contrib.learn.Estimator의 하위 클래스입니다. 

Estimator를 하위 분류하는 대신 Estimator에게 예측, 교육 단계 및 손실을 평가할 수있는 방법을 

tf.contrib.learn에게 알려주는 model_fn 함수를 제공하기 만하면됩니다. 코드는 다음과 같습니다.

import numpy as np
import tensorflow as tf
# Declare list of features, we only have one real-valued feature
def model(features, labels, mode):
  # Build a linear model and predict values
  W = tf.get_variable("W", [1], dtype=tf.float64)
  b = tf.get_variable("b", [1], dtype=tf.float64)
  y = W*features['x'] + b
  # Loss sub-graph
  loss = tf.reduce_sum(tf.square(y - labels))
  # Training sub-graph
  global_step = tf.train.get_global_step()
  optimizer = tf.train.GradientDescentOptimizer(0.01)
  train = tf.group(optimizer.minimize(loss),
                   tf.assign_add(global_step, 1))
  # ModelFnOps connects subgraphs we built to the
  # appropriate functionality.
  return tf.contrib.learn.ModelFnOps(
      mode=mode, predictions=y,
      loss=loss,
      train_op=train)

estimator = tf.contrib.learn.Estimator(model_fn=model)
# define our data set
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x}, y, 4, num_epochs=1000)

# train
estimator.fit(input_fn=input_fn, steps=1000)
# evaluate our model
print(estimator.evaluate(input_fn=input_fn, steps=10))

커스텀 모델 () 함수의 내용이 저수준 API의 수동 모델 트레이닝 루프와 얼마나 흡사한지 주목하십시오.

다음 단계

이제 TensorFlow의 기본 지식을 습득했습니다. 우리는 더 많은 것을 배우기 위해 여러분이 볼 수있는 튜토리얼을 몇 가지 더 가지고 있습니다. 초보자의 경우 초보자 인 경우 MNIST를 참조하십시오. 그렇지 않은 경우 전문가를위한 Deep MNIST를 참조하십시오

+ 다음 튜토리얼은 손글씨 인식을 하는 것입니다.

+ 이번 튜토리얼에서는 API에서 얼만큼 잘 제공해주는지 알려주는 것 같았습니다.

+ 다음 튜토리얼 부터는 점점 머신러닝과 관련하여 인곤지능과 가까워질 것 입니다. 

+ 다 같이 힘내봅시다.

TensorFlow 시작하기(설치 이후 첫 튜토리얼)

이 블로그는 첫 번째 튜토리얼을 번역 후 필요에 따라 중간중간 설명을 첨가하였습니다.

원본 글은 https://www.tensorflow.org/ 에 포함되어 있습니다.

이 튜토리얼은 TensorFlow에서 프로그래밍을 시작하도록 안내합니다.

이 게시글을 읽기 전에 TensorFlow를 설치하십시오. 설치 방법은 이전 글에 있습니다.

이 가이드를 최대한 활용하려면 다음 사항을 알아야합니다.

파이썬으로 프로그래밍하는 법. (C#, Java는 해봤었습니다. 뭔가 유저 친화적이지만, 배우지 않았었기 때문에, 미흡한 점은 많습니다만, 구글링 및 튜토리얼 따라하면서 많이 배워가고 있습니다.

처음 하시는 분들도 두려워말고 도전하실 수 있습니다.)

최소한 배열에 대해서는.

이상적으로는 기계 학습에 관한 것입니다. 그러나 기계 학습에 대해 거의 또는 전혀 알지 못하는 경우에도 여전히 읽어야 할 첫 번째 가이드입니다.

TensorFlow는 여러 API를 제공합니다. 최저 수준의 API 인 TensorFlow Core는 완벽한 프로그래밍 제어 기능을 제공합니다. TensorFlow Core는 기계 학습 연구자 및 모델을 미세하게 제어해야하는 사람들에게 권장됩니다. 높은 수준의 API는 TensorFlow Core 위에 구축됩니다. 이러한 상위 수준의 API는 일반적으로 TensorFlow Core보다 배우고 사용하기가 쉽습니다. 또한 상위 수준의 API는 반복적 인 작업을 여러 사용자간에보다 쉽고 일관되게 만듭니다. tf.contrib.learn과 같은 고급 API를 사용하면 데이터 세트, 견적 도구, 교육 및 추론을 관리 할 수 ​​있습니다. 메소드 이름에 contrib가 포함 된 상위 수준의 TensorFlow API 중 일부는 아직 개발 중입니다. 이후의 TensorFlow 릴리스에서 일부 contrib 메소드가 변경되거나 더 이상 사용되지 않을 수도 있습니다. 이 가이드는 TensorFlow Core에 대한 자습서로 시작됩니다. 나중에 tf.contrib.learn에서 동일한 모델을 구현하는 방법을 보여줍니다. TensorFlow를 아는 것보다 핵심적인 API를 사용할 때 핵심 원칙을 통해 내부적으로 일하는 방식에 대한 훌륭한 정신적 모델을 얻을 수 있습니다.

Tensor

TensorFlow에서 데이터의 중심 단위는 텐서입니다. 텐서는 임의의 수의 차원으로 배열 된 프리미티브 값 집합으로 구성됩니다. 텐서의 랭크는 차원 수입니다. 다음은 텐서 (tensors)의 몇 가지 예입니다.

3 # a rank 0 tensor; this is a scalar with shape []
[1. ,2., 3.] # a rank 1 tensor; this is a vector with shape [3]
[[1., 2., 3.], [4., 5., 6.]] # a rank 2 tensor; a matrix with shape [2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]] # a rank 3 tensor with shape [2, 1, 3]

+ 기존의 알고 있던 데이터 배열과는 살짝 다른 느낌입니다. 즉 집합의 개념으로 사용됩니다.

+ 텐서의 랭크는 차원의 수 라고 되어있는 것 처럼, 각 [ ] 괄호를 주의 깊게 보시면 대략적인 이해에 도움이 될 것입니다.

TensorFlow 핵심 자습서

TensorFlow 가져 오기

TensorFlow 프로그램에 대한 표준 import 문은 다음과 같습니다.

python

>>>  import tensorflow as tf

+ 입력 후 ">>>"가 안보인다면, tensorflow 설치를 완료 안했을 경우가 많습니다. 

이렇게하면 파이썬에서 TensorFlow의 모든 클래스, 메소드 및 심볼에 액세스 할 수 있습니다. 대부분의 문서에서는 이미이 작업을 수행했다고 가정합니다.

The Computational Graph

TensorFlow Core 프로그램은 두 개의 개별 섹션으로 구성되어 있다고 생각할 수 있습니다.

1.계산 그래프 작성. (Building the computational graph.)

2.전산 그래프를 실행합니다. (Running the computational graph.)

계산 그래프는 일련의 TensorFlow 작업을 노드 그래프로 배열 한 것입니다. 간단한 전산 그래프를 작성해 봅시다. 각 노드는 0 이상의 텐서를 입력으로 사용하고 텐서를 출력으로 생성합니다. 노드의 한 유형은 상수입니다. 모든 TensorFlow 상수와 마찬가지로 입력을받지 않으며 내부적으로 저장하는 값을 출력합니다. 다음과 같이 두 개의 부동 소수점 Tensors node1과 node2를 만들 수 있습니다.

node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)

마지막 print 서술문은

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

예상대로 노드 인쇄는 3.0과 4.0 값을 출력하지 않습니다. 대신 평가할 때 각각 3.0과 4.0을 생성하는 노드입니다. 노드를 실제로 평가하려면 세션 내에서 계산 그래프를 실행해야합니다. 세션은 TensorFlow 런타임의 컨트롤과 상태를 캡슐화합니다.

다음 코드는 Session 객체를 만든 다음 run 메소드를 호출하여 node1과 node2를 계산할 수있는 계산 그래프를 실행합니다. 다음과 같이 세션에서 전산 그래프를 실행합니다.

sess = tf.Session()
print(sess.run([node1, node2]))

3.0과 4.0의 예상 값을 봅니다.

Tensor 노드를 연산과 결합하여 더 복잡한 계산을 할 수 있습니다 (연산도 노드입니다). 예를 들어 두 개의 상수 노드를 추가하고 다음과 같이 새 그래프를 생성 할 수 있습니다.

node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))

+ 위의 결과되로 표시 되었다면 노드의 값을 tf.add를 통해 합쳐진 것을 볼 수 있습니다.

TensorFlow는 전산 그래프의 그림을 표시 할 수있는 TensorBoard라는 유틸리티를 제공합니다. 다음은 TensorBoard가 그래프를 시각화하는 방법을 보여주는 스크린 샷입니다.

+텐서보드의 설치 및 활용 법은 추후 게시글에 올리도록 하겠습니다. 데이터의 흐름도의 이해를 위해 스크린샷 처럼 표시되는구나 정도로 일단 이해하시고 넘어가시면 됩니다.

이 도표는 항상 일정한 결과를 산출하기 때문에 특히 흥미 롭지 않습니다. 자리 표시 자라고하는 외부 입력을 허용하도록 그래프를 매개 변수화 할 수 있습니다. 자리 표시자는 나중에 값을 제공하겠다는 약속입니다.

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

앞의 세 줄은 함수 또는 람다와 비슷하지만 두 개의 입력 매개 변수 (a 및 b)를 정의한 다음 해당 매개 변수에 대한 연산을 정의합니다. feed_dict 매개 변수를 사용하여 이러한 입력란에 구체적인 값을 제공하는 Tensors를 지정하여이 그래프를 여러 입력으로 평가할 수 있습니다.

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

+ 출력 결과 물은 봣을 때 첫 번쨰 명령 문의 계산식은

3+ 4.5 이고

두번째 계산은

a: 1 + b: 2  = 3

a: 3 + b: 4 = 7

의 결과값을 표현하는 것입니다.

In TensorBoard, the graph looks like this:

다른 연산을 추가하여 계산 그래프를 더 복잡하게 만들 수 있습니다. 예를 들어,

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

+ 연산 : (3+4.5)*3

The preceding computational graph would look as follows in TensorBoard:

기계 학습에서 우리는 전형적으로 위와 같은 임의의 입력을 취할 수있는 모델을 원할 것입니다. 모델을 학습 가능하게 만들려면 동일한 입력으로 새로운 출력을 얻기 위해 그래프를 수정할 수 있어야합니다. 변수를 사용하면 그래프에 학습 가능한 매개 변수를 추가 할 수 있습니다. 그것들은 타입과 초기 값으로 구성됩니다 :

W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

상원 의원은 제소자를 호출 할 때 값이 변하지 않을 것입니다. 반대로 할 수 없습니다. TensorFlow 프로그램의 모든 변수를 다음과 같이 사용하십시오.

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

init이 모든 전역 변수를 초기화하는 TensorFlow 하위 그래프의 핸들임을 인식하는 것이 중요합니다. sess.run을 호출 할 때까지 변수는 초기화되지 않습니다.

x는 자리 표시 자이므로 다음과 같이 x의 여러 값에 대해 linear_model을 동시에 평가할 수 있습니다.

print(sess.run(linear_model, {x:[1,2,3,4]}))

+ x를 순차적으로 대입하면서 출력하는 것을 볼 수 있습니다.

우리는 모델을 만들었지 만 아직 얼마나 좋은지 모릅니다. 훈련 데이터에 대한 모델을 평가하려면 원하는 값을 제공하기 위해 y 자리 표시자가 필요하며 손실 함수를 작성해야합니다.

손실 함수는 제공된 모델로부터 현재 모델이 얼마나 떨어져 있는지를 측정합니다. 현재 모델과 제공된 데이터 사이의 델타의 제곱을 합한 선형 회귀에 표준 손실 모델을 사용합니다. linear_model - y는 각 요소가 해당 예제의 오류 델타 인 벡터를 만듭니다. tf.square를 호출하여 오류를 제곱합니다. 그런 다음 모든 제곱 된 오류를 합하여 tf.reduce_sum을 사용하여 모든 예제의 오류를 추상화하는 단일 스칼라를 만듭니다.

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

W와 b의 값을 -1과 1의 완벽한 값으로 재 할당하여 수동으로 향상시킬 수 있습니다. 변수는 tf.Variable에 제공된 값으로 초기화되지만 tf.assign과 같은 연산을 사용하여 변경할 수 있습니다. 예를 들어, W = -1 및 b = 1은 우리 모델에 대한 최적의 매개 변수입니다. 그에 따라 W와 B를 변경할 수 있습니다.

fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

마지막 인쇄는 손실이 0임을 보여줍니다.

우리는 W와 B의 "완벽한"값을 추측했지만 기계 학습의 요점은 올바른 모델 매개 변수를 자동으로 찾는 것입니다. 다음 섹션에서이를 수행하는 방법을 보여줄 것입니다.

+ 지금은 손실이 0 인 것인 것처럼 간단한 계산식으로 했지만, 나중에 갈 수록 소수도 나오고 손실율도 커서 더 정확한 모듈을 만들기 위한 작업을 하겠습니다.

+ 일단 이번 글에서는 간단한 이해 및 원리만 이해하시면 되겠습니다.