마이크로 프로세서란 무엇입니까?

마이크로 프로세서는 컴퓨터 중앙 처리 장치(CPU)의 핵심 기능을 통합한 집적 회로(IC)이다. 

그것은 프로그램 가능한 다목적 실리콘 칩으로서, 클록 구동 방식이며, 레지스터 기반이며, 

바이너리 데이터를 입력으로 받아들이고 메모리에 저장된 지침에 따라 처리한 후 출력을 제공한다.

마이크로 프로세서는 어떻게 작동합니까?

프로세서는 기본적으로 

ALU(ArithmeticalUnit), ControlUnit(제어 장치)및 RegisterArray(어레이 등록)로

 구성된 컴퓨터의 두뇌입니다. 

이름이 ALU를 나타내듯이 입력 장치 또는 메모리에서 수신한 데이터에 대해 

모든 산술 및 논리 연산을 수행합니다. 

레지스터 어레이는 데이터 처리를 위한 임시 고속 액세스 메모리 위치로 작동하는 

축전지(A), B, C, D등과 같은 일련의 레지스터로 구성됩니다. 

이름에서 알 수 있듯이 컨트롤 유닛은 시스템 전체에서 명령 및 데이터 흐름을 제어합니다.

기본적으로 마이크로 프로세서는 입력 장치에서 입력을 취하여 메모리에 주어진 지시에 따라 처리하고 

출력을 생성합니다.

마이크로 프로세서의 장점
1. 저비용

마이크로 프로세서는 집적 회로 기술로 저렴한 비용으로 이용할 수 있습니다. 

그것은 컴퓨터 시스템의 비용을 줄일 것이다.

2. 고속

마이크로 프로세서 칩은 관련 기술 덕분에 매우 빠른 속도로 작동할 수 있습니다. 

그것은 초당 수백만개의 명령을 실행할 수 있다.

3. 작은 사이즈

매우 큰 규모와 초대형 통합 기술로 인해, 마이크로 프로세서는 매우 적은 공간에서 제작됩니다. 

그러면 전체 컴퓨터 시스템의 크기가 줄어듭니다.

4. 다재다능한

마이크로 프로세서는 용도가 매우 다양하며, 동일한 칩은 프로그램을 간단히 변경함으로써 

많은 용도에 사용될 수 있습니다 (메모리에 저장된 지침).

5. 저전력 소비

마이크로 프로세서는 일반적으로 산화 금속 반도체 기술을 사용하여 제조되며, 

이 기술에서는 MOSF가 포화 상태에서 작동하고 차단 모드로 작동합니다. 

그래서 다른 것들에 비해 전력 소비량이 매우 낮습니다.

6. 낮은 발열량

진공 튜브 장치에 비해 반도체 장치는 그렇게 많은 열을 방출하지 않는다.

7. 믿을 수 있는

마이크로 프로세서는 매우 신뢰할 수 있으며, 고장률은 반도체 기술이 사용됨에 따라 매우 낮다.

8. 휴대용의

마이크로 프로세서로 만들어진 장치나 컴퓨터 시스템은 작은 크기와 

낮은 전력 소비 때문에 휴대가 가능하다.

마이크로 프로세서에 사용되는 공통 용어

여기 마이크로 프로세서 분야에서 사용될 몇가지 공통 용어가 있습니다.

버스

버스는 데이터를 전송하거나, 정보를 마이크로 프로세서의 다른 요소에 

주소를 지정하거나 제어하기 위한 도체 집합입니다. 

일반적으로 마이크로 프로세서는 데이터 버스, 제어 버스 및 주소 버스의 세가지 유형의 버스를 가집니다. 

8비트 프로세서가 8비트 광역 버스를 사용합니다.

명령 집합

명령 집합은 마이크로 프로세서가 이해할 수 있는 명령 그룹입니다. 

따라서 명령 집합은 하드웨어와 소프트웨어(프로그램)간의 인터페이스입니다. 

명령어는 프로세서가 데이터 처리를 위해 관련 트랜지스터를 전환하도록 명령합니다. 

예를 들어. ADDA, B;는 레지스터 A와 B에 저장된 두개의 번호를 추가하는 데 사용됩니다.

단어 길이

워드 길이는 프로세서의 내부 데이터 버스에 있는 비트 수이거나 

프로세서가 한번에 처리할 수 있는 비트 수입니다. 

