作为练习，我正在尝试使用tf. contrib.learn.LinearRegressor对方程y=3*x1^2 4*x2^2进行建模。代码运行，但我对结果的准确性有点失望。结果对像y=3*x1 4*x2这样的线性方程很好。我认为tf.contrib.lear可以很好地应对平方项。是否有一个设置可以用来获得更好的结果，例如不同的优化器？

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

    import argparse
    import sys
    import tempfile

    from six.moves import urllib

    import pandas as pd
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import math

    FLAGS = None

    myImportedDatax1_np = np.empty((100, 1))
    myImportedDatax2_np = np.empty((100, 1))
    myImportedDatay_np = np.empty((100, 1))

    def trueOutput(x1, x2):
      return [3 * math.pow(x1, 2) + 4 * math.pow(x2, 2)]

    count = 0
# Create data, using true equation, in range x1= 0 to 9, and x2=0 to 9
    for a in range(0, 10):
      for b in range(0, 10):
        myImportedDatax1_np[count] = a
        myImportedDatax2_np[count] = b
        myImportedDatay_np[count] = trueOutput(myImportedDatax1_np[count], myImportedDatax2_np[count])
        print(myImportedDatay_np[count])
        count = count + 1

    combined_Imported_Data_x = np.append(myImportedDatax1_np, myImportedDatax2_np, axis=1)

    def build_estimator(model_dir, model_type):
      x1 = tf.contrib.layers.real_valued_column("x1")
      x2 = tf.contrib.layers.real_valued_column("x2")

      wide_columns = [x1, x2]
      m = tf.contrib.learn.LinearRegressor(model_dir=model_dir, feature_columns=wide_columns)
      return m

    def input_fn(input_batch, output_batch):
      inputs = {"x1": tf.constant(input_batch[:,0]), "x2": tf.constant(input_batch[:,1])}
      output = tf.constant(output_batch)
      return inputs, output

    def input_fn_predict(x1, x2):
      inputs = {"x1": tf.constant([[x1]]), "x2": tf.constant([[x2]])}
      return inputs

    def train_and_eval(model_dir, model_type, train_steps, train_data, test_data):
      model_dir = tempfile.mkdtemp() if not model_dir else model_dir
      print("model directory = %s" % model_dir)
      m = build_estimator(model_dir, model_type)
      m.fit(input_fn=lambda: input_fn(combined_Imported_Data_x, myImportedDatay_np), steps=train_steps)

      my_x1 = 2
      my_x2 = 6
      prediction = list(m.predict(input_fn=lambda: input_fn_predict(my_x1, my_x2)))
      print("Prediction value is: ")
      print(prediction)
      print("Actual value is: ")
      true_y = trueOutput(my_x1, my_x2)
      print(true_y)

    def main(_):
      train_and_eval(FLAGS.model_dir, FLAGS.model_type, FLAGS.train_steps,
                     FLAGS.train_data, FLAGS.test_data)

    if __name__ == "__main__":
      parser = argparse.ArgumentParser()
      parser.register("type", "bool", lambda v: v.lower() == "true")
      parser.add_argument(
          "--model_dir",
          type=str,
          default="",
          help="Base directory for output models."
      )
      parser.add_argument(
          "--model_type",
          type=str,
          default="wide_n_deep",
          help="Valid model types: {'wide', 'deep', 'wide_n_deep'}."
      )
      parser.add_argument(
          "--train_steps",
          type=int,
          default=10000,
          help="Number of training steps."
      )
      parser.add_argument(
          "--train_data",
          type=str,
          default="",
          help="Path to the training data."
      )
      parser.add_argument(
          "--test_data",
          type=str,
          default="",
          help="Path to the test data."
      )
      FLAGS, unparsed = parser.parse_known_args()
      tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)