rete neurale a flusso profondo di tensorflow per la regressione sempre prevedere gli stessi risultati in un lotto

Question

Uso un tensorflow per implementare un semplice percettore multistrato per la regressione. Il codice è stato modificato dal classificatore mnist standard, che ho modificato solo il costo dell'output in MSE (utilizzare tf.reduce_mean(tf.square(pred-y))) e alcune impostazioni di input, dimensione di output. Tuttavia, se addestro la rete utilizzando la regressione, dopo diverse epoche, il batch di output è totalmente lo stesso. ad esempio:

target: 48.129, estimated: 42.634 
target: 46.590, estimated: 42.634 
target: 34.209, estimated: 42.634 
target: 69.677, estimated: 42.634 
...... 

Ho provato differente dimensione del lotto, inizializzazione differente, ingresso normalizzazione utilizzando sklearn.preprocessing.scale (mie ingressi variano sono molto diverse). Tuttavia, nessuno di loro ha funzionato. Ho anche provato uno degli esempi sklearn di Tensorflow (Deep Neural Network Regression with Boston Data). Ma ho avuto un altro errore nella linea 40:

oggetto 'modulo' non ha alcun attributo 'infer_real_valued_columns_from_input'

Chiunque ha indizi su dove è il problema? Grazie

Il mio codice è riportato di seguito, può essere un po 'lunga, ma molto straghtforward:

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

import tensorflow as tf 
from tensorflow.contrib import learn 
import matplotlib.pyplot as plt 

from sklearn.pipeline import Pipeline 
from sklearn import datasets, linear_model 
from sklearn import cross_validation 
import numpy as np 

boston = learn.datasets.load_dataset('boston') 
x, y = boston.data, boston.target 
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(
x, y, test_size=0.2, random_state=42) 

total_len = X_train.shape[0] 

# Parameters 
learning_rate = 0.001 
training_epochs = 500 
batch_size = 10 
display_step = 1 
dropout_rate = 0.9 
# Network Parameters 
n_hidden_1 = 32 # 1st layer number of features 
n_hidden_2 = 200 # 2nd layer number of features 
n_hidden_3 = 200 
n_hidden_4 = 256 
n_input = X_train.shape[1] 
n_classes = 1 

# tf Graph input 
x = tf.placeholder("float", [None, 13]) 
y = tf.placeholder("float", [None]) 

# Create model 
def multilayer_perceptron(x, weights, biases): 
    # Hidden layer with RELU activation 
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1']) 
    layer_1 = tf.nn.relu(layer_1) 

    # Hidden layer with RELU activation 
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2']) 
    layer_2 = tf.nn.relu(layer_2) 

    # Hidden layer with RELU activation 
    layer_3 = tf.add(tf.matmul(layer_2, weights['h3']), biases['b3']) 
    layer_3 = tf.nn.relu(layer_3) 

    # Hidden layer with RELU activation 
    layer_4 = tf.add(tf.matmul(layer_3, weights['h4']), biases['b4']) 
    layer_4 = tf.nn.relu(layer_4) 

    # Output layer with linear activation 
    out_layer = tf.matmul(layer_4, weights['out']) + biases['out'] 
    return out_layer 

# Store layers weight & bias 
weights = { 
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], 0, 0.1)), 
    'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], 0, 0.1)), 
    'h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], 0, 0.1)), 
    'h4': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], 0, 0.1)), 
    'out': tf.Variable(tf.random_normal([n_hidden_4, n_classes], 0, 0.1)) 
} 
biases = { 
    'b1': tf.Variable(tf.random_normal([n_hidden_1], 0, 0.1)), 
    'b2': tf.Variable(tf.random_normal([n_hidden_2], 0, 0.1)), 
    'b3': tf.Variable(tf.random_normal([n_hidden_3], 0, 0.1)), 
    'b4': tf.Variable(tf.random_normal([n_hidden_4], 0, 0.1)), 
    'out': tf.Variable(tf.random_normal([n_classes], 0, 0.1)) 
} 

# Construct model 
pred = multilayer_perceptron(x, weights, biases) 

# Define loss and optimizer 
cost = tf.reduce_mean(tf.square(pred-y)) 
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 

# Launch the graph 
with tf.Session() as sess: 
    sess.run(tf.initialize_all_variables()) 

    # Training cycle 
    for epoch in range(training_epochs): 
     avg_cost = 0. 
     total_batch = int(total_len/batch_size) 
     # Loop over all batches 
     for i in range(total_batch-1): 
      batch_x = X_train[i*batch_size:(i+1)*batch_size] 
      batch_y = Y_train[i*batch_size:(i+1)*batch_size] 
      # Run optimization op (backprop) and cost op (to get loss value) 
      _, c, p = sess.run([optimizer, cost, pred], feed_dict={x: batch_x, 
                  y: batch_y}) 
      # Compute average loss 
      avg_cost += c/total_batch 

     # sample prediction 
     label_value = batch_y 
     estimate = p 
     err = label_value-estimate 
     print ("num batch:", total_batch) 

     # Display logs per epoch step 
     if epoch % display_step == 0: 
      print ("Epoch:", '%04d' % (epoch+1), "cost=", \ 
       "{:.9f}".format(avg_cost)) 
      print ("[*]----------------------------") 
      for i in xrange(3): 
       print ("label value:", label_value[i], \ 
        "estimated value:", estimate[i]) 
      print ("[*]============================") 

    print ("Optimization Finished!") 

    # Test model 
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
    # Calculate accuracy 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
    print ("Accuracy:", accuracy.eval({x: X_test, y: Y_test})) 

Answer 1

Risposta breve:

la trasposizione della pred vettore utilizzando tf.transpose(pred). risposta

Longer:

Il problema è che pred (le previsioni) e y (etichette) non sono della stessa forma: uno è un vettore riga e l'altro un vettore colonna. Apparentemente quando applichi su di loro un'operazione basata sull'elemento, otterrai una matrice, che non è ciò che desideri.

La soluzione è di trasporre il vettore di previsione utilizzando tf.transpose() per ottenere un vettore corretto e quindi una funzione di perdita adeguata. In realtà, se si imposta la dimensione del batch su 1 nell'esempio, si vedrà che funziona anche senza la correzione, poiché la trasposizione di un vettore 1x1 è un no-op.

Ho applicato questa correzione al codice di esempio e osservato il seguente comportamento. Prima la correzione:

Epoch: 0245 cost= 84.743440580 
[*]---------------------------- 
label value: 23 estimated value: [ 27.47437096] 
label value: 50 estimated value: [ 24.71126747] 
label value: 22 estimated value: [ 23.87785912] 

E dopo la correzione nello stesso punto nel tempo:

Epoch: 0245 cost= 4.181439120 
[*]---------------------------- 
label value: 23 estimated value: [ 21.64333534] 
label value: 50 estimated value: [ 48.76105118] 
label value: 22 estimated value: [ 24.27996063] 

vedrete che il costo è molto più basso e che in realtà ha imparato il valore 50 in modo corretto. Dovrai fare un po 'di messa a punto del tasso di apprendimento e tale per migliorare i tuoi risultati, naturalmente.

Answer 2

è probabile un problema con il set di dati di carico o di attuazione di indicizzazione. Se si è modificato solo il costo per MSE, assicurarsi che pred e siano stati aggiornati correttamente e che non siano stati sovrascritti con un'operazione di grafico diversa.

Un'altra cosa per aiutare il debug sarebbe quella di prevedere i risultati effettivi di regressione. Sarebbe anche utile se hai postato più del vostro codice in modo che possiamo vedere l'implementazione caricamento dei dati specifici, ecc