Example #1
0
  def inference_graph(self, input_data, data_spec):
    """Constructs a TF graph for evaluating a random tree.

    Args:
      input_data: A tensor or SparseTensor or placeholder for input data.
      data_spec: A list of tf.dtype values specifying the original types of
        each column.

    Returns:
      The last op in the random tree inference graph.
    """
    sparse_indices = []
    sparse_values = []
    sparse_shape = []
    if isinstance(input_data, sparse_tensor.SparseTensor):
      sparse_indices = input_data.indices
      sparse_values = input_data.values
      sparse_shape = input_data.dense_shape
      input_data = []
    return tensor_forest_ops.tree_predictions(
        input_data,
        sparse_indices,
        sparse_values,
        sparse_shape,
        data_spec,
        self.variables.tree,
        self.variables.tree_thresholds,
        self.variables.node_sums,
        valid_leaf_threshold=self.params.valid_leaf_threshold)
Example #2
0
  def inference_graph(self, input_data, data_spec, sparse_features=None):
    """Constructs a TF graph for evaluating a random tree.

    Args:
      input_data: A tensor or placeholder for input data.
      data_spec: A TensorForestDataSpec proto specifying the original
        input columns.
      sparse_features: A tf.SparseTensor for sparse input data.

    Returns:
      The last op in the random tree inference graph.
    """
    if input_data is None:
      input_data = []

    sparse_indices = []
    sparse_values = []
    sparse_shape = []
    if sparse_features is not None:
      sparse_indices = sparse_features.indices
      sparse_values = sparse_features.values
      sparse_shape = sparse_features.dense_shape

    return tensor_forest_ops.tree_predictions(
        input_data,
        sparse_indices,
        sparse_values,
        sparse_shape,
        self.variables.tree,
        self.variables.tree_thresholds,
        self.variables.node_sums,
        input_spec=data_spec.SerializeToString(),
        valid_leaf_threshold=self.params.valid_leaf_threshold)
Example #3
0
    def inference_graph(self, input_data, data_spec):
        """Constructs a TF graph for evaluating a random tree.

    Args:
      input_data: A tensor or SparseTensor or placeholder for input data.
      data_spec: A list of tf.dtype values specifying the original types of
        each column.

    Returns:
      The last op in the random tree inference graph.
    """
        sparse_indices = []
        sparse_values = []
        sparse_shape = []
        if isinstance(input_data, sparse_tensor.SparseTensor):
            sparse_indices = input_data.indices
            sparse_values = input_data.values
            sparse_shape = input_data.dense_shape
            input_data = []
        return tensor_forest_ops.tree_predictions(
            input_data,
            sparse_indices,
            sparse_values,
            sparse_shape,
            data_spec,
            self.variables.tree,
            self.variables.tree_thresholds,
            self.variables.node_sums,
            valid_leaf_threshold=self.params.valid_leaf_threshold)
  def testSparseInputDefaultIsZero(self):
    sparse_shape = [3, 10]
    sparse_indices = [[0, 0], [0, 4], [0, 9],
                      [1, 0], [1, 7],
                      [2, 0]]
    sparse_values = [3.0, -1.0, 0.5,
                     1.5, 6.0,
                     -2.0]
    sparse_data_spec = [constants.DATA_FLOAT] * 10

    tree = [[1, 7], [-1, 0], [-1, 0]]
    tree_thresholds = [3.0, 0., 0.]
    node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                [1.0, 0.5, 0.25, 0.25]]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          [],
          sparse_indices,
          sparse_values,
          sparse_shape,
          sparse_data_spec,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=1)

      self.assertAllClose([[0.1, 0.1, 0.8],
                           [0.5, 0.25, 0.25],
                           [0.1, 0.1, 0.8]],
                          predictions.eval())
Example #5
0
    def testSimple(self):
        input_data = [
            [-1., 0.],
            [-1., 2.],  # node 1
            [1., 0.],
            [1., -2.]
        ]  # node 2

        tree = [[1, 0], [-1, 0], [-1, 0]]
        tree_thresholds = [0., 0., 0.]
        node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                    [1.0, 0.5, 0.25, 0.25]]

        with self.test_session():
            predictions = tensor_forest_ops.tree_predictions(
                input_data, [], [], [],
                self.data_spec,
                tree,
                tree_thresholds,
                node_pcw,
                valid_leaf_threshold=1)

            self.assertAllClose([[0.1, 0.1, 0.8], [0.1, 0.1, 0.8],
                                 [0.5, 0.25, 0.25], [0.5, 0.25, 0.25]],
                                predictions.eval())