예를 들어. 8비트 프로세서에는 8비트 데이터 버스, 8비트 레지스터가 있으며 한번에 8비트 처리를 수행합니다. 

더 높은 비트(32비트, 16비트)작업을 수행할 경우 일련의 8비트 작업으로 분할됩니다.

캐시 메모리

캐시 메모리는 프로세서에 통합된 랜덤 액세스 메모리입니다. 따라서 프로세서는 일반 RAM보다 캐시 메모리의 데이터에 더 빨리 액세스 할 수 있습니다. CPU메모리라고도 합니다. 캐시 메모리는 작업 중에 소프트웨어 또는 프로그램에서 자주 참조하는 데이터 또는 지침을 저장하는 데 사용됩니다. 그래서 그것은 수술의 전반적인 속도를 증가시킬 것이다.

클럭 속도

마이크로 프로세서는 클럭 신호를 사용하여 명령이 실행되는 속도를 제어하고, 다른 내부 구성 요소를 동기화하고, 명령 간의 데이터 전송을 제어합니다. 클럭 속도는 마이크로 프로세서가 명령을 실행하는 속도를 말합니다. 일반적으로 헤르츠로 측정되며 MHz(메가 헤르츠), GHz(GHz)등으로 표현됩니다.

마이크로 프로세서 분류

단어 길이 기준

당신이 위의 단어 길이에 대해 읽기 바랍니다. 따라서 프로세서의 단어 길이를 기준으로 8비트, 16비트, 32비트 및 64비트 프로세서를 사용할 수 있습니다.

RISC–감소된 지침 세트 컴퓨터

RISC는 마이크로 프로세서 아키텍처의 한 종류로, 다른 곳에서 볼 수 있는 보다 

전문화된 명령어 세트가 아닌 소규모의 일반적인 목적과 고도로 최적화된 명령 세트를 사용합니다. 

RISC는 상대적인 아키텍처인 CISC에 비해 높은 성능을 제공합니다(아래 참조). 

프로세서에서 각 명령을 실행하려면 데이터를 로드하고 처리하기 위해 특수 회로가 필요합니다. 

그래서 명령을 줄이면, 프로세서는 간단한 회로를 사용하고 더 빠르게 작동할 것입니다.

간단한 명령 집합

더 큰 프로그램

많은 수의 레지스터로 구성됨

간단한 프로세서 회로( 적은 수의 트랜지스터)

추가 RAM사용

고정 길이 지침

간단한 주소 지정 모드

일반적으로 하나의 명령을 실행하기 위한 고정된 클럭 사이클 수

CISC– 복잡한 지침 세트 컴퓨터

CISC는 RISC의 상대적인 마이크로 프로세서 아키텍처입니다.

 프로그램별 명령 수를 줄이기 위해 명령별 사이클 수를 무시합니다. 

따라서 하드웨어에 직접 복잡한 지침이 적용되므로 프로세서가 복잡해지고 작동 속도가 느려집니다.

이 아키텍처는 실제로 프로그램 길이를 줄여 메모리 비용을 줄이도록 설계되었습니다.

복잡한 명령 집합

소규모 프로그램

레지스터 수 감소

복잡한 프로세서 회로(더 많은 수의 트랜지스터)

적은 RAM사용량

가변 길이 지침

다양한 주소 지정 모드

각 지침에 대한 클럭 사이클의 가변 수

특수 용도 프로세서

일부 특정 기능을 처리하도록 설계된 프로세서도 있습니다.

DSP–디지털 신호 처리기

프로세서–주 프로세서와 함께 사용되는 프로세서(8087 math-프로세서와 8086 사용)

입력/출력 프로세서

트랜지스터 컴퓨터:고유의 로컬 메모리를 가진 마이크로 프로세서

ex) 인텔 4004–최초의 마이크로 프로세서

인텔 8085

인텔 8086

인텔 펜티엄 4

인텔 코어 i7

AMD애틀론

출처 : https://electrosome.com/microprocessor/#Examples

TensorBoard: Visualizing Learning

(TensorBoard : 학습 시각화)

기계학습이 어떻게 하는지 시각적으로 볼 수 있는 라이브러리입니다.

