précision de tf.metrics.mean_squared_error

Question

Pour les besoins de l'étude, je veux vérifier l'exactitude de tf.Metrics.mean_squared_error. À ma grande surprise, ils sont très différents. Je cherche des explications. Voici mon résumé de l'expérience suivi de mon exemple de code:

1) d'évaluer le modèle de jouet formé avec les données d'entraînement entières par tf.Metrics.mean_squared_error; 2) évaluer à nouveau immédiatement après l'étape 1, en recueillant d'abord la prédiction donnée à tous les «X» (ou images) des mêmes données d'entraînement, puis en calculant l'erreur quadratique moyenne avec toute la vérité terrain (ou étiquettes) des données d'apprentissage et de la prédiction.

J'ai deux explications non prouvées: (1) la perte de précision flottante s'accumule et (2) tf.Metrics.mean_square_error applique une moyenne apparemment mobile dans son implémentation qui entraîne une imprécision.

Toutes les idées relavent sont grandement appréciées! Merci!

---

import tensorflow as tf 
from numpy import genfromtxt 

tf.logging.set_verbosity(tf.logging.INFO) 
# (hyper)parameters 
batch_size = 200 
num_epochs = 1000 
steps = 1000 
# prepare data 
with tf.Session() as sess: 
    training_x = sess.run(tf.random_normal([2048, 16], mean=-1, stddev=4, dtype=tf.float64)) 
    training_y = norm = sess.run(tf.random_normal([2048, 1], mean=-1, stddev=4, dtype=tf.float64)) 
# input function 
_input_fn = lambda _input_path: genfromtxt(_input_path, delimiter=',') 
input_training = tf.contrib.learn.io.numpy_input_fn({"input": training_x}, training_y, 
               batch_size=batch_size, num_epochs=num_epochs) 
input_evaluate_train_data = tf.contrib.learn.io.numpy_input_fn({"input": training_x}, training_y) 

# remember to give the same column name as used in _input_fn 
features = [tf.contrib.layers.real_valued_column('input', dimension=16)] 
regressor = tf.contrib.learn.DNNRegressor(feature_columns=features, 
              hidden_units=[32, 8], 
              dropout=0.1, 
              model_dir="testDNNR/result", 
              optimizer=tf.train.AdamOptimizer(learning_rate=0.008), 
              activation_fn=tf.nn.elu) 

# training 
regressor.fit(input_fn=input_training, steps=steps) 
# testing with training data 
eval_metric_ops = { 
    "mse": lambda targets, predictions: tf.metrics.mean_squared_error(tf.cast(targets, tf.float64), predictions) 
} 
ev = regressor.evaluate(input_fn=input_evaluate_train_data, steps=1, metrics=eval_metric_ops) 
pred = regressor.predict(input_fn=input_evaluate_train_data, as_iterable=False) 
# using my MSE 
mse = ((training_y - pred) ** 2).mean() 

print ("evaluation result given training data using my MSE: " + str(mse)) 
print ("evaluation result given training data using the library built-in MSE: " + str(ev)) 

Answer 1

Le décalage provient de la façon dont fonctionne tf.contrib.learn.io.numpy_input_fn. Après l'encapsulation, cette fonction est implémentée par https://github.com/tensorflow/tensorflow/blob/r1.3/tensorflow/python/estimator/inputs/numpy_io.py#L45

Comme vous pouvez le voir, par défaut, à chaque appel, il renvoie un lot de 128 valeurs. Lorsque vous l'utilisez dans un appel à regressor.evaluate vous obtenez un ensemble différent de 128 valeurs que ce que vous obtenez lorsque vous l'utilisez dans regressor.predict.

Il existe d'autres problèmes connexes. La mise en œuvre liée ci-dessus a shuffle=True ce qui signifie qu'il va choisir au hasard 128 éléments de vos données.

En outre, lorsque vous faites training_y - pred les tailles sont très différentes et les tenseurs diffusé résultant en beaucoup plus de termes que ce que vous attendez.