TensorFlowMapper transform for scoring Tensorflow models in ML.NET

Microsoft.ML.sln

@@ -103,13 +103,14 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.ML.CpuMath.UnitTe
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.ML.CpuMath.UnitTests.netcoreapp", "test\Microsoft.ML.CpuMath.UnitTests.netcoreapp\Microsoft.ML.CpuMath.UnitTests.netcoreapp.csproj", "{5F81A2A4-73AD-494C-B387-07D605EC8826}"
 EndProject
-
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Microsoft.ML.FSharp.Tests", "test\Microsoft.ML.FSharp.Tests\Microsoft.ML.FSharp.Tests.fsproj", "{802233D6-8CC0-46AD-9F23-FEE1E9AED9B3}"
+Project("{6EC3EE1D-3C4E-46DD-8F32-0CC8E7565705}") = "Microsoft.ML.FSharp.Tests", "test\Microsoft.ML.FSharp.Tests\Microsoft.ML.FSharp.Tests.fsproj", "{802233D6-8CC0-46AD-9F23-FEE1E9AED9B3}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.ML.ImageAnalytics", "src\Microsoft.ML.ImageAnalytics\Microsoft.ML.ImageAnalytics.csproj", "{00E38F77-1E61-4CDF-8F97-1417D4E85053}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.ML.HalLearners", "src\Microsoft.ML.HalLearners\Microsoft.ML.HalLearners.csproj", "{A7222F41-1CF0-47D9-B80C-B4D77B027A61}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.ML.TensorFlow", "src\Microsoft.ML.TensorFlow\Microsoft.ML.TensorFlow.csproj", "{570A0B8A-5463-44D2-8521-54C0CA4CACA9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -390,6 +391,14 @@ Global
 		{A7222F41-1CF0-47D9-B80C-B4D77B027A61}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A7222F41-1CF0-47D9-B80C-B4D77B027A61}.Release-Intrinsics|Any CPU.ActiveCfg = Release|Any CPU
 		{A7222F41-1CF0-47D9-B80C-B4D77B027A61}.Release-Intrinsics|Any CPU.Build.0 = Release|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Debug-Intrinsics|Any CPU.ActiveCfg = Debug|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Debug-Intrinsics|Any CPU.Build.0 = Debug|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Release-Intrinsics|Any CPU.ActiveCfg = Release|Any CPU
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9}.Release-Intrinsics|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -426,14 +435,15 @@ Global
 		{001F3B4E-FBE4-4001-AFD2-A6A989CD1C25} = {09EADF06-BE25-4228-AB53-95AE3E15B530}
 		{DCF46B79-1FDB-4DBA-A263-D3D64E3AAA27} = {09EADF06-BE25-4228-AB53-95AE3E15B530}
 		{BF66A305-DF10-47E4-8D81-42049B149D2B} = {D3D38B03-B557-484D-8348-8BADEE4DF592}
+		{B4E55B2D-2A92-46E7-B72F-E76D6FD83440} = {7F13E156-3EBA-4021-84A5-CD56BA72F99E}
+		{3E4ABF07-7970-4BE6-B45B-A13D3C397545} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
 		{7333EDEF-4144-405C-A5EC-6F42201857D8} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
 		{A0E562A9-0E6D-470D-B180-6EB44BA84D60} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
 		{5F81A2A4-73AD-494C-B387-07D605EC8826} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
-		{B4E55B2D-2A92-46E7-B72F-E76D6FD83440} = {7F13E156-3EBA-4021-84A5-CD56BA72F99E}
-		{3E4ABF07-7970-4BE6-B45B-A13D3C397545} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
 		{802233D6-8CC0-46AD-9F23-FEE1E9AED9B3} = {AED9C836-31E3-4F3F-8ABC-929555D3F3C4}
 		{00E38F77-1E61-4CDF-8F97-1417D4E85053} = {09EADF06-BE25-4228-AB53-95AE3E15B530}
 		{A7222F41-1CF0-47D9-B80C-B4D77B027A61} = {09EADF06-BE25-4228-AB53-95AE3E15B530}
+		{570A0B8A-5463-44D2-8521-54C0CA4CACA9} = {09EADF06-BE25-4228-AB53-95AE3E15B530}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {41165AF1-35BB-4832-A189-73060F82B01D}

build.proj

@@ -31,6 +31,7 @@
     <TraversalBuildDependsOn>
       CreateOrUpdateCurrentVersionFile;
       RestoreProjects;
+      BuildRedist;
       BuildNative;
       $(TraversalBuildDependsOn);
       DownloadExternalTestFiles;
@@ -44,9 +45,17 @@
              Properties="MSBuildWarningsAsMessages=NU1503" />
   </Target>
 