Example #6
0
    def testSparseInputDefaultIsZero(self):
        sparse_shape = [3, 10]
        sparse_indices = [[0, 0], [0, 4], [0, 9], [1, 0], [1, 7], [2, 0]]
        sparse_values = [3.0, -1.0, 0.5, 1.5, 6.0, -2.0]
        sparse_data_spec = [constants.DATA_FLOAT] * 10

        tree = [[1, 7], [-1, 0], [-1, 0]]
        tree_thresholds = [3.0, 0., 0.]
        node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                    [1.0, 0.5, 0.25, 0.25]]

        with self.test_session():
            predictions = tensor_forest_ops.tree_predictions(
                [],
                sparse_indices,
                sparse_values,
                sparse_shape,
                sparse_data_spec,
                tree,
                tree_thresholds,
                node_pcw,
                valid_leaf_threshold=1)

            self.assertAllClose(
                [[0.1, 0.1, 0.8], [0.5, 0.25, 0.25], [0.1, 0.1, 0.8]],
                predictions.eval())
Example #7
0
    def testBackoffToParent(self):
        input_data = [
            [-1., 0.],
            [-1., 2.],  # node 1
            [1., 0.],
            [1., -2.]
        ]  # node 2

        tree = [[1, 0], [-1, 0], [-1, 0]]
        tree_thresholds = [0., 0., 0.]
        node_pcw = [[15.0, 3.0, 9.0, 3.0], [5.0, 1.0, 1.0, 3.0],
                    [25.0, 5.0, 20.0, 0.0]]

        with self.test_session():
            predictions = tensor_forest_ops.tree_predictions(
                input_data, [], [], [],
                self.data_spec,
                tree,
                tree_thresholds,
                node_pcw,
                valid_leaf_threshold=10)

            # Node 2 has enough data, but Node 1 needs to combine with the parent
            # counts.
            self.assertAllClose([[0.2, 0.4, 0.4], [0.2, 0.4, 0.4],
                                 [0.2, 0.8, 0.0], [0.2, 0.8, 0.0]],
                                predictions.eval())
Example #8
0
    def testBadInput(self):
        input_data = [
            [-1., 0.],
            [-1., 2.],  # node 1
            [1., 0.],
            [1., -2.]
        ]  # node 2

        tree = [[1, 0], [-1, 0], [-1, 0]]
        tree_thresholds = [0., 0.]  # not enough nodes.
        node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                    [1.0, 0.5, 0.25, 0.25]]

        with self.test_session():
            with self.assertRaisesOpError(
                    'Number of nodes should be the same in tree, tree_thresholds '
                    'and node_pcw.'):
                predictions = tensor_forest_ops.tree_predictions(
                    input_data, [], [], [],
                    self.data_spec,
                    tree,
                    tree_thresholds,
                    node_pcw,
                    valid_leaf_threshold=10)

                self.assertEquals((0, 3), predictions.eval().shape)
  def testBackoffToParent(self):
    input_data = [
        [-1., 0.],
        [-1., 2.],  # node 1
        [1., 0.],
        [1., -2.]
    ]  # node 2

    tree = [[1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 0., 0.]
    node_pcw = [[15.0, 3.0, 9.0, 3.0], [5.0, 1.0, 1.0, 3.0],
                [25.0, 5.0, 20.0, 0.0]]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          input_data,
          self.nothing,
          self.nothing,
          self.nothing,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=10,
          input_spec=self.data_spec)

      # Node 2 has enough data, but Node 1 needs to combine with the parent
      # counts.
      self.assertAllClose([[0.2, 0.4, 0.4], [0.2, 0.4, 0.4], [0.2, 0.8, 0.0],
                           [0.2, 0.8, 0.0]], predictions.eval())
  def testSparseInput(self):
    sparse_shape = [3, 10]
    sparse_indices = [[0, 0], [0, 4], [0, 9],
                      [1, 0], [1, 7],
                      [2, 0]]
    sparse_values = [3.0, -1.0, 0.5,
                     1.5, 6.0,
                     -2.0]

    tree = [[1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 0., 0.]
    node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                [1.0, 0.5, 0.25, 0.25]]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          self.nothing,
          sparse_indices,
          sparse_values,
          sparse_shape,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=1,
          input_spec=self.data_spec)

      self.assertAllClose([[0.5, 0.25, 0.25],
                           [0.5, 0.25, 0.25],
                           [0.1, 0.1, 0.8]],
                          predictions.eval())
  def testBadInput(self):
    input_data = [
        [-1., 0.],
        [-1., 2.],  # node 1
        [1., 0.],
        [1., -2.]
    ]  # node 2

    tree = [[1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 0.]  # not enough nodes.
    node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                [1.0, 0.5, 0.25, 0.25]]

    with self.test_session():
      with self.assertRaisesOpError(
          'Number of nodes should be the same in tree, tree_thresholds '
          'and node_pcw.'):
        predictions = tensor_forest_ops.tree_predictions(
            input_data,
            self.nothing,
            self.nothing,
            self.nothing,
            tree,
            tree_thresholds,
            node_pcw,
            valid_leaf_threshold=10,
            input_spec=self.data_spec)

        self.assertEquals((0, 3), predictions.eval().shape)
  def testNoInput(self):
    input_data = []

    tree = [[1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 0., 0.]
    node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                [1.0, 0.5, 0.25, 0.25]]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          input_data, [], [], [],
          self.data_spec,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=10)

      self.assertEquals((0, 3), predictions.eval().shape)
