Adding basic test for Functions.

Author: RockfordWei

Sources/PerfectTensorFlow/APILoader.swift

@@ -785,33 +785,26 @@ public class TFLib {
   /// in this address space.
   public static var GetAllOpList: @convention(c) () -> UnsafeMutablePointer<TF_Buffer>? = { return nil }
 
-  // Adds a copy of function `func` and optionally its gradient function `grad`
-  // to `g`. Once `func`/`grad` is added to `g`, it can be called by creating
+  /// Adds a copy of function `func` and optionally its gradient function `grad`
+  /// to `g`. Once `func`/`grad` is added to `g`, it can be called by creating
   // an operation using the function's name.
-  // Any changes to `func`/`grad` (including deleting it) done after this method
-  // returns, won't affect the copy of `func`/`grad` in `g`.
-  // If `func` or `grad` are already in `g`, TF_GraphCopyFunction has no
-  // effect on them, but can establish the function->gradient relationship
-  // between them if `func` does not already have a gradient. If `func` already
-  // has a gradient different from `grad`, an error is returned.
-  //
-  // `func` must not be null.
-  // If `grad` is null and `func` is not in `g`, `func` is added without a
-  // gradient.
-  // If `grad` is null and `func` is in `g`, TF_GraphCopyFunction is a noop.
-  // `grad` must have appropriate signature as described in the doc of
-  // GradientDef in tensorflow/core/framework/function.proto.
-  //
-  // If successful, status is set to OK and `func` and `grad` are added to `g`.
-  // Otherwise, status is set to the encountered error and `g` is unmodified.
-  /*
-  TF_CAPI_EXPORT extern void TF_GraphCopyFunction(TF_Graph* g,
-  const TF_Function* func,
-  const TF_Function* grad,
-  TF_Status* status);
-   */
-
-  public static var GraphCopyFunction: @convention(c) (OpaquePointer?, OpaquePointer?, OpaquePointer?, OpaquePointer?) -> Void = { _, _, _, _ in }
+  /// Any changes to `func`/`grad` (including deleting it) done after this method
+  /// returns, won't affect the copy of `func`/`grad` in `g`.
+  /// If `func` or `grad` are already in `g`, TF_GraphCopyFunction has no
+  /// effect on them, but can establish the function->gradient relationship
+  /// between them if `func` does not already have a gradient. If `func` already
+  /// has a gradient different from `grad`, an error is returned.
+  ///
+  /// `func` must not be null.
+  /// If `grad` is null and `func` is not in `g`, `func` is added without a
+  /// gradient.
+  /// If `grad` is null and `func` is in `g`, TF_GraphCopyFunction is a noop.
+  /// `grad` must have appropriate signature as described in the doc of
+  /// GradientDef in tensorflow/core/framework/function.proto.
+  ///
+  /// If successful, status is set to OK and `func` and `grad` are added to `g`.
+  /// Otherwise, status is set to the encountered error and `g` is unmodified.
+  public static var GraphCopyFunction: @convention(c) (OpaquePointer, OpaquePointer, OpaquePointer?, OpaquePointer) -> Void = { _, _, _, _ in }
 
   /// Create a TF_Function from a TF_Graph
   ///

Sources/PerfectTensorFlow/PerfectTensorFlow.swift

@@ -1904,10 +1904,14 @@ public class TensorFlow {
     ///   - outputNames: [String], The names of the function's outputs. Must either have the same length as `outputs` or be null. In the former case, the names should match the regular expression for ArgDef names - "[a-z][a-z0-9_]*". In the latter case, names for outputs will be generated automatically.
     ///   - options: various options for the function, e.g. XLA's inlining control.
     ///   - description: optional human-readable description of this function
-    public func toFunction(_ name: String, appendHashToFunctionName: Bool = false, operations: [Operation], inputs: [Output], outputs: [Output], outputNames: [String], options: OpaquePointer? = nil, description: String = "") throws -> Function {
-      guard outputs.count == outputNames.count else {
-        throw Panic.FAULT(reason: "Output array elements are mismatched with names")
-      }
+    public func toFunction(
+      _ name: String, appendHashToFunctionName: Bool = false,
+      operations: [Operation] = [],
+      inputs: [Output] = [],
+      outputs: [Output] = [],
+      outputNames: [String] = [],
+      options: OpaquePointer? = nil,
+      description: String = "") throws -> Function {
       let status = try Status()
       let opera:UnsafePointer<OpaquePointer?>? = operations.map { $0.operation }
         .withUnsafeBufferPointer { $0.baseAddress }
@@ -1929,7 +1933,8 @@ public class TensorFlow {
           Int32(outputs.count > 0 ? outputs.count: 0),
           outputs.count > 0 ? pOutpus : nil,
 
-          outputs.count > 0 && outputNames.count == outputs.count ? pOutputNames : nil,
+          outputNames.count > 0
+            && outputNames.count == outputs.count ? pOutputNames : nil,
 
           options, description.isEmpty ? nil: description,
 
@@ -1941,6 +1946,32 @@ public class TensorFlow {
       return Function(fun)
     }
 
+    /// Adds a copy of function `func` and optionally its gradient function `grad`
+    /// to `g`. Once `func`/`grad` is added to `g`, it can be called by creating
+    /// an operation using the function's name.
+    /// Any changes to `func`/`grad` (including deleting it) done after this method
+    /// returns, won't affect the copy of `func`/`grad` in `g`.
+    /// If `func` or `grad` are already in `g`, TF_GraphCopyFunction has no
+    /// effect on them, but can establish the function->gradient relationship
+    /// between them if `func` does not already have a gradient. If `func` already
+    /// has a gradient different from `grad`, an error is returned.
+    /// If `grad` is null and `func` is not in `g`, `func` is added without a
+    /// gradient.
+    /// If `grad` is null and `func` is in `g`, TF_GraphCopyFunction is a noop.
+    /// `grad` must have appropriate signature as described in the doc of
+    /// GradientDef in tensorflow/core/framework/function.proto.
+    /// - parameters:
+    ///   - function: function to add
+    ///   - grad: the gradient function to add with.
+    /// - throws: Panic.FAULT
+    public func copy(function: Function, grad: Function? = nil) throws {
+      let status = try Status()
+      TFLib.GraphCopyFunction(self.graph, function.ref, grad?.ref, status.status)
+      guard status.code == .OK else {
+        throw Panic.FAULT(reason: status.message)
+      }
+    }
+    
     /// Function is a grouping of operations with defined inputs and outputs.
     /// Once created and added to graphs, functions can be invoked by creating an
     /// operation whose operation type matches the function name.
@@ -2023,17 +2054,17 @@ public class TensorFlow {
           return nil
         }
       }
-    }
 
-    /// get definition
-    public var def: FunctionDef? {
-      if let buf = self.buffer, let proto = buf.data {
-        return try? FunctionDef(serializedData: proto)
-      } else {
-        return nil
+      /// get definition
+      public var definition: FunctionDef? {
+        if let buf = self.buffer, let proto = buf.data {
+          return try? FunctionDef(serializedData: proto)
+        } else {
+          return nil
+        }
       }
-    }
 
+    }
   }//end graph
 
   /// class wrapper of Graph Definition Options

Tests/PerfectTensorFlowTests/PerfectTensorFlowTests.swift

@@ -114,6 +114,17 @@ public extension Data {
   }
 }
 
+extension Array where Element == TF.Output {
+  func useHelper(graph: TF.Graph, _ operationType: String, _ name: String)
+    throws -> TF.Operation {
+      var desc = try TF.OperationBuilder(graph: graph, name: name, type: operationType)
+      self.forEach { inp in
+        desc = desc.add(input: inp)
+      }
+      return try desc.set(device: "/cpu:0").build()
+  }
+}
+
 class PerfectTensorFlowTests: XCTestCase {
 
   static var allTests = [
@@ -148,9 +159,46 @@ class PerfectTensorFlowTests: XCTestCase {
     ("testMatrix", testMatrix),
     ("testBasicImproved",testBasicImproved),
     ("testDevices", testDevices),
-    ("testEventAndSummary", testEventAndSummary)
+    ("testEventAndSummary", testEventAndSummary),
+    ("testFunctionBasic", testFunctionBasic)
   ]
 
+  func testFunctionBasic() {
+    do {
+      let funcName = "MyFunc"
+      let nodeName = "MyFunc_0"
+      let funcGraph = try TF.Graph()
+      let hostGraph = try TF.Graph()
+      let c = try funcGraph.scalar(10, name: "scalar10")
+      let function = try funcGraph.toFunction(funcName, outputs: [c.asOutput(0)])
+      try hostGraph.copy(function: function)
+      let nullInput: [TF.Output] = []
+      let funOp = try nullInput.useHelper(graph: hostGraph, funcName, nodeName)
+      let s = try hostGraph.runner().fetch(funOp).run()
+      XCTAssertEqual(s.count, 1)
+      let res:[Int32] = try s[0].asArray()
+      XCTAssertEqual(res[0], 10)
+      guard let def = function.definition else {
+        XCTFail("function definition failure")
+        return
+      }
+      let node = def.nodeDef[0]
+      XCTAssertEqual(node.name, "scalar10_0")
+      guard let value = node.attr["value"] else {
+        XCTFail("function invalid value")
+        return
+      }
+      XCTAssertEqual( value.tensor.intVal, [10])
+      guard let ret = def.ret["scalar10"] else {
+        XCTFail("function return fault")
+        return
+      }
+      XCTAssertEqual(ret, "scalar10_0:output:0")
+    }catch {
+      XCTFail("functions: \(error)")
+    }
+  }
+
   func testDevices() {
     do {
       let g = try TF.Graph()