Struct Graph 

pub struct Graph { /* private fields */ }

Mirrors the MPSGraph framework counterpart for this type.

Implementations

impl Graph

pub fn call( &self, symbol_name: &str, input_tensors: &[&Tensor], output_types: &[&ShapedType], name: Option<&str>, ) -> Result<Vec<Tensor>>

Calls the MPSGraph framework counterpart for call.

Examples found in repository

examples/06_control_flow_call.rs (line 55)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

impl Graph

pub fn control_dependency<F>( &self, operations: &[&Operation], dependent_block: F, name: Option<&str>, ) -> Option<Vec<Tensor>>

where F: FnMut() -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for control_dependency.

Examples found in repository

examples/06_control_flow_call.rs (lines 68-76)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn if_then<Then>( &self, predicate: &Tensor, then_block: Then, name: Option<&str>, ) -> Option<Vec<Tensor>>

where Then: FnMut() -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for if_then.

pub fn if_then_else<Then, Else>( &self, predicate: &Tensor, then_block: Then, else_block: Else, name: Option<&str>, ) -> Option<Vec<Tensor>>

where Then: FnMut() -> Vec<Tensor>, Else: FnMut() -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for if_then_else.

Examples found in repository

examples/06_control_flow_call.rs (lines 58-63)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn while_loop<Before, After>( &self, initial_inputs: &[&Tensor], before: Before, after: After, name: Option<&str>, ) -> Option<Vec<Tensor>>

where Before: FnMut(&[Tensor]) -> WhileBeforeResult, After: FnMut(&[Tensor]) -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for while_loop.

Examples found in repository

examples/06_control_flow_call.rs (lines 101-117)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn for_loop<Body>( &self, lower_bound: &Tensor, upper_bound: &Tensor, step: &Tensor, initial_body_arguments: &[&Tensor], body: Body, name: Option<&str>, ) -> Option<Vec<Tensor>>

where Body: FnMut(&Tensor, &[Tensor]) -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for for_loop.

pub fn for_loop_iterations<Body>( &self, number_of_iterations: &Tensor, initial_body_arguments: &[&Tensor], body: Body, name: Option<&str>, ) -> Option<Vec<Tensor>>

where Body: FnMut(&Tensor, &[Tensor]) -> Vec<Tensor>,

Calls the MPSGraph framework counterpart for for_loop_iterations.

Examples found in repository

examples/06_control_flow_call.rs (lines 93-98)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

impl Graph

pub fn options(&self) -> u64

Return the graph’s MPSGraphOptions bitmask.

pub fn set_options(&self, options: u64) -> Result<()>

Replace the graph’s options bitmask.

pub fn placeholder_tensors(&self) -> Vec<Tensor>

Return the graph’s placeholder tensors in insertion order.

