회귀 구현하기 Implementing the Regression (7)

회귀 구현하기 Implementing the Regression

To do efficient numerical computing in Python, we typically use libraries like NumPy that do expensive operations such as matrix multiplication outside Python, using highly efficient code implemented in another language.
파이썬으로 숫자 계산을 효율적으로 하려면, 파이썬 외부에서, 다른 언어로 구현된 매우 효율적인 코드를 사용하여, 매트릭스 곱셈과 같은 비싼 운영을 수행하는, NumPy와 같은 라이브러리를 전형적으로 사용합니다.

Unfortunately, there can still be a lot of overhead from switching back to Python every operation.
불행하게도 매 작동 마다 파이썬으로 역 교대함에 따른 많은 오버헤드가 여전히 있습니다.

This overhead is especially bad if you want to run computations on GPUs or in a distributed manner, where there can be a high cost to transferring data.
이 오버헤드는 GPU 상에서 계산할 때 또는 분산된 방식으로 계산할 때 특히 나쁜데, 데이터 이전(transferring)에 많은 비용이 소요됩니다.

TensorFlow also does its heavy lifting outside python, but it takes things a step further to avoid this overhead.
텐서플로도 파이썬 외부에서 그 무거운 작업을 수행하지만, 이 오버헤드를 피하기 위해 한 단계 더 들어갑니다.

Instead of running a single expensive operation independently from Python, TensorFlow lets us describe a graph of interacting operations that run entirely outside Python. (Approaches like this can be seen in a few machine learning libraries.)
텐서플로는 파이썬과 별도로 비싼 단일 운영을 실행하는 대신, 완전히 파이썬 외부에서 실행되는 상호작용하는 운영 그래프를 서술하게 만듭니다.
To use TensorFlow, we need to import it.
텐서플로를 사용하려면 먼저 tensorflow를 import 해야 합니다.

               import tensorflow as tf

We describe these interacting operations by manipulating symbolic variables.
기호(symbolic) 변수를 조작하여 이들 상호작용하는 운영을 서술합니다.

Let's create one:
하나 만들어 봅니다:

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

 

x isn't a specific value.   
x는 특별히 정해진 값이 아닙니다.

It's a placeholder, a value that we'll input when we ask TensorFlow to run a computation.
x는 플레이스홀더로, 텐서플로에게 계산을 실행하라고 요구할 때 입력하는 값(value)입니다.

We want to be able to input any number of MNIST images, each flattened into a 784-dimensional vector.
각각 784-차원 벡터로 평면화된, MNIST 이미지의 모든 숫자를 입력할 수 있어야 합니다.

We represent this as a 2d tensor of floating point numbers, with a shape [None, 784]. (Here None means that a dimension can be of any length.)
이것을 [None, 784] 모양을 가진, 부동소수점숫자의 2차원 tensor로 표현합니다(여기서 None은 차원의 길이에 제한이 없음을 의미함).

We also need the weights and biases for our model.
모델의 가중치와 편향(biases)도 필요합니다.

We could imagine treating these like additional inputs, but TensorFlow has an even better way to handle it: Variable.
가중치와 편향을 추가 입력(additional inputs)으로 처리할 수도 있지만, 텐서플로에는 가중치와 편향을 보다 잘 처리하는 방식이 있는데, 바로 변수(Variable)입니다.

A Variable is a modifiable tensor that lives in TensorFlow's graph of interacting operations.
변수는 텐서플로의 상호작용 ops 그래프 안에 있는 수정 가능한 텐서 입니다.

It can be used and even modified by the computation.
계산(computation)이 변수를 사용하거나 수정할 수 있습니다.

For machine learning applications, one generally has the model parameters be Variables.
ML 애플리케이션에는, 일반적으로 변수인 모델 패러미터가 있습니다.

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

b = tf.Variable(tf.zeros([10]))

 

We create these Variables by giving tf.Variable the initial value of the Variable: in this case, we initialize both W and b as tensors full of zeros.
tf.Variable에 변수의 초기 값을 부여함으로써, 이들 변수를 생성시킵니다: 이 경우, W와 b를 0으로 채워진 tensor들로 초기화 합니다.

Since we are going to learn W and b, it doesn't matter very much what they initially are.
W와 b를 학습하고자 하는 것이기 때문에, 초기값이 무엇인가는 중요하지 않습니다.

Notice that W has a shape of [784, 10] because we want to multiply the 784-dimensional image vectors by it to produce 10-dimensional vectors of evidence for the difference classes. 
구분되는 클래스들을 위한 10-차원의 증거 벡터들을 만들기 위하여, 784-차원 이미지 벡터들을 10차원의 증거 벡터로 곱하려 하기 때문에, W가 [784, 10]의 형상 임을 주목하십시오.