이 자습서는 간단한 TensorBoard 사용법을 배우기위한 것입니다. 다른 리소스도 있습니다. TensorBoard의 GitHub(TensorBoard's GitHub)에는 팁 및 트릭 및 디버깅 정보를
포함하여 TensorBoard 사용에 대한 더 많은 정보가 있습니다.

Serializing the data

데이터 직렬화

TensorBoard는 TensorFlow를 실행할 때 생성 할 수있는 요약 데이터가 포함 된 TensorFlow 이벤트 파일을 읽음으로써 작동합니다. 다음은 TensorBoard 내의 요약 데이터에 대한 일반적인 수명주기입니다.

먼저 요약 데이터를 수집 할 TensorFlow 그래프를 만들고 요약 작업으로 주석(summary operations)을 추가 할 노드를 결정합니다.

예를 들어, MNIST 자리를 인식 할 수있는 길쌈 신경 네트워크를 학습한다고 가정합니다. 학습 속도가 시간에 따라 어떻게 변하는 지, 그리고 목적 함수가 어떻게 변하는지를 기록하고 싶습니다. 학습 속도와 손실을 각각 출력하는 노드에 tf.summary.scalar op를 연결하여이를 수집합니다. 그런 다음 각 스칼라 요약에 '학습률'또는 '손실 함수'와 같은 의미있는 태그를 지정합니다.

특정 레이어에서 나오는 활성화 분포 또는 그라데이션이나 가중치의 분포를 시각화하고 싶을 수도 있습니다. tf.summary.histogram ops를 그라디언트 출력과 가중치를 유지하는 변수에 각각 첨부하여이 데이터를 수집합니다.

사용 가능한 모든 요약 작업에 대한 자세한 내용은 요약 작업에 대한 문서를 확인하십시오.

TensorFlow의 작업은 실행하기 전까지는 아무 것도하지 않거나 출력에 의존하는 연산을 수행합니다. 방금 작성한 요약 노드는 그래프의 주변 장치입니다. 현재 실행중인 작업 단위는 모두 해당 노드에 의존하지 않습니다. 따라서 요약을 생성하려면 이러한 모든 요약 노드를 실행해야합니다. 손으로 직접 관리하는 것은 지루할 수 있으므로 tf.summary.merge_all을 사용하여 모든 요약 데이터를 생성하는 단일 op로 결합하십시오.

그런 다음 병합 된 요약 연산을 실행하면 주어진 단계에서 모든 요약 데이터가있는 직렬화 된 요약 protobuf 객체가 생성됩니다. 마지막으로이 요약 데이터를 디스크에 기록하려면 summary protobuf를 tf.summary.FileWriter에 전달하십시오.

FileWriter는 생성자에서 logdir을 사용합니다.이 logdir은 모든 이벤트가 기록되는 디렉토리입니다. 또한 FileWriter는 선택적으로 생성자에서 Graph를 가져올 수 있습니다. Graph 객체를 받으면 TensorBoard는 텐서 모양 정보와 함께 그래프를 시각화합니다. 이렇게하면 그래프를 통해 흐르는 것이 훨씬 잘 전달됩니다 : Tensor 모양 정보( Tensor shape information)를 참조하십시오.

이제 그래프를 수정하고 FileWriter를 만들었으므로 네트워크를 시작할 준비가되었습니다! 원하는 경우 매 단계마다 병합 된 요약 작업을 실행하고 많은 양의 교육 데이터를 기록 할 수 있습니다. 그것은 당신이 필요로하는 것보다 더 많은 데이터 일 것 같다. 대신 병합 된 요약 연산을 n 단계마다 실행하는 것을 고려하십시오.

아래의 코드 예제는 간단한 MNIST 튜토리얼을 수정 한 것으로서 몇 가지 요약 작업을 추가하고 10 단계마다 실행합니다. 이것을 실행하고 tensorboard --logdir = / tmp / tensorflow / mnist를 실행하면 훈련 도중 가중치 나 정확도가 어떻게 변화했는지와 같은 통계를 시각화 할 수 있습니다. 아래의 코드는 발췌 한 것입니다. 전체 소스가 여기(here)에 있습니다.

def variable_summaries(var):
  """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
  with tf.name_scope('summaries'):
    mean = tf.reduce_mean(var)
    tf.summary.scalar('mean', mean)
    with tf.name_scope('stddev'):
      stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
    tf.summary.scalar('stddev', stddev)
    tf.summary.scalar('max', tf.reduce_max(var))
    tf.summary.scalar('min', tf.reduce_min(var))
    tf.summary.histogram('histogram', var)

def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
  """Reusable code for making a simple neural net layer.

  It does a matrix multiply, bias add, and then uses relu to nonlinearize.
  It also sets up name scoping so that the resultant graph is easy to read,
  and adds a number of summary ops.
  """
  # Adding a name scope ensures logical grouping of the layers in the graph.
  with tf.name_scope(layer_name):
    # This Variable will hold the state of the weights for the layer
    with tf.name_scope('weights'):
      weights = weight_variable([input_dim, output_dim])
      variable_summaries(weights)
    with tf.name_scope('biases'):
      biases = bias_variable([output_dim])
      variable_summaries(biases)
    with tf.name_scope('Wx_plus_b'):
      preactivate = tf.matmul(input_tensor, weights) + biases
      tf.summary.histogram('pre_activations', preactivate)
    activations = act(preactivate, name='activation')
    tf.summary.histogram('activations', activations)
    return activations

hidden1 = nn_layer(x, 784, 500, 'layer1')

with tf.name_scope('dropout'):
  keep_prob = tf.placeholder(tf.float32)
  tf.summary.scalar('dropout_keep_probability', keep_prob)
  dropped = tf.nn.dropout(hidden1, keep_prob)

# Do not apply softmax activation yet, see below.
y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)

with tf.name_scope('cross_entropy'):
  # The raw formulation of cross-entropy,
  #
  # tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.softmax(y)),
  #                               reduction_indices=[1]))
  #
  # can be numerically unstable.
  #
  # So here we use tf.nn.softmax_cross_entropy_with_logits on the
  # raw outputs of the nn_layer above, and then average across
  # the batch.
  diff = tf.nn.softmax_cross_entropy_with_logits(targets=y_, logits=y)
  with tf.name_scope('total'):
    cross_entropy = tf.reduce_mean(diff)
tf.summary.scalar('cross_entropy', cross_entropy)

with tf.name_scope('train'):
  train_step = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(
      cross_entropy)

with tf.name_scope('accuracy'):
  with tf.name_scope('correct_prediction'):
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
  with tf.name_scope('accuracy'):
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)

# Merge all the summaries and write them out to /tmp/mnist_logs (by default)
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train',
                                      sess.graph)
test_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/test')
tf.global_variables_initializer().run()

FileWriter를 초기화 한 후에는 모델을 테스트하고 테스트 할 때 FileWriter에 요약을 추가해야합니다.

# Train the model, and also write summaries.
# Every 10th step, measure test-set accuracy, and write test summaries
# All other steps, run train_step on training data, & add training summaries

def feed_dict(train):
  """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
  if train or FLAGS.fake_data:
    xs, ys = mnist.train.next_batch(100, fake_data=FLAGS.fake_data)
    k = FLAGS.dropout
  else:
    xs, ys = mnist.test.images, mnist.test.labels
    k = 1.0
  return {x: xs, y_: ys, keep_prob: k}

for i in range(FLAGS.max_steps):
  if i % 10 == 0:  # Record summaries and test-set accuracy
    summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
    test_writer.add_summary(summary, i)
    print('Accuracy at step %s: %s' % (i, acc))
  else:  # Record train set summaries, and train
    summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
    train_writer.add_summary(summary, i)

이제 TensorBoard를 사용하여이 데이터를 시각화 할 수 있습니다.

Launching TensorBoard

TensorBoard 출시

TensorBoard를 실행하려면 다음 명령을 사용하십시오 (또는 python -m tensorboard.main).

tensorboard --logdir=path/to/log-directory

여기서 logdir은 FileWriter가 데이터를 직렬화 한 디렉토리를 가리 킵니다. 이 logdir 디렉토리에 별도의 실행에서 직렬화 된 데이터가 들어있는 하위 디렉토리가 있으면 TensorBoard는 이러한 모든 실행에서 데이터를 시각화합니다. TensorBoard가 실행되면 웹 브라우저에서 localhost : 6006으로 이동하여 TensorBoard를 봅니다.

TensorBoard를 보면 오른쪽 상단 모서리에 탐색 탭이 표시됩니다. 각 탭은 시각화 할 수있는 직렬화 된 데이터 집합을 나타냅니다.

그래프 탭을 사용하여 그래프를 시각화하는 방법에 대한 자세한 내용은 TensorBoard : 그래프 시각화를 참조하십시오.

TensorBoard에 대한 자세한 사용 정보는 TensorBoard의 GitHub(TensorBoard's GitHub)를 참조하십시오.

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]