def _custom_time_series_regressor( model_dir, head_type, exogenous_feature_columns): return ts_estimators.TimeSeriesRegressor( model=lstm_example._LSTMModel( num_features=5, num_units=128, exogenous_feature_columns=exogenous_feature_columns), optimizer=adam.AdamOptimizer(0.001), config=estimator_lib.RunConfig(tf_random_seed=4), state_manager=state_management.ChainingStateManager(), head_type=head_type, model_dir=model_dir)
def test_custom_metrics(self): """Tests that the custom metrics can be applied to the estimator.""" model_dir = self.get_temp_dir() estimator = ts_estimators.TimeSeriesRegressor( model=lstm_example._LSTMModel(num_features=1, num_units=4), optimizer=adam.AdamOptimizer(0.001), config=estimator_lib.RunConfig(tf_random_seed=4), model_dir=model_dir) def input_fn(): return { feature_keys.TrainEvalFeatures.TIMES: [[1, 2, 3], [7, 8, 9]], feature_keys.TrainEvalFeatures.VALUES: numpy.array([[[0.], [1.], [0.]], [[2.], [3.], [2.]]]) } def metrics_fn(predictions, features): # checking that the inputs are properly passed. predict = predictions["mean"] target = features[feature_keys.TrainEvalFeatures.VALUES][:, -1, 0] return { "plain_boring_metric386": (math_ops.reduce_mean(math_ops.abs(predict - target)), control_flow_ops.no_op()), "fun_metric101": (math_ops.reduce_sum(predict + target), control_flow_ops.no_op()), } # Evaluation without training is enough for testing custom metrics. estimator = extenders.add_metrics(estimator, metrics_fn) evaluation = estimator.evaluate(input_fn, steps=1) self.assertIn("plain_boring_metric386", evaluation) self.assertIn("fun_metric101", evaluation) self.assertIn("average_loss", evaluation) # The values are deterministic because of fixed tf_random_seed. # However if they become flaky, remove such exacts comparisons. self.assertAllClose(evaluation["plain_boring_metric386"], 1.130380) self.assertAllClose(evaluation["fun_metric101"], 10.435442)
params['total_steps_train'] = params['steps_per_epoch'] * epochs_to_train params['throttle_eval'] = throttle_mins * 60 params['momentum'] = 0.9 params['bias_reduction'] = 0.1 params['epochs_to_reduce_at'] = [40, 120] params['initial_learning_rate'] = 0.1 params['epoch_reduction_factor'] = 0.1 params['mixup_val'] = 0.7 pprint(params) # get data loader cifar_data = CIFAR10(batch_size=params['batch_size'], mixup_val=params['mixup_val']) run_config = estimator.RunConfig( save_checkpoints_steps=params['steps_per_epoch'], save_summary_steps=500, keep_checkpoint_max=5) fixup_estimator = estimator.Estimator(model_dir=model_dir, model_fn=model.model_fn, params=params, config=run_config) # training/evaluation specs for run train_spec = estimator.TrainSpec(input_fn=cifar_data.build_training_data, max_steps=params['total_steps_train']) eval_spec = estimator.EvalSpec(input_fn=cifar_data.build_validation_data, steps=None, throttle_secs=params['throttle_eval'], start_delay_secs=0)
def test_one_shot_prediction_head_export(self): model_dir = self.get_temp_dir() categorical_column = feature_column.categorical_column_with_hash_bucket( key="categorical_exogenous_feature", hash_bucket_size=16) exogenous_feature_columns = [ feature_column.numeric_column("2d_exogenous_feature", shape=(2, )), feature_column.embedding_column( categorical_column=categorical_column, dimension=10) ] estimator = ts_estimators.TimeSeriesRegressor( model=lstm_example._LSTMModel( num_features=5, num_units=128, exogenous_feature_columns=exogenous_feature_columns), optimizer=adam.AdamOptimizer(0.001), config=estimator_lib.RunConfig(tf_random_seed=4), state_manager=state_management.ChainingStateManager(), head_type=ts_head_lib.OneShotPredictionHead, model_dir=model_dir) train_features = { feature_keys.TrainEvalFeatures.TIMES: numpy.arange(20, dtype=numpy.int64), feature_keys.TrainEvalFeatures.VALUES: numpy.tile(numpy.arange(20, dtype=numpy.float32)[:, None], [1, 5]), "2d_exogenous_feature": numpy.ones([20, 2]), "categorical_exogenous_feature": numpy.array(["strkey"] * 20)[:, None] } train_input_fn = input_pipeline.RandomWindowInputFn( input_pipeline.NumpyReader(train_features), shuffle_seed=2, num_threads=1, batch_size=16, window_size=16) estimator.train(input_fn=train_input_fn, steps=5) input_receiver_fn = estimator.build_raw_serving_input_receiver_fn() export_location = estimator.export_savedmodel(self.get_temp_dir(), input_receiver_fn) graph = ops.Graph() with graph.as_default(): with session_lib.Session() as session: signatures = loader.load(session, [tag_constants.SERVING], export_location) self.assertEqual([feature_keys.SavedModelLabels.PREDICT], list(signatures.signature_def.keys())) predict_signature = signatures.signature_def[ feature_keys.SavedModelLabels.PREDICT] six.assertCountEqual(self, [ feature_keys.FilteringFeatures.TIMES, feature_keys.FilteringFeatures.VALUES, "2d_exogenous_feature", "categorical_exogenous_feature" ], predict_signature.inputs.keys()) features = { feature_keys.TrainEvalFeatures.TIMES: numpy.tile( numpy.arange(35, dtype=numpy.int64)[None, :], [2, 1]), feature_keys.TrainEvalFeatures.VALUES: numpy.tile( numpy.arange(20, dtype=numpy.float32)[None, :, None], [2, 1, 5]), "2d_exogenous_feature": numpy.ones([2, 35, 2]), "categorical_exogenous_feature": numpy.tile( numpy.array(["strkey"] * 35)[None, :, None], [2, 1, 1]) } feeds = { graph.as_graph_element(input_value.name): features[input_key] for input_key, input_value in predict_signature.inputs.items() } fetches = { output_key: graph.as_graph_element(output_value.name) for output_key, output_value in predict_signature.outputs.items() } output = session.run(fetches, feed_dict=feeds) self.assertAllEqual((2, 15, 5), output["mean"].shape)
def compile(self, run_config, envir_config, model_fn): import logging import sys # Config logging tf.logging.set_verbosity(logging.INFO) handlers = [ logging.FileHandler(os.path.join(run_config.store_dir, 'main.log')), logging.StreamHandler(sys.stdout) ] logging.getLogger('tensorflow').handlers = handlers tf.logging.set_verbosity(tf.logging.INFO) self.test_dir = run_config.test_dir start = time.time() session_config = self._create_session_config(envir_config) exe_config = estimator.RunConfig( model_dir=run_config.model_dir, session_config=session_config, save_summary_steps=run_config.save_summary_steps, keep_checkpoint_max=run_config.keep_checkpoint_max, save_checkpoints_steps=run_config.save_checkpoints_steps, keep_checkpoint_every_n_hours=run_config. keep_checkpoint_every_n_hours) def _model_fn(features, labels, mode): if mode == estimator.ModeKeys.TRAIN: loss, accuracy, var_list, hooks = model_fn[mode](features, labels, run_config) # Learning rate # todo organize lr and optimizer configuration learning_rate = run_config.learning_rate if run_config.scheduler == 'exponential': learning_rate = tf.train.exponential_decay( learning_rate=learning_rate, global_step=tf.train.get_or_create_global_step(), decay_steps=run_config.decay_steps, decay_rate=run_config.decay_rate, staircase=run_config.staircase) elif run_config.scheduler == 'step': learning_rate = step_lr(boundaries=run_config.boundaries, values=run_config.lr_values) else: learning_rate = tf.constant(learning_rate, dtype=tf.float32) tf.summary.scalar('lr', learning_rate) # Optimizer optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) # Hook hooks += [ LoggerHook(learning_rate=learning_rate, log_frequency=run_config.log_frequency, batch_size=run_config.batch_size, loss=loss, accuracy=accuracy, metric_names=run_config.class_names) ] if hasattr(run_config, 'lr_multiplier'): train_op = multi_lr(optimizer, loss, var_list, run_config.lr_multiplier) else: train_op = optimizer.minimize( loss, global_step=tf.train.get_global_step(), var_list=var_list) return estimator.EstimatorSpec(estimator.ModeKeys.TRAIN, loss=loss, training_hooks=hooks, train_op=train_op) elif mode == estimator.ModeKeys.EVAL: loss, metrics = model_fn[mode](features, labels, run_config) return estimator.EstimatorSpec(estimator.ModeKeys.EVAL, loss=loss, eval_metric_ops=metrics) elif mode == estimator.ModeKeys.PREDICT: predictions = model_fn[mode](features, run_config) return estimator.EstimatorSpec(estimator.ModeKeys.PREDICT, predictions) else: raise ValueError("Expect mode in [train, eval, infer]," "but received {}".format(mode)) self.executor = estimator.Estimator(model_fn=_model_fn, model_dir=run_config.model_dir, config=exe_config) self.steps = run_config.steps print(">>>>>>>>>>>>Finish Compiling in {:.2}s>>>>>>>>>>>>".format( time.time() - start)) print(envir_config) print(run_config) flag = input('Is all config correct? (yes/no)') if flag not in ['yes', 'y', '1']: exit(-1)