Getting Started with Tensorflow

MLeap Tensorflow integration provides support for including Tensorflowgraphs as a transform step in your ML pipelines. In the future we mayprovide more compatibility. For right now, Tensorflow integration shouldbe considered experimental as both Tensorflow and MLeap integration withTensorflow are still stabilizing.

Building MLeap-Tensorflow

MLeap Tensorflow modules are not included in maven central, and mustinstead be built from source along with the Tensorflow JNI support. Seeinstructions for buildingthe Tensorflow module.

Using MLeap-Tensorflow

Once you have everything built, it’s easy to incorporate Tensorflow intoyour MLeap pipelines.

First, include the module as a project dependency:

  1. libraryDependencies += "ml.combust.mleap" %% "mleap-tensorflow" % "0.13.0"

Then we can start using Tensorflow graphs, let’s build a simple one thatmultiplies two tensors:

  1. import ml.combust.mleap.core.types._
  2. import ml.combust.mleap.runtime.frame.{DefaultLeapFrame, Row}
  3. import ml.combust.mleap.tensor.Tensor
  4. import ml.combust.mleap.tensorflow.{TensorflowModel, TensorflowTransformer}
  5. import org.tensorflow
  7. // Initialize our Tensorflow demo graph
  8. val graph = new tensorflow.Graph
  10. // Build placeholders for our input values
  11. val inputA = graph.opBuilder("Placeholder", "InputA").
  12.   setAttr("dtype", tensorflow.DataType.FLOAT).
  13.   build()
  14. val inputB = graph.opBuilder("Placeholder", "InputB").
  15.   setAttr("dtype", tensorflow.DataType.FLOAT).
  16.   build()
  18. // Multiply the two placeholders and put the result in
  19. // The "MyResult" tensor
  20. graph.opBuilder("Mul", "MyResult").
  21.   setAttr("T", tensorflow.DataType.FLOAT).
  22.   addInput(inputA.output(0)).
  23.   addInput(inputB.output(0)).
  24.   build()
  26. // Build the MLeap model wrapper around the Tensorflow graph
  27. val model = TensorflowModel(graph,
  28.   // Must specify inputs and input types for converting to TF tensors
  29.   inputs = Seq(("InputA", TensorType.Float()), ("InputB", TensorType.Float())),
  30.   // Likewise, specify the output values so we can convert back to MLeap
  31.   // Types properly
  32.   outputs = Seq(("MyResult", TensorType.Float())))
  34. // Connect our Leap Frame values to the Tensorflow graph
  35. // Inputs and outputs
  36. val shape = NodeShape().
  37.   // Column "input_a" gets sent to the TF graph as the input "InputA"
  38.   withInput("InputA", "input_a").
  39.   // Column "input_b" gets sent to the TF graph as the input "InputB"
  40.   withInput("InputB", "input_b").
  41.   // TF graph output "MyResult" gets placed in the leap frame as col
  42.   // "my_result"
  43.   withOutput("MyResult", "my_result")
  45. // Create the MLeap transformer that executes the TF model against
  46. // A leap frame
  47. val transformer = TensorflowTransformer(shape = shape, model = model)
  49. // Create a sample leap frame to transform with the Tensorflow graph
  50. val schema = StructType(StructField("input_a", ScalarType.Float), StructField("input_b", ScalarType.Float)).get
  51. val dataset = Seq(Row(5.6f, 7.9f),
  52.   Row(3.4f, 6.7f),
  53.   Row(1.2f, 9.7f))
  54. val frame = DefaultLeapFrame(schema, dataset)
  56. // Transform the leap frame and make sure it behaves as expected
  57. val data = transformer.transform(frame).get.dataset
  58. assert(data(0)(2).asInstanceOf[Tensor[Float]].get(0).get == 5.6f * 7.9f)
  59. assert(data(1)(2).asInstanceOf[Tensor[Float]].get(0).get == 3.4f * 6.7f)
  60. assert(data(2)(2).asInstanceOf[Tensor[Float]].get(0).get == 1.2f * 9.7f)
  62. // Cleanup the transformer
  63. // This closes the TF session and graph resources
  64. transformer.close()

For more information on how Tensorflow integration works:

  1. Details on data conversion and integration here.
  2. How we serialize MLeap bundles with Tensorflow graphs here