+readme and model gen

Author: guschmue

README.md

@@ -33,15 +33,15 @@ onnxruntime (only avaliable on linux):
 
 ```pip install onnxruntime```
 
-For caffe2, follow the instructions here:
+For pytorch/caffe2, follow the instructions here:
 
-```https://caffe2.ai/```
+```https://pytorch.org/```
 
 
-We tested with caffe2 and onnxruntime and unit tests are passing for those.
+We tested with pytorch/caffe2 and onnxruntime and unit tests are passing for those.
 
 ## Supported Tensorflow and Python Versions
-We tested with tensorflow 1.5-1.11 and anaconda **3.5,3.6**.
+We tested with tensorflow 1.5-1.13 and anaconda **3.5,3.6**.
 
 # Installation
 ## From Pypi
@@ -64,13 +64,17 @@ python setup.py bdist_wheel
 
 # Usage
 
-To convert a TensorFlow model, tf2onnx expects a ```frozen TensorFlow graph``` and the user needs to specify inputs and outputs for the graph by passing the input and output
+To convert a TensorFlow model, tf2onnx prefers a ```frozen TensorFlow graph``` and the user needs to specify inputs and outputs for the graph by passing the input and output
 names with ```--inputs INPUTS``` and ```--outputs OUTPUTS```. 
 
 ```
-python -m tf2onnx.convert --input SOURCE_FROZEN_GRAPH_PB
-    --inputs SOURCE_GRAPH_INPUTS
-    --outputs SOURCE_GRAPH_OUTPUS
+python -m tf2onnx.convert 
+    --input SOURCE_GRAPHDEF_PB
+    --graphdef SOURCE_GRAPHDEF_PB
+    --checkpoint SOURCE_CHECKPOINT
+    --saved-model SOURCE_SAVED_MODEL
+    [--inputs GRAPH_INPUTS]
+    [--outputs GRAPH_OUTPUS]
     [--inputs-as-nchw inputs_provided_as_nchw]
     [--target TARGET]
     [--output TARGET_ONNX_GRAPH]
@@ -83,21 +87,26 @@ python -m tf2onnx.convert --input SOURCE_FROZEN_GRAPH_PB
 ```
 
 ## Parameters
