Struct Graph 

pub struct Graph { /* private fields */ }

Implementations

impl Graph

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

Examples found in repository

examples/06_control_flow_call.rs (line 48)

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>,

Examples found in repository

examples/06_control_flow_call.rs (lines 61-65)

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>,

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>,

Examples found in repository

examples/06_control_flow_call.rs (lines 51-56)

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>,

Examples found in repository

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

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>,

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>,

Examples found in repository

examples/06_control_flow_call.rs (lines 80-82)

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 109-123)

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>

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>

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>

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>

Examples found in repository

examples/07_gather_random_rnn.rs (line 43)

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

impl Graph

pub fn new() -> Option<Self>

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 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 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 22)

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>

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 10)

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 24)

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>

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>

Examples found in repository

examples/06_control_flow_call.rs (line 44)

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>

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 69)

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>

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

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 27)

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>

Examples found in repository

examples/06_control_flow_call.rs (line 54)

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>

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

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

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>

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

Examples found in repository

examples/05_concat_split.rs (line 19)

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 23)

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 132-147)

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>>

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

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 30-34)

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>

Examples found in repository

examples/03_arithmetic_topk.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, 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 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 binary_arithmetic( &self, op: BinaryArithmeticOp, primary: &Tensor, secondary: &Tensor, name: Option<&str>, ) -> Option<Tensor>

Examples found in repository

examples/06_control_flow_call.rs (line 89)

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>

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

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

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

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

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

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

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

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

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 concat_pair( &self, first: &Tensor, second: &Tensor, dimension: isize, name: Option<&str>, ) -> Option<Tensor>

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>

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

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

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

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>

Examples found in repository

examples/05_concat_split.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, 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>

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

Examples found in repository

examples/03_arithmetic_topk.rs (line 18)

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)>

impl Graph

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

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

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

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

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

Examples found in repository

examples/07_gather_random_rnn.rs (line 51)

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>

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

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

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

Examples found in repository

examples/07_gather_random_rnn.rs (line 53)

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>

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>>

Examples found in repository

examples/07_gather_random_rnn.rs (lines 66-75)

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>>

Examples found in repository

examples/07_gather_random_rnn.rs (lines 89-100)

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>>

Examples found in repository

examples/07_gather_random_rnn.rs (lines 118-128)

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"));
}

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