Training TensorFlow를 합계로 예측하기

Question

TensorFlow 제공 예제는 시작하기에 다소 복잡하므로 TensorFlow가 신경망을 학습하여 세 자리 이진수를 예측하도록 가르치려고합니다. 네트워크는 그 중 두 개를 입력으로 가져옵니다. 세 번째 것은 알려지지 않았습니다. 그래서 "최적의"네트워크는 합계가 알려진 두 비트의 합계와 미지의 비트의 1/2이 될 것이라고 추측합니다. "손실"함수가 네트워크에 의해 예측 된 값과 실제 값 사이의 차이의 제곱이라고 가정 해 봅시다.

가 나는 시련을 생성하는 코드를 작성했습니다 :

Filling feed dict 
inputs 1 0 
unknown 0 
sum 1 

inputs 1 0 
unknown 1 
sum 2 

inputs 0 1 
unknown 1 
sum 2 

inputs 0 1 
unknown 0 
sum 1 

inputs 0 0 
unknown 0 
sum 0 

(5, 2) 
(5,) 

그러나 나는 그것을 마무리 얼마나 I가 불분명 해요 :

import tensorflow as tf 
import numpy as np 
from random import randint 

flags = tf.app.flags 
FLAGS = flags.FLAGS 
flags.DEFINE_integer('batch_size', 5, 'Batch size. ') 
flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.') 
flags.DEFINE_integer('dim1', 3, 'layer size') 
flags.DEFINE_integer('training_epochs', 10, 'Number of passes through the main training loop') 


def ezString(list): 
    #debugging code so I can see what is going on 
    listLength = len(list) 
    r = '' 
    for i in range(listLength): 
     value = list[i] 
     valueString = str(value) 
     r = r + ' ' 
     r = r + valueString 
    return r 

def generateTrial(): 
    inputs = np.zeros(2, dtype=np.int) 
    for i in range(2): 
     inputs[i] = randint(0,1) 
    unknownInput = randint(0,1) 
    sum = 0 
    for j in range(2): 
     sum = sum + inputs[j] 
    sum = sum + unknownInput 
    inputTensor = tf.pack(inputs) 
    print 'inputs' + ezString(inputs) 
    print 'unknown ' + str(unknownInput) 
    print 'sum ' + str(sum) 
    print '' 
    return inputTensor, sum 

def printTensor(tensor): 
    sh = tensor.get_shape() 
    print(sh) 

def placeholder_inputs(size): 
    output_placeholder = tf.placeholder(tf.int32, shape=(size)) 
    input_placeholder = tf.placeholder(tf.int32, shape=(size, 
                               2)) 
    return input_placeholder, output_placeholder 

def fill_feed_dict(inputs_pl, output_pl): 
    print ('Filling feed dict') 
    inputs_placeholder, output_placeholder = placeholder_inputs(FLAGS.batch_size) 
    inputs = [] 
    outputs = [] 
    for i in range(FLAGS.batch_size): 
     input, output = generateTrial() 
     inputTensor = tf.pack(input) 
     inputs.append(input) 
     outputs.append(output) 
    inputs_placeholder = tf.pack(inputs) 
    outputs_placeholder = tf.pack(outputs) 

def run_training(): 
    input_placeholder, output_placeholder = placeholder_inputs(FLAGS.batch_size) 
    fill_feed_dict(input_placeholder, output_placeholder) 
    printTensor(input_placeholder) 
    printTensor(output_placeholder) 




run_training() 

출력이 많은 작동하고 있음을 시사한다. 특히, 나는 손실 함수를 정의 할 필요가 있으며, 네트워크의 출력이 추후 훈련 단계에 대한 추측을 생성하는 데 사용되도록 물건을 연결해야합니다. 누구든지 도와 줄 수 있습니까?

Answer 1

이 코드가 원하는 코드인지 여부는 확실하지 않지만 어쨌든 유용하다고 생각합니다. 평균 제곱 오류는 반복을 따라 실제로 감소합니다. 그러나 예측을 위해 테스트하지는 않았으므로 그것은 사용자의 몫입니다.

import tensorflow as tf 
import numpy as np 
from random import randint 

flags = tf.app.flags 
FLAGS = flags.FLAGS 
flags.DEFINE_integer('batch_size', 50, 'Batch size.') 
flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.') 
flags.DEFINE_integer('dim1', 3, 'layer size') 
flags.DEFINE_integer('training_epochs', 10, 'Number of passes through the main training loop') 
flag.DEFINE_integer('num_iters', 100, 'Number of iterations') 


def ezString(list): 
    #debugging code so I can see what is going on 
    listLength = len(list) 
    r = '' 
    for i in range(listLength): 
     value = list[i] 
     valueString = str(value) 
     r = r + ' ' 
     r = r + valueString 
    return r 

def generateTrial(): 
    inputs = np.zeros(2, dtype = np.float) 
    for i in range(2): 
     inputs[i] = randint(0, 1) 
    unknownInput = randint(0, 1) 
    um = 0 
    for j in range(2): 
     sum = sum + inputs[j] 
    sum = sum + unknownInput 
    inputTensor = np.asarray(inputs) 
    return inputTensor, sum 

def printTensor(tensor): 
    sh = tensor.get_shape() 
    print(sh) 

def placeholder_inputs(size): 
    output_placeholder = tf.placeholder(tf.float32, shape=(size)) 
    input_placeholder = tf.placeholder(tf.float32, shape=(size, 2)) 
    return input_placeholder, output_placeholder 

def fill_feed_dict(inputs_pl, output_pl): 
    inputs = [] 
    outputs = [] 
    for i in range(FLAGS.batch_size): 
     input, output = generateTrial() 
     inputs.append(input) 
     outputs.append(output) 

    return {inputs_pl: inputs, output_pl: outputs} 

def loss(y, pred): 
    return tf.reduce_mean(tf.pow(y - pred, 2)) 

def NN(x, y, W1, b1, W2, b2): 
    layer1 = tf.add(tf.matmul(x, W1), b1) 
    layer1 = tf.nn.relu(layer1) 
    output = tf.add(tf.matmul(layer1, W2), b2) 
    return output, loss(y, output) 

def get_params(dim_hidden): 
    with tf.variable_scope('nn_params'): 
     return tf.Variable(tf.truncated_normal([2, dim_hidden], stddev = 0.05)), tf.Variable(0.0, (dim_hidden)),\ 
     tf.Variable(tf.truncated_normal([dim_hidden, 1], stddev = 0.05)), tf.Variable(0.0, 1) 

def run_training(): 
    input_placeholder, output_placeholder = placeholder_inputs(FLAGS.batch_size) 
    W1, b1, W2, b2 = get_params(FLAGS.dim1) 
    pred, loss = NN(input_placeholder, output_placeholder, W1, b1, W2, b2) 
    optm = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(loss) 
    init = tf.initialize_all_variables() 
    sess = tf.Session() 
    sess.run(init) 

    for iters in range(FLAGS.num_iters): 
     l, _ = sess.run([loss, optm], feed_dict = fill_feed_dict(input_placeholder, output_placeholder)) 
     print l, iters + 1