Python API naming and other cleanup

onnxruntime/__init__.py

@@ -18,4 +18,4 @@
 from onnxruntime.capi import onnxruntime_validation
 onnxruntime_validation.check_distro_info()
 from onnxruntime.capi.session import InferenceSession
-from onnxruntime.capi._pybind_state import RunOptions, SessionOptions, set_default_logger_severity, get_device, NodeArg, ModelMetadata, GraphOptimizationLevel
+from onnxruntime.capi._pybind_state import RunOptions, SessionOptions, NodeArg, ModelMetadata, GraphOptimizationLevel

onnxruntime/python/onnxruntime_pybind_state.cc

@@ -274,15 +274,6 @@ void InitializeSession(InferenceSession* sess) {
 
 void addGlobalMethods(py::module& m) {
   m.def("get_session_initializer", &SessionObjectInitializer::Get, "Return a default session object initializer.");
-  m.def(
-      "get_device", []() -> std::string { return BACKEND_DEVICE; },
-      "Return the device used to compute the prediction (CPU, MKL, ...)");
-  m.def("set_default_logger_severity", [](int severity) {
-    ORT_ENFORCE(severity >= 0 && severity <= 4,
-                "Invalid logging severity. 0:Verbose, 1:Info, 2:Warning, 3:Error, 4:Fatal");
-    logging::LoggingManager* default_logging_manager = SessionObjectInitializer::Get();
-    default_logging_manager->SetDefaultLoggerSeverity(static_cast<logging::Severity>(severity));
-  });
 
 #ifdef onnxruntime_PYBIND_EXPORT_OPSCHEMA
   m.def(
@@ -474,20 +465,18 @@ Set this option to false if you don't want it. Default is True.)pbdoc")
                      R"pbdoc(Enable the memory pattern optimization. Default is true.)pbdoc")
       .def_readwrite("enable_sequential_execution", &SessionOptions::enable_sequential_execution,
                      R"pbdoc(Enables sequential execution, disables parallel execution. Default is true.)pbdoc")
-      .def_readwrite("max_num_graph_transformation_steps", &SessionOptions::max_num_graph_transformation_steps,
-                     R"pbdoc(Runs optimization steps on the execution graph. Default is 5.)pbdoc")
-      .def_readwrite("session_logid", &SessionOptions::session_logid,
+      .def_readwrite("logid", &SessionOptions::session_logid,
                      R"pbdoc(Logger id to use for session output.)pbdoc")
-      .def_readwrite("session_log_severity_level", &SessionOptions::session_log_severity_level,
+      .def_readwrite("log_severity_level", &SessionOptions::session_log_severity_level,
                      R"pbdoc(Log severity level. Applies to session load, initialization, etc. 
 0:Verbose, 1:Info, 2:Warning. 3:Error, 4:Fatal. Default is 2.)pbdoc")
-      .def_readwrite("session_log_verbosity_level", &SessionOptions::session_log_verbosity_level,
+      .def_readwrite("log_verbosity_level", &SessionOptions::session_log_verbosity_level,
                      R"pbdoc(VLOG level if DEBUG build and session_log_verbosity_level is 0. 
 Applies to session load, initialization, etc. Default is 0.)pbdoc")
-      .def_readwrite("session_thread_pool_size", &SessionOptions::session_thread_pool_size,
+      .def_readwrite("thread_pool_size", &SessionOptions::session_thread_pool_size,
                      R"pbdoc(How many threads in the session thread pool. Default is 0 to let onnxruntime choose.
 This parameter is unused unless *enable_sequential_execution* is false.)pbdoc")
-      .def_property_readonly(
+      .def_property(
           "graph_optimization_level",
           [](const SessionOptions* options) -> GraphOptimizationLevel {
             GraphOptimizationLevel retval = ORT_ENABLE_BASIC;
@@ -511,9 +500,7 @@ This parameter is unused unless *enable_sequential_execution* is false.)pbdoc")
             }
             return retval;
           },
-          R"pbdoc(Graph optimization level for this session.)pbdoc")
-      .def(
-          "set_graph_optimization_level",
+
           [](SessionOptions* options, GraphOptimizationLevel level) -> void {
             switch (level) {
               case ORT_DISABLE_ALL:
@@ -532,14 +519,15 @@ This parameter is unused unless *enable_sequential_execution* is false.)pbdoc")
           },
           R"pbdoc(Graph optimization level for this session.)pbdoc");
 
+
   py::class_<RunOptions>(m, "RunOptions", R"pbdoc(Configuration information for a single Run.)pbdoc")
       .def(py::init())
-      .def_readwrite("run_log_severity_level", &RunOptions::run_log_severity_level,
+      .def_readwrite("log_severity_level", &RunOptions::run_log_severity_level,
                      R"pbdoc(Log severity level for a particular Run() invocation. 0:Verbose, 1:Info, 2:Warning. 3:Error, 4:Fatal. Default is 2.)pbdoc")
-      .def_readwrite("run_log_verbosity_level", &RunOptions::run_log_verbosity_level,
+      .def_readwrite("log_verbosity_level", &RunOptions::run_log_verbosity_level,
                      R"pbdoc(VLOG level if DEBUG build and run_log_severity_level is 0. 
 Applies to a particular Run() invocation. Default is 0.)pbdoc")
-      .def_readwrite("run_tag", &RunOptions::run_tag,
+      .def_readwrite("logid", &RunOptions::run_tag,
                      "To identify logs generated by a particular Run() invocation.")
       .def_readwrite("terminate", &RunOptions::terminate,
                      R"pbdoc(Set to True to terminate any currently executing calls that are using this

onnxruntime/test/python/onnxruntime_test_python.py

@@ -35,8 +35,8 @@ def run_model(self, session_object, run_options):
 
     def testModelSerialization(self):
         so = onnxrt.SessionOptions()
-        so.session_log_verbosity_level = 1
-        so.session_logid = "TestModelSerialization"
+        so.log_verbosity_level = 1
+        so.logid = "TestModelSerialization"
         so.optimized_model_filepath = "./PythonApiTestOptimizedModel.onnx"
         onnxrt.InferenceSession(self.get_name("mul_1.onnx"), sess_options=so)
         self.assertTrue(os.path.isfile(so.optimized_model_filepath))
@@ -95,25 +95,21 @@ def testRunModel2(self):
 
     def testRunModelMultipleThreads(self):
         so = onnxrt.SessionOptions()
-        so.session_log_verbosity_level = 1
-        so.session_logid = "MultiThreadsTest"
+        so.log_verbosity_level = 1
+        so.logid = "MultiThreadsTest"
         sess = onnxrt.InferenceSession(
             self.get_name("mul_1.onnx"), sess_options=so)
         ro1 = onnxrt.RunOptions()
-        ro1.run_tag = "thread1"
+        ro1.logid = "thread1"
         t1 = threading.Thread(target=self.run_model, args=(sess, ro1))
         ro2 = onnxrt.RunOptions()
-        ro2.run_tag = "thread2"
+        ro2.logid = "thread2"
         t2 = threading.Thread(target=self.run_model, args=(sess, ro2))
         t1.start()
         t2.start()
         t1.join()
         t2.join()
 
-    def testRunDevice(self):
-        device = onnxrt.get_device()
-        self.assertTrue('CPU' in device or 'GPU' in device)
-
     def testRunModelSymbolicInput(self):
         sess = onnxrt.InferenceSession(self.get_name("matmul_2.onnx"))
         x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
@@ -494,10 +490,16 @@ def test_run_model_mlnet(self):
         self.assertEqual(total, 0)
 
     def testGraphOptimizationLevel(self):
-        sess = onnxrt.InferenceSession(self.get_name("logicaland.onnx"))
-        sess.graph_optimization_level = onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL
-        self.assertEqual(sess.graph_optimization_level,
-                         onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL)
+        opt = onnxrt.SessionOptions()
+        self.assertEqual(opt.graph_optimization_level, onnxrt.GraphOptimizationLevel.ORT_ENABLE_BASIC)
+            # default should be basic optimization
+        opt.graph_optimization_level = onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self.assertEqual(opt.graph_optimization_level, onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL)
+        sess = onnxrt.InferenceSession(self.get_name("logicaland.onnx"), sess_options=opt)
+        a = np.array([[True, True], [False, False]], dtype=np.bool)
+        b = np.array([[True, False], [True, False]], dtype=np.bool)
+
+        res = sess.run([], {'input1:0': a, 'input:0':b})
 
 
 if __name__ == '__main__':