creates directory for exported models, starts work on functions to export saved model

Author: SijanC147

export/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

main.py

@@ -27,28 +27,30 @@
     "initializer": tf.initializers.random_uniform(minval=-0.1, maxval=0.1),
 }
 
-# experiment = Experiment(
-#     dataset=Dataset(
-#         path=DATASETS.DEBUG_PATH,
-#         parser=DATASETS.DEBUG_PARSER,
-#         embedding=Embedding(path=EMBEDDINGS.DEBUG),
-#     ),
-#     model=MemNet(),
-#     run_config=tf.estimator.RunConfig(tf_random_seed=1234),
-# )
-# experiment.run(job="train+eval", steps=1, start_tb=True)
-# # experiment.run(job="train", steps=200, hooks=[debug_hook])
 experiment = Experiment(
     dataset=Dataset(
-        path=DATASETS.DONG2014_PATH,
-        parser=DATASETS.DONG2014_PARSER,
-        embedding=Embedding(path=EMBEDDINGS.GLOVE_TWITTER_100D),
+        path=DATASETS.DEBUG_PATH,
+        parser=DATASETS.DEBUG_PARSER,
+        embedding=Embedding(path=EMBEDDINGS.DEBUG),
     ),
-    model=MemNet(),
-    contd_tag="gold",
+    model=Lstm(),
+    contd_tag="gold_debug",
     # run_config=tf.estimator.RunConfig(tf_random_seed=1234),
 )
-experiment.run(job="train+eval", steps=16000, start_tb=True)
+# experiment.run(job="train+eval", steps=1, start_tb=True)
+# # experiment.run(job="train", steps=200, hooks=[debug_hook])
+# experiment = Experiment(
+#     dataset=Dataset(
+#         path=DATASETS.DONG2014_PATH,
+#         parser=DATASETS.DONG2014_PARSER,
+#         embedding=Embedding(path=EMBEDDINGS.GLOVE_TWITTER_25D),
+#     ),
+#     model=Lstm(),
+#     contd_tag="gold",
+#     # run_config=tf.estimator.RunConfig(tf_random_seed=1234),
+# )
+experiment.run(job="train+eval", steps=1)
+experiment.export_model()
 # experiment = Experiment(
 #     dataset=Dataset(
 #         path=DATASETS.NAKOV2016_PATH,

tsaplay/experiments/Experiment.py

@@ -11,6 +11,7 @@ def __init__(
     ):
         self.dataset = dataset
         self.model = model
+        self.model_name = model.__class__.__name__
         if embedding is not None:
             self.embedding = embedding
             self.dataset.embedding = self.embedding
@@ -21,8 +22,9 @@ def __init__(
                 )
             else:
                 self.embedding = self.dataset.embedding
+        self.contd_tag = contd_tag
         self.exp_dir = self._init_exp_dir(
-            model=self.model, dataset=self.dataset, contd_tag=contd_tag
+            model=self.model, dataset=self.dataset, contd_tag=self.contd_tag
         )
         if run_config is None:
             run_config = self.model.run_config
@@ -69,6 +71,17 @@ def run(
                 debug_port=debug_port,
             )
 
+    def export_model(self):
+        if self.contd_tag is None:
+            print("No continue tag defined, nothing to export!")
+        else:
+            export_model_name = "_".join(
+                [self.model_name.lower(), self.contd_tag]
+            )
+            export_dir = _join(getcwd(), "export", export_model_name)
+            self.model.export(directory=export_dir)
+        return
+
     def _init_exp_dir(self, model, dataset, contd_tag):
         all_exps_path = _join(dirname(abspath(__file__)), "data")
         rel_model_path = _join(
@@ -93,15 +106,6 @@ def _init_exp_dir(self, model, dataset, contd_tag):
                 )
         return exp_dir
 
-    def _init_run_config(self, exp_dir, run_config):
-        summary_dir = _join(exp_dir, "tb_summary")
-        if run_config is None:
-            return tf.estimator.RunConfig(model_dir=summary_dir)
-        elif run_config.model_dir is None:
-            return run_config.replace(model_dir=summary_dir)
-        else:
-            return run_config
-
     def _init_model_dir(self, exp_dir, run_config):
         summary_dir = _join(exp_dir, "tb_summary")
         if run_config.model_dir is None:

tsaplay/models/Model.py

@@ -23,6 +23,7 @@ def __init__(
         eval_input_fn=None,
         eval_hooks=None,
         model_fn=None,
+        serving_input_receiver_fn=None,
     ):
         self.params = params
         self.feature_columns = feature_columns