Example #13
0
    def testNoInput(self):
        input_data = []

        tree = [[1, 0], [-1, 0], [-1, 0]]
        tree_thresholds = [0., 0., 0.]
        node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                    [1.0, 0.5, 0.25, 0.25]]

        with self.test_session():
            predictions = tensor_forest_ops.tree_predictions(
                input_data, [], [], [],
                self.data_spec,
                tree,
                tree_thresholds,
                node_pcw,
                valid_leaf_threshold=10)

            self.assertEquals((0, 3), predictions.eval().shape)
  def testSimpleMixed(self):
    #        0       1       2       3        4        5        6
    tree = [[1, 0], [3, 2], [5, 5], [-1, 0], [-1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 15., 1., 0., 0., 0., 0.]
    node_pcw = [[1.0, 0., 1.0, 0.4, 0.3], [1.0, 0., 0.1, 0.1, 0.8],
                [1.0, 0., 0.5, 0.25, 0.25], [1.0, 1., 0., 0., 0.],
                [1.0, 0., 1., 0., 0.], [1.0, 0., 0., 1., 0.],
                [1.0, 0., 0., 0., 1.]]

    input_data = [
        [-1., 0., 15.],  # node 3
        [-1., 2., 11.],  # node 4
        [1., 0., 11.],
        [1., -2., 30.]
    ]

    sparse_shape = [4, 5]
    sparse_indices = [
        [0, 0],
        [0, 1],
        [0, 4],
        [1, 0],
        [1, 2],
        [2, 1],  # node 5
        [3, 2]
    ]  # node 6
    sparse_values = [3.0, -1.0, 0.5, 1.5, 6.0, -2.0, 2.0]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          input_data,
          sparse_indices,
          sparse_values,
          sparse_shape,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=1,
          input_spec=self.data_spec)

      self.assertAllClose([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.],
                           [0., 0., 0., 1.]], predictions.eval())
  def testSimple(self):
    input_data = [[-1., 0.], [-1., 2.],  # node 1
                  [1., 0.], [1., -2.]]  # node 2

    tree = [[1, 0], [-1, 0], [-1, 0]]
    tree_thresholds = [0., 0., 0.]
    node_pcw = [[1.0, 0.3, 0.4, 0.3], [1.0, 0.1, 0.1, 0.8],
                [1.0, 0.5, 0.25, 0.25]]

    with self.test_session():
      predictions = tensor_forest_ops.tree_predictions(
          input_data, [], [], [],
          self.data_spec,
          tree,
          tree_thresholds,
          node_pcw,
          valid_leaf_threshold=1)

      self.assertAllClose([[0.1, 0.1, 0.8], [0.1, 0.1, 0.8],
                           [0.5, 0.25, 0.25], [0.5, 0.25, 0.25]],
                          predictions.eval())