TensorFlow의 고급 기계 학습 API (tf.estimator)를 사용하면 다양한 기계 학습 모델을 쉽게 구성, 교육 및 평가할 수 있습니다. 이 튜토리얼에서는 tf.estimator를 사용하여 신경 네트워크 분류기를 만들고 Iris 데이터 세트
(Iris data set )에서이를 학습하여 sepal / petal geometry를 기반으로 꽃 종을 예측합니다. 다음 다섯 단계를 수행하는 코드를 작성합니다.

1.Iris 교육 / 테스트 데이터가 포함 된 CSV를 TensorFlow Dataset에로드하십시오.

2.신경 네트워크 분류 자 ​​생성

3.교육 데이터를 사용하여 모델 교육

4.모델의 정확성 평가

5.새 샘플 분류

참고 :이 자습서를 시작하기 전에 TensorFlow를 컴퓨터에 설치해야합니다.

Complete Neural Network Source Code(완전한 신경 네트워크 소스 코드)

다음은 신경망 분류 자의 전체 코드입니다.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import urllib

import numpy as np
import tensorflow as tf

# Data sets
IRIS_TRAINING
= "iris_training.csv"
IRIS_TRAINING_URL
= "http://download.tensorflow.org/data/iris_training.csv"

IRIS_TEST
= "iris_test.csv"
IRIS_TEST_URL
= "http://download.tensorflow.org/data/iris_test.csv"

def main():
 
# If the training and test sets aren't stored locally, download them.
 
if not os.path.exists(IRIS_TRAINING):
    raw
= urllib.urlopen(IRIS_TRAINING_URL).read()
   
with open(IRIS_TRAINING, "w") as f:
      f
.write(raw)

 
if not os.path.exists(IRIS_TEST):
    raw
= urllib.urlopen(IRIS_TEST_URL).read()
   
with open(IRIS_TEST, "w") as f:
      f
.write(raw)

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

 
# Specify that all features have real-value data
  feature_columns
= [tf.feature_column.numeric_column("x", shape=[4])]

 
# Build 3 layer DNN with 10, 20, 10 units respectively.
  classifier
= tf.estimator.DNNClassifier(feature_columns=feature_columns,
                                          hidden_units
=[10, 20, 10],
                                          n_classes
=3,
                                          model_dir
="/tmp/iris_model")
 
# Define the training inputs
  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)

 
# Train model.
  classifier
.train(input_fn=train_input_fn, steps=2000)

 
# Define the test inputs
  test_input_fn
= tf.estimator.inputs.numpy_input_fn(
      x
={"x": np.array(test_set.data)},
      y
=np.array(test_set.target),
      num_epochs
=1,
      shuffle
=False)

 
# Evaluate accuracy.
  accuracy_score
= classifier.evaluate(input_fn=test_input_fn)["accuracy"]

 
print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

 
# Classify two new flower samples.
  new_samples
= np.array(
     
[[6.4, 3.2, 4.5, 1.5],
       
[5.8, 3.1, 5.0, 1.7]], dtype=np.float32)
  predict_input_fn
= tf.estimator.inputs.numpy_input_fn(
      x
={"x": new_samples},
      num_epochs
=1,
      shuffle
=False)

  predictions
= list(classifier.predict(input_fn=predict_input_fn))
  predicted_classes
= [p["classes"] for p in predictions]

 
print(
     
"New Samples, Class Predictions:    {}\n"
     
.format(predicted_classes))

if __name__ == "__main__":
    main
()

다음 섹션에서는 코드를 자세히 설명합니다.

Load the Iris CSV data to TensorFlow / Iris CSV데이터를 TensorFlow에 로드.

Iris 데이터 세트에는 Iris setosa, Iris virginica 및 Iris versicolor와 같은 세 가지 관련된 Iris 종 각각에서 추출한 50 개의 샘플로 구성된 150 행의 데이터가 들어 있습니다.

Petal geometry compared for three iris species: Iris setosa, Iris virginica, and Iris versicolor

왼쪽에서 오른쪽으로 Iris setosa (Radomil, CC BY-SA 3.0), Iris versicolor (Dlanglois, CC BY-SA 3.0), Iris virginica (Frank Mayfield, CC BY-SA 2.0) 입니다.

각 행은 각 꽃 샘플에 대한 다음 데이터를 포함합니다 : 꽃잎 길이, 꽃잎 너비, 꽃잎 길이, 꽃잎 너비 및 꽃 종. 꽃 종은 정수로 표시되며, 0은 아이리스 세토 사, 1은 아이리스 versicolor, 2는 아이리스 virginica를 나타냅니다.

Sepal LengthSepal WidthPetal LengthPetal WidthSpecies
5.13.51.40.20
4.93.01.40.20
4.73.21.30.20
7.03.24.71.41
6.43.24.51.51
6.93.14.91.51
6.53.05.22.02
6.23.45.42.32
5.93.05.11.82

이 자습서에서는 아이리스 (Iris) 데이터가 무작위로 분리되어 두 개의 별도 CSV로 나뉩니다.

