Exemplo n.º 1
0
 def get_not_disjoint():
     feature_columns, input_fn = estimator_utils.to_feature_columns_and_input_fn(
         df,
         base_input_keys_with_defaults={"a": 1, "b": 2, "c": 3, "d": 4},
         target_keys=["f"],
         feature_keys=["a", "b", "f"],
     )
    def test_to_feature_columns_and_input_fn_no_labels(self):
        df = setup_test_df_3layer()
        feature_columns, input_fn = (
            estimator_utils.to_feature_columns_and_input_fn(
                df,
                base_input_keys_with_defaults={
                    "a": 1,
                    "b": 2,
                    "c": 3,
                    "d": 4
                },
                feature_keys=["a", "b", "f"]))

        base_features, labels = input_fn()
        expected_base_features = {
            "a": mocks.MockTensor("Tensor a", dtypes.int32),
            "b": mocks.MockSparseTensor("SparseTensor b", dtypes.int32),
            "c": mocks.MockTensor("Tensor c", dtypes.int32),
            "d": mocks.MockSparseTensor("SparseTensor d", dtypes.int32)
        }
        self.assertEqual(expected_base_features, base_features)

        expected_labels = {}
        self.assertEqual(expected_labels, labels)

        self.assertEqual(3, len(feature_columns))
Exemplo n.º 3
0
 def get_not_disjoint():
   feature_columns, input_fn = (
       estimator_utils.to_feature_columns_and_input_fn(
           df,
           base_input_keys_with_defaults={"a": 1,
                                          "b": 2,
                                          "c": 3,
                                          "d": 4},
           target_keys=["f"],
           feature_keys=["a", "b", "f"]))
    def test_to_feature_columns_and_input_fn(self):
        df = setup_test_df_3layer()
        feature_columns, input_fn = (
            estimator_utils.to_feature_columns_and_input_fn(
                df,
                base_input_keys_with_defaults={
                    "a": 1,
                    "b": 2,
                    "c": 3,
                    "d": 4
                },
                label_keys=["g"],
                feature_keys=["a", "b", "f"]))

        expected_feature_column_a = feature_column.DataFrameColumn(
            "a",
            learn.PredefinedSeries(
                "a",
                parsing_ops.FixedLenFeature(tensor_shape.unknown_shape(),
                                            dtypes.int32, 1)))
        expected_feature_column_b = feature_column.DataFrameColumn(
            "b",
            learn.PredefinedSeries("b",
                                   parsing_ops.VarLenFeature(dtypes.int32)))
        expected_feature_column_f = feature_column.DataFrameColumn(
            "f",
            learn.TransformedSeries([
                learn.PredefinedSeries(
                    "c",
                    parsing_ops.FixedLenFeature(tensor_shape.unknown_shape(),
                                                dtypes.int32, 3)),
                learn.PredefinedSeries("d",
                                       parsing_ops.VarLenFeature(dtypes.int32))
            ], mocks.Mock2x2Transform("iue", "eui", "snt"), "out2"))

        expected_feature_columns = [
            expected_feature_column_a, expected_feature_column_b,
            expected_feature_column_f
        ]
        self.assertEqual(sorted(expected_feature_columns),
                         sorted(feature_columns))

        base_features, labels = input_fn()
        expected_base_features = {
            "a": mocks.MockTensor("Tensor a", dtypes.int32),
            "b": mocks.MockSparseTensor("SparseTensor b", dtypes.int32),
            "c": mocks.MockTensor("Tensor c", dtypes.int32),
            "d": mocks.MockSparseTensor("SparseTensor d", dtypes.int32)
        }
        self.assertEqual(expected_base_features, base_features)

        expected_labels = mocks.MockTensor("Out iue", dtypes.int32)
        self.assertEqual(expected_labels, labels)

        self.assertEqual(3, len(feature_columns))
  def test_to_feature_columns_and_input_fn(self):
    df = setup_test_df_3layer()
    feature_columns, input_fn = (
        estimator_utils.to_feature_columns_and_input_fn(
            df,
            base_input_keys_with_defaults={"a": 1,
                                           "b": 2,
                                           "c": 3,
                                           "d": 4},
            label_keys=["g"],
            feature_keys=["a", "b", "f"]))

    expected_feature_column_a = feature_column.DataFrameColumn(
        "a",
        learn.PredefinedSeries(
            "a",
            parsing_ops.FixedLenFeature(tensor_shape.unknown_shape(),
                                        dtypes.int32, 1)))
    expected_feature_column_b = feature_column.DataFrameColumn(
        "b",
        learn.PredefinedSeries("b", parsing_ops.VarLenFeature(dtypes.int32)))
    expected_feature_column_f = feature_column.DataFrameColumn(
        "f",
        learn.TransformedSeries([
            learn.PredefinedSeries("c",
                                   parsing_ops.FixedLenFeature(
                                       tensor_shape.unknown_shape(),
                                       dtypes.int32, 3)),
            learn.PredefinedSeries("d", parsing_ops.VarLenFeature(dtypes.int32))
        ], mocks.Mock2x2Transform("iue", "eui", "snt"), "out2"))

    expected_feature_columns = [
        expected_feature_column_a, expected_feature_column_b,
        expected_feature_column_f
    ]
    self.assertEqual(sorted(expected_feature_columns), sorted(feature_columns))

    base_features, labels = input_fn()
    expected_base_features = {
        "a": mocks.MockTensor("Tensor a", dtypes.int32),
        "b": mocks.MockSparseTensor("SparseTensor b", dtypes.int32),
        "c": mocks.MockTensor("Tensor c", dtypes.int32),
        "d": mocks.MockSparseTensor("SparseTensor d", dtypes.int32)
    }
    self.assertEqual(expected_base_features, base_features)

    expected_labels = mocks.MockTensor("Out iue", dtypes.int32)
    self.assertEqual(expected_labels, labels)

    self.assertEqual(3, len(feature_columns))
Exemplo n.º 6
0
    def test_to_feature_columns_and_input_fn_no_targets(self):
        df = setup_test_df_3layer()
        feature_columns, input_fn = estimator_utils.to_feature_columns_and_input_fn(
            df, base_input_keys_with_defaults={"a": 1, "b": 2, "c": 3, "d": 4}, feature_keys=["a", "b", "f"]
        )

        base_features, targets = input_fn()
        expected_base_features = {
            "a": mocks.MockTensor("Tensor a", tf.int32),
            "b": mocks.MockSparseTensor("SparseTensor b", tf.int32),
            "c": mocks.MockTensor("Tensor c", tf.int32),
            "d": mocks.MockSparseTensor("SparseTensor d", tf.int32),
        }
        self.assertEqual(expected_base_features, base_features)

        expected_targets = {}
        self.assertEqual(expected_targets, targets)

        self.assertEqual(3, len(feature_columns))