Ejemplo n.º 1
0
    def testEvalMode(self):
        # Build config.
        feature_spec = {
            "time_feature_1": {
                "length": 10,
                "is_time_series": True,
            },
            "time_feature_2": {
                "length": 10,
                "is_time_series": True,
            },
            "aux_feature_1": {
                "length": 1,
                "is_time_series": False,
            },
        }
        config = configurations.base()
        config["inputs"]["features"] = feature_spec
        config = configdict.ConfigDict(config)
        config.hparams.output_dim = 1

        # Build model.
        features = input_ops.build_feature_placeholders(config.inputs.features)
        labels = input_ops.build_labels_placeholder()
        model = astro_model.AstroModel(features, labels, config.hparams,
                                       tf.estimator.ModeKeys.TRAIN)
        model.build()

        # Validate Tensor shapes.
        self.assertShapeEquals((None, 21), model.pre_logits_concat)
        self.assertShapeEquals((None, 1), model.logits)
        self.assertShapeEquals((None, 1), model.predictions)
        self.assertShapeEquals((None, ), model.batch_losses)
        self.assertShapeEquals((), model.total_loss)

        # Execute the TensorFlow graph.
        scaffold = tf.train.Scaffold()
        scaffold.finalize()
        with self.test_session() as sess:
            sess.run([scaffold.init_op, scaffold.local_init_op])
            step = sess.run(model.global_step)
            self.assertEqual(0, step)

            # Fetch total loss.
            features = testing.fake_features(feature_spec, batch_size=16)
            labels = testing.fake_labels(config.hparams.output_dim,
                                         batch_size=16)
            feed_dict = input_ops.prepare_feed_dict(model, features, labels)
            total_loss = sess.run(model.total_loss, feed_dict=feed_dict)
            self.assertShapeEquals((), total_loss)
Ejemplo n.º 2
0
    def testOneTimeSeriesFeature(self):
        # Build config.
        feature_spec = {
            "time_feature_1": {
                "length": 20,
                "is_time_series": True,
            }
        }
        hidden_spec = {
            "time_feature_1": {
                "cnn_num_blocks": 2,
                "cnn_block_size": 2,
                "cnn_initial_num_filters": 4,
                "cnn_block_filter_factor": 1.5,
                "cnn_kernel_size": 3,
                "convolution_padding": "same",
                "pool_size": 2,
                "pool_strides": 2,
            }
        }
        config = configurations.base()
        config["inputs"]["features"] = feature_spec
        config["hparams"]["time_series_hidden"] = hidden_spec
        config = configdict.ConfigDict(config)

        # Build model.
        features = input_ops.build_feature_placeholders(config.inputs.features)
        labels = input_ops.build_labels_placeholder()
        model = astro_cnn_model.AstroCNNModel(features, labels, config.hparams,
                                              tf.estimator.ModeKeys.TRAIN)
        model.build()

        # Validate Tensor shapes.
        block_1_conv_1 = testing.get_variable_by_name(
            "time_feature_1_hidden/block_1/conv_1/kernel")
        self.assertShapeEquals((3, 1, 4), block_1_conv_1)

        block_1_conv_2 = testing.get_variable_by_name(
            "time_feature_1_hidden/block_1/conv_2/kernel")
        self.assertShapeEquals((3, 4, 4), block_1_conv_2)

        block_2_conv_1 = testing.get_variable_by_name(
            "time_feature_1_hidden/block_2/conv_1/kernel")
        self.assertShapeEquals((3, 4, 6), block_2_conv_1)

        block_2_conv_2 = testing.get_variable_by_name(
            "time_feature_1_hidden/block_2/conv_2/kernel")
        self.assertShapeEquals((3, 6, 6), block_2_conv_2)

        self.assertItemsEqual(["time_feature_1"],
                              model.time_series_hidden_layers.keys())
        self.assertShapeEquals(
            (None, 30), model.time_series_hidden_layers["time_feature_1"])
        self.assertEqual(len(model.aux_hidden_layers), 0)
        self.assertIs(model.time_series_hidden_layers["time_feature_1"],
                      model.pre_logits_concat)

        # Execute the TensorFlow graph.
        scaffold = tf.train.Scaffold()
        scaffold.finalize()
        with self.test_session() as sess:
            sess.run([scaffold.init_op, scaffold.local_init_op])
            step = sess.run(model.global_step)
            self.assertEqual(0, step)

            # Fetch predictions.
            features = testing.fake_features(feature_spec, batch_size=16)
            labels = testing.fake_labels(config.hparams.output_dim,
                                         batch_size=16)
            feed_dict = input_ops.prepare_feed_dict(model, features, labels)
            predictions = sess.run(model.predictions, feed_dict=feed_dict)
            self.assertShapeEquals((16, 1), predictions)
Ejemplo n.º 3
0
    def testOneTimeSeriesFeature(self):
        # Build config.
        feature_spec = {
            "time_feature_1": {
                "length": 14,
                "is_time_series": True,
            }
        }
        hidden_spec = {
            "time_feature_1": {
                "num_local_layers": 2,
                "local_layer_size": 20,
                "translation_delta": 2,
                "pooling_type": "max",
                "dropout_rate": 0.5,
            }
        }
        config = configurations.base()
        config["inputs"]["features"] = feature_spec
        config["hparams"]["time_series_hidden"] = hidden_spec
        config = configdict.ConfigDict(config)

        # Build model.
        features = input_ops.build_feature_placeholders(config.inputs.features)
        labels = input_ops.build_labels_placeholder()
        model = astro_fc_model.AstroFCModel(features, labels, config.hparams,
                                            tf.estimator.ModeKeys.TRAIN)
        model.build()

        # Validate Tensor shapes.
        conv = testing.get_variable_by_name(
            "time_feature_1_hidden/conv1d/kernel")
        self.assertShapeEquals((10, 1, 20), conv)

        fc_1 = testing.get_variable_by_name(
            "time_feature_1_hidden/fully_connected_1/weights")
        self.assertShapeEquals((20, 20), fc_1)

        self.assertItemsEqual(["time_feature_1"],
                              model.time_series_hidden_layers.keys())
        self.assertShapeEquals(
            (None, 20), model.time_series_hidden_layers["time_feature_1"])
        self.assertEqual(len(model.aux_hidden_layers), 0)
        self.assertIs(model.time_series_hidden_layers["time_feature_1"],
                      model.pre_logits_concat)

        # Execute the TensorFlow graph.
        scaffold = tf.train.Scaffold()
        scaffold.finalize()
        with self.test_session() as sess:
            sess.run([scaffold.init_op, scaffold.local_init_op])
            step = sess.run(model.global_step)
            self.assertEqual(0, step)

            # Fetch predictions.
            features = testing.fake_features(feature_spec, batch_size=16)
            labels = testing.fake_labels(config.hparams.output_dim,
                                         batch_size=16)
            feed_dict = input_ops.prepare_feed_dict(model, features, labels)
            predictions = sess.run(model.predictions, feed_dict=feed_dict)
            self.assertShapeEquals((16, 1), predictions)