+  <Target Name="BuildRedist"
+          Condition="'$(SkipRedistBuild)' != 'true'"
+          DependsOnTargets="RestoreProjects">
+    <Message Importance="High" Text="Building redist components..." />
+    <MSBuild Projects="src/Redist/build.proj"
+             Targets="Build" />
+  </Target>
+
   <Target Name="BuildNative"
           Condition="'$(SkipNativeBuild)' != 'true'"
-          DependsOnTargets="RestoreProjects">
+          DependsOnTargets="RestoreProjects;BuildRedist">
     <Message Importance="High" Text="Building native components..." />
     <MSBuild Projects="src/Native/build.proj"
              Targets="Build" />

build/Dependencies.props

@@ -11,5 +11,6 @@
     <MlNetMklDepsPackageVersion>0.0.0.5</MlNetMklDepsPackageVersion>
     <SystemDrawingCommonPackageVersion>4.5.0</SystemDrawingCommonPackageVersion>
     <BenchmarkDotNetVersion>0.11.0</BenchmarkDotNetVersion>
+    <TensorFlowVersion>1.10.0</TensorFlowVersion>
   </PropertyGroup>
 </Project>

build/sign.proj

@@ -30,7 +30,10 @@
 
     <!-- If we are not signing nuget packages we default to sign binaries -->
     <ItemGroup Condition="'$(SignNugetPackages)' != 'true'">
-      <FilesToSign Include="$(OutDir)**/*.dll">
+      <!-- Don't sign tensorflow since we don't build it. -->
+      <ExcludeFilesToSign Include="$(OutDir)**/tensorflow.dll" />
+
+      <FilesToSign Include="$(OutDir)**/*.dll" Exclude="@(ExcludeFilesToSign)">
         <Authenticode>Microsoft</Authenticode>
       </FilesToSign>
     </ItemGroup>

pkg/Microsoft.ML.TensorFlow.Redist/Microsoft.ML.TensorFlow.Redist.nupkgproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk" DefaultTargets="Pack">
+
+  <PropertyGroup>
+    <Authors>The TensorFlow Authors</Authors>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageDescription>$(MSBuildProjectName) contains the TensorFlow C library version $(TensorFlowVersion) redistributed as a NuGet package.</PackageDescription>
+    <PackageLicenseUrl>https://github.com/tensorflow/tensorflow/blob/master/LICENSE</PackageLicenseUrl>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <Copyright>Copyright 2018 The TensorFlow Authors.  All rights reserved.</Copyright>
+    <PackageProjectUrl>https://www.tensorflow.org</PackageProjectUrl>
+    <PackageReleaseNotes>https://github.com/tensorflow/tensorflow/releases/tag/v$(TensorFlowVersion)</PackageReleaseNotes>
+    <PackageTags>$(PackageTags) TensorFlow</PackageTags>
+    <!-- TODO: consider PackageIconUrl -->
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="..\common\CommonPackage.props" Pack="true" PackagePath="build\netstandard2.0\$(MSBuildProjectName).props" />
+    <Content Include="$(PackageAssetsPath)$(PackageIdFolderName)\LICENSE.txt" Pack="true" PackagePath=".\" />
+    <Content Include="$(PackageAssetsPath)$(PackageIdFolderName)\THIRD_PARTY_NOTICES.txt" Pack="true" PackagePath=".\" />
+  </ItemGroup>
+</Project>

pkg/Microsoft.ML.TensorFlow/Microsoft.ML.TensorFlow.nupkgproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk" DefaultTargets="Pack">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageDescription>Microsoft.ML.TensorFlow contains ML.NET integration of TensorFlow.</PackageDescription>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Microsoft.ML.TensorFlow.Redist\Microsoft.ML.TensorFlow.Redist.nupkgproj" />
+  </ItemGroup>
+
+</Project>

pkg/Microsoft.ML.TensorFlow/Microsoft.ML.TensorFlow.symbols.nupkgproj

@@ -0,0 +1,5 @@
+<Project DefaultTargets="Pack">
+
+  <Import Project="Microsoft.ML.TensorFlow.nupkgproj" />
+
+</Project>

src/Directory.Build.props

