2016-07-15 38 views
26

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:rete neurale a flusso profondo di tensorflow per la regressione sempre prevedere gli stessi risultati in un lotto

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})) 
+2

Come sidenote, la parte di valutazione è errata.Dato che stai eseguendo la regressione, dovresti valutare la somma dei quadrati (nel tuo caso 'costo') come segue (mentre all'interno della sessione)' accuracy = sess.run (costo, feed_dict = {x: test_test, y: test_Y}} 'e per i valori stessi puoi fare' predicted_vals = sess.run (pred, feed_dict = {x: X_test}) '. – Kots

+0

@Kots Grazie, hai ragione, il codice originale è stato modificato direttamente dalla previsione in modo tale che ho dimenticato di cambiarlo. cambierà presto la fonte. –

+0

SufengNiu puoi condividere il tuo codice fisso? Sto affrontando lo stesso problema, quando ho provato a prendere la trasposizione di pred (pred = tf.transpose (pred)) come ha detto @CNugteren, quindi ottengo l'errore di dimensioni e quando imposto la dimensione del batch su 1, ottengo l'indice fuori di errore legato, non ho potuto farlo risolvere. – Itkrux

risposta

19

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.

+0

Grazie mille! –

+0

E 'stato molto utile! Grazie! – Simankov

+0

So che è un bel po 'di tempo, ma puoi farci sapere come hai realizzato cosa stava succedendo lì? – Kots

0

è 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

+0

Grazie, si prega di verificare la domanda aggiornata. Sono d'accordo con te che l'indice delle etichette potrebbe essere stato impostato in modo errato, ma ho controllato l'indice di y e ho stampato il valore dell'etichetta. sembra che non abbia problemi. funziona per la classificazione mnist e l'ho verificato. Come hai detto, ho anche controllato le effettive uscite di regressione, l'output in un batch è quasi lo stesso. il codice potrebbe essere un po 'lungo, ma in realtà molto semplice. Hai qualche suggerimento? Grazie –

Problemi correlati