b has a shape of [10] so we can add it to the output.
b는 [10]의 형상이기 때문에 그것을 출력에 더할 수 있습니다.

We can now implement our model. It only takes one line!
이제 모델을 구현할 수 있습니다. 단 1줄로!

 

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

 

First, we multiply x by W with the expression tf.matmul(x,W).
우선, 표현식(expression) tf.matmul(x,W) 로 x와 W를 곱합니다.

This is flipped from when we multiplied them in our equation, where we had Wx, as a small trick to deal with x being a 2D tensor with multiple inputs.
입력이 복수인 2D tensor인 x를 처리하기 위한 작은 트릭으로써, Wx를 가진 경우, 등식에서 그들을 곱할 때 뒤집힙니다(flipped).

We then add b, and finally apply tf.nn.softmax.
그런 다음 b를 더하고 마지막으로 tf.nn.softmax를 적용합니다.

That's it. 다 되었습니다.

It only took us one line to define our model, after a couple short lines of setup.
1쌍의 짧은 셋업 줄의 뒤에, 1줄로 모델을 정의할 수 있습니다.

That isn't because TensorFlow is designed to make a softmax regression particularly easy: it's just a very flexible way to describe many kinds of numerical computations, from machine learning models to physics simulations.
TensorFlow가 softmax 회귀를 특히 쉽게 만들도록 설계되었기 때문에 1줄로 모델을 정의할 수 있는 것은 아닙니다: 이것은 ML모델부터 물리적 시뮬레이션까지, 많은 종류의 숫자 계산을 서술 하는 아주 유연한 방식일 뿐입니다.

And once defined, our model can be run on different devices: your computer's CPU, GPUs, and even phones!
일단 정의되면, 모델은 여러 장치에서 가동될 수 있습니다: CPU, GPU 그리고 전화기!

Training

In order to train our model, we need to define what it means for the model to be good.
모델을 훈련하기 위하여, 모델에게 무엇이 적합한 지를 정의해야 합니다.

Well, actually, in machine learning we typically define what it means for a model to be bad, called the cost or loss, and then try to minimize how bad it is.
자, 실제로, ML에서는 모델이 부적합하다는 것(비용 또는 손실)이 무엇을 의미하는 지를 일반적 으로 정의하며, 그 부적합을 최소화 하고자 합니다.

But the two are equivalent.
하지만 둘은 같습니다.

One very common, very nice cost function is "cross-entropy."
아주 보편적인, 아주 훌륭한 비용함수는 “교차-엔트로피(cross-entropy)” 입니다.

Surprisingly, cross-entropy arises from thinking about information compressing codes in information theory but it winds up being an important idea in lots of areas, from gambling to machine learning. It's defined:
놀랍게도, 교차-엔트로피는 정보 이론의 정보압축코드에 대한 생각에서 생겼지만, 많은 영역 (도박에서 ML까지)에서 중요한 아이디어가 되고 있습니다. 다음과 같이 정의됩니다:

Hy′(y)=−∑iy′ilog(yi)

 