@@ -32,6 +33,7 @@ def __init__(
         self.eval_hooks = eval_hooks
         self.model_fn = model_fn
         self.run_config = run_config
+        self.serving_input_receiver_fn = serving_input_receiver_fn
 
     @property
     def params(self):
@@ -75,6 +77,12 @@ def eval_hooks(self):
             self.eval_hooks = self._eval_hooks()
         return self.__eval_hooks
 
+    @property
+    def serving_input_receiver_fn(self):
+        if self.__serving_input_receiver_fn is None:
+            self.serving_input_receiver_fn = self._serving_input_receiver_fn()
+        return self.__serving_input_receiver_fn
+
     @property
     def estimator(self):
         self.__estimator = tf.estimator.Estimator(
@@ -123,6 +131,10 @@ def eval_hooks(self, eval_hooks):
             eval_hooks = []
         self.__eval_hooks = eval_hooks
 
+    @serving_input_receiver_fn.setter
+    def serving_input_receiver_fn(self, serving_input_receiver_fn):
+        self.__serving_input_receiver_fn = serving_input_receiver_fn
+
     @run_config.setter
     def run_config(self, run_config):
         if run_config is None:
@@ -156,6 +168,26 @@ def _train_hooks(self):
     def _eval_hooks(self):
         return []
 
+    def _serving_input_receiver_fn(self):
+        feature_spec = {
+            "x": tf.FixedLenFeature(
+                dtype=tf.int64, shape=[self.params["max_seq_length"]]
+            ),
+            "len": tf.FixedLenFeature(dtype=tf.int64, shape=[]),
+        }
+
+        def default_serving_input_receiver_fn():
+            serialized_tf_example = tf.placeholder(
+                dtype=tf.string, shape=[None], name="input_example_tensor"
+            )
+            receiver_tensors = {"examples": serialized_tf_example}
+            features = tf.parse_example(serialized_tf_example, feature_spec)
+            return tf.estimator.export.ServingInputReceiver(
+                features, receiver_tensors
+            )
+
+        return default_serving_input_receiver_fn
+
     def train(self, dataset, steps, distribution=None, hooks=[]):
         self._add_embedding_params(embedding=dataset.embedding)
         features, labels, stats = dataset.get_features_and_labels(
@@ -232,10 +264,17 @@ def train_and_eval(self, dataset, steps):
             {"duration": duration_dict, **eval_stats},
         )
 
+    def export(self, directory):
+        self.estimator.export_savedmodel(
+            directory, self.serving_input_receiver_fn, strip_default_attrs=True
+        )
+
     def _wrap_model_fn(self, _model_fn):
         @wraps(_model_fn)
         def wrapper(features, labels, mode, params):
             spec = _model_fn(features, labels, mode, params)
+            if mode == ModeKeys.PREDICT:
+                return spec
             std_metrics = {
                 "accuracy": tf.metrics.accuracy(
                     labels=labels,
@@ -264,18 +303,19 @@ def wrapper(features, labels, mode, params):
             tf.summary.scalar("accuracy", std_metrics["accuracy"][1])
             tf.summary.scalar("auc", std_metrics["auc"][1])
             if mode == ModeKeys.EVAL:
-                attn_hook = SaveAttentionWeightVectorHook(
-                    labels=labels,
-                    predictions=spec.predictions["class_ids"],
-                    targets=features["target"]["lit"],
-                    summary_writer=tf.summary.FileWriterCache.get(
-                        join(self.run_config.model_dir, "eval")
-                    ),
-                    n_picks=self.params.get("n_attn_heatmaps", 5),
-                    n_hops=self.params.get("n_hops"),
-                )
                 all_eval_hooks = spec.evaluation_hooks or []
-                all_eval_hooks += [attn_hook]
+                if features.get("target") is not None:
+                    attn_hook = SaveAttentionWeightVectorHook(
+                        labels=labels,
+                        predictions=spec.predictions["class_ids"],
+                        targets=features["target"]["lit"],
+                        summary_writer=tf.summary.FileWriterCache.get(
+                            join(self.run_config.model_dir, "eval")
+                        ),
+                        n_picks=self.params.get("n_attn_heatmaps", 5),
+                        n_hops=self.params.get("n_hops"),
+                    )
+                    all_eval_hooks += [attn_hook]
                 all_metrics = spec.eval_metric_ops or {}
                 all_metrics.update(std_metrics)
                 return spec._replace(
@@ -299,8 +339,6 @@ def wrapper(features, labels, mode, params):
                 all_training_hooks += [logging_hook]
                 return spec._replace(training_hooks=all_training_hooks)
 
-            return spec
-
         return wrapper
 
     def _export_statistics(self, dataset_stats=None, steps=None):

tsaplay/models/Tang2016a/common.py

@@ -33,13 +33,13 @@ def lstm_input_fn(
             features["mappings"]["right"],
         )
     ]
-    sen_map, sen_len = prep_features_for_dataset(mappings=sentences)
+    sen_map, sen_len = prep_features_for_dataset(
+        mappings=sentences, max_seq_length=max_seq_length
+    )
+    sentence = wrap_mapping_length_literal(sen_map, sen_len)
     labels = make_labels_dataset_from_list(labels)
 
-    dataset = tf.data.Dataset.from_tensor_slices((sen_map, sen_len, labels))
-    dataset = dataset.map(
-        lambda sentence, length, label: ({"x": sentence, "len": length}, label)
-    )
+    dataset = tf.data.Dataset.zip((sentence, labels))
 
     iterator = prep_dataset_and_get_iterator(
         dataset=dataset,