@@ -12,6 +12,15 @@
     <WarningsNotAsErrors>$(WarningsNotAsErrors);1591</WarningsNotAsErrors>
 
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)\Source.ruleset</CodeAnalysisRuleSet>
+
+    <TargetArchitecture Condition="'$(TargetArchitecture)' == ''">x64</TargetArchitecture>
+
+    <NativeAssetsBuiltPath>$(BaseOutputPath)$(TargetArchitecture).$(Configuration)\Native</NativeAssetsBuiltPath>
+
+    <PackageRid Condition="'$(OS)' == 'Windows_NT'">win</PackageRid>
+    <PackageRid Condition="'$(OS)' != 'Windows_NT'">linux</PackageRid>
+    <PackageRid Condition="$([MSBuild]::IsOSPlatform('osx'))">osx</PackageRid>
+    <PackageRid>$(PackageRid)-$(TargetArchitecture)</PackageRid>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <IncludeInPackage>Microsoft.ML.TensorFlow</IncludeInPackage>
+    <DefineConstants>CORECLR</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Microsoft.ML.Core\Microsoft.ML.Core.csproj" />
+    <ProjectReference Include="..\Microsoft.ML.Data\Microsoft.ML.Data.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="TensorFlow\TensorGeneric.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>TensorGeneric.tt</DependentUpon>
+    </Compile>
+    <None Update="TensorFlow\TensorGeneric.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>TensorGeneric.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+</Project>

src/Microsoft.ML.TensorFlow/TensorFlow/Buffer.cs

