Question

代码：

const http = require('http');
const onRequest = (req, res) => {
   res.writeHead(200, {"Content-Type": "text/plain"});
   res.write('Hello World!');
   res.end();
}
const server = http.createServer(onRequest).listen(8000);

给出以下输出：

import numpy as np
import tensorflow as tf
import pandas as pd
from sklearn.model_selection import train_test_split

x_data = np.linspace(0, 1000, 100000)
y_true = np.square(x_data)
y_true += np.random.randn(len(x_data))


feature_columns = [tf.feature_column.numeric_column('x', shape=[1])]
estimator = tf.estimator.DNNRegressor(feature_columns=feature_columns,         hidden_units=[2, 2], optimizer=lambda:
                                  tf.train.AdamOptimizer(
                                      learning_rate=0.001
                                  ))


X_train, X_test, y_train, y_test = train_test_split(x_data, y_true, test_size=0.3)

input_function = tf.estimator.inputs.numpy_input_fn({'x': X_train},y_train,
                                                batch_size=20, num_epochs=10000,
                                                shuffle=True)

train_input_function = tf.estimator.inputs.numpy_input_fn({'x': X_train},y_train,
                                                      batch_size=8, num_epochs=10000,
                                                      shuffle=False)
test_input_function = tf.estimator.inputs.numpy_input_fn({'x': X_test},y_test,
                                                     batch_size=8, num_epochs=10000,
                                                     shuffle=False)


estimator.train(input_fn=input_function, steps=1000)

train_metrics = estimator.evaluate(input_fn=train_input_function, steps=1000)
test_metrics = estimator.evaluate(input_fn=test_input_function, steps=1000)


print('TRAINING DATA METRICS')
print(train_metrics)
print()

print('TEST DATA METRICS')
print(test_metrics)
print()
###
new_data = np.linspace(0, 1000, 10)
input_function_predict = tf.estimator.inputs.numpy_input_fn({'x':new_data},     shuffle=False)
print(list(estimator.predict(input_fn=input_function_predict)))

因此可以得出结论，损失是巨大的，因为TF预测所有X的Y值相同。代码有什么问题？

Answer 1

对于这样大小的输入，在响应变量上按比例缩放的输入和给定的模型，损失将总是很大。

您所做的实际上可以正常运行，但需要花费很多时间才能收敛，而无需进行进一步的微调。特别是如果我

删除lambda:（请参见上面的评论）
将learning_rate更改为0.1，
将batch_size更改为20000，
将num_epochs更改为100，

那么您的10个预测就会变成

[-2.036557, 82379.797, 165955.28, 249530.75, 333106.22, 416681.72, 500257.19, 583832.63, 667408.13, 750983.63]

通过快速查看，

对于给定模型似乎接近最佳状态（似乎不是特别好）：

有了这个，您就可以随意使用模型了。例如，我们知道一个更好的模型（如果不是非常神经网络）将是通过

定义的模型。

estimator = tf.estimator.DNNRegressor(feature_columns=feature_columns,
                                      hidden_units=[1],
                                      activation_fn=np.square,
                                      optimizer=tf.train.AdamOptimizer(learning_rate=1))

最终损失为7.20825e + 09，可以提供完美的预测：

在下面的评论中进行讨论之后，在现实生活中，您希望在模型中包含二次变换，通常会将其作为特征；例如，您可以DNNRegressor通过

进行线性回归（实际上是愚蠢的）

feature_columns = [tf.feature_column.numeric_column('x'),
                   tf.feature_column.numeric_column('x_squared')]

estimator = tf.estimator.DNNRegressor(feature_columns=feature_columns,
                                      hidden_units=[1],
                                      activation_fn=tf.identity,
                                      optimizer= tf.train.AdamOptimizer(learning_rate=1))

input_function = tf.estimator.inputs.numpy_input_fn({'x': X_train, 'x_squared': X_train**2}, y_train, 
                                                    batch_size=1000, num_epochs=500,
                                                    shuffle=True)

像以前一样，这将使您非常适合

Tensorflow不学习

1 个答案: