Add support for loading models from python.

Author: AsakusaRinne

src/TensorFlowNET.Core/Checkpoint/CheckpointReader.cs

@@ -62,14 +62,17 @@ public int GetVariableNumDims(string name)
             return c_api.TF_CheckpointReaderGetVariableNumDims(_reader, name);
         }
 
-        public unsafe Tensor GetTensor(string name)
+        public unsafe Tensor GetTensor(string name, TF_DataType dtype = TF_DataType.DtInvalid)
         {
             Status status = new Status();
             var tensor = c_api.TF_CheckpointReaderGetTensor(_reader, name, status.Handle);
             status.Check(true);
             var shape = GetVariableShape(name);
-            var dtype = GetVariableDataType(name);
-            return new Tensor(c_api.TF_TensorData(tensor), shape, dtype);
+            if(dtype == TF_DataType.DtInvalid)
+            {
+                dtype = GetVariableDataType(name);
+            }
+            return new Tensor(tensor);
         }
 
         private void ReadAllShapeAndType()

src/TensorFlowNET.Core/Checkpoint/checkpoint.cs

@@ -227,7 +227,7 @@ public LoadStatus restore(string? save_path, CheckpointOptions? options = null)
         {
             dtype_map = reader.VariableToDataTypeMap;
         }
-        Tensor object_graph_string = reader.GetTensor(Trackable.Constants.OBJECT_GRAPH_PROTO_KEY);
+        Tensor object_graph_string = reader.GetTensor(Trackable.Constants.OBJECT_GRAPH_PROTO_KEY, dtype: TF_DataType.TF_STRING);
 
         Dictionary<Tensor, string> file_prefix_feed_dict;
         Tensor file_prefix_tensor;
@@ -249,7 +249,14 @@ public LoadStatus restore(string? save_path, CheckpointOptions? options = null)
             file_prefix_feed_dict = null;
         }
         TrackableObjectGraph object_graph_proto = new();
-        object_graph_proto.MergeFrom(object_graph_string.BufferToArray());
+        if(object_graph_string.ndim > 0)
+        {
+            object_graph_proto.MergeFrom(object_graph_string.BufferToArray());
+        }
+        else
+        {
+            object_graph_proto.MergeFrom(object_graph_string.StringBytes()[0]);
+        }
         CheckpointRestoreCoordinator checkpoint = new CheckpointRestoreCoordinator(
             object_graph_proto: object_graph_proto, 
             save_path: save_path, 

src/TensorFlowNET.Core/Functions/ConcreteFunction.cs

@@ -13,8 +13,8 @@ namespace Tensorflow.Functions
     /// </summary>
     public class ConcreteFunction: Trackable
     {
-        FuncGraph func_graph;
-        ForwardBackwardCall forward_backward;
+        internal FuncGraph func_graph;
+        internal ForwardBackwardCall forward_backward;
         public Tensor[] Inputs => func_graph.Inputs;
         public Tensor[] CapturedInputs => func_graph.external_captures;
 
@@ -23,6 +23,8 @@ public class ConcreteFunction: Trackable
         public Tensor[] Outputs;
         public Type ReturnType;
         public TensorSpec[] OutputStructure;
+        public IEnumerable<string> ArgKeywords { get; set; }
+        public long NumPositionArgs { get; set; }
 
         public ConcreteFunction(string name)
         {
@@ -163,6 +165,15 @@ public Tensors CallFlat(Tensor[] args, Tensor[] captured_inputs)
             return flat_outputs;
         }
 
+        public void AddTograph(Graph? g = null)
+        {
+            if(!tf.Context.executing_eagerly() && g is null)
+            {
+                g = ops.get_default_graph();
+            }
+            // TODO(Rinne); complete it with `_delayed_rewrite_functions`.
+        }
+
         ForwardBackwardCall SelectForwardAndBackwardFunctions(Tensors args, int possible_gradient_type, bool executing_eagerly)
         {
             var functions = new FirstOrderTapeGradientFunctions(func_graph, false);

src/TensorFlowNET.Core/Keras/Common/CustomizedDTypeJsonConverter.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tensorflow.Keras.Common
+{
+    public class CustomizedDTypeJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(TF_DataType);
+        }
+
+        public override bool CanRead => true;
+
+        public override bool CanWrite => true;
+
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            var token = JToken.FromObject(value);
+            token.WriteTo(writer);
+        }
+
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.ValueType == typeof(string))
+            {
+                var str = (string)serializer.Deserialize(reader, typeof(string));
+                return dtypes.tf_dtype_from_name(str);
+            }
+            else
+            {
+                return (TF_DataType)serializer.Deserialize(reader, typeof(TF_DataType));
+            }
+        }
+    }
+}

src/TensorFlowNET.Core/Keras/Common/CustomizedNodeConfigJsonConverter.cs

@@ -46,27 +46,54 @@ public override void WriteJson(JsonWriter writer, object? value, JsonSerializer
             {
                 throw new ValueError("Cannot deserialize 'null' to `Shape`.");
             }
-            if(values.Length != 3)
+            if(values.Length == 1)
+            {
+                var array = values[0] as JArray;
+                if(array is null)
+                {
+                    throw new ValueError($"The value ({string.Join(", ", values)}) cannot be deserialized to type `NodeConfig`.");
+                }
+                values = array.ToObject<object[]>();
+            }
+            if (values.Length < 3)
             {
                 throw new ValueError($"The value ({string.Join(", ", values)}) cannot be deserialized to type `NodeConfig`.");
             }
             if (values[0] is not string)
             {
                 throw new TypeError($"The first value of `NodeConfig` is expected to be `string`, but got `{values[0].GetType().Name}`");
             }
-            if (values[1] is not int)
+            int nodeIndex;
+            int tensorIndex;
+            if (values[1] is long)
+            {
+                nodeIndex = (int)(long)values[1];
+            }
+            else if (values[1] is int)
+            {
+                nodeIndex = (int)values[1];
+            }
+            else
             {
                 throw new TypeError($"The first value of `NodeConfig` is expected to be `int`, but got `{values[1].GetType().Name}`");
             }
-            if (values[2] is not int)
+            if (values[2] is long)
+            {
+                tensorIndex = (int)(long)values[2];
+            }
+            else if (values[1] is int)
+            {
+                tensorIndex = (int)values[2];
+            }
+            else
             {
                 throw new TypeError($"The first value of `NodeConfig` is expected to be `int`, but got `{values[2].GetType().Name}`");
             }
             return new NodeConfig()
             {
                 Name = values[0] as string,
-                NodeIndex = (int)values[1],
-                TensorIndex = (int)values[2]
+                NodeIndex = nodeIndex,
+                TensorIndex = tensorIndex
             };
         }
     }

src/TensorFlowNET.Core/Keras/Saving/ModelConfig.cs

@@ -1,8 +1,11 @@
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Tensorflow.Keras.ArgsDefinition;
 using Tensorflow.Keras.Engine;
+using static Google.Protobuf.Reflection.FieldDescriptorProto.Types;
 
 namespace Tensorflow.Keras.Saving
 {

src/TensorFlowNET.Core/Tensors/TF_DataType.cs

@@ -1,9 +1,13 @@
-namespace Tensorflow
+using Newtonsoft.Json;
+using Tensorflow.Keras.Common;
+
+namespace Tensorflow
 {
     /// <summary>
     /// TF_DataType holds the type for a scalar value.  E.g., one slot in a tensor.
     /// The enum values here are identical to corresponding values in types.proto.
     /// </summary>
+    [JsonConverter(typeof(CustomizedDTypeJsonConverter))]
     public enum TF_DataType
     {
         DtInvalid = 0,

src/TensorFlowNET.Core/Tensors/dtypes.cs

@@ -159,7 +159,10 @@ public static TF_DataType tf_dtype_from_name(string name)
                 "uint32" => TF_DataType.TF_UINT32,
                 "int64" => TF_DataType.TF_INT64,
                 "uint64" => TF_DataType.TF_UINT64,
+                "float16" => TF_DataType.TF_BFLOAT16,
+                "float32" => TF_DataType.TF_FLOAT,
                 "single" => TF_DataType.TF_FLOAT,
+                "float64" => TF_DataType.TF_DOUBLE,
                 "double" => TF_DataType.TF_DOUBLE,
                 "complex" => TF_DataType.TF_COMPLEX128,
                 "string" => TF_DataType.TF_STRING,

src/TensorFlowNET.Core/Training/Saving/SavedModel/WrapperFunction.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Tensorflow.Functions;
+
+namespace Tensorflow.Training.Saving.SavedModel
+{
+    /// <summary>
+    /// A class wraps a concrete function to handle different distributed contexts.
+    /// </summary>
+    internal class WrapperFunction: ConcreteFunction
+    {
+        public WrapperFunction(ConcreteFunction concrete_function): base(concrete_function.func_graph)
+        {
+            this.forward_backward = concrete_function.forward_backward;
+            this.Outputs = concrete_function.Outputs;
+            this.ReturnType = concrete_function.ReturnType;
+            this.OutputStructure = concrete_function.OutputStructure;
+            this.ArgKeywords = concrete_function.ArgKeywords;
+        }
+    }
+}

src/TensorFlowNET.Core/Training/Saving/SavedModel/function_deserialization.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Tensorflow.Functions;
+using Tensorflow.Util;
+
+namespace Tensorflow.Training.Saving.SavedModel
+{
+    public static class function_deserialization
+    {
+        public static ConcreteFunction setup_bare_concrete_function(SavedBareConcreteFunction saved_bare_concrete_function, 
+            IDictionary<string, ConcreteFunction> concrete_functions)
+        {
+            var concrete_function = concrete_functions[saved_bare_concrete_function.ConcreteFunctionName];
+            concrete_function.ArgKeywords = saved_bare_concrete_function.ArgumentKeywords.ToList();
+            concrete_function.NumPositionArgs = saved_bare_concrete_function.AllowedPositionalArguments;
+
+            var function_spec = _deserialize_function_spec_as_nonmethod(saved_bare_concrete_function.FunctionSpec);
+            concrete_function.AddTograph();
+            return concrete_function;
+        }
+
+        private static FunctionSpec _deserialize_function_spec_as_nonmethod(FunctionSpec function_spec_proto)
+        {
+            // TODO(Rinne)； revise the implementation.
+            return new FunctionSpec()
+            {
+                Fullargspec = function_spec_proto.Fullargspec,
+                IsMethod = function_spec_proto.IsMethod,
+                InputSignature = function_spec_proto.InputSignature,
+                JitCompile = function_spec_proto.JitCompile
+            };
+        }
+    }
+}