@@ -0,0 +1,211 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using size_t = System.UIntPtr;
+
+#pragma warning disable MSML_GeneralName
+#pragma warning disable MSML_ParameterLocalVarName
+
+namespace Microsoft.ML.Transforms.TensorFlow
+{
+    /// <summary>
+    /// This attribute can be applied to callback functions that will be invoked
+    /// from unmanaged code to managed code.
+    /// </summary>
+    /// <remarks>
+    /// <code>
+    /// [TensorFlow.MonoPInvokeCallback (typeof (BufferReleaseFunc))]
+    /// internal static void MyFreeFunc (IntPtr data, IntPtr length){..}
+    /// </code>
+    /// </remarks>
+    internal sealed class MonoPInvokeCallbackAttribute : Attribute
+    {
+        /// <summary>
+        /// Use this constructor to annotate the type of the callback function that
+        /// will be invoked from unmanaged code.
+        /// </summary>
+        /// <param name="t">T.</param>
+        public MonoPInvokeCallbackAttribute(Type t) { }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct LLBuffer
+    {
+        internal IntPtr data;
+        internal size_t length;
+        internal IntPtr data_deallocator;
+    }
+
+    /// <summary>
+    /// Holds a block of data, suitable to pass, or retrieve from TensorFlow.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Use the TFBuffer to blobs of data into TensorFlow, or to retrieve blocks
+    /// of data out of TensorFlow.
+    /// </para>
+    /// <para>
+    /// There are two constructors to wrap existing data, one to wrap blocks that are
+    /// pointed to by an IntPtr and one that takes a byte array that we want to wrap.
+    /// </para>
+    /// <para>
+    /// The empty constructor can be used to create a new TFBuffer that can be populated
+    /// by the TensorFlow library and returned to user code.
+    /// </para>
+    /// <para>
+    /// Typically, the data consists of a serialized protocol buffer, but other data
+    /// may also be held in a buffer.
+    /// </para>
+    /// </remarks>
+    // TODO: the string ctor
+    // TODO: perhaps we should have an implicit byte [] conversion that just calls ToArray?
+    internal class TFBuffer : TFDisposable
+    {
+        // extern TF_Buffer * TF_NewBufferFromString (const void *proto, size_t proto_len);
+        [DllImport(NativeBinding.TensorFlowLibrary)]
+        private static extern unsafe LLBuffer* TF_NewBufferFromString(IntPtr proto, IntPtr proto_len);
+
+        // extern TF_Buffer * TF_NewBuffer ();
+        [DllImport(NativeBinding.TensorFlowLibrary)]
+        private static extern unsafe LLBuffer* TF_NewBuffer();
+
+        internal TFBuffer(IntPtr handle) : base(handle) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:TensorFlow.TFBuffer"/> class.
+        /// </summary>
+        public unsafe TFBuffer() : base((IntPtr)TF_NewBuffer())
+        {
+        }
+
+        /// <summary>
+        /// Signature of the method that is invoked to release the data.
+        /// </summary>
+        /// <remarks>
+        /// Methods of this signature are invoked with the data pointer and the
+        /// lenght pointer when then TFBuffer no longer needs to hold on to the
+        /// data.  If you are using this on platforms with static compilation
+        /// like iOS, you need to annotate your callback with the MonoPInvokeCallbackAttribute,
+        /// like this:
+        ///
+        /// <code>
+        /// [TensorFlow.MonoPInvokeCallback (typeof (BufferReleaseFunc))]
+        /// internal static void MyFreeFunc (IntPtr data, IntPtr length){..}
+        /// </code>
+        /// </remarks>
+        public delegate void BufferReleaseFunc(IntPtr data, IntPtr lenght);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:TensorFlow.TFBuffer"/> by wrapping the unmanaged resource pointed by the buffer.
+        /// </summary>
+        /// <param name="buffer">Pointer to the data that will be wrapped.</param>
+        /// <param name="size">The size of the buffer to wrap.</param>
+        /// <param name="release">Optional, if not null, this method will be invoked to release the block.</param>
+        /// <remarks>
+        /// This constructor wraps the buffer as a the data to be held by the <see cref="T:TensorFlow.TFBuffer"/>,
+        /// if the release parameter is null, then you must ensure that the data is not released before the TFBuffer
+        /// is no longer in use.   If the value is not null, the provided method will be invoked to release
+        /// the data when the TFBuffer is disposed, or the contents of the buffer replaced.
+        /// </remarks>
+        public unsafe TFBuffer(IntPtr buffer, long size, BufferReleaseFunc release) : base((IntPtr)TF_NewBuffer())
+        {
+            LLBuffer* buf = (LLBuffer*)handle;
+            buf->data = buffer;
+            buf->length = (size_t)size;
+            if (release == null)
+                buf->data_deallocator = IntPtr.Zero;
+            else
+                buf->data_deallocator = Marshal.GetFunctionPointerForDelegate(release);
+        }
+
+        [MonoPInvokeCallback(typeof(BufferReleaseFunc))]
+        internal static void FreeBlock(IntPtr data, IntPtr length)
+        {
+            Marshal.FreeHGlobal(data);
+        }
+
+        internal static IntPtr FreeBufferFunc;
+        internal static BufferReleaseFunc FreeBlockDelegate;
+
+        static TFBuffer()
+        {
+            FreeBlockDelegate = FreeBlock;
+            FreeBufferFunc = Marshal.GetFunctionPointerForDelegate<BufferReleaseFunc>(FreeBlockDelegate);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:TensorFlow.TFBuffer"/> by making a copy of the provided byte array.
+        /// </summary>
+        /// <param name="buffer">Buffer of data that will be wrapped.</param>
+        /// <remarks>
+        /// This constructor makes a copy of the data into an unmanaged buffer,
+        /// so the byte array is not pinned.
+        /// </remarks>
+        public TFBuffer(byte[] buffer) : this(buffer, 0, buffer.Length) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:TensorFlow.TFBuffer"/> by making a copy of the provided byte array.
+        /// </summary>
+        /// <param name="buffer">Buffer of data that will be wrapped.</param>
+        /// <param name="start">Starting offset into the buffer to wrap.</param>
+        /// <param name="count">Number of bytes from the buffer to keep.</param>
+        /// <remarks>
+        /// This constructor makes a copy of the data into an unmanaged buffer,
+        /// so the byte array is not pinned.
+        /// </remarks>
+        public TFBuffer(byte[] buffer, int start, int count) : this()
+        {
+            if (start < 0 || start >= buffer.Length)
+                throw new ArgumentException("start");
+            if (count < 0 || count > buffer.Length - start)
+                throw new ArgumentException("count");
+            unsafe
+            {
+                LLBuffer* buf = LLBuffer;
+                buf->data = Marshal.AllocHGlobal(count);
+                Marshal.Copy(buffer, start, buf->data, count);
+                buf->length = (size_t)count;
+                buf->data_deallocator = FreeBufferFunc;
+            }
+        }
+
+        internal unsafe LLBuffer* LLBuffer => (LLBuffer*)handle;
+
+        // extern void TF_DeleteBuffer (TF_Buffer *);
+        [DllImport(NativeBinding.TensorFlowLibrary)]
+        private static extern unsafe void TF_DeleteBuffer(LLBuffer* buffer);
+
+        internal override void NativeDispose(IntPtr handle)
+        {
+            unsafe { TF_DeleteBuffer((LLBuffer*)handle); }
+        }
+
+        // extern TF_Buffer TF_GetBuffer (TF_Buffer *buffer);
+        [DllImport(NativeBinding.TensorFlowLibrary)]
+        private static extern unsafe LLBuffer TF_GetBuffer(LLBuffer* buffer);
+
+        /// <summary>
+        /// Returns a byte array representing the data wrapped by this buffer.
+        /// </summary>
+        /// <returns>The array.</returns>
+        public byte[] ToArray()
+        {
+            if (handle == IntPtr.Zero)
+                return null;
+
+            unsafe
+            {
+                var lb = (LLBuffer*)handle;
+
+                var result = new byte[(int)lb->length];
+                Marshal.Copy(lb->data, result, 0, (int)lb->length);
+
+                return result;
+            }
+        }
+    }
+}