def testTrainSaveLoad(self): """Tests that insures you can save and reload a trained model.""" def _input_fn(num_epochs=None): features = { 'age': input_lib.limit_epochs(constant_op.constant([[.8], [.2], [.1]]), num_epochs=num_epochs), 'language': sparse_tensor.SparseTensor(values=input_lib.limit_epochs( ['en', 'fr', 'zh'], num_epochs=num_epochs), indices=[[0, 0], [0, 1], [2, 0]], dense_shape=[3, 2]) } return features, constant_op.constant([[1], [0], [0]], dtype=dtypes.int32) model_dir = tempfile.mkdtemp() classifier = debug.DebugClassifier( model_dir=model_dir, n_classes=3, config=run_config.RunConfig(tf_random_seed=1)) classifier.fit(input_fn=_input_fn, steps=5) predict_input_fn = functools.partial(_input_fn, num_epochs=1) predictions1 = classifier.predict_classes(input_fn=predict_input_fn) del classifier classifier2 = debug.DebugClassifier( model_dir=model_dir, n_classes=3, config=run_config.RunConfig(tf_random_seed=1)) predictions2 = classifier2.predict_classes(input_fn=predict_input_fn) self.assertEqual(list(predictions1), list(predictions2))
def test_uid_for_default_whitelist(self): config = run_config_lib.RunConfig( tf_random_seed=11, save_summary_steps=12, save_checkpoints_steps=13, save_checkpoints_secs=14, session_config=config_pb2.ConfigProto(allow_soft_placement=True), keep_checkpoint_max=16, keep_checkpoint_every_n_hours=17) self.assertEqual(11, config.tf_random_seed) self.assertEqual(12, config.save_summary_steps) self.assertEqual(13, config.save_checkpoints_steps) self.assertEqual(14, config.save_checkpoints_secs) self.assertEqual(config_pb2.ConfigProto(allow_soft_placement=True), config.session_config) self.assertEqual(16, config.keep_checkpoint_max) self.assertEqual(17, config.keep_checkpoint_every_n_hours) new_config = run_config_lib.RunConfig( tf_random_seed=21, save_summary_steps=22, save_checkpoints_steps=23, save_checkpoints_secs=24, session_config=config_pb2.ConfigProto(allow_soft_placement=False), keep_checkpoint_max=26, keep_checkpoint_every_n_hours=27) self.assertEqual(config.uid(), new_config.uid()) # model_dir is not on the default whitelist. self.assertNotEqual(config.uid(whitelist=[]), new_config.uid(whitelist=[])) new_config = new_config.replace(model_dir=ANOTHER_TEST_DIR) self.assertNotEqual(config.uid(), new_config.uid())
def testTrainSaveLoad(self): """Tests that insures you can save and reload a trained model.""" def _input_fn(num_epochs=None): features = { 'age': input_lib.limit_epochs(constant_op.constant([[0.8], [0.15], [0.]]), num_epochs=num_epochs), 'language': sparse_tensor.SparseTensor(values=input_lib.limit_epochs( ['en', 'fr', 'zh'], num_epochs=num_epochs), indices=[[0, 0], [0, 1], [2, 0]], dense_shape=[3, 2]) } return features, constant_op.constant([1., 0., 0.2], dtype=dtypes.float32) model_dir = tempfile.mkdtemp() regressor = debug.DebugRegressor( model_dir=model_dir, config=run_config.RunConfig(tf_random_seed=1)) regressor.fit(input_fn=_input_fn, steps=5) predict_input_fn = functools.partial(_input_fn, num_epochs=1) predictions = list(regressor.predict_scores(input_fn=predict_input_fn)) del regressor regressor2 = debug.DebugRegressor( model_dir=model_dir, config=run_config.RunConfig(tf_random_seed=1)) predictions2 = list( regressor2.predict_scores(input_fn=predict_input_fn)) self.assertAllClose(predictions, predictions2)
def test_checkpoint_and_export(self): model_dir = tempfile.mkdtemp() config = run_config_lib.RunConfig(save_checkpoints_steps=3) est = dnn.DNNClassifier( n_classes=3, feature_columns=[ feature_column.real_valued_column('feature', dimension=4) ], hidden_units=[3, 3], model_dir=model_dir, config=config) exp_strategy = saved_model_export_utils.make_export_strategy( est, 'export_input', exports_to_keep=None) ex = experiment.Experiment( est, train_input_fn=test_data.iris_input_multiclass_fn, eval_input_fn=test_data.iris_input_multiclass_fn, export_strategies=(exp_strategy,), train_steps=8, checkpoint_and_export=True, eval_delay_secs=0) with test.mock.patch.object(ex, '_maybe_export'): with test.mock.patch.object(ex, '_call_evaluate'): ex.train_and_evaluate() # Eval and export are called after steps 1, 4, 7, and 8 (after training # is completed). self.assertEqual(ex._maybe_export.call_count, 4) self.assertEqual(ex._call_evaluate.call_count, 4)
def test_explicitly_specified_values(self): cluster_spec = { run_config_lib.TaskType.PS: ["localhost:9990"], "my_job_name": ["localhost:9991", "localhost:9992", "localhost:0"] } tf_config = { "cluster": cluster_spec, "task": { "type": run_config_lib.TaskType.WORKER, "index": 2 } } with patch.dict("os.environ", {"TF_CONFIG": json.dumps(tf_config)}): config = run_config_lib.RunConfig( master="localhost:0", evaluation_master="localhost:9991") self.assertEqual(config.master, "localhost:0") self.assertEqual(config.task_id, 2) self.assertEqual(config.num_ps_replicas, 1) self.assertEqual(config.num_worker_replicas, 0) self.assertEqual(config.cluster_spec, server_lib.ClusterSpec(cluster_spec)) self.assertEqual(config.task_type, run_config_lib.TaskType.WORKER) self.assertFalse(config.is_chief) self.assertEqual(config.evaluation_master, "localhost:9991")
def testBostonDNN(self): boston = base.load_boston() feature_columns = [feature_column.real_valued_column("", dimension=13)] regressor = dnn.DNNRegressor( feature_columns=feature_columns, hidden_units=[10, 20, 10], config=run_config.RunConfig(tf_random_seed=1)) regressor.fit(boston.data, boston.target, steps=300, batch_size=boston.data.shape[0]) weights = ([regressor.get_variable_value("dnn/hiddenlayer_0/weights")] + [regressor.get_variable_value("dnn/hiddenlayer_1/weights")] + [regressor.get_variable_value("dnn/hiddenlayer_2/weights")] + [regressor.get_variable_value("dnn/logits/weights")]) self.assertEqual(weights[0].shape, (13, 10)) self.assertEqual(weights[1].shape, (10, 20)) self.assertEqual(weights[2].shape, (20, 10)) self.assertEqual(weights[3].shape, (10, 1)) biases = ([regressor.get_variable_value("dnn/hiddenlayer_0/biases")] + [regressor.get_variable_value("dnn/hiddenlayer_1/biases")] + [regressor.get_variable_value("dnn/hiddenlayer_2/biases")] + [regressor.get_variable_value("dnn/logits/biases")]) self.assertEqual(biases[0].shape, (10,)) self.assertEqual(biases[1].shape, (20,)) self.assertEqual(biases[2].shape, (10,)) self.assertEqual(biases[3].shape, (1,))
def _compare_with_sklearn(self, cov_type): # sklearn version. iterations = 40 np.random.seed(5) sklearn_assignments = np.asarray([0, 0, 1, 0, 0, 0, 1, 0, 0, 1]) sklearn_means = np.asarray([[144.83417719, 254.20130341], [274.38754816, 353.16074346]]) sklearn_covs = np.asarray([[[395.0081194, -4.50389512], [-4.50389512, 408.27543989]], [[385.17484203, -31.27834935], [-31.27834935, 391.74249925]]]) # skflow version. gmm = gmm_lib.GMM(self.num_centers, initial_clusters=self.initial_means, covariance_type=cov_type, config=run_config.RunConfig(tf_random_seed=2)) gmm.fit(input_fn=self.input_fn(), steps=iterations) points = self.points[:10, :] skflow_assignments = [] for item in gmm.predict_assignments( input_fn=self.input_fn(points=points, batch_size=10)): skflow_assignments.append(item) self.assertAllClose(sklearn_assignments, np.ravel(skflow_assignments).astype(int)) self.assertAllClose(sklearn_means, gmm.clusters()) if cov_type == 'full': self.assertAllClose(sklearn_covs, gmm.covariances(), rtol=0.01) else: for d in [0, 1]: self.assertAllClose(np.diag(sklearn_covs[d]), gmm.covariances()[d, :], rtol=0.01)
def testExport(self): """Tests export model for servo.""" def input_fn(): return { 'age': constant_op.constant([1]), 'language': sparse_tensor.SparseTensor(values=['english'], indices=[[0, 0]], dense_shape=[1, 1]) }, constant_op.constant([[1]]) language = feature_column.sparse_column_with_hash_bucket( 'language', 100) feature_columns = [ feature_column.real_valued_column('age'), feature_column.embedding_column(language, dimension=1) ] classifier = debug.DebugClassifier(config=run_config.RunConfig( tf_random_seed=1)) classifier.fit(input_fn=input_fn, steps=5) def default_input_fn(unused_estimator, examples): return feature_column_ops.parse_feature_columns_from_examples( examples, feature_columns) export_dir = tempfile.mkdtemp() classifier.export(export_dir, input_fn=default_input_fn)
def testIrisDNN(self): iris = base.load_iris() feature_columns = [feature_column.real_valued_column("", dimension=4)] classifier = dnn.DNNClassifier( feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3, config=run_config.RunConfig(tf_random_seed=1)) classifier.fit(iris.data, iris.target, max_steps=200) variable_names = classifier.get_variable_names() self.assertEqual( classifier.get_variable_value("dnn/hiddenlayer_0/weights").shape, (4, 10)) self.assertEqual( classifier.get_variable_value("dnn/hiddenlayer_1/weights").shape, (10, 20)) self.assertEqual( classifier.get_variable_value("dnn/hiddenlayer_2/weights").shape, (20, 10)) self.assertEqual( classifier.get_variable_value("dnn/logits/weights").shape, (10, 3)) self.assertIn("dnn/hiddenlayer_0/biases", variable_names) self.assertIn("dnn/hiddenlayer_1/biases", variable_names) self.assertIn("dnn/hiddenlayer_2/biases", variable_names) self.assertIn("dnn/logits/biases", variable_names)
def testTrainEvaluateInferDoesNotThrowErrorWithDnnInput(self): head_fn = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss( loss_reduction=losses.Reduction.SUM_OVER_NONZERO_WEIGHTS) learner_config = learner_pb2.LearnerConfig() learner_config.num_classes = 2 learner_config.constraints.max_tree_depth = 3 model_dir = tempfile.mkdtemp() config = run_config.RunConfig() est = estimator.CoreDNNBoostedTreeCombinedEstimator( head=head_fn, dnn_hidden_units=[1], dnn_feature_columns=[core_feature_column.numeric_column("x")], tree_learner_config=learner_config, num_trees=1, tree_examples_per_layer=3, model_dir=model_dir, config=config, dnn_steps_to_train=10, dnn_input_layer_to_tree=True, tree_feature_columns=[]) # Train for a few steps. est.train(input_fn=_train_input_fn, steps=1000) res = est.evaluate(input_fn=_eval_input_fn, steps=1) self.assertLess(0.5, res["auc"]) est.predict(input_fn=_eval_input_fn)
def testRankingDontThrowExceptionForForEstimator(self): learner_config = learner_pb2.LearnerConfig() learner_config.num_classes = 2 learner_config.constraints.max_tree_depth = 1 model_dir = tempfile.mkdtemp() config = run_config.RunConfig() head_fn = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss( loss_reduction=losses.Reduction.SUM_OVER_NONZERO_WEIGHTS) est = estimator.CoreGradientBoostedDecisionTreeRanker( head=head_fn, learner_config=learner_config, num_trees=1, examples_per_layer=3, model_dir=model_dir, config=config, feature_columns=[ core_feature_column.numeric_column("f1"), core_feature_column.numeric_column("f2") ], ranking_model_pair_keys=("a", "b")) # Train for a few steps. est.train(input_fn=_ranking_train_input_fn, steps=1000) est.evaluate(input_fn=_ranking_train_input_fn, steps=1) est.predict(input_fn=_infer_ranking_train_input_fn)
def testFitAndEvaluateMultiClassFullDontThrowException(self): learner_config = learner_pb2.LearnerConfig() learner_config.num_classes = 3 learner_config.constraints.max_tree_depth = 1 learner_config.multi_class_strategy = ( learner_pb2.LearnerConfig.FULL_HESSIAN) model_dir = tempfile.mkdtemp() config = run_config.RunConfig() classifier = estimator.GradientBoostedDecisionTreeClassifier( learner_config=learner_config, n_classes=learner_config.num_classes, num_trees=1, examples_per_layer=7, model_dir=model_dir, config=config, center_bias=False, feature_columns=[contrib_feature_column.real_valued_column("x")]) classifier.fit(input_fn=_multiclass_train_input_fn, steps=100) classifier.evaluate(input_fn=_eval_input_fn, steps=1) classifier.export(self._export_dir_base) result_iter = classifier.predict(input_fn=_eval_input_fn) for prediction_dict in result_iter: self.assertTrue("classes" in prediction_dict)
def test_fail_output_dir_and_run_config_are_both_set(self): with self.assertRaisesRegexp( ValueError, _CANNOT_SET_BOTH_OUTPUT_DIR_AND_CONFIG_MSG): learn_runner.run(build_experiment, output_dir=_MODIR_DIR, schedule="simple_task", run_config=run_config_lib.RunConfig())
def _experiment_fn(run_config, hparams): del run_config, hparams # unused. # Explicitly use a new run_config. new_config = run_config_lib.RunConfig(model_dir=_MODIR_DIR + "/123") return TestExperiment(config=new_config)
def test_run_with_explicit_local_run(self): run_config = run_config_lib.RunConfig(model_dir=_MODIR_DIR) self.assertEqual( "local_run-" + _MODIR_DIR, learn_runner.run(build_experiment_for_run_config, run_config=run_config, schedule="local_run"))
def test_fail_invalid_hparams_type(self): run_config = run_config_lib.RunConfig(model_dir=_MODIR_DIR) with self.assertRaisesRegexp(ValueError, _INVALID_HPARAMS_ERR_MSG): learn_runner.run(build_experiment_for_run_config, run_config=run_config, schedule="local_run", hparams=["hparams"])
def testCustomMetrics(self): """Tests custom evaluation metrics.""" def _input_fn(num_epochs=None): # Create 4 rows, one of them (y = x), three of them (y=Not(x)) labels = constant_op.constant([[1], [0], [0], [0]]) features = { 'x': input_lib.limit_epochs(array_ops.ones(shape=[4, 1], dtype=dtypes.float32), num_epochs=num_epochs), } return features, labels def _my_metric_op(predictions, labels): # For the case of binary classification, the 2nd column of "predictions" # denotes the model predictions. labels = math_ops.cast(labels, dtypes.float32) predictions = array_ops.strided_slice(predictions, [0, 1], [-1, 2], end_mask=1) labels = math_ops.cast(labels, predictions.dtype) return math_ops.reduce_sum(math_ops.multiply(predictions, labels)) classifier = debug.DebugClassifier(config=run_config.RunConfig( tf_random_seed=1)) classifier.fit(input_fn=_input_fn, steps=5) scores = classifier.evaluate( input_fn=_input_fn, steps=5, metrics={ 'my_accuracy': MetricSpec(metric_fn=metric_ops.streaming_accuracy, prediction_key='classes'), 'my_precision': MetricSpec(metric_fn=metric_ops.streaming_precision, prediction_key='classes'), 'my_metric': MetricSpec(metric_fn=_my_metric_op, prediction_key='probabilities') }) self.assertTrue( set(['loss', 'my_accuracy', 'my_precision', 'my_metric']).issubset(set(scores.keys()))) predict_input_fn = functools.partial(_input_fn, num_epochs=1) predictions = np.array( list(classifier.predict_classes(input_fn=predict_input_fn))) self.assertEqual(_sklearn.accuracy_score([1, 0, 0, 0], predictions), scores['my_accuracy']) # Test the case where the 2nd element of the key is neither "classes" nor # "probabilities". with self.assertRaisesRegexp(KeyError, 'bad_type'): classifier.evaluate(input_fn=_input_fn, steps=5, metrics={ 'bad_name': MetricSpec( metric_fn=metric_ops.streaming_auc, prediction_key='bad_type') })
def test_run_with_custom_schedule(self): run_config = run_config_lib.RunConfig(model_dir=_MODIR_DIR) self.assertEqual( "simple_task, default=None.", learn_runner.run(build_experiment_for_run_config, run_config=run_config, schedule="simple_task"))
def testFitAndEvaluateMultiClassFullDontThrowException(self): n_classes = 3 learner_config = learner_pb2.LearnerConfig() learner_config.num_classes = n_classes learner_config.constraints.max_tree_depth = 1 learner_config.multi_class_strategy = ( learner_pb2.LearnerConfig.FULL_HESSIAN) head_fn = estimator.core_multiclass_head(n_classes=n_classes) model_dir = tempfile.mkdtemp() config = run_config.RunConfig() classifier = estimator.CoreGradientBoostedDecisionTreeEstimator( learner_config=learner_config, head=head_fn, num_trees=1, center_bias=False, examples_per_layer=7, model_dir=model_dir, config=config, feature_columns=[core_feature_column.numeric_column("x")]) classifier.train(input_fn=_multiclass_train_input_fn, steps=100) classifier.evaluate(input_fn=_multiclass_train_input_fn, steps=1) classifier.predict(input_fn=_eval_input_fn)
def test_run_std_server(self, mock_server): # Arrange. tf_config = { 'cluster': self._cluster_spec(), 'task': { 'type': run_config_lib.TaskType.PS, 'index': 1 } } with test.mock.patch.dict('os.environ', {'TF_CONFIG': json.dumps(tf_config)}): config = run_config_lib.RunConfig( master='host2:2222', num_cores=15, gpu_memory_fraction=0.314,) for est in self._estimators_for_tests(config): ex = experiment.Experiment( est, train_input_fn='train_input', eval_input_fn='eval_input') # Act. ex.run_std_server() # Assert. mock_server.assert_has_calls( [test.mock.call().start(), test.mock.call().join()])
def testTrainWithWeights(self): """Tests training with given weight column.""" def _input_fn_train(): # Create 4 rows, one of them (y = x), three of them (y=Not(x)) # First row has more weight than others. Model should fit (y=x) better # than (y=Not(x)) due to the relative higher weight of the first row. labels = constant_op.constant([[1.], [0.], [0.], [0.]]) features = { 'x': array_ops.ones(shape=[4, 1], dtype=dtypes.float32), 'w': constant_op.constant([[100.], [3.], [2.], [2.]]) } return features, labels def _input_fn_eval(): # Create 4 rows (y = x) labels = constant_op.constant([[1.], [1.], [1.], [1.]]) features = { 'x': array_ops.ones(shape=[4, 1], dtype=dtypes.float32), 'w': constant_op.constant([[1.], [1.], [1.], [1.]]) } return features, labels regressor = debug.DebugRegressor( weight_column_name='w', config=run_config.RunConfig(tf_random_seed=1)) regressor.fit(input_fn=_input_fn_train, steps=5) scores = regressor.evaluate(input_fn=_input_fn_eval, steps=1) self.assertIn('loss', scores)
def testLossWithWeights(self): """Tests loss calculation with weights.""" def _input_fn_train(): # 4 rows with equal weight, one of them (y = x), three of them (y=Not(x)) # The algorithm should learn (y = 0.25). labels = constant_op.constant([[1.], [0.], [0.], [0.]]) features = { 'x': array_ops.ones(shape=[4, 1], dtype=dtypes.float32), 'w': constant_op.constant([[1.], [1.], [1.], [1.]]) } return features, labels def _input_fn_eval(): # 4 rows, with different weights. labels = constant_op.constant([[1.], [0.], [0.], [0.]]) features = { 'x': array_ops.ones(shape=[4, 1], dtype=dtypes.float32), 'w': constant_op.constant([[7.], [1.], [1.], [1.]]) } return features, labels regressor = debug.DebugRegressor( weight_column_name='w', config=run_config.RunConfig(tf_random_seed=1)) regressor.fit(input_fn=_input_fn_train, steps=5) scores = regressor.evaluate(input_fn=_input_fn_eval, steps=1) self.assertIn('loss', scores)
def testLearnSineFunction(self): """Tests learning a sine function.""" batch_size = 8 num_unroll = 5 sequence_length = 64 train_steps = 250 eval_steps = 20 num_rnn_layers = 1 num_units = [4] * num_rnn_layers learning_rate = 0.3 loss_threshold = 0.035 def get_sin_input_fn(sequence_length, increment, seed=None): def input_fn(): start = random_ops.random_uniform((), minval=0, maxval=(np.pi * 2.0), dtype=dtypes.float32, seed=seed) sin_curves = math_ops.sin( math_ops.linspace(start, (sequence_length - 1) * increment, sequence_length + 1)) inputs = array_ops.slice(sin_curves, [0], [sequence_length]) labels = array_ops.slice(sin_curves, [1], [sequence_length]) return {'inputs': inputs}, labels return input_fn seq_columns = [ feature_column.real_valued_column('inputs', dimension=1) ] config = run_config.RunConfig(tf_random_seed=1234) dropout_keep_probabilities = [0.9] * (num_rnn_layers + 1) sequence_estimator = ssre.StateSavingRnnEstimator( constants.ProblemType.LINEAR_REGRESSION, num_units=num_units, cell_type='lstm', num_unroll=num_unroll, batch_size=batch_size, sequence_feature_columns=seq_columns, learning_rate=learning_rate, dropout_keep_probabilities=dropout_keep_probabilities, config=config, queue_capacity=2 * batch_size, seed=1234) train_input_fn = get_sin_input_fn(sequence_length, np.pi / 32, seed=1234) eval_input_fn = get_sin_input_fn(sequence_length, np.pi / 32, seed=4321) sequence_estimator.fit(input_fn=train_input_fn, steps=train_steps) loss = sequence_estimator.evaluate(input_fn=eval_input_fn, steps=eval_steps)['loss'] self.assertLess( loss, loss_threshold, 'Loss should be less than {}; got {}'.format(loss_threshold, loss))
def test_no_schedule_and_non_distributed_runs_train_and_evaluate(self): tf_config = {"cluster": build_non_distributed_cluster_spec()} with patch.dict("os.environ", {"TF_CONFIG": json.dumps(tf_config)}): config = run_config_lib.RunConfig() self.assertEqual( "train_and_evaluate-" + _MODIR_DIR, learn_runner.run(build_experiment_fn_for_output_dir(config), output_dir=_MODIR_DIR))
def test_model_dir_fail_if_constructor_value_mismatch_tf_config(self): tf_config = {"model_dir": TEST_DIR} with patch.dict("os.environ", {"TF_CONFIG": json.dumps(tf_config)}): with self.assertRaisesRegexp( ValueError, "`model_dir` provided in RunConfig .* must have " "the same value .* in TF_CONFIG"): run_config_lib.RunConfig(model_dir=TEST_DIR + "/sub_dir")
def testRegression_MatrixData(self): """Tests regression using matrix data as input.""" regressor = debug.DebugRegressor(config=run_config.RunConfig( tf_random_seed=1)) input_fn = test_data.iris_input_logistic_fn regressor.fit(input_fn=input_fn, steps=200) scores = regressor.evaluate(input_fn=input_fn, steps=1) self.assertIn('loss', scores)
def testMultiRNNState(self): """Test that state flattening/reconstruction works for `MultiRNNCell`.""" batch_size = 11 sequence_length = 16 train_steps = 5 cell_sizes = [4, 8, 7] learning_rate = 0.1 def get_shift_input_fn(batch_size, sequence_length, seed=None): def input_fn(): random_sequence = random_ops.random_uniform( [batch_size, sequence_length + 1], 0, 2, dtype=dtypes.int32, seed=seed) labels = array_ops.slice(random_sequence, [0, 0], [batch_size, sequence_length]) inputs = array_ops.expand_dims( math_ops.cast( array_ops.slice(random_sequence, [0, 1], [batch_size, sequence_length]), dtypes.float32), 2) input_dict = { dynamic_rnn_estimator._get_state_name(i): random_ops.random_uniform( [batch_size, cell_size], seed=((i + 1) * seed)) for i, cell_size in enumerate([4, 4, 8, 8, 7, 7]) } input_dict['inputs'] = inputs return input_dict, labels return input_fn seq_columns = [feature_column.real_valued_column('inputs', dimension=1)] config = run_config.RunConfig(tf_random_seed=21212) cell_type = 'lstm' sequence_estimator = dynamic_rnn_estimator.DynamicRnnEstimator( problem_type=constants.ProblemType.CLASSIFICATION, prediction_type=rnn_common.PredictionType.MULTIPLE_VALUE, num_classes=2, num_units=cell_sizes, sequence_feature_columns=seq_columns, cell_type=cell_type, learning_rate=learning_rate, config=config, predict_probabilities=True) train_input_fn = get_shift_input_fn(batch_size, sequence_length, seed=12321) eval_input_fn = get_shift_input_fn(batch_size, sequence_length, seed=32123) sequence_estimator.fit(input_fn=train_input_fn, steps=train_steps) prediction_dict = sequence_estimator.predict( input_fn=eval_input_fn, as_iterable=False) for i, state_size in enumerate([4, 4, 8, 8, 7, 7]): state_piece = prediction_dict[dynamic_rnn_estimator._get_state_name(i)] self.assertListEqual(list(state_piece.shape), [batch_size, state_size])
def test_defaults_with_no_tf_config(self): config = run_config_lib.RunConfig() self.assertEqual(config.master, "") self.assertEqual(config.task_id, 0) self.assertEqual(config.num_ps_replicas, 0) self.assertEqual(config.cluster_spec, {}) self.assertIsNone(config.task_type) self.assertTrue(config.is_chief) self.assertEqual(config.evaluation_master, "")
def testLogisticRegression_MatrixData(self): """Tests binary classification using matrix data as input.""" classifier = debug.DebugClassifier(config=run_config.RunConfig( tf_random_seed=1)) input_fn = test_data.iris_input_logistic_fn classifier.fit(input_fn=input_fn, steps=5) scores = classifier.evaluate(input_fn=input_fn, steps=1) self._assertInRange(0.0, 1.0, scores['accuracy']) self.assertIn('loss', scores)
def testLearnSineFunction(self): """Tests learning a sine function.""" batch_size = 8 sequence_length = 64 train_steps = 200 eval_steps = 20 cell_size = [4] learning_rate = 0.1 loss_threshold = 0.02 def get_sin_input_fn(batch_size, sequence_length, increment, seed=None): def _sin_fn(x): ranger = math_ops.linspace( array_ops.reshape(x[0], []), (sequence_length - 1) * increment, sequence_length + 1) return math_ops.sin(ranger) def input_fn(): starts = random_ops.random_uniform( [batch_size], maxval=(2 * np.pi), seed=seed) sin_curves = map_fn.map_fn( _sin_fn, (starts,), dtype=dtypes.float32) inputs = array_ops.expand_dims( array_ops.slice(sin_curves, [0, 0], [batch_size, sequence_length]), 2) labels = array_ops.slice(sin_curves, [0, 1], [batch_size, sequence_length]) return {'inputs': inputs}, labels return input_fn seq_columns = [ feature_column.real_valued_column( 'inputs', dimension=cell_size[0]) ] config = run_config.RunConfig(tf_random_seed=1234) sequence_estimator = dynamic_rnn_estimator.DynamicRnnEstimator( problem_type=constants.ProblemType.LINEAR_REGRESSION, prediction_type=rnn_common.PredictionType.MULTIPLE_VALUE, num_units=cell_size, sequence_feature_columns=seq_columns, learning_rate=learning_rate, dropout_keep_probabilities=[0.9, 0.9], config=config) train_input_fn = get_sin_input_fn( batch_size, sequence_length, np.pi / 32, seed=1234) eval_input_fn = get_sin_input_fn( batch_size, sequence_length, np.pi / 32, seed=4321) sequence_estimator.fit(input_fn=train_input_fn, steps=train_steps) loss = sequence_estimator.evaluate( input_fn=eval_input_fn, steps=eval_steps)['loss'] self.assertLess(loss, loss_threshold, 'Loss should be less than {}; got {}'.format(loss_threshold, loss))