Delete deprecated TensorFlowDNN(Regressor|Classifier). Also add tf_random_seed to fix flakiness for the affected tests.

Change: 132347779

tensorflow/contrib/learn/__init__.py

@@ -25,8 +25,6 @@ Train and evaluate TensorFlow models.
 @@ModeKeys
 @@DNNClassifier
 @@DNNRegressor
-@@TensorFlowDNNClassifier
-@@TensorFlowDNNRegressor
 @@TensorFlowEstimator
 @@LinearClassifier
 @@LinearRegressor

tensorflow/contrib/learn/python/learn/estimators/__init__.py

@@ -26,8 +26,6 @@ from tensorflow.contrib.learn.python.learn.estimators.base import TensorFlowEsti
 from tensorflow.contrib.learn.python.learn.estimators.classifier import Classifier
 from tensorflow.contrib.learn.python.learn.estimators.dnn import DNNClassifier
 from tensorflow.contrib.learn.python.learn.estimators.dnn import DNNRegressor
-from tensorflow.contrib.learn.python.learn.estimators.dnn import TensorFlowDNNClassifier
-from tensorflow.contrib.learn.python.learn.estimators.dnn import TensorFlowDNNRegressor
 from tensorflow.contrib.learn.python.learn.estimators.dnn_linear_combined import DNNLinearCombinedClassifier
 from tensorflow.contrib.learn.python.learn.estimators.dnn_linear_combined import DNNLinearCombinedRegressor
 from tensorflow.contrib.learn.python.learn.estimators.estimator import BaseEstimator

tensorflow/contrib/learn/python/learn/estimators/dnn.py

@@ -19,9 +19,7 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-from tensorflow.contrib.learn.python.learn.estimators import _sklearn
 from tensorflow.contrib.learn.python.learn.estimators import dnn_linear_combined
-from tensorflow.contrib.learn.python.learn.estimators.base import DeprecatedMixin
 from tensorflow.python.ops import nn
 
 
@@ -279,14 +277,3 @@ class DNNRegressor(dnn_linear_combined.DNNLinearCombinedRegressor):
   @property
   def bias_(self):
     return self.dnn_bias_
-
-
-# TensorFlowDNNClassifier and TensorFlowDNNRegressor are deprecated.
-class TensorFlowDNNClassifier(DeprecatedMixin, DNNClassifier,
-                              _sklearn.ClassifierMixin):
-  pass
-
-
-class TensorFlowDNNRegressor(DeprecatedMixin, DNNRegressor,
-                             _sklearn.RegressorMixin):
-  pass

tensorflow/contrib/learn/python/learn/tests/early_stopping_test.py

@@ -47,26 +47,29 @@ class EarlyStoppingTest(tf.test.TestCase):
         x_train, y_train, test_size=0.2, random_state=42)
     val_monitor = learn.monitors.ValidationMonitor(
         x_val, y_val, every_n_steps=50, early_stopping_rounds=100,
-        early_stopping_metric='accuracy', early_stopping_metric_minimize=False)
+        early_stopping_metric='loss', early_stopping_metric_minimize=False)
+
+    feature_columns = learn.infer_real_valued_columns_from_input(iris.data)
 
     # classifier without early stopping - overfitting
-    classifier1 = learn.TensorFlowDNNClassifier(
+    classifier1 = learn.DNNClassifier(
-        hidden_units=[10, 20, 10], n_classes=3, steps=1000)
+        feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)
-    classifier1.fit(x_train, y_train)
+    classifier1.fit(x_train, y_train, steps=1000)
     _ = accuracy_score(y_test, classifier1.predict(x_test))
 
-    # Full 1000 steps, 12 summaries and no evaluation summary.
+    # Full 1000 steps, 19 summaries and no evaluation summary:
-    # 12 summaries = global_step + first + every 100 out of 1000 steps.
+    # 1 summary of net at step 1
-    self.assertEqual(12, len(_get_summary_events(classifier1.model_dir)))
+    # 9 x (1 summary of net and 1 summary of global step) for steps 101, 201,...
+    self.assertEqual(19, len(_get_summary_events(classifier1.model_dir)))
     with self.assertRaises(ValueError):
       _get_summary_events(classifier1.model_dir + '/eval')
 
     # classifier with early stopping - improved accuracy on testing set