pub fn compile_with_descriptor( &self, device: Option<&MetalDevice>, feeds: &[FeedDescription<'_>], targets: &[&Tensor], descriptor: Option<&CompilationDescriptor>, ) -> Option<Executable>

Compile the graph with an optional compilation descriptor.

Examples found in repository

examples/04_descriptor_compile.rs (lines 26-31)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

examples/06_control_flow_call.rs (lines 125-139)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

impl Graph

pub fn gather_nd( &self, updates_tensor: &Tensor, indices_tensor: &Tensor, batch_dimensions: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for gather_nd.

Examples found in repository

examples/07_gather_random_rnn.rs (line 37)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn gather( &self, updates_tensor: &Tensor, indices_tensor: &Tensor, axis: usize, batch_dimensions: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for gather.

Examples found in repository

examples/07_gather_random_rnn.rs (line 34)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn gather_along_axis( &self, axis: isize, updates_tensor: &Tensor, indices_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for gather_along_axis.

Examples found in repository

examples/07_gather_random_rnn.rs (line 40)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn gather_along_axis_tensor( &self, axis_tensor: &Tensor, updates_tensor: &Tensor, indices_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for gather_along_axis_tensor.

Examples found in repository

examples/07_gather_random_rnn.rs (lines 43-48)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

impl Graph

pub const fn as_ptr(&self) -> *mut c_void

Mirrors the MPSGraph framework constant fn.

impl Graph

pub fn new() -> Option<Self>

Calls the MPSGraph framework counterpart for new.

Examples found in repository

examples/05_concat_split.rs (line 6)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

examples/03_arithmetic_topk.rs (line 6)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

examples/01_add_relu.rs (line 6)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

examples/04_descriptor_compile.rs (line 9)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

examples/02_compile_matmul.rs (line 9)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let left = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("left"))
        .expect("failed to create left placeholder");
    let right = graph
        .placeholder(Some(&[3, 2]), data_type::FLOAT32, Some("right"))
        .expect("failed to create right placeholder");
    let output = graph
        .matrix_multiplication(&left, &right, Some("matmul"))
        .expect("failed to create matrix multiplication op");

    let executable = graph
        .compile(
            &device,
            &[
                FeedDescription::new(&left, &[2, 3], data_type::FLOAT32),
                FeedDescription::new(&right, &[3, 2], data_type::FLOAT32),
            ],
            &[&output],
        )
        .expect("failed to compile executable");

    let left_data = TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3])
        .expect("failed to create left tensor data");
    let right_data =
        TensorData::from_f32_slice(&device, &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0], &[3, 2])
            .expect("failed to create right tensor data");

    let results = executable
        .run(&queue, &[&left_data, &right_data])
        .expect("failed to run executable");
    let values = results[0].read_f32().expect("failed to read tensor output");
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in values.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {values:?}"
        );
    }

    println!("compile+matmul smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (line 23)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

Additional examples can be found in:

• examples/07_gather_random_rnn.rs

pub fn placeholder( &self, shape: Option<&[usize]>, data_type: u32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for placeholder.

Examples found in repository

examples/05_concat_split.rs (line 8)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

examples/03_arithmetic_topk.rs (line 8)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

examples/01_add_relu.rs (line 9)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

examples/04_descriptor_compile.rs (line 11)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

examples/02_compile_matmul.rs (line 12)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let left = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("left"))
        .expect("failed to create left placeholder");
    let right = graph
        .placeholder(Some(&[3, 2]), data_type::FLOAT32, Some("right"))
        .expect("failed to create right placeholder");
    let output = graph
        .matrix_multiplication(&left, &right, Some("matmul"))
        .expect("failed to create matrix multiplication op");

    let executable = graph
        .compile(
            &device,
            &[
                FeedDescription::new(&left, &[2, 3], data_type::FLOAT32),
                FeedDescription::new(&right, &[3, 2], data_type::FLOAT32),
            ],
            &[&output],
        )
        .expect("failed to compile executable");

    let left_data = TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3])
        .expect("failed to create left tensor data");
    let right_data =
        TensorData::from_f32_slice(&device, &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0], &[3, 2])
            .expect("failed to create right tensor data");

    let results = executable
        .run(&queue, &[&left_data, &right_data])
        .expect("failed to run executable");
    let values = results[0].read_f32().expect("failed to read tensor output");
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in values.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {values:?}"
        );
    }

    println!("compile+matmul smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (line 25)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn constant_bytes( &self, data: &[u8], shape: &[usize], data_type: u32, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for constant_bytes.

Examples found in repository

examples/07_gather_random_rnn.rs (line 21)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn constant_f32_slice( &self, values: &[f32], shape: &[usize], ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for constant_f32_slice.

Examples found in repository

examples/06_control_flow_call.rs (line 50)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

examples/07_gather_random_rnn.rs (line 18)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn constant_scalar(&self, scalar: f64, data_type: u32) -> Option<Tensor>

Calls the MPSGraph framework counterpart for constant_scalar.

Examples found in repository

examples/01_add_relu.rs (line 12)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (line 80)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

examples/07_gather_random_rnn.rs (line 30)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn constant_scalar_shaped( &self, scalar: f64, shape: &[usize], data_type: u32, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for constant_scalar_shaped.

pub fn addition( &self, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

Examples found in repository

examples/01_add_relu.rs (line 15)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (line 28)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn subtraction( &self, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

Examples found in repository

examples/06_control_flow_call.rs (line 61)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn multiplication( &self, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn division( &self, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn matrix_multiplication( &self, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

Examples found in repository

examples/02_compile_matmul.rs (line 18)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let left = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("left"))
        .expect("failed to create left placeholder");
    let right = graph
        .placeholder(Some(&[3, 2]), data_type::FLOAT32, Some("right"))
        .expect("failed to create right placeholder");
    let output = graph
        .matrix_multiplication(&left, &right, Some("matmul"))
        .expect("failed to create matrix multiplication op");

    let executable = graph
        .compile(
            &device,
            &[
                FeedDescription::new(&left, &[2, 3], data_type::FLOAT32),
                FeedDescription::new(&right, &[3, 2], data_type::FLOAT32),
            ],
            &[&output],
        )
        .expect("failed to compile executable");

    let left_data = TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3])
        .expect("failed to create left tensor data");
    let right_data =
        TensorData::from_f32_slice(&device, &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0], &[3, 2])
            .expect("failed to create right tensor data");

    let results = executable
        .run(&queue, &[&left_data, &right_data])
        .expect("failed to run executable");
    let values = results[0].read_f32().expect("failed to read tensor output");
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in values.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {values:?}"
        );
    }

    println!("compile+matmul smoke passed: {values:?}");
}

pub fn relu(&self, tensor: &Tensor, name: Option<&str>) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

Examples found in repository

examples/01_add_relu.rs (line 18)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

pub fn sigmoid(&self, tensor: &Tensor, name: Option<&str>) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn reduction_sum( &self, tensor: &Tensor, axes: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn reduction_maximum( &self, tensor: &Tensor, axes: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn reduction_minimum( &self, tensor: &Tensor, axes: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn mean( &self, tensor: &Tensor, axes: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for this method.

pub fn softmax( &self, tensor: &Tensor, axis: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for softmax.

pub fn reshape( &self, tensor: &Tensor, shape: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for reshape.

pub fn transpose( &self, tensor: &Tensor, permutation: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for transpose.

pub fn slice( &self, tensor: &Tensor, dimension: usize, start: isize, length: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for slice.

pub fn broadcast( &self, tensor: &Tensor, shape: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for broadcast.

pub fn convolution2d( &self, source: &Tensor, weights: &Tensor, descriptor: &Convolution2DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for convolution2d.

pub fn max_pooling2d( &self, source: &Tensor, descriptor: &Pooling2DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for max_pooling2d.

pub fn normalize( &self, tensor: &Tensor, mean: &Tensor, variance: &Tensor, gamma: Option<&Tensor>, beta: Option<&Tensor>, epsilon: f32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for normalize.

pub fn run( &self, feeds: &[Feed<'_>], targets: &[&Tensor], ) -> Result<Vec<TensorData>>

Calls the MPSGraph framework counterpart for run.

Examples found in repository

examples/05_concat_split.rs (line 21)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

examples/03_arithmetic_topk.rs (line 21)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

examples/01_add_relu.rs (line 24)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("failed to create placeholder");
    let bias = graph
        .constant_scalar(1.0, data_type::FLOAT32)
        .expect("failed to create scalar constant");
    let added = graph
        .addition(&input, &bias, Some("add"))
        .expect("failed to create addition op");
    let output = graph
        .relu(&added, Some("relu"))
        .expect("failed to create relu op");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, -2.0, 3.0, -4.0], &[2, 2])
        .expect("failed to create tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&output])
        .expect("failed to execute graph");
    let values = results[0].read_f32().expect("failed to read tensor output");

    assert_eq!(values, vec![2.0, 0.0, 4.0, 0.0]);
    println!("add+relu smoke passed: {values:?}");
}

examples/07_gather_random_rnn.rs (lines 139-154)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn run_with_command_queue( &self, command_queue: &CommandQueue, feeds: &[Feed<'_>], targets: &[&Tensor], ) -> Result<Vec<TensorData>>

Calls the MPSGraph framework counterpart for run_with_command_queue.

pub fn compile( &self, device: &MetalDevice, feeds: &[FeedDescription<'_>], targets: &[&Tensor], ) -> Option<Executable>

Calls the MPSGraph framework counterpart for compile.

Examples found in repository

examples/02_compile_matmul.rs (lines 22-29)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let left = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("left"))
        .expect("failed to create left placeholder");
    let right = graph
        .placeholder(Some(&[3, 2]), data_type::FLOAT32, Some("right"))
        .expect("failed to create right placeholder");
    let output = graph
        .matrix_multiplication(&left, &right, Some("matmul"))
        .expect("failed to create matrix multiplication op");

    let executable = graph
        .compile(
            &device,
            &[
                FeedDescription::new(&left, &[2, 3], data_type::FLOAT32),
                FeedDescription::new(&right, &[3, 2], data_type::FLOAT32),
            ],
            &[&output],
        )
        .expect("failed to compile executable");

    let left_data = TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3])
        .expect("failed to create left tensor data");
    let right_data =
        TensorData::from_f32_slice(&device, &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0], &[3, 2])
            .expect("failed to create right tensor data");

    let results = executable
        .run(&queue, &[&left_data, &right_data])
        .expect("failed to run executable");
    let values = results[0].read_f32().expect("failed to read tensor output");
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in values.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {values:?}"
        );
    }

    println!("compile+matmul smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (lines 31-39)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

impl Graph

pub fn unary_arithmetic( &self, op: UnaryArithmeticOp, tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for unary_arithmetic.

Examples found in repository

examples/03_arithmetic_topk.rs (line 11)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

examples/04_descriptor_compile.rs (line 14)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

examples/06_control_flow_call.rs (line 72)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn binary_arithmetic( &self, op: BinaryArithmeticOp, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for binary_arithmetic.

Examples found in repository

examples/06_control_flow_call.rs (line 105)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(
                &callee_input,
                &[2],
                data_type::FLOAT32,
            )],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph
        .constant_f32_slice(&[1.0, 1.0], &[2])
        .expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(
            &[&call_operation],
            || {
                vec![graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                    .expect("identity")]
            },
            Some("dependency"),
        )
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(
            &number_of_iterations,
            &[&zero],
            |_index, args| vec![graph.addition(&args[0], &one, None).expect("for-loop add")],
            Some("for_loop"),
        )
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data =
        TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL).expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!(
        "call output: {:?}",
        results[0].read_f32().expect("call output")
    );
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!(
        "dependency output: {:?}",
        results[2].read_f32().expect("dependency output")
    );
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

pub fn select( &self, predicate: &Tensor, true_tensor: &Tensor, false_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for select.

pub fn relu_gradient( &self, gradient: &Tensor, source: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for relu_gradient.

pub fn sigmoid_gradient( &self, gradient: &Tensor, source: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for sigmoid_gradient.

pub fn softmax_gradient( &self, gradient: &Tensor, source: &Tensor, axis: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for softmax_gradient.

pub fn leaky_relu( &self, tensor: &Tensor, alpha: f64, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for leaky_relu.

pub fn leaky_relu_tensor( &self, tensor: &Tensor, alpha_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for leaky_relu_tensor.

pub fn leaky_relu_gradient( &self, gradient: &Tensor, source: &Tensor, alpha_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for leaky_relu_gradient.

pub fn reduce_axis( &self, op: ReductionAxisOp, tensor: &Tensor, axis: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for reduce_axis.

pub fn reduce_axes( &self, op: ReductionAxesOp, tensor: &Tensor, axes: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for reduce_axes.

Examples found in repository

examples/03_arithmetic_topk.rs (line 14)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

pub fn concat_pair( &self, first: &Tensor, second: &Tensor, dimension: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for concat_pair.

Examples found in repository

examples/05_concat_split.rs (line 11)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

pub fn concat_tensors( &self, tensors: &[&Tensor], dimension: isize, interleave: bool, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for concat_tensors.

pub fn split_sizes( &self, tensor: &Tensor, split_sizes: &[usize], axis: isize, name: Option<&str>, ) -> Vec<Tensor>

Calls the MPSGraph framework counterpart for split_sizes.

pub fn split_sizes_tensor( &self, tensor: &Tensor, split_sizes_tensor: &Tensor, axis: isize, name: Option<&str>, ) -> Vec<Tensor>

Calls the MPSGraph framework counterpart for split_sizes_tensor.

pub fn split_num( &self, tensor: &Tensor, num_splits: usize, axis: isize, name: Option<&str>, ) -> Vec<Tensor>

Calls the MPSGraph framework counterpart for split_num.

Examples found in repository

examples/05_concat_split.rs (line 13)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

pub fn stack( &self, tensors: &[&Tensor], axis: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for stack.

Examples found in repository

examples/05_concat_split.rs (line 15)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 2]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let concat = graph
        .concat_pair(&input, &input, 1, Some("concat"))
        .expect("concat");
    let split = graph.split_num(&concat, 2, 1, Some("split"));
    let stacked = graph
        .stack(&[&split[0], &split[1]], 0, Some("stack"))
        .expect("stack");

    let input_data =
        TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0], &[2, 2]).expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&stacked])
        .expect("run");

    println!(
        "stacked tensor bytes: {}",
        results[0].byte_len().expect("byte len")
    );
}

pub fn pad( &self, tensor: &Tensor, padding_mode: isize, left_padding: &[isize], right_padding: &[isize], constant_value: f64, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for pad.

pub fn top_k( &self, source: &Tensor, k: usize, name: Option<&str>, ) -> Option<(Tensor, Tensor)>

Calls the MPSGraph framework counterpart for top_k.

Examples found in repository

examples/03_arithmetic_topk.rs (line 16)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let squared = graph
        .unary_arithmetic(UnaryArithmeticOp::Square, &input, Some("square"))
        .expect("square");
    let row_sum = graph
        .reduce_axes(ReductionAxesOp::Sum, &squared, &[1], Some("row_sum"))
        .expect("reduce");
    let topk = graph.top_k(&input, 2, Some("topk")).expect("topk");

    let input_data = TensorData::from_f32_slice(&device, &[1.0, 3.0, 2.0, 4.0, 6.0, 5.0], &[2, 3])
        .expect("tensor data");
    let results = graph
        .run(&[Feed::new(&input, &input_data)], &[&row_sum, &topk.0])
        .expect("run");

    println!("row sums: {:?}", results[0].read_f32().expect("row sums"));
    println!(
        "top-k values: {:?}",
        results[1].read_f32().expect("topk values")
    );
}

pub fn top_k_tensor( &self, source: &Tensor, k_tensor: &Tensor, name: Option<&str>, ) -> Option<(Tensor, Tensor)>

Calls the MPSGraph framework counterpart for top_k_tensor.

impl Graph

pub fn random_philox_state_seed( &self, seed: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_philox_state_seed.

pub fn random_philox_state_counter( &self, counter_low: usize, counter_high: usize, key: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_philox_state_counter.

pub fn random_tensor( &self, shape: &[usize], descriptor: &RandomOpDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_tensor.

pub fn random_tensor_shape_tensor( &self, shape_tensor: &Tensor, descriptor: &RandomOpDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_tensor_shape_tensor.

pub fn random_tensor_seed( &self, shape: &[usize], descriptor: &RandomOpDescriptor, seed: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_tensor_seed.

Examples found in repository

examples/07_gather_random_rnn.rs (line 56)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn random_tensor_shape_tensor_seed( &self, shape_tensor: &Tensor, descriptor: &RandomOpDescriptor, seed: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for random_tensor_shape_tensor_seed.

pub fn random_tensor_state( &self, shape: &[usize], descriptor: &RandomOpDescriptor, state: &Tensor, name: Option<&str>, ) -> Option<(Tensor, Tensor)>

Calls the MPSGraph framework counterpart for random_tensor_state.

pub fn random_tensor_shape_tensor_state( &self, shape_tensor: &Tensor, descriptor: &RandomOpDescriptor, state: &Tensor, name: Option<&str>, ) -> Option<(Tensor, Tensor)>

Calls the MPSGraph framework counterpart for random_tensor_shape_tensor_state.

pub fn dropout( &self, tensor: &Tensor, rate: f64, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for dropout.

Examples found in repository

examples/07_gather_random_rnn.rs (line 59)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn dropout_tensor( &self, tensor: &Tensor, rate_tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for dropout_tensor.

impl Graph

pub fn single_gate_rnn( &self, source: &Tensor, recurrent_weight: &Tensor, input_weight: Option<&Tensor>, bias: Option<&Tensor>, init_state: Option<&Tensor>, mask: Option<&Tensor>, descriptor: &SingleGateRNNDescriptor, name: Option<&str>, ) -> Option<Vec<Tensor>>

Calls the MPSGraph framework counterpart for single_gate_rnn.

Examples found in repository

examples/07_gather_random_rnn.rs (lines 73-82)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn lstm( &self, source: &Tensor, recurrent_weight: &Tensor, input_weight: Option<&Tensor>, bias: Option<&Tensor>, init_state: Option<&Tensor>, init_cell: Option<&Tensor>, mask: Option<&Tensor>, peephole: Option<&Tensor>, descriptor: &LSTMDescriptor, name: Option<&str>, ) -> Option<Vec<Tensor>>

Calls the MPSGraph framework counterpart for lstm.

Examples found in repository

examples/07_gather_random_rnn.rs (lines 96-107)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

pub fn gru( &self, source: &Tensor, recurrent_weight: &Tensor, input_weight: Option<&Tensor>, bias: Option<&Tensor>, init_state: Option<&Tensor>, mask: Option<&Tensor>, secondary_bias: Option<&Tensor>, descriptor: &GRUDescriptor, name: Option<&str>, ) -> Option<Vec<Tensor>>

Calls the MPSGraph framework counterpart for gru.

Examples found in repository

examples/07_gather_random_rnn.rs (lines 125-135)

fn main() {
    let graph = Graph::new().expect("graph");
    let updates = graph
        .constant_f32_slice(&[10.0, 20.0, 30.0, 40.0, 50.0, 60.0], &[2, 3])
        .expect("updates");
    let gather_indices = graph
        .constant_bytes(&i32_bytes(&[2, 0]), &[2], data_type::INT32)
        .expect("gather indices");
    let gather_nd_indices = graph
        .constant_bytes(&i32_bytes(&[0, 1, 1, 0]), &[2, 2], data_type::INT32)
        .expect("gather nd indices");
    let along_indices = graph
        .constant_bytes(&i32_bytes(&[2, 1, 0, 0, 1, 2]), &[2, 3], data_type::INT32)
        .expect("gather along indices");
    let axis_tensor = graph
        .constant_scalar(1.0, data_type::INT32)
        .expect("axis tensor");

    let gather = graph
        .gather(&updates, &gather_indices, 1, 0, Some("gather"))
        .expect("gather");
    let gather_nd = graph
        .gather_nd(&updates, &gather_nd_indices, 0, Some("gather_nd"))
        .expect("gather nd");
    let gather_axis = graph
        .gather_along_axis(1, &updates, &along_indices, Some("gather_axis"))
        .expect("gather along axis");
    let gather_axis_tensor = graph
        .gather_along_axis_tensor(
            &axis_tensor,
            &updates,
            &along_indices,
            Some("gather_axis_tensor"),
        )
        .expect("gather along axis tensor");

    let descriptor = RandomOpDescriptor::new(random_distribution::UNIFORM, data_type::FLOAT32)
        .expect("random descriptor");
    descriptor.set_min(0.0).expect("random min");
    descriptor.set_max(1.0).expect("random max");
    let random = graph
        .random_tensor_seed(&[4], &descriptor, 7, Some("random"))
        .expect("random tensor");
    let dropout = graph
        .dropout(&updates, 1.0, Some("dropout"))
        .expect("dropout");

    let single_gate_descriptor = SingleGateRNNDescriptor::new().expect("single gate descriptor");
    single_gate_descriptor
        .set_activation(rnn_activation::RELU)
        .expect("single gate activation");
    let single_gate_source = graph
        .constant_f32_slice(&[0.5], &[1, 1, 1])
        .expect("single gate source");
    let single_gate_recurrent = graph
        .constant_f32_slice(&[0.0], &[1, 1])
        .expect("single gate recurrent");
    let single_gate = graph
        .single_gate_rnn(
            &single_gate_source,
            &single_gate_recurrent,
            None,
            None,
            None,
            None,
            &single_gate_descriptor,
            Some("single_gate"),
        )
        .expect("single gate rnn");

    let lstm_descriptor = LSTMDescriptor::new().expect("lstm descriptor");
    lstm_descriptor
        .set_produce_cell(true)
        .expect("set produce cell");
    let lstm_source = graph
        .constant_f32_slice(&[0.0; 4], &[1, 1, 4])
        .expect("lstm source");
    let lstm_recurrent = graph
        .constant_f32_slice(&[0.0; 4], &[4, 1])
        .expect("lstm recurrent");
    let lstm = graph
        .lstm(
            &lstm_source,
            &lstm_recurrent,
            None,
            None,
            None,
            None,
            None,
            None,
            &lstm_descriptor,
            Some("lstm"),
        )
        .expect("lstm");

    let gru_descriptor = GRUDescriptor::new().expect("gru descriptor");
    gru_descriptor.set_training(true).expect("set gru training");
    gru_descriptor
        .set_reset_after(true)
        .expect("set gru reset_after");
    let gru_source = graph
        .constant_f32_slice(&[0.0; 3], &[1, 1, 3])
        .expect("gru source");
    let gru_recurrent = graph
        .constant_f32_slice(&[0.0; 3], &[3, 1])
        .expect("gru recurrent");
    let gru_secondary_bias = graph
        .constant_f32_slice(&[0.0], &[1])
        .expect("gru secondary bias");
    let gru = graph
        .gru(
            &gru_source,
            &gru_recurrent,
            None,
            None,
            None,
            None,
            Some(&gru_secondary_bias),
            &gru_descriptor,
            Some("gru"),
        )
        .expect("gru");

    let results = graph
        .run(
            &[],
            &[
                &gather,
                &gather_nd,
                &gather_axis,
                &gather_axis_tensor,
                &random,
                &dropout,
                &single_gate[0],
                &lstm[0],
                &lstm[1],
                &gru[0],
                &gru[1],
            ],
        )
        .expect("run graph");

    println!("gather: {:?}", results[0].read_f32().expect("gather"));
    println!("gather_nd: {:?}", results[1].read_f32().expect("gather_nd"));
    println!(
        "gather_axis: {:?}",
        results[2].read_f32().expect("gather_axis")
    );
    println!(
        "gather_axis_tensor: {:?}",
        results[3].read_f32().expect("gather_axis_tensor")
    );
    println!("random: {:?}", results[4].read_f32().expect("random"));
    println!("dropout: {:?}", results[5].read_f32().expect("dropout"));
    println!(
        "single_gate: {:?}",
        results[6].read_f32().expect("single_gate")
    );
    println!(
        "lstm state: {:?}",
        results[7].read_f32().expect("lstm state")
    );
    println!("lstm cell: {:?}", results[8].read_f32().expect("lstm cell"));
    println!("gru state: {:?}", results[9].read_f32().expect("gru state"));
    println!(
        "gru training: {:?}",
        results[10].read_f32().expect("gru training")
    );
}

impl Graph

pub fn convolution3d( &self, source: &Tensor, weights: &Tensor, descriptor: &Convolution3DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for convolution3d.

pub fn convolution_transpose2d( &self, source: &Tensor, weights: &Tensor, output_shape: &[usize], descriptor: &Convolution2DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for convolution_transpose2d.

pub fn cumulative_sum( &self, tensor: &Tensor, axis: isize, exclusive: bool, reverse: bool, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for cumulative_sum.

pub fn depthwise_convolution2d( &self, source: &Tensor, weights: &Tensor, descriptor: &DepthwiseConvolution2DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for depthwise_convolution2d.

pub fn depthwise_convolution3d( &self, source: &Tensor, weights: &Tensor, descriptor: &DepthwiseConvolution3DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for depthwise_convolution3d.

pub fn fast_fourier_transform( &self, tensor: &Tensor, axes: &[usize], descriptor: &FftDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for fast_fourier_transform.

pub fn im_to_col( &self, source: &Tensor, descriptor: &ImToColDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for im_to_col.

pub fn band_part( &self, tensor: &Tensor, num_lower: isize, num_upper: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for band_part.

pub fn softmax_cross_entropy( &self, source: &Tensor, labels: &Tensor, axis: isize, reduction_type: u64, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for softmax_cross_entropy.

pub fn matrix_inverse( &self, tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for matrix_inverse.

pub fn variable_bytes( &self, data: &[u8], shape: &[usize], data_type: u32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for variable_bytes.

pub fn variable_f32_slice( &self, values: &[f32], shape: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for variable_f32_slice.

pub fn read_variable( &self, variable: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for read_variable.

pub fn assign_variable( &self, variable: &Tensor, value: &Tensor, name: Option<&str>, ) -> Option<Operation>

Calls the MPSGraph framework counterpart for assign_variable.

pub fn non_maximum_suppression( &self, boxes: &Tensor, scores: &Tensor, iou_threshold: f32, score_threshold: f32, per_class_suppression: bool, coordinate_mode: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for non_maximum_suppression.

pub fn non_zero_indices( &self, tensor: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for non_zero_indices.

pub fn one_hot( &self, indices: &Tensor, depth: usize, data_type: u32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for one_hot.

pub fn stochastic_gradient_descent( &self, learning_rate: &Tensor, values: &Tensor, gradient: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for stochastic_gradient_descent.

pub fn max_pooling4d( &self, source: &Tensor, descriptor: &Pooling4DDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for max_pooling4d.

pub fn max_pooling4d_return_indices( &self, source: &Tensor, descriptor: &Pooling4DDescriptor, name: Option<&str>, ) -> Option<(Tensor, Tensor)>

Calls the MPSGraph framework counterpart for max_pooling4d_return_indices.

pub fn quantize( &self, tensor: &Tensor, scale: f64, zero_point: f64, data_type: u32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for quantize.

pub fn dequantize( &self, tensor: &Tensor, scale: f64, zero_point: f64, data_type: u32, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for dequantize.

pub fn resize( &self, images: &Tensor, size: &[usize], mode: usize, center_result: bool, align_corners: bool, layout: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for resize.

pub fn resize_nearest( &self, images: &Tensor, size_tensor: &Tensor, nearest_rounding_mode: usize, center_result: bool, align_corners: bool, layout: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for resize_nearest.

pub fn sample_grid( &self, source: &Tensor, coordinates: &Tensor, layout: usize, normalize_coordinates: bool, relative_coordinates: bool, align_corners: bool, padding_mode: isize, sampling_mode: usize, constant_value: f64, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for sample_grid.

pub fn scatter_nd( &self, updates: &Tensor, indices: &Tensor, shape: &[usize], batch_dimensions: usize, mode: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for scatter_nd.

pub fn scatter( &self, updates: &Tensor, indices: &Tensor, shape: &[usize], axis: isize, mode: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for scatter.

pub fn scatter_along_axis( &self, axis: isize, updates: &Tensor, indices: &Tensor, shape: &[usize], mode: isize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for scatter_along_axis.

pub fn sort( &self, tensor: &Tensor, axis: isize, descending: bool, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for sort.

pub fn arg_sort( &self, tensor: &Tensor, axis: isize, descending: bool, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for arg_sort.

pub fn sparse_tensor_with_descriptor( &self, descriptor: &CreateSparseDescriptor, tensors: &[&Tensor], shape: &[usize], name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for sparse_tensor_with_descriptor.

pub fn stencil( &self, source: &Tensor, weights: &Tensor, descriptor: &StencilDescriptor, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for stencil.

pub fn top_k_gradient( &self, gradient: &Tensor, source: &Tensor, k: usize, name: Option<&str>, ) -> Option<Tensor>

Calls the MPSGraph framework counterpart for top_k_gradient.

Trait Implementations

impl Drop for Graph

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for Graph

impl Sync for Graph