시작하려면 먼저 필요한 모든 모듈을 가져오고 데이터 세트를 다운로드하고 저장할 위치를 정의하십시오.

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

import os
import urllib

import tensorflow as tf
import numpy as np

IRIS_TRAINING
= "iris_training.csv"
IRIS_TRAINING_URL
= "http://download.tensorflow.org/data/iris_training.csv"

IRIS_TEST
= "iris_test.csv"
IRIS_TEST_URL
= "http://download.tensorflow.org/data/iris_test.csv"

그런 다음 교육 및 테스트 세트가 로컬에 저장되어 있지 않으면 다운로드하십시오.

if not os.path.exists(IRIS_TRAINING):
  raw
= urllib.urlopen(IRIS_TRAINING_URL).read()
 
with open(IRIS_TRAINING,'w') as f:
    f
.write(raw)

if not os.path.exists(IRIS_TEST):
  raw
= urllib.urlopen(IRIS_TEST_URL).read()
 
with open(IRIS_TEST,'w') as f:
    f
.write(raw)

다음으로 learn.datasets.base의 load_csv_with_header () 메소드를 사용하여 교육 및 테스트 세트를 데이터 세트에로드하십시오. load_csv_with_header () 메소드는 세 가지 필수 인수를 취합니다.

filename 파일 경로를 CSV 파일로 가져옵니다.

target_dtype - 데이터 세트의 대상 값에 numpy 데이터 유형을 사용합니다.

features_dtype : 데이터 집합의 특징 값에 numpy 데이터 유형을 사용합니다.

여기에서 목표 (모델을 예측하기 위해 훈련하는 값)는 0-2의 정수로 꽃의 종류이므로 적절한 numpy 데이터 유형은 np.int입니다.

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

tf.contrib.learn의 데이터 세트는 튜플로 명명됩니다. 데이터 및 대상 필드를 통해 기능 데이터 및 대상 값에 액세스 할 수 있습니다. 여기서, training_set.data 및 training_set.target은 각각 학습 세트에 대한 피쳐 데이터 및 목표 값을 포함하고, test_set.data 및 test_set.target은 피쳐 데이터 및 테스트 세트에 대한 목표 값을 포함한다.

나중에 "DNNClassifier를 Iris 교육 데이터에 맞추기"에서 training_set.data 및 training_set.target을 사용하여 모델을 교육하고 "모델 정확성 평가"에서 test_set.data 및 test_set.target을 사용합니다. . 하지만 먼저 다음 섹션에서 모델을 구성 해 보겠습니다.

Construct a Deep Neural Network Classifier

tf.estimator는 Estimator라고하는 미리 정의 된 다양한 모델을 제공하며, "즉시"사용하여 데이터에 대한 교육 및 평가 작업을 실행할 수 있습니다. 여기서, 아이리스 (Iris) 데이터에 맞게 딥 뉴럴 네트워크 분류 자 모델을 구성 할 것입니다. tf.estimator를 사용하면 몇 줄의 코드로 tf.estimator.DNNClassifier를 인스턴스화 할 수 있습니다.

# Specify that all features have real-value data
feature_columns
= [tf.feature_column.numeric_column("x", shape=[4])]

# Build 3 layer DNN with 10, 20, 10 units respectively.
classifier
= tf.estimator.DNNClassifier(feature_columns=feature_columns,
                                        hidden_units
=[10, 20, 10],
                                        n_classes
=3,
                                        model_dir
="/tmp/iris_model")

위의 코드는 데이터 집합의 지형지 물에 대한 데이터 형식을 지정하는 모델의 지형지 물 열을 먼저 정의합니다. 모든 기능 데이터는 연속적이므로 tf.feature_column.numeric_column은 기능 컬럼을 구성하는 데 사용할 수있는 적절한 함수입니다. 데이터 세트에는 세 가지 기능 (세퍼리 폭, 세팔 높이, 꽃잎 너비 및 꽃잎 높이)이 있으므로 모든 데이터를 저장하려면 모양을 [4]로 설정해야합니다.


그런 다음 코드는 다음 인수를 사용하여 DNNClassifier 모델을 만듭니다.

1. feature_columns = feature_columns. 위에 정의 된 기능 열 집합입니다.

2. hidden_units = [10, 20, 10]. 10, 20 및 10 개의 뉴런을 포함하는 3 개의 숨겨진 레이어입니다.

3. n_classes = 3. 3 개의 아이리스 종을 나타내는 3 개의 대상 클래스입니다.

4. model_dir = / tmp / iris_model. 모델 교육 중에 TensorFlow가 검사 점 데이터와 TensorBoard 요약을 저장할 디렉토리입니다.

Describe the training input pipeline

tf.estimator API는 모델의 데이터를 생성하는 TensorFlow 조작을 작성하는 입력 기능을 사용합니다. tf.estimator.inputs.numpy_input_fn을 사용하여 입력 파이프 라인을 생성 할 수 있습니다.

# Define the training inputs
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)

Fit the DNNClassifier to the Iris Training Data

