Enable TensorFlowTransform to work with pre-trained models that are not frozen

src/Microsoft.ML.Core/Utilities/Stream.cs

@@ -30,6 +30,30 @@ public static void CloseEx(this TextWriter writer)
             writer.Close();
         }
 
+        /// <summary>
+        /// Similar to Stream.CopyTo but takes a length rather than assuming copy to end.  Returns amount copied.
+        /// </summary>
+        /// <param name="source">Source stream to copy from</param>
+        /// <param name="destination">Destination stream to copy to</param>
+        /// <param name="length">Number of bytes to copy</param>
+        /// <param name="bufferSize">Size of buffer to use when copying, default is 81920 to match that of Stream</param>
+        /// <returns>number of bytes copied</returns>
+        public static long CopyRange(this Stream source, Stream destination, long length, int bufferSize = 81920)
+        {
+            // should use ArrayPool once we can take that dependency
+            byte[] buffer = new byte[bufferSize];
+            int read;
+            long remaining = length;
+            while (remaining != 0 &&
+                   (read = source.Read(buffer, 0, (int)Math.Min(buffer.Length, remaining))) != 0)
+            {
+                destination.Write(buffer, 0, read);
+                remaining -= read;
+            }
+
+            return length - remaining;
+        }
+
         public static void WriteBoolByte(this BinaryWriter writer, bool x)
         {
             Contracts.AssertValue(writer);

src/Microsoft.ML.Legacy/CSharpApi.cs

@@ -15787,9 +15787,9 @@ public sealed partial class TensorFlowScorer : Microsoft.ML.Runtime.EntryPoints.
 
 
             /// <summary>
-            /// This is the frozen protobuf model file. Please see https://www.tensorflow.org/mobile/prepare_models for more details.
+            /// TensorFlow model used by the transform. Please see https://www.tensorflow.org/mobile/prepare_models for more details.
             /// </summary>
-            public string ModelFile { get; set; }
+            public string Model { get; set; }
 
             /// <summary>
             /// The names of the model inputs

src/Microsoft.ML.TensorFlow/Microsoft.ML.TensorFlow.csproj

@@ -7,6 +7,11 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="4.5.0" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="4.5.0" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Microsoft.ML.Core\Microsoft.ML.Core.csproj" />
     <ProjectReference Include="..\Microsoft.ML.Data\Microsoft.ML.Data.csproj" />

src/Microsoft.ML.TensorFlow/TensorFlow/Tensorflow.cs

@@ -1182,7 +1182,7 @@ public IEnumerable<DeviceAttributes> ListDevices(TFStatus status = null)
         /// here: https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/saved_model/README.md
         /// </para>
         /// </remarks>
-        public TFSession FromSavedModel(TFSessionOptions sessionOptions, TFBuffer runOptions, string exportDir, string[] tags, TFGraph graph, TFBuffer metaGraphDef, TFStatus status = null)
+        public static TFSession FromSavedModel(TFSessionOptions sessionOptions, TFBuffer runOptions, string exportDir, string[] tags, TFGraph graph, TFBuffer metaGraphDef, TFStatus status = null)
         {
             if (graph == null)
                 throw new ArgumentNullException(nameof(graph));

src/Microsoft.ML.TensorFlow/TensorFlow/TensorflowUtils.cs

@@ -11,6 +11,8 @@
 using Microsoft.ML.Runtime.Data;
 using Microsoft.ML.Runtime.ImageAnalytics.EntryPoints;
 using Microsoft.ML.Runtime.Internal.Utilities;
+using System.Security.Principal;
+using System.Security.AccessControl;
 
 namespace Microsoft.ML.Transforms.TensorFlow
 {
@@ -158,6 +160,101 @@ internal static TFSession LoadTFSession(IExceptionContext ectx, byte[] modelByte
             return new TFSession(graph);
         }
 
+        private static TFSession LoadTFSession(IHostEnvironment env, string exportDirSavedModel)
+        {
+            env.CheckValue(exportDirSavedModel, nameof(exportDirSavedModel));
+            var sessionOptions = new TFSessionOptions();
+            var exportDir = exportDirSavedModel;
+            var tags = new string[] { "serve" };
+            var graph = new TFGraph();
+            var metaGraphDef = new TFBuffer();
+
+            return TFSession.FromSavedModel(sessionOptions, null, exportDir, tags, graph, metaGraphDef);
+        }
+        // A TensorFlow frozen model is a single file. An un-frozen (SavedModel) on the other hand has a well-defined folder structure.
+        // Given a modelPath, this utility method determines if we should treat it as a SavedModel or not
+        internal static bool IsSavedModel(string modelPath)
+        {
+            FileAttributes attr = File.GetAttributes(modelPath);
+            return attr.HasFlag(FileAttributes.Directory);
+        }
+
+        internal static void CreateTempDirectory(string tempDirPath)
+        {
+            //if directory exists, do nothing.
+            if (Directory.Exists(tempDirPath))
+                return;
+
+            WindowsIdentity currentIdentity = null;
+            try
+            {
+                currentIdentity = WindowsIdentity.GetCurrent();
+            }
+            catch (PlatformNotSupportedException)
+            { }
+
+            if (currentIdentity != null && new WindowsPrincipal(currentIdentity).IsInRole(WindowsBuiltInRole.Administrator))
+            {
+                // Create high integrity dir and set no delete policy for all files under the directory.
+                // In case of failure, throw exception.
+                CreateTempDirectoryWithAcl(tempDirPath, currentIdentity.User.ToString());
+            }
+            else
+                Directory.CreateDirectory(tempDirPath);
+        }
+
+        private static void CreateTempDirectoryWithAcl(string dirPath, string identity)
+        {
+            // Dacl Sddl string:
+            // D: Dacl type
+            // D; Deny access
+            // OI; Object inherit ace
+            // SD; Standard delete function
+            // wIdentity.User Sid of the given user.
+            // A; Allow access
+            // OICI; Object inherit, container inherit
+            // FA File access
+            // BA Built-in administrators
+            // S: Sacl type
+            // ML;; Mandatory Label
+            // NW;;; No write policy
+            // HI High integrity processes only
+            string sddl = "D:(D;OI;SD;;;" + identity + ")(A;OICI;FA;;;BA)S:(ML;OI;NW;;;HI)";
+
+            var dir = Directory.CreateDirectory(dirPath);
+            DirectorySecurity dirSec = new DirectorySecurity();
+            dirSec.SetSecurityDescriptorSddlForm(sddl);
+            dirSec.SetAccessRuleProtection(true, false);  // disable inheritance
+            dir.SetAccessControl(dirSec);
+
+            // Cleaning out the directory, in case someone managed to sneak in between creation and setting ACL.
+            DirectoryInfo dirInfo = new DirectoryInfo(dirPath);
+            foreach (FileInfo file in dirInfo.GetFiles())
+            {
+                file.Delete();
+            }
+            foreach (DirectoryInfo subDirInfo in dirInfo.GetDirectories())
+            {
+                subDirInfo.Delete(true);
+            }
+        }
+
+        internal static TFSession GetSession(IHostEnvironment env, string modelPath)
+        {
+            if (IsSavedModel(modelPath))
+                return LoadTFSession(env, modelPath);
+
+            return CheckFileAndRead(env, modelPath);
+        }
+
+        private static TFSession CheckFileAndRead(IHostEnvironment env, string modelFile)
+        {
+            env.CheckNonWhiteSpace(modelFile, nameof(modelFile));
+            env.CheckUserArg(File.Exists(modelFile), nameof(modelFile));
+            var bytes = File.ReadAllBytes(modelFile);
+            return LoadTFSession(env, bytes, modelFile);
+        }
+
         internal static unsafe void FetchData<T>(IntPtr data, T[] result)
         {
             var size = result.Length;