Le réseau neuronal profond de tensorflow pour la régression prédit toujours les mêmes résultats dans un lot

Question

J'utilise un tensorflow à mettre en œuvre un simple multi-layer perceptron pour la régression. Le code est modifié à partir de la norme mnist classificateur, que j'ai seulement changé la sortie du coût MSE (utiliser tf.reduce_mean(tf.square(pred-y))), et certaines d'entrée, de sortie les paramètres de taille. Cependant, si je train le réseau à l'aide de la régression, après plusieurs époques, le lot de sortie sont totalement identiques. par exemple:

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

J'ai essayé différentes taille de lot, d'initialisation différents, l'entrée de la normalisation à l'aide de sklearn.prétraitement.échelle (mon entrées de gamme sont tout à fait différents). Cependant, aucun d'entre eux travaillaient. J'ai aussi essayé l'une des sklearn exemple de Tensorflow (Réseau de Neurones Profonds avec une Régression de Boston de Données). Mais j'ai une autre erreur dans la ligne 40:

"module" de l'objet n'a pas d'attribut "infer_real_valued_columns_from_input'

Quelqu'un a des indices sur l'endroit où est le problème? Merci

Mon code est ci-dessous, peut-être un peu long, mais très 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

Réponse courte:

Transposer votre pred de vecteur à l'aide de tf.transpose(pred).

Plus de réponses:

Le problème est qu' pred (prédictions) et y (les étiquettes) ne sont pas de la même forme: l'un est un vecteur ligne et de l'autre un vecteur colonne. Apparemment, lorsque vous appliquez un élément-sage opération sur eux, vous obtiendrez une matrice, ce qui n'est pas ce que vous voulez.

La solution est de transposer la prédiction de vecteur à l'aide de tf.transpose() , pour obtenir un bon vecteur et donc une bonne perte de fonction. En fait, si vous définissez la taille du lot à 1 dans votre exemple, vous verrez que cela fonctionne même sans le corriger, parce que la transposition d'une 1x1 vecteur est un no-op.

J'ai appliqué ce correctif à votre code d'exemple et d'observer le comportement suivant. Avant le correctif:

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]

Et après la correction à la même point dans le temps:

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]

Vous verrez que le coût est beaucoup plus faible et qu'en fait, il a appris la valeur de 50 correctement. Vous aurez à faire quelques modifications sur le taux d'apprentissage et de tel pour améliorer vos résultats de cours.

Answer 2

Il y a probablement un problème avec le chargement de votre ensemble de données ou la mise en œuvre de l'indexation. Si vous avez uniquement modifié le coût en MSE, assurez-vous que pred et y sont correctement mis à jour et que vous ne les avez pas écrasés avec une opération de graphique différente.

Une autre chose pour aider au débogage serait de prédire les résultats de régression réels. Cela aiderait également si vous publiiez plus de votre code afin que nous puissions voir votre implémentation de chargement de données spécifique, etc.