Accelerate machine learning with Metal Performance Shaders Graph

// Execute the graph
let results = graph.run(feeds: [inputTensor: inputs],
                        targetTensors: [exp],
                        targetOperations: [assign])

// Create control dependency

let exp = graph.controlDependency(with: [assign],
                                  dependentBlock: { 
                                      return [graph.exponent(with: input, 
                                                             name: nil)]
                                  },
                                  name: nil)

// Execute the graph

let results = graph.run(feeds: [inputTensor: inputs],
                        targetTensors: [exp],
                        targetOperations: nil)

// Create the graph

let placeholder0 = graph.placeholder(shape: [1, 3], 
                                     dataType: .float32, 
                                     name: nil)

let placeholder1 = graph.placeholder(shape: [2, 1], 
                                     dataType: .float32, 
                                     name: nil)

let addTensor = graph.addition(placeholder0, 
                               placeholder1, 
                               name: nil)

// Compile the graph into an executable

let executable = graph.compile(with: nil,
                               feeds: [placeholder0: MPSGraphShapedType(shape: [1, 3], 
                                                                        dataType: .float32),
                                       placeholder1: MPSGraphShapedType(shape: [2, 1], 
                                                                        dataType: .float32)],
                               targetTensors: [addTensor],
                               targetOperations: nil,
                               compilationDescriptor: nil)

// Execute the graph into an executable

let fetch = executable.run(with: commandQueue,
                           inputs: [MPSGraphTensorData(input0),        
                                    MPSGraphTensorData(input1)],
                           results: nil,
                           executionDescriptor: nil)

// Create the graph compilation descriptor

let descriptor = MPSGraphCompilationDescriptor()

// Disable type inference

descriptor.disableTypeInference()

// Compile the graph into an executable

let executable = graph.compile(with: nil,
                               feeds: /* feeds */,
                               targetTensors: /* target tensors */,
                               targetOperations: nil,
                               compilationDescriptor: descriptor)

// execute the graph

// Different behavior during inference and training

let results = graph.if(isTraining,
                       then: { ... },    // compute mean and variance
                       else: { ... },    // use running_mean and running_variance
                       name: nil)

let predicate = graph.lessThan(a, 
                               b, 
                               name: nil)

let results = graph.if(predicate,
    then: {[
        graph.addition(a, 
                       b, 
                       name: nil)
    ]},
    else: {[
        graph.subtraction(a, 
                          b, 
                          name: nil)
    ]},
    name: nil)

var result = input0

for i in 0..<4 {
    result *= input1
}

// Initialize inputs

let input0 = graph.placeholder(shape: [], 
                               dataType: .int32, 
                               name: nil)

let input1 = graph.placeholder(shape: [], 
                               dataType: .int32, 
                               name: nil)
        
let numberOfIterations = graph.constant(4, 
                                        shape: [], 
                                        dataType: .int32)

// Define Body

let body = {
    (index: MPSGraphTensor, iterationArguments: [MPSGraphTensor]) -> [MPSGraphTensor] in
        let iterationResult = graph.multiplication(iterationArguments[0], input1, name: nil)
        return [iterationResult]
}

// Create for loop operation

let result = graph.for(numberOfIterations: numberOfIterations,
                       initialIterationArguments: [input0],
                       body: body)

var result = initialValue

while result < threshold {
    result *= multiplier
}

// Evaluate condition

let condition = {
    (inputs: [MPSGraphTensor], returnTensors: NSMutableArray) -> MPSGraphTensor in
        let predicate = graph.lessThan(inputs[0], threshold, name: nil)
        returnTensors.add(inputs[0])
        return predicate
}

// Define body

let body = {
    (inputs: [MPSGraphTensor]) -> [MPSGraphTensor] in
        let iterationResult = graph.multiplication(inputs[0], multiplier, name: nil)
        return [iterationResult]
}

// Create while loop operation

let results = graph.while(initialInputs: [initialValue],
                          before: condition,
                          after: body,
                          name: nil)

// Apply the laplacian edge filter on the source image

let edges = graph.stencil(with: source, 
                          weights: laplacianWeights, 
                          descriptor: desc, 
                          name: nil)