Where y is our predicted probability distribution, and y′ is the true distribution (the one-hot vector we'll input).
y는 예측된 확률 분포이고, y′는 실제 분포(입력할 one-hot vector) 입니다.

In some rough sense, the cross-entropy is measuring how inefficient our predictions are for describing the truth.
대략적으로, 교차-엔트로피는 참(truth)을 서술함에 있어서 예측이 얼마나 비효율적인지를 측정 합니다.

Going into more detail about cross-entropy is beyond the scope of this tutorial, but it's well worth understanding.
교차-엔트로피에 관하여 더 상세히 배우는 것은 이 교본의 범위 밖이지만 이해할 가치는 있습니다.

To implement cross-entropy we need to first add a new placeholder to input the correct answers:
교차-엔트로피를 구현하려면 먼저 정확한 대답을 입력할 새로운 플레이스홀더를 추가해야 합니다.

 

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

 

Then we can implement the cross-entropy, −∑y′log(y):
그런 다음 교차-엔트로피, −∑y′log(y)를 구현할 수 있습니다:

 

               cross_entropy = -tf.reduce_sum(y_*tf.log(y))

 

First, tf.log computes the logarithm of each element of y.
먼저, tf.log는 y의 각 엘리먼트의 로그를 계산합니다.

Next, we multiply each element of y_ with the corresponding element of tf.log(y_).
다음으로, y_의 각 엘리먼트에, 상응하는 엘리먼트 tf.log(y_)를 곱합니다

Finally, tf.reduce_sum adds all the elements of the tensor.
마지막으로, tf.reduce_sum은 텐서의 모든 엘리먼트를 더합니다.

(Note that this isn't just the cross-entropy of the truth with a single prediction, but the sum of the cross-entropies for all 100 images we looked at. How well we are doing on 100 data points is a much better description of how good our model is than a single data point.)
(알아둘 것은 이 값은 단지 한 번의 예측에 대한 참의 교차-엔트로피가 아니라 모든 100개의 이미지들에 대한 교차- 엔트로피의 합이라는 점입니다. 100개의 데이터 포인트들에 대해 얼마나 잘 동작하는지 보는 것은 1개의 데이터 포인트에 대한 것 보다 훨씬 좋은 기술 방법입니다.)

Now that we know what we want our model to do, it's very easy to have TensorFlow train it to do so.
모델에게 시킬 일을 안다면, TensorFlow가 그걸 학습하도록 만드는 것은 정말 쉽습니다.

Because TensorFlow know the entire graph of your computations, it can automatically use the backpropagation algorithmto efficiently determine how your variables affect the cost you ask it minimize.
TensorFlow는 계산의 전체 그래프를 알고 있기 때문에, 자동적으로 역-전파(backpropagation) 알고리즘을 이용하여 비용 최소화에 어떤 변수가 얼마나 영향을 주는지를 효율적으로 계산합니다.

Then it can apply your choice of optimization algorithm to modify the variables and reduce the cost.
그런 다음 변수를 수정하고 원가를 줄이기 위한 알고리즘 최적화를 위한 선택을 적용할 수 있습니다.

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

In this case, we ask TensorFlow to minimize cross_entropy using the gradient descent algorithm with a learning rate of 0.01.
이 경우, 0.01의 학습률을 가진 내리막 기울기 알고리즘을 사용하여, TensorFlow에게 교차_엔트로피를 최소화하도록 요구 합니다.

Gradient descent is a simple procedure, where TensorFlow simply shifts each variable a little bit in the direction that reduces the cost.
내리막 기울기는 단순한 절차인데, 텐서플로는 비용을 줄이는 방향으로 각 변수를 약간씩 이동 시킵니다.

But TensorFlow also provides many other optimization algorithms: using one is as simple as tweaking one line.
하지만 TensorFlow는 많은 다른 최적화 알고리즘도 제공합니다: 그 중 하나를 이용하는 것은 한 줄을 살짝 수정하는 것처럼 간단합니다.

What TensorFlow actually does here, behind the scenes, is it adds new operations to your graph which implement backpropagation and gradient descent.
실제로 여기서 TensorFlow가 하는 것은, 뒤에서, 역-전파(backpropagation) 및 내리막 기울기(gradient descent)를 구현하는 새로운 ops를 그래프에 추가하는 것입니다.

Then it gives you back a single operation which, when run, will do a step of gradient descent training, slightly tweaking your variables to reduce the cost.
그리고 실행할 경우, 비용을 줄이기 위해 변수들을 살짝 미세조정하는 내리막 기울기 훈련 단계를 실행할, 단일 op를 돌려줍니다.

Now we have our model set up to train.
이제 훈련하기 위한 모델을 셋업하였습니다.

One last thing before we launch it, we have to add an operation to initialize the variables we created:
훈련 시작 전의 마지막 한 가지 일은, 생성한 변수를 초기화하는 op를 추가해야 하는 일입니다:

               init = tf.initialize_all_variables()

 

We can now launch the model in a Session, and run the operation that initializes the variables:
이제 세션에서 모델을 가동시킬 수 있고, 변수를 초기화하는 op를 가동시킬 수 있습니다:

 

               sess = tf.Session()

          sess.run(init)

Let's train -- we'll run the training step 1000 times!
훈련시킵시다 – 훈련 단계를 1000번 가동시킬 것입니다!

for i in range(1000):

  batch_xs, batch_ys = mnist.train.next_batch(100)

  sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

 

Each step of the loop, we get a "batch" of one hundred random data points from our training set.
각 반복 단계마다, 훈련용 세트로부터 100개의 무작위 데이터포인트의 “batch”를 가져옵니다.

We run train_step feeding in the batches data to replace the placeholders.
플레이스홀더를 대체하기 위하여 일괄처리(batches) 데이터로 train_step 피딩을 실행합니다.

Using small batches of random data is called stochastic training -- in this case, stochastic gradient descent.
작은 무작위 데이터 뱃치(batches)를 사용하는 것을 확률(stochastic) 훈련 이라고 하는데, 이 경우에는 확률 내리막 기울기(stochastic gradient descent) 라고 합니다.

Ideally, we'd like to use all our data for every step of training because that would give us a better sense of what we should be doing, but that's expensive.
이상적으로, 모든 데이터를 사용하면 해야 할 것의 보다 나은 의미를 주기 때문에, 훈련의 매 단계에서 모든 데이터를 사용해야 하지만 비용이 많이 소요됩니다.

So, instead, we use a different subset every time. Doing this is cheap and has much of the same benefit.
그래서, 대신, 매번 서로 다른 서브셋을 사용합니다. 이렇게 하면 적은 비용으로 같은 효과를 많이 볼 수 있습니다.

Evaluating Our Model 모델 평가하기

How well does our model do?
모델은 잘 작동하나요?

Well, first let's figure out where we predicted the correct label. 
자, 먼저 정확한 레이블을 어디서 예측했는지 알아봅니다.

tf.argmax is an extremely useful function which gives you the index of the highest entry in a tensor along some axis.
tf.argmax는, 일부 축을 따라 텐서 안에서 최고 entry의 인덱스를 주는, 아주 유용한 함수입니다.

For example, tf.argmax(y,1) is the label our model thinks is most likely for each input, while tf.argmax(y_,1) is the correct label.
예를 들어, tf.argmax(y_,1)이 정확한 레이블일 때, tf.argmax(y,1)은 모델이 각 입력에 대하여 가장 적합하다고 생각하는, 레이블입니다.

We can use tf.equal to check if our prediction matches the truth.
예측(prediction)이 사실(truth)과 일치하는지를 체크하기 위하여 tf.equal을 사용할 수 있습니다.

               correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

 

That gives us a list of booleans.
여기서 Booleans 목록을 얻게 됩니다.

To determine what fraction are correct, we cast to floating point numbers and then take the mean.
얼마의 비율로 맞았는지 확인하려면, 부동 소숫점 숫자로 캐스팅한 후 평균값을 구하면 됩니다.

For example, [True, False, True, True] would become [1,0,1,1] which would become 0.75.
예를 들어, [True, False, True, True]는 0.75가 될 [1,0,1,1]이 될 것입니다.

 

               accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

Finally, we ask for our accuracy on our test data.
최종적으로, 테스트 데이터에 대한 정확도를 요구합니다.

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

This should be about 91%.
이것은 약 91% 입니다.

Is that good?
좋은가요?

Well, not really.
그렇지 않지요

In fact, it's pretty bad.
사실 아주 나쁩니다.

This is because we're using a very simple model.
그 이유는 아주 간단한 모델을 사용하고 있기 때문입니다.

With some small changes, we can get to 97%.
몇 가지를 바꾸면 97%를 얻을 수 있습니다.

The best models can get to over 99.7% accuracy! (For more information, have a look at this list of results.)
최적 모델은 99.7% 정확도를 얻을 수 있습니다! (더 많은 정보를 위해서는 결과 목록을 보세요.)

What matters is that we learned from this model.
중요한 것은 이 모델에서 우리가 배운 것입니다.

Still, if you're feeling a bit down about these results, check out the next tutorial where we do a lot better, and learn how to build more sophisticated models using TensorFlow!
여전히 이들 결과에 대하여 약간의 미진함이 느껴지면 다음 교본을 체크하시고, TensorFlow를 이용해서 어떻게 더 정교한 모델을 만드는지 배워봅시다!

위의 예제를 한 번에 실행한 결과를 MNIST 예제 샌드박스 로 확인해 봅시다.

 

THE MNIST DATABASE

of handwritten digits

Yann LeCun, Courant Institute, NYU

Corinna Cortes, Google Labs, New York

Christopher J.C. Burges, Microsoft Research, Redmond

 

The MNIST database of handwritten digits, available from this page, has a training set of 60,000 examples, and a test set of 10,000 examples.
이 페이지에서 사용할 수 있는 손으로 쓴 숫자의 DB인 MNIST DB는 6만개의 훈련용 세트와 1만개의 테스트 세트를 갖고 있습니다.
It is a subset of a larger set available from NIST.
NIST로부터 사용 가능한 보다 큰 세트의 서브셋 입니다.
The digits have been size-normalized and centered in a fixed-size image.
숫자은 사이즈-정규화되었으며 고정된-사이즈 이미지로 중심 되었습니다.

It is a good database for people who want to try learning techniques and pattern recognition methods on real-world data while spending minimal efforts on preprocessing and formatting.
전처리(preprocessing) 및 포맷팅(formatting)에 최소한의 노력을 들이면서, 현실-세계 데이터 위에서 기술과 패턴 인식 방법을 배우고자 하는 사람들을 위한 좋은 DB 입니다.

Four files are available on this site:

train-images-idx3-ubyte.gz:  training set images (9912422 bytes)
train-labels-idx1-ubyte.gz:  training set labels (28881 bytes)
t10k-images-idx3-ubyte.gz:   test set images (1648877 bytes)
t10k-labels-idx1-ubyte.gz:   test set labels (4542 bytes)