Struct Graph 

pub struct Graph { /* private fields */ }

Implementations

impl Graph

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

impl Graph

pub fn new() -> Option<Self>

Examples found in repository

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

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

Examples found in repository

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

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

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

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

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

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

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

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

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