-### input
-frozen TensorFlow graph, which can be created with the [freeze graph tool](#freeze_graph).
-### output 
+### --input or --graphdef
+TensorFlow model as graphdef file. If not already frozen we'll try to freeze the model.
+More information about freezing can be found here: [freeze graph tool](#freeze_graph).
+### --checkpoint
+TensorFlow model as checkpoint. We expect the path to the .meta file. tf2onnx will try to freeze the graph.
+### --saved-model
+TensorFlow model as saved_model. We expect the path to the saved_model directory. tf2onnx will try to freeze the graph.
+### --output 
 the target onnx file path.
-### inputs, outputs
-Tensorflow graph's input/output names, which can be found with [summarize graph tool](#summarize_graph). Those names typically end on ```:0```, for example ```--inputs input0:0,input1:0```
-### inputs-as-nchw
+### --inputs, --outputs
+Tensorflow model's input/output names, which can be found with [summarize graph tool](#summarize_graph). Those names typically end on ```:0```, for example ```--inputs input0:0,input1:0```. inputs and outputs are ***not*** needed for models in saved-model format.
+### --inputs-as-nchw
 By default we preserve the image format of inputs (nchw or nhwc) as given in the TensorFlow model. If your hosts (for example windows) native format nchw and the model is written for nhwc, ```--inputs-as-nchw``` tensorflow-onnx will transpose the input. Doing so is convinient for the application and the converter in many cases can optimize the transpose away. For example ```--inputs input0:0,input1:0 --inputs-as-nchw input0:0``` assumes that images are passed into ```input0:0``` as nchw while the TensorFlow model given uses nhwc.
-### target 
+### --target 
 Some runtimes need workarounds, for example they don't support all types given in the onnx spec. We'll workaround it in some cases by generating a different graph. Those workarounds are activated with ```--target TARGET```. 
-### opset
+### --opset
 by default we uses the newest opset 7 to generate the graph. By specifieing ```--opset``` the user can override the default to generate a graph with the desired opset. For example ```--opset 5``` would create a onnx graph that uses only ops available in opset 5. Because older opsets have in most cases fewer ops, some models might not convert on a older opset.
-### custom-ops
+### --custom-ops
 the runtime may support custom ops that are not defined in onnx. A user can asked the converter to map to custom ops by listing them with the --custom-ops option. Tensorflow ops listed here will be mapped to a custom op with the same name as the tensorflow op but in the onnx domain ai.onnx.converters.tensorflow. For example: ```--custom-ops Print``` will insert a op ```Print``` in the onnx domain ```ai.onnx.converters.tensorflow``` into the graph. We also support a python api for custom ops documented later in this readme. 
-### fold_const
+### --fold_const
 when set, TensorFlow fold_constants transformation will be applied before conversion. This will benefit features including Transpose optimization (e.g. Transpose operations introduced during tf-graph-to-onnx-graph conversion will be removed), and RNN unit conversion (for example LSTM). Older TensorFlow version might run into issues with this option depending on the model.
 
 

tests/make_models.py

@@ -0,0 +1,99 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT license.
+
+"""Make simple test model in all tensorflow formats."""
+
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import os
+import unittest
+from collections import namedtuple
+
+import graphviz as gv
+from onnx import TensorProto
+from onnx import helper
+
+import tensorflow as tf
+from tensorflow.python.framework.graph_util import convert_variables_to_constants
+import numpy as np
+
+import os
+
+
+# pylint: disable=missing-docstring
+
+# Parameters
+learning_rate = 0.02
+training_epochs = 100
+
+# Training Data
+train_X = np.array(
+    [3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59, 2.167, 7.042, 10.791, 5.313, 7.997, 5.654, 9.27, 3.1])
+train_Y = np.array(
+    [1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53, 1.221, 2.827, 3.465, 1.65, 2.904, 2.42, 2.94, 1.3])
+test_X = np.array([6.83, 4.668, 8.9, 7.91, 5.7, 8.7, 3.1, 2.1])
+test_Y = np.array([1.84, 2.273, 3.2, 2.831, 2.92, 3.24, 1.35, 1.03])
+
+def freeze_session(sess, keep_var_names=None, output_names=None, clear_devices=True):
+    """Freezes the state of a session into a pruned computation graph."""
+    output_names = [i.replace(":0", "") for i in output_names]
+    graph = sess.graph
+    with graph.as_default():
+        freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference(keep_var_names or []))
+        output_names = output_names or []
+        output_names += [v.op.name for v in tf.global_variables()]
+        input_graph_def = graph.as_graph_def()
+        if clear_devices:
+            for node in input_graph_def.node:
+                node.device = ""
+        frozen_graph = convert_variables_to_constants(sess, input_graph_def,
+                                                      output_names, freeze_var_names)
+        return frozen_graph
+
+def train(model_path):
+    n_samples = train_X.shape[0]
+
+    # tf Graph Input
+    X = tf.placeholder(tf.float32, name="X")
+    Y = tf.placeholder(tf.float32, name="Y")
+
+    # Set model weights
+    W = tf.Variable(np.random.randn(), name="W")
+    b = tf.Variable(np.random.randn(), name="b")
+
+    pred = tf.add(tf.multiply(X, W), b)
+    pred = tf.identity(pred, name="pred")
+    cost = tf.reduce_sum(tf.pow(pred - Y, 2)) / (2 * n_samples)
+
+    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
+    saver = tf.train.Saver()
+
+    # Launch the graph
+    with tf.Session() as sess:
+        sess.run(tf.global_variables_initializer())
+
+        # Fit all training data
+        for epoch in range(training_epochs):
+            for (x, y) in zip(train_X, train_Y):
+                sess.run(optimizer, feed_dict={X: x, Y: y})
+        training_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
+        testing_cost = sess.run(cost, feed_dict={X: test_X, Y: test_Y})
+        print("train_cost={}, test_cost={}, diff={}"
+              .format(training_cost, testing_cost, abs(training_cost - testing_cost)))
+
+        p = os.path.abspath(os.path.join(model_path, "checkpoint"))
+        os.makedirs(p, exist_ok=True)
+        p = saver.save(sess, os.path.join(p, "model"))
+
+        frozen_graph = freeze_session(sess, output_names=["pred:0"])
+        p = os.path.abspath(os.path.join(model_path, "graphdef"))
+        tf.train.write_graph(frozen_graph, p, "frozen.pb", as_text=False)
+
+        p = os.path.abspath(os.path.join(model_path, "saved_model"))
+        tf.saved_model.simple_save(sess, p, inputs={"X": X}, outputs={"pred": pred})
+
+
+train("models/regression")
+