def testLinearRegression(self): my_seed = 42 config = run_config.RunConfig(tf_random_seed=my_seed) boston = base.load_boston() columns = [feature_column.real_valued_column('', dimension=13)] # We train with with ops.Graph().as_default() as g1: random.seed(my_seed) g1.seed = my_seed variables.create_global_step() regressor1 = linear.LinearRegressor( optimizer=_NULL_OPTIMIZER, feature_columns=columns, config=config) regressor1.fit(x=boston.data, y=boston.target, steps=1) with ops.Graph().as_default() as g2: random.seed(my_seed) g2.seed = my_seed variables.create_global_step() regressor2 = linear.LinearRegressor( optimizer=_NULL_OPTIMIZER, feature_columns=columns, config=config) regressor2.fit(x=boston.data, y=boston.target, steps=1) self.assertAllClose(regressor1.weights_, regressor2.weights_) self.assertAllClose(regressor1.bias_, regressor2.bias_) self.assertAllClose( list(regressor1.predict( boston.data, as_iterable=True)), list(regressor2.predict( boston.data, as_iterable=True)), atol=1e-05)
def testUntrained(self): boston = base.load_boston() est = estimator.SKCompat(estimator.Estimator(model_fn=linear_model_fn)) with self.assertRaises(learn.NotFittedError): _ = est.score(x=boston.data, y=boston.target.astype(np.float64)) with self.assertRaises(learn.NotFittedError): est.predict(x=boston.data)
def testPredictInputFnWithQueue(self): est = estimator.Estimator(model_fn=linear_model_fn) boston = base.load_boston() est.fit(input_fn=boston_input_fn, steps=1) input_fn = functools.partial(boston_input_fn_with_queue, num_epochs=2) output = list(est.predict(input_fn=input_fn)) self.assertEqual(len(output), boston.target.shape[0] * 2)
def testContinueTrainingDictionaryInput(self): boston = base.load_boston() output_dir = tempfile.mkdtemp() est = estimator.Estimator(model_fn=linear_model_fn, model_dir=output_dir) boston_input = {'input': boston.data} float64_target = {'labels': boston.target.astype(np.float64)} est.fit(x=boston_input, y=float64_target, steps=50) scores = est.evaluate( x=boston_input, y=float64_target, metrics={'MSE': metric_ops.streaming_mean_squared_error}) del est # Create another estimator object with the same output dir. est2 = estimator.Estimator(model_fn=linear_model_fn, model_dir=output_dir) # Check we can evaluate and predict. scores2 = est2.evaluate( x=boston_input, y=float64_target, metrics={'MSE': metric_ops.streaming_mean_squared_error}) self.assertAllClose(scores2['MSE'], scores['MSE']) predictions = np.array(list(est2.predict(x=boston_input))) other_score = _sklearn.mean_squared_error(predictions, float64_target['labels']) self.assertAllClose(other_score, scores['MSE'])
def testContinueTraining(self): boston = base.load_boston() output_dir = tempfile.mkdtemp() est = estimator.SKCompat( estimator.Estimator( model_fn=linear_model_fn, model_dir=output_dir)) float64_labels = boston.target.astype(np.float64) est.fit(x=boston.data, y=float64_labels, steps=50) scores = est.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) del est # Create another estimator object with the same output dir. est2 = estimator.SKCompat( estimator.Estimator( model_fn=linear_model_fn, model_dir=output_dir)) # Check we can evaluate and predict. scores2 = est2.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) self.assertAllClose(scores['MSE'], scores2['MSE']) predictions = np.array(list(est2.predict(x=boston.data))) other_score = _sklearn.mean_squared_error(predictions, float64_labels) self.assertAllClose(scores['MSE'], other_score) # Check we can keep training. est2.fit(x=boston.data, y=float64_labels, steps=100) scores3 = est2.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) self.assertLess(scores3['MSE'], scores['MSE'])
def testContinueTraining(self): boston = base.load_boston() output_dir = tempfile.mkdtemp() est = estimator.SKCompat( estimator.Estimator(model_fn=linear_model_fn, model_dir=output_dir)) float64_labels = boston.target.astype(np.float64) est.fit(x=boston.data, y=float64_labels, steps=50) scores = est.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) del est # Create another estimator object with the same output dir. est2 = estimator.SKCompat( estimator.Estimator(model_fn=linear_model_fn, model_dir=output_dir)) # Check we can evaluate and predict. scores2 = est2.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) self.assertAllClose(scores['MSE'], scores2['MSE']) predictions = np.array(list(est2.predict(x=boston.data))) other_score = _sklearn.mean_squared_error(predictions, float64_labels) self.assertAllClose(scores['MSE'], other_score) # Check we can keep training. est2.fit(x=boston.data, y=float64_labels, steps=100) scores3 = est2.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) self.assertLess(scores3['MSE'], scores['MSE'])
def boston_input_fn(num_epochs=None): boston = base.load_boston() features = input_lib.limit_epochs(array_ops.reshape( constant_op.constant(boston.data), [-1, _BOSTON_INPUT_DIM]), num_epochs=num_epochs) labels = array_ops.reshape(constant_op.constant(boston.target), [-1, 1]) return features, labels
def testLinearRegression(self): my_seed = 42 config = run_config.RunConfig(tf_random_seed=my_seed) boston = base.load_boston() columns = [feature_column.real_valued_column('', dimension=13)] # We train with with ops.Graph().as_default() as g1: random.seed(my_seed) g1.seed = my_seed variables.create_global_step() regressor1 = linear.LinearRegressor( optimizer=_NULL_OPTIMIZER, feature_columns=columns, config=config) regressor1.fit(x=boston.data, y=boston.target, steps=1) with ops.Graph().as_default() as g2: random.seed(my_seed) g2.seed = my_seed variables.create_global_step() regressor2 = linear.LinearRegressor( optimizer=_NULL_OPTIMIZER, feature_columns=columns, config=config) regressor2.fit(x=boston.data, y=boston.target, steps=1) self.assertAllClose(regressor1.weights_, regressor2.weights_) self.assertAllClose(regressor1.bias_, regressor2.bias_) self.assertAllClose( list(regressor1.predict_scores( boston.data, as_iterable=True)), list(regressor2.predict_scores( boston.data, as_iterable=True)), atol=1e-05)
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 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 boston_input_fn(num_epochs=None): boston = base.load_boston() features = input_lib.limit_epochs( array_ops.reshape( constant_op.constant(boston.data), [-1, _BOSTON_INPUT_DIM]), num_epochs=num_epochs) labels = array_ops.reshape(constant_op.constant(boston.target), [-1, 1]) return features, labels
def boston_eval_fn(): boston = base.load_boston() n_examples = len(boston.target) features = array_ops.reshape( constant_op.constant(boston.data), [n_examples, _BOSTON_INPUT_DIM]) labels = array_ops.reshape( constant_op.constant(boston.target), [n_examples, 1]) return array_ops.concat([features, features], 0), array_ops.concat( [labels, labels], 0)
def boston_eval_fn(): boston = base.load_boston() n_examples = len(boston.target) features = array_ops.reshape(constant_op.constant(boston.data), [n_examples, _BOSTON_INPUT_DIM]) labels = array_ops.reshape(constant_op.constant(boston.target), [n_examples, 1]) return array_ops.concat([features, features], 0), array_ops.concat([labels, labels], 0)
def boston_input_fn(): boston = base.load_boston() features = math_ops.cast( array_ops.reshape(constant_op.constant(boston.data), [-1, 13]), dtypes.float32) labels = math_ops.cast( array_ops.reshape(constant_op.constant(boston.target), [-1, 1]), dtypes.float32) return features, labels
def testWithModelFnOps(self): """Test for model_fn that returns `ModelFnOps`.""" est = estimator.Estimator(model_fn=linear_model_fn_with_model_fn_ops) boston = base.load_boston() est.fit(input_fn=boston_input_fn, steps=1) input_fn = functools.partial(boston_input_fn, num_epochs=1) scores = est.evaluate(input_fn=input_fn, steps=1) self.assertIn('loss', scores.keys()) output = list(est.predict(input_fn=input_fn)) self.assertEqual(len(output), boston.target.shape[0])
def _get_regression_input_fns(): boston = base.load_boston() data = boston.data.astype(np.float32) labels = boston.target.astype(np.int32) train_input_fn = numpy_io.numpy_input_fn( x=data, y=labels, batch_size=506, num_epochs=None, shuffle=False) predict_input_fn = numpy_io.numpy_input_fn( x=data[:1,], y=None, batch_size=1, num_epochs=1, shuffle=False) return train_input_fn, predict_input_fn
def testPredictConstInputFn(self): est = estimator.Estimator(model_fn=linear_model_fn) boston = base.load_boston() est.fit(input_fn=boston_input_fn, steps=1) def input_fn(): features = array_ops.reshape( constant_op.constant(boston.data), [-1, _BOSTON_INPUT_DIM]) labels = array_ops.reshape(constant_op.constant(boston.target), [-1, 1]) return features, labels output = list(est.predict(input_fn=input_fn)) self.assertEqual(len(output), boston.target.shape[0])
def testBostonAll(self): boston = base.load_boston() est = estimator.SKCompat(estimator.Estimator(model_fn=linear_model_fn)) float64_labels = boston.target.astype(np.float64) est.fit(x=boston.data, y=float64_labels, steps=100) scores = est.score( x=boston.data, y=float64_labels, metrics={'MSE': metric_ops.streaming_mean_squared_error}) predictions = np.array(list(est.predict(x=boston.data))) other_score = _sklearn.mean_squared_error(predictions, boston.target) self.assertAllClose(scores['MSE'], other_score) self.assertTrue('global_step' in scores) self.assertEqual(100, scores['global_step'])
def testBostonAllDictionaryInput(self): boston = base.load_boston() est = estimator.Estimator(model_fn=linear_model_fn) boston_input = {'input': boston.data} float64_target = {'labels': boston.target.astype(np.float64)} est.fit(x=boston_input, y=float64_target, steps=100) scores = est.evaluate( x=boston_input, y=float64_target, metrics={'MSE': metric_ops.streaming_mean_squared_error}) predictions = np.array(list(est.predict(x=boston_input))) other_score = _sklearn.mean_squared_error(predictions, boston.target) self.assertAllClose(other_score, scores['MSE']) self.assertTrue('global_step' in scores) self.assertEqual(scores['global_step'], 100)
def testDNNRegression(self): my_seed = 42 config = run_config.RunConfig(tf_random_seed=my_seed) boston = base.load_boston() columns = [feature_column.real_valued_column('', dimension=13)] with ops.Graph().as_default() as g1: random.seed(my_seed) g1.seed = my_seed variables.create_global_step() regressor1 = dnn.DNNRegressor( hidden_units=[10], feature_columns=columns, optimizer=_NULL_OPTIMIZER, config=config) regressor1.fit(x=boston.data, y=boston.target, steps=1) with ops.Graph().as_default() as g2: random.seed(my_seed) g2.seed = my_seed variables.create_global_step() regressor2 = dnn.DNNRegressor( hidden_units=[10], feature_columns=columns, optimizer=_NULL_OPTIMIZER, config=config) regressor2.fit(x=boston.data, y=boston.target, steps=1) weights1 = ([regressor1.get_variable_value('dnn/hiddenlayer_0/weights')] + [regressor1.get_variable_value('dnn/logits/weights')]) weights2 = ([regressor2.get_variable_value('dnn/hiddenlayer_0/weights')] + [regressor2.get_variable_value('dnn/logits/weights')]) for w1, w2 in zip(weights1, weights2): self.assertAllClose(w1, w2) biases1 = ([regressor1.get_variable_value('dnn/hiddenlayer_0/biases')] + [regressor1.get_variable_value('dnn/logits/biases')]) biases2 = ([regressor2.get_variable_value('dnn/hiddenlayer_0/biases')] + [regressor2.get_variable_value('dnn/logits/biases')]) for b1, b2 in zip(biases1, biases2): self.assertAllClose(b1, b2) self.assertAllClose( list(regressor1.predict_scores( boston.data, as_iterable=True)), list(regressor2.predict_scores( boston.data, as_iterable=True)), atol=1e-05)
def testDNNRegression(self): my_seed = 42 config = run_config.RunConfig(tf_random_seed=my_seed) boston = base.load_boston() columns = [feature_column.real_valued_column('', dimension=13)] with ops.Graph().as_default() as g1: random.seed(my_seed) g1.seed = my_seed variables.create_global_step() regressor1 = dnn.DNNRegressor( hidden_units=[10], feature_columns=columns, optimizer=_NULL_OPTIMIZER, config=config) regressor1.fit(x=boston.data, y=boston.target, steps=1) with ops.Graph().as_default() as g2: random.seed(my_seed) g2.seed = my_seed variables.create_global_step() regressor2 = dnn.DNNRegressor( hidden_units=[10], feature_columns=columns, optimizer=_NULL_OPTIMIZER, config=config) regressor2.fit(x=boston.data, y=boston.target, steps=1) weights1 = ([regressor1.get_variable_value('dnn/hiddenlayer_0/weights')] + [regressor1.get_variable_value('dnn/logits/weights')]) weights2 = ([regressor2.get_variable_value('dnn/hiddenlayer_0/weights')] + [regressor2.get_variable_value('dnn/logits/weights')]) for w1, w2 in zip(weights1, weights2): self.assertAllClose(w1, w2) biases1 = ([regressor1.get_variable_value('dnn/hiddenlayer_0/biases')] + [regressor1.get_variable_value('dnn/logits/biases')]) biases2 = ([regressor2.get_variable_value('dnn/hiddenlayer_0/biases')] + [regressor2.get_variable_value('dnn/logits/biases')]) for b1, b2 in zip(biases1, biases2): self.assertAllClose(b1, b2) self.assertAllClose( list(regressor1.predict( boston.data, as_iterable=True)), list(regressor2.predict( boston.data, as_iterable=True)), atol=1e-05)
def _get_regression_input_fns(): boston = base.load_boston() data = boston.data.astype(np.float32) labels = boston.target.astype(np.int32) train_input_fn = numpy_io.numpy_input_fn(x=data, y=labels, batch_size=506, num_epochs=None, shuffle=False) predict_input_fn = numpy_io.numpy_input_fn(x=data[:1, ], y=None, batch_size=1, num_epochs=1, shuffle=False) return train_input_fn, predict_input_fn
def testRegression(self): """Tests multi-class classification using matrix data as input.""" hparams = tensor_forest.ForestHParams(num_trees=3, max_nodes=1000, num_classes=1, num_features=13, regression=True, split_after_samples=20) regressor = random_forest.TensorForestEstimator(hparams.fill()) boston = base.load_boston() data = boston.data.astype(np.float32) labels = boston.target.astype(np.int32) regressor.fit(x=data, y=labels, steps=100, batch_size=50) regressor.evaluate(x=data, y=labels, steps=10)
def testRegression(self): """Tests multi-class classification using matrix data as input.""" hparams = tensor_forest.ForestHParams( num_trees=3, max_nodes=1000, num_classes=1, num_features=13, regression=True, split_after_samples=20) regressor = random_forest.TensorForestEstimator(hparams.fill()) boston = base.load_boston() data = boston.data.astype(np.float32) labels = boston.target.astype(np.int32) regressor.fit(x=data, y=labels, steps=100, batch_size=50) regressor.evaluate(x=data, y=labels, steps=10)
# -*- coding: utf-8 -*- from tensorflow.contrib.learn.python.learn.datasets import base iris_data, iris_label = base.load_iris() house_data, house_label = base.load_boston()
def testEstimatorParams(self): boston = base.load_boston() est = estimator.SKCompat( estimator.Estimator( model_fn=linear_model_params_fn, params={'learning_rate': 0.01})) est.fit(x=boston.data, y=boston.target, steps=100)
def testPredict(self): est = estimator.Estimator(model_fn=linear_model_fn) boston = base.load_boston() est.fit(input_fn=boston_input_fn, steps=1) output = list(est.predict(x=boston.data, batch_size=10)) self.assertEqual(len(output), boston.target.shape[0])
def testEstimatorParams(self): boston = base.load_boston() est = estimator.SKCompat( estimator.Estimator(model_fn=linear_model_params_fn, params={'learning_rate': 0.01})) est.fit(x=boston.data, y=boston.target, steps=100)