-    classifier2 = learn.TensorFlowDNNClassifier(
+    classifier2 = learn.DNNClassifier(
-        hidden_units=[10, 20, 10], n_classes=3, steps=2000,
+        hidden_units=[10, 20, 10], feature_columns=feature_columns, n_classes=3,
         config=tf.contrib.learn.RunConfig(save_checkpoints_secs=1))
 
-    classifier2.fit(x_train, y_train, monitors=[val_monitor])
+    classifier2.fit(x_train, y_train, monitors=[val_monitor], steps=2000)
     _ = accuracy_score(y_val, classifier2.predict(x_val))
     _ = accuracy_score(y_test, classifier2.predict(x_test))
 

tensorflow/contrib/learn/python/learn/tests/estimators_test.py

@@ -41,19 +41,18 @@ class InferredfeatureColumnTest(tf.test.TestCase):
                                                         test_size=0.2,
                                                         random_state=42)
 
-    def custom_optimizer(learning_rate):
+    def custom_optimizer():
-      return tf.train.MomentumOptimizer(learning_rate, 0.9)
+      return tf.train.MomentumOptimizer(learning_rate=0.01, momentum=0.9)
 
     cont_features = [
         tf.contrib.layers.real_valued_column("", dimension=4)]
-    classifier = learn.TensorFlowDNNClassifier(
+    classifier = learn.DNNClassifier(
         feature_columns=cont_features,
         hidden_units=[10, 20, 10],
         n_classes=3,
-        steps=400,
+        optimizer=custom_optimizer,
-        learning_rate=0.01,
+        config=learn.RunConfig(tf_random_seed=1))
-        optimizer=custom_optimizer)
+    classifier.fit(x_train, y_train, steps=400)
-    classifier.fit(x_train, y_train)
     score = accuracy_score(y_test, classifier.predict(x_test))
 
     self.assertGreater(score, 0.65, "Failed with score = {0}".format(score))
@@ -71,17 +70,16 @@ class CustomOptimizer(tf.test.TestCase):
                                                         test_size=0.2,
                                                         random_state=42)
 
-    def custom_optimizer(learning_rate):
+    def custom_optimizer():
-      return tf.train.MomentumOptimizer(learning_rate, 0.9)
+      return tf.train.MomentumOptimizer(learning_rate=0.01, momentum=0.9)
 
-    classifier = learn.TensorFlowDNNClassifier(
+    classifier = learn.DNNClassifier(
         hidden_units=[10, 20, 10],
         feature_columns=learn.infer_real_valued_columns_from_input(x_train),
         n_classes=3,
-        steps=400,
+        optimizer=custom_optimizer,
-        learning_rate=0.01,
+        config=learn.RunConfig(tf_random_seed=1))
-        optimizer=custom_optimizer)
+    classifier.fit(x_train, y_train, steps=400)
-    classifier.fit(x_train, y_train)
     score = accuracy_score(y_test, classifier.predict(x_test))
 
     self.assertGreater(score, 0.65, "Failed with score = {0}".format(score))

tensorflow/contrib/learn/python/learn/tests/grid_search_test.py

@@ -43,12 +43,14 @@ class GridSearchTest(tf.test.TestCase):
     if HAS_SKLEARN:
       random.seed(42)
       iris = datasets.load_iris()
-      classifier = learn.TensorFlowDNNClassifier(hidden_units=[10, 20, 10],
+      feature_columns = learn.infer_real_valued_columns_from_input(iris.data)
-                                                 n_classes=3,
+      classifier = learn.DNNClassifier(
-                                                 steps=50)
+          feature_columns=feature_columns, hidden_units=[10, 20, 10],
+          n_classes=3)
       grid_search = GridSearchCV(classifier,
-                                 {'hidden_units': [[5, 5], [10, 10]],
+                                 {'hidden_units': [[5, 5], [10, 10]]},
-                                  'learning_rate': [0.1, 0.01]})
+                                 scoring='accuracy',
+                                 fit_params={'steps': [50]})
       grid_search.fit(iris.data, iris.target)
       score = accuracy_score(iris.target, grid_search.predict(iris.data))
       self.assertGreater(score, 0.5, 'Failed with score = {0}'.format(score))

tensorflow/contrib/learn/python/learn/tests/nonlinear_test.py

@@ -37,9 +37,10 @@ class NonLinearTest(tf.test.TestCase):
   def testIrisDNN(self):
     iris = tf.contrib.learn.datasets.load_iris()
     feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
-    classifier = tf.contrib.learn.TensorFlowDNNClassifier(
+    classifier = tf.contrib.learn.DNNClassifier(
-        feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)
+        feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3,
-    classifier.fit(iris.data, iris.target)
+        config=tf.contrib.learn.RunConfig(tf_random_seed=1))
+    classifier.fit(iris.data, iris.target, max_steps=200)
     score = accuracy_score(iris.target, classifier.predict(iris.data))
     self.assertGreater(score, 0.9, "Failed with score = {0}".format(score))
     weights = classifier.weights_
@@ -53,10 +54,11 @@ class NonLinearTest(tf.test.TestCase):
   def testBostonDNN(self):
     boston = tf.contrib.learn.datasets.load_boston()
     feature_columns = [tf.contrib.layers.real_valued_column("", dimension=13)]
-    regressor = tf.contrib.learn.TensorFlowDNNRegressor(
+    regressor = tf.contrib.learn.DNNRegressor(
-        feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=0,
+        feature_columns=feature_columns, hidden_units=[10, 20, 10],
-        batch_size=boston.data.shape[0], steps=300, learning_rate=0.01)
+        config=tf.contrib.learn.RunConfig(tf_random_seed=1))
-    regressor.fit(boston.data, boston.target)
+    regressor.fit(
+        boston.data, boston.target, steps=300, batch_size=boston.data.shape[0])
     score = mean_squared_error(boston.target, regressor.predict(boston.data))
     self.assertLess(score, 110, "Failed with score = {0}".format(score))
     weights = regressor.weights_
@@ -71,10 +73,10 @@ class NonLinearTest(tf.test.TestCase):
     # Dropout prob == 0.
     iris = tf.contrib.learn.datasets.load_iris()
     feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
-    classifier = tf.contrib.learn.TensorFlowDNNClassifier(
+    classifier = tf.contrib.learn.DNNClassifier(
         feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3,
-        dropout=0.0)
+        dropout=0.0, config=tf.contrib.learn.RunConfig(tf_random_seed=1))
-    classifier.fit(iris.data, iris.target)
+    classifier.fit(iris.data, iris.target, max_steps=200)
     score = accuracy_score(iris.target, classifier.predict(iris.data))
     self.assertGreater(score, 0.9, "Failed with score = {0}".format(score))
 
@@ -82,10 +84,10 @@ class NonLinearTest(tf.test.TestCase):
     # Dropping only a little.
     iris = tf.contrib.learn.datasets.load_iris()
     feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
-    classifier = tf.contrib.learn.TensorFlowDNNClassifier(
+    classifier = tf.contrib.learn.DNNClassifier(
         feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3,
-        dropout=0.1)
+        dropout=0.1, config=tf.contrib.learn.RunConfig(tf_random_seed=1))
-    classifier.fit(iris.data, iris.target)
+    classifier.fit(iris.data, iris.target, max_steps=200)
     score = accuracy_score(iris.target, classifier.predict(iris.data))
     # If the quality is lower - dropout is not working.
     self.assertGreater(score, 0.9, "Failed with score = {0}".format(score))
@@ -94,10 +96,10 @@ class NonLinearTest(tf.test.TestCase):
     # Dropping out most of it.
     iris = tf.contrib.learn.datasets.load_iris()
     feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]
-    classifier = tf.contrib.learn.TensorFlowDNNClassifier(
+    classifier = tf.contrib.learn.DNNClassifier(
         feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3,
-        dropout=0.9)
+        dropout=0.9, config=tf.contrib.learn.RunConfig(tf_random_seed=1))
-    classifier.fit(iris.data, iris.target)
+    classifier.fit(iris.data, iris.target, max_steps=200)
     score = accuracy_score(iris.target, classifier.predict(iris.data))
     self.assertGreater(score, 0.3, "Failed with score = {0}".format(score))
     # If the quality is higher - dropout is not working.

tensorflow/contrib/learn/python/learn/tests/saver_test.py

@@ -62,17 +62,17 @@ class SaverTest(tf.test.TestCase):
     # self.assertGreater(score, 0.5, 'Failed with score = {0}'.format(score))
 
   def testDNN(self):
-    path = tf.test.get_temp_dir() + '/tmp_saver3'
     random.seed(42)
     iris = datasets.load_iris()
     cont_features = [
         tf.contrib.layers.real_valued_column('', dimension=4)]
-    classifier = learn.TensorFlowDNNClassifier(feature_columns=cont_features,
+    classifier = learn.DNNClassifier(feature_columns=cont_features,
-                                               hidden_units=[10, 20, 10],
+                                     hidden_units=[10, 20, 10],
-                                               n_classes=3)
+                                     n_classes=3)
-    classifier.fit(iris.data, iris.target)
+    classifier.fit(iris.data, iris.target, max_steps=100)
-    classifier.save(path)
     # TODO(ipolosukhin): Remove or restore.
+    # path = tf.test.get_temp_dir() + '/tmp_saver3'
+    # classifier.save(path)
     # new_classifier = learn.TensorFlowEstimator.restore(path)
     # self.assertEqual(type(new_classifier), type(classifier))
     # score = accuracy_score(iris.target, new_classifier.predict(iris.data))
@@ -83,17 +83,17 @@ class SaverTest(tf.test.TestCase):
       learn.TensorFlowEstimator.restore('no_model_path')
 
   def testNoCheckpoints(self):
-    path = tf.test.get_temp_dir() + '/tmp/tmp.saver4'
     random.seed(42)
     iris = datasets.load_iris()
     cont_features = [
         tf.contrib.layers.real_valued_column('', dimension=4)]
-    classifier = learn.TensorFlowDNNClassifier(feature_columns=cont_features,
+    classifier = learn.DNNClassifier(feature_columns=cont_features,
-                                               hidden_units=[10, 20, 10],
+                                     hidden_units=[10, 20, 10],
-                                               n_classes=3)
+                                     n_classes=3)
-    classifier.fit(iris.data, iris.target)
+    classifier.fit(iris.data, iris.target, max_steps=100)
-    classifier.save(path)
     # TODO(ipolosukhin): Remove or restore.
+    # path = tf.test.get_temp_dir() + '/tmp/tmp.saver4'
+    # classifier.save(path)
 #     os.remove(os.path.join(path, 'checkpoint'))
 #     with self.assertRaises(NotImplementedError):
 #       learn.TensorFlowEstimator.restore(path)

tensorflow/examples/skflow/hdf5_classification.py

@@ -45,12 +45,11 @@ y_test = h5f['y_test']
 
 # Build 3 layer DNN with 10, 20, 10 units respectively.
 feature_columns = learn.infer_real_valued_columns_from_input(x_train)
-classifier = learn.TensorFlowDNNClassifier(
+classifier = learn.DNNClassifier(
-    feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3,
+    feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)
-    steps=200)
 
 # Fit and predict.
-classifier.fit(x_train, y_train)
+classifier.fit(x_train, y_train, steps=200)
 score = metrics.accuracy_score(y_test, classifier.predict(x_test))
 print('Accuracy: {0:f}'.format(score))
 

tensorflow/g3doc/contrib/learn/get_started/index.md

@@ -44,8 +44,10 @@ Example of 3 layer network with 10, 20 and 10 hidden units respectively:
     from sklearn import datasets, metrics
 
     iris = datasets.load_iris()
-    classifier = learn.TensorFlowDNNClassifier(hidden_units=[10, 20, 10], n_classes=3)
+    feature_columns = learn.infer_real_valued_columns_from_input(iris.data)
-    classifier.fit(iris.data, iris.target)
+    classifier = learn.DNNClassifier(
+        feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)
+    classifier.fit(iris.data, iris.target, steps=100)
     score = metrics.accuracy_score(iris.target, classifier.predict(iris.data))
     print("Accuracy: %f" % score)