이제 DNN 분류기 모델을 구성 했으므로 train 메서드를 사용하여 Iris 교육 데이터에 맞출 수 있습니다. train_input_fn을 input_fn으로 전달하고 훈련 단계 수를 입력하십시오 (here, 2000).

# Train model.
classifier
.train(input_fn=train_input_fn, steps=2000)

모델의 상태는 분류 기준에 유지되므로 원하는 경우 반복적으로 학습 할 수 있습니다. 예를 들어, 위의 내용은 다음과 같습니다.

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

그러나 기차를 타는 동안 모델을 추적하려는 경우 TensorFlow SessionRunHook을 사용하여 로깅 작업을 수행하는 것이 좋습니다.


Evaluate Model Accuracy / 모델 정확도 평가


Iris 교육 데이터에서 DNNClassifier 모델을 교육했습니다. 이제 평가 방법을 사용하여 아이리스 테스트 데이터에서 정확성을 확인할 수 있습니다. train과 마찬가지로 evaluate은 입력 파이프 라인을 만드는 입력 함수를 사용합니다. evaluate은 평가 결과로 dicts를 반환합니다. 다음 코드는 Iris 테스트 data-test_set.data와 test_set.target을 전달하여 결과의 정확성을 평가하고 인쇄합니다.

# Define the test inputs
test_input_fn
= tf.estimator.inputs.numpy_input_fn(
    x
={"x": np.array(test_set.data)},
    y
=np.array(test_set.target),
    num_epochs
=1,
    shuffle
=False)

# Evaluate accuracy.
accuracy_score
= classifier.evaluate(input_fn=test_input_fn)["accuracy"]

print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

참고 : numpy_input_fn에 대한 num_epochs = 1 인수가 중요합니다. test_input_fn은 데이터를 한 번 반복 한 다음 OutOfRangeError를 발생시킵니다. 이 오류는 분류 작업이 평가를 중단하도록 신호를 보내므로 입력을 한 번 평가합니다.

전체 스크립트를 실행하면 다음과 유사한 내용이 인쇄됩니다.

Test Accuracy: 0.966667

정확도 결과는 약간 다를 수 있지만 90 % 이상이어야합니다. 상대적으로 작은 데이터 세트는 나쁘지 않습니다!


새 샘플 분류


견적 기의 predict () 메소드를 사용하여 새 견본을 분류하십시오. 예를 들어,이 두 가지 새로운 꽃 샘플이 있다고 가정 해보십시오.

Sepal LengthSepal WidthPetal LengthPetal Width
6.43.24.51.5
5.83.15.01.7

predict () 메서드를 사용하여 해당 종을 예측할 수 있습니다. predict는 목록으로 쉽게 변환 될 수있는 dicts 생성자를 반환합니다. 다음 코드는 클래스 예측을 검색하고 인쇄합니다.

# Classify two new flower samples.
new_samples
= np.array(
   
[[6.4, 3.2, 4.5, 1.5],
     
[5.8, 3.1, 5.0, 1.7]], dtype=np.float32)
predict_input_fn
= tf.estimator.inputs.numpy_input_fn(
    x
={"x": new_samples},
    num_epochs
=1,
    shuffle
=False)

predictions
= list(classifier.predict(input_fn=predict_input_fn))
predicted_classes
= [p["classes"] for p in predictions]

print(
   
"New Samples, Class Predictions:    {}\n"
   
.format(predicted_classes))

결과는 다음과 같습니다.

New Samples, Class Predictions:    [1 2]

따라서 모델은 첫 번째 샘플이 Iris versicolor이고 두 번째 샘플은 Iris virginica라고 예측합니다.


추가 리소스


tf.estimator를 사용하여 선형 모델을 만드는 방법에 대한 자세한 내용은 TensorFlow를 사용하는 대규모 선형 모델을 참조하십시오.

tf.estimator API를 사용하여 사용자의 Estimator를 빌드하려면 tf.estimator에서 Estimator 만들기를 확인하십시오.

브라우저에서 신경망 모델링 및 시각화를 실험하려면 Deep Playground를 확인하십시오.

신경 네트워크에 대한 고급 자습서는 길쌈 신경 네트워크 및 순환 신경 네트워크를 참조하십시오.



++++++

csv 파일을 원하는 데이터를 입력하면 간단히 판단하는 프로그램 및 그래프를 얻을 수 있습니다.

일정한 데이터를 가지고 판별하는 그래프 및 수식을 만들지 않고 원하는 것을 만들 수 있습니다.

글보다는 csv파일을 원하는 것으로 직접 수정하셔서 활용해보시면 더 빠른 이해를 하실 수 있습니다.


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



+ 지난 텐서플로우 게시글에 이어서 튜토리얼 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))



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

TensorBoard final model visualization



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가 그래프를 시각화하는 방법을 보여주는 스크린 샷입니다.

TensorBoard screenshot

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


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

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:

TensorBoard screenshot


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

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:

TensorBoard screenshot

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

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 인 것인 것처럼 간단한 계산식으로 했지만, 나중에 갈 수록 소수도 나오고 손실율도 커서 더 정확한 모듈을 만들기 위한 작업을 하겠습니다.


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



+ Recent posts