Building Input Functions with tf.estimator

import numpy as np

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

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

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

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

def my_input_fn():

    # Preprocess your data here...

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

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

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

feature_cols

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

labels

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

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

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

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

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

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

dense_shape

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

indices

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

values

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

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

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

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

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

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

모델에 input_fn 데이터 전달

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

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

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

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

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

def my_input_fn(data_set):
  ...

def my_input_fn_training_set():
  return my_input_fn(training_set)

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

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

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

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

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

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

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

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

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

import pandas as pd

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

import numpy as np

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

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

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

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

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

설정

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

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

주택 데이터 가져 오기

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

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

import itertools

import pandas as pd
import tensorflow as tf

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

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

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

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

FeatureColumns 정의 및 회귀 변수 만들기

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

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

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

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

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

input_fn 빌드하기

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

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

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

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

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

회귀 자 훈련

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

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

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

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

모델 평가

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

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

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

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

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

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

예측하기

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

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

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

Predictions: [ 33.30348587  17.04452896  22.56370163  34.74345398  14.55953979
  19.58005714]

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 행의 데이터가 들어 있습니다.

왼쪽에서 오른쪽으로 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를 나타냅니다.

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

• A training set of 120 samples (iris_training.csv)
• A test set of 30 samples (iris_test.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 () 메소드를 사용하여 새 견본을 분류하십시오. 예를 들어,이 두 가지 새로운 꽃 샘플이 있다고 가정 해보십시오.

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파일을 원하는 것으로 직접 수정하셔서 활용해보시면 더 빠른 이해를 하실 수 있습니다.