Ok, so I figured out how to make predictions with the regression model. The tutorial example wraps the estimator in the train_and_evaluate function, so trying to call it from outside will obviously not work. Here is a simple example exposing estimator:

#@title AdaNet parameters
LEARNING_RATE = 0.0015  #@param {type:"number"}
TRAIN_STEPS = 100000  #@param {type:"integer"}
BATCH_SIZE = 32  #@param {type:"integer"}

LEARN_MIXTURE_WEIGHTS = True  #@param {type:"boolean"}
ADANET_LAMBDA = 0.018  #@param {type:"number"}
BOOSTING_ITERATIONS = 8  #@param {type:"integer"}


def train_and_evaluate(learn_mixture_weights=LEARN_MIXTURE_WEIGHTS,
                       adanet_lambda=ADANET_LAMBDA):
    return tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)


estimator = adanet.Estimator(
      # Since we are predicting housing prices, we'll use a regression
      # head that optimizes for MSE.
      head=tf.contrib.estimator.regression_head(
          loss_reduction=tf.losses.Reduction.SUM_OVER_BATCH_SIZE),

      # Define the generator, which defines our search space of subnetworks
      # to train as candidates to add to the final AdaNet model.
      subnetwork_generator=SimpleDNNGenerator(
          optimizer=tf.train.RMSPropOptimizer(learning_rate=LEARNING_RATE),
          learn_mixture_weights=LEARN_MIXTURE_WEIGHTS,
          seed=RANDOM_SEED),

      # Lambda is a the strength of complexity regularization. A larger
      # value will penalize more complex subnetworks.
      adanet_lambda=ADANET_LAMBDA,

      # The number of train steps per iteration.
      max_iteration_steps=TRAIN_STEPS // BOOSTING_ITERATIONS,

      # The evaluator will evaluate the model on the full training set to
      # compute the overall AdaNet loss (train loss + complexity
      # regularization) to select the best candidate to include in the
      # final AdaNet model.
      evaluator=adanet.Evaluator(
          input_fn=input_fn("train", training=False, batch_size=BATCH_SIZE)),

      # Configuration for Estimators.
      config=tf.estimator.RunConfig(
          save_checkpoints_steps=50000,
          save_summary_steps=50000,
          tf_random_seed=RANDOM_SEED))

  # Train and evaluate using using the tf.estimator tooling.
train_spec = tf.estimator.TrainSpec(
      input_fn=input_fn("train", training=True, batch_size=BATCH_SIZE),
      max_steps=TRAIN_STEPS)
eval_spec = tf.estimator.EvalSpec(
      input_fn=input_fn("test", training=False, batch_size=BATCH_SIZE),
      steps=None)
  #return tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)

To train you can just call train_and_evaluate like in the tutorial.

Predicting was trickier, for me anyway, I'm sure there are cleaner (correct) ways of doing it, this is going to be ugly, but I'm learning - here is what worked for me. To give the model new testing data you have to make a new input function, I borrowed the input_fn given in the tutorial like so:

FEATURES_KEYy = "x"


def test_input_fn(x, batch_size):
  """Generate an input function for the Estimator."""

  def _input_fn():

    dataset = tf.data.Dataset.from_tensor_slices({
          FEATURES_KEYy: x.values
      })


    dataset = dataset.batch(batch_size)
    iterator = dataset.make_one_shot_iterator()
    features = iterator.get_next()
    return features

  return _input_fn

It says x.values because I was giving it test data from a boston house price test csv from kaggle, converted into a pandas dataframe here called x_test.

predict_results = estimator.predict(input_fn=test_input_fn(x_test, len(x_test)), yield_single_examples=False)

predict_results (or whatever you call predictions) will return a generator. To see whats inside it call:

next(predict_results)) or p=next(predict_results))

This will show you the predictions by printing a dict, if you want the results as an array or series or whatever, extract the dict values:

pr=next(iter(p.values()))

To check if the predictions were sane I submitted them to the kaggle competition and they scored a 0.16 (I did engineer the training data a bit first rather than use the straight keras.dataset given in the tutorial, i.e, my x_train was (1459, 197)), not bad at all for not optimizing the adanet parameters at all, beyond the very small tweaks you can see in the above code to learning rate and lambda.

Predicting on classification is up next.

As to exporting the model, I could export the pb file only with the classification model so far and im not sure its right so I dont want to mislead anyone, I'll report when I'm sure I can get it working. GL

How-to serve #22

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions