def testCustomOptimizerByFunction(self):
    """Tests binary classification using matrix data as input."""
    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_features = [
        tf.contrib.layers.real_valued_column('feature', dimension=4)
    ]
    bucketized_features = [
        tf.contrib.layers.bucketized_column(
            cont_features[0],
            test_data.get_quantile_based_buckets(iris.data, 10))
    ]

    def _optimizer_exp_decay():
      global_step = tf.contrib.framework.get_global_step()
      learning_rate = tf.train.exponential_decay(learning_rate=0.1,
                                                 global_step=global_step,
                                                 decay_steps=100,
                                                 decay_rate=0.001)
      return tf.train.AdagradOptimizer(learning_rate=learning_rate)

    classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
        linear_feature_columns=bucketized_features,
        linear_optimizer=_optimizer_exp_decay,
        dnn_feature_columns=cont_features,
        dnn_hidden_units=[3, 3],
        dnn_optimizer=_optimizer_exp_decay)

    classifier.fit(input_fn=test_data.iris_input_logistic_fn, steps=100)
    scores = classifier.evaluate(
        input_fn=test_data.iris_input_logistic_fn, steps=100)
    _assert_metrics_in_range(('accuracy',), scores)

 def _input_fn():
   iris = test_data.prepare_iris_data_for_logistic_regression()
   return {
       'feature': constant_op.constant(
           iris.data, dtype=dtypes.float32)
   }, constant_op.constant(
       iris.target, shape=[100], dtype=dtypes.int32)

 def testRegression_NpMatrixData(self):
   """Tests binary classification using numpy matrix data as input."""
   iris = test_data.prepare_iris_data_for_logistic_regression()
   train_x = iris.data
   train_y = iris.target
   regressor = debug.DebugRegressor(
       config=run_config.RunConfig(tf_random_seed=1))
   regressor.fit(x=train_x, y=train_y, steps=200)
   scores = regressor.evaluate(x=train_x, y=train_y, steps=1)
   self.assertIn('loss', scores)

 def testLogisticRegression_NpMatrixData(self):
   """Tests binary classification using numpy matrix data as input."""
   iris = test_data.prepare_iris_data_for_logistic_regression()
   train_x = iris.data
   train_y = iris.target
   classifier = debug.DebugClassifier(
       config=run_config.RunConfig(tf_random_seed=1))
   classifier.fit(x=train_x, y=train_y, steps=5)
   scores = classifier.evaluate(x=train_x, y=train_y, steps=1)
   self._assertInRange(0.0, 1.0, scores['accuracy'])

  def testRegression_NpMatrixData(self):
    """Tests binary classification using numpy matrix data as input."""
    iris = test_data.prepare_iris_data_for_logistic_regression()
    train_x = iris.data
    train_y = iris.target
    feature_columns = [tf.contrib.layers.real_valued_column('', dimension=4)]
    regressor = tf.contrib.learn.DNNRegressor(
        feature_columns=feature_columns,
        hidden_units=[3, 3],
        config=tf.contrib.learn.RunConfig(tf_random_seed=1))

    regressor.fit(x=train_x, y=train_y, steps=200)
    scores = regressor.evaluate(x=train_x, y=train_y, steps=1)
    self.assertIn('loss', scores)

  def testLogisticRegression_NpMatrixData(self):
    """Tests binary classification using numpy matrix data as input."""
    iris = test_data.prepare_iris_data_for_logistic_regression()
    train_x = iris.data
    train_y = iris.target
    feature_columns = [tf.contrib.layers.real_valued_column('', dimension=4)]
    classifier = tf.contrib.learn.DNNClassifier(
        feature_columns=feature_columns,
        hidden_units=[3, 3],
        config=tf.contrib.learn.RunConfig(tf_random_seed=1))

    classifier.fit(x=train_x, y=train_y, steps=5)
    scores = classifier.evaluate(x=train_x, y=train_y, steps=1)
    self._assertInRange(0.0, 1.0, scores['accuracy'])

  def benchmarkTensorData(self):

    def _input_fn():
      iris = test_data.prepare_iris_data_for_logistic_regression()
      features = {}
      for i in range(4):
        # The following shows how to provide the Tensor data for
        # RealValuedColumns.
        features.update({
            str(i):
                array_ops.reshape(
                    constant_op.constant(
                        iris.data[:, i], dtype=dtypes.float32), (-1, 1))
        })
      # The following shows how to provide the SparseTensor data for
      # a SparseColumn.
      features['dummy_sparse_column'] = sparse_tensor.SparseTensor(
          values=('en', 'fr', 'zh'),
          indices=((0, 0), (0, 1), (60, 0)),
          dense_shape=(len(iris.target), 2))
      labels = array_ops.reshape(
          constant_op.constant(
              iris.target, dtype=dtypes.int32), (-1, 1))
      return features, labels

    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_features = [
        feature_column.real_valued_column(str(i)) for i in range(4)
    ]
    linear_features = [
        feature_column.bucketized_column(
            cont_features[i],
            test_data.get_quantile_based_buckets(iris.data[:, i], 10))
        for i in range(4)
    ]
    linear_features.append(
        feature_column.sparse_column_with_hash_bucket(
            'dummy_sparse_column', hash_bucket_size=100))

    classifier = dnn_linear_combined.DNNLinearCombinedClassifier(
        model_dir=tempfile.mkdtemp(),
        linear_feature_columns=linear_features,
        dnn_feature_columns=cont_features,
        dnn_hidden_units=(3, 3))

    metrics = classifier.fit(input_fn=_input_fn, steps=_ITERS).evaluate(
        input_fn=_input_fn, steps=100)
    self._assertSingleClassMetrics(metrics)

  def benchmarkMatrixData(self):
    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_feature = tf.contrib.layers.real_valued_column('feature', dimension=4)
    bucketized_feature = tf.contrib.layers.bucketized_column(
        cont_feature, test_data.get_quantile_based_buckets(iris.data, 10))

    classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
        model_dir=tempfile.mkdtemp(),
        linear_feature_columns=(bucketized_feature,),
        dnn_feature_columns=(cont_feature,),
        dnn_hidden_units=(3, 3))

    input_fn = test_data.iris_input_logistic_fn
    metrics = classifier.fit(input_fn=input_fn, steps=_ITERS).evaluate(
        input_fn=input_fn, steps=100)
    self._assertSingleClassMetrics(metrics)

 def _input_fn():
   iris = test_data.prepare_iris_data_for_logistic_regression()
   features = {}
   for i in range(4):
     # The following shows how to provide the Tensor data for
     # RealValuedColumns.
     features.update({
         str(i): tf.reshape(
             tf.constant(iris.data[:, i], dtype=tf.float32), (-1, 1))})
   # The following shows how to provide the SparseTensor data for
   # a SparseColumn.
   features['dummy_sparse_column'] = tf.SparseTensor(
       values=('en', 'fr', 'zh'),
       indices=((0, 0), (0, 1), (60, 0)),
       dense_shape=(len(iris.target), 2))
   labels = tf.reshape(tf.constant(iris.target, dtype=tf.int32), (-1, 1))
   return features, labels

  def testLogisticRegression_MatrixData(self):
    """Tests binary classification using matrix data as input."""
    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_features = [
        tf.contrib.layers.real_valued_column('feature', dimension=4)]
    bucketized_feature = [tf.contrib.layers.bucketized_column(
        cont_features[0], test_data.get_quantile_based_buckets(iris.data, 10))]

    classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
        linear_feature_columns=bucketized_feature,
        dnn_feature_columns=cont_features,
        dnn_hidden_units=[3, 3])

    classifier.fit(input_fn=test_data.iris_input_logistic_fn, steps=100)
    scores = classifier.evaluate(
        input_fn=test_data.iris_input_logistic_fn, steps=100)
    _assert_metrics_in_range(('accuracy', 'auc'), scores)

  def benchmarkLogisticNpMatrixData(self):
    classifier = tf.contrib.learn.DNNClassifier(
        feature_columns=(
            tf.contrib.layers.real_valued_column('', dimension=4),),
        hidden_units=(3, 3),
        config=tf.contrib.learn.RunConfig(tf_random_seed=1))
    iris = test_data.prepare_iris_data_for_logistic_regression()
    train_x = iris.data
    train_y = iris.target
    steps = 100
    metrics = classifier.fit(x=train_x, y=train_y, steps=steps).evaluate(
        x=train_x, y=train_y, steps=1)
    estimator_test_utils.assert_in_range(
        steps, steps + 5, 'global_step', metrics)
    estimator_test_utils.assert_in_range(0.8, 1.0, 'accuracy', metrics)

    self._report_metrics(metrics)

  def benchmarkCustomOptimizer(self):
    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_feature = feature_column.real_valued_column('feature', dimension=4)
    bucketized_feature = feature_column.bucketized_column(
        cont_feature, test_data.get_quantile_based_buckets(iris.data, 10))

    classifier = dnn_linear_combined.DNNLinearCombinedClassifier(
        model_dir=tempfile.mkdtemp(),
        linear_feature_columns=(bucketized_feature,),
        linear_optimizer=ftrl.FtrlOptimizer(learning_rate=0.1),
        dnn_feature_columns=(cont_feature,),
        dnn_hidden_units=(3, 3),
        dnn_optimizer=adagrad.AdagradOptimizer(learning_rate=0.1))

    input_fn = test_data.iris_input_logistic_fn
    metrics = classifier.fit(input_fn=input_fn, steps=_ITERS).evaluate(
        input_fn=input_fn, steps=100)
    self._assertSingleClassMetrics(metrics)

  def testCustomOptimizerByObject(self):
    """Tests binary classification using matrix data as input."""
    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_features = [
        tf.contrib.layers.real_valued_column('feature', dimension=4)]
    bucketized_features = [
        tf.contrib.layers.bucketized_column(
            cont_features[0],
            test_data.get_quantile_based_buckets(iris.data, 10))]

    classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
        linear_feature_columns=bucketized_features,
        linear_optimizer=tf.train.FtrlOptimizer(learning_rate=0.1),
        dnn_feature_columns=cont_features,
        dnn_hidden_units=[3, 3],
        dnn_optimizer=tf.train.AdagradOptimizer(learning_rate=0.1))

    classifier.fit(input_fn=test_data.iris_input_logistic_fn, steps=100)
    scores = classifier.evaluate(
        input_fn=test_data.iris_input_logistic_fn, steps=100)
    _assert_metrics_in_range(('accuracy',), scores)

  def testLogisticRegression_TensorData(self):
    """Tests binary classification using Tensor data as input."""
    def _input_fn():
      iris = test_data.prepare_iris_data_for_logistic_regression()
      features = {}
      for i in range(4):
        # The following shows how to provide the Tensor data for
        # RealValuedColumns.
        features.update({
            str(i): tf.reshape(tf.constant(iris.data[:, i], dtype=tf.float32),
                               [-1, 1])})
      # The following shows how to provide the SparseTensor data for
      # a SparseColumn.
      features['dummy_sparse_column'] = tf.SparseTensor(
          values=['en', 'fr', 'zh'],
          indices=[[0, 0], [0, 1], [60, 0]],
          shape=[len(iris.target), 2])
      labels = tf.reshape(tf.constant(iris.target, dtype=tf.int32), [-1, 1])
      return features, labels

    iris = test_data.prepare_iris_data_for_logistic_regression()
    cont_features = [tf.contrib.layers.real_valued_column(str(i))
                     for i in range(4)]
    linear_features = [
        tf.contrib.layers.bucketized_column(
            cont_features[i], test_data.get_quantile_based_buckets(
                iris.data[:, i], 10)) for i in range(4)
    ]
    linear_features.append(tf.contrib.layers.sparse_column_with_hash_bucket(
        'dummy_sparse_column', hash_bucket_size=100))

    classifier = tf.contrib.learn.DNNLinearCombinedClassifier(
        linear_feature_columns=linear_features,
        dnn_feature_columns=cont_features,
        dnn_hidden_units=[3, 3])

    classifier.fit(input_fn=_input_fn, steps=100)
    scores = classifier.evaluate(input_fn=_input_fn, steps=100)

 def _input_fn():
   iris = test_data.prepare_iris_data_for_logistic_regression()
   return {
       'feature': tf.constant(iris.data, dtype=tf.float32)
   }, tf.constant(iris.target, shape=(100,), dtype=tf.int32)